目 录CONTENT

文章目录

LeetCode|2304. 网格中的最小路径代价

RobKing
2023-11-22 / 0 评论 / 0 点赞 / 139 阅读 / 873 字

LeetCode|2304. 网格中的最小路径代价

题目

给你一个下标从 0 开始的整数矩阵 grid ,矩阵大小为 m x n ,由从 0m * 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 一条路径的代价是:所有路径经过的单元格的 值之和 加上 所有移动的 代价之和 。从 第一行 任意单元格出发,返回到达 最后一行 任意单元格的最小路径代价*。*

img

输入: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 。

思路

这一题之所以要记录下来,是因为使用了动态规划以及优化,滚动数组。另外也可以使用dfs来解决这个问题,通过记忆化搜索优化

普通动态规划

func minPathCost(grid [][]int, moveCost [][]int) int {
    // 思路:动态规划
    m, n := len(grid), len(grid[0])
    const Inf = 0x3f3f3f3f
    dp := make([][]int, m)
    for i := 0; i < m; i ++ {
        dp[i] = make([]int, n)
    }
    for i := 0; i < n; i ++ {
        dp[0][i] = grid[0][i]
    }

    for i := 1; i < m; i ++ {
        for j := 0; j < n; j ++ {
            dp[i][j] = Inf
            for k := 0; k < n; k ++ {
                dp[i][j] = min(dp[i][j], dp[i-1][k] + moveCost[grid[i-1][k]][j] + grid[i][j])
                // fmt.Println(i, j, k, dp[i][j])
            }
            // fmt.Println("dp:", dp[i][j])
        }
    }
    res := Inf
    for i := 0; i < n; i ++ {
        res = min(res, dp[m-1][i])
    }
    return res
}

滚动数组优化

func minPathCost(grid [][]int, moveCost [][]int) int {
    // 思路:动态规划
    // 优化:滚动数组,只需要依赖上一行的数据即可
    const Inf = 0x3f3f3f3f
    m, n := len(grid), len(grid[0])
    dp := [2][]int{
        make([]int, n), make([]int, n),
    }
    cur := 0 
    // 复制一行的数据
    copy(dp[0], grid[0])

    for i := 1; i < m; i ++ {
        next := 1 - cur 
        for j := 0; j < n; j ++ {
            dp[next][j] = Inf
            for 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
    }
    res := Inf
    for i := 0; i < n; i ++ {
        res = min(res, dp[cur][i])
    }
    return res
}

dfs

const Inf = 0x3f3f3f3f

func minPathCost(grid [][]int, moveCost [][]int) int {
    m, n := len(grid), len(grid[0])
    memo := make([][]int, m)
    for i := 0; i < m; i++ {
        memo[i] = make([]int, n)
        for j := 0; j < n; j++ {
            memo[i][j] = -1
        }
    }
    var dfs func(int, int)int
    dfs = func(i, j int) int {
        if i == 0 {
            return grid[i][j]
        }
        if memo[i][j] >= 0 {
            return memo[i][j]
        }
        res := Inf
        for 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
    }
    res := Inf
    for j := 0; j < n; j++ {
        res = min(res, dfs(m - 1, j))
    }
    return res
}
0

评论区