动态规划-经典dp（打家劫舍，股票等）

1.常规dp

1.1 爬楼梯

1.1.1 爬楼梯

 由于求的是组合数，我们将不同路径相加即可

dp定义：
dp[i]为爬到第i阶楼梯的方法数；

转移方程:

dp[i] = dp[i-2] +dp[i-1];

初始化：
 由于涉及到i-2和i-1，那么我们要从i=2开始遍历，因此要初始化dp[0] = 0,dp[1] = 1(根据定义)

遍历顺序：

从左往右 

完整代码：

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

 1.1.2 使用最小花费爬楼梯

 此题和上一题非常类似，只要理解题意就不难

由于是求解最优路径，我们使用min而不是相加，同时我们要理解假如有n层台阶，那么顶层就是顶n+1层（由题意可知）：

1）因此我们设置dp大小为n+1

2）同时初始化时，不要初始化错误，

如果我们认为dp[1]是跳过0 1 两级就错了，会初始化为：

        dp[0] = 0;
        dp[1] = min(cost[0],cost[1]);

实际上dp[1]表示跳到第1级台阶上面的顶层，而dp[0]表示顶层就是地板的下一级

        dp[0] = 0;
        dp[1] = 0;

其实不用专门初始化，dp[i]全为0即可 

其他不多赘述，详细步骤参考下面代码和1.1.1：

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int n = cost.size();
        vector<int> dp(n+1,0);
        dp[0] = 0;
        dp[1] = min(cost[0],cost[1]);
        
         for(int i =2;i <= n;i++){
            dp[i] = min(dp[i- 1]+cost[i-1],dp[i-2]+cost[i-2]);
         }
         return dp[n];
    }
};

1.2  不同路径

1.2.1 不同路径

这样的题显然会第一时间想到dfs，但这里使用dfs会超时，使用备忘录优化的话时间复杂度和dp相同，因此我们直接使用dp来做

dp定义：
这类问题的dp定义很简单，要么就是表示组合数要么就是最优路径，且一般为二维dp

 此题dp[i][j]表示走到（i，j）有多少路径

 转移方程：
转移方程也比较固定，dp[i][j]由dp[i-1][j] 和dp[i][j1]（上面和左边，因为机器人只能这样走）转移过来

此处为：

dp[i][j] = dp[i-1][j]+dp[i][j-1];

初始化：
注意二维dp同时是从左上角往右下角更新，因此，我们要初始化第一行和第一列 ，具体怎么初始化，根据定义即可

此处为：

        for(int i = 0;i < n;i++)dp[i][0] = 1;
        for(int i = 0;i < m;i++)dp[0][i] = 1;

遍历方向：

斜向下

完整代码：

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(n,vector<int>(m,0));

        for(int i = 0;i < n;i++)dp[i][0] = 1;
        for(int i = 0;i < m;i++)dp[0][i] = 1;
        
        for(int i = 1; i < n;i++)
            for(int j = 1;j <m;j++){
                dp[i][j] = dp[i-1][j]+dp[i][j-1];
            }
            return dp[n-1][m-1];
    }
};

1.2.2 不同路径2

核心和上一题相同，注意的点：
1）只有当一个点没有障碍时我们才能更新这个点

2）我们可以从有障碍的点推到无障碍的点，因为有障碍的点路径为0，相当于没有使用，也即是之前的转移方程不用变，加一点限制条件即可：

                if(obstacleGrid[i][j]!=1){
                    dp[i][j] = dp[i-1][j]+dp[i][j-1];
                }

3)初始化时，如果一行里有一个障碍，那么障碍之后都走不通了，也就是第一个障碍及其之后初值都为0

        for(int i =0;i <m;i++){
            if(obstacleGrid[i][0]==0)
                dp[i][0] = 1;
            else if(obstacleGrid[i][0]==1)
                break;
        }
        for(int i =0;i <n;i++){
            if(obstacleGrid[0][i]==0)
                dp[0][i] = 1;
            else if(obstacleGrid[0][i]==1)
                break;
        }

其余没有什么注意点，完整代码如下：

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& ob