华为OD机试 - 寻找最优的路测线路 - Dijkstra算法（Java 2024 E卷 200分）

哪吒

于 2024-09-11 18:13:33 发布

阅读量654

点赞数 7

分类专栏：搬砖工逆袭Java架构师文章标签：华为od 算法 java Dijkstra算法

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/guorui_java/article/details/141500591

版权

搬砖工逆袭Java架构师专栏收录该内容

260 篇文章 1454 订阅

订阅专栏

在这里插入图片描述

华为OD机试 2024E卷题库疯狂收录中，刷题点这里

专栏导读

本专栏收录于《华为OD机试（JAVA）真题（E卷+D卷+A卷+B卷+C卷）》。

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

一、题目描述

评估一个网络的信号质量 Q，其中一个做法是将网络划分为栅格，然后对每个栅格的信号质量计算。

路测的时候，希望选择一条信号最好的路线（彼此相连的栅格集合）进行演示。

现给出 R 行 C 列的整数数组 Cov，每个单元格的数值 S 即为该栅格的信号质量（已归一化，无单位，值越大信号越好）。

要求从 [0,0] 到 [R−1,C−1] 设计一条最优路测路线。返回该路线得分。

规则：

路测路线可以以上下左右四个方向，不能对角。
路线的评分是以路线上的信号最差的栅格为准的，例如路径 8→4→5→9 的值为 4，该路线评分为 4。路线最优表示该条路线的评分最高。

二、输入描述

第一行表示栅格的行数 R

第二行表示栅格的列数 C

第三行开始，每一行表示栅格地图一行的信号值，如 5 4 5

三、输出描述

最优路线的得分

四、测试用例

测试用例1：

1、输入

3
3
5 4 5
1 2 6
7 4 6

2、输出

3、说明

路线为：5→4→5→6→6

测试用例2：

1、输入

6
5
3 4 6 3 4
0 2 1 1 7
8 8 3 2 7
3 2 4 9 8
4 1 2 0 0
4 6 5 4 3

2、输出

3、说明

路线为：3→4→6→3→4→7→7→8→9→4→3→8→8→3→4→4→6→5→4→3

五、解题思路

这道题要求找到一个从左上角 [0,0] 到右下角 [R-1,C-1] 的最佳路线，并且最佳路线的得分是该路线中信号质量最差的那个值。为了实现这一目标，我们可以使用广度优先搜索 (BFS) 或者是优先队列 (Dijkstra 算法) 来找到最佳路径。

优先队列帮助我们快速获取当前最优的路径（信号最差值最大的路径），提高了算法效率。

Dijkstra-like算法通过贪心的思想，每一步选择当前最优的路径，逐步逼近全局最优解。这种算法在路径搜索问题中非常有效，尤其是当路径上的某个值（如信号质量）需要最大化或最小化时。

Dijkstra算法通常用于求解加权图中的最短路径问题。它通过使用优先队列，每次扩展最短路径节点，逐步找到从起点到终点的最短路径。
本题使用类似于Dijkstra的思路：从起点开始，每次优先选择当前路径中最小信号值最大的路径进行扩展，直到到达终点。这保证了我们找到的路径是最优的，即路径中的信号最差值尽可能大。

具体步骤：

初始条件：
- 从左上角开始，使用 BFS 或优先队列来探索所有可能的路径。
- 使用一个二维数组 visited 来标记每个栅格是否已被访问。
- 使用一个队列或优先队列来存储当前的节点及其路径上的最小信号值。
搜索过程：
- 从队列中取出一个节点，检查其四个方向的相邻栅格是否可以访问。
- 对于每个可以访问的相邻栅格，更新其路径上的最小信号值，然后将其加入队列。
- 如果已经到达右下角，则记录当前路径的信号质量，更新最优结果。
终止条件：
- 当到达右下角时，路径上最小的信号值即为该路径的得分。
- 在搜索完成后，输出最优路线的得分。

六、Java算法源码

public class OdTest01 {
    // 定义方向数组，表示上、下、左、右四个方向的偏移
    private static final int[][] DIRECTIONS = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int R = scanner.nextInt();
        int C = scanner.nextInt();
        int[][] grid = new int[R][C];

        for (int i = 0; i < R; i++) {
            for (int j = 0; j < C; j++) {
                grid[i][j] = scanner.nextInt();
            }
        }

        int result = findBestRouteSignal(grid, R, C);
        System.out.println(result);
    }

    public static int findBestRouteSignal(int[][] grid, int R, int C) {
        // 优先队列，按路径的信号质量从大到小排序
        PriorityQueue<Cell> pq = new PriorityQueue<>((a, b) -> b.minSignal - a.minSignal);
        pq.offer(new Cell(0, 0, grid[0][0]));

        // 标记矩阵，防止重复访问
        boolean[][] visited = new boolean[R][C];
        visited[0][0] = true;

        while (!pq.isEmpty()) {
            Cell current = pq.poll();

            // 如果到达右下角，返回最优路径的最小信号值
            if (current.x == R - 1 && current.y == C - 1) {
                return current.minSignal;
            }

            // 探索四个方向的相邻栅格
            for (int[] dir : DIRECTIONS) {
                int newX = current.x + dir[0];
                int newY = current.y + dir[1];

                // 检查新坐标是否在边界内且未访问过
                if (newX >= 0 && newX < R && newY >= 0 && newY < C && !visited[newX][newY]) {
                    visited[newX][newY] = true;
                    pq.offer(new Cell(newX, newY, Math.min(current.minSignal, grid[newX][newY])));
                }
            }
        }

        // 如果未能找到路径，返回 -1
        return -1;
    }

    // 定义栅格类，包含其坐标和路径中的最小信号值
    static class Cell {
        int x, y, minSignal;

        public Cell(int x, int y, int minSignal) {
            this.x = x;
            this.y = y;
            this.minSignal = minSignal;
        }
    }
}