Day40 LeetCode 509. 斐波那契数 70. 爬楼梯 746. 使用最小花费爬楼梯 62. 不同路径 63. 不同路径 II

 动态规划：

        题目分为五大部分：基础问题、背包问题、打家劫舍、股票问题、子序列问题

        解题五部曲：

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

题目：509. 斐波那契数 - 力扣（LeetCode）

思路：

        dp[i] 表示第i个数的斐波那契数值大小，递推公式dp[i] = dp[i - 1] + dp[i - 2]，初始化dp[0] = 0，dp[1] = 1，遍历顺序从前往后，因为后面的数需要根据前面的数之和才能得到。

代码：

class Solution {
public:
    int fib(int n) {
        if(n == 0 || n == 1) return n;
        //dp[i] 第i个数的斐波那契数值
        vector<int> dp(n + 1);
        //dp初始化
        dp[0] = 0;
        dp[1] = 1;
        for(int i = 2; i <= n; i++){
            dp[i] = dp[i - 1] + dp[i - 2]; //dp递推公式
        }
        return dp[n];
    }
};

题目：70. 爬楼梯 - 力扣（LeetCode）

思路：

        dp[i]表示爬到第i层楼梯的方法数，题目明确一次可以爬 1个或者2个阶梯，那么爬到第i - 1层楼梯再爬1个阶梯就到了第i层或者爬到第i - 2层楼梯再爬2个阶梯就到了第i层，因此dp递推公式

就是dp[i] = dp[i - 1] + dp[i - 2]，表示爬到第i层楼梯的方法数等于爬到第i -1层楼梯的方法数加上爬到第i - 2层楼梯的方法数。

代码：

class Solution {
public:
    int climbStairs(int n) {
        //dp[i]含义：爬到第i层楼梯的方法数
        vector<int> dp(n + 1);
        if(n <= 2) return n;
        //dp初始化
        dp[1] = 1;
        dp[2] = 2;

        for(int i = 3; i <= n; i++){
            dp[i] = dp[i - 1] + dp[i - 2];//dp递推公式
        }
        return dp[n];
    }
};
//时间复杂度：O(n)
//空间复杂度：O(n)

优化：空间复杂度O(n)优化成O(1)

class Solution {
public:
    int climbStairs(int n) {
        //dp[i]含义：爬到第i层楼梯的方法数
        vector<int> dp(n + 1);
        if(n <= 2) return n;
        //dp初始化
        dp[1] = 1;
        dp[2] = 2;

        for(int i = 3; i <= n; i++){
            //状态转移
            int sum = dp[1] + dp[2];
            dp[1] = dp[2];
            dp[2] = sum;
        }
        return dp[2];
    }
};
//时间复杂度：O(n)
//空间复杂度：O(1)

题目：746. 使用最小花费爬楼梯 - 力扣（LeetCode）

思路：注意本题题意，如果楼梯阶层是n，爬到楼顶是指爬到n + 1层，因此 i = cost.size()

        dp[i] 表示爬到第i层的最小花费。题目说可以爬一层或两层，那么爬到第i层的最小花费是等于（爬到第i - 1层的最小花费 + 从第 i - 1层爬到i层的花费） 与 （爬到第i - 2层的最小花费 + 从第 i - 2层爬到i层的花费）这两者之间的最小值。

dp递推公式：dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2])  dp初始化：dp[0] = 0, dp[1]  = 0,题目明确可以从第0层或者第1层开始爬，只有往上爬才花费。

代码：
 

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        vector<int> dp(cost.size() + 1, 0);
        dp[0] = 0;
        dp[1] = 0;
        for(int i = 2; i <= cost.size(); i++){//注意i == cost.size() 因为要爬到楼顶，因此i要比cost数组中的台阶数多一
            dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
        }
        return dp[cost.size()];
    }
};

题目：62. 不同路径 - 力扣（LeetCode）

思路：

        dp[i][j]表示从（0，0）位置走到（i，j）位置路径数总和。

        因为只能往右走或者往下走，那么第1行和第1列上的位置路径数都只有一种方法，因此初始化为1。dp递推公式：dp[i][j] = dp[i][j - 1] + dp[i - 1][j]，要走到（m，n) 的位置，最后返回dp[m - 1][n - 1]就行。

代码：

class Solution {
public:
    int uniquePaths(int m, int n) {
        int dp[m][n];
        for(int i = 0; i < n; i++){
            dp[0][i] = 1;
        }
        for(int j = 0; j < m; j++){
            dp[j][0] = 1;
        }
        //从左向右遍历，再从上往下遍历（保证上一行和前一列都有值）
        for(int i = 1; i < m; i++){
            for(int j = 1; j < n; j++){
                //(i, j - 1)的位置向右走一步或者（i - 1, j)的位置向下走一步
                //走到(i,j)
                dp[i][j] = dp[i][j - 1] + dp[i - 1][j];
            }
        }
        return dp[m - 1][n - 1];
    }
};

 题目：63. 不同路径 II - 力扣（LeetCode）

思路：

         dp[i][j]表示从（0，0）位置走到（i，j）位置路径数总和。因为只能往右走或者往下走，那么第1行和第1列上的位置路径数都只有一种方法，但是因为可能会有障碍物在第一行或者第一列上，一旦有的话，在第一行或者第一列上的障碍物后的位置都不能到达，dp[i][j]都为0，因此障碍物之前dp都为1，之后都为0。

        dp递推公式：dp[i][j] = dp[i][j - 1] + dp[i - 1][j]，注意代码里for循环的终止条件，一旦遇到obstacleGrid[i][0] == 1的情况就跳过（等价于将这个位置dp赋值为0），然后继续下一个位置的dp赋值。

代码：
 

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        vector<vector<int>> dp(m, vector<int>(n, 0));//初始化为0
        //如果左上角或者右下角有障碍物，直接返回0
        if(obstacleGrid[0][0] == 1 || obstacleGrid[m - 1][n - 1] == 1) return 0;
        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] = 0，即到达(i,j)这个点的路径和为0，因为dp已经初始化为0了，所以不需要赋值为0，直接continue
                dp[i][j] = dp[i][j - 1] + dp[i - 1][j];//未遇到障碍物直接统计路径和
            }
        }
        return dp[m - 1][n - 1];
    }
};