给定一个非循环有向图，返回一组“在同一级别”的节点集合？

Question

Firstly I am not sure what such an algorithm is called, which is the primary problem - so first part of the question is what is this algorithm called?

Basically I have a DiGraph() into which I insert the nodes [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] and the edges ([1,3],[2,3],[3,5],[4,5],[5,7],[6,7],[7,8],[7,9],[7,10])

From this I'm wondering if it's possible to get a collection as follows: [[1, 2, 4, 6], [3], [5], [7], [8, 9, 10]]

EDIT: Let me add some constraints if it helps. - There are no cycles, this is guaranteed - There is no one start point for the graph

What I'm trying to do is to collect the nodes at the same level such that their processing can be parallelized, but within the outer collection, the processing is serial.

EDIT2: So clearly I hadn't thought about this enough, so the easiest way to describe "level" is interms of deepest predecessor , all nodes that have the same depth of predecessors. So the first entry in the above list are all nodes that have 0 as the deepest predecessor, the second has one, third has two and so on. Within each list, the order of the siblings is irrelevant as they will be parallelly processed.

Answer 1

Your question states that you would like the output, for this graph, to be [[1, 2, 4, 6], [3], [5], [7], [8, 9, 10]] . IIUC, the pattern is as follows:

• [1, 2, 4, 6] are the nodes that have no in edges.

• [3] are the nodes that have no in edges, assuming all previous nodes were erased.

• [4] are the nodes that have no in edges, assuming all previous nodes were erased.

• Etc. (until all nodes have been erased)

Say we start with

g = networkx.DiGraph()
g.add_edges_from([[1,3],[2,3],[3,5],[4,5],[5,7],[6,7],[7,8],[7,9],[7,10]])

Then we can just code this as

def find_levels(g):
    levels = []
    while g.nodes():
        no_in_nodes = [n for (n, d) in g.in_degree(g.nodes()).items() if d == 0]
        levels.append(no_in_nodes)
        for n in no_in_nodes:
            g.remove_node(n)
    return levels

If we run this, we get the result:

>>> find_levels(g)
[[1, 2, 4, 6], [3], [5], [7], [8, 9, 10]]

The complexity here is Θ(|V| ² + |E|) . A somewhat more complicated version can be built using a Fibonnacci Heap . Basically, all vertices need to be placed into a heap, with each level consisting of the vertices with 0 in degree. Each time one is popped, and the edges to other vertices are removed, we can translate this to a heap decrease-key operation (the in-degrees of remaining vertices are reduced). This would reduce the running time to Θ(|V| log(|V|) + |E|) .

Answer 2

A topological sort will achieve this, as Ami states. The following is a Boost Graph Library implementation, with no context, but the pseudocode can be extracted. The toporder object just provides the iterator to a topological ordering. I can extract the general algorithm if desired.

template<typename F>
void 
scheduler<F>::set_run_levels()
{

  run_levels = std::vector<int>(tasks.size(), 0);
  Vertexcont toporder;

  try
    {
      topological_sort(g, std::front_inserter(toporder));
    }
  catch(std::exception &e)
    {
      std::cerr << e.what() << "\n";
      std::cerr << "You most likely have a cycle...\n";
      exit(1);
    }

  vContIt i = toporder.begin();

  for(;
      i != toporder.end();
      ++i)
    {
      if (in_degree(*i,g) > 0)
        {
          inIt j, j_end;
          int maxdist = 0;
          for(boost::tie(j,j_end) = in_edges(*i,g);
              j != j_end;
              ++j)
            {
              maxdist = (std::max)(run_levels[source(*j,g)], maxdist);
              run_levels[*i] = maxdist+1;
            }
        }
    }
}

I think I once applied this to the same problem, then realized it was unnecessary. Just set up the tasks on a hair-trigger, with all tasks signaling completion to their dependents (by a condition_variable, promise). So all I needed was to know the dependencies of each task, find the initial task, then fire. Is a full specification of run_level needed in your case?

Answer 3

Why would bfs not solve it? A bfs algorithm is breadth traversal algorithm, ie it traverses the tree level wise. This also means, all nodes at same level are traversed at once, which is your desired output. As pointed out in comment, this will however, assume a starting point in the graph.