如题，用的Java，算法是小根堆优化版的dijkstra算法，但是只能过2个用例，后面三个用例全t了，输入输出也优化了，求大佬帮忙解惑为什么过不了？

import javax.swing.*;
import java.io.*;
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Main {

    static final int N = (int) 1e6 + 5;
    static final int M = 2 * N;
    static final int MOD=100003;

    static int inx;
    static int[] head = new int[N];
    static int[] to = new int[M];
    static int[] next = new int[M];

    static int[] ans=new int[N];
    static int[] distance = new int[N];
    static boolean[] visit = new boolean[N];
    static PriorityQueue<int[]> heap = new PriorityQueue<>((o1, o2) -> o1[1] - o2[1]);

    public static void main(String[] args) throws IOException {
        Scanner br=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
        PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));

        int n = br.nextInt();
        int m = br.nextInt();

        Initi(n);   // 初始化方法

        for (int i = 0, u, v; i < m; ++i) {
            u = br.nextInt();
            v = br.nextInt();
            
            // 建图-无向图
            addEdge(u, v);
            addEdge(v, u);
        }
        
        // 算法方法
        dijkstra();

        for(int i=1; i<=n; ++i){
            pw.println(ans[i]);
        }
        pw.close();
        br.close();
    }

    public static void dijkstra() {
        ans[1]=1;
        distance[1] = 0;
        heap.add(new int[]{1, 0});

        while (!heap.isEmpty()) {
            int u = heap.poll()[0];
            if (visit[u]) {
                continue;
            }
            visit[u] = true;

            for (int ei = head[u], v; ei != 0; ei = next[ei]) {
                v = to[ei];

                if (distance[u] + 1 == distance[v]) {
                    // 如果当时路劲相当，那么就可以认为从1过u，到达v的距离与不经过u的距离是一样的，同样属于最短路
                    // 这样的话，两条路径相加即可
                    ans[v] +=ans[u];
                    ans[v]%=MOD;
                }
                else if(distance[u] + 1 < distance[v]) {
                    // 如果当前路径不是最短路，那么将ans中存储的就是替换成最短路径的条数
                    // 最短路径条数替换
                    ans[v]=ans[u];
                    distance[v] = distance[u] + 1;
                    if(!visit[v]){
                        heap.add(new int[]{v, distance[v]});
                    }
                }
            }
        }
    }


    public static void addEdge(int u, int v) {
        to[inx] = v;
        next[inx] = head[u];
        head[u] = inx++;
    }

    public static void Initi(int n) {
        inx = 1;
        heap.clear();
        Arrays.fill(ans,1,n+1,0);
        Arrays.fill(head, 1, n + 1, 0);
        Arrays.fill(visit, 1, n + 1, false);
        Arrays.fill(distance, 1, n + 1, Integer.MAX_VALUE);
    }
}