Exemplo n.º 1
0
def dijkstra(G, v):
    dist_so_far = priority_dict()
    dist_so_far[v] = 0
    final_dist = {}
    dist = {}
    dist[v] = 0
    shortest_paths = {}
    shortest_paths[v] = [[v]]
    while len(dist_so_far) != 0:
        w = dist_so_far.pop_smallest()
        # lock it down!
        final_dist[w] = dist[w]

        for x in G[w]:
            if x not in final_dist:
                if x not in dist:
                    dist[x] = final_dist[w] + G[w][x]
                    dist_so_far[x] = final_dist[w] + G[w][x]
                    paths = [path + [x] for path in shortest_paths[w]]
                    shortest_paths[x] = paths
                elif final_dist[w] + G[w][x] < dist[x]:
                    dist[x] = final_dist[w] + G[w][x]
                    dist_so_far[x] = final_dist[w] + G[w][x]
                    paths = [path + [x] for path in shortest_paths[w]]
                    shortest_paths[x] = paths
                elif final_dist[w] + G[w][x] == dist[x]:
                    paths = [path + [x] for path in shortest_paths[w]]
                    shortest_paths[x].extend(paths)
                    dist_so_far[x] = final_dist[w] + G[w][x]

    return final_dist, shortest_paths
def dijkstra(G,v):
    dist_so_far = priority_dict()
    dist_so_far[v] = 0
    final_dist = {}
    dist = {}
    dist[v] = 0
    shortest_paths = {}
    shortest_paths[v] = [[v]]
    while len(dist_so_far) != 0:
        w = dist_so_far.pop_smallest()
        # lock it down!
        final_dist[w] = dist[w]
        
        for x in G[w]:
            if x not in final_dist:
                if x not in dist:
                    dist[x] = final_dist[w] + G[w][x]
                    dist_so_far[x] = final_dist[w] + G[w][x]
                    paths = [path + [x] for path in shortest_paths[w]]
                    shortest_paths[x] = paths                    
                elif final_dist[w] + G[w][x] < dist[x]:
                    dist[x] = final_dist[w] + G[w][x]
                    dist_so_far[x] = final_dist[w] + G[w][x]
                    paths = [path + [x] for path in shortest_paths[w]]
                    shortest_paths[x] = paths
                elif final_dist[w] + G[w][x] == dist[x]:
                    paths = [path + [x] for path in shortest_paths[w]]
                    shortest_paths[x].extend(paths)
                    dist_so_far[x] = final_dist[w] + G[w][x]
                    
    return final_dist, shortest_paths
def dijkstra(G,v):
    dist_so_far = priority_dict()
    dist_so_far[v] = 0
    final_dist = {}
    dist = {}
    dist[v] = 0
    while len(final_dist) < len(G) and len(dist_so_far) != 0:
        w = dist_so_far.pop_smallest()
        # lock it down!
        final_dist[w] = dist[w]
        
        for x in G[w]:
            if x not in final_dist:
                if x not in dist:
                    dist[x] = final_dist[w] + G[w][x]
                    dist_so_far[x] = final_dist[w] + G[w][x]
                elif final_dist[w] + G[w][x] < dist[x]:
                    dist[x] = final_dist[w] + G[w][x]
                    dist_so_far[x] = final_dist[w] + G[w][x]
    return final_dist
def dijkstra(G, v):
    dist_so_far = priority_dict()
    dist_so_far[v] = 0
    final_dist = {}
    dist = {}
    dist[v] = 0
    while len(final_dist) < len(G) and len(dist_so_far) != 0:
        w = dist_so_far.pop_smallest()
        # lock it down!
        final_dist[w] = dist[w]

        for x in G[w]:
            if x not in final_dist:
                if x not in dist:
                    dist[x] = final_dist[w] + G[w][x]
                    dist_so_far[x] = final_dist[w] + G[w][x]
                elif final_dist[w] + G[w][x] < dist[x]:
                    dist[x] = final_dist[w] + G[w][x]
                    dist_so_far[x] = final_dist[w] + G[w][x]
    return final_dist
def dijkstra(G, v):
    obscr_so_far = priority_dict()
    obscr_so_far[v] = 0
    final_obscr = {}
    obscr = {}
    obscr[v] = 0
    while len(final_obscr) < len(G) and len(obscr_so_far) != 0:
        w = obscr_so_far.pop_smallest()
        # lock it down!
        final_obscr[w] = obscr[w]

        for x in G[w]:
            if x not in final_obscr:
                new_obscr = max(final_obscr[w], G[w][x])
                if x not in obscr:
                    obscr[x] = new_obscr
                    obscr_so_far[x] = new_obscr
                elif new_obscr < obscr[x]:
                    obscr[x] = new_obscr
                    obscr_so_far[x] = new_obscr
    return final_obscr
def dijkstra(G,v):
    obscr_so_far = priority_dict()
    obscr_so_far[v] = 0
    final_obscr = {}
    obscr = {}
    obscr[v] = 0
    while len(final_obscr) < len(G) and len(obscr_so_far) != 0:
        w = obscr_so_far.pop_smallest()
        # lock it down!
        final_obscr[w] = obscr[w]
        
        for x in G[w]:
            if x not in final_obscr:
                new_obscr = max(final_obscr[w], G[w][x])
                if x not in obscr:
                    obscr[x] = new_obscr
                    obscr_so_far[x] = new_obscr
                elif new_obscr < obscr[x]:
                    obscr[x] = new_obscr
                    obscr_so_far[x] = new_obscr
    return final_obscr
 def __init__(self):        
     self.dict_edge_set = priority_dict() 
     self.hash_tagset = {}