Leetcode64最小路径和（暴力递归转动态规划）

递归版本：

class Solution {
    public int minPathSum(int[][] grid) {
        //一共三种情况，左右都可以，只能左，只能有
        int m=grid.length;
        int n=grid[0].length;
        return  dfs(grid,0,0,m,n);
    }
    public int dfs(int[][] grid,int x,int y,int m,int n){
        int temp=grid[x][y];
        if(x==m-1&&y==n-1){
            return grid[x][y];
        }
        if((x+1)<m&&(y+1)<n){
            return temp+(Math.min(dfs(grid,x+1,y,m,n),dfs(grid,x,y+1,m,n)));
        }
        if(x==m-1){
            return temp+dfs(grid,x,y+1,m,n);
        }
            return temp+dfs(grid,x+1,y,m,n);
      
    }
}

动态规划版本：改动态规划首先就要写出暴力递归，暴力递归一般会超时，这个时候改动态规划，该动态规划就是建立几维表，如果两个可变参数就是二维表，如果是多个就是多维表，最重要的两个点给你的开始点以及暴力递归的结束点（结束状态一般是定值），条件先看basecase，然后再看调用本身的条件

class Solution {
    public int minPathSum(int[][] grid) {
        if(grid.length==0||grid[0].length==0) return 0;
        int m=grid.length;
        int n=grid[0].length;
        //所求：grid[0][0]
        //先求最后两列
        //最后一列
        int[][] dp=new int[m][n];//dp表
        dp[m-1][n-1]=grid[m-1][n-1];
        for(int i=m-2;i>=0;i--) dp[i][n-1]=dp[i+1][n-1]+grid[i][n-1];
        //最后一行
        for(int i=n-2;i>=0;i--) dp[m-1][i]=dp[m-1][i+1]+grid[m-1][i];
        //其余部分的dp
        for(int i=m-2;i>=0;i--) for(int j=n-2;j>=0;j--) dp[i][j]=Math.min(dp[i+1][j],dp[i][j+1])+grid[i][j];
        return dp[0][0];
    }      
}