【网格dp】【记忆化搜索&&动态规划+滚动数组】力扣2304. 网格中的最小路径代价

给你一个下标从 0 开始的整数矩阵 grid ，矩阵大小为 m x n ，由从 0 到 m * n - 1 的不同整数组成。你可以在此矩阵中，从一个单元格移动到 下一行 的任何其他单元格。如果你位于单元格 (x, y) ，且满足 x < m - 1 ，你可以移动到 (x + 1, 0), (x + 1, 1), …, (x + 1, n - 1) 中的任何一个单元格。注意： 在最后一行中的单元格不能触发移动。

每次可能的移动都需要付出对应的代价，代价用一个下标从 0 开始的二维数组 moveCost 表示，该数组大小为 (m * n) x n ，其中 moveCost[i][j] 是从值为 i 的单元格移动到下一行第 j 列单元格的代价。从 grid 最后一行的单元格移动的代价可以忽略。

grid 一条路径的代价是：所有路径经过的单元格的 值之和 加上 所有移动的 代价之和 。从 第一行 任意单元格出发，返回到达 最后一行 任意单元格的最小路径代价。

示例 1：

输入：grid = [[5,3],[4,0],[2,1]], moveCost = [[9,8],[1,5],[10,12],[18,6],[2,4],[14,3]]
输出：17
解释：最小代价的路径是 5 -> 0 -> 1 。

• 路径途经单元格值之和 5 + 0 + 1 = 6 。
• 从 5 移动到 0 的代价为 3 。
• 从 0 移动到 1 的代价为 8 。
  路径总代价为 6 + 3 + 8 = 17 。

示例 2：
输入：grid = [[5,1,2],[4,0,3]], moveCost = [[12,10,15],[20,23,8],[21,7,1],[8,1,13],[9,10,25],[5,3,2]]
输出：6
解释：
最小代价的路径是 2 -> 3 。

• 路径途经单元格值之和 2 + 3 = 5 。
• 从 2 移动到 3 的代价为 1 。
  路径总代价为 5 + 1 = 6 。
  

法一：记忆化搜索

class Solution {
public:
    int minPathCost(vector<vector<int>>& grid, vector<vector<int>>& moveCost) {
        int m = grid.size(), n = grid[0].size();
        vector<vector<int>> memo(m,vector<int>(n, -1));
        function<int(int, int)> dfs = [&](int i, int j) -> int{
            if(i == 0){
                return grid[i][j];
            }
            if(memo[i][j] >= 0){
                return memo[i][j];
            }
            int res = INT_MAX;
            for(int k = 0; k < n; k++){
                res = min(res, dfs(i-1, k) + moveCost[grid[i-1][k]][j] + grid[i][j]);
            }
            memo[i][j] = res;
            return res;
        };

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

    }
};

时间复杂度：O(m*n^2 )，其中 m 和 n 分别是数组 grid 的行数和列数。记忆化搜索最多计算 mn 个状态，每个状态需要 O(n)。

空间复杂度：O(mn)。

从下往上进行记忆化搜索，当dfs函数中输入了一个网格坐标，这时候就会开始计算上一行从哪个网格过来，整个过程付出的代价最小，然后不断递归到第一行。使用memo来避免重复运算。这题是比较经典的记忆化搜索的方式。

---

方法二：动态规划+滚动数组

class Solution {
public:
    int minPathCost(vector<vector<int>>& grid, vector<vector<int>>& moveCost) {
        int m = grid.size(), n = grid[0].size();
        vector<vector<int>> dp(2,vector<int>(n));
        dp[0] = grid[0];
        int cur = 0;
        for(int i = 1; i < m; i++){
            int next = 1 - cur;
            for(int j = 0; j < n; j++){
                dp[next][j] = INT_MAX;
                for(int k = 0; k < n; k++){
                    dp[next][j] = min(dp[next][j], dp[cur][k] + moveCost[grid[i-1][k]][j] + grid[i][j]);
                } 
            }
            cur = next;
        }
        return *min_element(dp[cur].begin(), dp[cur].end());

    }
};

时间复杂度：O(m*n^2 )，其中 m 和 n 分别是数组 grid 的行数和列数。

空间复杂度：O(n)。

使用动态规划在运行速度上和空间复杂度上都得到了优化，使用了一个dp数组，该数组的行数只有二，这意味数据在迭代的过程中是不断更新的，这是一种滚动数组优化空间复杂度的方式。

cur和next对应的是行，意味着当前计算过的行和接下来准备计算的行。接下来在第一层for中嵌套一层for，来锁定要计算的网格的dp。可以知道，一个网格的dp是由上一行中到该网格的最小代价，所以加入一层for循环，来比较上一行每个格子到这一行的代价，取其中最小值。

最后返回最后一行，也就是dp[cur]的最小dp，即网格中最小路径代价。