力扣64最小路径和

1. 暴力递归，力扣提交时间会超出限制

/**
 *  最小路径和问题
 *  给你一个二维数组，二维数组中的每个数都是正数，要求从左上角
 *  走到右下角，每一步只能向右或者向下，沿途经过的数字要累加起来。
 *
 *  要求：返回最小的路径和
 *
 *  解法一：暴力递归方式
 */
public class MinPath {
 
    public static int minPath(int[][] array){
        if(array == null || array.length == 0 || array[0].length == 0){
            throw new IllegalArgumentException("参数非法");
        }
 
        //从(0, 0)位置开始走，得到最终结果
        return minPath(array, 0, 0 );
    }
 
    /**
     * 暴力递归方式求解最短路径问题
     * @param array 二维数组
     * @param i  当前走到的行
     * @param j  当前走到的列
     * @return
     */
    private static int minPath(int[][] array, int i, int j){
        //当i的值为array.length - 1并且j的值为array[0].length  - 1时表示走到了右下角
        if(i == array.length - 1 && j == array[0].length  - 1){
            //走到了右下角则直接返回右下角的数值
            return array[i][j];
        }
 
        //当i的值为array.length - 1并且j的值不为array[0].length - 1时，只能往右走
        if(i == array.length - 1 && j != array[0].length - 1){
            return array[i][j] + minPath(array, i ,j + 1);
        }else if(i != array.length - 1 && j == array[0].length - 1){
            //当i的值不为array.length - 1并且j的值为array[0].length - 1时，只能往下走
            return array[i][j] + minPath(array, i + 1, j);
        }
 
        //否则既可以向下走也可以向右走，此时选取路径最短的那个
        return array[i][j] + Math.min(minPath(array, i, j + 1), minPath(array, i + 1, j));
    }
 
    //测试函数
    public static void main(String[] args) {
        int[][] array = { { 3, 1, 0, 2 }, { 4, 3, 2, 1 }, { 5, 2, 1, 0 }  };
        System.out.println("最小路径和为 ;" + minPath(array));
    }
 
}

2. 动态规划(官方)

我们新建一个额外的 dpdp 数组，与原矩阵大小相同。在这个矩阵中，dp(i, j)dp(i,j) 表示从坐标 (i, j)(i,j) 到右下角的最小路径权值。我们初始化右下角的 dpdp 值为对应的原矩阵值，然后去填整个矩阵，对于每个元素考虑移动到右边或者下面，因此获得最小路径和我们有如下递推公式：

dp(i, j)= mathrm{grid}(i,j)+min big(dp(i+1,j),dp(i,j+1)big)
dp(i,j)=grid(i,j)+min(dp(i+1,j),dp(i,j+1))

注意边界情况。下图描述了这个过程：

注意求一个点到最右下角的点的最小路径和，不应该考虑怎么直接到，而是倒着考虑，如果我们把上图的每一个点到最右下角的最小距离都算出来了，还愁算不出来吗？

public class Solution {
    public int minPathSum(int[][] grid) {
        int[][] dp = new int[grid.length][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)
                    dp[i][j] = grid[i][j] +  dp[i][j + 1];
                else if(j == grid[0].length - 1 && i != grid.length - 1)
                    dp[i][j] = grid[i][j] + dp[i + 1][j];
                else if(j != grid[0].length - 1 && i != grid.length - 1)
                    dp[i][j] = grid[i][j] + Math.min(dp[i + 1][j], dp[i][j + 1]);
                else
                    dp[i][j] = grid[i][j];
            }
        }
        return dp[0][0];
    }
}

 

时间复杂度 ：O(mn)O(mn)。遍历整个矩阵恰好一次。
空间复杂度 ：O(mn)O(mn)。额外的一个同大小矩阵。

最近提交结果：通过显示详情 执行用时 :7 ms, 在所有Java提交中击败了27.04%的用户
内存消耗 :39.9 MB, 在所有Java提交中击败了84.63%的用户

3. 一维动态规划

在上个解法中，我们可以用一个一维数组来代替二维数组，dpdp 数组的大小和行大小相同。这是因为对于某个固定状态，只需要考虑下方和右侧的节点。首先初始化 dpdp 数组最后一个元素是右下角的元素值，然后我们向左移更新每个 dp(j)dp(j) 为：

dp(j)=grid(i,j)+min(dp(j),dp(j+1))

我们对于每一行都重复这个过程，然后向上一行移动，计算完成后 dp(0)dp(0) 就是最后的结果。

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)
                   dp[j] = grid[i][j] +  dp[j + 1];
               else if(j == grid[0].length - 1 && i != grid.length - 1)
                   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
                   dp[j] = grid[i][j];
           }
       }
       return dp[0];
   }
}

 

其实没啥变化和上面的方法二，或者说因为中间状态我们都不用考虑，其实完全可以不申请额外的空间，如下：

4. 不申请空间（动态规划）

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];
    }