## 线段树基础题推荐
-### [luogu P3372【模板】线段树 1](https://www.luogu.org/problem/show?pid=3372)
-
-代码：
-
-```cpp
-#include <iostream>
-typedef long long LL;
-LL n, a[100005], d[270000], b[270000];
-void build(LL l, LL r, LL p) {
- if (l == r) {
- d[p] = a[l];
- return;
- }
- LL m = (l + r) >> 1;
- build(l, m, p << 1), build(m + 1, r, (p << 1) | 1);
- d[p] = d[p << 1] + d[(p << 1) | 1];
-}
-void update(LL l, LL r, LL c, LL s, LL t, LL p) {
- if (l <= s && t <= r) {
- d[p] += (t - s + 1) * c, b[p] += c;
- return;
- }
- LL m = (s + t) >> 1;
- if (b[p])
- d[p << 1] += b[p] * (m - s + 1), d[(p << 1) | 1] += b[p] * (t - m),
- b[p << 1] += b[p], b[(p << 1) | 1] += b[p];
- b[p] = 0;
- if (l <= m) update(l, r, c, s, m, p << 1);
- if (r > m) update(l, r, c, m + 1, t, (p << 1) | 1);
- d[p] = d[p << 1] + d[(p << 1) | 1];
-}
-LL getsum(LL l, LL r, LL s, LL t, LL p) {
- if (l <= s && t <= r) return d[p];
- LL m = (s + t) >> 1;
- if (b[p])
- d[p << 1] += b[p] * (m - s + 1), d[(p << 1) | 1] += b[p] * (t - m),
- b[p << 1] += b[p], b[(p << 1) | 1] += b[p];
- b[p] = 0;
- LL sum = 0;
- if (l <= m) sum = getsum(l, r, s, m, p << 1);
- if (r > m) sum += getsum(l, r, m + 1, t, (p << 1) | 1);
- return sum;
-}
-int main() {
- std::ios::sync_with_stdio(0);
- LL q, i1, i2, i3, i4;
- std::cin >> n >> q;
- for (LL i = 1; i <= n; i++) std::cin >> a[i];
- build(1, n, 1);
- while (q--) {
- std::cin >> i1 >> i2 >> i3;
- if (i1 == 2)
- std::cout << getsum(i2, i3, 1, n, 1) << endl;
- else
- std::cin >> i4, update(i2, i3, i4, 1, n, 1);
- }
- return 0;
-}
-```
-
-### [luogu P3373【模板】线段树 2](https://www.luogu.org/problem/show?pid=3373)
-
-代码：
-
-```cpp
-#include <cstdio>
-
-#define ll long long
-ll read() {
- ll w = 1, q = 0;
- char ch = ' ';
- while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
- if (ch == '-') w = -1, ch = getchar();
- while (ch >= '0' && ch <= '9') q = (ll)q * 10 + ch - '0', ch = getchar();
- return (ll)w * q;
-}
-int n, m;
-ll mod;
-ll a[100005], sum[400005], mul[400005], laz[400005];
-void up(int i) { sum[i] = (sum[(i << 1)] + sum[(i << 1) | 1]) % mod; }
-void pd(int i, int s, int t) {
- int l = (i << 1), r = (i << 1) | 1, mid = (s + t) >> 1;
- if (mul[i] != 1) {
- mul[l] *= mul[i];
- mul[l] %= mod;
- mul[r] *= mul[i];
- mul[r] %= mod;
- laz[l] *= mul[i];
- laz[l] %= mod;
- laz[r] *= mul[i];
- laz[r] %= mod;
- sum[l] *= mul[i];
- sum[l] %= mod;
- sum[r] *= mul[i];
- sum[r] %= mod;
- mul[i] = 1;
- }
- if (laz[i]) {
- sum[l] += laz[i] * (mid - s + 1);
- sum[l] %= mod;
- sum[r] += laz[i] * (t - mid);
- sum[r] %= mod;
- laz[l] += laz[i];
- laz[l] %= mod;
- laz[r] += laz[i];
- laz[r] %= mod;
- laz[i] = 0;
- }
- return;
-}
-void build(int s, int t, int i) {
- mul[i] = 1;
- if (s == t) {
- sum[i] = a[s];
- return;
- }
- int mid = (s + t) >> 1;
- build(s, mid, i << 1);
- build(mid + 1, t, (i << 1) | 1);
- up(i);
-}
-void chen(int l, int r, int s, int t, int i, ll z) {
- int mid = (s + t) >> 1;
- if (l <= s && t <= r) {
- mul[i] *= z;
- mul[i] %= mod;
- laz[i] *= z;
- laz[i] %= mod;
- sum[i] *= z;
- sum[i] %= mod;
- return;
- }
- pd(i, s, t);
- if (mid >= l) chen(l, r, s, mid, (i << 1), z);
- if (mid + 1 <= r) chen(l, r, mid + 1, t, (i << 1) | 1, z);
- up(i);
-}
-void add(int l, int r, int s, int t, int i, ll z) {
- int mid = (s + t) >> 1;
- if (l <= s && t <= r) {
- sum[i] += z * (t - s + 1);
- sum[i] %= mod;
- laz[i] += z;
- laz[i] %= mod;
- return;
- }
- pd(i, s, t);
- if (mid >= l) add(l, r, s, mid, (i << 1), z);
- if (mid + 1 <= r) add(l, r, mid + 1, t, (i << 1) | 1, z);
- up(i);
-}
-ll getans(int l, int r, int s, int t, int i) {
- int mid = (s + t) >> 1;
- ll tot = 0;
- if (l <= s && t <= r) return sum[i];
- pd(i, s, t);
- if (mid >= l) tot += getans(l, r, s, mid, (i << 1));
- tot %= mod;
- if (mid + 1 <= r) tot += getans(l, r, mid + 1, t, (i << 1) | 1);
- return tot % mod;
-}
-int main() {
- int i, j, x, y, bh;
- ll z;
- n = read();
- m = read();
- mod = read();
- for (i = 1; i <= n; i++) a[i] = read();
- build(1, n, 1);
- for (i = 1; i <= m; i++) {
- bh = read();
- if (bh == 1) {
- x = read();
- y = read();
- z = read();
- chen(x, y, 1, n, 1, z);
- } else if (bh == 2) {
- x = read();
- y = read();
- z = read();
- add(x, y, 1, n, 1, z);
- } else if (bh == 3) {
- x = read();
- y = read();
- printf("%lld\n", getans(x, y, 1, n, 1));
+### [luogu P3372【模板】线段树 1](https://www.luogu.org/problem/P3372)
+
+??? "参考代码"
+
+ ```cpp
+ #include <iostream>
+ typedef long long LL;
+ LL n, a[100005], d[270000], b[270000];
+ void build(LL l, LL r, LL p) {
+ if (l == r) {
+ d[p] = a[l];
+ return;
+ }
+ LL m = (l + r) >> 1;
+ build(l, m, p << 1), build(m + 1, r, (p << 1) | 1);
+ d[p] = d[p << 1] + d[(p << 1) | 1];
+ }
+ void update(LL l, LL r, LL c, LL s, LL t, LL p) {
+ if (l <= s && t <= r) {
+ d[p] += (t - s + 1) * c, b[p] += c;
+ return;
+ }
+ LL m = (s + t) >> 1;
+ if (b[p])
+ d[p << 1] += b[p] * (m - s + 1), d[(p << 1) | 1] += b[p] * (t - m),
+ b[p << 1] += b[p], b[(p << 1) | 1] += b[p];
+ b[p] = 0;
+ if (l <= m) update(l, r, c, s, m, p << 1);
+ if (r > m) update(l, r, c, m + 1, t, (p << 1) | 1);
+ d[p] = d[p << 1] + d[(p << 1) | 1];
}
- }
- return 0;
-}
-```
+ LL getsum(LL l, LL r, LL s, LL t, LL p) {
+ if (l <= s && t <= r) return d[p];
+ LL m = (s + t) >> 1;
+ if (b[p])
+ d[p << 1] += b[p] * (m - s + 1), d[(p << 1) | 1] += b[p] * (t - m),
+ b[p << 1] += b[p], b[(p << 1) | 1] += b[p];
+ b[p] = 0;
+ LL sum = 0;
+ if (l <= m) sum = getsum(l, r, s, m, p << 1);
+ if (r > m) sum += getsum(l, r, m + 1, t, (p << 1) | 1);
+ return sum;
+ }
+ int main() {
+ std::ios::sync_with_stdio(0);
+ LL q, i1, i2, i3, i4;
+ std::cin >> n >> q;
+ for (LL i = 1; i <= n; i++) std::cin >> a[i];
+ build(1, n, 1);
+ while (q--) {
+ std::cin >> i1 >> i2 >> i3;
+ if (i1 == 2)
+ std::cout << getsum(i2, i3, 1, n, 1) << endl;
+ else
+ std::cin >> i4, update(i2, i3, i4, 1, n, 1);
+ }
+ return 0;
+ }
+ ```
+
+### [luogu P3373【模板】线段树 2](https://www.luogu.org/problem/P3373)
+
+??? "参考代码"
+
+ ```cpp
+ #include <cstdio>
+ #define ll long long
+ ll read() {
+ ll w = 1, q = 0;
+ char ch = ' ';
+ while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
+ if (ch == '-') w = -1, ch = getchar();
+ while (ch >= '0' && ch <= '9') q = (ll)q * 10 + ch - '0', ch = getchar();
+ return (ll)w * q;
+ }
+ int n, m;
+ ll mod;
+ ll a[100005], sum[400005], mul[400005], laz[400005];
+ void up(int i) { sum[i] = (sum[(i << 1)] + sum[(i << 1) | 1]) % mod; }
+ void pd(int i, int s, int t) {
+ int l = (i << 1), r = (i << 1) | 1, mid = (s + t) >> 1;
+ if (mul[i] != 1) {
+ mul[l] *= mul[i];
+ mul[l] %= mod;
+ mul[r] *= mul[i];
+ mul[r] %= mod;
+ laz[l] *= mul[i];
+ laz[l] %= mod;
+ laz[r] *= mul[i];
+ laz[r] %= mod;
+ sum[l] *= mul[i];
+ sum[l] %= mod;
+ sum[r] *= mul[i];
+ sum[r] %= mod;
+ mul[i] = 1;
+ }
+ if (laz[i]) {
+ sum[l] += laz[i] * (mid - s + 1);
+ sum[l] %= mod;
+ sum[r] += laz[i] * (t - mid);
+ sum[r] %= mod;
+ laz[l] += laz[i];
+ laz[l] %= mod;
+ laz[r] += laz[i];
+ laz[r] %= mod;
+ laz[i] = 0;
+ }
+ return;
+ }
+ void build(int s, int t, int i) {
+ mul[i] = 1;
+ if (s == t) {
+ sum[i] = a[s];
+ return;
+ }
+ int mid = (s + t) >> 1;
+ build(s, mid, i << 1);
+ build(mid + 1, t, (i << 1) | 1);
+ up(i);
+ }
+ void chen(int l, int r, int s, int t, int i, ll z) {
+ int mid = (s + t) >> 1;
+ if (l <= s && t <= r) {
+ mul[i] *= z;
+ mul[i] %= mod;
+ laz[i] *= z;
+ laz[i] %= mod;
+ sum[i] *= z;
+ sum[i] %= mod;
+ return;
+ }
+ pd(i, s, t);
+ if (mid >= l) chen(l, r, s, mid, (i << 1), z);
+ if (mid + 1 <= r) chen(l, r, mid + 1, t, (i << 1) | 1, z);
+ up(i);
+ }
+ void add(int l, int r, int s, int t, int i, ll z) {
+ int mid = (s + t) >> 1;
+ if (l <= s && t <= r) {
+ sum[i] += z * (t - s + 1);
+ sum[i] %= mod;
+ laz[i] += z;
+ laz[i] %= mod;
+ return;
+ }
+ pd(i, s, t);
+ if (mid >= l) add(l, r, s, mid, (i << 1), z);
+ if (mid + 1 <= r) add(l, r, mid + 1, t, (i << 1) | 1, z);
+ up(i);
+ }
+ ll getans(int l, int r, int s, int t, int i) {
+ int mid = (s + t) >> 1;
+ ll tot = 0;
+ if (l <= s && t <= r) return sum[i];
+ pd(i, s, t);
+ if (mid >= l) tot += getans(l, r, s, mid, (i << 1));
+ tot %= mod;
+ if (mid + 1 <= r) tot += getans(l, r, mid + 1, t, (i << 1) | 1);
+ return tot % mod;
+ }
+ int main() {
+ int i, j, x, y, bh;
+ ll z;
+ n = read();
+ m = read();
+ mod = read();
+ for (i = 1; i <= n; i++) a[i] = read();
+ build(1, n, 1);
+ for (i = 1; i <= m; i++) {
+ bh = read();
+ if (bh == 1) {
+ x = read();
+ y = read();
+ z = read();
+ chen(x, y, 1, n, 1, z);
+ } else if (bh == 2) {
+ x = read();
+ y = read();
+ z = read();
+ add(x, y, 1, n, 1, z);
+ } else if (bh == 3) {
+ x = read();
+ y = read();
+ printf("%lld\n", getans(x, y, 1, n, 1));
+ }
+ }
+ return 0;
+ }
+ ```
### [HihoCoder 1078 线段树的区间修改](https://cn.vjudge.net/problem/HihoCoder-1078)
-代码：
-
-```cpp
-#include <iostream>
-
-int n, a[100005], d[270000], b[270000];
-void build(int l, int r, int p) {
- if (l == r) {
- d[p] = a[l];
- return;
- }
- int m = (l + r) >> 1;
- build(l, m, p << 1), build(m + 1, r, (p << 1) | 1);
- d[p] = d[p << 1] + d[(p << 1) | 1];
-}
-void update(int l, int r, int c, int s, int t, int p) {
- if (l <= s && t <= r) {
- d[p] = (t - s + 1) * c, b[p] = c;
- return;
- }
- int m = (s + t) >> 1;
- if (b[p]) {
- d[p << 1] = b[p] * (m - s + 1), d[(p << 1) | 1] = b[p] * (t - m);
- b[p << 1] = b[(p << 1) | 1] = b[p];
- b[p] = 0;
- }
- if (l <= m) update(l, r, c, s, m, p << 1);
- if (r > m) update(l, r, c, m + 1, t, (p << 1) | 1);
- d[p] = d[p << 1] + d[(p << 1) | 1];
-}
-int getsum(int l, int r, int s, int t, int p) {
- if (l <= s && t <= r) return d[p];
- int m = (s + t) >> 1;
- if (b[p]) {
- d[p << 1] = b[p] * (m - s + 1), d[(p << 1) | 1] = b[p] * (t - m);
- b[p << 1] = b[(p << 1) | 1] = b[p];
- b[p] = 0;
- }
- int sum = 0;
- if (l <= m) sum = getsum(l, r, s, m, p << 1);
- if (r > m) sum += getsum(l, r, m + 1, t, (p << 1) | 1);
- return sum;
-}
-int main() {
- std::ios::sync_with_stdio(0);
- std::cin >> n;
- for (int i = 1; i <= n; i++) std::cin >> a[i];
- build(1, n, 1);
- int q, i1, i2, i3, i4;
- std::cin >> q;
- while (q--) {
- std::cin >> i1 >> i2 >> i3;
- if (i1 == 0)
- std::cout << getsum(i2, i3, 1, n, 1) << endl;
- else
- std::cin >> i4, update(i2, i3, i4, 1, n, 1);
- }
- return 0;
-}
-```
+??? "参考代码"
+
+ ```cpp
+ #include <iostream>
+
+ int n, a[100005], d[270000], b[270000];
+ void build(int l, int r, int p) {
+ if (l == r) {
+ d[p] = a[l];
+ return;
+ }
+ int m = (l + r) >> 1;
+ build(l, m, p << 1), build(m + 1, r, (p << 1) | 1);
+ d[p] = d[p << 1] + d[(p << 1) | 1];
+ }
+ void update(int l, int r, int c, int s, int t, int p) {
+ if (l <= s && t <= r) {
+ d[p] = (t - s + 1) * c, b[p] = c;
+ return;
+ }
+ int m = (s + t) >> 1;
+ if (b[p]) {
+ d[p << 1] = b[p] * (m - s + 1), d[(p << 1) | 1] = b[p] * (t - m);
+ b[p << 1] = b[(p << 1) | 1] = b[p];
+ b[p] = 0;
+ }
+ if (l <= m) update(l, r, c, s, m, p << 1);
+ if (r > m) update(l, r, c, m + 1, t, (p << 1) | 1);
+ d[p] = d[p << 1] + d[(p << 1) | 1];
+ }
+ int getsum(int l, int r, int s, int t, int p) {
+ if (l <= s && t <= r) return d[p];
+ int m = (s + t) >> 1;
+ if (b[p]) {
+ d[p << 1] = b[p] * (m - s + 1), d[(p << 1) | 1] = b[p] * (t - m);
+ b[p << 1] = b[(p << 1) | 1] = b[p];
+ b[p] = 0;
+ }
+ int sum = 0;
+ if (l <= m) sum = getsum(l, r, s, m, p << 1);
+ if (r > m) sum += getsum(l, r, m + 1, t, (p << 1) | 1);
+ return sum;
+ }
+ int main() {
+ std::ios::sync_with_stdio(0);
+ std::cin >> n;
+ for (int i = 1; i <= n; i++) std::cin >> a[i];
+ build(1, n, 1);
+ int q, i1, i2, i3, i4;
+ std::cin >> q;
+ while (q--) {
+ std::cin >> i1 >> i2 >> i3;
+ if (i1 == 0)
+ std::cout << getsum(i2, i3, 1, n, 1) << endl;
+ else
+ std::cin >> i4, update(i2, i3, i4, 1, n, 1);
+ }
+ return 0;
+ }
+ ```
### [2018 Multi-University Training Contest 5 Problem G. Glad You Came](http://acm.hdu.edu.cn/showproblem.php?pid=6356)
## 拓展 - 猫树
-众所周知线段树可以支持高速查询某一段区间的信息和，比如区间最大子段和，区间和，区间矩阵的连乘积等等
+众所周知线段树可以支持高速查询某一段区间的信息和，比如区间最大子段和，区间和，区间矩阵的连乘积等等。
-但是有一个问题在于普通线段树的区间询问在某些毒瘤的眼里可能还是有些慢了
+但是有一个问题在于普通线段树的区间询问在某些毒瘤的眼里可能还是有些慢了。
-简单来说就是线段树建树的时候需要做 $O(n)$ 次合并操作，而每一次区间询问需要做 $O(\log{n})$ 次合并操作，询问区间和这种东西的时候还可以忍受，但是当我们需要询问区间线性基这种合并复杂度高达 $O(\log^2{n})$ 的信息的话，此时就算是做 $O(\log{n})$ 次合并有些时候在时间上也是不可接受的
+简单来说就是线段树建树的时候需要做 $O(n)$ 次合并操作，而每一次区间询问需要做 $O(\log{n})$ 次合并操作，询问区间和这种东西的时候还可以忍受，但是当我们需要询问区间线性基这种合并复杂度高达 $O(\log^2{n})$ 的信息的话，此时就算是做 $O(\log{n})$ 次合并有些时候在时间上也是不可接受的。
-而所谓 "猫树" 就是一种不支持修改，仅仅支持快速区间询问的一种静态线段树
+而所谓 "猫树" 就是一种不支持修改，仅仅支持快速区间询问的一种静态线段树。
-构造一棵这样的静态线段树需要 $O(n\log{n})$ 次合并操作，但是此时的查询复杂度被加速至 $O(1)$ 次合并操作
+构造一棵这样的静态线段树需要 $O(n\log{n})$ 次合并操作，但是此时的查询复杂度被加速至 $O(1)$ 次合并操作。
-在处理线性基这样特殊的信息的时候甚至可以将复杂度降至 $O(n\log^2{n})$
+在处理线性基这样特殊的信息的时候甚至可以将复杂度降至 $O(n\log^2{n})$ 。
### 原理
-在查询 $[l,r]$ 这段区间的信息和的时候，将线段树树上代表 $[l,l]$ 的节点和代表 $[r,r]$ 这段区间的节点在线段树上的 lca 求出来，设这个节点 p 代表的区间为 $[L,R]$ ，我们会发现一些非常有趣的性质：
+在查询 $[l,r]$ 这段区间的信息和的时候，将线段树树上代表 $[l,l]$ 的节点和代表 $[r,r]$ 这段区间的节点在线段树上的 lca 求出来，设这个节点 $p$ 代表的区间为 $[L,R]$ ，我们会发现一些非常有趣的性质：
**1. $[L,R]$ 这个区间一定包含 $[l,r]$ **
-显然，因为它既是 l 的祖先又是 r 的祖先
+显然，因为它既是 $l$ 的祖先又是 $r$ 的祖先。
**2. $[l,r]$ 这个区间一定跨越[L,R]的中点**
-由于 p 是 l 和 r 的 lca，这意味着 p 的左儿子是 l 的祖先而不是 r 的祖先，p 的右儿子是 r 的祖先而不是 l 的祖先
+由于 $p$ 是 $l$ 和 $r$ 的 lca，这意味着 $p$ 的左儿子是 $l$ 的祖先而不是 $r$ 的祖先，$p$ 的右儿子是 $r$ 的祖先而不是 $l$ 的祖先。
-因此 l 一定在 $[L,MID]$ 这个区间内，r 一定在 $[MID,R]$ 这个区间内
+因此 $l$ 一定在 $[L,MID]$ 这个区间内，$r$ 一定在 $[MID,R]$ 这个区间内。
-有了这两个性质，我们就可以将询问的复杂度降至 $O(1)$ 了
+有了这两个性质，我们就可以将询问的复杂度降至 $O(1)$ 了。
### 实现
-具体来讲我们建树的时候对于线段树树上的一个节点，设它代表的区间为 $(l,r]$
+具体来讲我们建树的时候对于线段树树上的一个节点，设它代表的区间为 $(l,r]$ 。
-不同于传统线段树在这个节点里只保留 $[l,r]$ 的和，我们在这个节点里面额外保存 $（l,mid]$ 的后缀和数组和 $(mid,r]$ 的前缀和数组
+不同于传统线段树在这个节点里只保留 $[l,r]$ 的和，我们在这个节点里面额外保存 $（l,mid]$ 的后缀和数组和 $(mid,r]$ 的前缀和数组。
-这样的话建树的复杂度为 $T(n)=2T(n/2)+O(n)=O(n\log{n})$ 同理空间复杂度也从原来的 $O(n)$ 变成了 $O(n\log{n})$
+这样的话建树的复杂度为 $T(n)=2T(n/2)+O(n)=O(n\log{n})$ 同理空间复杂度也从原来的 $O(n)$ 变成了 $O(n\log{n})$ 。
下面是最关键的询问了~
-如果我们询问的区间是 $[l,r]$ 那么我们把代表 $[l,l]$ 的节点和代表 $[r,r]$ 的节点的 lca 求出来，记为 p
+如果我们询问的区间是 $[l,r]$ 那么我们把代表 $[l,l]$ 的节点和代表 $[r,r]$ 的节点的 lca 求出来，记为 $p$ 。
-根据刚才的两个性质，l,r 在 p 所包含的区间之内并且一定跨越了 p 的中点
+根据刚才的两个性质，$l,r$ 在 $p$ 所包含的区间之内并且一定跨越了 $p$ 的中点。
-这意味这一个非常关键的事实是我们可以使用 p 里面的前缀和数组和后缀和数组，将 $[l,r]$ 拆成 $[l,mid]+(mid,r]$ 从而拼出来 $[l,r]$ 这个区间
+这意味这一个非常关键的事实是我们可以使用 $p$ 里面的前缀和数组和后缀和数组，将 $[l,r]$ 拆成 $[l,mid]+(mid,r]$ 从而拼出来 $[l,r]$ 这个区间。
而这个过程仅仅需要 $O(1)$ 次合并操作！
不过我们好像忽略了点什么？
-似乎求 lca 的复杂度似乎还不是 $O(1)$ ，暴力求是 $O(\log{n})$ 的，倍增法则是 $O(\log{\log{n}})$ 的，转 st 表的代价又太大……
+似乎求 lca 的复杂度似乎还不是 $O(1)$ ，暴力求是 $O(\log{n})$ 的，倍增法则是 $O(\log{\log{n}})$ 的，转 ST 表的代价又太大……
### 堆式建树
-具体来将我们将这个序列补成 2 的整次幂，然后建线段树
+具体来将我们将这个序列补成 2 的整次幂，然后建线段树。
-此时我们发现线段树上两个节点的 lca 编号，就是两个节点二进制编号的 lcp
+此时我们发现线段树上两个节点的 lca 编号，就是两个节点二进制编号的 lcp 。
-稍作思考即可发现发现在 x 和 y 的二进制下 `lcp(x,y)=x>>log[x^y]`
+稍作思考即可发现发现在 $x$ 和 $y$ 的二进制下 `lcp(x,y)=x>>log[x^y]` 。
-所以我们预处理一个 log 数组即可轻松完成求 lca 的工作
+所以我们预处理一个 `log` 数组即可轻松完成求 lca 的工作。
-这样我们就完成了一个猫树
+这样我们就完成了一个猫树。
-由于建树的时候涉及到求前缀和和求后缀和，所以对于线性基这种虽然合并是 $O(\log^2{n})$ 但是求前缀和却是 $O(n\log{n})$ 的信息，使用猫树可以将静态区间线性基从 $O(n\log^2{n}+m\log^3{n})$ 优化至 $O(n\log^2{n}+m\log^2{n})$ 的复杂度
+由于建树的时候涉及到求前缀和和求后缀和，所以对于线性基这种虽然合并是 $O(\log^2{n})$ 但是求前缀和却是 $O(n\log{n})$ 的信息，使用猫树可以将静态区间线性基从 $O(n\log^2{n}+m\log^3{n})$ 优化至 $O(n\log^2{n}+m\log^2{n})$ 的复杂度。
### 参考
OSDN Git Service
