煮酒与君饮

这个屌丝很懒，什么也没留下！

热门标签

动态规划刷题-详解_给你一个只包含正整数的非空数组

作者：煮酒与君饮 | 2024-06-28 12:19:28

踩

给你一个只包含正整数的非空数组

动态规划

动态规划步骤

确定dp数组（dp table）以及下标的含义
确定递推公式
dp数组如何初始化
确定遍历顺序
举例推导dp数组

343. 整数拆分 - 力扣（Leetcode）

dp思想：

dp[i]表示正整数i拆分后乘积最大的值
dp[i]=max(dp[i], max( (i - j) * j, dp[i - j] * j ))

其中dp[i - j] * j，为啥不是dp[j]，可以从循环看j是从1开始的，如果需要dp[j]即j也可以拆分成两个数j1和j2，那么在j=j1时就可以j1*dp[i - j1]时求得最大值，所有无需dp[j]；
而且如果是dp[j]，那么在j=1、2、3时会出现问题，若2*dp[i-2]时取最大，但如果dp[2]*dp[i-2]会取不到这个最大值

dp[1] = 0,注意1无法拆分，所有dp[1]不为1；dp[2] = 1，2要拆分成1和1，所有为1，不为2
i从3开始

for(int i = 3; i <= n; i++){
            for(int j = 1; j < i ; j++){
                dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));
            }
        }
1
2
3
4
5

代码：

class Solution {
public:
    int integerBreak(int n) {
        vector<int> dp(n + 1);
        dp[1] = 0;
        dp[2] = 1;
        for(int i = 3; i <= n; i++){
            for(int j = 1; j < i ; j++){
                dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));
            }
        }
        return dp[n];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

96. 不同的二叉搜索树 - 力扣（Leetcode）

思想：dp[i]为i个节点二叉搜索树的个数。

对于整数n，那么分为1为头节点，那么左子树节点为0、n-1，转化为0和n-1的个节点二叉搜索树个数的子问题。2为头节点，那么左右子树节点为1、n-2，转化为1和n-2的个节点二叉搜索树个数的子问题。。。

动态规划五部曲：

dp[i]为i个节点二叉搜索树的个数。
dp[i]+=dp[j]*dp[n - j -1]
dp[0]=1，节点数为0时也可以看成一个空树，dp[1]=1

for(int i = 1; i <= n; i++){
            for(int j = 0; j < i; j++){
                dp[i] += dp[i - j - 1] * dp[j];
            }
        }
1
2
3
4
5

代码：

class Solution {
public:
    int numTrees(int n) {
        vector<int> dp(n + 1);
        dp[0] = 1;
        for(int i = 1; i <= n; i++){
            for(int j = 0; j < i; j++){
                dp[i] += dp[i - j - 1] * dp[j];
            }
        }
        return dp[n];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13

背包问题

01背包

应用：首先每个物品只能拿一次，可以选择拿或者不拿。然后，需要将题目转化为求背包的重量（难点，像1049. 最后一块石头的重量 II - 力扣（Leetcode）就要想到可以转化为求解一半重量的背包能装的最大重量）
理解：背包最大容量bagWeight，每个物品有价值value和重量weight，且每个物品最多拿一个

二维数组dp时，两层for循环先遍历物品还是背包容量没区别 ，因为都是从每个位置都是状态都取决于其左上角的矩阵

一维数组dp，for循环顺序固定，先遍历物品，再从背包最大容量开始遍历，如果从背包0重量开始遍历会导致使用当前物品更新的信息，而不是使用上一个物品更新的信息

416. 分割等和子集 - 力扣（Leetcode）

题目：给你一个 只包含正整数 的非空数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

思路：每个数只能选择一次，转化为背包容量为数组和sum一半(如果sum是奇数直接retrun false)的情况下，背包能不能装sum/2的东西，每个数的价值和重量相等。

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;
        for(auto &x : nums){
            sum += x;
        }
        if(sum % 2) return false;
        int n = sum / 2, m = nums.size();
        vector<int> dp(n + 1, 0);
        for(int i = 0; i < m; i++){
            for(int j = n; j >= nums[i]; j--){
                    dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
            }
        }
        if(dp[n] - n == 0) {
            return true;
        }else{
            return false;
        }

    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

1049. 最后一块石头的重量 II - 力扣（Leetcode）

题目：

思路：每个石头只能选择一次，想到背包问题。

将石头分为两组，两组重量最接近情况下，相撞重量达到最小，即寻找sum/2的背包容量最大w为多少，结果就是sum-2w.

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int n = stones.size(), sum = 0;
        for(auto &x : stones){
            sum += x;
        }
        int m = sum / 2;
        vector<int> dp(m + 1, 0);
        for(int i = 0; i < n; i++){
            for(int j = m; j >=stones[i]; j--){
                dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
            }
        }
        return sum - 2 * dp[m];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

494. 目标和 - 力扣（Leetcode）

题目：

思路：每个数只能取一次，想到背包。重点是如何求解组合的个数，此时dp数组的含义就要和以前的区别开来。

同样分为两组一组是加（和为left），一组是减（和为right）。那么sum = left + right，

目标是求target = left - right = left - (sum - left) -> left = (sum + target) / 2;

所以就是求背包容量为left有多少种情况，相较于前面的题目这边求的是组合个数，dp[j]表示重量为j有dp[j]种组合方式，同时如果sum + target不为偶数或者target绝对值大于sum都直接return 0。

更新方式为：dp[j] += dp[j - nums[i]];

表示当前第i个数，组成和为j的个数为第i-1个数时dp[j]加上第i-1个数时dp[j - nums[i]]

初始化dp[0]=1，因为重量为0背包的情况就是1种

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = 0;
        for(auto &x : nums){
            sum += x;
        }
        if((sum + target) % 2 || abs(target) > sum){
            return 0;
        }
        int w = (sum + target) / 2, n = nums.size();
        vector<int> dp(w + 1, 0);
        dp[0] = 1;
        for(int i = 0; i < n; i++){
            for(int j = w; j >= nums[i]; j--){
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[w];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

474. 一和零 - 力扣（Leetcode）

思路：如何表示背包重量，dp数组含义如何确定，因为要求解的是最大子集长度,只需要两个维度表示背包容量就可以，dp的值就是当前重量子集最大值

dp[i][j] = max(dp[i][j], dp[i - x][j - y] + 1);

对于i和j遍历时先遍历谁没有区别，但是对于每一此遍历都必须是从大重量往小重量遍历（原理同一维dp时为何从最大重量往最小重量遍历一致）

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
        for(auto &x : strs){
            int cnt0 = 0, cnt1 = 0;
            for(auto &y : x){
                if(y == '0') cnt0++;
                else cnt1++;
            }
            for(int i = m; i >= cnt0; i--){
                for(int j = n; j >= cnt1; j--){
                    dp[i][j] = max(dp[i][j], dp[i - cnt0][j - cnt1] + 1);
                }
            }
        }
        return dp[m][n];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

完全背包

思想：

每个物品都有无数个，实际就是在01背包的一维数组将背包容量的遍历反过来就可以，当初01背包是要求背包重量从最大往最小遍历，就是为了防止当前物品计算多次。

代码：

01背包：

for(int i = 0; i < weight.size(); i++) { // 遍历物品
    for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
    }
}
1
2
3
4
5

完全背包：

// 先遍历物品，再遍历背包
for(int i = 0; i < weight.size(); i++) { // 遍历物品
    for(int j = weight[i]; j <= bagWeight ; j++) { // 遍历背包容量
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

    }
}
1
2
3
4
5
6
7

其中，对于纯完全背包中的两层for循环顺序可以颠倒，01背包不可以（不是纯完全背包可能有变化）。完全背包就是根据前面的空间状态更新当前状态，所以先更新列没有问题；01背包是根据上一个物品更新的空间状态从后往前更新，所以颠倒之后遍历顺序就反了，具体理解看代码随想录中《完全背包理论基础》

518. 零钱兑换 II - 力扣（Leetcode）

思路：完全背包问题，下面主要解决两个问题，一个dp数组含义，二是初始化

1、dp[j] 表示总面额为j时共有多少种组合

2、dp[0] 为总面额为0 时有一种组合

同时！这题求的是组合数而不是排列数，也就是和选择硬币的顺序无关，这点可以模拟dp数组好好理解

代码：

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        int n = coins.size();
        //dp[j] 表示总面额为j时共有多少种组合
        vector<int> dp(amount + 1, 0);
        //dp[0] 为总面额为0 时有一种组合
        dp[0] = 1;
        for(int i = 0; i < n; i++){
            for(int j = coins[i]; j <= amount; j++){
                dp[j] = dp[j] + dp[j - coins[i]];
            }
        }
        return dp[amount];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

377. 组合总和 Ⅳ - 力扣（Leetcode）

思路：这边要求的是面额的排列数，和上面那题只是for循环次序不同，同时c++还有一个int型限制。也可以转化为爬楼梯问题

class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        int n = nums.size();
        vector<long long> dp(target + 1, 0);
        dp[0] = 1;
        for(int j = 0; j <= target; j++){
            for(int i = 0; i < n; i++){
                if(j >= nums[i] && dp[j] + dp[j - nums[i]] < INT_MAX){
                    dp[j] += dp[j - nums[i]];
                }
            }
        }
        return dp[target];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

70. 爬楼梯 - 力扣（Leetcode）

思路：除了简单的斐波那契数列方式，还可以想象成完全背包，背包容量为n，两个物品1和2价值和重量相等，然后求排列数（此时for循环肯定先遍历容量）,代码中的m为可以走[1…m]步，如果是数组那么dp[j] = dp[j] + dp[j - i] -> dp[j] = dp[j] + dp[j - nums[i]]

class Solution {
public:
    int climbStairs(int n) {
        int dp[n + 1];
        memset(dp, 0, sizeof(dp));
        dp[0] = dp[1] = 1;
        for(int j = 2; j <= n; j++){
            for(int i = 1; i <= m; i++){
                dp[j] = dp[j] + dp[j - i];
            }
        }
        return dp[n];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

322. 零钱兑换 - 力扣（Leetcode）

思路：每个硬币无限量，amount为容量，完全背包问题。为了求取最少硬币数，dp[i]为容量为i时最少个数，递推公式 $\min (dp[j],dp[j - coins[i]] + 1)$

初始化dp[0]=0 dp[i]=INT_MAX,注意判断，否则再+1超范围了

同时，因为求取的是最小个数，所以不强调组合还是排序，两个for循环顺序无所谓

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        int dp[amount + 1];
        fill(dp, dp + amount + 1, INT_MAX);
        dp[0] = 0;
        for(int i = 0; i < coins.size(); i++){
            for(int j = coins[i]; j <= amount ; j++){
                if(dp[j-coins[i]] != INT_MAX)
                    dp[j] = min(dp[j], dp[j-coins[i]] + 1);
            }
        }
        return dp[amount] == INT_MAX ? -1 : dp[amount];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

279. 完全平方数 - 力扣（Leetcode）

思路：首先要想到完全背包问题

dp[j]为和为整数j的完全平方数最少数量，
递推公式dp[j]=min(dp[j], dp[j-i*i] + 1)
初始化同样dp[j]=INT_MAX,dp[0]=0
循环顺序没影响，注意判断int数据越界即可

class Solution {
public:
    int numSquares(int n) {
        vector<int> dp(n + 1, INT_MAX);
        dp[0] = 0;
        int m = sqrt(n);
        for(int i = 1; i <= m; i++){
            for(int j = i * i; j <= n; j++){
                if(dp[j - i * i] != INT_MAX){
                    dp[j] = min(dp[j], dp[j - i * i] + 1);
                }
            }
        }
        return dp[n];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

139. 单词拆分 - 力扣（Leetcode）

思路：单词可以重复使用拼接出s，想到完全背包（回溯方法也可以），但特殊的是每次能放入背包的物品有限制

dp[j]表示s[j-1]之前的字符都是否可以匹配 true/false
dp[j] = dp[j] ? dp[j] : dp[j-m] 本身到j都可以拼出那仍为true，否则可以更改为dp[j-m],m为当前拼接单词的长度
dp[j]=false, dp[0]=true,那么s下标从0开始，字符串长度为0时无需选择任何单词都可以拼出
排列数，遍历顺序得先是字符串s的长度，如果先是单词，更新单词i时还没考虑之后的单词，无法正常遍历

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        int len = s.length();
        vector<bool> dp(len + 1, false);
        //字符串长度为0时无需选择任何单词都可以拼出
        dp[0] = true;
        for(int j = 1; j <= len; j++){
            for(auto x : wordDict){
                int m = x.length();
                if(j >= m && s.substr(j - m, m) == x){
                    dp[j] = dp[j] ? dp[j] : dp[j - m];
                    if(dp[j]) break;
                }
            }
        }
        return dp[len];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

多重背包

背包容量BagWeight，每个物品有对应的重量、价值、数量

可以转化为01背包处理，将相同的物品看成是重量相同和价值相同的不同物品

打家劫舍

198. 打家劫舍 - 力扣（Leetcode）

思路：无法贪心，因为对于后续房间的价值未知，无法规划未来，使用动态规划

dp[i]为偷到第i个房间的最大价值
dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])，要么偷当前房间，要么不偷用dp[i-1]更新
初始化dp[i] = 0，dp[0] = nums[0] / dp[1] = max(nums[0], nums[1]);
n<2情况直接特判return；遍历从i=3开始往后

class Solution {
public:
    int rob(vector<int>& nums) {
        int n = nums.size();
        if(n == 1) return nums[0];
        vector<int> dp(n, 0);
        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);
        for(int i = 2; i < n; i++){
            dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
        }
        return dp[n - 1];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/煮酒与君饮/article/detail/765959