动态规划（二）背包问题

最新推荐文章于 2024-05-24 20:19:19 发布

AerialAce

最新推荐文章于 2024-05-24 20:19:19 发布

阅读量332

点赞数

分类专栏：算法文章标签：动态规划算法 leetcode

本文链接：https://blog.csdn.net/weixin_41029475/article/details/131029946

版权

算法专栏收录该内容

26 篇文章 0 订阅

订阅专栏

背包问题概述

背包问题分类
三种背包问题都有一个共同的限制，那就是背包容量，背包的容量是有限的，这便限制了物品的选择，而三种背包问题的共同目的，便是让背包中的物品价值最大。
不同的地方在于物品数量的限制，01背包问题中，每种物品只有一个，对于每种物品而言，便只有选和不选两个选择。完全背包问题中，每种物品有无限多个，所以可选的范围要大很多。在多重背包问题中，每种物品都有各自的数量限制。
题型：

最低、最多。初始化值一般是dp[0]=0, 递推公式一般是dp[j] = Math.max(dp[j], dp[j-w[i]] + v[i])。w[i]为重量，v[i]为价值；
恰好装满，有多少种。初始化值一般是dp[0]=1, 递推公式一般是dp[j] += dp[j-nums[i-1]。

0-1背包

重点记忆：

一维数组，先遍历物品再遍历背包，从大到小遍历背包；
题目是否可以转化为求总重量为x的背包；
二维背包。

416. 分割等和子集

当sum/2为奇数时，永远都不能等分
背包最大重量为sum/2，物品重量为nums[i]，价值为nums[i]
dp[i][j]：选取前i个物品，当背包最大能装j重量的物品时，dp[i][j]表示此时背包的最大价值（实际装的物品的重量）
问题可以转化为求dp[nums.lenth][sum/2]表示的最大价值（实际装的物品的重量）是否等于sum/2，若相等，则说明存在。
以输入数组 [1, 5, 11, 5]为例， dp[7] 只能等于 6，因为只能放进 1 和 5。
而dp[6] 就可以等于6了，放进1 和 5，那么dp[6] == 6，说明背包装满

二维数组解法

class Solution {
    public boolean canPartition(int[] nums) {
        int sum = Arrays.stream(nums).sum();
        if (sum % 2 != 0) {
            return false;
        }
        int target = sum/2;
        int[][] dp = new int[nums.length + 1][target + 1];
        for(int i = 1; i <= nums.length; i++){
            for(int j = 1; j <= target; j++){
                dp[i][j] = dp[i-1][j];
                if( (j-nums[i-1]) >= 0){
                    dp[i][j] =Math.max(dp[i][j] , dp[i-1][j-nums[i-1]]+ nums[i-1] );
                }
            }
        }
        return dp[nums.length][target] == target;
    }
}

一维数组解法

class Solution {
    public boolean canPartition(int[] nums) {
        int sum = Arrays.stream(nums).sum();
        if (sum % 2 != 0) {
            return false;
        }
        int target = sum/2;
        int[] dp = new int[target + 1];
        for(int i = 1; i <= nums.length; i++){
            for(int j = target; j>=nums[i-1]; j--){
                dp[j] = Math.max(dp[j],dp[j-nums[i-1]]+nums[i-1]);
            }
        }
        return dp[target] == target;
    }
}

1049. 最后一块石头的重量 II

思路：尽量让石头分成重量相同的两堆，相撞之后剩下的石头最小，这样就化解成01背包问题
物品的重量、价值都为stone[i]
背包最大重量为sum / 2，左右边界无需考虑，只要左右能够尽量相等就好

一维数组解法

class Solution {
    public int lastStoneWeightII(int[] stones) {
        int sum = 0;
        for(int i = 0; i < stones.length; i++){
            sum+=stones[i];
        }
        int m = sum / 2; 
        int[] dp = new int[m+1];
        for(int i = 1; i <= stones.length; i++){
            for(int j = m; j >= stones[i-1]; j--){
                dp[j] = Math.max(dp[j],dp[j-stones[i-1]]+ stones[i-1]);
            }
        }
        return (sum - dp[m]) - dp[m];
    }
}

494. 目标和

思路：l表示加正号的数，r表示加负号的数，根据题意存在l + r = sum，l - r = target, 即l = (sum + target) / 2, 题目可以转化为给定nums数组，取出n个数，使其和为l的组合；
注意当(sum + target) / 2 != 0 || abs(target) > sum时，题目无解，因为nums数组取n个数怎么组合都无法使其和为l；
物品重量为nums[i]，背包最大重量为l，求恰好装满背包有多少种解法;
- dp数组：前i个物品中，任取n个数，使得n个数的总和为j，dp[i][j]表示有几种选法；
- 递推公式dp[i][j] = dp[i-1][j] + dp[i-1][j-nums[i-1]
- 初始化：dp[0][0] = 1
- 先遍历物品，再遍历容量

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        for(int num : nums){
            sum+=num;
        }
        if((target + sum) % 2 == 1 || Math.abs(target) > sum) return 0; 
        //为什么把m作为背包的容量
        int m = (target + sum) >> 1;
        int[] dp = new int[m+1];
        dp[0] = 1;
        for(int i = 1; i <= nums.length; i++){
            for(int j = m; j >= nums[i-1]; j--){
                dp[j]+=dp[j-nums[i-1]];
            }
        }
        return dp[m];
    }
}

474. 一和零

每个字符串只能取0或1次，有两个维度的限制，分别是0的数量最多为m，1的数量最多为n，所以是二维0-1背包；
背包的最大容量是m和n，物品的重量是strs[i]中0和1的数目，每个物品的价值是1，求最大价值
dp[i][j][k]含义：前i个字符串中，0的最大数量为j，1的最大数量为k时，dp[i][j][k]表示符合条件的最大子集（字符串的数目最多）
dp[i][j][k] = Max(dp[i-1][j][k], dp[i-1][j-zero][k-one] + 1)
初始化：dp[0][j][k] = 0
遍历顺序：先遍历字符串，再遍历0和1的最大数量

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][] dp = new int[m+1][n+1];
        for(int i = 1; i <= strs.length; i++){
            int zero = 0, one = 0;
            for(char str: strs[i - 1].toCharArray()){
                if(str == '0') zero++;
                else           one++;
            }    
            for(int j = m; j >= zero; j--){
                for(int k = n; k >= one; k--){
                    dp[j][k] = Math.max(dp[j][k], dp[j-zero][k-one] + 1); 
                }
            }
        }
        return dp[m][n];
    }
}

完全背包

重点记忆：

一维数组，从小到大遍历背包，可以重复添加；
推导公式；
先遍历物品再遍历背包求组合，先遍历背包再遍历物品求排列；

完全背包推导与理解

公式推导

k满足: k>=0 && k*v[i]<=j
f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i],f[i-1][j-2*v[i]]+2*w[i],f[i-1][j-3*v[i]]+3*w[i],.....)
f[i][j-v[i]]=max(       f[i-1][j-v[i]],f[i-1][j-2*v[i]]+w[i],f[i-1][j-3*v[i]]+2*w[i],.....)
由上两式，可得出如下递推关系：f[i][j]=max( f[i-1][j],f[i][j-v[i]]+w[i])

一维数组优化

for(int i = 1; i <= n ; i++){
    for(int j = v[i]; j <= m; j++){
        //当j∈[0,v[i]）时，f[i][j] = f[i-1][j]
        //当j∈[v[i],m]时，f[j-v[i]]为第i层的执行结果，符合上述恒等式
        f[j] = Math.max(f[j], f[j-v[i]] + w[i]);
    }
}

理解记忆
完全背包的物品是可以添加多次的，所以遍历背包时，要从小到大去遍历。

518. 零钱兑换 II

dp[j]含义：取前n个硬币，当总金额为j时，dp[j]表示可以凑成总金额j的硬币组合数
dp[j] = dp[j] + dp[j-coins[i-1]]
初始化，dp[0]=1
遍历顺序：先遍历硬币，再遍历总金额

class Solution {
    public int change(int amount, int[] coins) {
        int[] dp = new int[amount+1];
        dp[0] = 1;
        for(int i = 1; i <= coins.length; i++){
            for(int j = coins[i-1]; j <= amount; j++){
                dp[j]+= dp[j - coins[i-1]];
            }
        }
        return dp[amount];
    }
}

377. 组合总和 Ⅳ

dp[j]含义：表示可以凑成目标总数j的整数的排列数
dp[j] = dp[j] + dp[j-nums[i-1]]
初始化dp[0]=1
遍历顺序：纯完全背包求得装满背包的最大价值是多少，和凑成总和的元素有没有顺序没关系。但是求方案个数时，则有排列与组合之分，要通过不同的遍历顺序来求。
先遍历背包，再遍历物品，求的是排列

先遍历物品，再遍历背包，求的是组合。如果把遍历nums（物品）放在外循环，遍历target的作为内循环的话，举一个例子：计算dp[4]的时候，结果集只有 {1,3} 这样的集合，不会有{3,1}这样的集合，因为nums遍历放在外层，3只能出现在1后面。

class Solution {
    public int combinationSum4(int[] nums, int target) {
        int[] dp = new int[target+1];
        dp[0] = 1; 
        for(int i = 1; i <= target; i++){   //背包
            for(int j = 1; j <= nums.length; j++){   //物品
                if(i >= nums[j-1]){
                    dp[i]+=dp[i-nums[j-1]];
                }
            }
        }        
        return dp[target];
    }
}

70. 爬楼梯（进阶）

改为：一步一个台阶，两个台阶，三个台阶，…，直到 m个台阶。问有多少种不同的方法可以爬到楼顶呢？
解析：1阶，2阶，… m阶就是物品，楼顶就是背包。每一阶可以重复使用，例如跳了1阶，还可以继续跳1阶。问跳到楼顶有几种方法其实就是问装满背包有几种方法。

class Solution {
    public int climbStairs(int n) {
        int[] dp = new int[n+1];
        dp[0] = 1;
        for(int i = 1; i <= n; i++){   //总台阶数
            for(int j = 1; j <= 2; j++){   //每次可以爬的台阶数
               if(i >= j)    dp[i]+=dp[i - j];
            }
        }
        return dp[n];
    }
}

322. 零钱兑换

dp数组：取前n个物品，总金额为j时，dp[j]表示可以凑成总金额j所需的最少的硬币个数
递推公式：dp[j] = Math.min(dp[j],dp[j-coins[i-1]]+1);
初始化：dp[0] = 0, 求最小值，所以dp[i](i>0)都初始化为最大值
遍历顺序：不是求方案数，任意顺序都可以

class Solution {
    public int coinChange(int[] coins, int amount) {
        //取前n个物品，总金额为j时，dp[j]表示可以凑成总金额j所需的最少的硬币个数
        int[] dp = new int[amount+1];
        dp[0] = 0;
        for(int i = 1; i < dp.length; i++){
            dp[i] = Integer.MAX_VALUE;
        }
        for(int i = 1; i <= coins.length; i++){
            for(int j = coins[i-1]; j <= amount; j++){ 
                if(dp[j-coins[i-1]] != Integer.MAX_VALUE){
                   dp[j] = Math.min(dp[j],dp[j-coins[i-1]]+1); 
                }
            }      
        }
        return dp[amount] == Integer.MAX_VALUE ? -1: dp[amount];
    }
}

279.完全平方数

class Solution {
    public int numSquares(int n) {
        int[] dp = new int[n+1];
        dp[0] = 0;
        for(int i = 1; i < dp.length; i++)  dp[i] = Integer.MAX_VALUE;
        for(int i = 1; i*i <= n; i++){
            int sq = i * i;
            for(int j = sq; j <= n; j++){
                dp[j] = Math.min(dp[j],dp[j-sq]+1);
            }
            // for(int j = 0; j < dp.length; j++){
            //     System.out.print(dp[j]+"\t");
            // }
            // System.out.println();
        }
        return dp[n];
    }
}

139.单词拆分

解题思路：字典里的单词（物品）能否组成字符串（背包），即正好装满背包，且单词可以使用多次，所以是完全背包问题。

dp数组含义：字典能否组成长度为i的字符串s；
dp[i] = dp[i-wordDict[j].length] && s.substring(i-wordDict[j].length,i).equals(wordDict[j])；
初始化：dp[0] = true；
遍历顺序：装满背包对物品的顺序有要求，选择排列数，先遍历长度，即背包，再遍历字典，即物品

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        boolean[] dp = new boolean[s.length() + 1];
        dp[0] = true;
        for(int i = 1; i <= s.length(); i++){   //遍历长度，即背包
            for(String word: wordDict){   //遍历字典，即物品
                int len = word.length();
                if(i >= len && dp[i-len] && s.substring(i-len,i).equals(word)){
                    dp[i] = true;
                    break;
                }
            }
        }
        return dp[s.length()];
    }
}

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        boolean[] dp = new boolean[s.length() + 1];
        HashSet<String> set = new HashSet<>(wordDict);
        dp[0] = true;
        for(int i = 1; i <= s.length(); i++){   //遍历长度，即背包
            for(int j = 0; j < i; j++){   //遍历物品
                if(dp[j] && set.contains(s.substring(j,i))){
                    dp[i] = true;
                }
            }
        }
        return dp[s.length()];
    }
}