Kosaraju's Algorithm in Python

Last Updated : 30 May, 2024

What is Kosaraju's Algorithm?

Kosaraju's Algorithm is a classic graph theory algorithm used to find the Strongly Connected Components (SCCs) in a directed graph. A strongly connected component is a maximal subgraph where every vertex is reachable from every other vertex. Kosaraju's algorithm is efficient, with a time complexity of O(V+E), where V is the number of vertices and E is the number of edges.

Kosaraju's algorithm consists of two main passes over the graph:

First Pass: Perform a Depth-First Search (DFS) on the original graph to compute the finishing times of the vertices.
Second Pass: Perform a DFS on the transposed graph (graph with all edges reversed) in the order of decreasing finishing times obtained in the first pass.

The algorithm can be broken down into the following steps:

Steps of Kosaraju's Algorithm:

Initialize: Create an empty stack to store the order of finishing times and a visited list to track visited vertices.
First DFS: Perform DFS on the original graph. Push each vertex onto the stack once its DFS finishes.
Transpose Graph: Reverse the direction of all edges in the graph to get the transposed graph.
Second DFS: Perform DFS on the transposed graph using the vertices in the order defined by the stack (from the first DFS).
Collect SCCs: Each DFS in this second pass gives one SCC.

Implementation of Kosaraju's Algorithm in Python

Here’s a Python implementation of Kosaraju’s Algorithm:

Python

from collections import defaultdict, deque  class Graph:     def __init__(self, vertices):         self.V = vertices         self.graph = defaultdict(list)      def add_edge(self, u, v):         self.graph[u].append(v)      def _dfs(self, v, visited, stack):         visited[v] = True         for neighbor in self.graph[v]:             if not visited[neighbor]:                 self._dfs(neighbor, visited, stack)         stack.append(v)      def _transpose(self):         transposed_graph = Graph(self.V)         for node in self.graph:             for neighbor in self.graph[node]:                 transposed_graph.add_edge(neighbor, node)         return transposed_graph      def _fill_order(self, visited, stack):         for i in range(self.V):             if not visited[i]:                 self._dfs(i, visited, stack)      def _dfs_util(self, v, visited, component):         visited[v] = True         component.append(v)         for neighbor in self.graph[v]:             if not visited[neighbor]:                 self._dfs_util(neighbor, visited, component)      def kosaraju_scc(self):         stack = deque()         visited = [False] * self.V          self._fill_order(visited, stack)          transposed_graph = self._transpose()          visited = [False] * self.V         scc_list = []          while stack:             node = stack.pop()             if not visited[node]:                 component = []                 transposed_graph._dfs_util(node, visited, component)                 scc_list.append(component)          return scc_list  # Example usage if __name__ == "__main__":     g = Graph(5)     g.add_edge(1, 0)     g.add_edge(0, 2)     g.add_edge(2, 1)     g.add_edge(0, 3)     g.add_edge(3, 4)      sccs = g.kosaraju_scc()     print("Strongly Connected Components:", sccs)

Output

Strongly Connected Components: [[0, 1, 2], [3], [4]]

Time complexity: O(V+E), where V is the number of vertices and E is the number of edges in the graph.
Auxiliary space: O(V+E)

Kosaraju’s Algorithm in C

code_r

Improve

Article Tags :

Practice Tags :

Graph

Kosaraju's Algorithm in Python

What is Kosaraju's Algorithm?

Steps of Kosaraju's Algorithm:

Implementation of Kosaraju's Algorithm in Python

Similar Reads