Question

我正在寻找一种方法来追踪我的bfs算法的路径，但我不知道如何。也许我错了，但我认为我确实需要一个duble ArrayList来保存每一种可能的方式。这意味着在以下示例中：

arraylist：6-3-1
arraylist：6-3-5
arraylist：5-9-7
arraylist：6-9-10

如果有从3到9的连接，这甚至会更糟。

    public List<E> BFS(N source, N target)
    {
        ArrayList<ArrayList<N>> nodes_paths = new ArrayList<ArrayList<N>>();
        ArrayList<N> nodes_list = new ArrayList<N>(graph.getNodes());
        N current_node;

        Queue <N> list = new LinkedList<N>();
        HashMap<N, Boolean> already_visited = new HashMap<N, Boolean>();
//      mark all nodes in HashMap as not visited
        for(int i=0; i<nodes_list.size(); i++)
        {
            already_visited.put(nodes_list.get(i), false);
        }

        ArrayList<N> successors = new ArrayList<N>();
        list.add(source);

        while(!list.isEmpty())
        {
            current_node = list.poll();
            already_visited.put(current_node, true);
          //need to add the node to any path, but don't know to which?
            if(current_node.equals(target))
            {

            }
            else
            {
                successors = new ArrayList<N>(graph.getSuccessors(current_node));
                for(int j=0; j<successors.size(); j++)
                {
                    if(!already_visited.get(successors.get(j)))
                    {
                        already_visited.put(successors.get(j), true);
                        list.add(successors.get(j));
                    }
                }
            }
        }


//      need the path array here!
        ArrayList<E> edges_list = new ArrayList<E>(graph.getEdges());
        ArrayList<E> path_edges = new ArrayList<E>();
        for(int k=0; k<path.size()-1; k++)  //If there are path.size nodes, so therer are only path.size-1 edges
        {
            for(int l=0; l<edges_list.size(); l++)
            {
                if(path.get(k).equals(edges_list.get(l).getSource()) && path.get(k+1).equals(edges_list.get(l).getTarget()))
                {
                    path_edges.add(edges_list.get(l));
                }
            }
        }

        return path_edges;


    }

Answer 1

这种方法会得到复杂的管理，您可以存储地图：V-> V [从顶点到顶点]，它将从每个节点v映射，即“发现”v的顶点u。

您将在BFS的迭代过程中填充此地图。

稍后 - 你可以通过简单地从目标节点[在地图中] - 重新开始直到你回到源头来重建路径。如果枚举顶点，则可以将此映射实现为数组。

如何在算法BFS期间跟踪路径

1 个答案: