diff --git a/src/SUMMARY.md b/src/SUMMARY.md
index de0278ee..69535234 100644
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@@ -11,6 +11,10 @@
- [Dynamic Programming]()
- [Basic DP]()
- [Flow]()
+- [Sqrt Technique](sqrt/intro.md)
+ - [Square Root Decomposition](sqrt/sqrt_decomposition.md)
+ - [Sqrt-Related Observation]()
+ - [Mo's Algorithm]()
- [Mathematics](math/intro.md)
- [Arithmetic Function](math/arithmetic_function.md)
- [Miscellaneous]()
diff --git a/src/sqrt/image/sqrt_decomposition/array.png b/src/sqrt/image/sqrt_decomposition/array.png
new file mode 100644
index 00000000..840a3273
Binary files /dev/null and b/src/sqrt/image/sqrt_decomposition/array.png differ
diff --git a/src/sqrt/image/sqrt_decomposition/l_r_not_same.png b/src/sqrt/image/sqrt_decomposition/l_r_not_same.png
new file mode 100644
index 00000000..1914de89
Binary files /dev/null and b/src/sqrt/image/sqrt_decomposition/l_r_not_same.png differ
diff --git a/src/sqrt/image/sqrt_decomposition/l_r_same.png b/src/sqrt/image/sqrt_decomposition/l_r_same.png
new file mode 100644
index 00000000..18ac3eef
Binary files /dev/null and b/src/sqrt/image/sqrt_decomposition/l_r_same.png differ
diff --git a/src/sqrt/image/sqrt_decomposition/move_element.png b/src/sqrt/image/sqrt_decomposition/move_element.png
new file mode 100644
index 00000000..d8b96f0f
Binary files /dev/null and b/src/sqrt/image/sqrt_decomposition/move_element.png differ
diff --git a/src/sqrt/image/sqrt_decomposition/move_element_2.png b/src/sqrt/image/sqrt_decomposition/move_element_2.png
new file mode 100644
index 00000000..6b979daa
Binary files /dev/null and b/src/sqrt/image/sqrt_decomposition/move_element_2.png differ
diff --git a/src/sqrt/image/sqrt_decomposition/why_sqrt.png b/src/sqrt/image/sqrt_decomposition/why_sqrt.png
new file mode 100644
index 00000000..81380dcb
Binary files /dev/null and b/src/sqrt/image/sqrt_decomposition/why_sqrt.png differ
diff --git a/src/sqrt/intro.md b/src/sqrt/intro.md
new file mode 100644
index 00000000..12ed6e11
--- /dev/null
+++ b/src/sqrt/intro.md
@@ -0,0 +1,4 @@
+# Sqrt Technique
+
+此章節將收錄時間複雜度與根號有關的技巧例如 Square Root Decomposition 、Mo's Algorithm，中文常稱之為分塊、莫隊算法，以及一些能應用於題目中與根號相關的觀察。
+
diff --git a/src/sqrt/sqrt_decomposition.md b/src/sqrt/sqrt_decomposition.md
new file mode 100644
index 00000000..6b5c6dbb
--- /dev/null
+++ b/src/sqrt/sqrt_decomposition.md
@@ -0,0 +1,650 @@
+# Square Root Decomposition
+
+## Introduction
+此技巧中文常稱之為分塊，概念並不困難，就像是比較優美的暴力。
+
+考慮以下問題：
+
+> [CSES - Dynamic Range Sum Queries](https://cses.fi/problemset/task/1648)
+>
+> 給定一個長度為 \\( N \\) 的序列 \\( a \\)，並對其進行 \\( Q \\) 筆操作。操作有兩種：
+> 1. 給定 \\( k, u \\)，將 \\( a_k \\) 修改成 \\( u \\)。
+> 2. 給定 \\( l, r \\)，請輸出 \\( a_l + a_{l + 1} + ... + a_r \\)，也就是 \\( l \\) 到 \\( r \\) 的區間和。
+> - \\( N, Q \leq 2 \times 10^5 \\)
+
+
+此問題可以使用一些資料結構例如線段樹來得到 \\( O(N + Q\log N) \\) 的解法。但這裡要介紹的是如何使用分塊來解這題。
+
+### 序列分塊
+
+對於一個長度為 \\( N \\) 的陣列，我們先將其每 \\( K \\) 個元素分在同一塊，同時維護每一塊的總和是多少。如下圖，設 \\( K = 4 \\)：
+
+
+
+我們先考慮第二種詢問區間和的操作。若 \\( l, r \\) 在同一塊內，如下圖，我們就直接用最暴力的方式遍歷過 \\( l \\) 到 \\( r \\) 之間的元素。最壞的情況下不可能走超過 \\( K \\) 個元素，否則他們就不應該在同一塊，因此此部分的時間複雜度為 \\( O(K) \\)。
+
+
+
+若 \\( l, r \\) 不在同一塊內的話，如下圖，對於 \\(l, r \\) 所在的塊，我們一樣使用暴力的方式取得數值總和，也就是綠色部分。此步同上，時間複雜度為 \\( O(K) \\)。
+
+對於 \\( l, r \\) 中間橫跨過的塊，也就是藍色的部分，因為我們有預先計算每一塊的總和分別是多少，因此我們可以遍歷過去中間的每一「塊」，注意到不是遍歷過中間的每一個元素，來取得最終的區間總和。最壞的情況下，中間至多有 \\( \frac{N}{K} \\) 塊，所以此步驟為 \\( O(\frac{N}{K}) \\)。
+
+
+
+接著回來看一下第一種操作，也就是單點修改，可以發現我們只需要去修改 \\( a_k \\) 的值，以及 \\( a_k \\) 所在的塊的總和即可，此步可以在 \\( O(1) \\) 辦到。
+
+總結一下此做法，首先預處理原本的陣列維護每一塊的總和是多少，可以在 \\( O(n) \\) 內辦到。對於每一筆操作，時間複雜度為 \\( O(1) + O(K) + O(\frac{N}{K}) \\)。於是此做法的總時間複雜度為 \\( O(N + Q(K + \frac{N}{K})) \\)。
+
+我們最後要討論的問題是，每幾個元素要被分在同一塊？也就是 \\( K \\) 的值該選什麼能讓我們的時間複雜度最好。我們要最小化 \\( K + \frac{N}{K} \\)，一個簡單但不嚴謹的推論是左邊那一項就越大，右邊那一項就越小，反之亦同，因此左右相等時會有最佳的時間複雜度，因此 \\( K \\) 我們取 \\( \sqrt{N} \\) 會讓時間複雜度最好。這個結果其實也可以從國中教的算幾不等式求出。
+
+因此此做法的時間複雜度為：\\( O(N + Q\sqrt{N}) \\)。
+
+ Solution Code
+
+- 以下將 \\( K \\) 的值直接設定成固定值，大約是題目中的 \\( N \\) 的最大值開根號。
+- `block_size` 代表一塊有幾個元素。
+- `block_num` 帶表總共分成幾塊。
+- `block_sum[i]` 就是第 \\( i \\) 塊的總和。
+- `block_map[i]` 代表 \\( a_i \\) 屬於哪一塊。
+- 另一種實作查詢答案的想法是查 `[1, r]` 的區間和減掉 `[1, l - 1]`。
+
+```cpp
+#include
+using namespace std;
+
+int main() {
+ cin.tie(0);
+ ios_base::sync_with_stdio(0);
+
+ int n, q;
+ cin >> n >> q;
+
+ const int block_size = 450;
+ const int block_num = 450;
+ vector a(n + 1), block_map(n + 1);
+ vector block_sum(block_num);
+
+ for (int i = 1; i <= n; i++) {
+ cin >> a[i];
+ block_map[i] = i / block_size;
+ block_sum[block_map[i]] += a[i];
+ }
+
+ while (q--) {
+ int t;
+ cin >> t;
+ if (t == 1) {
+ int k, u;
+ cin >> k >> u;
+ block_sum[block_map[k]] += u - a[k];
+ a[k] = u;
+ } else {
+ int l, r;
+ cin >> l >> r;
+ int L = block_map[l], R = block_map[r];
+ long long ans = 0;
+ if (L == R) {
+ for (int i = l; i <= r; i++) {
+ ans += a[i];
+ }
+ } else {
+ for (int i = L + 1; i <= R - 1; i++) {
+ ans += block_sum[i];
+ }
+ int it = l;
+ while (block_map[it] == block_map[l]) {
+ ans += a[it];
+ it++;
+ }
+ it = r;
+ while (block_map[it] == block_map[r]) {
+ ans += a[it];
+ it--;
+ }
+ }
+ cout << ans << '\n';
+ }
+ }
+
+ return 0;
+}
+```
+
+ Solution Code
+
+- 一樣先把 `block_size` 設定成一個固定值
+- `buf` 存的是累積的單點修改操作
+
+```cpp
+#include
+using namespace std;
+
+int main() {
+ cin.tie(0);
+ ios_base::sync_with_stdio(0);
+
+ int n, q;
+ cin >> n >> q;
+
+ vector a(n + 1);
+ vector pre(n + 1);
+
+ for (int i = 1; i <= n; i++) {
+ cin >> a[i];
+ pre[i] = pre[i - 1] + a[i];
+ }
+
+ const int block_size = 400;
+ vector> buf;
+ while (q--) {
+ int t;
+ cin >> t;
+ if (t == 1) {
+ int k, u;
+ cin >> k >> u;
+ buf.emplace_back(k, u - a[k]);
+ a[k] = u;
+ } else {
+ int l, r;
+ cin >> l >> r;
+ long long ans = pre[r] - pre[l - 1];
+ for (auto [id, val] : buf) {
+ if (l <= id && id <= r) {
+ ans += val;
+ }
+ }
+ cout << ans << '\n';
+ }
+ if (buf.size() >= block_size) {
+ buf.clear();
+ for (int i = 1; i <= n; i++) {
+ pre[i] = pre[i - 1] + a[i];
+ }
+ }
+ }
+
+ return 0;
+}
+```
+
+ Solution Code
+
+- 使用 lambda function 純粹是筆者習慣，同學參考就好。
+- vector 的 erase 和 insert 的時間複雜度是 \\( O(size) \\)。
+- 以下的程式碼為每 `block_size` 次操作就會重新建分塊的序列，追求速度的話可以修改成每 \\( \sqrt{N} \\) 次操作一後再重建分塊的序列，這樣子時間複雜度不變，只是執行時間應該會快一點。
+- 注意到，重建分塊序列時，不能直接暴力 \\( O(N\sqrt{N}) \\) 將 `cnt` 陣列歸 0，或是重開一個大小為 \\( O(N\sqrt{N}) \\) 的陣列，這樣會讓總時間複雜度變成 \\( O(N^2) \\)，這是一個初學者常犯的小錯誤。
+
+
+```cpp
+#include
+using namespace std;
+
+int main() {
+ cin.tie(0);
+ ios_base::sync_with_stdio(0);
+
+ int block_size = 320;
+ int block_num = 320;
+
+ int n; cin >> n;
+ vector a(n + 1);
+ vector> block(block_num);
+ vector> cnt(block_num, vector(n + 1));
+
+ for (int i = 1; i <= n; i++) {
+ cin >> a[i];
+ int block_id = i / block_size;
+ block[block_id].push_back(a[i]);
+ cnt[block_id][a[i]]++;
+ }
+
+ int q; cin >> q;
+
+ int last_ans = 0;
+
+ auto decode = [&](int& x) {
+ x = (x + last_ans - 1) % n + 1;
+ };
+ auto find_block_id = [&](int id) -> pair {
+ int res = 0;
+ for (int i = 0; i < block_num; i++) {
+ if (res + (int) block[i].size() >= id) {
+ return {i, res};
+ }
+ res += block[i].size();
+ }
+ };
+
+ auto remove = [&](vector& v, vector& c, int id) {
+ auto it = v.begin() + id;
+ int ret = *it;
+ c[ret]--;
+ v.erase(it);
+ return ret;
+ };
+
+ auto insert = [&](vector& v, vector& c, int id, int val) {
+ auto it = v.begin() + id;
+ c[val]++;
+ v.insert(it, val);
+ };
+
+ auto rebuild = [&]() {
+ vector> new_block(block_num);
+ int id = 0;
+ for (int i = 0; i < block_num; i++) {
+ for (auto it : block[i]) {
+ int block_id = id / block_size;
+ new_block[block_id].push_back(it);
+ cnt[i][it]--;
+ cnt[block_id][it]++;
+ id++;
+ }
+ }
+ block = new_block;
+ };
+
+ for (int p = 1; p <= q; p++) {
+ if (p % block_size == 0) rebuild();
+ int t, l, r; cin >> t >> l >> r;
+ decode(l), decode(r);
+ if (l > r) swap(l, r);
+ auto [l_bid, l_pre] = find_block_id(l);
+ auto [r_bid, r_pre] = find_block_id(r);
+ int l_id = l - l_pre - 1, r_id = r - r_pre - 1;
+ if (t == 1) {
+ if (l == r) continue;
+ auto val = remove(block[r_bid], cnt[r_bid], r_id);
+ insert(block[l_bid], cnt[l_bid], l_id, val);
+ } else {
+ int k; cin >> k;
+ decode(k);
+ int ans = 0;
+ if (l_bid == r_bid) {
+ for (int i = l_id; i <= r_id; i++) ans += (block[l_bid][i] == k);
+ } else {
+ for (int i = l_bid + 1; i <= r_bid - 1; i++) ans += cnt[i][k];
+ for (int i = l_id; i < (int) block[l_bid].size(); i++) ans += (block[l_bid][i] == k);
+ for (int i = 0; i <= r_id; i++) ans += (block[r_bid][i] == k);
+ }
+ cout << ans << '\n';
+ last_ans = ans;
+ }
+ }
+
+ return 0;
+}
+```
+
+
+
+此時第一塊的元素會多一個而第四塊的元素會少一個。我們只要從第一塊開始將最右邊多的那一塊丟給下一塊，下一塊將他最右邊多的那一塊給下一塊，直到少一個的塊被補足為止。
+
+
+
+也就是說，第一種操作暴力插入刪除元素後，從 \\( l \\) 所在的塊開始，持續將最後面的元素推到下一塊的開頭，直到 \\( r \\) 所在的塊為止。因為至多 \\( O(\sqrt{N}) \\) 塊，搭配使用能 \\( O(1) \\) 在最前面與最後面插入/刪除的 deque，則這步的時間複雜度為 \\( O(\sqrt{N}) \\)。這樣能保證第一種操作之後還是每 \\( O(\sqrt{N}) \\) 個元素在同一塊。總時間複雜度不變。
+
+這樣做的好處是每一次操作結束後第 `i` 個元素仍然會在第 `i / block_size` 塊上。就不用再額外找第 `i` 塊在哪。也不需要重建序列分塊。
+
+
+ Solution Code
+
+- 使用 0-based index，這樣才能方便透過 `i % block_size` 取得第 `i` 個元素在第 `i / block_size` 的哪個位置。
+
+```cpp
+#include
+using namespace std;
+
+int main() {
+ cin.tie(0);
+ ios_base::sync_with_stdio(0);
+
+ int block_size = 320;
+ int block_num = 320;
+
+ int n; cin >> n;
+ vector a(n + 1);
+ vector> block(block_num);
+ vector> cnt(block_num, vector(n + 1));
+
+ for (int i = 0; i < n; i++) {
+ cin >> a[i];
+ int block_id = i / block_size;
+ block[block_id].push_back(a[i]);
+ cnt[block_id][a[i]]++;
+ }
+
+ int q; cin >> q;
+
+ int last_ans = 0;
+
+ auto decode = [&](int& x) {
+ x = (x + last_ans - 1) % n + 1;
+ };
+
+ auto remove = [&](deque& deq, vector& c, int id) {
+ auto it = deq.begin() + id;
+ int ret = *it;
+ c[ret]--;
+ deq.erase(it);
+ return ret;
+ };
+
+ auto insert = [&](deque& deq, vector& c, int id, int val) {
+ auto it = deq.begin() + id;
+ c[val]++;
+ deq.insert(it, val);
+ };
+
+ auto balance = [&](int l, int r) {
+ for (int i = l; i < r; i++) {
+ int val = block[i].back();
+ cnt[i + 1][val]++;
+ block[i + 1].push_front(block[i].back());
+ cnt[i][val]--;
+ block[i].pop_back();
+ }
+ };
+
+ auto calc = [&](int l, int r, int k) {
+ int ans = 0;
+ while (l <= r) {
+ if (l % block_size == 0 && l + block_size - 1 <= r) {
+ ans += cnt[l / block_size][k];
+ l += block_size;
+ } else {
+ ans += (block[l / block_size][l % block_size] == k);
+ l++;
+ }
+ }
+ return ans;
+ };
+
+ while (q--) {
+ int t, l, r; cin >> t >> l >> r;
+ decode(l), decode(r);
+ if (l > r) swap(l, r);
+ l--, r--;
+ int l_bid = l / block_size, l_id = l % block_size;
+ int r_bid = r / block_size, r_id = r % block_size;
+ if (t == 1) {
+ if (l == r) continue;
+ auto val = remove(block[r_bid], cnt[r_bid], r_id);
+ insert(block[l_bid], cnt[l_bid], l_id, val);
+ balance(l_bid, r_bid);
+ } else {
+ int k; cin >> k;
+ decode(k);
+ last_ans = calc(l, r, k);
+ cout << last_ans << '\n';
+ }
+ }
+
+ return 0;
+}
+```
+
+
+
+雖然說他的結論不是很正確，多數題目下帶 \\( \log{N} \\) 的演算法還是能跑的比分塊還快，除非分塊的操作真的很乾淨，或者是出題者沒卡。
+
+但是我們可以知道分塊其實跑得很快，因為沒有遞迴、程式碼乾淨、常數較小。第一個範例題目的 \\( N \\) 最大為 \\( 2 \times 10^5 \\)，分塊的做法能在 0.13s 通過所有測資，並不會比線段樹還差。而且有許多題目是分塊能做但線段樹不能做的。因此這個技巧還滿重要且實用的。
+
+
+### 序列分塊的思路
+ 1. 完整的一塊要維護什麼資訊？
+ 2. 查詢時，左右不完整的塊要怎麼處理？
+ 3. 如何在不用太快的方法下更新塊的資訊？因為分塊的複雜度已經帶一個根號了，所以只要更新的操作在 \\( O(\sqrt{N}) \\) 下，都不會讓時間複雜度變差。
+
+### 操作分塊的思路
+ 1. 怎麼快速做沒有修改的版本？
+ 2. 如果將單一個修改應用到詢問上？
+ 3. 如何快速的重建維護的資訊？
+
+## Exercises
+
+以下我們來看一些題目。
+
+> [CSES - Dynamic Range Minimum Queries](https://cses.fi/problemset/task/1649)
+>
+> 給定一個長度為 \\( N \\) 的序列 \\( a \\)，並對其進行 \\( Q \\) 筆操作。操作有兩種：
+> 1. 給定 \\( k, u \\)，將 \\( a_k \\) 修改成 \\( u \\)。
+> 2. 給定 \\( l, r \\)，請輸出 \\( a_l, a_{l + 1}, ..., a_r \\) 的最小值。
+> - \\( N, Q \leq 2 \times 10^5 \\)
+
+ Solution
+
+查詢區間最小值與查詢區間和的差異在於單點修改時不能 \\( O(1) \\) 達成。不過只要每次單點修改就重新計算該塊的最小值是多少就能做了。適合當作基礎分塊技巧的練習題。
+
+ Solution
+
+對序列分塊，假設塊的大小是 \\( K \\)。每一塊維護塊內元素排序好的陣列。
+
+對於區間加值操作，被區間完全覆蓋的塊，直接打懶標紀錄整塊加上 \\( w \\)，至多 \\( O(\frac{N}{K}) \\) 塊，所以此步驟的時間複雜度為 \\( O(\frac{N}{K}) \\)。對於左右沒有被區間完整覆蓋而散落的元素，直接暴力在塊中排序好的陣列上找出被區間覆蓋的元素並直接加值。加完值後需要重新排序。因為被加值的元素與沒被加值的元素會形成兩個排序好的序列，可以線性合併他們兩個以獲得整個排序好的陣列。所以此步驟的時間複雜度是 \\( O(K) \\)。
+
+對於區間查詢有多少數字大於等於 \\( c \\)，被區間完全覆蓋的塊直接在塊內元素排序好的陣列上搭配懶標二分搜即可，此步驟的時間複雜度為 \\( O(\frac{N}{K} \times \log K) \\)。對於左右沒有被區間完整覆蓋而散落的元素，直接暴力在塊中查找，此步驟時間複雜度為 \\( O(K) \\)。
+
+總結一下：
+- 初始構造每一塊塊內還續好的陣列：\\( O(N\log N) \\)。
+- 區間加值：\\( O(\frac{N}{K} + K) \\)
+- 查詢：\\( O( \frac{NlogK}{K}+K) \\)
+
+則總時間複雜度：\\( O( N\log N + Q ( \frac {NlogK}{K}+K) ) \\)
+
+- 若取 \\( K = \sqrt{N} \\)，則總時間複雜度為 \\( O( N\log N + Q\sqrt{N}\log N) ) \\)。
+- 若取 \\( K = \sqrt{N\log N} \\)，則總時間複雜度為 \\( O( N\log N + Q\sqrt{N\log N}) ) \\)。
+
+這個題目的用意是想展示，並不是所有分塊都是取 \\( O(\sqrt{N}) \\) 為最優。
+
+ Solution
+
+將洞每連續 \\( \sqrt{N} \\) 個分成一塊。
+
+每個洞都維護這個洞往後跑時，第一個離開當前塊能到達的洞穴編號、這途中經過幾個洞穴以及離開當前塊之前最後經到達的洞邊號。建這個表需要 \\( O(N\sqrt{N}) \\)。
+
+- 對於查詢操作，直接從第 \\( x \\) 個洞開始模擬，每次直接跳到離開當前塊，第一個能到達的位置，並將答案加上這途中經過幾個洞穴。因為至多 \\( \sqrt{N} \\) 個塊，所以此步驟時間複雜度為 \\( O\sqrt{N} \\)。
+- 對於修改操作，修改了第 \\( x \\) 個洞維護的值之後，在 \\( x \\) 右邊或者是不在同一塊內的元素不會受影響。但有可能需要修改同一塊內在他左邊的元素維護的值。此步驟可以在 \\( O(\sqrt{N}) \\) 辦到。
+
+總時間複雜度為 \\( O((N + M)\sqrt{N}) \\)。
+
+ Solution
+
+本題可以使用 Centroid Decomposition 來解，不過既然這章節是分塊，要來討論一下怎麼用分塊來解這題。
+
+回想操作分塊的思路：
+1. 怎麼快速做沒有修改的版本
+
+假設樹初始有一些點是紅色的，我們只要透過從所有紅色點開始 BFS，即可 \\( O(N) \\) 維護每個點到最近的紅色點的距離。
+
+2. 如果將單一個修改應用到詢問上
+
+對於額外被修改成紅色的點，我們直接計算他與詢問的點距離是多少。
+
+樹上給定兩點求距離是一個非常經典的問題，請讀者參考其他章節，或自行研究。總而言之，這裡你可以透過將查詢距離的問題轉換成 LCA 問題後再轉換成 RMQ 問題，然後搭配 Sparse Table 來達到 \\( O(N\log N) \\) 預處理、\\( O(1) \\) 查詢兩點距離的算法。
+
+事實上此處就算是使用倍增法來求 LCA ，也就是查詢時會是 \\( O(\log N) \\)，仍然能通過此題。
+
+3. 如何快速的重建維護的資訊
+
+重新從所有紅色的點開始 BFS 即可，此步驟 \\( O(N + M) \\)。
+
+綜上所述，透過操作分塊，我們可以得到一個 \\( O((N + M)\sqrt{N}) \\) 的做法。
+
+ Solution
+
+本題的官方解答是利用一些筆者認為很無聊的觀察來得出一個 \\( O(M\log N) \\) 作法。
+
+事實上，你也可以使用操作分塊的想法來做這題。
+
+
+預處理費氏數列前 \\( N \\) 項的前綴和，就可以快速將一個區間加上費氏數列的操作貢獻給詢問區間和。
+
+查詢區間和就會想到前綴和，可以透過對要區間加費氏數列的左端點與右端點打上標記，從頭掃過去，快速重建前綴和。
+
+可以在 \\( O((N + M)\sqrt{N}) \\) 下解出這題，細節就給讀者自行練習。
+
+ Solution
+
+直接對序列分塊，每一塊維護一個懶人標記，代表這一整塊的元素是否都相同。操作時，對於包含到的塊，直接查看懶標，看整塊是否全等於某個數字，不是的話就進入塊中查看每個元素；是的話直接修改懶標即可。對於被包含到部分的塊，直接到塊中暴力查看與修改。
+
+以上的作法看似非常暴力，因爲直觀上，可能一次操作就會進入很多塊中一個元素一個元素去比較，單一操作的最慘時間複雜度是 \\( O(N) \\)。
+
+這個做法的時間複雜度與到底有幾塊並非整塊相等有關，因為非整塊相等會讓他有機會在未來的操作需要進入塊中查看每個元素。可以發現每一次操作過後，塊內的元素不全部相等的塊的數量最多加二。
+
+因此其實這個做法均攤來看其實是 \\( O(N\sqrt{N}) \\)。證明留給讀者練習。
+
+
+ Solution
+
+這題在當年台北站算是有難度的題目，僅有 14 隊做出來。官解做法複雜度為 \\( O(M\log N) \\)，但是在賽中有隊伍直接使用分塊算法解出這題。
+
+首先因為 \\( n \leq 10^6 \\)，而 \\( e \leq 2 \times 10^5 \\)，所以可以先 relabel ，讓序列的大小變成 \\( 2 \times 10^5 \\)。
+
+接著對序列分塊，每一塊需要維護兩種 stack，完整覆蓋到的 stack，稱作 \\(whole\\)，以及部分覆蓋的 stack，稱做 \\(part\\)。每一個元素也要自己維護一個 stack。
+
+每當第一種操作時，就將新增的人 push 到區間完整覆蓋到的塊的 \\( whole \\) 與左右沒完整覆蓋到的元素自己的 stack 上。注意到，左右只包含到部分的塊，會需要 push 到該塊的 \\( part \\) 上。因為有一種可能是第二種操作的區間完整包含這一塊，如果只有 push 進個別的小元素的 stack 內，會沒辦法知道其實他可供選擇。
+
+第二種操作時，對於查詢區間完整覆蓋到的塊，他的 \\( whole \\) 與 \\( part \\) 的 top 會是答案候選人，對於左右區間沒完整覆蓋到的部分，各自元素自己的 stack 的 \\( top \\) 與他們所在的塊的 \\( whole \\) 的 \\( top \\) 會是答案候選人，將所有答案候選人挑最晚加進來的就是答案。
+
+我們同時也需要 lazy 的去 pop stack 的元素。如果每次操作二找到答案後直接將所有 stack 中有他的都刪掉，這樣複雜度非常差。我們可以要開個陣列紀錄每個元素是否已經被刪除了。當每次要求某個 stack 的 top 時，都從他的 top 開始持續 pop 直到碰到第一個還沒被刪除的元素。
+
+綜上所述，因此我們可以在 \\( e\sqrt{e} \\) 的複雜度下解出這題。
+
+這個做法的正確性就請讀者自行思考看看了。
+
+