#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int N = 1e5 + 10;
int minv[N * 4], a[N];
int n, m;
//id 表示节点编号，l r 表示这个节点对应的区间
void build(int id, int l, int r) {
if (l == r) {
//如果当前区间是长度为 1 的叶子节点
minv[id] = a[l];
return;
}
//否则的话从中间拆分开左右两个区间
int mid = (l + r) >> 1;//(l + r) >> 1 ==> (l + r) / 2
build(id << 1, l, mid);//id << 1 ==> id * 2
build(id << 1 | 1, mid + 1, r);//id << 1 | 1 ==> id * 2 + 1
//左右两个孩子的结果全部计算完毕后
//把结果合并到当前节点
minv[id] = min(minv[id << 1], minv[id << 1 | 1]);
}
int query(int id, int l, int r, int x, int y) {
//如果当前节点区间 [l, r] 被 [x, y] 所包含，则直接返回结果
if (x <= l && r <= y) {
return minv[id];
}
int mid = (l + r) >> 1;
int ans = INF;
if (x <= mid) {
//如果查询区间包含左半边
ans = min(ans, query(id << 1, l, mid, x, y));
}
if (y > mid) {
//如果查询区间包含右半边
ans = min(ans, query(id << 1 | 1, mid + 1, r, x, y));
}
return ans;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
build(1, 1, n);
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
printf("%d\n", query(1, 1, n, x, y));
}
return 0;
}
举个例子：
需要组合出 1 \sim n 的所有货币价值。
请问，你至少准备几种面额的货币，保证任何交易你都付的出来。
每种货币最多使用一张。
$2^x \le n$。
把 $1 \sim n$ 看成二进制，只要全是二的幂次，就可以组合出 $1 \sim n$。
```c++
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int N = 1e5 + 10;
int minv[N * 4], a[N];
int n, m;
//id 表示节点编号，l r 表示这个节点对应的区间
void build(int id, int l, int r) {
if (l == r) {
//如果当前区间是长度为 1 的叶子节点
minv[id] = a[l];
return;
}
//否则的话从中间拆分开左右两个区间
int mid = (l + r) >> 1;//(l + r) >> 1 ==> (l + r) / 2
build(id << 1, l, mid);//id << 1 ==> id * 2
build(id << 1 | 1, mid + 1, r);//id << 1 | 1 ==> id * 2 + 1
//左右两个孩子的结果全部计算完毕后
//把结果合并到当前节点
minv[id] = min(minv[id << 1], minv[id << 1 | 1]);
}
int query(int id, int l, int r, int x, int y) {
//如果当前节点区间 [l, r] 被 [x, y] 所包含，则直接返回结果
if (x <= l && r <= y) {
return minv[id];
}
int mid = (l + r) >> 1;
int ans = INF;
if (x <= mid) {
//如果查询区间包含左半边
ans = min(ans, query(id << 1, l, mid, x, y));
}
if (y > mid) {
//如果查询区间包含右半边
ans = min(ans, query(id << 1 | 1, mid + 1, r, x, y));
}
return ans;
}
//x 是修改节点编号，v 是修改后的值
void update(int id, int l, int r, int x, int v) {
if (l == r) {
minv[id] = v;
return;
}
int mid = (l + r) >> 1;
if (x <= mid) {
//我要修改的值在左半边
update(id << 1, l, mid, x, v);
} else {
//我要修改的值在右半边
update(id << 1 | 1, mid + 1, r, x, v);
}
minv[id] = min(minv[id << 1], minv[id << 1 | 1]);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
build(1, 1, n);
while (m--) {
int op, x, y;
scanf("%d%d%d", &op, &x, &y);
if (op == 1) {
printf("%d ", query(1, 1, n, x, y));
} else {
update(1, 1, n, x, y);
}
}
return 0;
}
```
关于线段树的题目类型：
1. 题目不止是需要你维护区间信息，你可能需要用到区间信息去进行加速。
2. 思维性较强，不止是简单的维护区间最大值，区间最小值，区间和。
线段树维护区间最大值的位置。
### 例题一：广告板
### 说明
徐老师有一个 $h \times w$ 的矩形公告板，其中 $h$ 是高度，$w$ 是宽度。
现在有若干张 $1 \times W_i$ 的公告，$W_i$ 是宽度，公告只能横着放，即高度为 $1$ 的边垂直于水平面，且不能互相有重叠，每张公告都要求尽可能的放在最上面的合法的位置上。
若可以放置，输出每块可放置的位置的行号；若不存在，输出 $-1$。行号由上至下分别为 $1,2, \dots ,h$。
### 输入格式
第一行三个整数 $h,w,n$($1 \le h,w \le 10^9$; $1 \le n \le 200000$) 。
接下来 $n$ 行，每行一个整数 $W_i$($1 \le W_i \le 10^9$) 。
### 输出格式
输出 $n$ 行，一行一个整数。
### 样例输入
```
3 5 5
2
4
3
3
3
```
### 样例输出
```
1
2
1
3
-1
```
**思路**
就是求最大值。
**代码**
```c++
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int N = 2e5 + 10;
int maxv[N * 4], a[N];
int h, w, n;
//id 表示节点编号，l r 表示这个节点对应的区间
void build(int id, int l, int r) {
if (l == r) {
//如果当前区间是长度为 1 的叶子节点
maxv[id] = w;
return;
}
//否则的话从中间拆分开左右两个区间
int mid = (l + r) >> 1;//(l + r) >> 1 ==> (l + r) / 2
build(id << 1, l, mid);//id << 1 ==> id * 2
build(id << 1 | 1, mid + 1, r);//id << 1 | 1 ==> id * 2 + 1
//左右两个孩子的结果全部计算完毕后
//把结果合并到当前节点
maxv[id] = max(maxv[id << 1], maxv[id << 1 | 1]);
}
bool flag;
//x 是修改节点编号
void update(int id, int l, int r, int x) {
if (l == r) {
maxv[id] -= x;
flag = true;
printf("%d\n", l);
return;
}
int mid = (l + r) >> 1;
if (maxv[id << 1] >= x) {
//我要修改的值在左半边
update(id << 1, l, mid, x);
}
if (maxv[id << 1 | 1] >= x && !flag) {
//我要修改的值在右半边
update(id << 1 | 1, mid + 1, r, x);
}
maxv[id] = max(maxv[id << 1], maxv[id << 1 | 1]);
}
int main() {
scanf("%d%d%d", &h, &w, &n);
h = min(h, n);
build(1, 1, h);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
flag = false;
if (maxv[1] >= a[i]) {
update(1, 1, h, min(a[i], w));
}
if (!flag) {
printf("-1\n");
}
}
return 0;
}
```
线段树维护的是区间信息。
树状数组维护的是前缀信息。
1. 树状数组能解决的问题是线段树的子集。
2. 树状数组的速度比线段树快一点。
3. 树状数组代码量小。
线段树复杂度 $O(k_1logn)$，树状数组复杂度 $O(k_2logn)$（$k_1 > k_2$）。
区间和（树状数组）：$sum(1 \sim r) - sum(1 \sim l - 1) = sum(l \sim r)$。
区间最大值、最小值：$min(l \sim r) - min(1 \sim l - 1)$。
## 树状数组
$lowbit(x)$ 求出 $x$ 在二进制下最低位的 $1$ 所对应的权值。
$(10)_{10} = (1010)_{2}
$(12)_{10} = (1100)_{2}$。
$lowbit(12) = 4$。
$bit[i]$ 维护的是以 $i$ 为结尾长度为 $lowbit(i)$ 的区间信息。
$(7)_{10} = (111)_{2}(5)_{10} = (101)_{2}
不存在什么特殊形式的数据能使得树状数组/线段树特别慢。
如何使得线段树超时而树状数组不超时呢？
数据量大到一定程度，数据量大到线段树超时，但是有没有大到树状数组超时。
```c++
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e6 + 10;
int bit[N], a[N];
int lowbit(int x) {
return x & (-x);
}
int getsum(int x) {
int res = 0;
while (x > 0) {
res += bit[x];
x -= lowbit(x);
}
return res;
}
//a[x] + v
void update(int x, int v) {
while (x <= n) {
bit[x] += v;
x += lowbit(x);
}
}
int query_max(int x, int y) {
int ans = -1;
while (x <= y) {
int l = y - lowbit(y) + 1;
if (l < x) {
ans = max(ans, a[y]);
y--;
} else {
ans = max(ans, tree[y]);
y -= lowbit(y);
}
}
return ans;
}
int main() {
return 0;
}
```