Advanced Data Structures — Segment Trees, Fenwick Trees, Disjoint Sets

🎯 Learning Objectives

• Build and query segment trees in O(log n)
• Implement Fenwick tree for prefix sums
• Apply DSU with union by rank and path compression
• Solve range query problems with these structures

1. Segment Tree

1.1 Structure

1.2 Query: Range Sum [1, 4]

1. Start at root [0-5]
2. [0-5] partially overlaps → go to children
3. [0-2] partially overlaps → go to children
4. [0-1] partially → return right child [1] = 3
5. [2] = 7 (fully covered)
6. [3-5] partially → go to child [3-4] = 10 (fully covered)
7. Result: 3 + 7 + 10 = 20

1.3 Time Complexity

2. Fenwick Tree (Binary Indexed Tree)

2.1 Key Idea

2.2 Query: Prefix Sum [1, 5]

1. i=5: tree[5]=1, i=5-1=4
2. i=4: tree[4]=24, i=4-4=0
3. Result: 1 + 24 = 25 Update: Add v at position i: while i ≤ n: tree[i] += v; i += LSB(i)

3. Disjoint Set Union (DSU)

3.1 Path Compression + Union by Rank

python
Run Inline
class DSU:
    def __init__(self, n):
        self.parent = list(range(n))
        self.rank = [0] * n
    def find(self, x):  # Path compression
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])
        return self.parent[x]
    def union(self, x, y):  # Union by rank
        px, py = self.find(x), self.find(y)
        if px == py: return False
        if self.rank[px] < self.rank[py]:
            px, py = py, px
        self.parent[py] = px
        if self.rank[px] == self.rank[py]:
            self.rank[px] += 1
        return True

3.2 Tracing

• Initially: parent = [0,1,2,3], rank = [0,0,0,0]
• Union(1,2): find(1)=1, find(2)=2, rank same, parent[2]=1, rank[1]=1
• Union(2,3): find(2)→1, find(3)=3, rank[1]=1 > rank[3]=0, parent[3]=1 Complexity: O(α(n)) per operation (inverse Ackermann — practically constant)

4. Common Pitfalls

Pitfall: Fenwick Tree for Min/Max

5. Key Concepts Reference

6. 📝 Practice Questions

Q1: Build a segment tree for [2, 4, 1, 5, 3] for range sum.

Answer: Root (0-4): 15 Left (0-2): 7, Right (3-4): 8 (0-1): 6, (2): 1, (3): 5, (4): 3 (0): 2, (1): 4 Query [1, 3]: right child of (0-1)=4 + (2)=1 + (3)=5 = 10 Q2: Fenwick tree: prefix sum up to 6 for tree = [3, 7, 2, 12, 5, 9].

Answer: tree indices: 1=3, 2=7, 3=2, 4=12, 5=5, 6=9. prefix(6)=tree[6]+tree[4]=9+12=21. Verify: array = [3, 4, 2, 3, 5, 4]? Wait, Fenwick stores differently. tree[2]=7 means arr[1]+arr[2]=7. Let me verify: if tree = [3,7,2,12,5,9], then prefix(6)=tree[6]+tree[4]=9+12=21. prefix(5)=tree[5]+tree[4]=5+12=17. Q3: DSU: find operation with path compression. Explain the effect.

Answer: After find(x), every node on the path from x to the root has its parent set directly to the root. Future finds for these nodes are O(1). Without path compression, find could be O(n) for a chain. Combined with union by rank, the amortized time is O(α(n)) — practically constant even for n = 10^600.

7. 🔗 Cross-References

• Week 1 - Greedy: Scheduling with DSU
• Week 5 - Flow Applications: Min-cut via segment tree
• BSCS4020 (DSA): Basic data structures Join Discord PreviousRandomized AlgorithmsNextExact Algorithms