LeetCode——算法思想训练（动态规划上）

LeetCode——算法思想训练（动态规划上）

题号目录网址 (只做了部分题)
对应题号到LeetCode搜索

1.动态规划

主要是最优子结构和动态转移方程，动态规划很多情况是近似最优解

70. 爬楼梯（简单题）

// 这是数学
class Solution {
public:
    int climbStairs(int n) {
        double sqrt5 = sqrt(5);
        // 将矩阵M= PA(P-1),A是对角阵
        double fibn = pow((1 + sqrt5) / 2, n + 1) - pow((1 - sqrt5) / 2, n + 1);
        return (int)round(fibn / sqrt5);
    }
};

class Solution {
public:
    int climbStairs(int n) {
        if (n <= 2) return n;
        // pre2是前两步的地方，pre1是前一步的地方
        int pre2 = 1, pre1 = 2, cur;
        for (int i = 2; i < n; ++i) {
        cur = pre1 + pre2;
        pre2 = pre1;
        pre1 = cur;
        }
        return cur;
    }
};

198. 打家劫舍（中等题）

class Solution {
public:
    int rob(vector<int>& nums) {
        int n = nums.size();
        if(n==0) return 0;
        if(n==1) return nums[0];
        int p1=0,p2=0,cur; // 抢劫i-1和i-2房子获得的价值，cur当前最大
        for(int i=0;i<n;++i){
            cur = max(p1,nums[i]+p2);
            p2 = p1;
            p1 = cur;
        }
        return cur;
    }
};

413. 等差数列划分（中等题）

因为每次记录的当前位置的数列个数，所以要把每个位置的个数都加一遍

class Solution {
public:
    int numberOfArithmeticSlices(vector<int>& nums) {
        int n = nums.size();
        if(n<3) return 0;
        vector<int> dp(n,0);
        for(int i=2;i<n;++i){
            if(nums[i]-nums[i-1]==nums[i-1]-nums[i-2]){
                dp[i] = dp[i-1]+1;
            }
        }
        return accumulate(dp.begin(), dp.end(), 0);
    }
};

64. 最小路径和（中等题）

找到动态转移方程

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int m=grid.size(),n=grid[0].size();
        vector<int> dp(n,0);
        for(int i=0;i<m;++i){
            for(int j=0;j<n;++j){
                if(i==0 && j==0){
                    dp[j] = grid[i][j];
                }
                else if(i==0){
                    dp[j] = dp[j-1]+grid[i][j];
                }
                else if(j==0){
                    dp[j] = dp[j]+grid[i][j];
                }
                else{
                    // 第J个位置还没有更新，其实就是等于存放着dp[i-1][j]的值
                    dp[j] = min(dp[j],dp[j-1])+grid[i][j];
                }
            }
        }
        return dp[n-1];
    }
};

542. 01 矩阵（中等题）

class Solution {
public:
    vector<vector<int>> updateMatrix(vector<vector<int>>& mat) {
        if(mat.empty()) return {};
        int n = mat.size(), m = mat[0].size();
        vector<vector<int>> dp(n,vector<int>(m,INT_MAX-1));
        // 从左上角到右下角,只跟上左比较
        for(int i=0;i<n;++i){
            for(int j=0;j<m;++j){
                if(mat[i][j]==0) dp[i][j]=0;
                else{
                    if(i>0) dp[i][j] = min(dp[i][j],dp[i-1][j]+1);
                    if(j>0) dp[i][j] = min(dp[i][j],dp[i][j-1]+1);
                }
            }
        }
        // 从右下角到左上角,跟下右比较
        for(int i=n-1;i>=0;--i){
            for(int j=m-1;j>=0;--j){
                if(mat[i][j]!=0){
                    if(i<n-1) dp[i][j] = min(dp[i][j],dp[i+1][j]+1);
                    if(j<m-1) dp[i][j] = min(dp[i][j],dp[i][j+1]+1);
                }
            }
        }

        return dp;
    }
};

221. 最大正方形（中等题）

主要是和左，上和左上这三个位置比较，如果是正方形，当前位置长是K，那其他三个位置肯定是K-1

class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        if(matrix.empty() || matrix.empty()) return 0;
        int n = matrix.size(), m = matrix[0].size(), max_length=0;
        vector<vector<int>> dp(n+1,vector<int>(m+1,0)); //+1是因为正方形可能是靠右下角
        for(int i=1;i<=n;++i){
            for(int j=1;j<=m;++j){
                if(matrix[i-1][j-1]=='1'){
                    // 主要是和左，上和左上这三个位置比较，如果是正方形，当前位置长是K，
                    // 那其他三个位置肯定是K-1
                    dp[i][j] = min(dp[i-1][j-1],min(dp[i-1][j],dp[i][j-1]))+1;
                }
                max_length = max(dp[i][j],max_length);
            }
        }
        return max_length*max_length;
    }
};

279. 完全平方数（中等题）

class Solution {
public:
    int numSquares(int n) {
        vector<int> dp(n + 1);
        for (int i = 1; i <= n; i++) {
            int minn = INT_MAX;
            for (int j = 1; j * j <= i; j++) {
            	// 这里是动态转移方程
                minn = min(minn, dp[i - j * j]);
            }
            dp[i] = minn + 1;
        }
        return dp[n];
    }
};

300. 最长递增子序列（中等题）

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

1143. 最长公共子序列（中等题）

跟上面那题相比，主要是两个数列，因此用二维数组

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int n = text1.size(), m = text2.size();
        vector<vector<int>> dp(n+1,vector<int>(m+1,0));
        for(int i=1;i<=n;++i){
            for(int j=1;j<=m;++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[n][m];
    }
};

总结

动态规划，最主要是找最优子结构以及动态转移方程，目前这些较简单些，且题目可以用其他方法也可以解决，下面准备写背包等较经典的动态规划题目。