Java Dijkstra Alogrithm给出了错误的最短路径

我将

Dijkstra算法的
C++
实现转换为
Java
。
当我运行
Java
代码时，没有得到预期的输出

从我的
C++
代码中预期：

Minimum distance for source vertex 0 to reach vertex 0 is 0
Minimum distance for source vertex 0 to reach vertex 1 is 4
Minimum distance for source vertex 0 to reach vertex 2 is 12
Minimum distance for source vertex 0 to reach vertex 3 is 19
Minimum distance for source vertex 0 to reach vertex 4 is 21
Minimum distance for source vertex 0 to reach vertex 5 is 11
Minimum distance for source vertex 0 to reach vertex 6 is 9
Minimum distance for source vertex 0 to reach vertex 7 is 8
Minimum distance for source vertex 0 to reach vertex 8 is 14

Minimum distance for source vertex 0 to reach vertex 0 is 0
Minimum distance for source vertex 0 to reach vertex 1 is 4
Minimum distance for source vertex 0 to reach vertex 2 is 2
Minimum distance for source vertex 0 to reach vertex 3 is 7
Minimum distance for source vertex 0 to reach vertex 4 is 9
Minimum distance for source vertex 0 to reach vertex 5 is 2
Minimum distance for source vertex 0 to reach vertex 6 is 1
Minimum distance for source vertex 0 to reach vertex 7 is 1
Minimum distance for source vertex 0 to reach vertex 8 is 2

实际来自
Java
code:

Minimum distance for source vertex 0 to reach vertex 0 is 0
Minimum distance for source vertex 0 to reach vertex 1 is 4
Minimum distance for source vertex 0 to reach vertex 2 is 12
Minimum distance for source vertex 0 to reach vertex 3 is 19
Minimum distance for source vertex 0 to reach vertex 4 is 21
Minimum distance for source vertex 0 to reach vertex 5 is 11
Minimum distance for source vertex 0 to reach vertex 6 is 9
Minimum distance for source vertex 0 to reach vertex 7 is 8
Minimum distance for source vertex 0 to reach vertex 8 is 14

Minimum distance for source vertex 0 to reach vertex 0 is 0
Minimum distance for source vertex 0 to reach vertex 1 is 4
Minimum distance for source vertex 0 to reach vertex 2 is 2
Minimum distance for source vertex 0 to reach vertex 3 is 7
Minimum distance for source vertex 0 to reach vertex 4 is 9
Minimum distance for source vertex 0 to reach vertex 5 is 2
Minimum distance for source vertex 0 to reach vertex 6 is 1
Minimum distance for source vertex 0 to reach vertex 7 is 1
Minimum distance for source vertex 0 to reach vertex 8 is 2

我试图在java代码中寻找bug，我仔细检查了如果我复制了C++代码，我没有发现任何不同。p>
我已经花了很多时间调试我的代码

我不明白出了什么问题！我非常需要帮助，谢谢

代码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;

public class Dijkstra
{
    public static final int INF = 100000;

    private static class IPair implements Comparable<IPair>
    {
        int first;
        int second;

        IPair(int first, int second)
        {
            this.first = first;
            this.second = second;
        }

        public int compareTo(IPair that)
        {
            return this.first - that.first;
        }
    }

    public static int[] dijkstra(List<IPair>[] adj, int source)
    {
        Queue<IPair> pq = new PriorityQueue<>();
        int[] dist = new int[adj.length];
        boolean[] visited = new boolean[adj.length];

        Arrays.fill(dist, INF);

        pq.add(new IPair(0, source));
        dist[source] = 0;

        while (!pq.isEmpty())
        {
            int u = pq.poll().second;

            if (visited[u])
                continue;

            System.err.println(u);

            visited[u] = true;

            for (IPair pair : adj[u])
            {
                int v = pair.first;
                int weight = pair.second;

                if (dist[v] > dist[u] + weight)
                {
                    dist[v] = dist[u] + weight;
                    pq.add(new IPair(dist[v], v));

                    System.err.println(Arrays.toString(dist));
                }
            }
        }

        return dist;
    }

    private static void addEdge(List<IPair>[] adj, int u, int v, int weight)
    {
        adj[u].add(new IPair(v, weight));
        adj[v].add(new IPair(u, weight));
    }

    public static void main(String[] args)
    {
        int V = 9;

        List<IPair>[] adj = new ArrayList[V];

        Arrays.fill(adj, new ArrayList<IPair>());

        addEdge(adj, 0, 1, 4);
        addEdge(adj, 0, 7, 8);
        addEdge(adj, 1, 2, 8);
        addEdge(adj, 1, 7, 11);
        addEdge(adj, 2, 3, 7);
        addEdge(adj, 2, 8, 2);
        addEdge(adj, 2, 5, 4);
        addEdge(adj, 3, 4, 9);
        addEdge(adj, 3, 5, 14);
        addEdge(adj, 4, 5, 10);
        addEdge(adj, 5, 6, 2);
        addEdge(adj, 6, 7, 1);
        addEdge(adj, 6, 8, 6);
        addEdge(adj, 7, 8, 7);

        int[] dist = dijkstra(adj, 0);

        for (int i = 0; i < V; ++i)
            System.out.println("Minimum distance for source vertex " + 0 + " to reach vertex " + i + " is " + dist[i]);
    }
}

import java.util.ArrayList；
导入java.util.array；
导入java.util.List；
导入java.util.PriorityQueue；
导入java.util.Queue；
公共级迪杰斯特拉酒店
{
公共静态最终int INF=100000；
私有静态类IPair实现了可比较的
{
int优先；
int秒；
IPair（整数第一，整数第二）
{
this.first=first；
这个秒=秒；
}
公共整数比较（IPair-that）
{
返回this.first-that.first；
}
}
公共静态int[]dijkstra（列表[]调整，int源）
{
队列pq=新的优先级队列（）；
int[]dist=新的int[adj.length]；
boolean[]访问=新的boolean[adj.length]；
数组。填充（dist，INF）；
pq.添加（新IPair（0，来源））；
距离[来源]=0；
而（！pq.isEmpty（））
{
int u=pq.poll（）.秒；
如果（访问[u]）
继续；
系统错误打印项次（u）；
访问[u]=真；
用于（IPair对：调整[u]）
{
int v=成对优先；
int-weight=pair.second；
if（距离[v]>距离[u]+重量）
{
距离[v]=距离[u]+重量；
pq.添加（新IPair（区[v]，v））；
System.err.println（Arrays.toString（dist））；
}
}
}
返回距离；
}
私有静态无效添加（列表[]调整，整数u，整数v，整数权重）
{
调整[u]。添加（新IPair（v，重量））；
adj[v].添加（新的IPair（u，重量））；
}
公共静态void main（字符串[]args）
{
int V=9；
列表[]调整=新数组列表[V]；
fill（adj，newarraylist（））；
加法（adj，0，1，4）；
加法（adj，0，7，8）；
附录（adj，1，2，8）；
附录（adj，1，7，11）；
补遗（adj，2，3，7）；
附录（adj，2，8，2）；
附录（adj，2，5，4）；
附录（adj，3，4，9）；
附录（adj，3，5，14）；
附录（adj，4，5，10）；
附录（adj，5，6，2）；
附录（adj，6，7，1）；
附录（adj，6，8，6）；
附录（adj，7，8，7）；
int[]dist=dijkstra（形容词，0）；
对于（int i=0；i
数组。填充（adj，new ArrayList（））

相当于：

List<IPair> list = new ArrayList<>();
Arrays.fill(adj, list)

---

标题有点滑稽：）我没有读你的代码，但我敢打赌这是因为Java处理数组的方式或对象的状态，它们实际上不相等。

arrays.fill（adj，new ArrayList（））

将使用相同的列表填充数组（相同且唯一的

ArrayList

）-是这样做的，还是每个位置都应该是自己的列表？！因此，每个顶点都将最短边作为最佳路径使用循环将新列表分配给每个位置或类似于

list[]adj=IntStream.range（0，V）.mapToObj（ArrayList:：new）.toArray（ArrayList[]：：new）数组.fill（）的文档

（更好的英语？“将指定的对象引用分配给每个元素”