all_simple_paths#
- all_simple_paths(G, source, target, cutoff=None)[source]#
Generate all simple paths in the graph G from source to target.
A simple path is a path with no repeated nodes.
- Parameters:
- GNetworkX graph
- sourcenode
Starting node for path
- targetnodes
Single node or iterable of nodes at which to end path
- cutoffinteger, optional
Depth to stop the search. Only paths of length <= cutoff are returned.
- Returns:
- path_generator: generator
A generator that produces lists of simple paths. If there are no paths between the source and target within the given cutoff the generator produces no output. If it is possible to traverse the same sequence of nodes in multiple ways, namely through parallel edges, then it will be returned multiple times (once for each viable edge combination).
See also
all_shortest_paths
,shortest_path
,has_path
Notes
This algorithm uses a modified depth-first search to generate the paths [1]. A single path can be found in \(O(V+E)\) time but the number of simple paths in a graph can be very large, e.g. \(O(n!)\) in the complete graph of order \(n\).
This function does not check that a path exists between
source
andtarget
. For large graphs, this may result in very long runtimes. Consider usinghas_path
to check that a path exists betweensource
andtarget
before calling this function on large graphs.References
[1]R. Sedgewick, “Algorithms in C, Part 5: Graph Algorithms”, Addison Wesley Professional, 3rd ed., 2001.
Examples
This iterator generates lists of nodes:
>>> G = nx.complete_graph(4) >>> for path in nx.all_simple_paths(G, source=0, target=3): ... print(path) ... [0, 1, 2, 3] [0, 1, 3] [0, 2, 1, 3] [0, 2, 3] [0, 3]
You can generate only those paths that are shorter than a certain length by using the
cutoff
keyword argument:>>> paths = nx.all_simple_paths(G, source=0, target=3, cutoff=2) >>> print(list(paths)) [[0, 1, 3], [0, 2, 3], [0, 3]]
To get each path as the corresponding list of edges, you can use the
networkx.utils.pairwise()
helper function:>>> paths = nx.all_simple_paths(G, source=0, target=3) >>> for path in map(nx.utils.pairwise, paths): ... print(list(path)) [(0, 1), (1, 2), (2, 3)] [(0, 1), (1, 3)] [(0, 2), (2, 1), (1, 3)] [(0, 2), (2, 3)] [(0, 3)]
Pass an iterable of nodes as target to generate all paths ending in any of several nodes:
>>> G = nx.complete_graph(4) >>> for path in nx.all_simple_paths(G, source=0, target=[3, 2]): ... print(path) ... [0, 1, 2] [0, 1, 2, 3] [0, 1, 3] [0, 1, 3, 2] [0, 2] [0, 2, 1, 3] [0, 2, 3] [0, 3] [0, 3, 1, 2] [0, 3, 2]
The singleton path from
source
to itself is considered a simple path and is included in the results:>>> G = nx.empty_graph(5) >>> list(nx.all_simple_paths(G, source=0, target=0)) [[0]]
>>> G = nx.path_graph(3) >>> list(nx.all_simple_paths(G, source=0, target={0, 1, 2})) [[0], [0, 1], [0, 1, 2]]
Iterate over each path from the root nodes to the leaf nodes in a directed acyclic graph using a functional programming approach:
>>> from itertools import chain >>> from itertools import product >>> from itertools import starmap >>> from functools import partial >>> >>> chaini = chain.from_iterable >>> >>> G = nx.DiGraph([(0, 1), (1, 2), (0, 3), (3, 2)]) >>> roots = (v for v, d in G.in_degree() if d == 0) >>> leaves = (v for v, d in G.out_degree() if d == 0) >>> all_paths = partial(nx.all_simple_paths, G) >>> list(chaini(starmap(all_paths, product(roots, leaves)))) [[0, 1, 2], [0, 3, 2]]
The same list computed using an iterative approach:
>>> G = nx.DiGraph([(0, 1), (1, 2), (0, 3), (3, 2)]) >>> roots = (v for v, d in G.in_degree() if d == 0) >>> leaves = (v for v, d in G.out_degree() if d == 0) >>> all_paths = [] >>> for root in roots: ... for leaf in leaves: ... paths = nx.all_simple_paths(G, root, leaf) ... all_paths.extend(paths) >>> all_paths [[0, 1, 2], [0, 3, 2]]
Iterate over each path from the root nodes to the leaf nodes in a directed acyclic graph passing all leaves together to avoid unnecessary compute:
>>> G = nx.DiGraph([(0, 1), (2, 1), (1, 3), (1, 4)]) >>> roots = (v for v, d in G.in_degree() if d == 0) >>> leaves = [v for v, d in G.out_degree() if d == 0] >>> all_paths = [] >>> for root in roots: ... paths = nx.all_simple_paths(G, root, leaves) ... all_paths.extend(paths) >>> all_paths [[0, 1, 3], [0, 1, 4], [2, 1, 3], [2, 1, 4]]
If parallel edges offer multiple ways to traverse a given sequence of nodes, this sequence of nodes will be returned multiple times:
>>> G = nx.MultiDiGraph([(0, 1), (0, 1), (1, 2)]) >>> list(nx.all_simple_paths(G, 0, 2)) [[0, 1, 2], [0, 1, 2]]