目录
题单
线段树1
区间相加，区间求和
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
typedef long long LL;
int n, m;
int w[N];
struct Node {
int l, r;
LL sum, add;
}tr[N << 2];
void pushup(int u) {
tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}
void pushdown(int u) {
auto& root = tr[u], &left = tr[u << 1], &right = tr[u << 1 | 1];
if (root.add) {
left.add += root.add, left.sum += (LL)(left.r - left.l + 1) * root.add;
right.add += root.add, right.sum += (LL)(right.r - right.l + 1) * root.add;
root.add = 0;
}
}
void build(int u, int l, int r) {
if (l == r) tr[u] = {l, r, w[l], 0};
else {
tr[u] = {l, r};
int mid = l + r >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
// 注意这里
pushup(u);
}
}
void modify(int u, int l, int r, int d) {
if (l <= tr[u].l && r >= tr[u].r) {
// [l, r]完全包含u对应的区间
// 处理sum和懒标记
tr[u].sum += (LL)d * (tr[u].r - tr[u].l + 1);
tr[u].add += d;
} else {
// 注意这里
pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
if (l <= mid) modify(u << 1, l, r, d);
if (r > mid) modify(u << 1 | 1, l, r, d);
// 注意这里
pushup(u);
}
}
LL query(int u, int l, int r) {
if (l <= tr[u].l && r >= tr[u].r) return tr[u].sum;
// 注意这里
pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
LL sum = 0;
if (l <= mid) sum += query(u << 1, l, r);
if (r > mid) sum += query(u << 1 | 1, l, r);
return sum;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", w + i);
build(1, 1, n);
int op, l, r, d;
while (m--) {
scanf("%d", &op);
if (op == 1) {
scanf("%d%d%d", &l, &r, &d);
modify(1, l, r, d);
} else {
scanf("%d%d", &l, &r);
printf("%lld\n", query(1, l, r));
}
}
return 0;
}
TJOI2009开关
一排灯初始是关闭的，每次可翻转一个区间的等的状态，每次询问一个区间内亮的等的个数。相当于是区间改状态，区间求和。
sum表示当前节点的开着的灯的个数，tag表示操作了多少次.
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define debug(...) 42
#endif
const int N = 100010;
typedef long long LL;
int n, m;
int w[N];
struct Node {
int l, r;
// sum当前区间开着的灯的个数 tag标记:初始为0，操作一次变为1
int sum, tag;
}tr[N << 2];
void pushup(int u) {
tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}
void pushdown(int u) {
auto& root = tr[u], &left = tr[u << 1], &right = tr[u << 1 | 1];
if (root.tag) {
left.tag ^=1, left.sum = (left.r - left.l + 1)- left.sum;
right.tag ^= 1, right.sum = (right.r - right.l + 1) - right.sum;
root.tag = 0;
}
}
void build(int u, int l, int r) {
if (l == r) tr[u] = {l, r, 0, 0};
else {
tr[u] = {l, r};
int mid = l + r >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
// 注意这里
pushup(u);
}
}
void modify(int u, int l, int r) {
if (l <= tr[u].l && r >= tr[u].r) {
// [l, r]完全包含u对应的区间
// 处理sum和懒标记
tr[u].sum = (tr[u].r - tr[u].l + 1) - tr[u].sum;
tr[u].tag ^= 1;
} else {
// 注意这里
pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
if (l <= mid) modify(u << 1, l, r);
if (r > mid) modify(u << 1 | 1, l, r);
// 注意这里
pushup(u);
}
}
LL query(int u, int l, int r) {
if (l <= tr[u].l && r >= tr[u].r) {
// debug(tr[u].l, tr[u].r, tr[u].sum);
return tr[u].sum;
}
// 注意这里
pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
LL sum = 0;
if (l <= mid) sum += query(u << 1, l, r);
if (r > mid) sum += query(u << 1 | 1, l, r);
return sum;
}
int main() {
scanf("%d%d", &n, &m);
build(1, 1, n);
int op, l, r, d;
while (m--) {
scanf("%d", &op);
if (op == 0) {
scanf("%d%d", &l, &r);
modify(1, l, r);
} else {
scanf("%d%d", &l, &r);
printf("%lld\n", query(1, l, r));
}
}
return 0;
}
逆序对
倒序枚举，然后计算已经插入到线段树中的在这个数前面的区间和，这个表示的意义是：在原数组中当前数之后，且小于当前数的个数。 数据比较大，需要离散化。
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define debug(...) 42
#endif
typedef long long LL;
const int N = 1e6+10;
struct Node
{
int l, r;
LL s; // 区间和
}tr[N * 4];
LL w[N], x[N];
void pushup(int u) // 由子节点的信息，来计算父节点的信息
{
tr[u].s = tr[u << 1].s + tr[u << 1 | 1].s;
}
void build(int u, int l, int r)
{
if (l == r) tr[u] = {l, r, 0};
else {
tr[u] = {l, r};
int mid = l + r >> 1;
build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
pushup(u);
}
}
LL query(int u, int l, int r)
{
if (tr[u].l >= l && tr[u].r <= r) return tr[u].s; // 树中节点，已经被完全包含在[l, r]中了
int mid = tr[u].l + tr[u].r >> 1;
LL s = 0;
if (l <= mid) s += query(u << 1, l, r);
if (r > mid) s += query(u << 1 | 1, l, r);
return s;
}
// 单点更新
void modify(int u, int index, int d)
{
if (tr[u].l == tr[u].r) {
tr[u].s += d;
} else {
int mid = tr[u].l + tr[u].r >> 1;
if (index <= mid) modify(u << 1, index, d);
if (index > mid) modify(u << 1 | 1, index, d);
pushup(u);
}
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n;
build(1, 1, n);
map<int,int> mp;
int t = 0;
// 读入 离散化
for (int i = 1; i <= n; i++) {
cin >> w[i];
x[i] = w[i];
}
sort(x + 1, x + 1 + n);
for (int i = 1; i <= n; i++) mp[x[i]] = ++t;
// 计算贡献
LL ans = 0;
for (int i = n; i >= 1; i--) {
int index = mp[w[i]];
// debug(w[i], index);
ans += query(1, 1, index - 1);
modify(1, index, 1);
}
cout << ans << endl;
return 0;
}
忠诚
区间求最小值.
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define debug(...) 42
#endif
typedef long long LL;
const int N = 200010;
struct Node
{
int l, r;
int v; // 区间[l, r]中的最小值
}tr[N * 4];
int w[N];
void pushup(int u) // 由子节点的信息，来计算父节点的信息
{
tr[u].v = min(tr[u << 1].v, tr[u << 1 | 1].v);
}
void build(int u, int l, int r)
{
if (l == r) tr[u] = {l, r, w[l]};
else {
tr[u] = {l, r};
int mid = l + r >> 1;
build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
pushup(u);
}
}
int query(int u, int l, int r)
{
if (tr[u].l >= l && tr[u].r <= r) return tr[u].v; // 树中节点，已经被完全包含在[l, r]中了
int mid = tr[u].l + tr[u].r >> 1;
int v = INT_MAX;
if (l <= mid) v = query(u << 1, l, r);
if (r > mid) v = min(v, query(u << 1 | 1, l, r));
return v;
}
// 本题不需要这个函数，这个函数是单点修改
void modify(int u, int x, int v)
{
if (tr[u].l == x && tr[u].r == x) tr[u].v = v;
else
{
int mid = tr[u].l + tr[u].r >> 1;
if (x <= mid) modify(u << 1, x, v);
else modify(u << 1 | 1, x, v);
pushup(u);
}
}
int main()
{
int m, n;
scanf("%d%d", &m, &n);
for (int i = 1; i <= m; i++) scanf("%d", w + i);
build(1, 1, m);
int x, y;
while (n--)
{
scanf("%d%d", &x, &y);
printf("%d ", query(1, x, y));
}
return 0;
}
无聊的数列
区间加等差数列。
转化为维护原序列的差分数列，那么区间
[
l
,
r
]
[l,r]
[l,r]加等差数列等价于在差分数列的[l]加首项,
[
l
+
1
,
r
]
[l+1, r]
[l+1,r]加公差，
[
r
]
[r]
[r]处减去末项. 转化为区间修改，区间求和的问题。
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
typedef long long LL;
int n, m;
int w[N];
struct Node {
int l, r;
LL sum, add;
}tr[N << 2];
void pushup(int u) {
tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}
void pushdown(int u) {
auto& root = tr[u], &left = tr[u << 1], &right = tr[u << 1 | 1];
if (root.add) {
left.add += root.add, left.sum += (LL)(left.r - left.l + 1) * root.add;
right.add += root.add, right.sum += (LL)(right.r - right.l + 1) * root.add;
root.add = 0;
}
}
void build(int u, int l, int r) {
if (l == r) tr[u] = {l, r, w[l], 0};
else {
tr[u] = {l, r};
int mid = l + r >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
// 注意这里
pushup(u);
}
}
void modify(int u, int l, int r, int d) {
if (l <= tr[u].l && r >= tr[u].r) {
// [l, r]完全包含u对应的区间
// 处理sum和懒标记
tr[u].sum += (LL)d * (tr[u].r - tr[u].l + 1);
tr[u].add += d;
} else {
// 注意这里
pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
if (l <= mid) modify(u << 1, l, r, d);
if (r > mid) modify(u << 1 | 1, l, r, d);
// 注意这里
pushup(u);
}
}
LL query(int u, int l, int r) {
if (l <= tr[u].l && r >= tr[u].r) return tr[u].sum;
// 注意这里
pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
LL sum = 0;
if (l <= mid) sum += query(u << 1, l, r);
if (r > mid) sum += query(u << 1 | 1, l, r);
return sum;
}
int main() {
scanf("%d%d", &n, &m);
//原数组
for (int i = 1; i <= n; i++) scanf("%d", w + i);
// 差分数组
for (int i = n; i > 1; i--) w[i] = w[i] - w[i - 1];
build(1, 1, n);
int op, l, r, k, d;
while (m--) {
scanf("%d", &op);
if (op == 1) {
scanf("%d%d%d%d", &l, &r, &k, &d);
// 差分数组 w[l] += k
modify(1, l, l, k);
// 差分数组 [l+1, r] += d
if (l + 1 <= r) modify(1, l + 1, r, d);
// 差分数组 w[r+1]-=末项 也就是 k+d*(r-l)
if (r < n) modify(1, r + 1, r + 1, -(k + 1LL * d * (r - l)));
} else {
scanf("%d", &r);
printf("%lld\n", query(1, 1, r));
}
}
return 0;
}
扶苏的问题
支持区间加，区间修改，询问区间最大值
做法：打两个标记
一些需要考虑的地方:
需要两个懒标记, assgin(赋值), add(区间加)
考虑如何更新.
- 区间赋值操作: 更新assgin标记，add置为0. 因为区间赋值会无视掉之前的值，add没有用了
- 区间加x: 如果assgin有值(这里我们可以假设assgin=INF_MAX为没有值),那么更新assgin+=x, add不变。因为区间赋值为a，然后区间加b，就等价于区间赋值为(a+b)
- 区间加x: 如果assgin没有值，那么assgin不变，add+=x
总结一下：
赋值标记优先级大于区间加标记. 并且在有区间赋值的情况下，区间加标记肯定为0.
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
typedef long long LL;
int n, m;
int w[N];
struct Node {
int l, r;
LL maxV, add, assign;
}tr[N << 2];
void pushup(int u) {
tr[u].maxV = max(tr[u << 1].maxV, tr[u << 1 | 1].maxV);
}
// 辅助函数，被多次调用，因此抽出来. 用来计算当前节点的作用了懒标记后的结果
void eval(Node& t, LL add, LL assign) {
if (assign != LLONG_MAX) {
// 下传有赋值标记
t.maxV = assign;
t.assign = assign;
t.add = 0;
} else {
if (add == 0) return;
// 下传add标记
if (t.assign != LLONG_MAX) {
t.assign += add;
t.maxV = t.assign;
t.add = 0;
} else {
t.add += add;
t.maxV += add;
}
}
}
void pushdown(int u) {
// 切记，懒标记作用的是当前节点的子孙节点。对当前节点的作用已经计算过了
eval(tr[u << 1], tr[u].add, tr[u].assign); //懒标记传递为左儿子
eval(tr[u << 1 | 1], tr[u].add, tr[u].assign); //懒标记传递为右儿子
tr[u].add = 0, tr[u].assign = LLONG_MAX;
}
void build(int u, int l, int r) {
if (l == r) tr[u] = {l, r, w[l], 0, LLONG_MAX}; // LLONG_MAX 表示没有赋值标记
else {
tr[u] = {l, r, 0, 0, LLONG_MAX};
int mid = l + r >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
// 注意这里
pushup(u);
}
}
void modify(int u, int l, int r, LL add, LL assign) {
if (l <= tr[u].l && r >= tr[u].r) eval(tr[u], add, assign); // [l, r]完全包含u对应的区间
else {
// 注意这里
pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
if (l <= mid) modify(u << 1, l, r, add, assign);
if (r > mid) modify(u << 1 | 1, l, r, add, assign);
// 注意这里
pushup(u);
}
}
LL query(int u, int l, int r) {
if (l <= tr[u].l && r >= tr[u].r) return tr[u].maxV;
// 注意这里
pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
LL ans = LLONG_MIN;
if (l <= mid) ans = max(ans, query(u << 1, l, r));
if (r > mid) ans = max(ans, query(u << 1 | 1, l, r));
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> w[i];
build(1, 1, n);
int op, l, r;
LL d;
while (m--) {
cin >> op;
if (op == 1) {
cin >> l >> r >> d;
// 区间修改为d
modify(1, l, r, 0, d);
} else if (op == 2) {
cin >> l >> r >> d;
// LLONG_MAX 表示无意义
// 区间加上d
modify(1, l, r, d, LLONG_MAX);
} else {
cin >> l >> r;
cout << query(1, l, r) << endl;
}
}
return 0;
}
线段树2
支持区间加，区间乘，求区间和
做法：打两个标记
一些需要考虑的地方：
需要两个懒标记，add和mul，并且mul的优先级大于add的优先级
那么我们有如下标记更新策略,设当前的节点的和为s
(
s
+
c
)
∗
d
=
s
∗
d
+
c
∗
d
,
即为
a
d
d
=
c
∗
d
,
m
u
l
=
d
(s+c)*d = s*d+c*d,即为add = c*d, mul = d
(s+c)∗d=s∗d+c∗d,即为add=c∗d,mul=d
也就是说如果是区间加(x)操作，那么更新add懒标记: add += x; 如果是区间乘(x)操作，add需要更新: add *= x, mul *= x
初始时，add=0, mul=1。
具体实现的时候可以为区间加和区间乘写为两个函数，也可以合并为一个函数。
定义函数
m
o
d
i
f
y
(
u
,
l
,
r
,
a
d
d
,
m
u
l
)
modify(u, l, r, add, mul)
modify(u,l,r,add,mul)
区间加的话，mul传1，区间乘的话，add传0.
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
typedef long long LL;
int n, m, p;
int w[N];
struct Node {
int l, r;
LL sum, add, mul; // add和mul两个懒标记. 定义乘法优先级大于加法优先级
}tr[N << 2];
void pushup(int u) {
tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}
// 辅助函数，被多次调用，因此抽出来. 用来计算当前节点的作用了懒标记后的结果
void eval(Node& t, int add, int mul) {
t.sum = ((LL)t.sum * mul + (LL)(t.r - t.l + 1) * add) % p; // 解释: 当前区间需要乘一个数，加一个数。 乘的话就直接乘，加的话需要每个数都加，所以要加上区间的长度*add
t.mul = (LL)(t.mul * mul) % p; // 这个是作用于子节点的，当前节点已经在上一行计算过了
t.add = ((LL)t.add * mul + add) % p; // (s+c)*d = s*d + c*d 因此add需要这样来更新
}
void pushdown(int u) {
// 切记，懒标记作用的是当前节点的子孙节点。对当前节点的作用已经计算过了
eval(tr[u << 1], tr[u].add, tr[u].mul); //懒标记传递为左儿子
eval(tr[u << 1 | 1], tr[u].add, tr[u].mul); //懒标记传递为右儿子
tr[u].add = 0, tr[u].mul = 1;
}
void build(int u, int l, int r) {
if (l == r) tr[u] = {l, r, w[l], 0, 1}; // add=0, mul=1
else {
tr[u] = {l, r, 0, 0, 1}; //这里不能写tr[u] = {l, r} 这样的话mul的值不对
int mid = l + r >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
// 注意这里
pushup(u);
}
}
void modify(int u, int l, int r, int add, int mul) {
if (l <= tr[u].l && r >= tr[u].r) eval(tr[u], add, mul); // [l, r]完全包含u对应的区间
else {
// 注意这里
pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
if (l <= mid) modify(u << 1, l, r, add, mul);
if (r > mid) modify(u << 1 | 1, l, r, add, mul);
// 注意这里
pushup(u);
}
}
LL query(int u, int l, int r) {
if (l <= tr[u].l && r >= tr[u].r) return tr[u].sum;
// 注意这里
pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
LL sum = 0;
if (l <= mid) sum += query(u << 1, l, r);
if (r > mid) sum += query(u << 1 | 1, l, r);
return sum % p;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m >> p;
for (int i = 1; i <= n; i++) cin >> w[i];
build(1, 1, n);
int op, l, r, d;
while (m--) {
cin >> op;
if (op == 1) {
cin >> l >> r >> d;
modify(1, l, r, 0, d);
} else if (op == 2) {
cin >> l >> r >> d;
modify(1, l, r, d, 1);
} else {
cin >> l >> r;
cout << query(1, l, r) << endl;
}
}
return 0;
}
[COCI2010-2011#6]STEP
01序列，支持单点修改一个点，询问区间内的最长无相邻数字连续串的长度
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
typedef long long LL;
// 题意转化: 给定一个0/1序列,支持单点修改. 若一个串不含有相邻的数字，则满足要求，求最长的这样的串的长度.
int n, m;
int w[N];
struct Node {
int l, r;
// 区间的最大01连续子串长度
int sum;
// 区间前缀最大01连续子串长度
int lsum;
// 区间后缀最大01连续子串长度
int rsum;
}tr[N << 2];
void pushup(int u) {
// 先赋值
tr[u].sum = max(tr[u << 1].sum, tr[u << 1 | 1].sum);
tr[u].lsum = tr[u << 1].lsum;
tr[u].rsum = tr[u << 1 | 1].rsum;
// 考虑区间可以合并的情况
int Llen = tr[u << 1].r - tr[u << 1].l + 1; // 左儿子区间长度
int Rlen = tr[u << 1 | 1].r - tr[u << 1 | 1].l + 1; // 右儿子区间长度
if (w[tr[u << 1].r] != w[tr[u << 1 | 1].l]) // 如果左儿子的右端点和右儿子的左端点值不同
{
tr[u].sum = max(tr[u].sum, tr[u << 1].rsum + tr[u << 1 | 1].lsum); // 左儿子的后缀和右儿子的前缀合并也可以是答案
if (tr[u << 1].sum == Llen) tr[u].lsum = Llen + tr[u << 1 | 1].lsum; // 整个左儿子区间加上右儿子的前缀
if (tr[u << 1 | 1].sum == Rlen) tr[u].rsum = Rlen + tr[u << 1].rsum; // 整个右儿子区间加上左儿子的后缀
}
}
void build(int u, int l, int r) {
if (l == r) tr[u] = {l, r, 1, 1, 1};
else {
tr[u] = {l, r};
int mid = l + r >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
// 注意这里
pushup(u);
}
}
void modify(int u, int p) {
if (tr[u].l == tr[u].r && tr[u].l == p) w[p] ^= 1;
else {
int mid = tr[u].l + tr[u].r >> 1;
if (p <= mid) modify(u << 1, p);
else modify(u << 1 | 1, p);
pushup(u);
}
}
int query() {return tr[1].sum;}
int main() {
scanf("%d%d", &n, &m);
build(1, 1, n);
int pos;
while (m--) {
scanf("%d", &pos);
modify(1, pos);
printf("%d\n", query());
}
return 0;
}
三元上升子序列
询问 i < j < k 且 a [ i ] < a [ j ] < a [ k ] i<j<k且a[i]<a[j]<a[k] i<j<k且a[i]<a[j]<a[k]的序列个数
色板游戏
支持区间修改，询问区间内不同颜色个数。颜色个数 <= 30
小白逛公园
支持单点修改，询问区间内最长连续区间最大和
注注意query函数需要返回Node节点
#include <bits/stdc++.h>
using namespace std;
const int N = 500010;
typedef long long LL;
int n, m;
int w[N];
struct Node {
int l, r;
// 分别表示:区间和/左端点开始的最大子段和/右端点开始的最大子段和/区间内的最大子段和
int sum, lmax, rmax, amax;
}tr[N << 2];
void eval(Node& u, Node ul, Node ur) {
u.sum = ul.sum + ur.sum;
u.lmax = max(ul.lmax, ul.sum + ur.lmax);
u.rmax = max(ur.rmax, ur.sum + ul.rmax);
u.amax = max({ul.amax, ur.amax, ul.rmax + ur.lmax});
}
void pushup(int u) {
eval(tr[u], tr[u << 1], tr[u << 1 | 1]);
}
void build(int u, int l, int r) {
if (l == r) tr[u] = {l, r, w[l],w[l],w[l],w[l]};
else {
tr[u] = {l, r};
int mid = l + r >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
// 注意这里
pushup(u);
}
}
void modify(int u, int pos, int s) {
if (tr[u].l == tr[u].r) w[pos] = tr[u].sum = tr[u].lmax = tr[u].rmax = tr[u].amax = s;
else {
int mid = tr[u].l + tr[u].r >> 1;
if (pos <= mid) modify(u << 1, pos, s);
else modify(u << 1 | 1, pos, s);
pushup(u);
}
}
// 查询函数，因为查询时候也得记录子区间的sum/lmax/rmax/amax,我们返回Node
Node query(int u, int l, int r) {
if (tr[u].l >= l && tr[u].r <= r) return tr[u];
else {
int mid = tr[u].l + tr[u].r >> 1;
if (r <= mid) return query(u << 1, l, r); // 只在左区间
else if (l > mid) return query(u << 1 | 1, l, r); // 只在右区间
else {
// 两边都有
Node lnode = query(u << 1, l, r);
Node rnode = query(u << 1 | 1, l, r);
Node ansNode;
eval(ansNode, lnode, rnode);
return ansNode;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++ ) scanf("%d", &w[i]);
build(1, 1, n);
int op, a, b, p, s;
while (m--) {
scanf("%d", &op);
if (op == 1) {
scanf("%d%d", &a, &b);
if (a > b) swap(a, b);
printf("%d\n", query(1, a, b).amax);
} else {
scanf("%d%d", &p, &s);
modify(1, p, s);
}
}
return 0;
}
方差
支持区间加，询问区间平均数，询问区间方差
[yLOI2019]棠梨煎雪
m个01传，可能有?字符。支持单点修改，区间查询
上帝造题的七分钟2/花神游历各国
支持区间开平方，询问区间和
注意到每个数最多开方6次就为1， 维护区间和和区间最大值。在修改的时候只要最大值大于1就暴力递归下去修改。可以证明复杂度是NlogN
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define debug(...) 42
#endif
typedef long long LL;
const int N = 100010;
struct Node
{
int l, r;
LL u, v; // u表示区间和 v表示区间最大值
}tr[N * 4];
LL w[N];
void pushup(int u) // 由子节点的信息，来计算父节点的信息
{
tr[u].v = max(tr[u << 1].v, tr[u << 1 | 1].v);
tr[u].u = tr[u << 1].u + tr[u << 1 | 1].u;
}
void build(int u, int l, int r)
{
if (l == r) tr[u] = {l, r, w[l], w[l]};
else {
tr[u] = {l, r};
int mid = l + r >> 1;
build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
pushup(u);
}
}
LL query(int u, int l, int r)
{
if (tr[u].l >= l && tr[u].r <= r) return tr[u].u; // 树中节点，已经被完全包含在[l, r]中了
int mid = tr[u].l + tr[u].r >> 1;
LL s = 0;
if (l <= mid) s += query(u << 1, l, r);
if (r > mid) s += query(u << 1 | 1, l, r);
return s;
}
// 区间开方
void modify(int u, int l, int r)
{
if (tr[u].l == tr[u].r) {
tr[u].v = (int)sqrt(tr[u].v);
tr[u].u = tr[u].v;
} else {
int mid = tr[u].l + tr[u].r >> 1;
if (l <= mid && tr[u << 1].v > 1) modify(u << 1, l, r); // 只有区间的最大值大于1，才更新下去
if (r > mid && tr[u << 1 | 1].v > 1) modify(u << 1 | 1, l, r); // 只有区间的最大值大于1，才更新下去
pushup(u);
}
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n;
for (int i = 1; i <= n; i++) cin >> w[i];
build(1, 1, n);
cin >> m;
int k, l, r;
while (m--)
{
cin >> k >> l >> r;
if (l > r) swap(l, r);
if (k == 0) modify(1, l, r);
else cout << query(1, l, r) << endl;
}
return 0;
}
[SCOI2010]序列操作
给一个01序列，支持区间修改为0或1，区间取反，询问区间1的个数，询问区间最多连续1的个数
Points
二维坐标系，支持添加点，删除点，询问一个点最左边的点的坐标
635
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
