门(GATE-IT-2004) 第 54 题介绍

这道题是一个经典的图论问题。给定一张无向图和两个节点 s 和 t，要求从 s 到 t 的所有简单路径中最小边权和的最大值。如果不存在从 s 到 t 的路径，则输出 "NO PATH EXISTS"。

这个问题可以用深度优先搜索 (DFS) 或广度优先搜索 (BFS) 来解决，但是这两种方法的时间复杂度都非常高。更好的解决方法是使用 Dijkstra 算法或 A* 算法，它们都可以在多项式时间内解决该问题。

下面是 Dijkstra 算法的代码示例：

import java.util.*;

class Node implements Comparable<Node> {
    int id, dist;
    public Node(int id, int dist) {
        this.id = id;
        this.dist = dist;
    }
    public int compareTo(Node other) {
        return Integer.compare(this.dist, other.dist);
    }
}

public class Main {
    static final int INF = Integer.MAX_VALUE;
    static int[][] graph;
    static int n;

    static int dijkstra(int s, int t) {
        int[] dist = new int[n];
        Arrays.fill(dist, INF);
        dist[s] = 0;

        PriorityQueue<Node> pq = new PriorityQueue<>();
        pq.offer(new Node(s, 0));

        while (!pq.isEmpty()) {
            Node node = pq.poll();
            if (node.id == t) break;
            if (dist[node.id] < node.dist) continue;

            for (int v = 0; v < n; v++) {
                if (graph[node.id][v] >= 0 && dist[v] > dist[node.id] + graph[node.id][v]) {
                    dist[v] = dist[node.id] + graph[node.id][v];
                    pq.offer(new Node(v, dist[v]));
                }
            }
        }

        return dist[t];
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        int m = scanner.nextInt();
        graph = new int[n][n];
        for (int[] row: graph) Arrays.fill(row, -1);
        for (int i = 0; i < m; i++) {
            int u = scanner.nextInt() - 1;
            int v = scanner.nextInt() - 1;
            int w = scanner.nextInt();
            graph[u][v] = graph[v][u] = w;
        }
        int s = scanner.nextInt() - 1;
        int t = scanner.nextInt() - 1;
        int ans = dijkstra(s, t);
        System.out.println(ans == INF ? "NO PATH EXISTS" : ans);
    }
}

对于任何无向图上的最短路径问题，Dijkstra 算法是一个很好的选择，因为它可以保证正确性，而且效率通常比常规搜索要高得多。