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

【LeetCode:2304. 网格中的最小路径代价 | dijkstra(迪杰斯特拉)】

在这里插入图片描述

🚀 算法题 🚀

🌲 算法刷题专栏 | 面试必备算法 | 面试高频算法 🍀
🌲 越难的东西,越要努力坚持，因为它具有很高的价值，算法就是这样✨
🌲 作者简介：硕风和炜，CSDN-Java领域新星创作者🏆，保研|国家奖学金|高中学习JAVA|大学完善JAVA开发技术栈|面试刷题|面经八股文|经验分享|好用的网站工具分享💎💎💎
🌲 恭喜你发现一枚宝藏博主,赶快收入囊中吧🌻
🌲 人生如棋，我愿为卒，行动虽慢，可谁曾见我后退一步？🎯🎯

🚀 算法题 🚀

在这里插入图片描述

🍔 目录

- 🚩 题目链接
- ⛲ 题目描述
- 🌟 求解思路&实现代码&运行结果
- - ⚡ dijkstra(迪杰斯特拉)
  - - 🥦 求解思路
    - 🥦 实现代码
    - 🥦 运行结果
- 💬 共勉

🚩 题目链接

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

🌟 求解思路&实现代码&运行结果

⚡ dijkstra(迪杰斯特拉)

🥦 求解思路

该题通过迪杰斯特拉算法求解即可，但是需要注意的是，我们需要找到一个开始的节点位置，以及结束的位置，因为题目中给定的是可以从第一行任意节点开始，到达最后一行任意节点，这个过程通过设置俩个虚拟的节点解决。
其它的过程就是dijkstra基本求解过程。
具体实现代码如下：
需要注意的是，该题还可以通过dp来做，后续补充。敬请期待。

🥦 实现代码

class Solution {
    public int minPathCost(int[][] grid, int[][] moveCost) {
        int m=grid.length,n=grid[0].length;
        int[][] map=new int[m*n+2][m*n+2];
        for(int i=0;i<map.length;i++) Arrays.fill(map[i],Integer.MAX_VALUE/2);
        int start=m*n;
        for(int j=0;j<n;j++){
            int to=grid[0][j];
            map[start][to]=0+to;
        }
        for(int i=0;i<m-1;i++){
            for(int j=0;j<n;j++){
                int from=grid[i][j];
                for(int k=0;k<n;k++){
                    int to=grid[i+1][k];
                    map[from][to]=moveCost[from][k]+to;
                }
            }
        }
        for(int j=0;j<n;j++){
            int from=grid[m-1][j];
            map[from][n*m+1]=0;
        }
        int[] ans=dijkstra(grid,map,moveCost,start);
        for(int v:ans){
            System.out.println(v);
        }
        return ans[n*m+1];
    }

    public int[] dijkstra(int[][] grid,int[][] map,int[][] moveCost,int start){
        int m=grid.length,n=grid[0].length;
        PriorityQueue<int[]> queue=new PriorityQueue<>((a,b)->a[1]-b[1]);
        queue.add(new int[]{start,0});
        boolean[] flag=new boolean[m*n+2];
        Arrays.fill(flag,false);
        int[] dist=new int[m*n+2];
        Arrays.fill(dist,Integer.MAX_VALUE/2);
        dist[m*n]=0;
        while(!queue.isEmpty()){
            int[] arr=queue.poll();
            int next=arr[0],cost=arr[1];
            if(flag[next]) continue;
            flag[next]=true;
            for(int ne=0;ne<=m*n+1;ne++){
                if(map[next][ne]+dist[next]<dist[ne]){
                    dist[ne]=map[next][ne]+dist[next];
                    queue.add(new int[]{ne,dist[ne]});
                }
            }
        }
        return dist;
    }
}