动态归化题总结

一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。

class Solution {
public:
    int numWays(int n) {
        
        if(n==0)
            return 1;
        if(n==1)
            return 1;
        if(n==2)
            return 2;
        int* dp = new int [n+1];
        dp[0] = 1;
        dp[1] = 1;  
        dp[2] = 2;
        for(int i=3;i<=n;i++) {
            dp[i] = (dp[i-1] + dp[i-2]);
        }
        return dp[n];
    }
};

注意事项：
1.初始化里的dp[2] = 2;是为了解决当dp[0] != 1(不同的题目要求可能会不一样);
2.new int[n+1],一定要多new一个元素；
3.第一次写的时候写，for循环进而写成了dp[n] = (dp[n-1] + dp[n-2]);弱智错误调试了半天，如果面试的时候发生了这种情况，算是与公司无缘吧。。

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

示例 1：

输入：m = 3, n = 7
输出：28

示例 2：

输入：m = 3, n = 2
输出：3
解释：
从左上角开始，总共有 3 条路径可以到达右下角。

1. 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右
3. 向下 -> 向右 -> 向下

示例 3：

输入：m = 7, n = 3
输出：28

示例 4：

输入：m = 3, n = 3
输出：6

提示：

1 <= m, n <= 100
题目数据保证答案小于等于 2 * 109

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/unique-paths

class Solution {
public:
    int uniquePaths(int m, int n) {
        std::vector<std::vector<int>> dp;
        dp.resize(m);
        for(int i =0; i < m; i++) {
            dp[i].resize(n);
        }
        for(int i = 0;i<n;i++) {
            dp[0][i] = 1;
        }
        
        for(int i = 0;i<m;i++) {
            dp[i][0] = 1;
        }
        for(int i=1;i<m;i++) {
            for(int j=1;j<n;j++) {
                dp[i][j] = dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
};

注意事项：
1.初始化时要注意，初始值是1，第一写的时候，我初始化成了0
2.网上的代码错误提示，基本上是不可调试的。。
比如越界访问的错误提示是：
Line 1034: Char 34: runtime error: addition of unsigned offset to 0x607000000020 overflowed to 0x607000000008 (stl_vector.h)
SUMMARY: UndefinedBehaviorSanitizer: undefined-behavior /usr/bin/…/lib/gcc/x86_64-linux-gnu/9/…/…/…/…/include/c++/9/bits/stl_vector.h:1043:34

总结：
0，找到dp[i]的定义
1，找递推公式
2.找初始条件
动态规划是一种从前往后找的方法，无法一下子求出n，只能先求n－1

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

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

示例 1：

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

示例 2：

输入：grid = [[1,2,3],[4,5,6]]
输出：12

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-path-sum

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {

        if(grid.empty())
            return 0;
        if(grid[0].empty())
            return 0;
        int m = grid.size();
        int n = grid[0].size();
        vector<vector<int>> dp;
        dp.resize(m);
        for(int i=0;i<m;i++) {
            dp[i].resize(n);
        }
        

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

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

注意：
二维数组的初始化，要每一行都初始化到
或者用new int[m][n]