1289 下降路径最小和【leetcode每日一题系列】

采用动态规划的思想来解决：题意中可以看出，数组的每一行取一个数，因此下一行的状态可以通过上一行的值来预测，具体分析如下：

如图所示为一个4*4的矩阵，我们定义$dp[i][j]$来表示选取矩阵中第i行第j列的数作为最后一个数，从而得到的非零偏移下降矩阵的最小值，则可知：

当i为0时，表示矩阵第一行，$dp[0][j]$表示选取矩阵中第$0$行第$j$列的数作为最后一个数，则可知：
$$dp[0][j]=grid[0][j]$$

即$dp[0]$的值为：

根据$dp[0]$来寻找$dp[1]$,则$dp[1][0]$表示第一行的数字取$grid[1][0]$的非零偏移下降矩阵的最小值，则可知：

$$dp[1][0]=min(dp[0][1],dp[0][2],dp[0][3])+grid[1][0]$$

其他也可按照同理进行推断，总公式为：

$$dp[1][i]=min(dp[0][j])+grid[1][i],j=0,1,...,n且j!=i$$

即$dp[1]$的值为：

则可得递推公式为：

$$dp[i][j]=min(dp[i-1][k])+grid[i][j],k!=j$$

最后，遍历$dp[n-1]$找到最小值即可。
代码如下：

class Solution {
    public int minFallingPathSum(int[][] grid) {
        int n = grid.length;
        int[][] dp = new int[n][n];
        for(int i=0;i<n;i++){
            dp[0][i] = grid[0][i];
        }
        int row = 1, column = 0;
        while (row<n){
            while (column<n){
                int laxmin = Integer.MAX_VALUE;
                for(int i=0;i<n;i++){
                    if(i==column) continue;
                    laxmin = Math.min(laxmin,dp[row-1][i]);
                }
                dp[row][column] = laxmin + grid[row][column];
                column++;
            }
            System.out.println(" ");
            row++;
            column = 0;
        }
        int min = Integer.MAX_VALUE;
        for(int i=0;i<n;i++){
            min = Math.min(min,dp[n-1][i]);
        }
        return min;
 }

此代码的时间复杂度为$n^3$。由于在遍历时进行了重复遍历，每次寻找某行最小值时都需要遍历一遍上一行的值，增加了时间复杂度，可以先行记录下上一行的最小值$firstmin$，最小值索引$firstindex$以及次小值$secondmin$，则递推公式变为：

$$dp[i][j]=\{\begin{array}{c}firstmin+grid[i][j],j!=firstindex,\\ \\ secondmin+grid[i][j],j=firstindex\end{array}$$

即在每次寻找完$dp[i]$之后，更新三个值即可，此时可使时间复杂度降为$n^2$,优化之后的代码如下：

class Solution {
    public int minFallingPathSum(int[][] grid) {
        int n = grid.length;
        int[][] dp = new int[n][n];
        for(int i=0;i<n;i++){
            dp[0][i] = grid[0][i];
        }
        int[] calcutate = findNumber(dp[0]);
        System.out.println(calcutate[0]);
        System.out.println(calcutate[2]);
        int length = 1, high = 0;
        while (length<n){
            while (high<n){
                if(high == calcutate[1]) dp[length][high] = calcutate[2] + grid[length][high];
                else dp[length][high] = calcutate[0] + grid[length][high];
                high++;
            }
            calcutate = findNumber(dp[length]);
            length++;
            high = 0;
        }
        return calcutate[0];
    }
    public int[] findNumber(int[] dp){
        int firstindex = -1;
        int firstmin = Integer.MAX_VALUE;
        int secondmin = Integer.MAX_VALUE;
        for(int i=0;i<dp.length;i++){
            if(secondmin>dp[i]){
                secondmin = dp[i];
                if(firstmin>secondmin){
                    int temp = firstmin;
                    firstmin = secondmin;
                    firstindex = i;
                    secondmin = temp;
                }
            }
        }
        return new int[]{firstmin,firstindex,secondmin};
    }
}
~~~