【Lintcode】440. Backpack III

题目地址：

https://www.lintcode.com/problem/backpack-iii/description

给定一个数组$A$，表示每个物品的体积，再给定一个数组$V$，表示每个物品的价值。有一个容积为$m$的背包，问可以加入背包的最大价值是多少。每个物品可以取无限次。

思路是动态规划。首先，为了选法表达的唯一性，我们将每种选法按照物品在数组$A$中的下标排序。例如，如果$A=[2,3,5,7]$，那么第$0$个物品选$2$个，第$1$和$2$个物品各选一个，这种选法就可以用序列$(0,0,1,2)$表示，并且我们只接受这种写法，不接受类似于$(0,1,0,2)$这种写法，因为我们要保证所选的物品按照其在$A$中的下标是排序好的。设$f[i][j]$表示$A[0:i]$中选物品，并且体积不超过$j$的时候，所能达到的最大价值。首先，$$f[0][j]=j/A[0]\ast V[0]$$考虑一般情况下的递推式。$f[i][j]$的所有方案可以按照其序列的最后一个数是几来分类。如果最后一个数恰好是$i$，也就是方案里选了$A[i]$，那么此时最大价值是$f[i][j-A[i]]+V[i]$；如果最后一个数不是$i$，也就是方案里不选$A[i]$，那就相当于是从$A[0:i-1]$里选物品，则最大价值是$f[i-1][j]$，所以 f [ i ] [ j ] = max ⁡ { f [ i − 1 ] [ j ] , f [ i ] [ j − A [ i ] ] + V [ i ] } f[i][j]=\max\{f[i-1][j],f[i][j-A[i]]+V[i]\} f[i][j]=max{f[i−1][j],f[i][j−A[i]]+V[i]}这里注意，对于每一个$i$，我们按照$j$必须从小到大更新，因为$f[i][j]$的取值是依赖$f[i][j-A[i]]$的。代码如下：

public class Solution {
    /**
     * @param A: an integer array
     * @param V: an integer array
     * @param m: An integer
     * @return: an array
     */
    public int backPackIII(int[] A, int[] V, int m) {
        // write your code here
        if (A == null || A.length == 0 || V == null || V.length == 0) {
            return 0;
        }
        
        int[][] dp = new int[A.length][m + 1];
        for (int i = 0; i * A[0] <= m; i++) {
            dp[0][i * A[0]] = i * V[0];
        }
    
        for (int i = 1; i < A.length; i++) {
        	// j递增更新
            for (int j = 0; j <= m; j++) {
                dp[i][j] = dp[i - 1][j];
                if (j - A[i] >= 0) {
                    dp[i][j] = Math.max(dp[i][j], dp[i][j - A[i]] + V[i]);
                }
            }
        }
        
        return dp[A.length - 1][m];
    }
}

时空复杂度$O(l_{A}m)$。

考虑空间优化。我们发现$f[i][j]$的取值只取决于其上方一行和其左方的值。所以算出$f[i]$这一行的时候可以直接覆盖到原数组上。但需要注意，这里每一行需要从左向右算，因为$f[i][j]$要依赖其左边已经算好的数值。代码如下：

public class Solution {
    /**
     * @param A: an integer array
     * @param V: an integer array
     * @param m: An integer
     * @return: an array
     */
    public int backPackIII(int[] A, int[] V, int m) {
        // write your code here
        if (A == null || A.length == 0 || V == null || V.length == 0) {
            return 0;
        }
        
        int[] dp = new int[m + 1];
        for (int i = 0; i * A[0] <= m; i++) {
            dp[i * A[0]] = i * V[0];
        }
        
        for (int i = 1; i < A.length; i++) {
        	// j从小到大更新
            for (int j = 0; j <= m; j++) {
                if (j - A[i] >= 0) {
                    dp[j] = Math.max(dp[j], dp[j - A[i]] + V[i]);
                }
            }
        }
        
        return dp[m];
    }
}

时间复杂度不变，空间$O(m)$。