Rare
0/27

# Square Root Decomposition

Authors: Benjamin Qi, Neo Wang

Splitting up data into smaller chunks to speed up processing.

Focus Problem – try your best to solve 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 $\mathcal{O}(Q\sqrt N)$ time.

Resources
CPH
CF

Blocking, Mo's Algo

## Blocking

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

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

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

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

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

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

$\sum_{i = 0}^{R-1} \texttt{blocks}[i] + \sum_{R \cdot \texttt{block\_size}}^r \texttt{nums}[i]$

where $\texttt{blocks}[i]$ represents the total sum of the $i$-th block, the $i$-th block represents the sum of the elements from the range $[i\cdot \texttt{block\_size},(i + 1)\cdot \texttt{block\_size})$, and $R=\left\lceil \frac{r}{\texttt{block\_size}} \right\rceil$.

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

C++

#include <bits/stdc++.h>using namespace std;
struct Sqrt {	int block_size;	vector<int> nums;	vector<long long> blocks;	Sqrt(int sqrtn, vector<int> &arr) : block_size(sqrtn), blocks(sqrtn, 0) {		nums = arr;		for (int i = 0; i < nums.size(); i++) {

Java

import java.io.*;import java.util.*;
public class DRSQ {	public static void main(String[] args) throws IOException {		BufferedReader br =		    new BufferedReader(new InputStreamReader(System.in));		PrintWriter pw = new PrintWriter(System.out);		StringTokenizer st = new StringTokenizer(br.readLine());


## Batching

See the CPH section on batch processing.

Maintain a "buffer" of the latest updates (up to $\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 ($\ge \sqrt N$), clear it and recalculate prefix sums.

C++

#include <bits/stdc++.h>using namespace std;
int n, q;vector<int> arr;vector<long long> prefix;
/** Build the prefix array for arr */void build() {	prefix = 0;

Java

### Warning: TLE

Due to tight time constraint on CSES, the Java implementation might get TLE.

import java.io.*;import java.util.*;
public class DRSQ {	static int[] arr;	static List<Long> prefix;
public static void main(String[] args) throws IOException {		BufferedReader br =		    new BufferedReader(new InputStreamReader(System.in));

## Mo's Algorithm

Focus Problem – try your best to solve this problem before continuing!

Resources
CF

very brief description

HE

elaborate description with proof

CPH

C++

#include <bits/stdc++.h>using namespace std;
struct Query {	int l, r, idx;};
int main() {	int n;	cin >> n;

• Low constraints (ex. $n=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 $\sqrt n$ as a parameter, and instead we may use parameters $k$ and $n/k$ where $k$ is different from $\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<\sqrt n$ blocks, each of which contains $n/k > \sqrt n$ elements.

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

• Solutions with worse complexities are not necessarily slower (at least for problems with reasonable input sizes, ex. $n\le 5\cdot 10^5$). I recall an instance where a fast $\mathcal{O}(n\sqrt n\log n)$ solution passed (where $\log n$ came from a BIT) while an $\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
DMOPCVery Hard
Show TagsSqrt
Wesley's Anger ContestVery 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
PlatNormal
Show TagsSqrt
PlatHard
Show TagsSqrt
CFHard
Show TagsSqrt
CFHard
Show TagsHLD
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

### 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!