P3371 【模板】单源最短路径（弱化版）

P3371 【模板】单源最短路径（弱化版）

输入输出样例

输入样例#1： 复制

4 6 1
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
1 4 4

输出样例#1： 复制

0 2 4 3

说明

时空限制：1000ms,128M

数据规模：

对于20%的数据：N<=5，M<=15；

对于40%的数据：N<=100，M<=10000；

对于70%的数据：N<=1000，M<=100000；

对于100%的数据：N<=10000，M<=500000。保证数据随机。

对于真正 100% 的数据，请移步 P4779。请注意，该题与本题数据范围略有不同。

 思路

堆优化的dijkstra

import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;

public class Main {
    static int N = 10005;
    static int M = 500005;
    static int n,m;
    static int num = 0;
    static P[] p = new P[M];
    static int[] head = new int[N];
    static int[] dis = new int[N];
    public static void main(String[] args) throws Exception {
        Scanner cin = new Scanner(System.in);
        n = cin.nextInt();
        m = cin.nextInt();
        int s = cin.nextInt();

        for(int i=0; i<m; i++) {
            int a = cin.nextInt();
            int b = cin.nextInt();
            int c = cin.nextInt();
            add(a, b, c);
        }
        dijkstra(s);
        
        for(int i=1; i<n; i++)
            System.out.print(dis[i]+" ");
        System.out.println(dis[n]);
    }
    private static void dijkstra(int s) {
        boolean[] vis = new boolean[N];

        Queue<Node> q = new PriorityQueue<>();
        Arrays.fill(dis, 2147483647);
        dis[s] = 0;
        Arrays.fill(vis, false);
        q.add(new Node(0, s));
        while(!q.isEmpty()) {
            Node t = q.poll();
            if(vis[t.d]) continue;
            vis[t.d] = true;
            for(int i = head[t.d]; ; i=p[i].nex) {
                if(p[i] == null) break;
                int temp = p[i].to;
                if(dis[temp] > dis[t.d] + p[i].w && dis[t.d] != 2147483647) {
                    dis[temp] = dis[t.d] + p[i].w;
                    q.add(new Node(dis[temp], temp));
                }
            }
        } 
    }
    
    private static void add(int u, int v, int w) {
        p[++num] = new P();
        p[num].to = v;
        p[num].w = w;
        p[num].nex = head[u];
        head[u] = num;
    }
    static class P{
        int to, nex, w;
    }

    static class Node implements Comparable{
        int val;
        int d;
        
        public Node(int val, int d) {
            this.val = val;
            this.d = d;
        }

        @Override
        public int compareTo(Object arg0) {
            Node d = (Node)arg0;
            return this.val - d.val;
        }
    }
}