Leetcode动态规划系列题解合集(持续更新)

Leetcode动态规划系列题解

写在前面

1、该博文为记录学习算法过程

2、 该博文的题解不一定是最优解，但一定都是测试通过的

3、 相对简单的题只有代码，无解释，代码中基本都无注释(懒)，如有疑问，可私信或评论。

4、 所有代码全部在托管平台上保存，使用可自取。
github地址：https://github.com/MaeStrive/algorithm
gitee地址: 暂时未放

5、预计 更新完成时间：6.9

一、简单题(已完结)

53.最大子数组和

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if(nums.size()==1)
            return nums[0];
        int b=0,sum=0,max0=0xc0c0c0c0;
        for(int i=0;i<nums.size();i++){
            if(nums[i]>max0)
                max0=nums[i];
            if(b>0){
                b+=nums[i];
            }else{
                b=nums[i];
            }
            if(b>sum)
                sum=b;
        }
        if(sum==0)
            return max0;
        return sum;
    }
};

70.爬楼梯

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

118.杨辉三角 1

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> result(numRows);
        int dp[35][35]={0};
        //初始化
        for(int i=1;i<=numRows;i++){
            dp[i][1]=1;
            dp[i][i]=1;        
        }
        for(int i=3;i<=numRows;i++){
            for(int j=2;j<=numRows-1;j++){
                dp[i][j]=dp[i-1][j-1]+dp[i-1][j];
            }
        }
        for(int i=0;i<numRows;i++){
            for(int j=1;j<=i+1;j++){
                result[i].push_back(dp[i+1][j]);
            }
        }
        return result;
    }
};

119.杨辉三角 2

class Solution {
public:
    vector<int> getRow(int rowIndex) {
        vector<int> result;
        int dp[35][35]={0};
        for(int i=0;i<=rowIndex;i++){
                dp[i][i]=1;
                dp[i][0]=1;
        }
        for(int i=2;i<=rowIndex;i++){
            for(int j=1;j<i;j++){
                dp[i][j]=dp[i-1][j-1]+dp[i-1][j];
            }
        }
        for(int j=0;j<=rowIndex;j++)
            result.push_back(dp[rowIndex][j]);
        return result;
    }
};

121.买卖股票的最佳时机

121.详细题解

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

338.比特位计数

338 题目详解

class Solution {
public:

    int count(int i){
        int r=0;
        while(i>0){
            //二进制 运算
            //最低位与1 相与
            if(i&1){
                r++;
            }
            //i右移一位
            i=i>>1;
        }
        return r;
    }
    vector<int> countBits(int n) {
        vector<int> v;
        for(int i=0;i<=n;i++){
            v.push_back(count(i));
        }
        return v;
    }
};

392.判断子序列

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int n = s.length(), m = t.length();
        int i = 0, j = 0;
        while (i < n && j < m) {
            if (s[i] == t[j]) {
                i++;
            }
            j++;
        }
        return i == n;
    }
};

509.斐波那契数

class Solution {
public:
    int fib(int n) {
        int f[35]={0};
        f[0]=0;f[1]=1;
        for(int i=2;i<=n;i++){
            f[i]=f[i-1]+f[i-2];
        }
        return f[n];
    }
};

746.使用最小化花费楼梯

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

1025.除数博弈

此题一言难尽！

class Solution {
public:
    bool divisorGame(int n) {
        return n%2==0;
    }
};

1137.第N个斐波那契额数

class Solution {
public:
    int tribonacci(int n) {
        int f[38]={0};
        f[1]=1,f[2]=1;
        for(int i=3;i<=n;i++)
            f[i]=f[i-1]+f[i-2]+f[i-3];
        return f[n];
    }
};

1646.获取生成数组的最大和

class Solution {
public:
    int getMaximumGenerated(int n) {
        if(n==0)
            return 0;
        int nums[2*100+1000]={0},max_num=1;
        nums[0]=0;nums[1]=1;
        int i=2;
        while(i<=n){
            if(i%2==0){
                nums[i]=nums[i/2];
            }else{
                nums[i]=nums[i/2]+nums[i/2+1];
            }
            if(nums[i]>max_num||nums[i+1]>max_num)
                max_num=max(nums[i],nums[i+1]);
            i++;
        }
        return max_num;
    }
};

LCP 07.传递信息

LCP 07 详解

class Solution {
public:
    int numWays(int n, vector<vector<int>>& relation, int k) {
        int sum=0;
        int dp[105]={0};
        dp[0]=1;
        for(int i=1;i<=k;i++){
          for(int j=0;j<relation.size();j++){
              dp[i][relation[j][1]]+=dp[i-1][relation[j][0]];
          }
        }
        return dp[k][n-1];
    }

};

LCS 01.下载插件

class Solution {
public:
    int leastMinutes(int n) {
        int i=1,time=1;
        while(i<n){
            time++;
            i=i*2;
        }
        return time;
    }
};

剑指 offer 2 003 前n个数组的二进制中1的个数

该题同比特位计数。

class Solution {
public:

    int count(int i){
        int r=0;
        while(i>0){
            //二进制 运算
            //最低位与1 相与
            if(i&1){
                r++;
            }
            //i右移一位
            i=i>>1;
        }
        return r;
    }
    vector<int> countBits(int n) {
        vector<int> v;
        for(int i=0;i<=n;i++){
            v.push_back(count(i));
        }
        return v;
    }
};

剑指 offer 2 088 爬楼梯的最少成本

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        //注意 可以从第一个或者第二个开始 所以他们不需要花费力气就能达到 
        // dp[0]=dp[1]=0'
        int dp[1005]={0};
        for(int i=2;i<=cost.size();i++){
            dp[i]=min(dp[i-1]+cost[i-1],+cost[i-2]+dp[i-2]);
        }
        return dp[cost.size()];
    }
};

剑指 offer 10-1 斐波那契额数列

class Solution {
public:
    int fib(int n) {
        int f[35]={0};
        f[0]=0;f[1]=1;
        for(int i=2;i<=n;i++){
            f[i]=f[i-1]+f[i-2];
        }
        return f[n];
    }
};

剑指 offer 10-2 青蛙跳台问题

class Solution {
public:
    int numWays(int n) {
        int dp[105]={0};
        dp[0]=1;dp[1]=1;
        for(int i=2;i<=n;i++){
            dp[i]=(dp[i-1]+dp[i-2])%1000000007;
        }
        return dp[n];
    }
};

剑指 offer 42.连续子数组的最大和

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        //截止到nums[i](必须包括nums[i])为止的子数组和的最大值
        int b=0;
        //保存子数组和的最大值
        int sum=0;
        //保存最大值
        int max_0=0xc0c0c0c0;
        for(int i=0;i<nums.size();i++){
            if(b>0){
                b+=nums[i];
            }else{
                b=nums[i];
            }
            if(nums[i]>max_0)
                max_0=nums[i];
            if(sum<b)
                sum=b;
        }
        if(sum<=0)
            return max_0;
        return sum;
    }
};

面试题 05.03 翻转数位

05.03 详解

class Solution {
public:
    int reverseBits(int num) {
        //l 记录位数
        //k 记录当前是否可将0变为1
        int l=0,sum=0,k=0,f=0,max_len=0;
        while(l<32){
            //当前位等于1
            if(num&1==1){
                sum++;
            //当前位等于0 但是可以将该0位转成1
            }else if(k==0){
                f=l;
                k++;
                sum++;
            //当前位为0 不能够转成1了,
            }else{
                //更改当前最大值
                sum=l-f;
                f=l;
            }
            //更新最大值
            if(sum>max_len){
                max_len=sum;
            }
            l++;
            num>>=1;
        }
        return max_len;
    }
};

面试题 08.01 三步问题

class Solution {
public:
    int waysToStep(int n) {
        int dp[1000005]={0};
        dp[0]=1;dp[1]=1;dp[2]=2;
        for(int i=3;i<=n;i++){
            dp[i]=((dp[i-1]%1000000007+dp[i-2]%1000000007)%1000000007+dp[i-3]%1000000007)%1000000007;
        }
        return dp[n];
    }
};

面试题 16.17.连续数列

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if(nums.size()==0)
            return 0;
        //以第i个结尾的最大连续和
        int dp[10500000]={0};
        dp[0]=nums[0];
        int sum=dp[0];
        for(int i=1;i<nums.size();i++){
            dp[i]=max(nums[i],nums[i]+dp[i-1]);
            if(dp[i]>sum)
                sum=dp[i];
        }
        return sum;
    }
};

面试题 17.16. 按摩师

打家劫舍的小偷变成了按摩师！

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

二、中等题(正在更新)

5.最长回文子串

经典滑动窗口题目
我记得写过题解啊，竟然没写！！！
看这篇文章吧

class Solution {
public:
    string longestPalindrome(string s) {
        bool dp[1005][1005]={false};
        for(int i=0;i<s.length();i++)
            dp[i][i]=true;
        //最大长度
        int max_len=1,start=0;
        //区间长度   
        int j,i;
        for(int len=2;len<=s.length();len++){
            //左边界i，右边界 j=i+len-1
            for(i=0;i<s.length();i++){
                j=i+len-1;
                if(j>=s.length()){
                    break;
                }
                if(s[i]!=s[j]){
                    //前后不相等
                    dp[i][j]=false;
                }else{
                    //长度<=3
                    if(j-i+1<=3){
                        dp[i][j]=true;
                    }else{
                        //去掉前后两个字符
                        dp[i][j]=dp[i+1][j-1];
                    }
                }
                  //记录
                if(dp[i][j]==true&&j-i+1>max_len){
                    max_len=j-i+1;
                    start=i;
                }
            }
        }
        return s.substr(start,max_len);
    }
};

55.跳跃游戏

这是贪心啊 ！
题目详解

class Solution {
public:
    bool canJump(vector<int>& nums) {
        if(nums.size()==0) return 0;
        //求每个位置能跳到的最大下标
        int jump[100005]={0};
        for(int i=0;i<nums.size();i++) jump[i]=i+nums[i];
        int j=0;
        //当前能跳跃到的最大下标
        int max_index=nums[j];
        //从第一个位置 往后扫描。注意 j<=max_index 防止越界
        while(j<nums.size()&&j<=max_index){
            if(jump[j]>max_index)
                //能跳的更远
                max_index=jump[j];
            j++;
        }
        if(j==nums.size())
            return true;
        else return false;
    }
};

45.跳跃游戏 2

题目详解

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

62.不同路径

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

63.不同路径2

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

64.最小路径和

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int dp[205][205]={0};
        dp[0][0]=grid[0][0];
        int m=grid.size(),n=grid[0].size();
        for(int i=1;i<m;i++)
            dp[i][0]=dp[i-1][0]+grid[i][0];
        for(int j=1;j<n;j++)
            dp[0][j]=dp[0][j-1]+grid[0][j];
        for(int i=1;i<m;i++)
            for(int j=1;j<n;j++)
                dp[i][j]=min(dp[i-1][j],dp[i][j-1])+grid[i][j];
        return dp[m-1][n-1];
    }
};

120.三角形最小路径和

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

122.买卖股票的最佳实际2

又是贪心！

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

198.打家劫舍

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.empty()) return 0;
        int dp[105]={0};
        if(nums.size()==1){
            return nums[0];
        }
        dp[0]=nums[0];dp[1]=max(nums[0],nums[1]);
        if(nums.size()==2){
            return max(dp[0],dp[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];
      return 0;
    }
};

剑指offer 2 090.环形房屋偷盗

详细题解

class Solution {
public:
    int rob_dp(int dp[],vector<int>& nums,int start,int end,int n){
        for(int i=start;i<end;i++){
            dp[i]=max(dp[(i+n-1)%n],dp[(n+i-2)%n]+nums[i]);
        }
        return dp[end-1];
    }
    int rob(vector<int>& nums) {
        if(nums.empty()) return 0;
        int n=nums.size();
        if(n==1){
            return nums[0];
        }
        int dp1[105]={0},dp2[105]={0};
        return max(rob_dp(dp1,nums,0,n-1,n),rob_dp(dp2,nums,1,n,n));   
    }
};

剑指 offer 2 091.粉刷房子

class Solution {
public:
    int minCost(vector<vector<int>>& costs) {
        int dp[105][3]={0};
        dp[0][0]=costs[0][0];
        dp[0][1]=costs[0][1];
        dp[0][2]=costs[0][2];
        for(int i=1;i<costs.size();i++){
            for(int j=0;j<3;j++){
                 dp[i][j]=min(dp[i-1][(j+1)%3],dp[i-1][(j+2)%3])+costs[i][j];
            }
        }     
        return min(min(dp[costs.size()-1][0],dp[costs.size()-1][1]),dp[costs.size()-1][2]);
    }
};

三、困难题(未更新)