PrevNext
Rare
 0/24

Square Root Decomposition

Authors: Benjamin Qi, Neo Wang

Splitting up data into smaller chunks to speed up processing.

Edit This Page

Focus Problem – read through this problem before continuing!

You should already have done this problem in Point Update Range Sum, but here we'll present two more approaches. Both run in O(QN)\mathcal{O}(Q\sqrt N) time.

Blocking

We partition the array into blocks of size blocksz=N\texttt{blocksz}=\lfloor \sqrt{N} \rfloor. Each block stores the sum of elements within it, and allows for the creation of corresponding update and query operations.

Update Queries: O(1)\mathcal{O}(1)

To update an element at location xx, first find the corresponding block using the formula xblocksz\frac{x}{\texttt{blocksz}}.

Then, apply the corresponding difference between the element currently stored at xx and the element we want to change it to.

Sum Queries: O(N)\mathcal{O}(\sqrt{N})

To perform a sum query from [0r][0\ldots r], calculate

i=0R1blocks[i]+Rblockszrnums[i]\sum_{i = 0}^{R-1} \texttt{blocks}[i] + \sum_{R \cdot \texttt{blocksz}}^r \texttt{nums}[i]

where blocks[i]\texttt{blocks}[i] represents the total sum of the ii-th block, the ii-th block represents the sum of the elements from the range [iblocksz,(i+1)blocksz)[i\cdot \texttt{blocksz},(i + 1)\cdot \texttt{blocksz}), and R=rblockszR=\left\lfloor \frac{r}{\texttt{blocksz}} \right\rfloor.

Finally, i=lrnums[i]\sum_{i=l}^{r} \texttt{nums}[i] is the difference between the two sums i=0rnums[i]\sum_{i=0}^{r}\texttt{nums}[i] and i=0l1nums[i]\sum_{i=0}^{l-1}\texttt{nums}[i], which each are calculated in O(N)\mathcal{O}(\sqrt N).

C++

Code Snippet: C++ Short Template (Click to expand)
ll blocks[450]; // 450^2 > 2e5
int nums[(int)(2e5 + 1)];
int block_sz;
void upd(int x, int v) { // O(1) update
blocks[x / block_sz] -= nums[x];
nums[x] = v;
blocks[x / block_sz] += nums[x];

Batching

See the CPH section on batch processing.

Maintain a "buffer" of the latest updates (up to N\sqrt N). The answer for each sum query can be calculated with prefix sums and by examining each update within the buffer. When the buffer gets too large (N\ge \sqrt N), clear it and recalculate prefix sums.

C++

Code Snippet: C++ Short Template (Click to expand)
int n, q;
vi x;
vector<long long> cum;
void build() {
cum = {0};
for(const auto &t : x) cum.pb(cum.back() + t);
}

Mo's Algorithm

Resources
CF

very brief description

CPH

Additional Notes

  • Low constraints (ex. n=5104n=5\cdot 10^4) and/or high time limits (greater than 2s) can be signs that square root decomposition is intended.

  • In practice, it is not necessary to use the exact value of n\sqrt n as a parameter, and instead we may use parameters kk and n/kn/k where kk is different from n\sqrt n. The optimal parameter depends on the problem and input. For example, if an algorithm often goes through the blocks but rarely inspects single elements inside the blocks, it may be a good idea to divide the array into k<nk<\sqrt n blocks, each of which contains n/k>nn/k > \sqrt n elements.

  • If an update takes time proportional to the size of one block (O(n/k)\mathcal{O}(n/k)) while a query takes time proportional to the number of blocks times logn\log n (O(klogn)\mathcal{O}(k\log n)) then we can set knlognk\approx \sqrt{\frac{n}{\log n}} to make both updates and queries take time O(nlogn)\mathcal{O}(\sqrt{n\log n}).

  • Solutions with worse complexities are not necessarily slower (at least for problems with reasonable input sizes, ex. n5105n\le 5\cdot 10^5). I recall an instance where a fast O(nnlogn)\mathcal{O}(n\sqrt n\log n) solution passed (where logn\log n came from a BIT) while an O(nn)\mathcal{O}(n\sqrt n) solution did not. Constant factors are important!

On Trees

The techniques mentioned in the blogs below are extremely rare but worth a mention.

Some more discussion about how square root decomposition can be used:

Resources
CF

format isn't great but tree example is ok

Problems

Set A

Problems where the best solution involves square root decomposition.

StatusSourceProblem NameDifficultyTags
CFEasy
Show TagsSqrt
JOIEasy
Show TagsSqrt
POIEasy
Show TagsSqrt
CFEasy
Show TagsSqrt
CFEasy
Show TagsSqrt
YSNormal
Show TagsSqrt
CFNormal
Show TagsMo's Algorithm
APIOHard
Show TagsSqrt
JOIHard
Show TagsSOS DP
PlatVery Hard
Show TagsSqrt
DMOJVery Hard
Show TagsSqrt
DMOJVery Hard
Show TagsSqrt

Set B

Problems that can be solved without it. But you might as well try to use it!

StatusSourceProblem NameDifficultyTags
JOINormal
Show Tags2DRQ, Mo's Algorithm
IOINormal
Show TagsSqrt
PlatHard
Show TagsSqrt
CFHard
Show TagsSqrt
TLXHard
Show TagsSqrt
CSAHard
Show TagsSqrt
Old GoldHard
Show TagsConvex
CFVery Hard
Show TagsConvex
IOIVery Hard
Show TagsSqrt
PlatVery Hard
Show TagsSqrt
IOIVery Hard
Show Tags2DRQ

Module Progress:

Join the USACO Forum!

Stuck on a problem, or don't understand a module? Join the USACO Forum and get help from other competitive programmers!

PrevNext