1--动态规划理论基础

动态规划经典问题：① 背包问题；② 打家劫舍；③ 股票问题； ④ 子序列问题；

动态规划五部曲：

        ① 确定 dp 数组及其下标的含义；

        ② 确定递推公式；

        ③ 确定 dp 数组的初始化；

        ④ 确定遍历顺序，一般为从左到右；

        ⑤ 打印 dp 数组，一般用于检查；

2--斐波那契数

主要思路：

        经典动态规划，dp[i] 表示第 i 个数的斐波那契数；递推公式为：dp[i] = dp[i-1] + dp[i - 2]；初始化dp[0] = 1，dp[1] = 1；遍历顺序从左到右；

#include <iostream>
#include <vector>

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

int main(int argc, char argv[]){
    int test = 2;
    Solution S1;
    int res = S1.fib(test);
    std::cout << res << std::endl;
    return 0;
}

3--爬楼梯

主要思路：

        经典动态规划，dp[i] 表示到达第 i 阶楼梯的方法数；递推公式为 dp[i] = dp[i - 1] + dp[i - 2]；初始化dp[1] = 1, dp[2] = 2；遍历顺序从左到右；

#include <iostream>
#include <vector>

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

int main(int argc, char argv[]){
    int n = 2;
    Solution S1;
    int res = S1.climbStairs(n); 
    std::cout << res << std::endl;
    return 0;
}

4--使用最小花费爬楼梯

主要思路：

        dp[i] 表示到达第 i 阶楼梯需要的最小花费；初始化 dp[0] = 0, dp[1] = 0，因为可以从 0 和 1 出发，因此不需要花费；递推公式为 dp[i] = std::min(dp[i-1] + cost[i-1], dp[i-2] + cost[i-2])；默认从左到右遍历；

#include <iostream>
#include <vector>

class Solution {
public:
    int minCostClimbingStairs(std::vector<int>& cost) {
        std::vector<int> dp(cost.size()+1, 0); // 到达第i阶的最小花费
        dp[0] = 0;
        dp[1] = 0;
        for(int i = 2; i <= cost.size(); i++){
            dp[i] = std::min(cost[i-2]+dp[i-2], cost[i-1]+dp[i-1]);
        }
        return dp[cost.size()];
    }
};

int main(int argc, char argv[]){
    // cost = [1,100,1,1,1,100,1,1,100,1]
    std::vector<int> cost = {1, 100, 1, 1, 1, 100, 1, 1, 100, 1};
    Solution S1;
    int res = S1.minCostClimbingStairs(cost);
    std::cout << res << std::endl;
    return 0;
}

5--不同路径

主要思路：

        dp[i][j] 表示到达 (i, j) 位置的路径数，初始化两个边界 dp[i][0] = 1，dp[0][j] = 1；状态转移方程为：dp[i][j] = dp[i-1][j] + dp[i][j-1]；遍历顺序为从上到下，从左到右；

#include <iostream>
#include <vector>

class Solution {
public:
    int uniquePaths(int m, int n) {
        std::vector<std::vector<int>> dp(m, std::vector<int>(n, 0));
        // 初始化
        for(int i = 0; i < m; i++) dp[i][0] = 1;
        for(int j = 0; j < n; j++) dp[0][j] = 1;
        // 遍历
        for(int r = 1; r < m; r++){
            for(int c = 1; c < n; c++){
                dp[r][c] = dp[r-1][c] + dp[r][c-1];
            }
        }
        return dp[m-1][n-1];
    }
};

int main(int argc, char argv[]){
    // m = 3, n = 7
    int m = 3, n = 7;
    Solution S1;
    int res = S1.uniquePaths(m, n);
    std::cout << res << std::endl;
    return 0;
}

6--不同路径II

主要思路：

        与上题类似，dp[i][j] 表示到达 (i, j) 位置的路径数，初始化两个边界 dp[i][0] = 1，dp[0][j] = 1（确保边界没有障碍物，有障碍物初始化为0）；状态转移方程为：(i, j)不是障碍物则 dp[i][j] = dp[i-1][j] + dp[i][j-1]，(i, j)为障碍物则dp[i][j] = 0；遍历顺序为从上到下，从左到右；

#include <iostream>
#include <vector>

class Solution {
public:
    int uniquePathsWithObstacles(std::vector<std::vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size(), n = obstacleGrid[0].size();
        if(obstacleGrid[m-1][n-1] == 1) return 0;
        
        std::vector<std::vector<int>> dp(m, std::vector<int>(n, 0));
        // 初始化
        for(int i = 0; i < m && obstacleGrid[i][0] != 1; i++) dp[i][0] = 1;
        for(int j = 0; j < n && obstacleGrid[0][j] != 1; j++) dp[0][j] = 1;
        // 遍历
        for(int r = 1; r < m; r++){
            for(int c = 1; c < n; c++){
                if(obstacleGrid[r][c] == 1) dp[r][c] = 0; // 障碍
                else dp[r][c] = dp[r-1][c] + dp[r][c-1];
            }
        }
        return dp[m-1][n-1];
    }
};

int main(int argc, char argv[]){
    // obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
    std::vector<std::vector<int>> test = {{0, 0, 0}, {0, 1, 0}, {0, 0, 0}};
    Solution S1;
    int res = S1.uniquePathsWithObstacles(test);
    std::cout << res << std::endl;
    return 0;
}

7--整数拆分

主要思路：

        dp[i] 表示整数 i 拆分后的最大乘积；初始化dp[0] = 0, dp[1] = 0, dp[2] = 1; 状态转移方程为：dp[i] = max(dp[i], max(j*(i-j), j * dp[i-j]))；

#include <iostream>
#include <vector>

class Solution {
public:
    int integerBreak(int n) {
        std::vector<int> dp(n+1, 0);
        // 初始化
        dp[0] = 0, dp[1] = 0, dp[2] = 1;
        // 遍历
        for(int i = 3; i <= n; i++){
            for(int j = 0; j <= i/2; j++){
                dp[i] = std::max(dp[i], std::max(j*(i-j), j * dp[i-j]));
            }
        }
        return dp[n];
    }
};

int main(int argc, char argv[]){
    // n = 10
    int test = 10;
    Solution S1;
    int res = S1.integerBreak(test);
    std::cout << res << std::endl;
    return 0;
}

8--不同的二叉搜索树

主要思路：

        dp[i] 表示由 i 个数字构成的不同二叉搜索树的数目；

        初始化：dp[0] = 1；

        状态转移方程：dp[i] += dp[j-1] * dp[i-j]，0 <= j <= i；其中 dp[j-1] 来构成 j 的左子树，dp[i-j] 来构成 j 的右子树；

         遍历顺序：两个 for 循环，第 1 个 for 循环遍历 1 - n，第二个 for 循环遍历 1 - i；

#include <iostream>
#include <vector>

class Solution {
public:
    int numTrees(int n) {
		std::vector<int> dp(n+1, 0);
		// 初始化
		dp[0] = 1;
		// 遍历
		for(int i = 1; i <= n; i++){
			for(int j = 1; j <= i; j++){
				dp[i] += dp[j-1] * dp[i-j];
			}
		}
		return dp[n];
    }
};

int main(int argc, char *argv[]) {
	// n = 3
	int test = 3;
	Solution S1;
	int res = S1.numTrees(test);
	std::cout << res << std::endl;
	return 0;
}

9--