What is the Union Find (DSU) pattern?

The Union Find (DSU) pattern is a systematic approach to solving a class of coding interview problems. By recognizing the Union Find (DSU) structure, you can solve problems in optimal time complexity using proven techniques.

When should I use the Union Find (DSU) pattern?

Use the Union Find (DSU) pattern when the problem structure matches its recognition signals — typically when brute force would be O(n²) or worse, and the pattern reduces complexity to O(α(n)) amortized per operation.

What is the time complexity of Union Find (DSU)?

The Union Find (DSU) pattern typically runs in O(α(n)) amortized per operation time and uses O(n) space. The exact complexity depends on the specific sub-variant being applied.

Is Union Find (DSU) important for coding interviews?

Yes — the Union Find (DSU) pattern is frequently tested at FAANG companies and competitive engineering interviews. Mastering this pattern gives you a reliable framework to solve many problem variations quickly.

How do I practice the Union Find (DSU) pattern?

Start by studying the pattern's mental model and recognition signals on DSAPatterns, then practice the curated LeetCode problems below in order from Easy to Hard. Aim for pattern recognition before memorizing solutions.

← back to patterns

pattern / HARD

Union Find (DSU).

Track connected components efficiently

complexity

time

O(α(n)) amortized per operation

space

O(n)

practice questions

browse and solve all 0 pattern questions →

02' — visual

interactive

Sliding window — k = 3

Maximum sum subarray

Window

[0, 2]

Sum

Step

0 / 3

03'

mental
model.

Each set has a parent. Find: walk up to root with path compression. Union: merge by rank.

Disjoint Set Union (DSU) tracks elements partitioned into disjoint sets. Supports union and find in nearly O(1) amortized time.

when to use ✓

01Number of connected components
02Detect cycle in undirected graph
03Redundant connection
04Accounts merge

when not ✗

01Directed graph problems
02Path queries (use other structures)

04'

recognition signals

Connected components

Cycle detection in undirected graph

Network connectivity

Kruskal's MST

Standard DSUDSU with size/rankWeighted DSU

05'

templates

python

1# Beginner: Fixed-size sliding window
2def max_sum_k(nums, k):
3   n = len(nums)
4   if n < k:
5      return 0
6   window_sum = sum(nums[:k])
7   max_sum = window_sum
8   for i in range(k, n):
9      window_sum += nums[i] - nums[i - k]
10      max_sum = max(max_sum, window_sum)
11   return max_sum

common mistakes

01Forgetting path compression
02Not using union by rank
03Confusing with graph BFS/DFS

interview tips

01Master path compression + union by rank
02Use for offline queries on connectivity

06'

practice this pattern

0 curated problems from LeetCode

See all

No questions found for this pattern yet.

07'

faq

1# Beginner: Fixed-size sliding window

2def max_sum_k(nums, k):

3 n = len(nums)

4 if n < k:

5 return 0

6 window_sum = sum(nums[:k])

7 max_sum = window_sum

8 for i in range(k, n):

9 window_sum += nums[i] - nums[i - k]

10 max_sum = max(max_sum, window_sum)

11 return max_sum