in a directed graph a strongly connected component is a set of vertices such that for any pairs of vertices u and v there exists a path u v that connects them a graph is strongly connected if it is a single strongly connected component a directed graph where edges are oneway a twoway edge can be represented by using two edges create a new graph with vertexcount vertices add an edge going from source to target determine if all nodes are reachable from node 0 determine if all nodes are reachable from the given node create a new graph where every edge ab is replaced with an edge ba note we reverse the order of arguments pylint disableargumentsoutoforder determine if the graph is strongly connected a directed graph where edges are one way a two way edge can be represented by using two edges create a new graph with vertex_count vertices add an edge going from source to target determine if all nodes are reachable from node 0 determine if all nodes are reachable from the given node create a new graph where every edge a b is replaced with an edge b a note we reverse the order of arguments pylint disable arguments out of order determine if the graph is strongly connected
from collections import defaultdict

class Graph:
    

    def __init__(self,vertex_count):
        

        self.vertex_count = vertex_count
        self.graph = defaultdict(list)

    def add_edge(self,source,target):
        
        self.graph[source].append(target)

    def dfs(self):
        
        visited = [False] * self.vertex_count
        self.dfs_util(0,visited)
        if visited == [True]*self.vertex_count:
            return True
        return False

    def dfs_util(self,source,visited):
        
        visited[source] = True
        for adjacent in self.graph[source]:
            if not visited[adjacent]:
                self.dfs_util(adjacent,visited)

    def reverse_graph(self):
        
        reverse_graph = Graph(self.vertex_count)
        for source, adjacent in self.graph.items():
            for target in adjacent:
                
                
                reverse_graph.add_edge(target,source)
        return reverse_graph


    def is_strongly_connected(self):
        
        if self.dfs():
            reversed_graph = self.reverse_graph()
            if reversed_graph.dfs():
                return True
        return False