单源最短路径-Dijkstra算法（朴素+堆优化)

单源最短路径-Dijkstra算法

首先简单解释以下什么时候使用优化，什么时候使用朴素，我们使用n表示点数，m表示边数。

1. 当图是一个稠密图的时候，也就是m与$n^2$是一个数量级的时候，我们采用邻接矩阵的形式存储，使用朴素的Dijkstra算法就可以。
2. 当是一个稀疏图或者边数很大的时候，可以选择在使用邻接表或者链式前向星来存储图，这时就可以采用堆优化来完成Dijkstra。

时间复杂度

朴素的Dijkstra算法的时间复杂度是O($n^2$)，n是顶点的个数，是因为每次都需要找到当前最小的；而采用堆优化正是优化的这一步，使用小根堆，那么找到最小就是O(1)，在将新的节点插入到优先队列时的时间复杂度时logn（n是顶点的个数，小根堆的构建），一共有m条边，所以时间复杂度就是O(mlogn)。

朴素算法

/**
 * 有向图的最短路路径
 * 从s点出发，到达其他点的最短路径
 * @param s
 */
public static void Dijkstra(int s){
    int INF = 0x3f3f3f3f;
    Scanner in = new Scanner(System.in);
    int n = in.nextInt(); // 顶点数
    int m = in.nextInt(); // 边数
    int[][] g = new int[n + 1][n + 1];
    boolean[] st = new boolean[n + 1];
    int[] dist = new int[n + 1];
    for(int i = 1;i <= n;i ++) Arrays.fill(g[i],INF);
    while(m --> 0){
        int a = in.nextInt();
        int b = in.nextInt();
        int c = in.nextInt();
        g[a][b] = Math.min(g[a][b],c);// 这个因为可能存在重边，所以选择出最短的
    }
    Arrays.fill(dist,INF);
    dist[s] = 0;
    for(int i = 0;i < n;i ++){
        int t = -1;
        // 找到未加入结果集的最短的距离
        for(int j = 1;j <= n;j ++){
            if(!st[j] && (t == -1 || dist[j] < dist[t])){
                t = j;
            }
        }
        st[t] = true;
        // 进行松弛操作
        for(int j = 1;j <= n;j ++){
            if(!st[j])dist[j] = Math.min(dist[j],dist[t] + g[t][j]);
        }
    }
    System.out.println(Arrays.toString(dist));
}

堆优化

借助优先队列（小根堆），这样在寻找最小的dist的时间复杂度就降低到了O(1)，但是每次松弛之后插入到优先队列的时间复杂度就会变成O(logn)，所以整体的时间复杂度就是O(mlogn)。

package 图;

import java.util.*;

/**
 * dijkstra的堆优化版本
 * 稀疏图的时候或者边数很大的时候
 */
public class Short {
    static final int N = (int) (1.5 * 1e5), INF = 0x3f3f3f3f;
    static int[] h = new int[N], e = new int[N], ne = new int[N], w = new int[N], dist = new int[N];
    static boolean[] st = new boolean[N];
    static int n, m, idx;
    public static void main(String[] args) {
        Arrays.fill(dist, INF);
        Arrays.fill(h, -1);
        idx = 0;
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        m = in.nextInt();
        while(m --> 0){
            int a = in.nextInt();
            int b = in.nextInt();
            int c = in.nextInt();
            add(a, b, c);
        }
        dijkstra(1);
    }

    public static void add(int a, int b, int c){
        e[idx] = b;
        w[idx] = c;
        ne[idx] = h[a];
        h[a] = idx ++;
    }

    public static void dijkstra(int u){
        Queue<pos> q = new PriorityQueue<>((a,b) -> a.dist - b.dist);
        dist[u] = 0;
        q.offer(new pos(u, dist[u]));
        while(!q.isEmpty()){
            pos p = q.poll();
            // 我们的优先队列是直接插入的，并不是把已经在优先队列中的进行更新。
            // 所以我们使用st来标记当前点是否已经被用过，不加也不影响，因为我们是小根堆，也就是说有效的已经被使用了，其余的全是无效的，为了提高效率，我们就标记一下就行。
            if(st[p.index]) continue;
            st[p.index] = true;
            for(int i = h[p.index]; i != -1; i = ne[i]){
                int j = e[i];
                if(p.dist + w[i] < dist[j]){
                    dist[j] = p.dist + w[i];
                    q.offer(new pos(j, dist[j]));
                }
            }
        }
        for (int i = 1; i <= n; i++) {
            System.out.print(dist[i] + " ");
        }
    }
}
class pos{
    int index;
    int dist;

    public pos(int index, int dist) {
        this.index = index;
        this.dist = dist;
    }
}