力扣刷题之动态规划

最新推荐文章于 2022-06-24 17:24:26 发布
最新推荐文章于 2022-06-24 17:24:26 发布
阅读量274 收藏 1
点赞数
分类专栏： 数据结构与算法 力扣 文章标签： 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41191468/article/details/119949220
版权

力扣刷题之动态规划

动态规划，简称DP，如果某问题有很多重叠子问题，使用动态规划是最有效的，动态规划中每一个状态一定是由上一个状态推导出来的，这一点区别于贪心，贪心没有状态推导，而是从局部直接选最优

动态规划解题五部曲：

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

509.斐波那契数列

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int fib(int n) {
     if(n<2) return n;
     int dp[2];
     dp[0]=0;
     dp[1]=1;
     for(int i=2;i<=n;i++){
         int sum=dp[0]+dp[1];
         dp[0]=dp[1];
         dp[1]=sum;
     }
     return dp[1];
    }
};

O(n),O(1)
用递归的话，时间复杂度太高

70.爬楼梯

在这里插入图片描述

思路：爬到第一层楼梯有一种方法，爬到第二层楼梯有两种方法，从第一层楼梯再跨两步就到第三层，第二层楼梯再跨一步就到第三层，所以第三层楼梯的状态可以由第二层楼梯和到第一层楼梯状态推导出来，那么就可以想到动态规划

动规五部曲：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int climbStairs(int n) {
        if(n<2)return n;
        int dp[3];
        dp[1]=1;
        dp[2]=2;
        for(int i=3;i<=n;i++){
            int sum=dp[1]+dp[2];
            dp[1]=dp[2];
            dp[2]=sum;
        }
        return dp[2];
    }
};

和斐波那契数列很类似
O(n),O(1)

//背包法，求组合数
class Solution {
public:
    int climbStairs(int n) {
        vector<int> dp(n + 1, 0);
        dp[0] = 1;
        for (int i = 1; i <= n; i++) { // 遍历背包
            for (int j = 1; j <= 2; j++) { // 遍历物品
                if (i - j >= 0) dp[i] += dp[i - j];
            }
        }
        return dp[n];
    }
};

746.使用最小花费爬楼梯

在这里插入图片描述

思路：dp[i]的定义：到达第i个台阶所花费的最少体力为dp[i]
有两个途径得到dp[i],一个是dp[i-1]，一个是dp[i-2],选其中最小的，所以dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int dp0=cost[0];
        int dp1=cost[1];
        for(int i=2;i<cost.size();i++){
            int dpi=min(dp0,dp1)+cost[i];
            dp0=dp1;
            dp1=dpi;
        }
        return min(dp0,dp1);
    }
};

62.不同路径

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

//二维dp数组
class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m,vector<int>(n));
        for(int i=0;i<m;i++)dp[i][0]=1;
        for(int j=0;j<n;j++)dp[0][j]=1;
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
};

在这里插入图片描述

//数论法
class Solution {
public:
    int uniquePaths(int m, int n) {
        long long ans = 1;
        for (int x = n, y = 1; y < m; ++x, ++y) {
            ans = ans * x / y;
        }
        return ans;
    }
};

63.不同路径II

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m=obstacleGrid.size();
        int n=obstacleGrid[0].size();
        vector<vector<int>>dp(m,vector<int>(n));
        for(int i=0;i<m&&obstacleGrid[i][0]==0;i++)dp[i][0]=1;
        for(int j=0;j<n&&obstacleGrid[0][j]==0;j++)dp[0][j]=1;
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                if(obstacleGrid[i][j]==1)continue;
                dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
};

343.整数拆分

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int integerBreak(int n) {
        vector<int> dp(n+1);
        dp[2]=1;
        for(int i=3;i<=n;i++){
            for(int j=1;j<i-1;j++){
                dp[i]=max(dp[i],max((i-j)*j,dp[i-j]*j));
            }
        }
        return dp[n];
    }
};

96.不同的二叉搜索树

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int numTrees(int n) {
        vector<int> dp(n+1,0);
        dp[0]=1;
        dp[1]=1;
        for(int i=2;i<=n;++i){
            for(int j=1;j<=i;++j){
                dp[i]+=dp[j-1]*dp[i-j];
            }
        }
        return dp[n];
    }
};

01背包问题

在这里插入图片描述

416.分割等和子集

在这里插入图片描述

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum=0;
        vector<int> dp(10001,0);
        for(int i=0;i<nums.size();i++){
            sum+=nums[i];
        }
        if(sum%2==1)return false;
        int target=sum/2;
        for(int i=0;i<nums.size();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 false;
    }
};

在这里插入图片描述

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

在这里插入图片描述

思路：任意选i块石头，使得他们的重量趋近于总重量的一半，这样和另一半抵消的差值就是最小的

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        vector<int> dp(15001,0);
        int sum=0;
        for(int i=0;i<stones.size();i++)sum+=stones[i];
        int target=sum/2;
        for(int i=0;i<stones.size();i++){
            for(int j=target;j>=stones[i];j--){
                dp[j]=max(dp[j],dp[j-stones[i]]+stones[i]);
            }
        }
        return sum-dp[target]-dp[target];
    }
};

494.目标和

背包解决排列组合问题
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum=0;
        for(int i=0;i<nums.size();i++)sum+=nums[i];
        if(target>sum)return 0;
        if((target+sum)%2==1)return 0;
        int bagSize=(target+sum)/2;
        vector<int> dp(abs(bagSize)+1,0);
        dp[0]=1;
        for(int i=0;i<nums.size();i++){
            for(int j=bagSize;j>=nums[i];j--){
                dp[j]+=dp[j-nums[i]];
            }
        }
        return dp[abs(bagSize)];
    }
};

474.一和零

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        vector<vector<int>>dp(m+1,vector<int>(n+1,0));
        for(string str:strs){
            int oneNum=0,zeroNum=0;
            for(char c:str){
                if(c=='0')zeroNum++;
                else oneNum++;
            }
            for(int i=m;i>=zeroNum;i--){
                for(int j=n;j>=oneNum;j--){
                    dp[i][j]=max(dp[i][j],dp[i-zeroNum][j-oneNum]+1);
                }
            }
        }
        return dp[m][n];      

    }
};

完全背包问题

完全背包和01背包唯一不同的地方就是，每种物品有无限件

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

518.零钱兑换II（可以照葫芦画瓢写了）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        vector<int> dp(amount+1,0);
        dp[0]=1;//这步一开始忘记了
        for(int i=0;i<coins.size();i++){
            for(int j=coins[i];j<=amount;j++){
                dp[j]+=dp[j-coins[i]];
            }
        }
        return dp[amount];
    }
};

在这里插入图片描述

377.组合总数IV

在这里插入图片描述

class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        vector<int> dp(target+1,0);
        dp[0]=1;
        for(int j=0;j<=target;j++){
            for(int i=0;i<nums.size();i++){
                if(j-nums[i]>=0&&dp[j]<INT_MAX-dp[j-nums[i]])
                dp[j]+=dp[j-nums[i]];
            }
        }
        return dp[target];
    }
};

322.零钱兑换

在这里插入图片描述

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        vector<int> 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-coins[i]]+1,dp[j]);
                }
            }
        }
        if(dp[amount]==INT_MAX)return -1;
        return dp[amount];
    }
};

279.完全平方数

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int numSquares(int n) {
        vector<int> dp(n+1,INT_MAX);
        dp[0]=0;
        dp[1]=1;
        for(int i=1;i*i<=n;i++){
            for(int j=1;j<=n;j++){
                if(j-i*i>=0)
                dp[j]=min(dp[j-i*i]+1,dp[j]);
            }
        }
        return dp[n];

    }
};

139.单词拆分

引发思考：如果目标是个字符串应该怎么处理？
如何用set+find找一个单词是否存在在容器中？
如何用substr()函数截取长字符串中的短字符串

在这里插入图片描述

public:
    bool wordBreak(string s, vector<string>& wordDict) {
        unordered_set<string> wordSet(wordDict.begin(),wordDict.end());
        vector<bool> dp(s.size()+1,false);
        dp[0]=true;
        for(int i=1;i<=s.size();i++){
            for(int j=0;j<i;j++){
                string word=s.substr(j,i-j);
                if(wordSet.find(word)!=wordSet.end()&&dp[j]){
                    dp[i]=true;
                }
            }
        }
        return dp[s.size()];

    }
};

多重背包

和01背包有点像，每件物品最多有M件可用，把M件摊开，其实就是一个01背包问题了

在这里插入图片描述

在这里插入图片描述

背包问题总结

在这里插入图片描述
遍历顺序：
01背包

  • 二维dp数组：先遍历物品或者先遍历背包都可以，第二层for循环是从小到大遍历
  • 一维dp数组：只能先遍历物品再遍历背包，且第二层for循环是从大到小遍历

完全背包：
一维dp数组：先遍历物品或者先遍历背包都可以，且第二层for循环是从小到大遍历

  • 如果求组合数就应该外层for循环遍历物品，内层for循环遍历背包；
  • 求排列数就应该外层for循环遍历背包，内层for循环遍历物品；
  • 求最小数的话，两层for循环的先后顺序就无所谓了

打家劫舍

198.打家劫舍

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.size()==0)return 0;
        if(nums.size()==1)return nums[0];
        vector<int> dp(nums.size());
        dp[0]=nums[0];
        dp[1]=max(nums[0],nums[1]);
        for(int i=2;i<nums.size();i++){
            dp[i]=max(dp[i-2]+nums[i],dp[i-1]);
        }
        return dp[nums.size()-1];
    }
};

213.打家劫舍II

思路就是把环拆分成不包含环的情况

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.size()==0)return 0;
        if(nums.size()==1)return nums[0];
        int result1=robRange(nums,0,nums.size()-2);
        int result2=robRange(nums,1,nums.size()-1);
        return max(result1,result2);
    }

    int robRange(vector<int>& nums,int start,int end){
        if(end==start)return nums[start];
        vector<int> dp(nums.size());
        dp[start]=nums[start];
        dp[start+1]=max(nums[start],nums[start+1]);
        for(int i=start+2;i<=end;i++){
            dp[i]=max(dp[i-2]+nums[i],dp[i-1]);
        }
        return dp[end];
    }
};

337.打家劫舍III(好难呜呜）

树形dp入门题，所谓树形dp就是在树上进行递归公式的推导

在这里插入图片描述在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int rob(TreeNode* root) {
        vector<int> result=robTree(root);
        return max(result[0],result[1]);
    }
    vector<int> robTree(TreeNode*cur){
        if(cur==NULL)return vector<int>{0,0};
        vector<int>left=robTree(cur->left);
        vector<int>right=robTree(cur->right);
        int val1=cur->val+left[0]+right[0];
        int val2=max(left[0],left[1])+max(right[0],right[1]);
        return {val2,val1};
    }
};

树形贪心

在这里插入图片描述

121.买卖股票的最佳时机（只买卖一次）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len=prices.size();
        if(len==0)return 0;
        vector<vector<int>> dp(len,vector<int>(2));
        dp[0][0]-=prices[0];
        dp[0][1]=0;
        for(int i=1;i<len;i++){
            dp[i][0]=max(dp[i-1][0],-prices[i]);
            dp[i][1]=max(dp[i-1][1],prices[i]+dp[i-1][0]);
        }
        return dp[len-1][1];
    }
};

法二：max(今天的价格-今天之前的最小值)

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size() <= 1)
            return 0;
        int mmin = prices[0], mmax = 0;
        for(int i = 1; i < prices.size(); i++) {
            mmax = max(mmax, prices[i] - mmin);
            mmin = min(mmin, prices[i]);
        }
        return mmax;
    }
};

122.买卖股票的最佳时机II（可以买卖多次）

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len=prices.size();
        if(len==0)return 0;
        vector<vector<int>> dp(len,vector<int>(2));
        dp[0][0]-=prices[0];
        dp[0][1]=0;
        for(int i=1;i<len;i++){
            dp[i][0]=max(dp[i-1][0],dp[i-1][1]-prices[i]);
            dp[i][1]=max(dp[i-1][1],prices[i]+dp[i-1][0]);
        }
        return dp[len-1][1];
    }
};

123.买卖股票的最佳时机III（最多买卖两次）

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size()==0)return 0;
        vector<vector<int>>dp(prices.size(),vector<int>(5,0));
        dp[0][1]=-prices[0];
        dp[0][3]=-prices[0];
        for(int i=1;i<prices.size();i++){
            dp[i][0]=dp[i-1][0];
            dp[i][1]=max(dp[i-1][1],dp[i-1][0]-prices[i]);
            dp[i][2]=max(dp[i-1][2],dp[i-1][1]+prices[i]);
            dp[i][3]=max(dp[i-1][3],dp[i-1][2]-prices[i]);
            dp[i][4]=max(dp[i-1][4],dp[i-1][3]+prices[i]);
        }
        return dp[prices.size()-1][4];

    }
};

188、买卖股票的最佳时机IV

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        if(prices.size()==0)return 0;
        vector<vector<int>> dp(prices.size(),vector<int>(2*k+1,0));
        for(int j=1;j<2*k;j+=2){
            dp[0][j]=-prices[0];
        }
        for(int i=1;i<prices.size();i++){
            for(int j=0;j<2*k-1;j+=2){
                dp[i][j+1]=max(dp[i-1][j+1],dp[i-1][j]-prices[i]);
                dp[i][j+2]=max(dp[i-1][j+2],dp[i-1][j+1]+prices[i]);
            }
        }
        return dp[prices.size()-1][2*k];

    }
};

309.最佳买卖股票时机含冷冻期（买卖多次，卖出有一天冷冻期）（好难哦）

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n=prices.size();
        if(n==0) return 0;
        vector<vector<int>> dp(n,vector<int>(4,0));
        dp[0][0]-=prices[0];
        for(int i=1;i<n;i++){
            dp[i][0]=max(dp[i-1][0],max(dp[i-1][3],dp[i-1][1])-prices[i]);
            dp[i][1]=max(dp[i-1][1],dp[i-1][3]);
            dp[i][2]=dp[i-1][0]+prices[i];
            dp[i][3]=dp[i-1][2];
        }
        return max(dp[n-1][3],max(dp[n-1][2],dp[n-1][1]));
    }
};

714.买卖股票的最佳时机含手续费（买卖多次，买卖一次有一次手续费）

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int n=prices.size();
        vector<vector<int>> dp(n,vector<int>(2,0));
        dp[0][0]-=prices[0];
        for(int i=1;i<n;i++){
            dp[i][0]=max(dp[i-1][0],dp[i-1][1]-prices[i]);
            dp[i][1]=max(dp[i-1][1],dp[i-1][0]+prices[i]-fee);
        }
        return max(dp[n-1][0],dp[n-1][1]);//注意这里与买卖股票II的不同，因为多了手续费，所以最大获益不一定在卖出的时候了

    }
};

子序列问题

300.最长增长子序列

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        if(nums.size()<=1)return nums.size();
        vector<int> dp(nums.size(),1);
        int result=0;
        for(int i=1;i<nums.size();i++){
            for(int j=0;j<i;j++){
                if(nums[i]>nums[j])dp[i]=max(dp[i],dp[j]+1);
            }
            if(dp[i]>result)result=dp[i];
        }
        return result;
    }
};

674.最长连续递增序列

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        if(nums.size()==0)return 0;
        int result=1;
        vector<int> dp(nums.size(),1);
        for(int i=0;i<nums.size()-1;i++){
            if(nums[i+1]>nums[i]){
                dp[i+1]=dp[i]+1;
            }
            if(dp[i+1]>result)result=dp[i+1];
        }
        return result;
    }
};

718.最长重复子数组

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        vector<vector<int>> dp(nums1.size()+1,vector<int>(nums2.size()+1,0));
        int result=0;
        for(int i=1;i<=nums1.size();i++){
            for(int j=1;j<=nums2.size();j++){
                if(nums1[i-1]==nums2[j-1]){
                    dp[i][j]=dp[i-1][j-1]+1;
                }
                if(dp[i][j]>result)result=dp[i][j];
            }
        }
        return result;
    }
};

1143.最长公共子序列

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        vector<vector<int>>dp(text1.size()+1,vector<int>(text2.size()+1,0));
        for(int i=1;i<=text1.size();i++){
            for(int j=1;j<=text2.size();j++){
                if(text1[i-1]==text2[j-1]){
                    dp[i][j]=dp[i-1][j-1]+1;
                }else{
                    dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
                }
            }
        }
        return dp[text1.size()][text2.size()];
    }
};

1035.不相交的线

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
        vector<vector<int>> dp(nums1.size()+1,vector<int>(nums2.size()+1,0));
        for(int i=1;i<=nums1.size();i++){
            for(int j=1;j<=nums2.size();j++){
                if(nums1[i-1]==nums2[j-1]){
                    dp[i][j]=dp[i-1][j-1]+1;
                }else{
                    dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
                }
            }
        }
        return dp[nums1.size()][nums2.size()];
    }
};

53.最大子序和

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if(nums.size()==0)return 0;
        vector<int> dp(nums.size());
        dp[0]=nums[0];
        int result=dp[0];
        for(int i=1;i<nums.size();i++){
            dp[i]=max(dp[i-1]+nums[i],nums[i]);
            if(dp[i]>result)result=dp[i];
        }
        return result;
    }
};

392.判断子序列

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    bool isSubsequence(string s, string t) {
        vector<vector<int>> dp(s.size()+1,vector<int>(t.size()+1,0));
        for(int i=1;i<=s.size();i++){
            for(int j=1;j<=t.size();j++){
                if(s[i-1]==t[j-1])dp[i][j]=dp[i-1][j-1]+1;
                else dp[i][j]=dp[i][j-1];
            }
        }
        if(dp[s.size()][t.size()]==s.size())return true;
        return false;
    }
};

115.不同的子序列

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int numDistinct(string s, string t) {
        vector<vector<uint64_t>> dp(s.size()+1,vector<uint64_t>(t.size()+1));
        for(int i=0;i<s.size();i++)dp[i][0]=1;
        for(int j=1;j<t.size();j++)dp[0][j]=0;
        for(int i=1;i<=s.size();i++){
            for(int j=1;j<=t.size();j++){
                if(s[i-1]==t[j-1]){
                    dp[i][j]=dp[i-1][j-1]+dp[i-1][j];
                }else{
                    dp[i][j]=dp[i-1][j];
                }
            }
        }
        return dp[s.size()][t.size()];
    }
};

583.两个字符串的删除操作

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int minDistance(string word1, string word2) {
        vector<vector<int>> dp(word1.size()+1,vector<int>(word2.size()+1));
        for(int i=0;i<=word1.size();i++) dp[i][0]=i;
        for(int j=0;j<=word2.size();j++) dp[0][j]=j;
        for(int i=1;i<=word1.size();i++){
            for(int j=1;j<=word2.size();j++){
                if(word1[i-1]==word2[j-1]){
                    dp[i][j]=dp[i-1][j-1];
                }else{
                    dp[i][j]=min({dp[i-1][j-1]+2,dp[i-1][j]+1,dp[i][j-1]+1});
                }
            }
        }
        return dp[word1.size()][word2.size()];
    }
};

72.编辑距离

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public:
    int minDistance(string word1, string word2) {
        vector<vector<int>> dp(word1.size()+1,vector<int>(word2.size()+1,0));
        for(int i=0;i<=word1.size();i++)dp[i][0]=i;
        for(int j=0;j<=word2.size();j++)dp[0][j]=j;
        for(int i=1;i<=word1.size();i++){
            for(int j=1;j<=word2.size();j++){
                if(word1[i-1]==word2[j-1]){
                    dp[i][j]=dp[i-1][j-1];
                }else{
                    dp[i][j]=min({dp[i-1][j-1],dp[i-1][j],dp[i][j-1]})+1;
                }
            }
        }
        return dp[word1.size()][word2.size()];
    }
};

647.回文子串

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int countSubstrings(string s) {
        vector<vector<bool>> dp(s.size(),vector<bool>(s.size(),false));
        int result=0;
        for(int i=s.size()-1;i>=0;i--){
            for(int j=i;j<s.size();j++){
                if(s[i]==s[j]){
                    if(j-i<=1){
                        result++;
                        dp[i][j]=true;
                    }else if(dp[i+1][j-1]){
                        result++;
                        dp[i][j]=true;
                    }
                }
            }
        }
        return result;
    }
};

516.最长回文子序列

回文子串要求连续，回文子序列不要求连续


在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        vector<vector<int>>dp(s.size(),vector<int>(s.size(),0));
        for(int i=0;i<s.size();i++)dp[i][i]=1;
        for(int i=s.size()-1;i>=0;i--){
            for(int j=i+1;j<s.size();j++){
                if(s[i]==s[j]){
                    dp[i][j]=dp[i+1][j-1]+2;
                }else{
                    dp[i][j]=max(dp[i+1][j],dp[i][j-1]);
                }
            }
        }
        return dp[0][s.size()-1];

    }
};
南不喃
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法｜LeetCode（力扣）经典题：动态规划
峰峰的博客
02-24 2336
LeetCode经典（数据结构与算法）题刷题指南：动态规划篇
Leetcode动态规划专题（共38道）
weixin_45627369的博客
04-10 6007
某一问题有很多重叠子问题 每一状态一定由上一状态推导出来 而贪心没有状态推导，而是直接选局部最优 解决方式： 确定dp数组（dp table）以及下标的含义 确定递推公式 dp数组如何初始化 确定遍历顺序 举例推导dp数组 模拟：举例推导dp数组 检查：打印dp数组 1.Leetcode509. 斐波那契数 class Solution { public: int fib(int n) { //第i个数的值 vector<int>n
动态规划DP（中上）（力扣中等难度题目解析）
lihua777的博客
01-25 1144
动态规划DP（中上）（力扣中等难度题目解析）
力扣刷题系列——动态规划II
qq_43568704的博客
08-19 1459
常见的动态规划问题(二） 本文转载于GitHub地址：https://github.com/CyC2018/CS-Notes/，仅作为个人日后复习。整合了多方面的资料，侵删。 引例解析： 内容来源于公众号文章：https://mp.weixin.qq.com/s/lKQI0aS1MBwfPujC-m_zkA 运用动态规划四部曲来进行解答： //解法一 public int coinChange(int[] coins, int amount) { // 子问题： ...
力扣题型总汇——动态规划
qq_51329170的博客
03-14 9274
动态规划总结： 题目： Day2:53最大子数和 Day4:70爬楼梯 Day4:509最大子数和 Day8:118杨辉三角 Day9:119杨辉三角 II Day10:121买卖股票的最佳时机 Day23:292Nim 游戏 Day25:441第三大的数
力扣刷题力扣刷题力扣刷题力扣刷题
07-16
- 动态规划：解决最优化问题，例如斐波那契数列、背包问题、最长公共子序列等。 - 贪心算法：局部最优解来达到全局最优解，如活动选择问题、霍夫曼编码等。 - 回溯法：尝试所有可能的解，如八皇后问题、N皇后问题...
Leetcode:记录力扣刷题之路
03-15
3. **算法**：排序算法（如冒泡排序、快速排序、归并排序、堆排序）、查找算法（如二分查找、哈希查找）、动态规划、回溯法、贪心算法等。熟悉这些算法能帮助我们找到高效解题策略。 4. **指针与引用**：C++中的...
力扣刷题精选11111
03-23
通过LeetCode的刷题，我们可以学习到如排序、搜索、图论、动态规划等经典算法，这些都是软件开发中的基础工具。例如，快速排序、归并排序等可以优化数据处理效率；二分查找则能高效地在有序数组中定位元素；图论中的...
力扣刷题算法截图汇总2021
04-02
2021年的力扣刷题算法截图汇总是一个珍贵的学习资源，它可能包含了当年力扣上的热门问题及其解决方案的截图。由于标签为"python"，我们可以推断这些截图主要涉及使用Python语言解决这些问题。 在Python编程中，解决...
大厂笔试算法宝典力扣刷题
05-25
综上所述，这份《大厂笔试算法宝典力扣刷题》资源结合了力扣平台的实战练习和labuladong的精辟讲解，旨在帮助求职者提升算法水平，顺利通过大厂的笔试环节，为职场之路铺平道路。无论是初学者还是有一定经验的开发者...
leetcode-64-最小路径和
weixin_45942124的博客
03-08 181
64. 最小路径和 给定一个包含非负整数的 *m* x *n* 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。 **说明：**每次只能向下或者向右移动一步。 示例 1： 输入：grid = [[1,3,1],[1,5,1],[4,2,1]] 输出：7 解释：因为路径 1→3→1→1→1 的总和最小。 示例 2： 输入：grid = [[1,2,3],[4,5,6]] 输出：12 提示： m == grid.length n == grid[i].length 1 &
力扣刷题-动态规划总结
m0_48437268的博客
11-13 515
力扣-动态规划 动态规划基础题目 按照如下顺序将力扣题目做完，相信会帮助你对 动态规划基础问题 有一个深刻的理解。 509.斐波那契数 70.爬楼梯 746.使用最小花费爬楼梯 62.不同路径 63.不同路径II 343.整数拆分 96.不同的二叉搜索树 动态规划的五个步骤： 确定 f 数组以及下标的含义 确定递推公式 f 的初始化 确定遍历顺序 举例推导dp数组 解法 509.斐波那契数 斐波那契数，通常用 F(n) 表示，形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都
力扣刷题（二）动态规划
xuhong_001的博客
08-22 605
动态规划 最长回文子串 给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。 解题思路 第一步：确定动态规划状态 与上面两题不同的是，这个题目必须用二维的dp数组来记录状态，主要原因就是子串有回文的限制。用两个指针来记录子串的位置可以很好的实现子串的回文要求，又因为后结果需要返回的是子串，这里不同于之前题目的用dp保存长度，我们必须找到具体哪个部分符合回文子串的要求。这里插一句，其实也有求回文子串长度的题目Leetcode516. 长回文子序列,如果有兴趣可以看一 下
力扣刷题_动态规划dp
Black eyes的博客
11-19 453
文章目录easy170. 爬楼梯392. 判断子序列746. 使用最小花费爬楼梯剑指 Offer 42. 连续子数组的最大和面试题 16.17. 连续数列面试题 08.01. 三步问题面试题 17.16. 按摩师353. 最大子序和198. 打家劫舍middle62. 不同路径63. 不同路径 IIhard easy 1 70. 爬楼梯 题目链接 难度：简单 1 类型： 动态规划 题目：假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼
力扣算法分享——动态规划
小谢的博客
09-20 700
力扣 动态规划：#10题 题目：给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 ‘.’ 和 ‘*’ 的正则表达式匹配。 ‘.’ 匹配任意单个字符 ‘*’ 匹配零个或多个前面的那一个元素 所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。 说明: s 可能为空，且只包含从 a-z 的小写字母。 p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。 解法一：递归 递...
力扣刷题计划（day1)
m0_52151913的博客
03-23 602
1.基本（数组） 对于我这种刚开始刷题的小菜鸟来说，遇到这种题第一反应是用暴力解法，两个for搞定 class Solution { public: int maxArea(vector<int>& height) { size_t max=0; for(int i=0;i<height.size();i++) { for(int j=i+1;j<height.size();j++) { int _height=height[i]
力扣(LeetCode)打卡刷题交流计划(长期维护)
bigsai
08-02 5877
前言 忙忙活活暑期过去了一半，在即将升学的日子里，打算干点什么东西，由于实力以及经验的欠缺没有创群和大家讨论，但我更喜欢以更实在的方式——能作点什么——和大家一起从0打开力扣LeetCode， 对，没错，就是从开开始一起刷力扣，因为力扣自己还没刷过，想和大家一起开始。在笔者公众号(bigsai)后台回复进群，即可通过二维码扫码进群，也可以加笔者vxq1315426911拉你进群。 本次活动长期维护运行，希望能和大家一起进步。 打卡计划 因为在去年寒假今年春的时候已经组织过类似的活动，当时是暑假搞得剑指off
力扣算法题中使用“动态规划”刷题的简单解析：小白向（有实题和答案）
kiyokiwa的博客
06-24 359
解析力扣53.题最大子数组和，经典动态规划题，java
力扣动态规划
dayday学习的博客
09-06 1283
力扣动态规划1. 斐波那契数列70. 爬楼梯1要求2 思路198. 打家劫舍1要求2.思路2131 要求2.思路矩阵路径64. 最小路径和1 要求2.思路62. 不同路径1要求 1. 斐波那契数列 70. 爬楼梯 1要求 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？ 注意：给定 n 是一个正整数。 示例 1： 输入： 2 输...
力扣刷题笔记：动态规划与链表操作
"力扣500题刷题笔记2，包含C++代码实现，涉及动态规划、链表操作和双指针技术" 本资源主要涵盖了LeetCode中的三道经典问题，分别是力扣500题中的某一部分，包括杨辉三角II、移除链表元素和反转字符串中的单词III。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值