矩阵的最小路径和

给你一个数组，求从[0,0]位置到[n-1,m-1]的最短路径。

数组如图所示：

1	3	5	9
8	2	3	4
5	0	6	1
8	8	4	0

路径1→3→1→0→6→1→0是所有路径中路径和最小的，所以返回12

代码：

public class MinpathSum{

    //时间复杂度O(M*N),空间复杂度O(M*N)
    public static int minPathSum1(int[][] matrix) {
        if(matrix == null || matrix.length==0 || matrix[0].length==0) {
            return 0;
        }
        
        int row = matrix.length;
        int col = matrix[0].length;
        
        int[][] dp = new int[row][col];
        //初始化数组
        dp[0][0] = matrix[0][0];
        
        for(int i=1; i<row; i++) {
            dp[i][0]=dp[i-1][0]+matrix[i][0];
        }
        for(int i=1; i<col; i++) {
            dp[0][i]=dp[0][i-1]+matrix[0][i];
        }
        
        for(int i=1; i<row; i++) {
            for(int j=1; j<col; j++) {
                dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1])+matrix[i][j];
            }
        }
        
        return dp[row-1][col-1];
    }
    
    //时间复杂度O(M*N),空间复杂度O(min(M*N))
    public static int minPathSum2(int[][] matrix) {
        if(matrix == null || matrix.length==0 || matrix[0].length==0) {
            return 0;
        }
        
        int row = matrix.length;
        int col = matrix[0].length;
        //压缩dp数组为一维数组，运用翻滚的的方法逐行往下翻滚
        int[] dp = new int[col];
        //初始化数组
        dp[0] = matrix[0][0];
        
        for(int i=1; i<col; i++) {
            dp[i]=dp[i-1]+matrix[0][i];
        }
        
        for(int i=1; i<row; i++) {
            dp[0] += matrix[i][0];
            for(int j=1; j<col; j++) {
                dp[j] = Math.min(dp[j], dp[j-1])+matrix[i][j];
            }
        }
        
        return dp[col-1];
    }
    
    
    public static void main(String[] args) {
        int[][] matrix = {{1,3,5,9},{8,1,3,4},{5,0,6,1},{8,8,4,0}};
        System.out.println(minPathSum1(matrix));
        System.out.println(minPathSum2(matrix));
    }
}