从度量> = 3的节点处拆分的图形中检索路径

Question

When I add paths to a graph:

>>> graph = nx.MultiGraph()  # Needs to be MultiGraph/MultiDiGraph.
>>> graph.add_path([1,2,3,4,5])
>>> graph.add_path([2,6,7])
>>> graph.add_path([4,8,9,10,11])

What can I do to retrieve my paths split at nodes with a degree >= 3? So that I get:

[[1, 2], [2, 6, 7], [2, 3, 4], [4, 8, 9, 10, 11], [4, 5]]

Answer 1

I assume you know your paths in advance. If you actually start out with a graph and want to "strip" it into paths, let me know. I would suggest another approach then.

Here is would I came up with, might not be the fastest or most elegant way, but it should work:

import networkx as nx

graph = nx.MultiGraph()
paths = [[1,2,3,4,5], [2,6,7], [4,8,9,10,11]]

for path in paths:
    graph.add_path(path)

splitted_paths = []    

# generate list of nodes at which the paths are to be splitted
splitting_nodes = [node for node in graph if graph.degree(node)>=3]

for path in paths:
    # find the splitting nodes in the current path
    splitting_nodes_in_path = [node for node in splitting_nodes if node in path]
    for splitting_node in splitting_nodes_in_path:
        # get remaining path up to the current splitting node
        path_piece = path[:path.index(splitting_node)+1]
        if len(path_piece) > 1:
            splitted_paths.append(path_piece)
        # overwrite current path with the remaining path
        path = path[path.index(splitting_node):]
    # get the remaining piece from the last splitting node until the end of the current path
    if len(path) > 1:        
        splitted_paths.append(path)

print splitted_paths

Hope this helps!

EDIT 1: removed an unnecessary for loop and added some missing code lines

---

EDIT 2: If you need to start out with a graph, like @marcus comment suggests, and want to have two paths in the given list of paths "glued together" if they are connected without a node of degree >= 3, you have to use a different approach. I don't have the time to fully code what I have in mind to solve this, but here is a sketch of what I would try:

• write a function cut(graph, node) that takes a Networkx graph and a nodelabel and replaces node by degree( node ) new nodes, each connected to one of node s neighbors (one has to think of a clever way to name the new nodes, so that it's clear in the end where they came from)
• apply cut() to all nodes of degree >= 3 and end up with a disconnected graph, where each component is one of the desired splitted paths

The following Networkx functions could maybe be helpful for that: remove_node() , subgraph() . all_simple_paths() , predecessor() and the Operators .

Answer 2

first: why do you need MultiGraph? From what you are saying, a simple DiGraph would suffice; MultiGraphs are only needed if you want two different connections from eg node 4 and 10, with different attributes.

A lot of nx functions don't work with MultiGraphs, but if DiGraphs will work, then you could try weakly_connected_subcomponent_graphs . I don't have time to completely code it up, but this should be the algorithm:

1- Get all the nodes with degree >=3 (this is easy, and left as an exercise to the reader), along with any node connected to it (predecessors + successors). 2- Remove the nodes from the graph. This should leave only nodes with degree <= 2. 3- Call weakly_connected_subcomponent_graphs. This will return the forest of remaining graphs that aren't connected to each other. 4- But the nodes with degree >=3 aren't included; you'll need to add them back. You have to add both nodes and edges; you can either just get the node list from the weakly connected subtree, add in the connection nodes, and ask the original graph for a subgraph, or add the edges yourself.

This should be reasonably fast.