給你一個數組，求從[0,0]位置到[n-1,m-1]的最短路徑。

數組如圖所示：

路徑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));
    }
}

矩陣的最小路徑和