单源最短路径问题java

单源最短路径问题通常可以使用 Dijkstra 算法或 Bellman-Ford 算法来解决。下面是一个使用 Dijkstra 算法的 Java 实现：

import java.util.*;

public class Dijkstra {
    private int dist[];
    private Set<Integer> settled;
    private PriorityQueue<Node> pq;
    private int V; // number of vertices
    List<List<Node> > adj;

    public Dijkstra(int V) {
        this.V = V;
        dist = new int[V];
        settled = new HashSet<Integer>();
        pq = new PriorityQueue<Node>(V, new Node());
    }

    public void dijkstra(List<List<Node> > adj, int src) {
        this.adj = adj;

        for (int i = 0; i < V; i++)
            dist[i] = Integer.MAX_VALUE;

        pq.add(new Node(src, 0));
        dist[src] = 0;
        while (settled.size() != V) {
            int u = pq.remove().node;
            settled.add(u);
            e_Neighbours(u);
        }
    }

    private void e_Neighbours(int u) {
        int edgeDistance = -1;
        int newDistance = -1;

        for (int i = 0; i < adj.get(u).size(); i++) {
            Node v = adj.get(u).get(i);

            if (!settled.contains(v.node)) {
                edgeDistance = v.cost;
                newDistance = dist[u] + edgeDistance;

                if (newDistance < dist[v.node])
                    dist[v.node] = newDistance;

                pq.add(new Node(v.node, dist[v.node]));
            }
        }
    }

    public static void main(String[] args) {
        int V = 5;
        int source = 0;

        List<List<Node> > adj = new ArrayList<List<Node> >();
        for (int i = 0; i < V; i++) {
            List<Node> item = new ArrayList<Node>();
            adj.add(item);
        }

        adj.get(0).add(new Node(1, 9));
        adj.get(0).add(new Node(2, 6));
        adj.get(0).add(new Node(3, 5));
        adj.get(0).add(new Node(4, 3));

        adj.get(2).add(new Node(1, 2));
        adj.get(2).add(new Node(3, 4));

        Dijkstra dpq = new Dijkstra(V);
        dpq.dijkstra(adj, source);

        System.out.println("The shorted path from node :");
        for (int i = 0; i < dpq.dist.length; i++)
            System.out.println(source + " to " + i + " is " + dpq.dist[i]);
    }
}

class Node implements Comparator<Node> {
    public int node;
    public int cost;

    public Node() {}

    public Node(int node, int cost) {
        this.node = node;
        this.cost = cost;
    }

    @Override
    public int compare(Node node1, Node node2) {
        if (node1.cost < node2.cost)
            return -1;
        if (node1.cost > node2.cost)
            return 1;
        return 0;
    }
}

这个实现假设图是以邻接表的形式表示的，其中 `List<List<Node>> adj` 表示邻接表。算法的主要步骤包括：

1. 初始化距离数组 `dist` 和已经处理的节点集合 `settled`。
2. 将起点加入优先队列，并将起点到自己的距离设为 0。
3. 当优先队列不为空时，取出距离起点最近的节点 u。
4. 将节点 u 加入已经处理的节点集合 settled。
5. 遍历节点 u 的所有邻居，并计算起点到这些邻居的距离。如果新的距离比已知的距离更短，则更新距离数组并将邻居节点加入优先队列。

这个实现的时间复杂度是 O(E log V)，其中 E 是边数，V 是节点数。