How many components in a directed graph? - graph

Question

I have the following graph:
The optimal solution is to start dfs from vertex (3) then i will get one component, but when we start the dfs from vertex (1) then (3) i will get two components.
The question is:
I want to know how many components in this graph? or on other way, what is the minimum number of dfs needed to cover all the graph?
what is the needed algorithm for doing this?

Answer 1

You are confusing two definitions.
For undirected graphs there is the notion of connected components, which you find by performing a DFS on the undirected graph.
For directed graphs there is the notion of strongly connected components, for which multiple algorithms are available, all slightly more complicated than a simple DFS.
What you should do depends on which of the two notions you need. Your graph has one connected component when viewed as an undirected graph, and two strongly connected components when viewed as a directed graph.

Answer 2

I know this is an old thread but it would be helpful to add how I solved the problem:
1 - Find the strongly connected components (SCC) inside the graph, and for each SCC, we can replace it with a single node that represents that SCC.
2 - Now, we can know the min number of nodes that we can run DFS from and cover all the other nodes by looking at the degrees of the nodes in the new graph, so we can start DFS from the nodes with zero in degree.

Answer 3

I believe you are trying to find weakly connected components .
Testing whether a directed graph is weakly connected can be done easily in linear time. Simply turn all edges into undirected edges and use the DFS-based connected components algorithm.

Answer 4

To solve this exercise, the idea is to work with an adjacency list of IN-edges.
Take as an example a graph with 3 nodes and 2 edges (0,1) and (0,2), whereas (a,b) indicates that if you switch light a, then light b will also be switched.
OUT-edges adjacency list:
0 -> 1, 2
1 -> _
2 -> _
IN-edges adjacency list:
0 -> _
1 -> 0
2 -> 0
Assuming we don't have cycles, if we follow the IN-edges down until you reach a node which does not have a child, you get what I call an "influencer", that is, you can not switch it with any other node.
Now to take account for cycles I check if any neighbor has or is an influencer. If this is not the case and all neighbors have been visited already, I encounter a cycle and make the current node an influencer.
This is my code (tested with simple examples on my desk):
private int numberOfLights(){
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
List<List<Integer>> inAdjList = new ArrayList<List<Integer>>();
for(int i = 0; i < n; i++){
inAdjList.add(new ArrayList<>());
}
for(int i = 0; i < n; i++){
int from = scanner.nextInt();
int to = scanner.nextInt();
inAdjList.get(to).add(from);
}
int[] visited = new int[n];
int[] isOrHasInfluencer = new int[n];
List<Integer> influencers = new ArrayList<>();
for(int i = 0; i < n; i++){
if(!visited[i]){
DFS(i, visited, isOrHasInfluencer, influencers, inAdjList);
}
}
return influencers.size();
}
private void DFS(Integer cur, int[] visited, int[] isOrHasInfluencer, List<Integer> influencers, List<List<Integer>> inAdjList){
visited[cur] = true;
boolean hasUnvisitedChildren = false;
for(Integer neighbor : inAdjList.get(cur)){
if(!visited[neighbor]){
hasUnvisitedChildren = true;
DFS(neighbor, visited, isOrHasInfluencer, influencers, inAdjList);
}
if(isOrHasInfluencer[neighbor]){
isOrHasInfluencer[cur] = true;
}
}
if(!hasUnvisitedChildren && !isOrHasInfluencer[cur]){
isOrHasInfluencer[cur] = true;
influencers.add(cur);
}
}
Hope that helps! :)

Answer 5

You can run findConnectedComponent algorithm from each of nodes and return the minimum number to solve your specific problem.
I think this solution is not optimal but it works very well with small to medium sized input graph.

Answer 6

Old question, but there is another way.
Convert the directed graph to an undirected one by doing a DFS on all the nodes. O(V+E)
Do what you do for undirected graph. O(V+E)