Find the Dominators for every vertex in a given DAG (Directed Acyclic Graph)

Given a Directed Acyclic Graph with V vertices and E edges, the task is to find the set of dominant vertices for each vertex of the graph.

What are Dominators in Graph Theory: In control flow graphs a vertex V1 is the dominator of another vertex V2 if all the paths from the source vertex (in this case the vertex ‘0’) to the vertex V2 passes through V1. By definition, every vertex is one of its own dominators.

Examples:

Input: V = 5, E = 5, adj[][] = {{0, 1}, {0, 2}, {1, 3}, {2, 3}, {3, 4}}
Output:
Dominating set of vertex: 0 –> 0 
Dominating set of vertex: 1 –> 0 1 
Dominating set of vertex: 2 –> 0 2 
Dominating set of vertex: 3 –> 0 3 
Dominating set of vertex: 4 –> 0 3 4
Explanation:
          0
       /     \
     1        2
      \      /
         3
         |
        4          
Here 0 is the entry node, so its dominator is 0 itself.
Only one path exists between (0, 1) so the dominators of 1 are 0, 1.
Only one path exists between (0, 2) so the dominators of 2 are 0, 2.
There are 2 paths between(0, 3) having only 0, 3 in common.
From (0, 4) there are 2 paths (0 1 3 4) and (0 2 3 4) with 0, 3 and 4 common.

Input: V = 4, E = 3, adj[][] = {{0, 1}, {0, 2}, {3, 2}}
Output:
Dominating set of vertex: 0 –> 0 
Dominating set of vertex: 1 –> 0 1 
Dominating set of vertex: 2 –> 0 2 
Dominating set of vertex: 3 –> 0 2 3

Approach: The idea is to perform DFS and maintain a set of all the dominators of each vertex. Follow the steps below to solve the problem:

• Graph Traversal and Postorder: Perform a DFS from the source node (usually node 0) to obtain a postorder of the vertices. This will help process the vertices in reverse order.
• Initialize Dominators: Initialize the dominators for each vertex. The entry vertex (source vertex) should dominate only itself. For all other vertices, their initial dominators should include all vertices in the graph.
• Iterative Process: Repeat the following process until there is no change in the dominators for any vertex:
• For each vertex v in postorder (starting from the entry point), calculate its dominators as the intersection of its predecessors’ dominators, adding itself to the intersection result.
• Update the dominator set for each vertex.
• Calculate Intersection: Calculate the intersection of dominators of each vertex’s predecessors and add the current vertex to its dominator set.
• Repeat Until No Changes: Keep iterating until no changes are made to any vertex’s dominator set.
• Output: Once the process completes, output the set of dominators for each vertex.

Below is the implementation of the above approach:

Java

import java.util.*;

public class Dominators {
    public static void findDominators(int V, int[][] edges) {
        // Initialize graph
        Map<Integer, List<Integer>> graph = new HashMap<>();
        for (int[] edge : edges) {
            graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]);
        }
        
        // Initialize the list of dominators
        List<Set<Integer>> dominators = new ArrayList<>(V);
        for (int i = 0; i < V; i++) {
            dominators.add(new HashSet<>());
        }
        
        // Initialize a list of incoming edges count for each vertex
        int[] inDegrees = new int[V];
        for (int[] edge : edges) {
            inDegrees[edge[1]]++;
        }
        
        // Initialize the dominator set for the entry node (source node 0)
        dominators.get(0).add(0);
        
        // Initialize a queue for BFS traversal
        Queue<Integer> queue = new LinkedList<>();
        queue.add(0);
        
        // Perform BFS
        while (!queue.isEmpty()) {
            int u = queue.poll();
            
            // Traverse neighbors of the current vertex
            for (int v : graph.getOrDefault(u, new ArrayList<>())) {
                // Calculate the intersection of dominators from all predecessors of v
                if (dominators.get(v).isEmpty()) {
                    dominators.get(v).addAll(dominators.get(u));
                    dominators.get(v).add(v);
                } else {
                    dominators.get(v).retainAll(dominators.get(u));
                }
                
                // Reduce the in-degree count for vertex v
                inDegrees[v]--;
                
                // If all predecessors of v have been processed, add v to the queue
                if (inDegrees[v] == 0) {
                    queue.add(v);
                }
            }
        }
        
        // Print the dominator sets for each vertex
        for (int i = 0; i < V; i++) {
            System.out.print("Dominating set of vertex " + i + ": ");
            List<Integer> sortedDominators = new ArrayList<>(dominators.get(i));
            Collections.sort(sortedDominators);
            for (int dominator : sortedDominators) {
                System.out.print(dominator + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        int V = 5;
        int[][] edges = {{0, 1}, {0, 2}, {1, 3}, {2, 3}, {3, 4}};
        findDominators(V, edges);
    }
}

Python3

from collections import defaultdict, deque

def find_dominators(V, edges):
    # Initialize graph
    graph = defaultdict(list)
    for u, v in edges:
        graph[u].append(v)
    
    # Initialize the list of dominators
    dominators = [set() for _ in range(V)]
    
    # Initialize a list of incoming edges count for each vertex
    in_degrees = [0] * V
    for u, v in edges:
        in_degrees[v] += 1
    
    # Initialize the dominator set for the entry node (source node 0)
    dominators[0] = {0}
    
    # Initialize a queue for BFS traversal
    queue = deque([0])
    
    # Perform BFS
    while queue:
        u = queue.popleft()
        
        # Traverse neighbors of current vertex
        for v in graph[u]:
            # Calculate the intersection of dominators from all predecessors of v
            if not dominators[v]:
                dominators[v] = dominators[u].copy()
                dominators[v].add(v)
            else:
                dominators[v].intersection_update(dominators[u])
            
            # Reduce the in-degree count for vertex v
            in_degrees[v] -= 1
            
            # If all predecessors of v have been processed, add v to the queue
            if in_degrees[v] == 0:
                queue.append(v)
    
    # Print the dominator sets for each vertex
    for i in range(V):
        print(f"Dominating set of vertex {i}: {sorted(dominators[i])}")

# Example usage:
V = 5
edges = [(0, 1), (0, 2), (1, 3), (2, 3), (3, 4)]
find_dominators(V, edges)

C#

using System;
using System.Collections.Generic;

public class Dominators
{
    public static void FindDominators(int V, int[][] edges)
    {
        // Initialize graph
        Dictionary<int, List<int>> graph = new Dictionary<int, List<int>>();
        foreach (var edge in edges)
        {
            if (!graph.ContainsKey(edge[0]))
                graph[edge[0]] = new List<int>();
            graph[edge[0]].Add(edge[1]);
        }
        
        // Initialize the list of dominators
        List<HashSet<int>> dominators = new List<HashSet<int>>(V);
        for (int i = 0; i < V; i++)
        {
            dominators.Add(new HashSet<int>());
        }
        
        // Initialize a list of incoming edges count for each vertex
        int[] inDegrees = new int[V];
        foreach (var edge in edges)
        {
            inDegrees[edge[1]]++;
        }
        
        // Initialize the dominator set for the entry node (source node 0)
        dominators[0].Add(0);
        
        // Initialize a queue for BFS traversal
        Queue<int> queue = new Queue<int>();
        queue.Enqueue(0);
        
        // Perform BFS
        while (queue.Count > 0)
        {
            int u = queue.Dequeue();
            
            // Traverse neighbors of the current vertex
            if (graph.TryGetValue(u, out var neighbors))
            {
                foreach (var v in neighbors)
                {
                    // Calculate the intersection of dominators from all predecessors of v
                    if (dominators[v].Count == 0)
                    {
                        dominators[v].UnionWith(dominators[u]);
                        dominators[v].Add(v);
                    }
                    else
                    {
                        dominators[v].IntersectWith(dominators[u]);
                    }
                    
                    // Reduce the in-degree count for vertex v
                    inDegrees[v]--;
                    
                    // If all predecessors of v have been processed, add v to the queue
                    if (inDegrees[v] == 0)
                    {
                        queue.Enqueue(v);
                    }
                }
            }
        }
        
        // Print the dominator sets for each vertex
        for (int i = 0; i < V; i++)
        {
            Console.Write($"Dominating set of vertex {i}: ");
            var sortedDominators = new List<int>(dominators[i]);
            sortedDominators.Sort();
            foreach (var dominator in sortedDominators)
            {
                Console.Write(dominator + " ");
            }
            Console.WriteLine();
        }
    }

    public static void Main()
    {
        int V = 5;
        int[][] edges = new int[][] { new int[] { 0, 1 }, new int[] { 0, 2 }, new int[] { 1, 3 }, new int[] { 2, 3 }, new int[] { 3, 4 } };
        FindDominators(V, edges);
    }
}

Javascript

function findDominators(V, edges) {
    // Initialize graph
    const graph = {};
    for (const [u, v] of edges) {
        if (!graph[u]) graph[u] = [];
        graph[u].push(v);
    }

    // Initialize the list of dominators
    const dominators = Array.from({ length: V }, () => new Set());

    // Initialize a list of incoming edges count for each vertex
    const inDegrees = new Array(V).fill(0);
    for (const [u, v] of edges) {
        inDegrees[v]++;
    }

    // Initialize the dominator set for the entry node (source node 0)
    dominators[0].add(0);

    // Initialize a queue for BFS traversal
    const queue = [0];

    // Perform BFS
    while (queue.length > 0) {
        const u = queue.shift();

        // Traverse neighbors of the current vertex
        if (graph[u]) {
            for (const v of graph[u]) {
                // Calculate the intersection of dominators from all predecessors of v
                if (dominators[v].size === 0) {
                    dominators[v] = new Set([...dominators[u]]);
                    dominators[v].add(v);
                } else {
                    dominators[v] = new Set([...dominators[v]].filter(val => dominators[u].has(val)));
                }
                
                // Reduce the in-degree count for vertex v
                inDegrees[v]--;

                // If all predecessors of v have been processed, add v to the queue
                if (inDegrees[v] === 0) {
                    queue.push(v);
                }
            }
        }
    }

    // Print the dominator sets for each vertex
    for (let i = 0; i < V; i++) {
        console.log(`Dominating set of vertex ${i}: ${[...dominators[i]].sort().join(' ')}`);
    }
}

// Example usage:
const V = 5;
const edges = [[0, 1], [0, 2], [1, 3], [2, 3], [3, 4]];
findDominators(V, edges);

C++14

#include <iostream>
#include <vector>
#include <queue>
#include <unordered_map>
#include <set>
#include <algorithm>

using namespace std;

void findDominators(int V, const vector<pair<int, int>>& edges) {
    // Initialize graph
    unordered_map<int, vector<int>> graph;
    for (const auto& edge : edges) {
        graph[edge.first].push_back(edge.second);
    }
    
    // Initialize the list of dominators
    vector<set<int>> dominators(V);
    
    // Initialize a list of incoming edges count for each vertex
    vector<int> inDegrees(V, 0);
    for (const auto& edge : edges) {
        inDegrees[edge.second]++;
    }
    
    // Initialize the dominator set for the entry node (source node 0)
    dominators[0].insert(0);
    
    // Initialize a queue for BFS traversal
    queue<int> q;
    q.push(0);
    
    // Perform BFS
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        
        // Traverse neighbors of the current vertex
        for (int v : graph[u]) {
            // Calculate the intersection of dominators from all predecessors of v
            if (dominators[v].empty()) {
                dominators[v] = dominators[u];
                dominators[v].insert(v);
            } else {
                set<int> intersection;
                set_intersection(
                    dominators[v].

Output

0 -> 0 
1 -> 0 1 
2 -> 0 2 
3 -> 0 3 
4 -> 0 3 4 

Time Complexity: O(V + E)
Auxiliary Space: O(V²)