動態規劃——0-1揹包問題

題目描述

有一個容量爲 N 的揹包，要用這個揹包裝下物品的價值最大，這些物品有兩個屬性：體積 w 和價值 v。

解題思路

記憶化搜索

/// 揹包問題
/// 記憶化搜索
/// 時間複雜度: O(n * C) 其中n爲物品個數; C爲揹包容積
/// 空間複雜度: O(n * C)
public class Solution {

    private int[][] memo;

    public int knapsack01(int[] w, int[] v, int C) {

        int n = v.length;
        memo = new int[n][C + 1];
        Arrays.fill(memo, -1);
        return bestValue(w, v, n - 1, C);

    }

    //用 [0..index] 的物品，填充容積爲 c 的揹包的最大價值
    private int bestValue(int[] w, int[] v, int index, int c) {

        if (index < 0 || c <= 0) {
            return 0;
        }

        if (memo[index][c] != -1) {
            return memo[index][c];
        }
        
        // 不考慮index 直接考慮，index - 1的價值
        int res = bestValue(w, v, index - 1, c);
        if (c >= w[index]) {
            res = Math.max(res, v[index] + bestValue(w, v, index - 1, c));
        }

        memo[index][c] = res;
        
        return res;
    }
}
複製代碼

動態規劃

/// 揹包問題
/// 記憶化搜索
/// 時間複雜度: O(n * C) 其中n爲物品個數; C爲揹包容積
/// 空間複雜度: O(n * C)
public class Solution {

    public static int knapsack01(int[] w, int[] v, int C) {
        if (w == null || v == null || w.length != v.length) {
            throw new IllegalArgumentException("Invalid w or v");

        }
        int n = w.length;
        if (n == 0 || C == 0) {
            return 0;
        }
        int[][] memo = new int[n][C + 1];

        //先肯定最基本的狀況
        for (int j = 0; j <= C; j++) {
            memo[0][j] = (j >= w[0] ? v[0] : 0);
        }
        for (int i = 0; i < n; i++) {
            memo[i][0] = 0;
        }

        for (int i = 1; i < n; i++) {
            for (int j = 0; j <= C; j++) {
                //1.物品i不放入揹包中，因此c[i][j]爲c[i-1][j]的值
                memo[i][j] = memo[i - 1][j];
                //2.物品i放入揹包中，則揹包剩餘重量爲j-w[i],因此c[i][j]爲c[i-1][j-w[i]]的值加上當前物品i的價值
                if (j >= w[i]) {
                    memo[i][j] = Math.max(memo[i][j], v[i] + memo[i - 1][j - w[i]]);
                }
            }
        }

        return memo[n - 1][C];
    }

    public static void main(String[] args) {
        int m = 10;
        int w[] = {3, 4, 5};
        int p[] = {4, 5, 6};
        int c = knapsack01(w, p, m);
        System.out.println(c);
    }
}
複製代碼

動態規劃-優化空間

import java.util.Arrays;

/// 揹包問題
/// 記憶化搜索
/// 時間複雜度: O(n * C) 其中n爲物品個數; C爲揹包容積
/// 空間複雜度: O(n * C)
public class Solution {

    public static int knapsack01(int[] w, int[] v, int C) {
        if (w == null || v == null || w.length != v.length) {
            throw new IllegalArgumentException("Invalid w or v");

        }
        int n = w.length;
        if (n == 0 || C == 0) {
            return 0;
        }
        //每次計算新的 memo 時只需用到上一個 memo，所以只需 2 行就好了
        int[][] memo = new int[2][C + 1];

        //先肯定最基本的狀況
        for (int j = 0; j <= C; j++) {
            memo[0][j] = (j >= w[0] ? v[0] : 0);
        }

        for (int i = 0; i < n; i++) {
            memo[i % 2][0] = 0;
        }

        for (int i = 1; i < n; i++) {
            for (int j = 0; j <= C; j++) {
                //1.物品i不放入揹包中，因此c[i][j]爲c[i-1][j]的值
                memo[i % 2][j] = memo[(i - 1) % 2][j];
                //2.物品i放入揹包中，則揹包剩餘重量爲j-w[i],因此c[i][j]爲c[i-1][j-w[i]]的值加上當前物品i的價值
                if (j >= w[i]) {
                    memo[i % 2][j] = Math.max(memo[i % 2][j], v[i] + memo[(i - 1) % 2][j - w[i]]);
                }
            }
        }

        return memo[(n - 1) % 2][C];
    }

    public static void main(String[] args) {
        int m = 10;
        int w[] = {3, 4, 5};
        int p[] = {4, 5, 6};
        int c = knapsack01(w, p, m);
        System.out.println(c);
    }
}
複製代碼

動態規劃-優化空間（一維數組）

/// 揹包問題
/// 動態規劃改進: 滾動數組
/// 時間複雜度: O(n * C) 其中n爲物品個數; C爲揹包容積
/// 空間複雜度: O(C), 實際使用了2*C的額外空間
public class Solution1 {

    public int knapsack01(int[] w, int[] v, int C) {

        if (w == null || v == null || w.length != v.length)
            throw new IllegalArgumentException("Invalid w or v");

        if (C < 0)
            throw new IllegalArgumentException("C must be greater or equal to zero.");

        int n = w.length;
        if (n == 0 || C == 0) {
            return 0;
        }


        int[][] memo = new int[2][C + 1];

        for (int j = 0; j <= C; j++) {
            memo[0][j] = (j >= w[0] ? v[0] : 0);
        }


        for (int i = 1; i < n; i++) {
            for (int j = 0; j <= C; j++) {
                memo[i % 2][j] = memo[(i - 1) % 2][j];
                if (j >= w[i])
                    memo[i % 2][j] = Math.max(memo[i % 2][j], v[i] + memo[(i - 1) % 2][j - w[i]]);
            }
        }


        return memo[(n - 1) % 2][C];
    }

    public static void main(String[] args) {

    }
}
複製代碼