from collections import defaultdict

​

def dfs(graph, vertex, visited, stack):

    visited[vertex] = True

    for neighbor in graph[vertex]:

        if not visited[neighbor]:

            dfs(graph, neighbor, visited, stack)

    stack.append(vertex)

​

def get_sink_components(graph):

    # Step 1: Reverse the edges of the graph to obtain GR

    reversed_graph = defaultdict(list)

    for vertex in graph:

        for neighbor in graph[vertex]:

            reversed_graph[neighbor].append(vertex)

​

    # Step 2: Run DFS on GR to determine finishing times

    visited = defaultdict(bool)

    stack = []

    for vertex in reversed_graph:

        if not visited[vertex]:

            dfs(reversed_graph, vertex, visited, stack)

​

    # Step 4: Sort vertices based on finishing times

    sorted_vertices = sorted(stack, reverse=True)

​

    # Step 5: Identify sink components in G

    sink_components = []

    visited = defaultdict(bool)

    for vertex in sorted_vertices:

        if not visited[vertex]:

            component = []

            dfs(graph, vertex, visited, component)

            sink_components.append(component)

​

    return sink_components

​

# Example usage:

# Define the graph as an adjacency list

graph = {

    1: [2],

    2: [3, 4],

    3: [],

    4: [5],

    5: [],

    6: [4, 7],

    7: [],

    8: [6, 9],

    9: []

}

​

sink_components = get_sink_components(graph)

print("Sink components of G:")

for component in sink_components:

    print(component)