【网格图dp】【hard】力扣1289. 下降路径最小和 II

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

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

示例 1：

输入：grid = [[1,2,3],[4,5,6],[7,8,9]]
输出：13
解释：
所有非零偏移下降路径包括：
[1,5,9], [1,5,7], [1,6,7], [1,6,8],
[2,4,8], [2,4,9], [2,6,7], [2,6,8],
[3,4,8], [3,4,9], [3,5,7], [3,5,9]
下降路径中数字和最小的是 [1,5,7] ，所以答案是 13 。

示例 2：
输入：grid = [[7]]
输出：7

方法一：记忆化搜索

class Solution {
public:
    int minFallingPathSum(vector<vector<int>>& grid) {
        int n= grid[0].size();
        vector<vector<int>> memo(n,vector<int>(n, INT_MAX));

        function<int(int, int)> dfs = [&](int i, int j) -> int{
            if(memo[i][j] != INT_MAX){
                return memo[i][j];
            }

            if(i == 0){
                return grid[i][j];
            }

            int res = INT_MAX;
            for(int k = 0; k < n; k++){
                if(k != j){
                    res = min(res, dfs(i-1, k) + grid[i][j]);
                }
            }

            memo[i][j] = res;
            return res;          
        };

        int res = INT_MAX;
        for(int i = 0;i < n; i++){
            res = min(res, dfs(n-1,i));
        }
        return res;
    }
};

时间复杂度：O(n^3)
空间复杂度：O(n^2)

这题记忆化搜索过程和力扣2304很像，可以看主页2304记忆化搜索的讲解。

---

方法二：转移过程优化

class Solution {
public:
    int minFallingPathSum(vector<vector<int>>& grid) {
        int n = grid.size();
        int first_min_sum = 0;
        int second_min_sum = 0;
        int min_sum_index = -1;

        for(int i = 0; i < n; i++){
            int cur_first_min_sum = INT_MAX;
            int cur_second_min_sum = INT_MAX;
            int cur_min_sum_index = -1;

            for(int j = 0; j < n; j++){
                int cur_sum = (j != min_sum_index ? first_min_sum : second_min_sum) + grid[i][j];
                if(cur_sum < cur_first_min_sum){
                    cur_second_min_sum = cur_first_min_sum;
                    cur_first_min_sum = cur_sum;
                    cur_min_sum_index = j;
                }else if(cur_sum < cur_second_min_sum){
                    cur_second_min_sum = cur_sum;
                }
            }
            first_min_sum = cur_first_min_sum;
            second_min_sum = cur_second_min_sum;
            min_sum_index = cur_min_sum_index;
        }
        return first_min_sum;
    }
};

时间复杂度：O(n^2)
空间复杂度：O(1)

经过观察可以发现，在计算一个网格之前的最小路径的时候，只需要知道上一行中的最小值是多少，由于可能会出现最小值刚好在网格上面，所以我们还要统计上一行中的次最小值，并且我们还要维护一个关于上一行最小值下标的变量，来决定当下网格的最小路径要通过上一行的最小值还是次最小值来求。

前面带cur的是当下计算的值，在遍历j的过程中，就是为了选出这一行的最小值和次最小值还有最小值索引，然后当这一行遍历结束后，就将当前找到的数据储存到

first_min_sum = cur_first_min_sum;
second_min_sum = cur_second_min_sum;
min_sum_index = cur_min_sum_index;

然后供下一行继续使用。

最后返回的first_min_sum也就是最后一行的最小值，也就是整个过程中的最小路径。