java - BFS 无法正常工作

Question

我正在尝试实现 BFS 来查找学习某门类(class)之前所需的所有先决条件。我的public List<Node> computeAllPrereqs(String courseName)方法是我的代码困惑的地方。有人可以看看我的方法并帮助我找到问题吗？我认为结束节点将是无，因为我图中的类(class)都不会导致任何结果。该图不是循环的。

这是我传递给构造函数的文本文件，第一列是类(class)，后面的类(class)是其先决条件:

CS1 None
CS2 CS1
CS3 CS2
CS4 CS1
CS5 CS3 CS4
CS6 CS2 CS4

.

public class Graph {

    private Map<String, Node> graph;

    public Graph(String filename) throws FileNotFoundException {

        // open the file for scanning
        File file = new File(filename);
        Scanner in = new Scanner(file);

        // create the graph
        graph = new HashMap<String, Node>();

        // loop over and parse each line in the input file
        while (in.hasNextLine()) {
            // read and split the line into an array of strings
            // where each string is separated by a space.
            Node n1, n2;
            String line = in.nextLine();
            String[] fields = line.split(" ");
            for(String name: fields){
                if (!graph.containsKey(fields[0]))
                {
                    n1 = new Node(name);
                    graph.put(name, n1);
                }
                else{
                    n2 = new Node(name);
                    graph.get(fields[0]).addNeighbor(n2);
                }
            }
        }
        in.close();
    }    
    public List<Node> computeAllPrereqs(String courseName){
        // assumes input check occurs previously
        Node startNode;
        startNode = graph.get(courseName);


        // prime the dispenser (queue) with the starting node
        List<Node> dispenser = new LinkedList<Node>();
        dispenser.add(startNode);

        // construct the predecessors data structure
        Map<Node, Node> predecessors = new HashMap<Node,Node>();
        // put the starting node in, and just assign itself as predecessor
        predecessors.put(startNode, startNode);

        // loop until either the finish node is found, or the
        // dispenser is empty (no path)
        while (!dispenser.isEmpty()) {
            Node current = dispenser.remove(0);
            if (current == new Node(null)) {
                break;
            }
            // loop over all neighbors of current
            for (Node nbr : current.getNeighbors()) {
                // process unvisited neighbors
                if(!predecessors.containsKey(nbr)) {
                    predecessors.put(nbr, current);
                    dispenser.add(nbr);
                }
            }
        }

        return constructPath(predecessors, startNode, null);
    }
    private List<Node> constructPath(Map<Node,Node> predecessors,
                                     Node startNode, Node finishNode) {

        // use predecessors to work backwards from finish to start,
        // all the while dumping everything into a linked list
        List<Node> path = new LinkedList<Node>();

        if(predecessors.containsKey(finishNode)) {
            Node currNode = finishNode;
            while (currNode != startNode) {
                path.add(0, currNode);
                currNode = predecessors.get(currNode);
            }
            path.add(0, startNode);
        }

        return path;
    }

}

这是我用来在图中创建节点和邻居的节点类:

public class Node {

    /*
     *  Name associated with this node.
     */
    private String name;

    /*
     * Neighbors of this node are stored as a list (adjacency list).
     */
    private List<Node> neighbors;


    public Node(String name) {
        this.name = name;
        this.neighbors = new LinkedList<Node>();
    }


    public String getName() {
        return name;
    }

    public void addNeighbor(Node n) {
        if(!neighbors.contains(n)) {
            neighbors.add(n);
        }
    }

    public List<Node> getNeighbors() {
        return new LinkedList<Node>(neighbors);
    }


    @Override
    public String toString() {
        String result;
        result = name + ":  ";

        for(Node nbr : neighbors) {
            result = result + nbr.getName() + ", ";
        }
        // remove last comma and space, or just spaces in the case of no neighbors
        return (result.substring(0, result.length()-2));
    }


    @Override
    public boolean equals(Object other) {
        boolean result = false;
        if (other instanceof Node) {
            Node n = (Node) other;
            result = this.name.equals(n.name);
        }
        return result;
    }

    @Override
    public int hashCode() {
        return this.name.hashCode();
    }
}

这是我的测试类:

public class Prerequisite {

/**
 * Main method for the driver program.
 *
 * @param args the name of the file containing the course and
 * prerequisite information
 *
 * @throws FileNotFoundException if input file not found
 */
public static void main(String[] args) throws FileNotFoundException {

    // Check for correct number of arguments
    if(args.length != 1) {
        String us = "Usage: java Prerequisite <input file>";
        System.out.println(us);
        return;
    }

    // create a new graph and load the information
    // Graph constructor from lecture notes should
    // be modified to handle input specifications
    // for this lab.
    Graph graph = new Graph(args[0]);

    // print out the graph information
    System.out.println("Courses and Prerequisites");
    System.out.println("=========================");
    System.out.println(graph);


    // ASSUMPTION:  we assume there are no cycles in the graph

    // Part I:
    // compute how many (and which) courses must be taken before it is
    // possible to take any particular course

    System.out.println("How many courses must I take "
            + "before a given course?!?!?");
    for(String name : graph.getAllCourseNames()) {
        List<Node> allPrereqs = graph.computeAllPrereqs(name);
        System.out.print(String.valueOf(allPrereqs.size()));
        System.out.print(" courses must be taken before " + name + ": ");
        for(Node el : allPrereqs) {
            System.out.print(el.getName() + " ");
        }
        System.out.println();
    }


}

当我运行此测试时，我的输出是:

0 courses must be taken before CS1: 
0 courses must be taken before CS3: 
0 courses must be taken before CS2: 
0 courses must be taken before CS5: 
0 courses must be taken before CS4: 
0 courses must be taken before CS6: 

应该是:

0 courses must be taken before CS1: 
2 courses must be taken before CS3: CS1 CS2 
1 courses must be taken before CS2: CS1 
4 courses must be taken before CS5: CS1 CS3 CS2 CS4 
1 courses must be taken before CS4: CS1 
3 courses must be taken before CS6: CS1 CS2 CS4 

我知道我发布了很多代码，但如果需要帮助修复我的错误，我不想在以后编辑更多代码。

Answer 1

请注意，通过深度优先搜索 (DFS) 可以更有效地确定先决条件，从而可以实现拓扑排序。

在图构建过程中，当链接邻居时，链接的是“相似节点”而不是现有图节点本身，因此生成的图实际上是未连接的。要解决该问题，请将图表的实际节点相互链接。

            if (!graph.containsKey(fields[0]))
            {
                n1 = new Node(name);
                graph.put(name, n1);
            }
            else{
                if(graph.containsKey(name)) {
                    n2 = graph.get(name);
                }
                else {
                    n2 = new Node(name);
                    graph.put(name, n2);
                }
                graph.get(fields[0]).addNeighbor(n2);
            }

上述代码片段的另一个好处是它将终端“None”节点添加到图表中。

无法构建单行路径，因为一门类(class)可能有多个先决条件。例如，CS6 依赖于 CS2 和 CS4。在 constructorPath 方法中，仅在遵循这些路径之一后就会触发终止条件。因此，考虑到程序的当前结构，您能实现的最好结果就是输出先决类(class)集而不是单行路径。

private List<Node> constructPath(Map<Node,Node> predecessors,
                                 Node startNode, Node finishNode) {
/*
    // use predecessors to work backwards from finish to start,
    // all the while dumping everything into a linked list
    List<Node> path = new LinkedList<Node>();

    if(predecessors.containsKey(finishNode)) {
        Node currNode = finishNode;
        while (currNode != startNode) {
            path.add(0, currNode);
            currNode = predecessors.get(currNode);
        }
        path.add(0, startNode);
    }
*/
    Set<Node> prereqs = new HashSet<Node>(predecessors.keySet());
    prereqs.remove(graph.get("None"));
    return new ArrayList<Node>(prereqs);
}

采用这种方法，参数 startNode 和 finishNode 都不是必需的，并且前驱映射的创建是多余的。

最后，类(class)本身并不是先决条件，因此将自己指定为前修类(class)是不正确的。

    // put the starting node in, and just assign itself as predecessor
    // predecessors.put(startNode, startNode);

考虑到这些修改，这就是输出

0 courses must be taken before CS1: 
1 courses must be taken before CS2: CS1 
2 courses must be taken before CS3: CS2 CS1 
1 courses must be taken before CS4: CS1 
4 courses must be taken before CS5: CS4 CS2 CS3 CS1 
3 courses must be taken before CS6: CS4 CS2 CS1 

为了改进代码，可以使用 TreeSet ( http://docs.oracle.com/javase/7/docs/api/java/util/TreeSet.html ) 代替 HashSet 以统一的顺序输出先决条件。然而，要使用 TreeSet，必须扩充 Node 类以实现 Comparable ( How to implement the Java comparable interface? )。

同样，如果输出先决条件集不令人满意，请考虑使用 DFS 来生成拓扑排序 ( http://www.personal.kent.edu/~rmuhamma/Algorithms/MyAlgorithms/GraphAlgor/topoSort.htm )。