Question

t 是我第一次尝试了解如何检测图表中的循环。我试图实现这个伪代码来检测图中的循环（有向或无向）：

@GET("/ObjectTracking/login.php/")
public void getSimpleResponse(@Query("username") String username,
                              @Query("pwd") String password,
                              Callback<List<SimpleResponse>> handlerCallback);

这是我在Scala中的代码：

 boolean containsCycle(Graph g):
     for each vertex v in g do:
       v.mark = WHITE;
     od;
     for each vertex v in g do:
       if v.mark == WHITE then:
        if visit(g, v) then:
          return TRUE;
        fi;
       fi;
     od;
    return FALSE;

   boolean visit(Graph g, Vertex v):
    v.mark = GREY;
    for each edge (v, u) in g do:
       if u.mark == GREY then:
         return TRUE;
       else if u.mark == WHITE then:
         if visit(g, u) then:
            return TRUE;
         fi;
       fi;
     od;
    v.mark = BLACK;
    return FALSE;

我不知道我编码错了什么？

Answer 1

我还使用着色方法将节点分类为未探测（W），探索（G）和完成（B）探索

这是我在图表中检测CYCLES的代码（已连接和已断开连接）。它不是超级高效的，但它提供了正确的DFS输出，并指示图中是否有循环。

对于检测周期，您必须考虑两个条件：

Selfloops

或
我们尝试探索已经在递归堆栈中的顶点（灰色）/（后边缘）

对于第二个条件，我使用了递归堆栈（Recur Stack）。

我已经使用了这里给出的想法Algo for DFS(TH Cormen)
请遵循此示例Example for the above Algo(TH Cormen)

虽然我已经使用着色方法来理解DFS，但我还没有添加算法中给出的时间特征。

我希望以下代码能回答您的问题。

import collections

class Vertex:
    def __init__(self,val):
        self.color="W"

class Graph:
    def __init__(self):
        self.master_vertex={}                                                                        
        self.Q=[]                                                                                    
        self.visit=[]                                                                                
        self.adj_vertex=collections.defaultdict(list)                                                
        self.cycle=0                                                                                 

    def add_vertex(self,vert):
        nv=Vertex(vert)
        self.master_vertex[vert]=nv

    def add_edge(self,src,dest):                                                                     
        self.adj_vertex[src].append(dest)



def DFS_Visit(graph):
        for ver in list(graph.master_vertex.keys()):
            if ver not in graph.visit and graph.master_vertex[ver].color=="W":
            DFS_iterative(graph,ver)
        if graph.cycle==1:
            return True
        else:
            return False


def DFS_iterative(graph,start):
    recur_stack=[]                                                                                      
    graph.Q.append(start)

    while len(graph.Q)>0:
        start=graph.Q[len(graph.Q)-1]                                                               
        recur_stack.append((graph.Q.pop()))
        graph.master_vertex[start].color="G"  

        if len(graph.adj_vertex[start])==0:                                                         
            graph.master_vertex[start].color="B"   
        for ver in graph.adj_vertex[start]:
            if start==ver or (graph.master_vertex[ver].color=="G" and ver in recur_stack):          
                graph.cycle=1
            if graph.master_vertex[ver].color=="W" and ver not in graph.Q:
                graph.Q.append(ver)
        graph.visit.append(start)

    while len(recur_stack)>0:
        x=recur_stack.pop()
        if graph.master_vertex[x].color=="G":
            graph.master_vertex[x].color="B"   


if __name__=='__main__':

    g=Graph()
    for i in range(1,7):
        g.add_vertex(str(input()))

    g.add_edge('u','v')
    g.add_edge('u','x')
    g.add_edge('v','y')
    g.add_edge('y','x')
    g.add_edge('x','v')
    g.add_edge('w','y')
    g.add_edge('w','z')
    g.add_edge('z','z')
    print g.adj_vertex
    print "Iterative DFS: "
    if DFS_Visit(g):
        print "graph contains cycle"
    else:
        print "graph does not contain cycle"
    print g.visit

以上代码的输出： CODE OUTPUT

检测图形中的循环，一种实现

1 个答案: