def _bellman_ford_relaxation(G, pred, dist, source, weight):
"""Relaxation loop for Bellman–Ford algorithm
Parameters
----------
G : NetworkX graph
pred: dict
Keyed by node to predecessor in the path
dist: dict
Keyed by node to the distance from the source
source: list
List of source nodes
weight: string
Edge data key corresponding to the edge weight
Returns
-------
Returns two dictionaries keyed by node to predecessor in the
path and to the distance from the source respectively.
Raises
------
NetworkXUnbounded
If the (di)graph contains a negative cost (di)cycle, the
algorithm raises an exception to indicate the presence of the
negative cost (di)cycle. Note: any negative weight edge in an
undirected graph is a negative cost cycle
"""
if G.is_multigraph():
def get_weight(edge_dict):
return min(eattr.get(weight, 1) for eattr in edge_dict.values())
else:
def get_weight(edge_dict):
return edge_dict.get(weight, 1)
G_succ = G.succ if G.is_directed() else G.adj
inf = float('inf')
n = len(G)
count = {}
q = deque(source)
in_q = set(source)
while q:
u = q.popleft()
in_q.remove(u)
# Skip relaxations if the predecessor of u is in the queue.
if pred[u] not in in_q:
dist_u = dist[u]
for v, e in G_succ[u].items():
dist_v = dist_u + get_weight(e)
if dist_v < dist.get(v, inf):
if v not in in_q:
q.append(v)
in_q.add(v)
count_v = count.get(v, 0) + 1
if count_v == n:
raise nx.NetworkXUnbounded(
"Negative cost cycle detected.")
count[v] = count_v
dist[v] = dist_v
pred[v] = u
return pred, dist
def bellman_ford(G, source, weight='weight'):
"""Compute shortest path lengths and predecessors on shortest paths
in weighted graphs.
The algorithm has a running time of O(mn) where n is the number of
nodes and m is the number of edges. It is slower than Dijkstra but
can handle negative edge weights.
Parameters
----------
G : NetworkX graph
The algorithm works for all types of graphs, including directed
graphs and multigraphs.
source: node label
Starting node for path
weight: string, optional (default='weight')
Edge data key corresponding to the edge weight
Returns
-------
pred, dist : dictionaries
Returns two dictionaries keyed by node to predecessor in the
path and to the distance from the source respectively.
Raises
------
NetworkXUnbounded
If the (di)graph contains a negative cost (di)cycle, the
algorithm raises an exception to indicate the presence of the
negative cost (di)cycle. Note: any negative weight edge in an
undirected graph is a negative cost cycle.
Examples
--------
>>> import networkx as nx
>>> G = nx.path_graph(5, create_using = nx.DiGraph())
>>> pred, dist = nx.bellman_ford(G, 0)
>>> sorted(pred.items())
[(0, None), (1, 0), (2, 1), (3, 2), (4, 3)]
>>> sorted(dist.items())
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
>>> from nose.tools import assert_raises
>>> G = nx.cycle_graph(5, create_using = nx.DiGraph())
>>> G[1][2]['weight'] = -7
>>> assert_raises(nx.NetworkXUnbounded, nx.bellman_ford, G, 0)
Notes
-----
Edge weight attributes must be numerical.
Distances are calculated as sums of weighted edges traversed.
The dictionaries returned only have keys for nodes reachable from
the source.
In the case where the (di)graph is not connected, if a component
not containing the source contains a negative cost (di)cycle, it
will not be detected.
"""
if source not in G:
raise KeyError("Node %s is not found in the graph" % source)
for u, v, attr in G.selfloop_edges(data=True):
if attr.get(weight, 1) < 0:
raise nx.NetworkXUnbounded("Negative cost cycle detected.")
dist = {source: 0}
pred = {source: None}
if len(G) == 1:
return pred, dist
if G.is_multigraph():
def get_weight(edge_dict):
return min(eattr.get(weight, 1) for eattr in edge_dict.values())
else:
def get_weight(edge_dict):
return edge_dict.get(weight, 1)
if G.is_directed():
G_succ = G.succ
else:
G_succ = G.adj
inf = float('inf')
n = len(G)
count = {}
q = deque([source])
in_q = set([source])
while q:
u = q.popleft()
in_q.remove(u)
# Skip relaxations if the predecessor of u is in the queue.
if pred[u] not in in_q:
dist_u = dist[u]
for v, e in G_succ[u].items():
dist_v = dist_u + get_weight(e)
if dist_v < dist.get(v, inf):
if v not in in_q:
q.append(v)
in_q.add(v)
count_v = count.get(v, 0) + 1
if count_v == n:
raise nx.NetworkXUnbounded(
"Negative cost cycle detected.")
count[v] = count_v
dist[v] = dist_v
pred[v] = u
return pred, dist
def _bellman_ford_relaxation(G, pred, dist, source, weight):
"""Relaxation loop for Bellman–Ford algorithm
Parameters
----------
G : NetworkX graph
pred: dict
Keyed by node to predecessor in the path
dist: dict
Keyed by node to the distance from the source
source: list
List of source nodes
weight: string
Edge data key corresponding to the edge weight
Returns
-------
Returns two dictionaries keyed by node to predecessor in the
path and to the distance from the source respectively.
Raises
------
NetworkXUnbounded
If the (di)graph contains a negative cost (di)cycle, the
algorithm raises an exception to indicate the presence of the
negative cost (di)cycle. Note: any negative weight edge in an
undirected graph is a negative cost cycle
"""
if G.is_multigraph():
def get_weight(edge_dict):
return min(eattr.get(weight, 1) for eattr in edge_dict.values())
else:
def get_weight(edge_dict):
return edge_dict.get(weight, 1)
G_succ = G.succ if G.is_directed() else G.adj
inf = float('inf')
n = len(G)
count = {}
q = deque(source)
in_q = set(source)
while q:
u = q.popleft()
in_q.remove(u)
# Skip relaxations if the predecessor of u is in the queue.
if pred[u] not in in_q:
dist_u = dist[u]
for v, e in G_succ[u].items():
dist_v = dist_u + get_weight(e)
if dist_v < dist.get(v, inf):
if v not in in_q:
q.append(v)
in_q.add(v)
count_v = count.get(v, 0) + 1
if count_v == n:
raise nx.NetworkXUnbounded(
"Negative cost cycle detected.")
count[v] = count_v
dist[v] = dist_v
pred[v] = u
return pred, dist
def _bellman_ford_relaxation(G, pred, dist, source, weight):
"""Relaxation loop for Bellman–Ford algorithm
Parameters
----------
G : NetworkX graph
pred: dict
Keyed by node to predecessor in the path
dist: dict
Keyed by node to the distance from the source
source: list
List of source nodes
weight : function
The weight of an edge is the value returned by the function. The
function must accept exactly three positional arguments: the two
endpoints of an edge and the dictionary of edge attributes for
that edge. The function must return a number.
Returns
-------
Returns two dictionaries keyed by node to predecessor in the
path and to the distance from the source respectively.
Raises
------
NetworkXUnbounded
If the (di)graph contains a negative cost (di)cycle, the
algorithm raises an exception to indicate the presence of the
negative cost (di)cycle. Note: any negative weight edge in an
undirected graph is a negative cost cycle
"""
G_succ = G.succ if G.is_directed() else G.adj
inf = float('inf')
n = len(G)
count = {}
q = deque(source)
in_q = set(source)
while q:
u = q.popleft()
in_q.remove(u)
# Skip relaxations if the predecessor of u is in the queue.
if pred[u] not in in_q:
dist_u = dist[u]
for v, e in G_succ[u].items():
dist_v = dist_u + weight(u, v, e)
if dist_v < dist.get(v, inf):
if v not in in_q:
q.append(v)
in_q.add(v)
count_v = count.get(v, 0) + 1
if count_v == n:
raise nx.NetworkXUnbounded(
"Negative cost cycle detected.")
count[v] = count_v
dist[v] = dist_v
pred[v] = u
return pred, dist
def bellman_ford(G, source, weight='weight'):
"""Compute shortest path lengths and predecessors on shortest paths
in weighted graphs.
The algorithm has a running time of O(mn) where n is the number of
nodes and m is the number of edges. It is slower than Dijkstra but
can handle negative edge weights.
Parameters
----------
G : NetworkX graph
The algorithm works for all types of graphs, including directed
graphs and multigraphs.
source: node label
Starting node for path
weight: string, optional (default='weight')
Edge data key corresponding to the edge weight
Returns
-------
pred, dist : dictionaries
Returns two dictionaries keyed by node to predecessor in the
path and to the distance from the source respectively.
Raises
------
NetworkXUnbounded
If the (di)graph contains a negative cost (di)cycle, the
algorithm raises an exception to indicate the presence of the
negative cost (di)cycle. Note: any negative weight edge in an
undirected graph is a negative cost cycle.
Examples
--------
>>> import networkx as nx
>>> G = nx.path_graph(5, create_using = nx.DiGraph())
>>> pred, dist = nx.bellman_ford(G, 0)
>>> sorted(pred.items())
[(0, None), (1, 0), (2, 1), (3, 2), (4, 3)]
>>> sorted(dist.items())
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
>>> from nose.tools import assert_raises
>>> G = nx.cycle_graph(5, create_using = nx.DiGraph())
>>> G[1][2]['weight'] = -7
>>> assert_raises(nx.NetworkXUnbounded, nx.bellman_ford, G, 0)
Notes
-----
Edge weight attributes must be numerical.
Distances are calculated as sums of weighted edges traversed.
The dictionaries returned only have keys for nodes reachable from
the source.
In the case where the (di)graph is not connected, if a component
not containing the source contains a negative cost (di)cycle, it
will not be detected.
"""
if source not in G:
raise KeyError("Node %s is not found in the graph" % source)
for u, v, attr in G.selfloop_edges(data=True):
if attr.get(weight, 1) < 0:
raise nx.NetworkXUnbounded("Negative cost cycle detected.")
dist = {source: 0}
pred = {source: None}
if len(G) == 1:
return pred, dist
if G.is_multigraph():
def get_weight(edge_dict):
return min(eattr.get(weight, 1) for eattr in edge_dict.values())
else:
def get_weight(edge_dict):
return edge_dict.get(weight, 1)
if G.is_directed():
G_succ = G.succ
else:
G_succ = G.adj
inf = float('inf')
n = len(G)
count = {}
q = deque([source])
in_q = set([source])
while q:
u = q.popleft()
in_q.remove(u)
# Skip relaxations if the predecessor of u is in the queue.
if pred[u] not in in_q:
dist_u = dist[u]
for v, e in G_succ[u].items():
dist_v = dist_u + get_weight(e)
if dist_v < dist.get(v, inf):
if v not in in_q:
q.append(v)
in_q.add(v)
count_v = count.get(v, 0) + 1
if count_v == n:
raise nx.NetworkXUnbounded(
"Negative cost cycle detected.")
count[v] = count_v
dist[v] = dist_v
pred[v] = u
return pred, dist
def bellman_ford(
G: Type[nx.DiGraph],
source: str,
weight_index: str = 'weight'
) -> Tuple[Dict[str, Optional[int]], Dict[str, Optional[int]]]:
"""
Computes shortest paths from a single source vertex to all of the other vertices in a weighted digraph (allowing for negative weights).
"""
if source not in G:
raise KeyError("Node %s is not found in the graph" % source)
dist = {source: 0}
pred = {source: None}
if len(G) == 1:
return pred, dist
if G.is_multigraph():
def get_weight(edge_dict):
return min(
eattr.get(weight_index, 1)
for eattr in list(edge_dict.values()))
else:
def get_weight(edge_dict):
return edge_dict.get(weight_index, 1)
if G.is_directed():
G_succ = G.succ
else:
G_succ = G.adj
inf = float('inf')
n = len(G)
count = {}
q = deque([source])
in_q = set([source])
while q:
u = q.popleft()
in_q.remove(u)
# Skip relaxations if the predecessor of u is in the queue.
if pred[u] not in in_q:
dist_u = dist[u]
for v, e in list(G_succ[u].items()):
dist_v = dist_u + get_weight(e)
if dist_v < dist.get(v, inf):
if v not in in_q:
q.append(v)
in_q.add(v)
count_v = count.get(v, 0) + 1
if count_v == n:
q.remove(v)
continue
count[v] = count_v
dist[v] = dist_v
pred[v] = u
return pred, dist
