Java 深度优先搜索，1周期打印

我的深度优先搜索非常有效，但它不处理循环。我想用DFS打印一个周期

printalpath（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

代码如下

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

void printAllPathsUtil（顶点v、顶点d、数组列表路径）{
v、 国家=访问；
路径。添加（v）；
如果（v==d）{
对于（顶点p:路径）{
系统输出打印（“打印：+p.value+”）；
}
System.out.println（）；
}
否则{
用于（顶点城市：v.外围城市）{
如果（city.state==未访问）{
printAllPathsUtil（城市，d，路径）；
}
}
}
路径。移除（v）；
v、 状态=未访问；
}
无效打印所有路径（顶点v、顶点u）{
清除状态（）；
ArrayList路径=新建ArrayList（）；
printAllPathsUtil（v，u，路径）；
}

顶点类是这样的：

public class Vertex{
String value;

Vertex previous = null;
int minDistance = Integer.MAX_VALUE;

List<Vertex> inboundCity;
List<Vertex> outboundCity;
State state;
}

公共类顶点{
字符串值；
顶点前一个=空；
int minDistance=Integer.MAX_值；
列出边界城市；
列出外围城市；
国家；
}

---

我知道我们不应该有这样的情况，它打印无限。但它应该只打印一个周期。我试过很多东西，但都没有用

通过以上代码，我觉得您对图形的工作原理有了很好的理解

因此，上述方法将打印图形中的所有路径。让那个方法保持原样吧

为了在图形中查找循环，您可以创建一个新方法，该方法只需为您查找一个循环

这是它的伪代码，我没有运行它，所以我不能，所以它是完全正确的，但你肯定会明白的

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

ArrayList dfsCycle（顶点v，ArrayList路径）{
如果（v.state=访问）{
System.out.println（“Yayy找到了一个循环”）；
返回路径；
}
路径。添加（v）；
用于（顶点城市：v.外围城市）{
自行车（城市、道路）；
}
返回路径；
}

---

希望这有帮助

通过以上代码，我觉得您对图形的工作原理有了很好的理解

因此，上述方法将打印图形中的所有路径。让那个方法保持原样吧

为了在图形中查找循环，您可以创建一个新方法，该方法只需为您查找一个循环

这是它的伪代码，我没有运行它，所以我不能，所以它是完全正确的，但你肯定会明白的

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

ArrayList dfsCycle（顶点v，ArrayList路径）{
如果（v.state=访问）{
System.out.println（“Yayy找到了一个循环”）；
返回路径；
}
路径。添加（v）；
用于（顶点城市：v.外围城市）{
自行车（城市、道路）；
}
返回路径；
}

---

希望这有帮助

算法是正确的。问题是国家的执行。只有当city.state和UNVISITED是同一类时，“if（city.state==UNVISITED）”中的条件才为true。如果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（））{…}

算法是正确的。问题是国家的执行。只有当city.state和UNVISITED是同一类时，“if（city.state==UNVISITED）”中的条件才为true。如果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（））{…}

如果您想只允许一个周期，那么使用

0,1,2

而不是

state.visted

和

state.UNVISITED

使用

v.state++

使用

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

void printAllPathsUtil（顶点上、顶点v、顶点d、数组列表路径）{
v、 状态++；
路径。添加（v）；
如果（v==d）{
对于（顶点p:路径）{
系统输出打印（“打印：+p.value+”）；
}
System.out.println（）；
}
否则{
用于（顶点城市：v.外围城市）{
如果（城市！=prev&&city.state<2）{
printAllPathsUtil（v，城市，d，路径）；
}
}
}
路径。移除（v）；
v、 国家--；
}
无效打印所有路径（顶点v、顶点u）{
清除状态（）；
ArrayList路径=新建ArrayList（）；
printAllPathsUtil（null、v、u、path）；
}
如果希望只允许一个周期，则使用
0,1,2
而不是
状态。已访问
和
状态。未访问

使用
v.state++
使用
v.state--
使用
if（city.state==UNVISITED）代替
if（city.state<2）

通过增加最后一个条件中的值，还可以设置允许的循环数

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

还有一件事：您还必须提供方法的最后一个站，并将其排除在循环中，否则将有大量的小循环