各种类型题目总结--动态规划(更新中）-CSDN博客

本文解析了最长递增子序列、杨辉三角等经典动态规划问题的解决方案，通过代码示例详细说明了每种问题的算法实现，为读者提供了一个深入理解动态规划思想的学习资源。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

思路：

dp[i]表示前i个元素中，到dp[i]的最大上升序列数

dp[i]=max(dp[i],dp[j]+1)

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> dp(nums.size(),1);
        if(nums.size()==1){
            return 1;
        }
        int ans=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]>ans){
                ans=dp[i];
            }
        }
        return ans;
    }
};

杨辉三角

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> v(numRows);
        for(int i=0;i<numRows;i++){
            v[i].resize(i+1);
            v[i][0]=1;
            v[i][i]=1;
            for(int j=1;j<i;j++){
                v[i][j]=v[i-1][j]+v[i-1][j-1];
            }
        }
        return v;
    }
};

杨辉三角 II

class Solution {
public:
    vector<int> getRow(int rowIndex) {
        vector<vector<int>> dp(rowIndex + 1, vector<int>(rowIndex + 1, 0));
        dp[0][0] = 1;
        for (int row = 1; row <= rowIndex; row++) {
            for (int col = 0; col <= row; col++) {
                if (col == 0) {
                    dp[row][col] = 1;
                } else if (col == row) {
                    dp[row][col] = 1;
                } else {
                    dp[row][col] = dp[row - 1][col - 1] + dp[row - 1][col];
                }
            }
        }
        return dp[rowIndex];
    }
};

不同路径

挺容易的不多说

class Solution {
public:
    int uniquePaths(int m, int n) {
        int dp[m+1][n+1];
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(i==1||j==1){
                    dp[i][j]=1;
                }
                else{
                    dp[i][j]=dp[i-1][j]+dp[i][j-1];
                }
            }
        }
        return dp[m][n];
    }
};

不同路径 II

就是多个障碍物罢了，直接遇到障碍物那个点的dp就是0就可，不难

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        int dp[m][n];
        memset(dp,0,sizeof(dp));
        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];
    }
};

完全平方数

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

思路：转移方程其实不算很难推，但是刚开始往递推上想了，结果没写出来。