Question

我已经在HackerRank上提交了这个（https://www.hackerrank.com/challenges/ctci-bfs-shortest-reach）问题的解决方案。某些测试用例失败了。我无法弄清楚我的解决方案中有什么不正确。

问题陈述

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

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

输入格式

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

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

输出格式

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

示例

示例输入：

示例输出：

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();
    }
}

当我提交上述代码时，HackerRank报告某些TestCases没有通过。我不确定我做错了什么。请帮忙。谢谢。

Answer 1

这是一个非常直接的bfs问题。

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

使它成为bfs功能。目前，它是一种递归方法，使其成为stack而不是queue。

    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.
            }
        }
    }

Here是已修改的已接受代码。

HackerRank上最短的到达图

1 个答案: