def Bicomponent(G,S):
    '''Construct an auxiliary graph that shows biconnected component'''

    Auxiliary = Graph()  # initially empty auxiliary graph
   
    Auxiliary.Set_directed(True)
    Auxiliary.Set_weighted(False)
    
    explored_v, explored_e, back_edges = DFS(G,S, sort = True) # run DFS once
    discovery_edges = [p for p in explored_e if p not in back_edges]
    examined_backedges = []
    print("---------------------------------------------------")
    print("Above is DFS information")
    # add all discovery edges as vertices

    for u,v in discovery_edges:
        Auxiliary.Add_vertice(tuple((u,v)))

    print(Auxiliary.vertices)
    # for every node, DFS reach order, process back edges that link to it
    for v in explored_v: 
        
        for be in back_edges:
            
            if v in be and be not in examined_backedges:
                print("Back Edge", be, "connect to vertice", v)
                
                examined_backedges.append(be)
                Auxiliary.Add_vertice(be)

                u = G.GetDestination(be,v)

                while (u != v):
                    
                    p = G.FindParent(discovery_edges, u)
              
                    f = tuple((p,u))
                    
                    Auxiliary.Add_edge(be,f)
                    print("Added", be, "link to", f)
                    u = p

              
                
    return Auxiliary
Beispiel #2
0
    G1.Set_weighted(False)
    G1.Set_directed(True)

    V1 = ['A', 'B', 'C', 'D', 'E']
    E1 = [
        ('A', 'B'),
        ('B', 'C'),
        ('C', 'A'),
        ('E', 'A'),
        ('B', 'D'),
        ('C', 'D'),
        ('D', 'E'),
    ]

    for u, v in E1:
        G1.Add_edge(u, v)

    print("G1", TestStrongConnectivity(G1, 'A'))

    G2 = Graph()
    G2.Set_weighted(False)
    G2.Set_directed(True)

    V2 = ['A', 'B', 'C', 'D', 'E']
    E2 = [
        ('A', 'B'),
        ('B', 'C'),
        ('C', 'A'),
        ('A', 'E'),
        ('B', 'D'),
        ('C', 'D'),
              
                
    return Auxiliary

if __name__ == "__main__":

    image = Image.open('images\AuxiliaryGraph.PNG').show()
    V = ['A','B','C','D','E','F','H','J','K','L','M','P','N','Q']
    E = [('A','B'),('A','C'),('B','C'),('C','D'),('D','E'),('E','F'),
         ('F','H'),('H','J'),('J','D'),('H','D'),('C','K'),('K','L'),
         ('L','M'),('M','P'),('P','Q'),('P','N'),('C','Q'),('L','Q'),
         ('C','P')]
    
    G = Graph()
    G.Set_directed(False)
    G.Set_weighted(False)

    for v,u in E:
        G.Add_edge(u,v)

    AuxiliaryGraph = Bicomponent(G, 'A')







 
      
Beispiel #4
0
                if (new_cost < result[v][0]):
                    result[v][0] = new_cost
                    result[v][1] = u

        visited_vertices.append(vertex_smallest_cost)

    return result


if __name__ == "__main__":

    image = Image.open('images\dijkstra_example.PNG').show()

    V = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
    E = [('A', 'B', 12), ('A', 'C', 3), ('A', 'D', 7), ('B', 'C', 8),
         ('C', 'D', 6), ('B', 'E', 15), ('C', 'F', 2), ('D', 'G', 1),
         ('C', 'E', 5), ('C', 'G', 4), ('E', 'F', 5), ('F', 'G', 6),
         ('E', 'I', 10), ('G', 'J', 9), ('F', 'H', 10), ('E', 'H', 9),
         ('G', 'H', 6), ('H', 'I', 2), ('H', 'J', 5), ('I', 'J', 12)]

    G = Graph()
    G.Set_directed(False)
    G.Set_weighted(True)

    for u, v, w in E:
        G.Add_edge(u, v, w)

    result = Dijkstra(G, 'A')
    for i in sorted(result):
        print(i, result[i])