动态规划之背包问题

01背包

总共有n种物品，每种物品的数量为1。
可以通过回溯算法进行暴力枚举求解。因为每种物品就只有取与不取两种状态，时间复杂度为2^n。
dp[i][j]表示[0, i]的物品任取放入容量为j的背包之中。dp数组的行为物品的编号，dp数组的列是背包从0到j的容量。
递推公式：
1.放物品i：dp[i - 1][j - weight(i)] + value(i)
2.不放物品i: dp[i - 1][j]
max(dp[i - 1][j - weight(i)] + value(i), dp[i - 1][j])
初始化dp：
dp数组的第一列是对应的背包的容量为0，故全部初始化为0；dp数组的第一行从背包容量大于或等于最轻的物品重量开始，初始化为最轻的物品重量，其余元素均初始化为0。其余的元素可以初始化成为任意值，因为每个元素是根据其正上方与左斜上方的元素进行求取的。
遍历顺序：
对于01背包问题，两层for循环的遍历顺序可以颠倒。即先遍历物品再遍历背包与先遍历背包再遍历物品皆可。

滚动数组

1.定义：dp[j]: 容量为j的背包的最大价值。
2.递推公式：max(dp[j], dp[j - weight(i)] + value(i))。
3.初始化：dp[0] = 0;
4.遍历顺序：
用两层for循环，第一层遍历物品，第二层从后往前遍历背包（即j = bagWeight; j >= weight(i); j–）。这样可确保同一物品只被遍历一次。
5.打印dp数组

完全背包

总共有n种物品，每种物品的数量有无限多个。

多重背包

总共有n种物品，每种物品的的数量各不相同。
代码随想录

题目

leetcode 416 分割等和子集

将数组中的元素视作物品的重量，既是重量也是价值。由于每个元素只能使用1次，所以是01背包问题。
dp数组的定义：dp[target] == target 表示容量为target的背包刚好装满。

class Solution {
    public int max(int val1, int val2){
        return val1 > val2 ? val1 : val2;
    }
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for(int num : nums){
            sum += num;
        }
        if(sum % 2 != 0){
            return false; //因为数组之和是奇数，所以不能平分
        }
        //定义并初始化dp数组
        int target = sum / 2;
        int[] dp = new int[target + 1];
        //定义递推公式和遍历顺序：先物品再背包
        for(int i = 0; i < nums.length; i++){
            for(int j = target; j >= nums[i]; j--){
                dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
            }
            if(dp[target] == target){
                return true;
            }
        }
        return dp[target] == target;
    }
}

leetcode 1049 最后一块石头的重量

关键：尽量把石头分成重量相似的两堆。

class Solution {
    public int lastStoneWeightII(int[] stones) {
        int sum = 0;
        for(int stone : stones){
            sum += stone;
        }
        int target = sum / 2;
        //定义以及初始化dp数组
        int[] dp = new int[target + 1];
        dp[0] = 0;
        //定义递推公式及遍历顺序
        for(int i = 0; i < stones.length; i++){
            for(int j = target; j >= stones[i]; j--){
                dp[j] = Math.max(dp[j], dp[j - stones[i]] + stones[i]);
            }
        }
        return sum - dp[target] - dp[target];
    }
}

leetcode 494 目标和

定义dp数组：装满容量为j的数组有dp[j]种方法。

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        //定义dp数组
        for(int num : nums){
            sum += num;
        }
        if(target < 0 && target < -sum){
            return 0;
        }
        if((target + sum) % 2 != 0){
            return 0;
        }
        int left = (sum + target) / 2;//问题转化成求装满容量为left的背包有多少种不同的方式
        if(left < 0){
            return -left;
        }
        int[] dp = new int[left + 1];
        dp[0] = 1;//初始化dp数组
        //定义递推公式以及遍历顺序
        for(int i = 0; i < nums.length; i++){
            //因为每种物品只能用1次，所以从后往前遍历背包
            for(int j = left; j >= nums[i]; j--){
               dp[j] += dp[j - nums[i]];
            }
        }
        return dp[left];
    }
}

leetcode 474 一和零

本题也属于01背包问题，相当于是问：要装满具有m和n的两个维度的背包，最多需要多少物品。
dp数组的定义：装满i个0和j个1的背包最多可以有dp[i][j]物品。
这里每个物品的价值都是1。

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        //定义dp数组以及初始化数组
        int[][] dp = new int[m + 1][n + 1];//不要忘记加1
        dp[0][0] = 0;//因为能装0个m和0个n的背包所能装下的最多物品数量也为0
        //递推公式以及遍历顺序：先遍历物品再遍历背包
        for(String str : strs){
            int x = 0;//记录每个字符串中所包含0的数量
            int y = 0;//记录每个字符串中所包含1的数量
            for(int i = 0; i < str.length(); i++){
                if(str.charAt(i) == '0'){
                    x++;
                }else{
                    y++;
                }
            }
            for(int i = m; i >= x; i--){
                for(int j = n; j >= y; j--){
                    dp[i][j] = Math.max(dp[i][j], dp[i - x][j - y] + 1);//物品的个数对应1个价值
                }
            }
        }
        return dp[m][n];
    }
}

完全背包问题

容量一定的背包，可以装不同的物品，每种物品可以使用无数次，怎样装背包使得背包的价值最大。
完全背包问题的遍历顺序可以交换，即可以先遍历背包再遍历物品。
注意：先遍历物品再遍历背包，得到的才是组合数；先遍历背包再遍历物品，得到的是排列数。

leetcode 518 零钱兑换（2）

本题相当于求组合数，不考虑元素的排列顺序。
当dp数组的j下标j表示背包容量时，dp[j]则表示装满容量为j的背包总共有多少种方法。则对应的递推公式：dp[j] += dp[j - coins[i]]。

class Solution {
    public int change(int amount, int[] coins) {
        //定义dp数组
        int[] dp = new int[amount + 1];
        dp[0] = 1;
        //递推公式以及遍历顺序:先遍历物品再遍历背包。物品可以重复使用
        for(int i = 0; i < coins.length; i++){
            for(int j = coins[i]; j <= amount; j++){
                dp[j] += dp[j - coins[i]];
            }
        }
        return dp[amount];
    }
}

leetcode 377 组合总和（4）

本题属于完全背包问题种的排列数问题。故dp数组的遍历顺序为先背包再物品。迭代公式为：
dp[i] += dp[i - nums[j]]。

class Solution {
    public int combinationSum4(int[] nums, int target) {
        //本题属于排列数问题，所以遍历顺序时先背包再物品
        //定义dp数组
        int[] dp = new int[target + 1];
        dp[0] = 1;
        //定义递推公式与遍历顺序：先背包再物品
        for(int i = 0; i <= target; i++){
            for(int j = 0; j < nums.length; j++){
                if(i - nums[j] >= 0){
                    dp[i] += dp[i - nums[j]];
                }
            }
        }
        return dp[target];
    }
}

leetcode 322 零钱兑换

注意：若递推公式中要求最小值，则初始dp数组的时候应初始为最大值才不会被覆盖。

    public int coinChange(int[] coins, int amount) {
        if(amount == 0){
            return 0;
        } 
        //定义dp数组
        int[] dp = new int[amount + 1];
        dp[0] = 0;
        //为了递推公式中的dp[j]不被0所覆盖掉，所以将dp数组的其余元素初始化为最大值
        for(int i = 1; i < dp.length; i++){
            dp[i] = Integer.MAX_VALUE;
        }
        //递推公式以及遍历顺序：先物品再背包(由于每种物品的数量无限，故背包从前往后遍历)
        //硬币的数量即是价值。每个硬币的价值是1。
        for(int i = 0; i < coins.length; i++){
            for(int j = coins[i]; j <= amount; j++){
                if(dp[j - coins[i]] != Integer.MAX_VALUE){
                    dp[j] = Math.min(dp[j], dp[j - coins[i]] + 1);
                }
            }
        }
        if(dp[amount] == Integer.MAX_VALUE){
            return -1;
        }else{
            return dp[amount];
        }
    }
}

leetcode 279 完全平方数

本题与上一题的思路完全一致。相当于求装满容量为j的背包所需要的最少的物品的数量。

class Solution {
    public int numSquares(int n) {
        //定义dp数组
        int[] dp = new int[n + 1];
        //初始化dp数组
        dp[0] = 0;
        for(int i = 1; i < dp.length; i++){
            dp[i] = Integer.MAX_VALUE;
        }
        //定义递归函数与遍历顺序
        for(int i = 0; i <= n; i++){
            for(int j = 1; j*j <= n; j++){
                if(i - j*j >= 0){
                    dp[i] = Math.min(dp[i], dp[i - j*j] + 1);
                }
            }
        }
        return dp[n];
    }
}

leetcode 139 单词拆分

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        HashSet<String> set = new HashSet<>(wordDict);
        //定义dp数组
        boolean[] dp = new boolean[s.length() + 1];
        //初始化dp数组
        dp[0] = true;
        //定义递推公式以及遍历顺序：由于本题与字典数组中的字符串出现在s中的顺序相关，故先遍历背包再物品
        for(int i = 1; i <= s.length(); i++){
            for(int j = 0; j < i && !dp[i]; j++){
                if(set.contains(s.substring(j, i)) && dp[j]){
                    dp[i] = true;
                }
            }
        }
        return dp[s.length()];
    }
}