def update_path(self): m = self.edge_number es = self.es et = self.et ds = self.ds dt = self.dt G = nx.DiGraph() E = [(int(es[k]), int(et[k]), self.time[k]) for k in range(m)] G.add_weighted_edges_from(E) shortest_path = dict(nx.all_pairs_bellman_ford_path(G)) greedy_cost = 0 n_path = len(self.f_vec) new_cost = list() l = 0 for k in range(len(self.q)): path = shortest_path[int(ds[k])][int(dt[k])] edges = self.edge_serial[es[path[:-1]], et[path[1:]]] c_min = torch.sum(self.time[edges]) greedy_cost += self.q[k] * c_min path_k = self.pool[k] if torch.min(torch.abs(self.cost_vec[path_k] - c_min)) < 1e-10: continue self.pool[k].append(n_path + l) new_cost.append(c_min) for a in edges: self.path_vec[0].append(int(a)) self.path_vec[1].append(n_path + l) l += 1 self.cost_vec = torch.cat((self.cost_vec, torch.tensor(new_cost))) zero_vector = torch.zeros(len(new_cost), dtype=torch.double) self.f_vec = torch.cat((self.f_vec, zero_vector)) self.vectorization() return greedy_cost
def calc_shortest_path(Ga): G = Ga.copy() update_weight(G) f1 = open("../data/length.file", "wb") f2 = open("../data/path.file", "wb") def dict2df(data): return pd.DataFrame.from_dict(data, orient='index') length = dict(nx.all_pairs_bellman_ford_path_length(G)) path = dict(nx.all_pairs_bellman_ford_path(G)) pickle.dump(length, f1) pickle.dump(path, f2)
def Update_shortest_dis(self): # change the dis matrix to avoid deleted edges in initial heuristic # This is needed for left nodes and the nodes under them # We use bellman ford algorithm to find al pair shorets beased on new Graph #Dis=nx.all_pairs_bellman_ford_path_length(self.G , weight='Travel_time') paths = dict(nx.all_pairs_bellman_ford_path(self.G)) for i, j in it.combinations(self.G.node, 2): path = paths[i][j] travel_dis = 0 pernode = path.pop(0) while len(path): Cnode = path.pop(0) travel_dis += self.G.edges[pernode, Cnode]["Travel_distance"] pernode = Cnode self.Dis[i, j] = travel_dis self.Dis[j, i] = travel_dis
def test_all_pairs_shortest_path(self): p = nx.shortest_path(self.cycle) assert_equal(p[0][3], [0, 1, 2, 3]) assert_equal(p, dict(nx.all_pairs_shortest_path(self.cycle))) p = nx.shortest_path(self.grid) validate_grid_path(4, 4, 1, 12, p[1][12]) # now with weights p = nx.shortest_path(self.cycle, weight='weight') assert_equal(p[0][3], [0, 1, 2, 3]) assert_equal(p, dict(nx.all_pairs_dijkstra_path(self.cycle))) p = nx.shortest_path(self.grid, weight='weight') validate_grid_path(4, 4, 1, 12, p[1][12]) # weights and method specified p = nx.shortest_path(self.cycle, weight='weight', method='dijkstra') assert_equal(p[0][3], [0, 1, 2, 3]) assert_equal(p, dict(nx.all_pairs_dijkstra_path(self.cycle))) p = nx.shortest_path(self.cycle, weight='weight', method='bellman-ford') assert_equal(p[0][3], [0, 1, 2, 3]) assert_equal(p, dict(nx.all_pairs_bellman_ford_path(self.cycle)))
def test_all_pairs_shortest_path(self): p = nx.shortest_path(self.cycle) assert_equal(p[0][3], [0, 1, 2, 3]) assert_equal(p, dict(nx.all_pairs_shortest_path(self.cycle))) p = nx.shortest_path(self.grid) validate_grid_path(4, 4, 1, 12, p[1][12]) # now with weights p = nx.shortest_path(self.cycle, weight='weight') assert_equal(p[0][3], [0, 1, 2, 3]) assert_equal(p, dict(nx.all_pairs_dijkstra_path(self.cycle))) p = nx.shortest_path(self.grid, weight='weight') validate_grid_path(4, 4, 1, 12, p[1][12]) # weights and method specified p = nx.shortest_path(self.cycle, weight='weight', method='dijkstra') assert_equal(p[0][3], [0, 1, 2, 3]) assert_equal(p, dict(nx.all_pairs_dijkstra_path(self.cycle))) p = nx.shortest_path(self.cycle, weight='weight', method='bellman-ford') assert_equal(p[0][3], [0, 1, 2, 3]) assert_equal(p, dict(nx.all_pairs_bellman_ford_path(self.cycle)))
def test_all_pairs_shortest_path(self): p = nx.shortest_path(self.cycle) assert p[0][3] == [0, 1, 2, 3] assert p == dict(nx.all_pairs_shortest_path(self.cycle)) p = nx.shortest_path(self.grid) validate_grid_path(4, 4, 1, 12, p[1][12]) # now with weights p = nx.shortest_path(self.cycle, weight="weight") assert p[0][3] == [0, 1, 2, 3] assert p == dict(nx.all_pairs_dijkstra_path(self.cycle)) p = nx.shortest_path(self.grid, weight="weight") validate_grid_path(4, 4, 1, 12, p[1][12]) # weights and method specified p = nx.shortest_path(self.cycle, weight="weight", method="dijkstra") assert p[0][3] == [0, 1, 2, 3] assert p == dict(nx.all_pairs_dijkstra_path(self.cycle)) p = nx.shortest_path(self.cycle, weight="weight", method="bellman-ford") assert p[0][3] == [0, 1, 2, 3] assert p == dict(nx.all_pairs_bellman_ford_path(self.cycle))
def initialize_path(self): m = self.edge_number es = self.es et = self.et ds = self.ds dt = self.dt G = nx.DiGraph() E = [(int(es[k]), int(et[k]), self.time[k]) for k in range(m)] G.add_weighted_edges_from(E) shortest_path = dict(nx.all_pairs_bellman_ford_path(G)) flow = torch.zeros(m, dtype=torch.double) self.f_vec = 1.0 * self.q self.cost_vec = torch.zeros_like(self.q) for k in range(len(self.q)): path = shortest_path[int(ds[k])][int(dt[k])] edges = self.edge_serial[es[path[:-1]], et[path[1:]]] self.cost_vec[k] = torch.sum(self.time[edges]) self.pool[k] = [k] flow[edges] += self.q[k] for a in edges: self.path_vec[0].append(int(a)) self.path_vec[1].append(k) self.x = flow
def shortest_path(G, source=None, target=None, weight=None, method='dijkstra'): """Compute shortest paths in the graph. Parameters ---------- G : NetworkX graph source : node, optional Starting node for path. If not specified, compute shortest paths for each possible starting node. target : node, optional Ending node for path. If not specified, compute shortest paths to all possible nodes. weight : None or string, optional (default = None) If None, every edge has weight/distance/cost 1. If a string, use this edge attribute as the edge weight. Any edge attribute not present defaults to 1. method : string, optional (default = 'dijkstra') The algorithm to use to compute the path. Supported options: 'dijkstra', 'bellman-ford'. Other inputs produce a ValueError. If `weight` is None, unweighted graph methods are used, and this suggestion is ignored. Returns ------- path: list or dictionary All returned paths include both the source and target in the path. If the source and target are both specified, return a single list of nodes in a shortest path from the source to the target. If only the source is specified, return a dictionary keyed by targets with a list of nodes in a shortest path from the source to one of the targets. If only the target is specified, return a dictionary keyed by sources with a list of nodes in a shortest path from one of the sources to the target. If neither the source nor target are specified return a dictionary of dictionaries with path[source][target]=[list of nodes in path]. Raises ------ NodeNotFound If `source` is not in `G`. ValueError If `method` is not among the supported options. Examples -------- >>> G = nx.path_graph(5) >>> print(nx.shortest_path(G, source=0, target=4)) [0, 1, 2, 3, 4] >>> p = nx.shortest_path(G, source=0) # target not specified >>> p[4] [0, 1, 2, 3, 4] >>> p = nx.shortest_path(G, target=4) # source not specified >>> p[0] [0, 1, 2, 3, 4] >>> p = nx.shortest_path(G) # source, target not specified >>> p[0][4] [0, 1, 2, 3, 4] Notes ----- There may be more than one shortest path between a source and target. This returns only one of them. See Also -------- all_pairs_shortest_path() all_pairs_dijkstra_path() all_pairs_bellman_ford_path() single_source_shortest_path() single_source_dijkstra_path() single_source_bellman_ford_path() """ if method not in ('dijkstra', 'bellman-ford'): # so we don't need to check in each branch later raise ValueError('method not supported: {}'.format(method)) method = 'unweighted' if weight is None else method if source is None: if target is None: # Find paths between all pairs. if method == 'unweighted': paths = dict(nx.all_pairs_shortest_path(G)) elif method == 'dijkstra': paths = dict(nx.all_pairs_dijkstra_path(G, weight=weight)) else: # method == 'bellman-ford': paths = dict(nx.all_pairs_bellman_ford_path(G, weight=weight)) else: # Find paths from all nodes co-accessible to the target. with nx.utils.reversed(G): if method == 'unweighted': paths = nx.single_source_shortest_path(G, target) elif method == 'dijkstra': paths = nx.single_source_dijkstra_path(G, target, weight=weight) else: # method == 'bellman-ford': paths = nx.single_source_bellman_ford_path(G, target, weight=weight) # Now flip the paths so they go from a source to the target. for target in paths: paths[target] = list(reversed(paths[target])) else: if target is None: # Find paths to all nodes accessible from the source. if method == 'unweighted': paths = nx.single_source_shortest_path(G, source) elif method == 'dijkstra': paths = nx.single_source_dijkstra_path(G, source, weight=weight) else: # method == 'bellman-ford': paths = nx.single_source_bellman_ford_path(G, source, weight=weight) else: # Find shortest source-target path. if method == 'unweighted': paths = nx.bidirectional_shortest_path(G, source, target) elif method == 'dijkstra': paths = nx.dijkstra_path(G, source, target, weight) else: # method == 'bellman-ford': paths = nx.bellman_ford_path(G, source, target, weight) return paths