LeetCode: Minimum Path Sum 解题报告

Minimum Path Sum

Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.

Note: You can only move either down or right at any point in time.

SOLUTION 1:

相当基础的DP题目：

This is a simple DP.
表达式：  D[i][j]: 从左下到本点的最小值
递推公式: D[i][j] = Math.mn(D[i - 1][j], D[i][j - 1]) + grid[i][j]
初始化：  D[i][j] = grid[i][j].

终止条件：到达终点

 // Solution 1: DP
     public int minPathSum1(int[][] grid) {
         if (grid == null || grid.length == 0 || grid[0].length == 0) {
             return 0;
         }

         int rows = grid.length;
         int cols = grid[0].length;
         int[][] D = new int[rows][cols];

         // This is a simple DP.
         // 表达式：  D[i][j]: 从左下到本点的最小值
         // 递推公式: D[i][j] = Math.mn(D[i - 1][j], D[i][j - 1]) + grid[i][j]
         // 初始化：  D[i][j] = grid[i][j].
         for (int i = 0; i < rows; i++) {
             for (int j = 0; j < cols; j++) {
                 D[i][j] = grid[i][j];

                 if (i == 0 && j != 0) {
                     D[i][j] += D[i][j - 1];
                 } else if (j == 0 && i != 0) {
                     D[i][j] += D[i - 1][j];
                 } else if (i != 0 && j != 0) {
                     D[i][j] += Math.min(D[i][j - 1], D[i - 1][j]);
                 }
             }
         }

         return D[rows - 1][cols - 1];
     }

SOLUTION 2:

使用DFS + Memory也可以解决问题。当前到终点有2种方式，往右，往下，两种路线，取一个较小的路线就行了。

 public class Solution {
     // Solution 1: DP
     public int minPathSum1(int[][] grid) {
         if (grid == null || grid.length == 0 || grid[0].length == 0) {
             return 0;
         }

         int rows = grid.length;
         int cols = grid[0].length;
         int[][] D = new int[rows][cols];

         // This is a simple DP.
         // 表达式：  D[i][j]: 从左下到本点的最小值
         // 递推公式: D[i][j] = Math.mn(D[i - 1][j], D[i][j - 1]) + grid[i][j]
         // 初始化：  D[i][j] = grid[i][j].
         for (int i = 0; i < rows; i++) {
             for (int j = 0; j < cols; j++) {
                 D[i][j] = grid[i][j];

                 if (i == 0 && j != 0) {
                     D[i][j] += D[i][j - 1];
                 } else if (j == 0 && i != 0) {
                     D[i][j] += D[i - 1][j];
                 } else if (i != 0 && j != 0) {
                     D[i][j] += Math.min(D[i][j - 1], D[i - 1][j]);
                 }
             }
         }

         return D[rows - 1][cols - 1];
     }

     // Solution 2: DFS + memory.
     public int minPathSum(int[][] grid) {
         if (grid == null || grid.length == 0 || grid[0].length == 0) {
             return 0;
         }

         int[][] memory = new int[grid.length][grid[0].length];

         // Bug 1: forget to initilize
         for (int i = 0; i < grid.length; i++) {
             for (int j = 0; j < grid[0].length; j++) {
                 memory[i][j] = -1;
             }
         }

         return dfs(grid, 0, 0, memory);
     }

     public int dfs (int[][] grid, int i, int j, int[][] memory) {
         int rows = grid.length;
         int cols = grid[0].length;

         if (i >= rows || j >= cols) {
             // 表示不可达
             return Integer.MAX_VALUE;
         }

         // The base case: arrive the destination.
         if (i == rows - 1 && j == cols - 1) {
             return grid[i][j];
         }

         // 已经搜索过的点不需要重复搜索
         if (memory[i][j] != -1) {
             return memory[i][j];
         }

         int sum = grid[i][j];

         // 开始dfs 可能的路径,目前我们只有2种可能
         sum += Math.min(dfs(grid, i + 1, j, memory), dfs(grid, i, j + 1, memory));

         // Record the memory
         memory[i][j] = sum;
         return sum;
     }
 }

GITHUB:

https://github.com/yuzhangcmu/LeetCode_algorithm/blob/master/dp/MinPathSum_1222_2014.java