Algorithm HackerRank上的最短可达图

我已经在HackerRank上提交了这个（）问题的解决方案。它在某些测试用例中失败。我无法找出我的解决方案中的错误之处

问题陈述

考虑一个由n个节点组成的无向图，其中每个节点的标记范围为1到n，并且任意两个节点之间的边的长度始终为6。我们将节点s定义为BFS的起始位置

给定图形式的q查询和一些起始节点s，通过计算起始节点s到图中所有其他节点的最短距离来执行每个查询。然后打印一行空格分隔的整数，列出节点s到其他每个节点的最短距离（按节点编号顺序排列）；如果s与节点断开连接，则打印为到该节点的距离

输入格式

第一行包含一个整数q，表示查询的数量。后续行以以下格式描述每个查询：

第一行包含两个空格分隔的整数，分别描述图中n（节点数）和m（边数）的值。 m个后续行中的每一行i包含两个空格分隔的整数u和v，描述连接节点u到节点v的边。 最后一行包含一个整数s，表示起始节点的索引

输出格式

对于每个q查询，打印一行n-1空格分隔的整数，表示从起始位置s到每个其他节点的最短距离。这些距离应按节点编号（即1,2…n）顺序列出，但不应包括节点s。如果从s无法到达某个节点，则打印-1作为到该节点的距离

示例

样本输入：

    2
    4 2
    1 2
    1 3
    1
    3 1
    2 3
    2

样本输出：

6 6 -1
-1 6

我的解决方案：

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    public static class Graph {
        //key = node. value = list of neighbors.
       Map<Integer, List<Integer>> nodes;

        public Graph(int size) {
            nodes = new HashMap<Integer, List<Integer>>();
            for(int i = 0; i<size; i++){
                nodes.put(i, new ArrayList<Integer>());
            }
        }

        public void addEdge(int first, int second) {
            if(first != second){
               if(!(nodes.get(first).contains(second))){
                    nodes.get(first).add(second);
                }
                if(!(nodes.get(second).contains(first))){
                    nodes.get(second).add(first);
                } 
            }
        }

        public int[] shortestReach(int startId) { // 0 indexed
            int[] distances = new int[nodes.keySet().size()];
            Arrays.fill(distances, -1);
            distances[startId] = 0;
            visitNeighbors(startId, distances);
            return distances;
        }

        private void visitNeighbors(int startId, int[] distances){
            List<Integer> nodesToVisit = new ArrayList<Integer>();
            for(int i:nodes.get(startId)){
                if(distances[i] == -1){
                    distances[i] = distances[startId] + 6;
                    nodesToVisit.add(i);
                }
                //dont recurse right here, otherwise it will become depth-first and we will not get shortest path.
            }
            for(int i:nodesToVisit){
                visitNeighbors(i, distances);
            }
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int queries = scanner.nextInt();

        for (int t = 0; t < queries; t++) {

            // Create a graph of size n where each edge weight is 6:
            Graph graph = new Graph(scanner.nextInt());
            int m = scanner.nextInt();

            // read and set edges
            for (int i = 0; i < m; i++) {
                int u = scanner.nextInt() - 1;
                int v = scanner.nextInt() - 1;

                // add each edge to the graph
                graph.addEdge(u, v);
            }

            // Find shortest reach from node s
            int startId = scanner.nextInt() - 1;
            int[] distances = graph.shortestReach(startId);

            for (int i = 0; i < distances.length; i++) {
                if (i != startId) {
                    System.out.print(distances[i]);
                    System.out.print(" ");
                }
            }
            System.out.println();            
        }

        scanner.close();
    }
}

import java.io.*；
导入java.util.*；
导入java.text.*；
导入java.math.*；
导入java.util.regex.*；
公共类解决方案{
公共静态类图{
//键=节点。值=邻居列表。
地图节点；
公共图形（整数大小）{
nodes=newhashmap（）；
对于（inti=0；i这是一个非常直接的bfs问题

您的
visit
方法不正确，因为它指向
visitNeighbors

使其成为bfs函数。目前，它是一种递归方法，使其成为
堆栈
，而不是
队列

    private void visitNeighbors(int startId, int[] distances){
        List<Integer> nodesToVisit = new ArrayList<Integer>();

        nodesToVisit.add(startId);
        distances[startId] = 0;
        while (!nodesToVisit.isEmpty()) {
            int current = nodesToVisit.get(0);
            nodesToVisit.remove(0);
            for (int i : nodes.get(current)) {
                if (distances[i] == -1) {
                    distances[i] = distances[current] + 6;
                    nodesToVisit.add(i);
                }
                //dont recurse right here, otherwise it will become depth-first and we will not get shortest path.
            }
        }
    }

private void visitNeighbors（int startId，int[]距离）{
List nodesToVisit=new ArrayList（）；
nodesToVisit.add（startId）；
距离[startId]=0；
而（！nodesToVisit.isEmpty（））{
int current=nodesToVisit.get（0）；
nodesToVisit.remove（0）；
for（int i:nodes.get（当前））{
如果（距离[i]=-1）{
距离[i]=距离[电流]+6；
添加（i）；
}
//不要在这里递归，否则它将成为深度优先，我们将无法得到最短路径。
}
}
}

是经过编辑的可接受代码。
这是一个非常直接的bfs问题

您的
visit
方法不正确，因为它指向
visitNeighbors

使其成为bfs函数。目前，它是一种递归方法，使其成为
堆栈
，而不是
队列

    private void visitNeighbors(int startId, int[] distances){
        List<Integer> nodesToVisit = new ArrayList<Integer>();

        nodesToVisit.add(startId);
        distances[startId] = 0;
        while (!nodesToVisit.isEmpty()) {
            int current = nodesToVisit.get(0);
            nodesToVisit.remove(0);
            for (int i : nodes.get(current)) {
                if (distances[i] == -1) {
                    distances[i] = distances[current] + 6;
                    nodesToVisit.add(i);
                }
                //dont recurse right here, otherwise it will become depth-first and we will not get shortest path.
            }
        }
    }

private void visitNeighbors（int startId，int[]距离）{
List nodesToVisit=new ArrayList（）；
nodesToVisit.add（startId）；
距离[startId]=0；
而（！nodesToVisit.isEmpty（））{
int current=nodesToVisit.get（0）；
nodesToVisit.remove（0）；
for（int i:nodes.get（当前））{
如果（距离[i]=-1）{
距离[i]=距离[电流]+6；
添加（i）；
}
//不要在这里递归，否则它将成为深度优先，我们将无法得到最短路径。
}
}
}

是已编辑的可接受代码。
谢谢！我没有意识到使用递归（尽管我在代码中有注释），我是在做深度优先。这一定导致了一些非最短路径。谢谢！谢谢！我没有意识到使用递归（尽管我在代码中有注释），我在做深度优先。这一定导致了一些非最短路径。谢谢！