Question

Suppose we have a DAG with one source. I would like to find nodes n such that any complete path from the source runs through n (i.e. n dominates all sinks). In other words: if we removed all the succesors of n, then all paths would end in n. The problem is that nodes are incrementally marked as deleted in the DAG. As nodes are marked deleted, other nodes can start to satisfy the above property. How can I efficiently detect this as it happens?

Bonus points if the data structure can do this with multiple sources in a more efficient way than running the algorithm for a single source separately on each of the sources.

Answer 1

Topologically sort this DAG to establish some order for its nodes. For each node, its value would be the number of outgoing edges from all preceding nodes minus the number of incoming edges to all preceding nodes and current node. Value for “dominator” node is always zero.

After some node is marked “deleted”, put its predecessors and successors to priority queue. Priority is determined by the topological sort order. Update values for all nodes, following the “deleted” node (add the number of incoming nodes and subtract the number of outgoing nodes for this node). At the same time (in same order) decrement value for each node between predecessor node in the priority queue and the “deleted” node and increment value for each node, starting from successor node in the priority queue. Stop when some node’s value is decremented to zero. This is a new “dominator” node. If all “dominator” nodes needed, continue until the end of the graph.

delete(delNode):
  for each predecessor in delNode.predecessors: queue.add(predecessor)
  for each successor in delNode.successors: queue.add(successor)
  for each node in DAG:
    if queue.top.priority == node.priority > delNode.priority:
      ++accumulator

    node.value += accumulator
    if node.value == 0: dominatorDetected(node)

    if node.priority == delNode.priority:
      accumulator += (delNode.predecessors.size - delNode.successors.size)
      node.value = -1

    if queue.top.priority == node.priority:
      queue.pop()
      if node.priority < delNode.priority:
        --accumulator

    if queue.empty: stop

For multiple sources case, it is possible to use the same algorithm, but keep a list of “values” for each node, one value for each source. Algorithm complexity is O(Nodes * Sources), the same as for independent search on each of the sources. But the program may be made more efficient if vectorization is used. “values” may be processed in parallel with SIMD instructions. Modern compilers may do automatic vectorization to acieve this.