力扣2304 网格中的最小路径代价

2023-11-22

难度 中等

原题：

2304. 网格中的最小路径代价 - 力扣（LeetCode）

给你一个下标从 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 。

        第一次看我也云里雾里的，grid都能理解是图中的这个矩阵，moveCost就是每一个数字的路径，比如grid图中的4，箭头上的数字是2和4，所以moveCost[4]就是[2,4]，同理moveCost[0]的[9,8]就是图中的0的箭头，可以看到0下面的箭头是9和8，那么我们要求的结果就是从顶层开始到达底层所经过的箭头与矩阵数字和的最小值。

        这个题实际上我也没做出来，找到了几道高效简洁的解法然后根据自己理解照猫画虎写出了自己的解法

这一题我用的是修改原矩阵，从上往下加，每次将当前值替换为之前相加获得的最小值

public int minPathCost(int[][] grid, int[][] moveCost) {
            int m = grid.length, n = grid[0].length;//获取矩阵的长和宽
            int[][] grid2 = new int[m][n];//因为数组会不停的修改，所以需要一个原数组的克隆来获取对应的moveCost
            for (int i = 0; i < m; i++) {
                //注意这里绝对不能用clone()方法，因为这是一个二维数组，clone是浅拷贝，
                // 仅适用于基础类型不适用于对象类型，而grid的数据类型是数组类型，
                // clone方法拷贝的元素还是原本的地址，所以无论修改grid还是grid2都会影响原数组，
                //所以此处使用了复杂的方法克隆数组
                for (int j = 0; j < n; j++) {
                    grid2[i][j] = grid[i][j];
                }
            }
            for (int i = 1; i < m; i++) {//当i=0时在第一行，这里我们从第2行开始计算前n行的和
                for (int j = 0; j < n; j++) {//这个j到下一层循环再讲
                    int res = Integer.MAX_VALUE;//因为我们要取最小值，这里可以用最大值作为比较的基础值
                    for (int k = 0; k < n; k++) {
                        int[] cost = moveCost[grid[i - 1][k]];//注意这里是grid不是grid2，因为grid2是要修改的数组，
                        // 而grid是不会变化的原数组，moveCost的下标即是grid数组中的数字，该下标对应是数组即是grid中的数字的路径
                        res = Math.min(res, grid2[i - 1][k] + cost[j]);//然后开始对比上一层每个矩阵上的数字与其路径和的最小值
                    }
                    grid2[i][j] += res;//获取最小值之后就可以把最小值加到矩阵的当前位置上，那么到下一层就可以直接从这一层开始加，
                    //不用从头开始算了
                }
            }
            int ans = Integer.MAX_VALUE;
            for (int res : grid2[m-1]) {//我们的目标就是最后一行的最小值
                ans = Math.min(ans, res);
            }
            return ans;
        }

当然这个办法可以通过倒着加优化，因为原答案就是这样的