算法——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) {

    }
}