Disjoint Set Union (Union-Find) - Problem

Implement a Disjoint Set Union (DSU) data structure with union by rank and path compression optimizations. Use it to solve a dynamic connectivity problem.

Given a series of operations to connect nodes and check if two nodes are connected, efficiently determine the connectivity status after each query.

Your task is to implement:

union(x, y): Connect nodes x and y
find(x): Find the root parent of node x with path compression
connected(x, y): Check if nodes x and y are in the same component

Process a list of operations and return the results of all connectivity queries.

Input & Output

Example 1 — Basic Union and Connected Operations

$ Input: n = 4, operations = [["union",0,1], ["connected",0,1], ["connected",0,2]]

› Output: [true, false]

💡 Note: After union(0,1), nodes 0 and 1 are connected. Query connected(0,1) returns true. Query connected(0,2) returns false since 2 is not connected to 0.

Example 2 — Multiple Components

$ Input: n = 5, operations = [["union",0,1], ["union",2,3], ["connected",1,3], ["union",1,2], ["connected",0,3]]

› Output: [false, true]

💡 Note: Initially 0-1 and 2-3 are separate components. connected(1,3) is false. After union(1,2), all nodes 0,1,2,3 are connected, so connected(0,3) is true.

Example 3 — Self Connection

$ Input: n = 3, operations = [["connected",0,0], ["union",0,1], ["connected",1,1]]

› Output: [true, true]

💡 Note: Any node is always connected to itself. Both connected(0,0) and connected(1,1) return true.

Constraints

1 ≤ n ≤ 10⁴
1 ≤ operations.length ≤ 10⁴
operations[i] is either ["union", x, y] or ["connected", x, y]
0 ≤ x, y < n

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 38 a Amazon 35 M Microsoft 32

The Disjoint Set Union (Union-Find) efficiently manages dynamic connectivity with union by rank and path compression optimizations. Best approach uses both techniques for nearly O(1) operations. Time: O(N × α(N)), Space: O(N).

Common Approaches

✓ Basic Union-Find

⏱️ Time: O(N × α(N)) Space: O(N)

Implement basic union-find with parent tracking but no rank optimization or path compression. Each node initially points to itself.

Naive Graph Traversal

⏱️ Time: O(Q × (N + M)) Space: O(N + M)

Store connections as adjacency list and perform graph traversal for every connectivity check. No preprocessing or optimization.

Union-Find with Union by Rank and Path Compression

⏱️ Time: O(N × α(N)) Space: O(N)

Implement the complete optimized version with union by rank (attach smaller tree under larger) and path compression (flatten paths during find operations).

Basic Union-Find — Algorithm Steps

Initialize parent array where parent[i] = i
Find: traverse up parent chain to root
Union: set parent of one root to another
Connected: check if both have same root

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Each node is its own parent

Union

Set one root as parent of another

Find

Follow parent chain to root (can be long)

Code -

solution.c — C

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

#define MAX_N 1000
#define MAX_OPS 1000

int parent[MAX_N];

int find(int x) {
    while (parent[x] != x) {
        x = parent[x];
    }
    return x;
}

void unionSets(int x, int y) {
    int rootX = find(x);
    int rootY = find(y);
    if (rootX != rootY) {
        parent[rootX] = rootY;
    }
}

bool connected(int x, int y) {
    return find(x) == find(y);
}

int* solution(int n, char operations[][50], int opCount, int* returnSize) {
    // Initialize parent array
    for (int i = 0; i < n; i++) {
        parent[i] = i;
    }
    
    int* results = malloc(MAX_OPS * sizeof(int));
    *returnSize = 0;
    
    for (int i = 0; i < opCount; i++) {
        char opType[20];
        int x, y;
        sscanf(operations[i], "[\"%[^\"]\", %d, %d]", opType, &x, &y);
        
        if (strcmp(opType, "union") == 0) {
            unionSets(x, y);
        } else if (strcmp(opType, "connected") == 0) {
            results[(*returnSize)++] = connected(x, y) ? 1 : 0;
        }
    }
    
    return results;
}

int main() {
    int n;
    scanf("%d", &n);
    
    // Simplified input parsing
    printf("[]");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(N × α(N))

N operations, each find/union can take O(N) in worst case without optimizations

✓ Linear Growth

Space Complexity

O(N)

Parent array of size N to track component representatives

✓ Linear Space

78.0K Views

Medium-High Frequency

~35 min Avg. Time

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

Disjoint Set Union (Union-Find) - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Basic Union-Find — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler