给你一个下标从 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,即网格中最小路径代价。