【Lintcode】562. Backpack IV

题目地址：

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

给定一个数组$A$，代表每个物品的体积，题目保证$A$里的数全是正数并且没有重复。再给定一个容积$m$，问能塞满这个容积的物品组合的方案数。每个物品可以用无限次。

思路是动态规划。将一个方案与一个上升序列做一一对应，例如，某个方案是$A[0]$取$2$个，$A[1]$取$1$个，$A[3]$取$2$个，那么这个方案可以表示为$(0,0,1,3,3)$。也就是将选取的每个物品的下标做成一个单调增序列。设$f[i][j]$是只选$A[0:i]$的物品，要填满体积$j$的方案数。那么可以按照方案所对应的序列的最后一个数字做分类，如果最后一个数字恰好是$i$，意思是这个方案包含$A[i]$，那么此时的方案数是$f[i][j-A[i]]$；如果最后一个数字不是$i$，那么此时方案数是$f[i-1][j]$，所以有：$$f[i][j]=f[i][j-A[i]]+f[i-1][j]$$边界条件：$$f[0][j]=\{\begin{array}{l}1,A[0]|j\\ 0,A[0]\nmid j\end{array}$$注意到递推式，$f[i]$在更新的时候一定要按照$j$递增的顺序更新，因为$f[i][j]$是依赖$f[i][j-A[i]]$的。代码如下：

public class Solution {
    /**
     * @param nums: an integer array and all positive numbers, no duplicates
     * @param target: An integer
     * @return: An integer
     */
    public int backPackIV(int[] nums, int target) {
        // write your code here
        if (nums == null || nums.length == 0) {
            return 0;
        }
        
        int[][] dp = new int[nums.length][target + 1];
        for (int i = 0; i * nums[0] <= target; i++) {
            dp[0][i * nums[0]] = 1;
        }
    
        for (int i = 1; i < nums.length; i++) {
            for (int j = 0; j <= target; j++) {
                dp[i][j] = dp[i - 1][j];
                if (j >= nums[i]) {
                    dp[i][j] += dp[i][j - nums[i]];
                }
            }
        }
        
        return dp[nums.length - 1][target];
    }
}

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

考虑空间优化。由于$f[i][j]$只依赖其正上方一行和其左边的值，所以可以考虑在更新的时候直接覆盖到原数组上。但是需要注意，一定要从左向右更新，因为$f[i][j]$是依赖$f[i][j-A[i]]$的。代码如下：

public class Solution {
    /**
     * @param nums: an integer array and all positive numbers, no duplicates
     * @param target: An integer
     * @return: An integer
     */
    public int backPackIV(int[] nums, int target) {
        // write your code here
        if (nums == null || nums.length == 0) {
            return 0;
        }
        
        int[] dp = new int[target + 1];
        for (int i = 0; i * nums[0] <= target; i++) {
            dp[i * nums[0]] = 1;
        }
        
        for (int i = 1; i < nums.length; i++) {
        	// 按照j递增的顺序更新
            for (int j = 0; j <= target; j++) {
                if (j >= nums[i]) {
                    dp[j] += dp[j - nums[i]];
                }
            }
        }
        
        return dp[target];
    }
}

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