网格中的最小路径代价

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 。

提示：

m == grid.length
n == grid[i].length
2 <= m, n <= 50
grid 由从 0 到 m * n - 1 的不同整数组成
moveCost.length == m * n
moveCost[i].length == n
1 <= moveCost[i][j] <= 100

原站题解

去查看

上次编辑到这里，代码来自缓存点击恢复默认模板

class Solution { public: int minPathCost(vector<vector<int>>& grid, vector<vector<int>>& moveCost) { } };

rust 解法, 执行用时: 32 ms, 内存消耗: 3.3 MB, 提交时间: 2023-11-22 19:46:57

impl Solution {
    pub fn min_path_cost(mut grid: Vec<Vec<i32>>, move_cost: Vec<Vec<i32>>) -> i32 {
        let m = grid.len();
        let n = grid[0].len();
        for i in (0..m - 1).rev() {
            for j in 0..n {
                grid[i][j] += grid[i + 1]
                    .iter()
                    .zip(move_cost[grid[i][j] as usize].iter())
                    .map(|(&g, &c)| g + c)
                    .min()
                    .unwrap();
            }
        }
        *grid[0].iter().min().unwrap()
    }
}

python3 解法, 执行用时: 396 ms, 内存消耗: 22.3 MB, 提交时间: 2023-11-22 19:46:12

class Solution:
    def minPathCost(self, grid: List[List[int]], moveCost: List[List[int]]) -> int:
        m, n = len(grid), len(grid[0])
        f = [[inf] * n for _ in range(m)]
        f[-1] = grid[-1]
        for i in range(m - 2, -1, -1):
            for j, g in enumerate(grid[i]):
                for k, c in enumerate(moveCost[g]):  # 移动到下一行的第 k 列
                    f[i][j] = min(f[i][j], f[i + 1][k] + c)
                f[i][j] += g
        return min(f[0])

python3 解法, 执行用时: 628 ms, 内存消耗: 19.1 MB, 提交时间: 2022-11-29 11:22:49

class Solution:
    def minPathCost(self, grid: List[List[int]], moveCost: List[List[int]]) -> int:
        m, n = len(grid), len(grid[0])
        @cache
        def dfs(x, y): # i, j 的最短路径
            if x==m-1:
                return grid[x][y]
            res = inf
            for j in range(n):
                res = min(res, grid[x][y] + moveCost[grid[x][y]][j] + dfs(x+1, j))

            return res
            
            
        return min(dfs(0, j) for j in range(n))

golang 解法, 执行用时: 256 ms, 内存消耗: 9 MB, 提交时间: 2022-11-29 11:21:16

func minPathCost(grid [][]int, moveCost [][]int) int {
	m, n := len(grid), len(grid[0])
	pre := grid[0]
	f := make([]int, n)
	for i := 1; i < m; i++ {
		for j, g := range grid[i] {
			f[j] = math.MaxInt32
			for k, v := range grid[i-1] {
				f[j] = min(f[j], pre[k]+moveCost[v][j])
			}
			f[j] += g
		}
		pre, f = f, pre
	}
	ans := math.MaxInt32
	for _, v := range pre {
		ans = min(ans, v)
	}
	return ans
}

func min(a, b int) int { if a > b { return b }; return a }

python3 解法, 执行用时: 240 ms, 内存消耗: 18.8 MB, 提交时间: 2022-11-29 11:20:46

'''
定义 f[i][j] 表示从第一行出发到达第 i 行第 j 列时的最小路径代价
'''
class Solution:
    def minPathCost(self, grid: List[List[int]], moveCost: List[List[int]]) -> int:
        f = grid[0]
        for pre, cur in pairwise(grid):
            f = [g + min(f[k] + moveCost[v][j] for k, v in enumerate(pre)) for j, g in enumerate(cur)]
        return min(f)

上一题

下一题

详情