Critical Connections in a Network - Practice Coding Problems

Critical Connections in a Network - Problem

Imagine you're a network administrator managing a critical server infrastructure where n servers (numbered 0 to n-1) are connected by bidirectional links. Your network is represented by connections[i] = [a_i, b_i], meaning servers a_i and b_i can communicate directly.

Currently, every server can reach every other server either directly or through intermediate servers. However, some connections are more critical than others!

A critical connection (bridge) is a link that, if removed, would split the network into disconnected parts, making some servers unreachable from others.

Your mission: Find all critical connections that keep the network fully connected. Without these bridges, your network would fragment!

Example: If servers 0-1-2 form a line, then both connections [0,1] and [1,2] are critical because removing either would disconnect the network.

Input & Output

example_1.py — Python

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

› Output: [[0,1]]

💡 Note: The network forms a cycle between nodes 1,2,3 with node 0 connected only through node 1. Removing edge [0,1] would isolate node 0 from the rest of the network, making it the only critical connection.

example_2.py — Python

$ Input: n = 2, connections = [[0,1]]

› Output: [[0,1]]

💡 Note: With only two nodes and one connection, removing the single edge [0,1] would completely disconnect the network. Therefore, it's a critical connection.

example_3.py — Python

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

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

💡 Note: This forms a linear chain: 0-1-2. Both edges are critical because removing either [0,1] or [1,2] would split the network into disconnected components.

Visualization

Tap to expand

Understanding the Visualization

Start Journey

Begin DFS traversal from any starting point, recording when we first discover each location

Track Reachability

For each location, track the earliest discoverable location we can reach through any path

Identify Bottlenecks

A bridge is critical if it's the only way to reach newer territory - no alternative routes exist

Mark Critical Routes

Edges where low[neighbor] > discovery[current] are bottlenecks that would isolate parts of the network

Key Takeaway

🎯 Key Insight: Tarjan's algorithm elegantly identifies bridges by detecting when there's no "back door" route around an edge - if low[neighbor] > discovery[current], that edge is the sole connection between network components.

Time & Space Complexity

Time Complexity

⏱️

O(E × (V + E))

For each of E edges, we perform a DFS/BFS taking O(V + E) time

✓ Linear Growth

Space Complexity

O(V + E)

Space for adjacency list representation and recursion stack

✓ Linear Space

Constraints

2 ≤ n ≤ 10⁵
n - 1 ≤ connections.length ≤ 10⁵
0 ≤ a_i, b_i ≤ n - 1
a_i ≠ b_i
There are no repeated connections
The given graph is connected

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses Tarjan's Bridge-Finding Algorithm which efficiently identifies all critical connections in O(V + E) time using a single DFS traversal. The key insight is tracking discovery times and low values to detect bridges without expensive connectivity checks.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Remove Each Edge)	O(E × (V + E))	O(V + E)	Remove each connection and check if graph remains connected
Tarjan's Bridge Algorithm (Optimal)	O(V + E)	O(V + E)	Use DFS with discovery times and low values to find bridges in one pass

Brute Force (Remove Each Edge) — Algorithm Steps

Iterate through each edge in the connections list
Temporarily remove the current edge from the graph
Perform DFS/BFS from any node to check connectivity
If not all nodes are visited, the removed edge is critical
Add critical edges to result and restore the edge
Continue with next edge

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Edge

Choose an edge to temporarily remove from the graph

Remove Edge

Create a new graph without the selected edge

Test Connectivity

Run DFS from any node to see if all nodes are reachable

Check Result

If any nodes are unreachable, the removed edge is critical

Code -

solution.c — C

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

typedef struct {
    int* data;
    int size;
    int capacity;
} IntArray;

IntArray* createArray() {
    IntArray* arr = malloc(sizeof(IntArray));
    arr->data = malloc(10 * sizeof(int));
    arr->size = 0;
    arr->capacity = 10;
    return arr;
}

void addToArray(IntArray* arr, int val) {
    if (arr->size >= arr->capacity) {
        arr->capacity *= 2;
        arr->data = realloc(arr->data, arr->capacity * sizeof(int));
    }
    arr->data[arr->size++] = val;
}

void dfs(int node, IntArray** graph, bool* visited) {
    visited[node] = true;
    for (int i = 0; i < graph[node]->size; i++) {
        int neighbor = graph[node]->data[i];
        if (!visited[neighbor]) {
            dfs(neighbor, graph, visited);
        }
    }
}

bool isConnected(int n, IntArray** graph) {
    bool* visited = calloc(n, sizeof(bool));
    dfs(0, graph, visited);
    
    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            free(visited);
            return false;
        }
    }
    free(visited);
    return true;
}

int** criticalConnections(int n, int** connections, int connectionsSize, int* returnSize) {
    int** result = malloc(connectionsSize * sizeof(int*));
    *returnSize = 0;
    
    for (int exclude = 0; exclude < connectionsSize; exclude++) {
        IntArray** graph = malloc(n * sizeof(IntArray*));
        for (int i = 0; i < n; i++) {
            graph[i] = createArray();
        }
        
        for (int i = 0; i < connectionsSize; i++) {
            if (i != exclude) {
                int u = connections[i][0], v = connections[i][1];
                addToArray(graph[u], v);
                addToArray(graph[v], u);
            }
        }
        
        if (!isConnected(n, graph)) {
            result[*returnSize] = malloc(2 * sizeof(int));
            result[*returnSize][0] = connections[exclude][0];
            result[*returnSize][1] = connections[exclude][1];
            (*returnSize)++;
        }
        
        for (int i = 0; i < n; i++) {
            free(graph[i]->data);
            free(graph[i]);
        }
        free(graph);
    }
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(E × (V + E))

For each of E edges, we perform a DFS/BFS taking O(V + E) time

✓ Linear Growth

Space Complexity

O(V + E)

Space for adjacency list representation and recursion stack

✓ Linear Space

Constraints

2 ≤ n ≤ 10⁵
n - 1 ≤ connections.length ≤ 10⁵
0 ≤ a_i, b_i ≤ n - 1
a_i ≠ b_i
There are no repeated connections
The given graph is connected

89.5K Views

High Frequency

~35 min Avg. Time

2.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Remove Each Edge) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler