Question

我正在尝试实现一个BFS，该BFS以顶点列表的形式返回从a到b的路径。我正在树上实现此BFS，所以我知道如果找到一个，它将是最短的路径。但是，到目前为止，我的研究仅使我找到了搜索和查找节点而不是返回路径的BSF算法。

我要处理的输入是最小生成树的邻接矩阵。我必须接受这一点，并找到从一点到另一点的路径。

Answer 1

如果您真的想使用BFS解决此问题，则要跟踪从源到目标的路径，您需要存储所访问的每个节点的父节点。这是没有优化的示例BFS。

import java.util.*;

public class bfs {

    static class Node {
        Node parent;
        int x;

        Node (int x) {
            this (x, null);
        }

        Node (int x, Node parent) {
            this.parent = parent;
            this.x = x;
        }

        void trace () {
            if (parent == null) {
                System.out.print (x);
            } else {
                parent.trace ();
                System.out.print ("->" + x);
            }
        }
    }

    static void bfs (int start, int goal, int[][] adj) {
        List<Node> list = new ArrayList<> ();

        list.add (new Node (start));

        while (!list.isEmpty ()) {
            Node cur = list.remove (0);

            if (cur.x == goal) {
                cur.trace ();
                break;
            } else {
                for (int i = 0; i < adj[cur.x].length; i++) {
                    if (adj[cur.x][i] == 1) {
                        list.add (new Node (i, cur));
                    }
                }
            }
        }
    }

    public static void main (String[] args) {
        int[][] adjacency_matrix = {
            {0, 1, 1, 0, 0},
            {1, 0, 0, 1, 0},
            {1, 0, 0, 0, 0},
            {0, 1, 0, 0, 1},
            {0, 0, 0, 1, 0}
        };
        int start = 0;
        int goal = 4;

        bfs (start, goal, adjacency_matrix);
    }

}

Answer 2

Dijkstra或A *可能是您想要使用的。不过要看情况。您似乎在描述的是寻路算法，而不是节点搜索。

如何使用广度优先搜索在树中找到从一个顶点到另一个顶点的路径？

2 个答案: