LeetCode 931/1289. Minimum Falling Path Sum Series

931 还是min path sum的问题 这种问题首先想到DP.

首先看一下规则：
Given a square array of integers A, we want the minimum sum of a falling path through A.

A falling path starts at any element in the first row, and chooses one element from each row. The next row’s choice must be in a column that is different from the previous row’s column by at most one.

就是说我们可以从第一行的任何一个出发 然后我们向下走 不能直直的向下走 只能往左下或者右下去走。

class Solution {
    public int minFallingPathSum(int[][] A) {
        int m = A.length;
        int n = A[0].length;
        
        int[] dpNew = new int[n];
        int[] dpOld = new int[n];
        
        //dp[i] represents the min path sum end in position of i
        for (int i = 0; i < n; i++) {
            dpOld[i] = A[0][i];
            dpNew[i] = A[0][i];
        }
        
        for (int i = 1; i < m; i++) { //outer loop on A
            for (int j = 0; j < n; j++) { //inner loop on dp
                if (j == 0 ) {
                    dpNew[j] = Math.min(dpOld[j+1], dpOld[j]) + A[i][j];
                } else if (j == n - 1) {
                    dpNew[j] = Math.min(dpOld[j-1], dpOld[j]) + A[i][j];
                } else {
                    dpNew[j] = Math.min(Math.min(dpOld[j-1], dpOld[j+1]), dpOld[j]) + A[i][j];
                }
                
            }
            for (int j = 0; j < n; j++) {
                dpOld[j] = dpNew[j];
            }
            //we can't use dpOld = dpNew to make a copy of dpNew, and if dpNew is changing later, then dpOld will change to.
        }
        int min = Integer.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            System.out.println(dpNew[i]);
            min = Math.min(min, dpNew[i]);
        }
        return min;
        
    }
}
 

但是有个东西我想不明白 为什么题目给了一个square呢？有什么用途？
1289 现在移动的规则改了 只要不移动后仍在同一列 就行
之前的方法还能用吗？试着写一下
可以 但是复杂度不太好

class Solution {
    public int minFallingPathSum(int[][] arr) {
        int m = arr.length;
        int n = arr[0].length;
        
        int[] dpNew = new int[n];
        int[] dpOld = new int[n];
        
        for (int i = 0; i < n; i++) {
            dpOld[i] = arr[0][i];
            dpNew[i] = arr[0][i];
        }
        
        for (int i = 1; i < m; i++) { //outer loop on A
            for (int j = 0; j < n; j++) { //inner loop on dp
                int min = Integer.MAX_VALUE;
                if (j == 0 ) {
                    min = findMin(dpOld, 1, n - 1, -1);
                    
                } else if (j == n - 1) {
                    min = findMin(dpOld, 0, n - 2, -1);
                } else {
                    min = findMin(dpOld, 0, n - 1, j);
                }
                dpNew[j] = min + arr[i][j];
                
            }
            for (int j = 0; j < n; j++) {
                dpOld[j] = dpNew[j];
            }
        }            //we can't use dpOld = dpNew to make a copy of dpNew, and if dpNew is changing later, then dpOld will change to.
            int min = Integer.MAX_VALUE;
            for (int i = 0; i < n; i++) {
                System.out.println(dpNew[i]);
                min = Math.min(min, dpNew[i]);
            }
            return min;
        
    }
    
    private int findMin(int[] dp, int s, int e, int del) {
        int min = Integer.MAX_VALUE;
        for (int i = s; i <= e; i++) {
            if (i != del) {
                min = Math.min(min, dp[i]);
            }
        }
        return min;
    }
    
    
}