Leetcode 64. Minimum Path Sum

方法1: dfs+memo。时间复杂mn，空间复杂mn。这个复杂度我不确定分析的对不对。

class Solution {
    int m;
    int n;
    int[][] grids;
    Map<Pair<Integer, Integer>, Integer> map = new HashMap<>();
    public int minPathSum(int[][] grid) {
        this.m = grid.length;
        this.n = grid[0].length;
        this.grids = grid;
        return dfs(0, 0);
    }
    
    public int dfs(int i, int j){
        if(map.containsKey(new Pair<>(i, j))) return map.get(new Pair<>(i, j));
        if((i == m && j == n- 1) || (i == m - 1 && j == n))
            return 0;
        if(i >= m || j >= n || i < 0 || j < 0) 
            return Integer.MAX_VALUE;
        int res = grids[i][j] + Math.min(dfs(i, j + 1), dfs(i + 1, j));
        map.put(new Pair<>(i, j), res);
        return res;
    }
}

方法2: 2D-dp。时间复杂mn，空间复杂mn。

class Solution {
    public int minPathSum(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        int[][] dp = new int[m + 1][n + 1];
        for(int[] row : dp) Arrays.fill(row, Integer.MAX_VALUE);
        dp[1][1] = grid[0][0];
        for(int i = 1; i <= m; i++){
            for(int j = 1; j <= n; j++){
                if(i == 1 && j == 1) continue;
                dp[i][j] = grid[i - 1][j - 1] + Math.min(dp[i - 1][j], dp[i][j - 1]);
            }
        }
        return dp[m][n];
    }
}

方法3: dp，no extra space。时间复杂mn，空间复杂1。直接在原数组上修改。方法3和方法2几乎一模一样，这边我就不实现了，直接拿lc的代码，但是lc代码和我的方法2是有一些区别的，它是top down，我是bottom up，但是本质是一样的。

public class Solution {
    public int minPathSum(int[][] grid) {
        for (int i = grid.length - 1; i >= 0; i--) {
            for (int j = grid[0].length - 1; j >= 0; j--) {
                if(i == grid.length - 1 && j != grid[0].length - 1)
                    grid[i][j] = grid[i][j] +  grid[i][j + 1];
                else if(j == grid[0].length - 1 && i != grid.length - 1)
                    grid[i][j] = grid[i][j] + grid[i + 1][j];
                else if(j != grid[0].length - 1 && i != grid.length - 1)
                    grid[i][j] = grid[i][j] + Math.min(grid[i + 1][j],grid[i][j + 1]);
            }
        }
        return grid[0][0];
    }
}

方法4: 方法3虽然没有额外空间，但是会修改原数组，为了不改变原数组，我们必须得使用额外空间。方法4也是用额外空间的，但是和方法2相比，方法4只用row size大小的空间，大大减小了空间复杂度。时间复杂mn，空间复杂n。具体思路直接参考lc官方解答3，自己走一遍代码，还是有一些tricky的。

 public class Solution {
    public int minPathSum(int[][] grid) {
        int[] dp = new int[grid[0].length];
        for (int i = grid.length - 1; i >= 0; i--) {
            for (int j = grid[0].length - 1; j >= 0; j--) {
                if(i == grid.length - 1 && j != grid[0].length - 1) // last row, but not last point
                    dp[j] = grid[i][j] +  dp[j + 1];
                else if(j == grid[0].length - 1 && i != grid.length - 1) // last col, but not last point
                    dp[j] = grid[i][j] + dp[j];
                else if(j != grid[0].length - 1 && i != grid.length - 1)
                    dp[j] = grid[i][j] + Math.min(dp[j], dp[j + 1]);
                else // last point
                    dp[j] = grid[i][j];
            }
        }
        return dp[0];
    }
}