【LeetCode 算法】Minimum Falling Path Sum II 下降路径最小和 II-动态规划-SP

Minimum Falling Path Sum II 下降路径最小和 II

问题描述：

给你一个 n x n 整数矩阵 grid ，请你返回 非零偏移下降路径 数字和的最小值。

非零偏移下降路径 定义为：从 grid 数组中的每一行选择一个数字，且按顺序选出来的数字中，相邻数字不在原数组的同一列。

$$\begin{gathered} n==grid.length==grid[i].length \\ 1<=n<=200 \\ -99<=grid[i][j]<=99 \end{gathered}$$

分析

定义f[i][j] 表示在选到第i+1行的第j列的元素时，可以得到的最小路径和。
$$f[i][j]=min(f[i-1][k]+a[i][j]),k!=j$$

在DP的基础上，有一层是需要O(N)的时间复杂度来找min。但是这里有一个trick，在计算某一行的元素时，只需要 记录 最小的2个数，还有一个 是最小值的索引。

如果找上一行的最小值索引与当前元素不一致，可以直接使用这个min，否则就只能选secondary。

这里没有使用滚动数组压缩空间。

代码

DP

class Solution { 
    public int minFallingPathSum(int[][] grid) {
        int n = grid.length; 
        int INF = 1<<30;
        int[][] f = new int[n][n];
        // f[0][j] = g[0][j];
        // f[i][j] = min( f[i-1][k])+ g[i][j]
        for (int i = 0; i < n; i++) {
            Arrays.fill(f[i],INF);
        }
        int[][] memo = new int[2][3];// 0 min1 1 min2 2 idx of min1
        memo[0][0]=INF;memo[0][1]=INF;
        memo[1][0]=INF;memo[1][1]=INF;
        for (int i = 0; i < n; i++) {
            f[0][i] = grid[0][i];
            if(f[0][i]<memo[0][0]){
                memo[0][1] = memo[0][0];
                memo[0][0] = f[0][i];
                memo[0][2] = i;
            }
            else if(f[0][i]<memo[0][1]){
                memo[0][1] = f[0][i];
            }
        }
        
        int ans = INF;
        for (int i = 1; i < n; i++) {
            int r = i%2;
            memo[r][0]=INF;memo[r][1]=INF;
            for (int j = 0; j < n; j++) {
                f[i][j] = grid[i][j];
                if(j!=memo[r^1][2]){
                    f[i][j]  += memo[r^1][0];
                }
                else{
                    f[i][j]  += memo[r^1][1];
                }

                if(f[i][j]<memo[r][0]){
                    memo[r][1] = memo[r][0];
                    memo[r][0] = f[i][j];
                    memo[r][2] = j;
                }
                else if(f[i][j]<memo[r][1]){
                    memo[r][1] = f[i][j];
                } 
            }
        }
        for (int i = 0; i < n; i++) {
            if(ans>f[n-1][i]) ans = f[n-1][i];
        }
        return ans;
    } 
}

时间复杂度$O(N^2)$

空间复杂度$O(N^2)$

Tag

Matrix

Dynamic Programming