【算法/动态规划/基础题目】题解+详细备注（共7题）

动态规划解题步骤

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

509.斐波那契数

class Solution {
public:
    int fib(int n) {
        if(n <= 1) return n;
        // 1.确定dp数组以及下标的含义
        // dp[i]的定义是：第i个数的斐波那契数值是dp[i]
        vector<int> dp(n+1);
		
		// 3.dp数组初始化
        dp[0] = 0;
        dp[1] = 1;
        
        // 4.遍历顺序，从前往后遍历
        for(int i = 2;i<=n;++i){
        	// 2.确定递推公式：dp[i] = dp[i-1] + dp[i-2];
            dp[i] = dp[i-1]+dp[i-2];
        }
		// 5.举例推导
        return dp[n];
    }
};

70.爬楼梯

class Solution {
public:
    int climbStairs(int n) {
    	// 1.确定dp数组以及下标的含义
    	// dp[i] 表示爬i阶楼梯一共右dp[i]种不同的方法
        vector<int> dp(n+1);
		// 3.dp数组的初始化
        dp[0] = 0;
        dp[1] = 1;
        if(n > 1) dp[2] = 2;
        // 4.确定遍历顺序，从前向后遍历
        for(int i = 3;i<=n;++i){
        	// 2.确定递推公式:dp[i] = dp[i-1] + dp[i-2]
            dp[i] = dp[i-1] + dp[i-2];
        }

        return dp[n];
        // 5.举例推导dp数组
    }
};

746.使用最小花费爬楼梯

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int n = cost.size();
		// 1.确定dp数组以及下标的含义
		// dp[i]表示：到达第i个台阶所需要花费的最小体力值dp[i]
		// 3.dp数组的初始化
        vector<int> dp(n);
        dp[0] = cost[0];
        dp[1] = cost[1];
		// 4.确定遍历顺序
        for(int i = 2;i<n;++i){
        	// 2.确定递推公式：dp[i] = min(dp[i-1],dp[i-2]) + cost[i];
            dp[i] = min(dp[i-1],dp[i-2]) + cost[i];
        }
		// 5.举例推导dp数组
		
		// 返回值很重要，到达楼梯顶部的选择有两种：从n-1爬上来和n-2爬上来
        return min(dp[n-1],dp[n-2]);
    }
};

62.不同路径

class Solution {
public:
    int uniquePaths(int m, int n) {
    	// 1.确定dp数组以及下标的含义
    	// dp[i][j]表示从（0，0）到（i，j）有dp[i][j]种不同的路径
        vector<vector<int>> dp(m,vector<int>(n));
		// 3.dp数组初始化
        for(int i{};i<m;++i) dp[i][0] = 1;
        for(int i{};i<n;++i) dp[0][i] = 1; 
		
		// 4.确定遍历顺序，从左到右，从上到下
        for(int i{1};i<m;++i){
            for(int j{1};j<n;++j){
            	// 2.确定递推公式：dp[i][j] = dp[i-1][j] + dp[i][j-1]
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
		
        return dp[m-1][n-1];
        // 5.举例推导
    }
};

63.不同路径II

class Solution {
public:
	// 与62.不同路径相比，处理障碍问题即可
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        // 1.确定dp数组以及下标的含义
    	// dp[i][j]表示从（0，0）到（i，j）有dp[i][j]种不同的路径
        vector<vector<int>> dp(m,vector<int>(n));

		// 3.dp数组初始化
        for(int i{};i<m && obstacleGrid[i][0] == 0;++i){
            dp[i][0] = 1;
        }

        for(int j{};j<n && obstacleGrid[0][j] == 0;++j){
            dp[0][j] = 1;
        }
		// 4.确定遍历顺序，从左到右，从上到下
        for(int i{1};i<m;++i){
            for(int j{1};j<n;++j){
                if(obstacleGrid[i][j] == 0){
                	// 2.确定递推公式：dp[i][j] = dp[i-1][j] + dp[i][j-1]
                    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) {
    	// 1.确定dp数组以及下标的含义
    	// dp[i]:分拆数字i，可以得到的最大乘积为dp[i]
        vector<int> dp(n+1);
        // 3.dp数组初始化（根据题意dp[0] 与 dp[1]的初始化意义不大）
        dp[2] = 1;
        // 4.确定遍历顺序 从小到大获取dp[i]
        for(int i = 3;i<=n;++i){
            for(int j = 1;j<i-1;++j){
            	// 2.确定递推公式 (i-j)*j表示拆分成了两个数  j*dp[i-j]表示拆分成了 2个以上的数
            	// dp[i] = max(dp[i],max((i-j)*j,j*dp[i-j]))
                dp[i] = max(dp[i],max((i-j)*j,j*dp[i-j]));
            }
        }

        return dp[n];
    }
};

96.不同的二叉搜索树

class Solution {
public:
    int numTrees(int n) {
    	// 1.确定dp数组以及下标的含义
    	// dp[i]:1到i为节点组成的二叉搜索树的个数为dp[i]
        vector<int> dp(n+1);
        // 3.dp数组的初始化，0个节点的数量为1
        dp[0] = 1;
        // 4.确定遍历顺序
        for(int i = 1;i<=n;++i){
            for(int j = 1;j<=i;++j){
            	// 2.确定递推公式：dp[i]+= dp[j-1]*dp[i-j]
            	// j-1为j为头节点左子树节点数量、i-j为j为头节点右子树的数量
                dp[i] += dp[j-1]*dp[i-j];
            }
        }
		// 5.举例推导dp数组
        return dp[n];
    }
};