Tarjan's Strongly Connected Components - Problem

Given a directed graph represented as an adjacency list, find all strongly connected components (SCCs) using Tarjan's algorithm.

A strongly connected component is a maximal set of vertices such that for every pair of vertices u and v, there is a directed path from u to v and a directed path from v to u.

Input: An adjacency list where graph[i] contains all vertices that vertex i points to.

Output: A list of strongly connected components, where each component is a list of vertices.

Input & Output

Example 1 — Cycle with Isolated Node

$ Input: graph = [[1], [2], [0], []]

› Output: [[0,1,2], [3]]

💡 Note: Vertices 0→1→2→0 form a cycle (strongly connected). Vertex 3 has no edges, so it's isolated.

Example 2 — Two Separate Cycles

$ Input: graph = [[1], [0], [3], [2]]

› Output: [[0,1], [2,3]]

💡 Note: Two separate cycles: 0↔1 and 2↔3. Each cycle forms its own strongly connected component.

Example 3 — Single Vertex

$ Input: graph = [[]]

› Output: [[0]]

💡 Note: Single vertex with no edges forms one SCC containing just itself.

Constraints

1 ≤ graph.length ≤ 1000
0 ≤ graph[i][j] < graph.length
graph[i] contains all vertices that vertex i points to

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 M Microsoft 15 a Amazon 12

The key insight is using Tarjan's algorithm with discovery times and a stack to identify strongly connected components in a single DFS pass. Best approach is Tarjan's algorithm with Time: O(V+E), Space: O(V).

Common Approaches

✓ Check All Pairs

⏱️ Time: O(V²(V+E)) Space: O(V)

For every pair of vertices (u,v), use DFS to check if u can reach v and v can reach u. Group vertices that are mutually reachable.

Tarjan's Algorithm

⏱️ Time: O(V+E) Space: O(V)

Use DFS with a stack to track vertices. Maintain discovery times and low-link values. When a vertex's low-link equals its discovery time, it's the root of an SCC - pop all vertices from stack until reaching this root.

Check All Pairs — Algorithm Steps

Step 1: For each vertex pair (u,v), run DFS from u to check if v is reachable
Step 2: Run DFS from v to check if u is reachable
Step 3: If both directions work, they're in the same SCC
Step 4: Group all mutually reachable vertices

Visualization

Tap to expand

Step-by-Step Walkthrough

Pick Vertex Pair

Select vertices u and v to test

Check u → v

Run DFS from u to see if v is reachable

Check v → u

Run DFS from v to see if u is reachable

Group If Mutual

If both directions work, they're in same SCC

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define MAX_VERTICES 100

typedef struct {
    int adj[MAX_VERTICES][MAX_VERTICES];
    int adjCount[MAX_VERTICES];
    int n;
} Graph;

bool dfsCanReach(int start, int target, Graph* graph) {
    if (start == target) return true;
    
    bool visited[MAX_VERTICES] = {false};
    int stack[MAX_VERTICES];
    int top = 0;
    
    stack[top++] = start;
    visited[start] = true;
    
    while (top > 0) {
        int curr = stack[--top];
        for (int i = 0; i < graph->adjCount[curr]; i++) {
            int neighbor = graph->adj[curr][i];
            if (neighbor == target) return true;
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                stack[top++] = neighbor;
            }
        }
    }
    return false;
}

int solution(Graph* graph, int result[][MAX_VERTICES]) {
    int n = graph->n;
    bool visitedGlobal[MAX_VERTICES] = {false};
    int sccCount = 0;
    
    for (int i = 0; i < n; i++) {
        if (visitedGlobal[i]) continue;
        
        int currentScc[MAX_VERTICES];
        int sccSize = 0;
        
        for (int j = 0; j < n; j++) {
            if (!visitedGlobal[j]) {
                if (dfsCanReach(i, j, graph) && dfsCanReach(j, i, graph)) {
                    currentScc[sccSize++] = j;
                    visitedGlobal[j] = true;
                }
            }
        }
        
        if (sccSize > 0) {
            for (int k = 0; k < sccSize; k++) {
                result[sccCount][k] = currentScc[k];
            }
            result[sccCount][sccSize] = -1; // End marker
            sccCount++;
        }
    }
    
    return sccCount;
}

int main() {
    Graph graph;
    // Parse input - simplified for demo
    graph.n = 4;
    
    int result[MAX_VERTICES][MAX_VERTICES];
    int sccCount = solution(&graph, result);
    
    // Print result
    printf("[");
    for (int i = 0; i < sccCount; i++) {
        if (i > 0) printf(",");
        printf("[");
        int j = 0;
        while (result[i][j] != -1) {
            if (j > 0) printf(",");
            printf("%d", result[i][j]);
            j++;
        }
        printf("]");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V²(V+E))

For each of V² pairs, we run DFS which takes O(V+E) time

✓ Linear Growth

Space Complexity

O(V)

DFS recursion stack and visited array

✓ Linear Space

23.4K Views

Medium Frequency

~35 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Tarjan's Strongly Connected Components - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Check All Pairs — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler