题目

给你一个下标从 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： image.png

输入：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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/minimum-path-cost-in-a-grid
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

没太多技巧，看准路径的代价如何定义的，状态方程写对，边界和下标处理好就可以了。

代码

  1. class Solution {
  2.     public int minPathCost(int[][] grid, int[][] moveCost) {
  3.         int m = grid.length;
  4.         int n = grid[0].length;
  5.         // dp[i][j]表示到达(i,j)点的最小代价
  6.         int[][] dp = new int[m][n];
  7.         // 对于第一行，每个点的代价就是该处的值
  8.         System.arraycopy(grid[0], 0, dp[0], 0, n);
  9.         // 遍历每个点，每个点都可以从上一行的n个点转移过来，取其中最小值
  10.         for (int i = 1; i < m; i++) {
  11.             for (int j = 0; j < n; j++) {
  12.                 dp[i][j] = Integer.MAX_VALUE;
  13.                 for (int k = 0; k < n; k++) {
  14.                     dp[i][j] = Math.min(dp[i][j], dp[i - 1][k] + grid[i][j] + moveCost[grid[i - 1][k]][j]);
  15.                 }
  16.             }
  17.         }
  18.         // 返回最后一行的最小值
  19.         return Arrays.stream(dp[m - 1]).min().getAsInt();
  20.     }
  21. }