动态规划 70.climbing Stairs ，120，64

1. 记忆化搜索 - 自上向下的解决问题：使用vector来保存每次计算的结果，如果下次再碰到同样的需要计算的式子就不需要重复计算了。

2. 动态规划 - 自下向上的解决问题

 解法一：自顶向下

解法二：自底向上

class Solution {

private:
    vector<int> memo;
    
    int calcWays(int n){
        
        if(n==0) return 1;   //一个台阶都没有
        if(n==1) return 1;
        //if(n==2) return 2; //有两种解决方法：一次迈一步，迈两次；一次迈两步
        if(memo[n] == -1)
            memo[n] = calcWays(n-1) + calcWays(n-2);  
        //在第n-1阶台阶迈一步或者在第n-2阶台阶迈两步
        return memo[n];
    }
    
public:
    int climbStairs(int n) {
        //n为台阶数
        memo = vector<int>(n+1,-1);   //memo初始化为n+1个-1
        return calcWays(n);
    }
};

class Solution {
    
public:
    int climbStairs(int n) {
        //n为台阶数
        vector<int> memo(n+1,-1);   //memo初始化为n+1个-1
        memo[0] = memo[1] = 1;
        for(int i=2;i<=n;i++)
            memo[i] = memo[i-1] + memo[i-2];
        return memo[n];
    }
};

注意：从2只能移动到3和4；从3只能移动到6和5.

思路：设从位置（i,j）达到底部的最小路径和为MP(i,j)；根据约束条件，从位置（i,j）只能达到下一行的（i+1,j）和（i+1,j+1）两个位置；

 前面的思路是自顶向下的，如果采用自底向上的求解思路，最后的sum[0]是要的结果。可以申请一个一维数组初始化为三角形数阵底部向量，逐步向上计算更新，空间复杂度为O(n)

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int length = triangle.size();
        if(length==0) return 0;
        if(length==1) return triangle[0][0];
        vector<int> sum = triangle[length-1];   //初始化sum为三角形底部的向量
        
        for(int i=length-2;i>=0;i--){
            for(int j=0;j<triangle[i].size();j++)
                sum[j] = min(triangle[i][j]+sum[j], triangle[i][j]+sum[j+1]);
        }
        
        return sum[0];
    }
};

这个解法是重做了一遍题想到的，感觉比上一个解法有点麻烦，还容易索引溢出。

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        if(triangle.empty()) return 0;
        int row = triangle.size();
        int column = triangle[row-1].size();
        int dp[row][column+1];
        for(int i=0; i<row; i++){
            for(int j=0; j<column+1; j++){
                dp[i][j] = INT_MAX;
            }
        }
        dp[0][1] = triangle[0][0];
        
        for(int i = 1; i < row; i++){
            for(int j=1; j<=i+1; j++){
                
                dp[i][j] = min(dp[i-1][j-1], dp[i-1][j]) + triangle[i][j-1];
            }
        }
        
        sort(dp[row-1], dp[row-1]+column+1);
        return dp[row-1][0];
    }
};

题目：给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：每次只能向下或者向右移动一步。

示例:

输入:
[[1,3,1],
[1,5,1],
[4,2,1]]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。

思路

以输入为 3*3 的网格为例，其中 m=3，n=3
[1,3,1]
[1,5,1]
[4,2,1]
由于每次只能向下或者向右移动，则每一步结果为当前值＋min(上边一步，左边一步)，即 dp[i][j] = grid[i][j] + min(dp[i-1][j], dp[i][j-1])

注意：不要忘记dp[0][0]的初始化。

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        if(grid.size() == 0) return 0;
        int m = grid.size();
        int n = grid[0].size();
        int dp[m][n];   //m行n列的一个二维数组
        dp[0][0] = grid[0][0];
        //初始化边界
        for(int i = 1; i<m; i++){
            dp[i][0] = grid[i][0] + dp[i-1][0];   //最左边一列的值只能是当前格子+上面一个
        }
        for(int i=1;i<n;i++){
            dp[0][i] = grid[0][i] + dp[0][i-1];   //最上面一行的值只能是当前格子+左边一个
        }
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++)
                dp[i][j] = grid[i][j] + min(dp[i-1][j], dp[i][j-1]);
        }
        
        return dp[m-1][n-1];
    }
};

 解法二：又做了一遍，自己想出来了思路

1）设置一维数组 dp[i] 为 当前行存储的到该索引的最小和；

2）初始化dp为grid的第一行，即  dp[0] = grid[0][0]; 然后接下来dp[i] = dp[i-1] + grid[0][i];

3) 状态方程：dp[j] = min(dp[j-1]+grid[i][j], dp[j]+grid[i][j]); //取左边或上面到该索引的最小值

4）dp最左边一列只能从上面走到。

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int n = grid.size();
        int m = grid[0].size();
        int dp[m] = {};
        dp[0] = grid[0][0];
        for(int i=1; i<m;i++){
            dp[i] = dp[i-1] + grid[0][i];
            
        }
        
        for(int i=1; i<n; i++){
            for(int j=0; j<m ; j++){
                if(j==0)
                    dp[j] = dp[j] + grid[i][j];
                else{
                    dp[j] = min(dp[j-1]+grid[i][j], dp[j]+grid[i][j]);
                }
            }
        }
        return dp[m-1];
    }
};