dijkstra+链式向前星

闲来无事，学习了下新的存储结构：链式向前星。之前自己一直用邻接链表，发现这种方式好像不如链式向前星，具体原因也搞得不是很明白，有大佬可以帮忙解答一下。
主要记录下链式向前星的存储应用结合dijkstra求最短路径

P4779 https://www.luogu.com.cn/problem/P4779

代码如下：

package com.practise;


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

import static java.lang.Integer.parseInt;

//【模板】单源最短路径（标准版）
public class P4779_链式向前星实现dijkstra {

    static StringTokenizer st;
    static int n, m, s, cnt = 1, inf = 2087654321;
    static Edge[] edges;
    static int[] head, dist;
    static PriorityQueue<Point> pq;
    static boolean visited[];

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        st = new StringTokenizer(br.readLine());
        n = parseInt(st.nextToken());
        m = parseInt(st.nextToken());
        s = parseInt(st.nextToken());
        edges = new Edge[m + 1];
        head = new int[n + 1];
        dist = new int[n + 1];
        visited = new boolean[n + 1];
        Arrays.fill(head, -1);
        Arrays.fill(dist, inf);

        for (int i = 1; i <= m; i++) {
            st = new StringTokenizer(br.readLine());
            int u = parseInt(st.nextToken());
            int v = parseInt(st.nextToken());
            int w = parseInt(st.nextToken());
            addEdge(u, v, w);
        }
        pq = new PriorityQueue<>();
        dijkstra();

        //System.out.println(dist);
        for (int i = 1; i <= n; i++) {
            System.out.print(dist[i]);
            if (i != n) System.out.print(" ");
        }
    }

    private static void dijkstra() {
        dist[s] = 0;
        pq.add(new Point(s, 0));
        while (!pq.isEmpty()) {
            Point poll = pq.poll();
            if (visited[poll.s]) continue;
            visited[poll.s] = true;
            for (int i = head[poll.s]; i != -1; i = edges[i].next) {
                int to = edges[i].to;
                if (dist[to] > dist[poll.s] + edges[i].weight) {
                    dist[to] = dist[poll.s] + edges[i].weight;
                    if (!visited[to]) {
                        pq.add(new Point(to, dist[to]));
                    }
                }
            }
        }
    }

    private static void addEdge(int from, int to, int w) {
        edges[cnt] = new Edge(to, head[from], w);
        head[from] = cnt++;
    }


    static class Point implements Comparable<Point> {
        int s;
        int w;

        public Point(int s, int w) {
            this.s = s;
            this.w = w;
        }

        @Override
        public int compareTo(Point point) {
            return this.w - point.w;
        }
    }

    static class Edge {
        int to;
        int next;
        int weight;

        public Edge(int to, int next, int weight) {
            this.to = to;
            this.next = next;
            this.weight = weight;
        }
    }
}