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

Eric.Cui

已于 2023-08-11 00:09:27 修改

阅读量248

点赞数

分类专栏：数据结构与算法文章标签：算法深度优先 leetcode

于 2023-08-10 21:01:24 首次发布

本文链接：https://blog.csdn.net/edisonzhi/article/details/132218456

版权

数据结构与算法专栏收录该内容

201 篇文章 0 订阅

订阅专栏

文章目录

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

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

问题描述：

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

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

$grid[i].length\\ 1 <= n <= 200\\ -99 <= grid[i][j] <= 99$

分析

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

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

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

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

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

递归的边界，就是 $ro w == 0$ ，需要选择与 $ro w == 1$ 不同列的元素。
以递归搜索这个思路计算的时间复杂度，依然是 $O(N^N),$ 所以TLE是必然的。
原因就在于在递归树上，会出现 $df s (n, co l)$ 的重复计算。
所以记忆化搜索，可以大幅度的减少时间复杂度，理论上可以达到 $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;
   }
}