【刷题（8）】动态规划

m0_51579041

已于 2024-05-30 17:49:28 修改

阅读量369

点赞数 4

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

于 2024-05-21 11:55:36 首次发布

本文链接：https://blog.csdn.net/m0_51579041/article/details/139087352

版权

刷题专栏收录该内容

18 篇文章 0 订阅

订阅专栏

一、动态规划问题基础

（1）先思考返回值是什么，true? length? value?
（2）边界条件
（3）状态转移，从1开始
（4）状态枚举，状态计算
（5）状态转移：dp[i]=max(dp[i],dp[j]+1)
（6）背包问题通用框架：

dp[i] 表示是否存在和为 i 的 num 组合。
外层遍历 nums 每个 num；
内层遍历 target（由大到小）。

二、70. 爬楼梯

1 题目

在这里插入图片描述

2 解题思路

(1)定义状态：dp[i]表示爬到第i层的方式
(2)状态转移：dp[i]=dp[i-1]+dp[i-2]
(3)状态初始化：dp[1]=1 dp[2]=2

3 code

class Solution {
public:
    int climbStairs(int n) {

        if(n<=1) return n;
        
        // 状态定义
        vector<int> dp(n+1);

        // 状态初始化
        dp[1]=1;
        dp[2]=2;

        // 状态转移
        // 注意i是从3开始的，且i<n+1
        for(int i=3;i<n+1;i++)
        {
            dp[i]=dp[i-1]+dp[i-2];
        }

        return dp[n];
    }
};

三、118. 杨辉三角

1 题目

在这里插入图片描述

2 解题思路

（1）把杨辉三角的每一排左对齐：
在这里插入图片描述

（2）状态转移：其余数字，等于左上方的数，加上正上方的数，即 dp[i][j]=dp[i−1][j−1]+dp[i−1][j]dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j] dp[i][j]=dp[i−1][j−1]+dp[i−1][j]。例如 4=1+3, 6=3+34=1+3,\ 6=3+34=1+3, 6=3+3 等。

（3）状态初始化：每一排的第一个数和最后一个数都是1，即 dp[i][0]=dp[i][i]=1 dp[i][0]=dp[i][i] = 1 dp[i][0]=dp[i][i]=1。

3 code

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        //状态定义
        vector<vector<int>> dp(numRows);

        for(int i=0;i<numRows;i++)
        {
            dp[i].resize(i+1,1);

            for(int j =1;j<i;j++)
            {
                // 状态转移，左上方的数+正上方的数
                dp[i][j]=dp[i-1][j]+dp[i-1][j-1];
            }
        }
        return dp;
    }
};

四、198. 打家劫舍

1 题目

在这里插入图片描述

2 解题思路

（1）状态定义：dp[i]代表前i家能偷盗的最大金额
（2）状态初始化：如果只有一家，只能偷这家dp[i]=nums[i]；如果有两家，因为是连通的，所以，只能偷较富的dp[i]=max(nums[i],nums[i-1])
（3）状态转移：如果大于等于3家，转移方程为：dp[i]=max(dp[i-1],dp[i-2]+nums[i])

3 code

class Solution {
public:
    int rob(vector<int>& nums) {

        // 状态定义
        vector<int> dp(nums.size(),0);

        // 状态初始化
        int size = nums.size();
        if(size ==1)
        {
            return nums[0];
        }

        dp[0]=nums[0];
        dp[1]=max(nums[0],nums[1]);

        // 状态转移
        for(int i=2;i<nums.size();i++)
        {
                dp[i]=max(dp[i-1],dp[i-2]+nums[i]);
        }

        return dp[nums.size()-1];

    }
};

五、322. 零钱兑换

1 题目

在这里插入图片描述

2 解题思路

（1）coins逐渐增加
（2）amount逐渐增加
（3）状态转移：dp[j+coin]=min(dp[j+coin],dp[j]+1);

3 code

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        // 状态定义
        vector<int> dp(amount+5,1e4+5);

        // 状态初始化
        dp[0]=0;

        // 双重状态转移
        for(int i=0;i<coins.size();i++)
        {
            int coin=coins[i];
            for(int j=0;j<=amount-coin;j++)
            {
                dp[j+coin]=min(dp[j+coin],dp[j]+1);
            }
        }
        if(dp[amount]==1e4+5) 
        {
            dp[amount]=-1;
        }
        return dp[amount];
    }
};

六、139. 单词拆分

1 题目

在这里插入图片描述

2 解题思路

（1）状态定义： dp[i]表示字符串s的前i个字符是否可以拆分成wordDict，其值有两个true 和false。
（2）状态计算：假设当前遍历到了第i个字符，依据最后一次拆分成的字符串str划分集合，最后一次拆分成的字符串str可以为s[0 ~ i - 1]，s[1 ~ i - 1]，，，s[j ~ i - 1]。
在这里插入图片描述
（3）状态转移方程： f[i] = ture 的条件是：f[j] = ture并且s[j, i - 1]在hash表中存在。

（4）初始化： f[0] = true，表示空串合法。

（5）实现细节：
为了快速判断字符串s拆分出来的子串在wordDict中出现，我们可以用一个哈希表存贮wordDict中的每个word。
时间复杂度分析：状态枚举O(n)，状态计算O(n)，因此时间复杂度为O(n^2)。

3 code

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        int n=s.size();

        // 用一个哈希表存贮wordDict中的每个word
        unordered_set<string> hash;
        for(string word:wordDict){
            hash.insert(word);
        }

        // 定义状态
        vector<bool> dp(n+1,false);
        // 状态初始化
        dp[0]=true;
        //状态转移,从1开始
        for(int i=1;i<n+1;i++){
            for(int j=0;j<i;j++){
                if(dp[j] && hash.find(s.substr(j, i - j)) != hash.end()){
                    dp[i]=true;
                    break;
                }
            }
        }
        return dp[n];

    }
};

七、300. 最长递增子序列

1 题目

在这里插入图片描述

2 解题思路

（1）状态枚举：for(int i=0;i<n;i++)
（2）状态计算：for(int j=0;j<i;j++)
（3）状态转移：dp[i]=max(dp[i],dp[j]+1)

3 code

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n=nums.size();
        if(n==0) return 0;

        // 状态定义
        vector<int> dp(n,1);

        int Maxn=1;
        // 状态转移
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<i;j++)
            {
                if(nums[i]> nums[j])
                {
                    dp[i]=max(dp[i],dp[j]+1);
                }
                Maxn=max(Maxn,dp[i]);
            }
        }

        return Maxn;

    }
};

八、152. 乘积最大子数组

1 题目

在这里插入图片描述

2 解题思路

（1）这题是求数组中子区间的最大乘积，对于乘法，我们需要注意，负数乘以负数，会变成正数，所以解这题的时候我们需要维护两个变量，当前的最大值，以及最小值，最小值可能为负数，但没准下一步乘以一个负数，当前的最大值就变成最小值，而最小值则变成最大值了。
（2）我们的动态方程可能这样：
maxDP[i + 1] = max(maxDP[i] * A[i + 1], A[i + 1],minDP[i] * A[i + 1])
minDP[i + 1] = min(minDP[i] * A[i + 1], A[i + 1],maxDP[i] * A[i + 1])
dp[i + 1] = max(dp[i], maxDP[i + 1])
（3）这里，我们还需要注意元素为 0 的情况，如果 A[i] 为 0，那么 maxDP 和 minDP 都为 0，
我们需要从 A[i + 1] 重新开始。

3 code

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int n=nums.size();

        // 边界条件
        if(n==0) return 0;
        if(n==1) return nums[0];

        int p = nums[0];
        int maxP = nums[0];
        int minP=nums[0];
        
        // 状态转移，从1开始
        for(int i=1;i<n;i++){
            int t =maxP;
            maxP=max(max(maxP*nums[i],nums[i]),minP*nums[i]);
            minP=min(min(t*nums[i],nums[i]),minP*nums[i]);
            p=max(maxP,p);
        }
        return p;

    }
};

九、416. 分割等和子集

1 题目

在这里插入图片描述

2 解题思路

（1）本题要求把数组分成两个等和的子集，相当于找到一个子集，其和为 sum / 2，这个 sum / 2 就是 target（target 间接给出）。
于是转化为是否可以用 nums 中的数组合和成 target，01 背包问题，外层循环为选择池 num: nums，内层循环为 target。
（2）对于元素之和等于 i - num 的每一种组合，在最后添加 num 之后即可得到一个元素之和等于 i 的组合，因此dp[i] 依赖于 dp[i - num]，并且在计算 dp[i - num] 时，要保证索引较小的元素值不被覆盖，需要后向更新 dp[i]，并且当 i - num < i 时， dp[i] 已经更新过，于是：
dp[i] = dp[i] || dp[i - num]
（3）对于特例：如果 sum 为奇数，那一定找不到符合要求的子集，返回 False。
对于边界条件，我们定义 dp[0] = true 表示当 i - num = 0，存在一个 num 和为 i。
最后返回 dp[target]。

3 code

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int len =nums.size();
        int sum=0;

        for(int num:nums){
            sum+=num;
        }
        if((sum&1)==1){
            return false;
        }

        int target=sum/2;
        vector<bool> dp(target+1);
        dp[0]=true;

        for(int num:nums){
            for(int i=target;i>=num;i--){
                dp[i]=dp[i] || dp[i-num];
            }
        }
        return dp[target];
    }
};