动态规划-背包问题

这是一个九章lintcode上的动态规划算法题，该题的解题思路基于九章侯老师的讲解给出。
题目出处：https://www.lintcode.com/problem/92/description?showListFe=true&page=1&tagIds=400&pageSize=50

相关题目：

动态规划-背包问题
动态规划-背包问题（二）
动态规划-背包问题（三）
动态规划-Backpack VI
动态规划-背包问题 V

1 描述

在 n 个物品中挑选若干物品装入背包，最多能装多满？假设背包的大小为m，每个物品的大小为Ai

（每个物品只能选择一次且物品大小均为正整数）

Lintcode超级VIP年卡 618预售 享买一年送一年

微信加【jiuzhang1104】备注【VIP】即可参加

你不可以将物品进行切割

n<1000

m<1e5

2 样例

2.1 样例 1：

输入：

数组 = [3,4,8,5]
backpack size = 10
输出：

9
解释：

装4和5.

2.2 样例 2：

输入：

数组 = [2,3,5,7]
backpack size = 12
输出：

12
解释：

装5和7.

3 算法解题方法和实现

3.1 解题思路

3.1.1 确定状态

设f[i][j]表示的是前i个物品是否可以拼出j的重量来

3.1.2 转移方程

3.1.3 初始条件和边界情况

初始条件：
f[0][0] = true 表示前0个物品可以拼出0的重量来
f[0][1]，…，f[0][m] = false 表示前0个物品无法拼出其他的重量来

边界条件：
计算的前提条件为：j > a[i - 1]

3.1.4 计算顺序

f[0][0] … f[0][m]
…
f[n][0] … f[n][m]

结果为：前n个物品能拼出的重量f[n][0] … f[n][m]

3.2 算法实现

3.2.1 java实现

public class Solution {
    /**
     * @param m: An integer m denotes the size of a backpack
     * @param a: Given n items with size A[i]
     * @return: The maximum size
     */
    public int backPack(int m, int[] a) {
        // write your code here
        int n = a.length;
        if (n == 0) {
            return 0;
        }

        boolean[][] f = new boolean[n + 1][m + 1];
        f[0][0] = true;
        for (int i = 1; i <= m; i++) {
            f[0][i] = false;
        }

        for (int i = 1; i <= n; i++) {
            for (int j = 0; j <= m; j++) {
                f[i][j] = f[i - 1][j];
                if (j >= a[i - 1]) {
                    f[i][j] |= f[i - 1][j - a[i - 1]];
                }
            }
        }

        int res = 0;
        for (int i = m; i >= 0; i--) {
            if (f[n][i] == true) {
                res = i;
                break;
            }
        }

        return res;
    }
}

3.2.2 c++(时间超时)

c++在实现的时候会提示运行时间超时，但是在算法实现上和java是一样的，目前还没有想明白为什么会出现这种情况

class Solution {
public:
    /**
     * @param m: An integer m denotes the size of a backpack
     * @param a: Given n items with size A[i]
     * @return: The maximum size
     */
    int backPack(int m, vector<int> &a) {
        // write your code here
        int n = a.size();
        if (n == 0) {
            return 0;
        }

        vector<vector<bool>> f(n + 1, vector<bool>(m + 1, false));
        f[0][0] = true;

        for (int i = 1; i <= n; i++) {
            for (int j = 0; j <= m; j++) {
                f[i][j] = f[i - 1][j];
                if (j >= a[i - 1]) {
                    f[i][j] = f[i][j] || f[i - 1][j - a[i - 1]];
                }
            }
        }

        for (int i = m; i >= 0; i--) {
            if (f[n][i]) {
                return i;
            }
        }
    }
};

3.2.3 空间优化后的实现

该算法是在lintcode上一位算法好友分享的实现方法，简洁清晰。后面的计算充分利用二维空间前面的结果，进而覆盖掉之前的计算结果而获得最终的计算结果。

public class Solution {
    /**
     * @param m: An integer m denotes the size of a backpack
     * @param a: Given n items with size A[i]
     * @return: The maximum size
     */
    public int backPack(int m, int[] A) {
        // write your code here
        int n = A.length;
        if (n == 0) {
            return 0;
        }

        int f[] = new int[m + 1];

        for (int i = 0; i < A.length; i++) {
            for (int j = m; j >= A[i]; j--) {
                f[j] = Math.max(f[j], f[j - A[i]] + A[i]);
            } 
        }
        return f[m];
    }
}