Warning
This documents an unmaintained version of NetworkX. Please upgrade to a maintained version and see the current NetworkX documentation.
Source code for networkx.algorithms.tree.branchings
# encoding: utf-8
"""
Algorithms for finding optimum branchings and spanning arborescences.
This implementation is based on:
J. Edmonds, Optimum branchings, J. Res. Natl. Bur. Standards 71B (1967),
233–240. URL: http://archive.org/details/jresv71Bn4p233
"""
# TODO: Implement method from Gabow, Galil, Spence and Tarjan:
#
#@article{
# year={1986},
# issn={0209-9683},
# journal={Combinatorica},
# volume={6},
# number={2},
# doi={10.1007/BF02579168},
# title={Efficient algorithms for finding minimum spanning trees in
# undirected and directed graphs},
# url={http://dx.doi.org/10.1007/BF02579168},
# publisher={Springer-Verlag},
# keywords={68 B 15; 68 C 05},
# author={Gabow, Harold N. and Galil, Zvi and Spencer, Thomas and Tarjan,
# Robert E.},
# pages={109-122},
# language={English}
#}
from __future__ import division
from __future__ import print_function
import string
import random
from operator import itemgetter
import networkx as nx
from .recognition import *
__all__ = [
'branching_weight', 'greedy_branching',
'maximum_branching', 'minimum_branching',
'maximum_spanning_arborescence', 'minimum_spanning_arborescence',
'Edmonds'
]
KINDS = set(['max', 'min'])
STYLES = {
'branching': 'branching',
'arborescence': 'arborescence',
'spanning arborescence': 'arborescence'
}
INF = float('inf')
def edge_subgraph(G, ebunch):
"""Return the subgraph induced on edges in `ebunch`.
The induced subgraph of the graph contains the edges appearing in `ebunch`
and only the nodes that appear in some edge in `ebunch`.
Parameters
----------
ebunch : list, iterable
A container of edges as 3-tuples (u, v, key), which will be iterated
through exactly once.
Returns
-------
H : MultiDiGraph
A subgraph of the graph with the same graph, node, and edge attributes.
Notes
-----
The graph, edge or node attributes just point to the original graph.
So changes to the node or edge structure will not be reflected in
the original graph while changes to the attributes will.
To create a subgraph with its own copy of the edge/node attributes use:
nx.Graph(G.subgraph(nbunch))
If edge attributes are containers, a deep copy can be obtained using:
G.subgraph(nbunch).copy()
For an inplace reduction of a graph to a subgraph you can remove nodes:
G.remove_nodes_from([ n in G if n not in set(nbunch)])
Examples
--------
>>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G.add_path([0,1,2,3])
>>> H = G.subgraph([0,1,2])
>>> H.edges()
[(0, 1), (1, 2)]
"""
# TODO: Add all the bells and whistles that G.subgraph has.
# Note: MultiDiGraph seems to point to node/graph and copy edge attributes.
# Seems inconsistent.
# create new graph and copy subgraph into it
H = G.__class__()
# add edges
G_succ = G.succ
for u, v, key in ebunch:
try:
attrs = G_succ[u][v][key]
except KeyError:
raise KeyError('Invalid edge: ({0}, {1}, {2})'.format(u, v, key))
H.add_edge(u, v, key=key, **attrs)
# copy node and graph attributes
for u in H:
H.node[u] = G.node[u].copy()
H.graph = G.graph.copy()
return H
def random_string(L=15, seed=None):
random.seed(seed)
return ''.join([random.choice(string.ascii_letters) for n in range(L)])
def _min_weight(weight):
return -weight
def _max_weight(weight):
return weight
[docs]def branching_weight(G, attr='weight', default=1):
"""
Returns the total weight of a branching.
"""
return sum(edge[2].get(attr, default) for edge in G.edges(data=True))
[docs]def greedy_branching(G, attr='weight', default=1, kind='max'):
"""
Returns a branching obtained through a greedy algorithm.
This algorithm is wrong, and cannot give a proper optimal branching.
However, we include it for pedagogical reasons, as it can be helpful to
see what its outputs are.
The output is a branching, and possibly, a spanning arborescence. However,
it is not guaranteed to be optimal in either case.
Parameters
----------
G : DiGraph
The directed graph to scan.
attr : str
The attribute to use as weights. If None, then each edge will be
treated equally with a weight of 1.
default : float
When `attr` is not None, then if an edge does not have that attribute,
`default` specifies what value it should take.
kind : str
The type of optimum to search for: 'min' or 'max' greedy branching.
Returns
-------
B : directed graph
The greedily obtained branching.
"""
if kind not in KINDS:
raise nx.NetworkXException("Unknown value for `kind`.")
if kind == 'min':
reverse = False
else:
reverse = True
if attr is None:
# Generate a random string the graph probably won't have.
attr = random_string()
edges = [(u, v, data.get(attr, default))
for (u, v, data) in G.edges(data=True)]
# We sort by weight, but also by nodes to normalize behavior across runs.
try:
edges.sort(key=itemgetter(2, 0, 1), reverse=reverse)
except TypeError:
# This will fail in Python 3.x if the nodes are of varying types.
# In that case, we use the arbitrary order.
edges.sort(key=itemgetter(2), reverse=reverse)
# The branching begins with a forest of no edges.
B = nx.DiGraph()
B.add_nodes_from(G)
# Now we add edges greedily so long we maintain the branching.
uf = nx.utils.UnionFind()
for i, (u, v, w) in enumerate(edges):
if uf[u] == uf[v]:
# Adding this edge would form a directed cycle.
continue
elif B.in_degree(v) == 1:
# The edge would increase the degree to be greater than one.
continue
else:
# If attr was None, then don't insert weights...
data = {}
if attr is not None:
data[attr] = w
B.add_edge(u, v, **data)
uf.union(u, v)
return B
class MultiDiGraph_EdgeKey(nx.MultiDiGraph):
"""
MultiDiGraph which assigns unique keys to every edge.
Adds a dictionary edge_index which maps edge keys to (u, v, data) tuples.
This is not a complete implementation. For Edmonds algorithm, we only use
add_node and add_edge, so that is all that is implemented here. During
additions, any specified keys are ignored---this means that you also
cannot update edge attributes through add_node and add_edge.
Why do we need this? Edmonds algorithm requires that we track edges, even
as we change the head and tail of an edge, and even changing the weight
of edges. We must reliably track edges across graph mutations.
"""
def __init__(self, data=None, **attr):
cls = super(MultiDiGraph_EdgeKey, self)
cls.__init__(data=data, **attr)
self._cls = cls
self.edge_index = {}
def remove_node(self, n):
keys = set([])
for keydict in self.pred[n].values():
keys.update(keydict)
for keydict in self.succ[n].values():
keys.update(keydict)
for key in keys:
del self.edge_index[key]
self._cls.remove_node(n)
def remove_nodes_from(self, nbunch):
for n in nbunch:
self.remove_node(n)
def add_edge(self, u, v, key, attr_dict=None, **attr):
"""
Key is now required.
"""
if key in self.edge_index:
uu, vv, _ = self.edge_index[key]
if (u != uu) or (v != vv):
raise Exception("Key {0!r} is already in use.".format(key))
self._cls.add_edge(u, v, key=key, attr_dict=attr_dict, **attr)
self.edge_index[key] = (u, v, self.succ[u][v][key])
def add_edges_from(self, ebunch, attr_dict=None, **attr):
raise NotImplementedError
def remove_edge_with_key(self, key):
try:
u, v, _ = self.edge_index[key]
except KeyError:
raise KeyError('Invalid edge key {0!r}'.format(key))
else:
del self.edge_index[key]
self._cls.remove_edge(u, v, key)
def remove_edges_from(self, ebunch):
raise NotImplementedError
def get_path(G, u, v):
"""
Returns the edge keys of the unique path between u and v.
This is not a generic function. G must be a branching and an instance of
MultiDiGraph_EdgeKey.
"""
nodes = nx.shortest_path(G, u, v)
# We are guaranteed that there is only one edge connected every node
# in the shortest path.
def first_key(i, vv):
# Needed for 2.x/3.x compatibilitity
keys = G[nodes[i]][vv].keys()
# Normalize behavior
keys = list(keys)
return keys[0]
edges = [first_key(i, vv) for i, vv in enumerate(nodes[1:])]
return nodes, edges
[docs]class Edmonds(object):
"""
Edmonds algorithm for finding optimal branchings and spanning arborescences.
"""
[docs] def __init__(self, G, seed=None):
self.G_original = G
# Need to fix this. We need the whole tree.
self.store = True
# The final answer.
self.edges = []
# Since we will be creating graphs with new nodes, we need to make
# sure that our node names do not conflict with the real node names.
self.template = random_string(seed=seed) + '_{0}'
def _init(self, attr, default, kind, style):
if kind not in KINDS:
raise nx.NetworkXException("Unknown value for `kind`.")
# Store inputs.
self.attr = attr
self.default = default
self.kind = kind
self.style = style
# Determine how we are going to transform the weights.
if kind == 'min':
self.trans = trans = _min_weight
else:
self.trans = trans = _max_weight
if attr is None:
# Generate a random attr the graph probably won't have.
attr = random_string()
# This is the actual attribute used by the algorithm.
self._attr = attr
# The object we manipulate at each step is a multidigraph.
self.G = G = MultiDiGraph_EdgeKey()
for key, (u, v, data) in enumerate(self.G_original.edges(data=True)):
d = {attr: trans(data.get(attr, default))}
G.add_edge(u, v, key, **d)
self.level = 0
# These are the "buckets" from the paper.
#
# As in the paper, G^i are modified versions of the original graph.
# D^i and E^i are nodes and edges of the maximal edges that are
# consistent with G^i. These are dashed edges in figures A-F of the
# paper. In this implementation, we store D^i and E^i together as a
# graph B^i. So we will have strictly more B^i than the paper does.
self.B = MultiDiGraph_EdgeKey()
self.B.edge_index = {}
self.graphs = [] # G^i
self.branchings = [] # B^i
self.uf = nx.utils.UnionFind()
# A list of lists of edge indexes. Each list is a circuit for graph G^i.
# Note the edge list will not, in general, be a circuit in graph G^0.
self.circuits = []
# Stores the index of the minimum edge in the circuit found in G^i and B^i.
# The ordering of the edges seems to preserve the weight ordering from G^0.
# So even if the circuit does not form a circuit in G^0, it is still true
# that the minimum edge of the circuit in G^i is still the minimum edge
# in circuit G^0 (depsite their weights being different).
self.minedge_circuit = []
def find_optimum(self, attr='weight', default=1, kind='max', style='branching'):
"""
Returns a branching from G.
Parameters
----------
attr : str
The edge attribute used to in determining optimality.
default : float
The value of the edge attribute used if an edge does not have
the attribute `attr`.
kind : {'min', 'max'}
The type of optimum to search for, either 'min' or 'max'.
style : {'branching', 'arborescence'}
If 'branching', then an optimal branching is found. If `style` is
'arborescence', then a branching is found, such that if the
branching is also an arborescence, then the branching is an
optimal spanning arborescences. A given graph G need not have
an optimal spanning arborescence.
Returns
-------
H : (multi)digraph
The branching.
"""
self._init(attr, default, kind, style)
uf = self.uf
# This enormous while loop could use some refactoring...
G, B = self.G, self.B
D = set([])
nodes = iter(list(G.nodes()))
attr = self._attr
G_pred = G.pred
def desired_edge(v):
"""
Find the edge directed toward v with maximal weight.
"""
edge = None
weight = -INF
for u, _, key, data in G.in_edges(v, data=True, keys=True):
new_weight = data[attr]
if new_weight > weight:
weight = new_weight
edge = (u, v, key, new_weight)
return edge, weight
while True:
# (I1): Choose a node v in G^i not in D^i.
try:
v = next(nodes)
except StopIteration:
# If there are no more new nodes to consider, then we *should*
# meet the break condition (b) from the paper:
# (b) every node of G^i is in D^i and E^i is a branching
# Construction guarantees that it's a branching.
assert( len(G) == len(B) )
if len(B):
assert( is_branching(B) )
if self.store:
self.graphs.append(G.copy())
self.branchings.append(B.copy())
# Add these to keep the lengths equal. Element i is the
# circuit at level i that was merged to form branching i+1.
# There is no circuit for the last level.
self.circuits.append([])
self.minedge_circuit.append(None)
break
else:
if v in D:
#print("v in D", v)
continue
# Put v into bucket D^i.
#print("Adding node {0}".format(v))
D.add(v)
B.add_node(v)
edge, weight = desired_edge(v)
#print("Max edge is {0!r}".format(edge))
if edge is None:
# If there is no edge, continue with a new node at (I1).
continue
else:
# Determine if adding the edge to E^i would mean its no longer
# a branching. Presently, v has indegree 0 in B---it is a root.
u = edge[0]
if uf[u] == uf[v]:
# Then adding the edge will create a circuit. Then B
# contains a unique path P from v to u. So condition (a)
# from the paper does hold. We need to store the circuit
# for future reference.
Q_nodes, Q_edges = get_path(B, v, u)
Q_edges.append(edge[2])
else:
# Then B with the edge is still a branching and condition
# (a) from the paper does not hold.
Q_nodes, Q_edges = None, None
# Conditions for adding the edge.
# If weight < 0, then it cannot help in finding a maximum branching.
if self.style == 'branching' and weight <= 0:
acceptable = False
else:
acceptable = True
#print("Edge is acceptable: {0}".format(acceptable))
if acceptable:
dd = {attr: weight}
B.add_edge(u, v, key=edge[2], **dd)
G[u][v][edge[2]]['candidate'] = True
uf.union(u, v)
if Q_edges is not None:
#print("Edge introduced a simple cycle:")
#print(Q_nodes, Q_edges)
# Move to method
# Previous meaning of u and v is no longer important.
# Apply (I2).
# Get the edge in the cycle with the minimum weight.
# Also, save the incoming weights for each node.
minweight = INF
minedge = None
Q_incoming_weight = {}
for edge_key in Q_edges:
u, v, data = B.edge_index[edge_key]
w = data[attr]
Q_incoming_weight[v] = w
if w < minweight:
minweight = w
minedge = edge_key
self.circuits.append(Q_edges)
self.minedge_circuit.append(minedge)
if self.store:
self.graphs.append(G.copy())
# Always need the branching with circuits.
self.branchings.append(B.copy())
# Now we mutate it.
new_node = self.template.format(self.level)
#print(minweight, minedge, Q_incoming_weight)
G.add_node(new_node)
new_edges = []
for u, v, key, data in G.edges(data=True, keys=True):
if u in Q_incoming_weight:
if v in Q_incoming_weight:
# Circuit edge, do nothing for now.
# Eventually delete it.
continue
else:
# Outgoing edge. Make it from new node
dd = data.copy()
new_edges.append((new_node, v, key, dd))
else:
if v in Q_incoming_weight:
# Incoming edge. Change its weight
w = data[attr]
w += minweight - Q_incoming_weight[v]
dd = data.copy()
dd[attr] = w
new_edges.append((u, new_node, key, dd))
else:
# Outside edge. No modification necessary.
continue
G.remove_nodes_from(Q_nodes)
B.remove_nodes_from(Q_nodes)
D.difference_update(set(Q_nodes))
for u, v, key, data in new_edges:
G.add_edge(u, v, key, **data)
if 'candidate' in data:
del data['candidate']
B.add_edge(u, v, key, **data)
uf.union(u, v)
nodes = iter(list(G.nodes()))
self.level += 1
# (I3) Branch construction.
#print(self.level)
H = self.G_original.__class__()
def is_root(G, u, edgekeys):
"""
Returns True if `u` is a root node in G.
Node `u` will be a root node if its in-degree, restricted to the
specified edges, is equal to 0.
"""
if u not in G:
#print(G.nodes(), u)
raise Exception('{0!r} not in G'.format(u))
for v in G.pred[u]:
for edgekey in G.pred[u][v]:
if edgekey in edgekeys:
return False, edgekey
else:
return True, None
# Start with the branching edges in the last level.
edges = set(self.branchings[self.level].edge_index)
while self.level > 0:
self.level -= 1
# The current level is i, and we start counting from 0.
# We need the node at level i+1 that results from merging a circuit
# at level i. randomname_0 is the first merged node and this
# happens at level 1. That is, randomname_0 is a node at level 1
# that results from merging a circuit at level 0.
merged_node = self.template.format(self.level)
# The circuit at level i that was merged as a node the graph
# at level i+1.
circuit = self.circuits[self.level]
#print
#print(merged_node, self.level, circuit)
#print("before", edges)
# Note, we ask if it is a root in the full graph, not the branching.
# The branching alone doesn't have all the edges.
isroot, edgekey = is_root(self.graphs[self.level + 1],
merged_node, edges)
edges.update(circuit)
if isroot:
minedge = self.minedge_circuit[self.level]
if minedge is None:
raise Exception
# Remove the edge in the cycle with minimum weight.
edges.remove(minedge)
else:
# We have identified an edge at next higher level that
# transitions into the merged node at the level. That edge
# transitions to some corresponding node at the current level.
# We want to remove an edge from the cycle that transitions
# into the corresponding node.
#print("edgekey is: ", edgekey)
#print("circuit is: ", circuit)
# The branching at level i
G = self.graphs[self.level]
#print(G.edge_index)
target = G.edge_index[edgekey][1]
for edgekey in circuit:
u, v, data = G.edge_index[edgekey]
if v == target:
break
else:
raise Exception("Couldn't find edge incoming to merged node.")
#print("not a root. removing {0}".format(edgekey))
edges.remove(edgekey)
self.edges = edges
H.add_nodes_from(self.G_original)
for edgekey in edges:
u, v, d = self.graphs[0].edge_index[edgekey]
dd = {self.attr: self.trans(d[self.attr])}
# TODO: make this preserve the key. In fact, make this use the
# same edge attributes as the original graph.
H.add_edge(u, v, **dd)
return H
[docs]def maximum_branching(G, attr='weight', default=1):
ed = Edmonds(G)
B = ed.find_optimum(attr, default, kind='max', style='branching')
return B
[docs]def minimum_branching(G, attr='weight', default=1):
ed = Edmonds(G)
B = ed.find_optimum(attr, default, kind='min', style='branching')
return B
[docs]def maximum_spanning_arborescence(G, attr='weight', default=1):
ed = Edmonds(G)
B = ed.find_optimum(attr, default, kind='max', style='arborescence')
if not is_arborescence(B):
msg = 'No maximum spanning arborescence in G.'
raise nx.exception.NetworkXException(msg)
return B
[docs]def minimum_spanning_arborescence(G, attr='weight', default=1):
ed = Edmonds(G)
B = ed.find_optimum(attr, default, kind='min', style='arborescence')
if not is_arborescence(B):
msg = 'No maximum spanning arborescence in G.'
raise nx.exception.NetworkXException(msg)
return B
docstring_branching = """
Returns a {kind} {style} from G.
Parameters
----------
G : (multi)digraph-like
The graph to be searched.
attr : str
The edge attribute used to in determining optimality.
default : float
The value of the edge attribute used if an edge does not have
the attribute `attr`.
Returns
-------
B : (multi)digraph-like
A {kind} {style}.
"""
docstring_arborescence = docstring_branching + """
Raises
------
NetworkXException
If the graph does not contain a {kind} {style}.
"""
maximum_branching.__doc__ = \
docstring_branching.format(kind='maximum', style='branching')
minimum_branching.__doc__ = \
docstring_branching.format(kind='minimum', style='branching')
maximum_spanning_arborescence.__doc__ = \
docstring_arborescence.format(kind='maximum', style='spanning arborescence')
minimum_spanning_arborescence.__doc__ = \
docstring_arborescence.format(kind='minimum', style='spanning arborescence')