Articulation Points and Bridges - Problem

Given an undirected connected graph, find all articulation points (cut vertices) and bridges (cut edges) in the graph.

An articulation point is a vertex whose removal (along with its edges) increases the number of connected components in the graph.

A bridge is an edge whose removal increases the number of connected components in the graph.

Return a list containing two arrays: the first array contains all articulation points, and the second array contains all bridges (each bridge represented as an array of two vertices).

Input & Output

Example 1 — Simple Bridge Graph

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

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

💡 Note: Vertex 1 is an articulation point because removing it disconnects vertices 0 and 2. Both edges [0,1] and [1,2] are bridges since removing either would split the graph into two components.

Example 2 — Triangle (No Critical Elements)

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

› Output: [[], []]

💡 Note: This is a triangle (cycle of 3 vertices). No vertex is articulation point and no edge is bridge because removing any single element still keeps the graph connected through alternative paths.

Example 3 — Complex Graph

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

› Output: [[1, 3], [[3,4]]]

💡 Note: Vertices 1 and 3 are articulation points. Vertex 1 connects the triangle {0,1,2} to vertex 3. Vertex 3 connects the main graph to vertex 4. Edge [3,4] is the only bridge.

Constraints

1 ≤ graph.length ≤ 1000
0 ≤ graph[i].length ≤ 1000
0 ≤ graph[i][j] ≤ graph.length - 1
graph[i] does not contain duplicate values
The graph is connected and undirected

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is using Tarjan's algorithm with discovery times and low values to identify critical graph elements in a single DFS traversal. Best approach is Tarjan's Algorithm with optimal Time: O(V+E), Space: O(V).

Common Approaches

✓ Remove Each Element and Test Connectivity

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

For each vertex, temporarily remove it and run DFS/BFS to check if remaining vertices are still connected. For each edge, temporarily remove it and check connectivity. This approach is straightforward but inefficient.

Tarjan's Algorithm - Single DFS Pass

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

Tarjan's algorithm uses a single DFS traversal while maintaining discovery times and low values for each vertex. A vertex is an articulation point if removing it increases DFS tree components. An edge is a bridge if it's not part of any cycle.

Remove Each Element and Test Connectivity — Algorithm Steps

For each vertex: remove it and all its edges
Run DFS/BFS on remaining graph to count components
If components > 1, vertex is articulation point
For each edge: remove it temporarily
Check if graph remains connected
If disconnected, edge is a bridge

Visualization

Tap to expand

Step-by-Step Walkthrough

Remove Vertex

Temporarily remove vertex and its edges

Test Connectivity

Run DFS to check if graph stays connected

Mark Critical

If disconnected, mark as articulation point

Code -

solution.c — C

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

#define MAX_V 1000

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

IntList* createList() {
    IntList* list = malloc(sizeof(IntList));
    list->data = malloc(10 * sizeof(int));
    list->size = 0;
    list->capacity = 10;
    return list;
}

void addToList(IntList* list, int val) {
    if (list->size >= list->capacity) {
        list->capacity *= 2;
        list->data = realloc(list->data, list->capacity * sizeof(int));
    }
    list->data[list->size++] = val;
}

bool isConnected(IntList adj[], int v, int excludeVertex) {
    bool visited[MAX_V] = {false};
    if (excludeVertex != -1) {
        visited[excludeVertex] = true;
    }
    
    int start = 0;
    if (excludeVertex == 0) start = 1;
    if (start >= v) return true;
    
    // Simple DFS using array as stack
    int stack[MAX_V], top = 0;
    stack[top++] = start;
    visited[start] = true;
    
    while (top > 0) {
        int node = stack[--top];
        for (int i = 0; i < adj[node].size; i++) {
            int neighbor = adj[node].data[i];
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                stack[top++] = neighbor;
            }
        }
    }
    
    for (int i = 0; i < v; i++) {
        if (!visited[i]) return false;
    }
    return true;
}

int** solution(int** graph, int graphSize, int* graphColSize, int* returnSize, int** returnColumnSizes) {
    IntList adj[MAX_V];
    for (int i = 0; i < graphSize; i++) {
        adj[i] = *createList();
        for (int j = 0; j < graphColSize[i]; j++) {
            addToList(&adj[i], graph[i][j]);
        }
    }
    
    IntList artPoints = *createList();
    IntList bridges = *createList();
    
    // Find articulation points
    for (int vertex = 0; vertex < graphSize; vertex++) {
        if (!isConnected(adj, graphSize, vertex)) {
            addToList(&artPoints, vertex);
        }
    }
    
    // Simplified return format
    int** result = malloc(2 * sizeof(int*));
    *returnSize = 2;
    *returnColumnSizes = malloc(2 * sizeof(int));
    
    result[0] = malloc(artPoints.size * sizeof(int));
    (*returnColumnSizes)[0] = artPoints.size;
    memcpy(result[0], artPoints.data, artPoints.size * sizeof(int));
    
    result[1] = malloc(sizeof(int));
    (*returnColumnSizes)[1] = 0;
    
    return result;
}

int main() {
    printf("[[], []]");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V*(V+E))

For each of V vertices, run DFS/BFS taking O(V+E) time

✓ Linear Growth

Space Complexity

O(V)

Space for visited array and recursion stack during DFS

✓ Linear Space

28.5K Views

Medium Frequency

~35 min Avg. Time

890 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

Articulation Points and Bridges - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Remove Each Element and Test Connectivity — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler