【LeetCode】动态规划相关问题汇总

最新推荐文章于 2024-07-13 16:30:23 发布
最新推荐文章于 2024-07-13 16:30:23 发布
阅读量489 收藏 2
点赞数
分类专栏： 做题 文章标签： leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/allensu374125056/article/details/106961099
版权

动态规划相关问题汇总

动态规划基础

70. 爬楼梯

题目描述

在这里插入图片描述

题解1 使用数组

class Solution {
public:
    int climbStairs(int n) {
        if(n<2)return n;
        vector<int>step(n+1);
        step[0]=1;
        step[1]=1;
        for(int i=2;i<n+1;i++)
        {
            step[i]=step[i-1]+step[i-2];
        }
        return step[n];

    }
};

题解2 两个临时变量

    int climbStairs(int n) {
        if(n<2)return n;;
        int tmp;
        int last1=1;
        int last2=1;
        for(int i=2;i<n+1;i++)
        {
            tmp=last1+last2;
            last2=last1;
            last1=tmp;
        }
  }

120. 三角形最短路径和

题目描述

在这里插入图片描述

题解1 两行变量记录 复杂度O(n)

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int n=triangle.size();
        vector<int> lastbest(n,INT_MAX);
        vector<int> tmpbest(n,INT_MAX);
        lastbest[0]=triangle[0][0];
        tmpbest[0]=triangle[0][0];
        for(int i=1;i<n;i++)
        {
            for(int j=0;j<i+1;j++)
            {
                if(j==0)tmpbest[j]=lastbest[j]+triangle[i][j];
                else if(j<i)tmpbest[j]=min(lastbest[j]+triangle[i][j],lastbest[j-1]+triangle[i][j]);
                else 
                    tmpbest[j]=lastbest[j-1]+triangle[i][j];
                    //cout<<tmpbest[j]<<endl;
                
            }
            lastbest=tmpbest;
        }
        int ret=INT_MAX;
        for(int i=0;i<n;i++)
        {
            ret=min(ret,tmpbest[i]);
        }
        return ret;

    }
};

题解2 一行变量 自顶向下 空间复杂度O（n）

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int n=triangle.size();
        vector<int> lastbest(n,INT_MAX);
        vector<int> tmpbest(n,INT_MAX);
        //lastbest[0]=triangle[0][0];
        tmpbest[0]=triangle[0][0];
        for(int i=1;i<n;i++)
        {
            for(int j=i;j>=0;j--)
            {
                if(j==0)tmpbest[j]=tmpbest[j]+triangle[i][j];
                else if(j<i)tmpbest[j]=min(tmpbest[j]+triangle[i][j],tmpbest[j-1]+triangle[i][j]);
                else 
                    tmpbest[j]=tmpbest[j-1]+triangle[i][j];
                    //cout<<tmpbest[j]<<endl;
                
            }
            //lastbest=tmpbest;
        }
        int ret=INT_MAX;
        for(int i=0;i<n;i++)
        {
            ret=min(ret,tmpbest[i]);
        }
        return ret;

    }
};

题解3 自底向上 不需要额外空间

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int n=triangle.size();
        for(int i=n-2;i>=0;i--)
        {
            for(int j=0;j<triangle[i].size();j++)
            {
                triangle[i][j]=triangle[i][j]+min(triangle[i+1][j],triangle[i+1][j+1]);
            }
        }
        return triangle[0][0];

    }
};

343. 整数拆分

题目描述

在这里插入图片描述

题解1 动态规划

class Solution {
public:
    int max3(int x,int y,int z)
    {
        return x>y?x>z?x:z:y>z?y:z;
    }
    int integerBreak(int n) {
        vector<int> ret(n+1,0);
        ret[1]=1;
        for(int i=2;i<n+1;i++)
        {
            //cout<<"sdfdfs0"<<endl;
            for(int j=1;j<i;j++)
            {
                //cout<<(i-j)*ret[i-j]<<endl;
                ret[i]=max3((j)*ret[i-j],ret[i],(i-j)*(j));//(i-j)*(j)为i-j不拆分的情况
            }
        }
        return ret[n];
    }
};

279. 完全平方数

题目描述

在这里插入图片描述

题解1 使用队列进行图的遍历（时间较短）

题解2 动态规划

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

91. 解码方法

题目描述

在这里插入图片描述

题解1 难点在于分类讨论

class Solution {
public:
    int numDecodings(string s) {
        int n=s.size();
        vector<int> ret(n+1);
        
        if(s[0]=='0'){return 0;}
        else 
        {ret[0]=1;
        ret[1]=1;}
        for(int i=2;i<n+1;i++)
        {
            //if(s[i-1]=='0'&&s[i-2]=='0')return 0;
            if(s[i-1]=='0')
            {
               if(s[i-2]!='1'&&s[i-2]!='2') return 0;
               ret[i]=ret[i-2];
            }
            else if((s[i-2]=='2'&&s[i-1]>'6')||s[i-2]>'2'||s[i-2]=='0')
            {
                ret[i]=ret[i-1];
            }
            else
            {ret[i]=ret[i-2]+ret[i-1];}
        }
        return ret[n];
    }
};

62. 不同路径

题目描述

在这里插入图片描述

题解1

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp=vector<vector<int>>(m,vector<int>(n,0));
        
        for(int i=0;i<m;i++)
        {
            dp[i][0]=1;
        }
        for(int i=0;i<n;i++)
        {
            dp[0][i]=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];
    }
};

63. 不同路径 II

题目描述

在这里插入图片描述

题解1 额外空间

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

题解2 不使用额外空间

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m=obstacleGrid.size();
        int n=obstacleGrid[0].size();
        bool test=false;
        if(obstacleGrid[0][0]==1)test=true;
        int flag=false;
        for(int i=0;i<m;i++)
        {
            if(flag||obstacleGrid[i][0]==1){obstacleGrid[i][0]=0;flag=true;}
            else
            obstacleGrid[i][0]=1;
        }
        flag=test;
        for(int i=1;i<n;i++)
        {
            if(flag||obstacleGrid[0][i]==1){obstacleGrid[0][i]=0;flag=true;}
            else
            obstacleGrid[0][i]=1;
        }
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                if(obstacleGrid[i][j]==1){obstacleGrid[i][j]=0;continue;}
                obstacleGrid[i][j]=obstacleGrid[i-1][j]+obstacleGrid[i][j-1];
            }
        }
        return obstacleGrid[m-1][n-1];
    }
};

状态定义和状态转移

198. 打家劫舍

题目描述

在这里插入图片描述

题解

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

        if(n==0)return 0;
        vector<int> ret(n);
        ret[0]=nums[0];
        if(n==1)return nums[0];
        ret[1]=max(nums[0],nums[1]);
        for(int i=2;i<n;i++)
        {
            ret[i]=max(ret[i-2]+nums[i],ret[i-1]);
        }
        return ret[n-1];
    }
};

213. 打家劫舍 II

题目描述

在这里插入图片描述

题解1 使用两个变量 分别为偷了第一间和没偷第一间的最大值

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

        if(n==0)return 0;
        vector<int> ret(n);
        vector<int> nret(n);
        nret[0]=0;
        ret[0]=nums[0];
        if(n==1)return nums[0];
        ret[1]=max(nums[0],nums[1]);
        nret[1]=max(nums[1],0);
        for(int i=2;i<n;i++)
        {
            ret[i]=max(ret[i-2]+nums[i],ret[i-1]);
            nret[i]=max(nret[i-2]+nums[i],nret[i-1]);
        if(i==n-1)
        ret[n-1]=max(ret[n-2],nret[n-3]+nums[n-1]);
        }
        
       // nret[n-1]=max()
        return ret[n-1];
    }
};

337. 打家劫舍 III

题目描述

在这里插入图片描述

题解1 两个变量 偷和不偷 可以使用pair类型

class Solution {
    
    pair<int,int> dfs(TreeNode* root)
    {
       //pair<int,int> ret=make_pair(0,0);
        if(root==NULL)return make_pair(0,0);
        pair<int,int> lmax=dfs(root->left);
        pair<int,int> rmax=dfs(root->right);

        return make_pair(lmax.second+rmax.second+root->val,max(lmax.first,lmax.second)+max(rmax.first,rmax.second));
        
    }
public:
    int rob(TreeNode* root) {
        //root->left
        pair<int,int> res=dfs(root);
        return max(res.first,res.second);
    }
};

面试中的背包问题

416. 分割等和子集

题目描述

在这里插入图片描述

题解1 记忆化搜索 bool类型

class Solution {
    bool helper(vector<int>&nums ,int c,int index,vector<vector<int>>&memo)
    {
        //cout<<c<<" "<<index<<endl;
        
        if(index<0||c<0)return false;
        if(c==0)return true;
        

        if(memo[index][c]!=-1)return memo[index][c]==1;

        memo[index][c]=(helper(nums,c,index-1,memo)||helper(nums,c-nums[index],index-1,memo))==1?1:0;
        return memo[index][c]==1;
        
    }
public:
    bool canPartition(vector<int>& nums) {
        int n=nums.size();
        int sum=0;
        for(int i=0;i<n;i++)
        {
            sum+=nums[i];
        }
        if(sum%2!=0)return false;
        //cout<<sum<<endl;
        vector<vector<int>>memo(n,vector<int>(sum/2+1,-1) );
        return helper(nums,sum/2,n-1,memo);
        
    }
};

题解2 动态规划

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int n=nums.size();
        int sum=0;
        for(int i=0;i<n;i++)
        {
            sum+=nums[i];
        }
        if(sum%2!=0)return false;
        vector<bool> ret(sum/2+1,false);
        sum=sum/2;
        //cout<<sum+1<<endl;
        for(int i=0;i<sum+1;i++)
        {
            ret[i]=(nums[0]==i);
            //cout<<i<<endl;
        }
        for(int i=1;i<n;i++)
        {
            for(int j=sum;j>=nums[i];j--)
            {
                //cout<<i<<' '<<j<<endl;
                ret[j]=(ret[j]||ret[j-nums[i]]);
            }
        }
        return ret[sum];
    }
};

322. 零钱兑换

题目描述

在这里插入图片描述

题解1 排序后提前结束

class Solution {//排序过了 提前跳过
public:
    int coinChange(vector<int>& coins, int amount) {
        int MAX=amount+1;
        vector<int> ret(amount+1,MAX);
        sort(coins.begin(),coins.end());
        ret[0]=0;
        for(int i=coins[0];i<amount+1;i++)
        {
            for(int j=0;j<coins.size()&&coins[j]<=i;j++)
            {
               
                ret[i]=min(1+ret[i-coins[j]],ret[i]);
            }
        }
        return ret[amount]==MAX?-1:ret[amount];
    }
};

题解2 没有排序

class Solution {//没有排序
public:
    int coinChange(vector<int>& coins, int amount) {
        vector<int> ret(amount+1,INT_MAX);
        sort(coins.begin(),coins.end());
        ret[0]=0;
        for(int i=coins[0];i<amount+1;i++)
        {
            for(int j=0;j<coins.size()&&coins[j]<=i;j++)
            {
                //cout<<i<<" "<<coins[j]<<endl;
                if(ret[i-coins[j]]==INT_MAX)
                {//cout<<'s'<<endl;
                continue;}
                //cout<<i<<"2"<<coins[j]<<endl;
                ret[i]=min(1+ret[i-coins[j]],ret[i]);
            }
        }
        return ret[amount]==INT_MAX?-1:ret[amount];
    }
};

377. 组合总和 Ⅳ

题目描述

在这里插入图片描述

题解1

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

474. 一和零

题目描述

题解 二维背包问题

139

494

LIS问题

300. 最长上升子序列

题目描述

在这里插入图片描述

题解1 动态规划 以n结尾的最长上升子序列

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n=nums.size();
        if(n==0)return 0;
        vector<int> res(n,1);
        int ret=1;
        for(int i=1;i<n;i++)
        {
            for(int j=0;j<i;j++)           
            {
                if(nums[i]>nums[j])
                {
                    //cout<<'a'<<endl;
                res[i]=max(res[i],res[j]+1);
                }
            }
        }
        
        for(int i=0;i<n;i++)
        {
            ret=max(ret,res[i]);
        }
        return ret;
    }
};

题解2 贪心算法+二分查找 难点在找upper bound

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int len = 1, n = (int)nums.size();
        if (n == 0) return 0;
        vector<int> d(n + 1, 0);
        d[len] = nums[0];
        for (int i = 1; i < n; ++i) {
            if (nums[i] > d[len]) d[++len] = nums[i];
            else{
                int l = 1, r = len, pos = 0; // 如果找不到说明所有的数都比 nums[i] 大，此时要更新 d[1]，所以这里将 pos 设为 0
                while (l <= r) {
                    int mid = (l + r) >> 1;
                    if (d[mid] < nums[i]) {
                        pos = mid;
                        l = mid + 1;
                    }
                    else r = mid - 1;
                }
                d[pos + 1] = nums[i];
            }
        }
        return len;
    }
};

376. 摆动序列

题目描述

在这里插入图片描述

题解1 类似LIS

两个序列 值为以该元素为结尾的 一个是比上一个元素大 （上一个元素比上上个元素小的序列） 另一个是比上一个元素小（上一个元素比上上个元素大）的序列

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        int n=nums.size();
        if(n==0)return 0;
        vector<int> maxres(n,1);
        vector<int> minres(n,1);
        for(int i=1;i<n;i++)
        {
            for(int j=0;j<i;j++)
            {//相等直接跳过
                if(nums[i]>nums[j])
                {
                    maxres[i]=max(maxres[i],minres[j]+1);
                }
                else if(nums[i]<nums[j])
                {
                    minres[i]=max(minres[i],maxres[j]+1);
                }
            }
        }
        int ret=0;
        for(int i=0;i<n;i++)
        {
            ret=max(ret,maxres[i]);
            ret=max(ret,minres[i]);
        }
        return ret;
    }
};
� 晶妹妹
关注
专栏目录
C++之动态规划问题汇总
03-05
### C++ 动态规划问题汇总 #### 一、引言 动态规划（Dynamic Programming，简称 DP）是一种解决多阶段决策过程最优化问题的方法。它适用于具有重叠子问题和最优子结构特性的问题。本篇文章主要针对 LeetCode 中一些...
详解多种动态规划问题，看完必会动态规划
NZXHJ的博客
10-24 7376
如何解决动态规划问题？看完本文总结的解题模板，看完必会动态规划解题
leetcode之动态规划
weixin_47414034的博客
06-23 1956
以爬楼梯问题为例，总结动态规划的步骤：第一步：定义dp数组（可能时一维数组，也可能是二维数组），这一步需要确定两个问题：（1）dp[i]或者dp[i][j]是什么含义（比如在爬楼梯问题中，dp[i]表示到达第i层有多少种爬法）（2）到底开多大的空间，你搞懂了第一个问题dp[i]或者dp[i][j]是什么含义，就知道到底要开多大的空间了，由于在爬楼梯问题中，dp[i]表示到达第i层有多少种爬法，你最后求的是到达第n层所需要的爬法数，所以最后要返回的是dp[n]，所以显然要开n+1大小的数组，这样才能有dp[n
动态规划问题（POJ1579/1458/1088）（C++）
CUGLin的博客
07-13 806
本文主要讲述了算法中的热点问题——动态规划问题（POJ1579/1458/1088）使用了（C++）
【数据结构与算法】之动态规划经典问题
小新要变强的博客
11-11 5765
本文将对【数据结构与算法】动态规划经典问题相关介绍 ，具体将对最长递增子序列问题，找零钱问题，0-1背包问题相关动态规划算法问题进行详尽介绍~
动态规划问题
m0_62404808的博客
02-14 1564
利用动态规划的思想解决问题
Leetcode——动态规划
qq_43332536的博客
09-12 426
leetcode——动态规划
LeetCode 刷题汇总1
08-03
8. 动态规划： * 3Sum（3Sum）：找到数组中三个元素的和等于目标值的元素。 * 3Sum最近（3Sum Closest）：找到数组中三个元素的和最近目标值的元素。 * 4Sum（4Sum）：找到数组中四个元素的和等于目标值的元素。 ...
LeetCode经典算法题汇总
最新发布
08-27
LeetCode经典算法题汇总
leetcode下载-LeetCode:LeetCode刷题汇总
06-29
leetcode下载 我的leetcode刷题原创 项目介绍 本人小媛一枚，喜欢学习，喜欢coding。尤其喜欢算法coding，本项目是小媛刷题原创，分享给大家 说明 leetcode开始刷题很久了，但一直是断断续续地刷，最近感觉基础...
leetcode题目汇总.docx
03-06
这里涉及到了动态规划和栈的概念，可以利用左右两侧的最大高度来计算每个位置能接住的雨水。 10. **二叉树的右视图**：在199题中，我们需要获取二叉树每一层最右边节点的值，形成右视图。这可以使用层次遍历（BFS）...
LeetCode刷题笔记之动态规划（一）
abtgu的博客
03-09 538
LeetCode刷题笔记之动态规划（一）
leetcode-动态规划-python
Greeksilverfir的博客
09-25 277
一、动态规划 动态规划的三要素:最优子结构,边界和状态转移函数, 最优子结构是指每个阶段的最优状态可以从之前某个阶段的某个或某些状态直接得到(子问题的最优解能够决定这个问题的最优解) 边界指的是问题最小子集的解(初始范围) 状态转移函数是指从一个阶段向另一个阶段过度的具体形式,描述的是两个相邻子问题之间的关系(递推式) 重叠子问题,对每个子问题只计算一次,然后将其计算的结果保存到一个表格中,每一次需要上一个子问题解时,进行调用,只要o(1)时间复杂度,准确的说,动态规划是利用空间去换取时间的算法. 判断
leetcode-动态规划总结
许诗宇的博客
09-30 1696
leetcode-70-爬楼梯(climbing trees)-java 爬楼梯的三种解法 1 简单的递归算法 return climbStairs(n-1)+climbStairs(n-2); 速度是o(2^n),速度很慢 2 动态规划，也是备忘录算法 有一个hashmap存放之前得出的值 if(map.containsKey(n)){ return map.get(n); ...
动态规划问题经典例题
dddddrrrzz的博客
02-23 7869
DP（Dynamic Programming）定义： 动态规划是分治思想的延伸，通俗一点来说就是大事化小，小事化无的艺术。在将大问题化解为小问题的分治过程中，保存对这些小问题已经处理好的结果，并供后面处理更大规模的问题时直接使用这些结果。 动态规划具备了以下三个特点： 把原来的问题分解成了几个相似的子问题。 所有的子问题都只需要解决一次。 储存子问题的解 动态规划的本质，是对问题状态的定义和状态转移方程的定义(状态以及状态
【LeetCode】动态规划类题目详解
Clay_Guo的博客
04-11 820
一文学会动态规划算法
动态规划-各种题型及思路整理（自用笔记，大神绕道）
关注网络安全、云原生安全
01-07 9766
简介： 动态规划(dynamic programming，简称dp)，是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。（没办法，其实算法就是数学，毕竟数学是基础学科，由数学支撑的学科太多太多） 分类： 动态规划一般可分为线性动规，区域动规，树形动规，背包动规四类。 举例： 线性动规：拦截导弹，合唱队形，挖地雷，建学校，剑客决斗等； 区...
C++动态规划解题集：爬楼梯与粉刷房子
这个资源是关于C++实现的动态规划问题的汇总，特别针对LeetCode上的常见动态规划题目进行了解答和思路分析，同时提供了模板化的代码结构，对于学习和准备面试非常有帮助。" 动态规划是一种广泛应用于计算机科学和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值