Codestin Search App

Count Unreachable Pairs of Nodes in an Undirected Graph - Problem

Imagine you have n islands numbered from 0 to n-1, and some islands are connected by bridges. Your task is to find how many pairs of islands cannot reach each other through any path of bridges.

You're given:

n: The total number of islands (nodes)
edges: A 2D array where edges[i] = [a, b] means there's a bridge connecting islands a and b

Goal: Return the number of pairs of different islands that are unreachable from each other.

Example: If you have islands [0, 1, 2] where 0-1 are connected but 2 is isolated, then pairs (0,2) and (1,2) are unreachable from each other, so the answer is 2.

Input & Output

example_1.py — Basic Case

$ Input: n = 3, edges = [[0,1]]

› Output: 2

💡 Note: Nodes 0 and 1 are connected, but node 2 is isolated. The unreachable pairs are (0,2) and (1,2), so the answer is 2.

example_2.py — Multiple Components

$ Input: n = 7, edges = [[0,2],[0,5],[2,4],[1,6],[5,4]]

› Output: 14

💡 Note: Component 1: {0,2,4,5} (size 4), Component 2: {1,6} (size 2), Component 3: {3} (size 1). Unreachable pairs: 4×2 + 4×1 + 2×1 = 8 + 4 + 2 = 14.

example_3.py — All Connected

$ Input: n = 3, edges = [[0,1],[1,2]]

› Output: 0

💡 Note: All nodes are in one connected component, so every pair is reachable. No unreachable pairs exist.

Constraints

1 ≤ n ≤ 10⁵
0 ≤ edges.length ≤ 2 × 10⁵
edges[i].length == 2
0 ≤ a_i, b_i < n
a_i != b_i
No duplicate edges

Visualization

Tap to expand

6 pairs• Green Group (3 islands) ↔ Orange Group (1 island): 3 × 1 = 3 pairs• Red Group (2 islands) ↔ Orange Group (1 island): 2 × 1 = 2 pairs🎯 Total Unreachable Pairs: 6 + 3 + 2 = 11💡 Key Insight: Instead of checking all n² pairs, find components in O(V+E) time!

Understanding the Visualization

Map the Network

Build adjacency list from edges to represent ferry connections

Find Island Groups

Use DFS to discover all connected components (groups of reachable islands)

Count Group Sizes

Record the size of each connected component

Calculate Unreachable Pairs

Multiply sizes between different groups: if groups have sizes [a,b,c], unreachable pairs = a×b + a×c + b×c

Key Takeaway

🎯 Key Insight: Transform the problem from checking every pair O(n²) to finding connected components O(V+E) and using multiplication to count unreachable pairs between different components.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal approach uses DFS to find connected components in O(V+E) time. Instead of checking every pair, we calculate component sizes and use combinatorics: unreachable pairs = Σ(size[i] × size[j]) for all component pairs i,j. This reduces time complexity from O(n³) to O(V+E).

Common Approaches

Approach	Time	Space	Notes
✓ DFS Connected Components	O(V + E)	O(V + E)	Find all connected components using DFS, then calculate unreachable pairs mathematically

DFS Connected Components — Algorithm Steps

Build adjacency list representation of the graph
Use DFS to find all connected components and their sizes
For each unvisited node, start DFS to explore entire component
Calculate unreachable pairs: sum of (size[i] × size[j]) for all component pairs

Visualization

Tap to expand

Step-by-Step Walkthrough

DFS Traversal

Use DFS to find all connected components

Component Sizes

Record the size of each connected component

Calculate Pairs

Multiply component sizes to count unreachable pairs

Code -

solution.c — C

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

int dfs(int node, int** graph, int* graphSize, int* visited) {
    visited[node] = 1;
    int size = 1;
    for (int i = 0; i < graphSize[node]; i++) {
        int neighbor = graph[node][i];
        if (!visited[neighbor]) {
            size += dfs(neighbor, graph, graphSize, visited);
        }
    }
    return size;
}

long long countPairs(int n, int** edges, int edgesSize, int* edgesColSize) {
    // Build adjacency list
    int** graph = (int**)malloc(n * sizeof(int*));
    int* graphSize = (int*)calloc(n, sizeof(int));
    
    // Count edges for each node
    for (int i = 0; i < edgesSize; i++) {
        graphSize[edges[i][0]]++;
        graphSize[edges[i][1]]++;
    }
    
    // Allocate memory
    for (int i = 0; i < n; i++) {
        graph[i] = (int*)malloc(graphSize[i] * sizeof(int));
    }
    
    // Reset and build graph
    memset(graphSize, 0, n * sizeof(int));
    for (int i = 0; i < edgesSize; i++) {
        int a = edges[i][0], b = edges[i][1];
        graph[a][graphSize[a]++] = b;
        graph[b][graphSize[b]++] = a;
    }
    
    int* visited = (int*)calloc(n, sizeof(int));
    int* componentSizes = (int*)malloc(n * sizeof(int));
    int numComponents = 0;
    
    // Find connected components
    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            int componentSize = dfs(i, graph, graphSize, visited);
            componentSizes[numComponents++] = componentSize;
        }
    }
    
    // Calculate unreachable pairs
    long long totalPairs = 0;
    long long totalProcessed = 0;
    
    for (int i = 0; i < numComponents; i++) {
        totalPairs += (long long)componentSizes[i] * totalProcessed;
        totalProcessed += componentSizes[i];
    }
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(graph[i]);
    }
    free(graph);
    free(graphSize);
    free(visited);
    free(componentSizes);
    
    return totalPairs;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each vertex and edge exactly once during DFS traversal

✓ Linear Growth

Space Complexity

O(V + E)

Adjacency list storage + DFS recursion stack + visited array

✓ Linear Space

43.2K Views

Medium Frequency

~18 min Avg. Time

1.8K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

DFS Connected Components — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler