华为OD机试真题-电脑病毒感染-2023年OD统一考试（C卷）

shineJo

已于 2024-04-01 14:56:37 修改

阅读量265

点赞数 3

分类专栏：华为OD机考C卷文章标签：华为od java

于 2024-04-01 14:55:19 首次发布

本文链接：https://blog.csdn.net/smallsun0801/article/details/137225796

版权

华为OD机考C卷专栏收录该内容

11 篇文章 0 订阅

订阅专栏

本文介绍了如何使用Java实现迪杰斯特拉算法解决2023年OD统一考试中的问题，涉及求起始点到其他点的最短路径，并检查图的连通性。代码展示了创建邻接矩阵、执行Dijkstra算法以及处理非连通图的情况。

摘要由CSDN通过智能技术生成

题目
华为OD机试真题-电脑病毒感染-2023年OD统一考试（C卷）
解题思路
用迪杰斯特拉算法求最短路径。起始点到其他各个点的最短路径求最大值。
另外需要判断图的连通性，如果是非联通图。则返回-1。

3、java解法

public class Test1Service {


    private static final int MAX_VALUE = 1000000;
    public static void main(String[] args) {

        while(true){

            Scanner sc = new Scanner(System.in);
            int veNum = sc.nextInt();
            sc.nextLine();
            int edgeNum = sc.nextInt();
            sc.nextLine();
            int[][] edges = new int[edgeNum][3];
            for (int i = 0; i < edgeNum; i++) {
                edges[i][0] = sc.nextInt();
                edges[i][1] = sc.nextInt();
                edges[i][2] = sc.nextInt();
                sc.nextLine();
            }

            int start = sc.nextInt();
            sc.nextLine();

            System.out.println(cal(edges, veNum, start));
        }
    }


    public static int cal(int[][] edges, int n, int start) {

        //创建邻接矩阵
        int[][] adj = new int[n][n];
        for (int i = 0; i < n; i++) {
            Arrays.fill(adj[i], MAX_VALUE);
        }

        for (int[] edge : edges) {
            int node1 = edge[0];
            int node2 = edge[1];
            int weight = edge[2];
            adj[node1 - 1][node2 - 1] = weight;
            adj[node2 - 1][node1 - 1] = weight;
        }

        int[] ret = dijkstra(adj, start - 1);
        int max = -1;
        for (int x : ret) {
            if(x == MAX_VALUE){
                return -1;
            }
            max = Math.max(max, x);
        }
        return max;
    }


    /**
     * Dijkstra算法：计算start点到其他所有点的最短距离。
     * @param matrix 邻接矩阵
     * @param start 原点
     * @return start点到其他所有点的最短距离。
     */
    public static int[] dijkstra(int[][] matrix, int start){

        int[] shortest = new int[matrix.length];
        int[] isVisited = new int[matrix.length];

        shortest[start] = 0;
        isVisited[start] = 1;

        for (int i = 1; i < matrix.length; i++) {

            int min = MAX_VALUE;
            int index = -1;

            for (int j = 0; j < matrix.length; j++) {
                if(isVisited[j] == 0 && matrix[start][j] < min){
                    min = matrix[start][j];
                    index = j;
                }
            }

            shortest[index] = min;
            isVisited[index] = 1;

            for (int m = 0; m < matrix.length; m++) {
                int tmp = matrix[start][index] + matrix[index][m];
                if(isVisited[m] == 0 && matrix[index][m] < MAX_VALUE && tmp < matrix[start][m]){
                    matrix[start][m] = tmp;
                }
            }
        }
        return shortest;
    }