Question

My Depth First搜索工作完美，但不涉及Cycles。我想用DFS打印一个循环。

hasOwnProperty()会产生如下结果：

printAllPaths(VertexA, VertexC)

代码在

之下

A B C D C //with cycle since C repeated
A B C 
A D C 
A D E B C 
A E B C

Vertex Class是这样的：

  void printAllPathsUtil(Vertex v, Vertex d, ArrayList<Vertex> path){

        v.state = VISITED;
        path.add(v);

        if (v == d) {
            for (Vertex p : path) {
                System.out.print("Print: " + p.value + " ");
            }
            System.out.println();
        }
        else {
            for (Vertex city : v.outboundCity){

                if (city.state == UNVISITED) {

                    printAllPathsUtil(city, d, path);
                }
            }
        }
        path.remove(v);
        v.state = UNVISITED;
    }


    void printAllPaths(Vertex v, Vertex u){
        clearStates();
        ArrayList<Vertex> path = new ArrayList<>();
        printAllPathsUtil(v, u, path);
    }

我知道我们不应该有无限打印的情况。但它应该只打印1个周期。我尝试过很多东西，但无济于事。

Answer 1

因此，从上面的代码中我觉得你对图表的工作方式有了很好的理解。

因此上述方法将打印图中的所有路径。让那种方法保持不变。

为了在图表中查找循环，您可以创建一个只为您找到循环的新方法。

这是伪代码，我没有运行它所以我不能这样完全正确，但你肯定会得到这个想法

ArrayList<Vertex> dfsCycle(Vertex v, ArrayList<Vertex> path) {
 if(v.state = VISITED) {
   System.out.println("Yayy found a cycle");
  return path;
 }
 path.add(v);
 for(Vertex city : v.outboundCity) {
   dfsCycle(city,path);
 }
 return path;
}

希望这有帮助！

Answer 2

算法是正确的。问题是国家的实施。仅当city.state和UNVISITED属于同一类时，“if（city.state == UNVISITED）”中的条件为真。如果city.state和UNVISITED是原始类型int，则算法可以正常工作。

 public enum State {
    VISITED (1),
    UNVISITED (2);

    private final int state;

    State(int state) {
        this.state = state;
    }

    public int getState() {
        return this.state;
    }
}

现在：if(city.state.getState() == State.UNVISTED.getState()) {...}

Answer 3

如果您想只允许一个周期，请使用0,1,2代替state.VISITED和state.UNVISITED

而不是v.state = VISITED使用v.state++ 而不是v.state = UNVISITED使用v.state-- 而不是if(city.state == UNVISITED)使用if(city.state < 2)

通过增加最后一个条件中的值，您还可以设置允许的周期数。

实际上它允许算法两次访问所有城市而不是一次，所以如果地图有多个周期，那么计算出的路线中可能会有多个周期，但每条路线最多可以访问一个给定的城市。

还有一件事：您还必须为方法提供最后一个工作站并将其排除在循环中，否则解决方案中会有大量的小型循环，如ABABC，ABCBC

呃，这是整个代码：

 void printAllPathsUtil(Vertex prev, Vertex v, Vertex d, ArrayList<Vertex> path){

        v.state++;
        path.add(v);

        if (v == d) {
            for (Vertex p : path) {
                System.out.print("Print: " + p.value + " ");
            }
            System.out.println();
        }
        else {
            for (Vertex city : v.outboundCity){

                if (city!= prev && city.state < 2) {

                    printAllPathsUtil(v, city, d, path);
                }
            }
        }
        path.remove(v);
        v.state--;
    }


    void printAllPaths(Vertex v, Vertex u){
        clearStates();
        ArrayList<Vertex> path = new ArrayList<>();
        printAllPathsUtil(null, v, u, path);
    }

深度优先搜索1周期打印

3 个答案: