【力扣-动态规划入门】【第 13 天】931. 下降路径最小和

标题：931. 下降路径最小和
难度：中等
天数：第13天,第1/2题

给你一个 n x n 的 方形 整数数组 matrix ，请你找出并返回通过 matrix 的下降路径 的 最小和 。

下降路径 可以从第一行中的任何元素开始，并从每一行中选择一个元素。在下一行选择的元素和当前行所选元素最多相隔一列（即位于正下方或者沿对角线向左或者向右的第一个元素）。具体来说，位置 (row, col) 的下一个元素应当是 (row + 1, col - 1)、(row + 1, col) 或者 (row + 1, col + 1) 。

 

示例 1：

输入：matrix = [[2,1,3],[6,5,4],[7,8,9]]
输出：13
解释：下面是两条和最小的下降路径，用加粗+斜体标注：
[[2,1,3], [[2,1,3],
[6,5,4], [6,5,4],
[7,8,9]] [7,8,9]]

示例 2：

输入：matrix = [[-19,57],[-40,-5]]
输出：-59
解释：下面是一条和最小的下降路径，用加粗+斜体标注：
[[-19,57],
[-40,-5]]

示例 3：

输入：matrix = [[-48]]
输出：-48

提示：

• n == matrix.length
• n == matrix[i].length
• 1 <= n <= 100
• -100 <= matrix[i][j] <= 100

来源：力扣（LeetCode）
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    //动态规划 第 13 天  1/2
    public int minFallingPathSum(int[][] matrix) {
        int maLength = matrix.length;
        //记录走到第n层第n元素的最小值
        int[][] dp = new int[maLength][maLength];
        //记录最小值
        int min = matrix[0][0];
        for(int i = 0 ; i < maLength;i++){
            //这一层纵向遍历
            for(int j = 0 ; j < maLength;j++){
                //这一层横向遍历
                int item =  matrix[i][j];
               if(i == 0){
                    //第一层初始化赋值
                    dp[i][j] = matrix[i][j];
                    //找出最小值
                    min = Math.min(min,dp[i][j]) ;
               }else{
                   //第二层开始计算走到当前j位置的，可能的最小值
                    if( j == 0){
                        //如果是第一位 ，只有j-1 ,j 两个位置可以到这里
                        dp[i][j] = Math.min(dp[i-1][j],dp[i-1][j+1]) + item;
                        //每层第一个给最小值赋值
                        min = dp[i][j];
                    }else if(j == maLength - 1){
                        //如果是最后一位 只有j,j-1 两种情况
                        dp[i][j] = Math.min(dp[i-1][j],dp[i-1][j-1])+ item;
                        //对比当前值和最小值，取最小
                        min = Math.min(min,dp[i][j]);
                    }else{
                       //如果不是第一位或者最后一位，有j-1,j,j+1三个位置可以到达当前位置j   找出最小值，然后加上当前值，就是当期那位置最小值
                        dp[i][j] = Math.min(dp[i-1][j-1],Math.min(dp[i-1][j],dp[i-1][j+1])) + item;
                        //对比当前值和最小值，取最小
                        min = Math.min(min,dp[i][j]);
                   }
               }
            }
        }
        return min;
    }
}