Sqrt Decomposition
You've learned tree structures. Sqrt decomposition divides arrays into blocks for O(√n) queries.
Lessons
1. Intro
Why √n matters
2. The Core Idea
Dividing into blocks
3. Vocabulary - Block Size
Choosing B
4. Quiz: Block Index
Which block contains i?
5. Building Block Sums
Preprocessing
6. Range Sum Query
Combining blocks
7. Range Sum - Implementation
The code
8. Point Updates
Updating one element
9. Point Update - Implementation
The code
10. Problem - Range Sum Queries I
Basic sqrt decomposition
11. Range Sum I - Analysis
Complexity comparison
12. Range Sum I - Implementation
Complete solution
13. Lessons from Range Sum
summary
14. Range Minimum Query
Min instead of sum
15. Range Min - Update Challenge
Rebuilding blocks
16. Quiz: Update Complexity
Sum vs min updates
17. When to Use Sqrt Decomposition
Tradeoffs
18. MO's Algorithm - Introduction
Offline query magic
19. MO's Sorting Order
The magic ordering
20. MO's Algorithm - Framework
The template
21. Problem - Distinct Values
Count unique elements
22. Distinct Values - Add/Remove
Tracking counts
23. Distinct Values - Implementation
Complete solution
24. Lessons from Distinct Values
summary
25. MO's with Expensive Operations
When add/remove costs more
26. Problem - Mode Query
Most frequent element
27. Mode Query - Data Structures
Tracking frequencies
28. Mode Query - Implementation
The code
29. Lessons from Mode Query
summary
30. MO's Optimization - Zigzag Order
Reducing constant factor
31. Quiz: MO's Complexity
Understanding the analysis
32. Block Decomposition for Updates
Range updates too
33. Lazy Block Updates
Implementation details
34. Problem - Polynomial Queries
Harder range updates
35. Polynomial Queries - Analysis
Arithmetic progression sums
36. Polynomial Queries - Pushdown
When tails need updates
37. Lessons from Polynomial Queries
summary
38. MO's with Updates
Time as third dimension
39. MO's with Updates - Analysis
Why n^(5/3)?
40. Comparing Sqrt to Other Structures
When to choose what
41. Challenge: Design Your Solution
Practice choosing techniques
42. Section Recap
What you've learned
Practice Problems
The quintessential Mo's algorithm problem. Teaches fundamental add/remove operations and proper block size selection to avoid TLE.
Brilliant combination of prefix XOR with Mo's algorithm. Demonstrates how to transform range queries into Mo's algorithm format.
Classic Mo's algorithm counting elements x that occur exactly x times. Great for beginners learning Mo's algorithm basics.
Mo's algorithm on trees using Euler tour transformation. Teaches how to flatten trees into arrays for Mo's algorithm.
Pure sqrt decomposition without Mo's algorithm. Excellent for understanding block-based updates and jump operations.
Advanced sqrt decomposition with cyclic shifts. Demonstrates lazy propagation concepts and block maintenance with deques.
Sqrt optimization on trees with BFS preprocessing every √m queries. Teaches query batching techniques for maintaining O(q√n) complexity.
Introduces heavy-light decomposition for sets. Splits sets into 'heavy' and 'light' demonstrating threshold-based sqrt decomposition.
Sqrt decomposition with lazy propagation for Fibonacci updates. Combines mathematical properties with block-based updates.
Range update and range query with sqrt decomposition. Teaches lazy propagation on blocks tracking colorfulness changes.
Graph-based sqrt decomposition splitting nodes by degree. Demonstrates applying sqrt decomposition beyond arrays.
Sqrt decomposition for connectivity queries across colored edges. Teaches handling multiple dimensions with sqrt techniques.
Foundational sqrt decomposition problem. Perfect introduction teaching how to split arrays into √n blocks with precomputed sums.
Solvable with sqrt decomposition maintaining block-level majority candidates. Demonstrates advanced aggregation beyond simple sums.
Sqrt decomposition for 2D range queries. Shows how to extend 1D block decomposition to 2D problems efficiently.
Range flip operations with sqrt decomposition and lazy updates. Teaches handling bit flips in blocks with pending XOR operations.
Interval system solvable with sqrt decomposition. Shows maintaining interval coverage using blocks instead of trees.
Dynamic interval merging with sqrt decomposition. Demonstrates maintaining distinct counts across overlapping intervals.
Coordinate compression with sqrt decomposition for interval maximum queries. Handles large coordinate spaces with manageable blocks.
Interval painting with overlap detection. Combines range updates with jump pointers demonstrating path compression in blocks.