【LeetCode 算法】Minimum Falling Path Sum II 下降路径最小和 II -DFS

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}$$

分析

实际的目标是要从每一行选一个数，而且相邻的行不能选择同一列，这样的n个数的和是最小的。

如果以暴力计算，第一行可以选择n，第二至第n行,每一行可以选择n-1。
需要枚举的规模就是大概$n^n$.

简单的试图使用暴力的方式是无法解决的。

以问题的描述，一定会存在至少一条和最小的path。
如果在第n行选了一个元素$a[n][i],$那么这个路径在n-1行就不能选列$i$。但是可以选择$a[n-1][k],k!=i.$

所以可以利用递归的方式来搜索这个路径。
设定一个递归$dfs(row,precol)$,表示在行为$row$时，行 $row+1$选择列 $precol$时的最小路径和。
$$dfs(n,precol)=min(dfs(n-1,k)+a[n][k]),k!=precol$

递归的边界，就是$row==0$，需要选择与$row==1$不同列的元素。
以递归搜索这个思路计算的时间复杂度，依然是$O(N^N),$所以TLE是必然的。
原因就在于在递归树上，会出现$dfs(n,col)$的重复计算。
所以记忆化搜索，可以大幅度的减少时间复杂度，理论上可以达到$O(N^3)$.

代码

暴力递归

class Solution {
    int n,INF;
    int[][] g;
    public int minFallingPathSum(int[][] grid) {
        n = grid.length;
        g = grid;
        INF = 1<<30; 
        return dfs(n-1,-1);
    }
    public int dfs(int row,int precol){ 
        if(row==0){
            int res = INF;
            for(int i=0;i<n;i++){
                if(i!=precol){
                    res = Math.min(res,g[row][i]);
                } 
            }
            return res;
        }
        int res = INF;
        for(int i=0;i<n;i++){
            if(i!=precol){
                int t = dfs(row-1,i)+g[row][i];
                res = Math.min(res,t);
            }
        } 
        return res;
    }
}

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

空间复杂度$O(N)$

记忆化

class Solution {
   int n,INF;
   int[][] g,memo;
   public int minFallingPathSum(int[][] grid) {
       n = grid.length;
       g = grid;
       INF = 1<<30;
       memo = new int[n][n+1];
       for(int i=0;i<n;i++) Arrays.fill(memo[i],-1);
       return dfs(n-1,-1);
   }
   public int dfs(int row,int precol){
       if(memo[row][precol+1]!=-1){
           return memo[row][precol+1];
       }
       if(row==0){
           int res = 100;
           for(int i=0;i<n;i++){
               if(i!=precol){
                   res = Math.min(res,g[row][i]);
               } 
           }
           return memo[row][precol+1] = res;
       }
       int res = INF;
       for(int i=0;i<n;i++){
           if(i!=precol){
               int t = dfs(row-1,i)+g[row][i];
               res = Math.min(res,t);
           }
       }
       memo[row][precol+1] = res;
       return res;
   }
}

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

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

Tag

Matrix

Memory