线段树总结分析第三版
区间修改部分
1.批量等值修改
前提条件
是要区间修改，区间查询，且修改操作修改的值是相同的，比如批量+1，批量-1.
有一种特例是批量替换，
情景
一般是要对一个数组执行k次操作，每次改变其中一个区间内所有元素的值，然后询问一个区间内所有元素的最值或总和，
例题1区间等值操作
题解代码
void Pushdown(int k){ //更新子树的lazy值，这里是RMQ的函数，要实现区间和等则需要修改函数内容
if(lazy[k]){ //如果有lazy标记
lazy[k<<1] += lazy[k]; //更新左子树的lazy值
lazy[k<<1|1] += lazy[k]; //更新右子树的lazy值
t[k<<1] += lazy[k]; //左子树的最值加上lazy值
t[k<<1|1] += lazy[k]; //右子树的最值加上lazy值
lazy[k] = 0; //lazy值归0
}
}
注意懒标记中储存区间修改的值与长度的乘积，大概率开long long
struct node {
int l, r;
ll val;
ll lazy;
}t[N << 2];
void pushdown(node& op, ll lazy) {
op.val += lazy * (op.r - op.l + 1);
op.lazy += lazy;
}
void pushdown(int x) {
if (!t[x].lazy) return;
pushdown(t[x << 1], t[x].lazy), pushdown(t[x << 1 | 1], t[x].lazy);
t[x].lazy = 0;
}
void build(int l, int r, int x = 1\没有值传入时，默认初始化为1) {
t[x] = { l, r, w[l], 0 };
if (l == r) return;
int mid = l + r >> 1;
build(l, mid, x << 1), build(mid + 1, r, x << 1 | 1);
pushup(x);
}
void modify(int l, int r, int c, int x = 1) {
if (l <= tr[x].l && r >= tr[x].r) { pushdown(tr[x], c); return; }\通过打标记的方法来赋值
pushdown(x);
操作时遇到了懒标记就处理下（懒的思想，顺路就搞下，不顺路就拖着不干）
int mid = tr[x].l + tr[x].r >> 1;
if (l <= mid) modify(l, r, c, x << 1);\modify的递归也变成了和线段树单点修改query里的递归形式，有交集就递归。
if (r > mid) modify(l, r, c, x << 1 | 1);
pushup(x);
}
ll ask(int l, int r, int x = 1) {
if (l <= t[x].l && r >= tr[x].r) return tr[x].val;
pushdown(x);
//query的唯一变化就是加上了一个pushdown();
int mid = tr[x].l + tr[x].r >> 1;
ll res = 0;
if (l <= mid) res += ask(l, r, x << 1);
if (r > mid) res += ask(l, r, x << 1 | 1);
return res;
}
int main()
{
int n, m; cin >> n >> m;
rep(i, n) scanf("%d", &w[i]);
build(1, n);
while (m--) {
char op[2]; int l, r; scanf("%s %d %d", op, &l, &r);
if (*op == 'Q') printf("%lld\n", ask(l, r));
else {
int c; scanf("%d", &c);
modify(l, r, c);
}
}
return 0;
}
自己写的acwing式代码
#include 注意：
线段树的初始化在build里完成，多组数据集时不需要再额外初始化。
例题2线段树区间覆盖，二分查找
区别似乎可以用储存的是什么，还有操作是什么来区分
题解代码
#include 经过模仿得到的acwing代码
#include 例题3最大连续区间的维护，给连续区间长度，找端点
与例题2的区别，
此题要求在一个连续的区间上操作，所以是要知道一段区间是否连续，是否足够长，
用节点信息fmax，lmax，rmax来维护区间最大连续，左到右的最大连续，右到左的最大连续
情景：
如果这段时间空闲就安排活动。
因为要找到最左的区间，用深度优先搜索来找。
递归方面倒是和例题2很像，都是有一个左侧空瓶优先。但不会例题2递归做法，还不太懂。
套路
区间合并
前提条件：找连续区间
情景
区间合并，最大连续的情景
每组i向柜台的麋鹿Canmuu申请一组Di连续的房间。
任意两个相邻村庄之间可以通过地道保持连通。八路军司令询问从第 x 个村庄可以到达多少个地道完好的村庄（包括第 x 个村庄本身）。
就是找一段最靠前的符合要求的连续空间分配给每个请求，
应对：
用fmax，lmax，和rmax来维护最大连续。
查询区间，端点如果有优先级
递归优先的情景Canmuu总是选择尽可能小的r值。
就是找一段最靠前的符合要求的连续空间分配给每个请求，
dfs深搜递归查询，有先的放在前面。
一个染色优先度的套路，
前提条件
分色1，和色2，两种颜色
色1优先级高，可以无视色2进行区间染色，优先染无色区间，次优先染色2区间，不能染色1区间
色2不能在色1染色过的地方染色。
情景：
如果没有找到，小明就冒着木叽叽的风险无视所有屌丝基友的约定，
女神时间安排操作优先于屌丝。
处理方法
用两颗树来维护女神和屌丝的时间。女神邀约时先在屌丝树上找空闲（满足条件的最大连续）找不到再在女神树上找空闲（满足条件的最大连续）
女神操作染色时，要在两棵树上都进行染色，而屌丝操作只染一棵树。
题解代码
#include 经过模仿得到的acwing代码
#include 套路
前提条件
给连续区间长度，求满足长度要求的连续区间端点。
######应对：
dfs，fmax，lmax，rmax，搜fmax，rmax+lmax，
int findleft(node tr[],int u,int v){
if(tr[u].l == tr[u].r ) return tr[u].l;
pushdown(tr,u);
if(tr[u<<1].fmax >= v)return findleft(tr,u<<1,v);
会递到第一个左子节点<v的位置，然后回归到最后一个左子节点<= v的位置，然后往下面的语句走。
if(tr[u<<1].rmax +tr[u<<1|1].lmax >= v) return tr[u<<1].r - tr[u<<1].rmax + 1;
中间的区间不符合要求，说明答案不在左子节点，就往右子节点递归。
return findleft(tr,u<<1|1,v);
}
例题4最大连通区间维护，给点找连续区间长度
找连续区间，用递归找，x点在的连续区间，长度大于n的连续区间。
没有优先级，可以先找左子节点，也可以先找右子节点。
和例题3的递归一样，x在左右子节点的合并区间或在叶子节点才返回具体的值。
fmax不能用来确定x的位置，所以没有任何用，此题就没有使用fmax，只使用了
lmax和rmax
套路：
前提条件：给点，找连续区间长度
应对，根据点与mid的值来确定在左右子节点，然后找
左rmax的左端点，
右lmax的右端点
看x在不在。在则返回左rmax+右lmax，
不在则继续搜左子节点（右子节点）
搜到叶子返回节点的lmax或rmax
int query(int u,int x){
if(tr[u].l == tr[u].r) return tr[u].lmax;
int mid = tr[u].l + tr[u].r >> 1;
if(x <= mid){
if(x>= tr[u<<1].r - tr[u<<1].rmax + 1) return tr[u<<1].rmax + tr[u<<1|1].lmax;
return query(u<<1,x);
}
else{
if(x<= tr[u<<1|1].l + tr[u<<1|1].lmax - 1) return tr[u<<1].rmax + tr[u<<1|1].lmax;
return query(u<<1|1,x);
}
}
题解代码
#include 模仿后得到的acwing代码
#include 习题1最大连续区间维护，例题3的简化版：
题链：
Hotel
22ACM集训队-树状数组与线段树基础 - Virtual Judge (vjudge.net)
代码
#include 习题2批量替换，例题1的变式
就只是根据操作变了个pushdown。
根节点tr[1].sum,查询树的总和
代码
#include 2.批量自适应修改
题链
Q - Hotel
22ACM集训队-树状数组与线段树基础 - Virtual Judge (vjudge.net)
卡壳点:
忘记build，递归的 tr[u].l == tr[u].r == 写成 =
区间修改，题目给的时l和len，以为是l和r导致错误
用l和len表示r错误，写成了l + len，应该是l + len -1 ；
代码
#include 前提条件
是区间修改，区间查询，且修改操作的修改的值是根据具体节点储存的值而变化的，比如开根，幂，替换，乘除；
新做的题里发现替换可以直接批量赋值来实现，属于等值修改。
情景
对一个序列里的元素执行k次自适应操作，每次操作一个区间，然后询问区间内所有元素的值。
也有询问某个区间内所有值经过某种处理后的值。（此种问法是询问时用一个变量储存找到的值，经过处理后返回
例题1单种操作
Can you answer these queries?
22ACM集训队-树状数组与线段树基础 - Virtual Judge (vjudge.net)
主要就是把modify的递归条件改成了和传统query操作相同的有交集
复杂度比较高，需要一些剪枝
代码
#include 例题2多种操作
Transformation HDU - 4578
22ACM集训队-树状数组与线段树基础 - Virtual Judge (vjudge.net)
题解代码
Transformation HDU - 4578 （线段树，审题很重要）_Soar-的博客-CSDN博客
#include经过模仿后得到的acwing版代码
#include 注意
注意点就是非数组模拟节点的代码要用build初始化，然后叶子节点懒标记初始化为1，因为代表的含义是两个子节点值是否相等
懒标记区间自适应修改至少耗时2s，如果能操作简单，能用简单的语句来确定是否可以省略操作（如例题1tr[u].r - tr[u].l + 1) == tr[u].sum)判断区间内是否全为1而可以省略掉区间开方操作。
其他套路：
涉及到一个多组输入的套路
前提条件是没有明确组数，结束关键词的多组数据集输入
取反while（~scanf(“%d”,&n)
和while(scanf(“%d”,&n) != EOF)
还有while（cin >> n)三种形式
习题1开方单点剪枝1e5 + 2e5，常数n为6以内：
题链
花神游历各国
22ACM集训队-树状数组与线段树基础 - Virtual Judge (vjudge.net)
比较
与例题1是同一题型，但例题1的题解里没有用到fmax来维护区间最大值，而是直接用
tr[u].sum 与 tr[u].r - tr[u].l +1 是否相等来判断是否return。
例题1的做法仅限于元素最小是1的情况下，
习题1的元素最小为0，所以不能用这种做法。
于是归结出第一个剪枝套路
卡壳点：
没注意node内的maxn也要在modify内开方。
注意操作时除了l，r之外的属性基本都要处理
build初始化，注意叶子节点和根节点的初始化可能会不同。
代码
#include 套路：
区间单点修改开平方剪枝：
前提条件，
对区间进行开平方，并需要动态维护区间和：
应对
节点中用fmax维护区间最值，modify时区间最值<=1就直接return。
如果节点值最小是1的话，直接通过判断tr[u].sum 与 tr[u].r - tr[u].l +1 是否相等可以确定是否需要剪枝。（区间值全为1）
3.区间染色
普通例题
题链
22ACM集训队-树状数组与线段树基础 - Virtual Judge (vjudge.net)
套路：
lazy代替sum：
前提条件：
题目不需要求区间长度，操作时各种值无优先级，在区间上互相进行区间覆盖操作，求最后的状态。
情景
操作之间存在覆盖，遮挡的影响
之前画的一些线段可能会被后面的一些线段所覆盖
给出每张海报所贴的范围li，ri（1<=li<=ri<=10000000) 。求出最后还能看见多少张海报。
疑问
染过色后lazy被pushdown下移会不会有影响？
：modify经过lazy所在节点时，也就是lazy底下有节点被另外染色了此时lazy下移，这个节点没资格再代表其下的所有节点了。
判断是否颜色相同可以用个pushup，见批量自适应修改里的例题2多种操作里的pushup，但没什么必要。
代码
统计颜色种类及段数。
卡壳点：segment fault
用N作为下标访问元素时要养成写N-1的习惯，防止出现数组越界
#include 离散化例题
离散化，下标很大，值很小
我们看这组数据[1,10],[1,3],[6,10],很明显答案是3
但是离散化之后为[1,4],[1,2],[3,4],答案变成了2
为解决这种问题,我们可以在更新线段树的时候将区间从[l,r]变成[l,r-1],就将区间转化成了[1,3],[1,1],[3,3]这样的树
但是当我们遇到这样的数据[1,3],[1,1],[2,2],[3,3],就会导致区间更新时出错,我们可以将初始数据的r都加上1,就排除了li和ri相等的情况,如果没有这种情况,离散化后的区间也都是一样的
其实这道题数据很弱,不管这样的情况也能过(逃
正解https://www.luogu.com.cn/paste/vl2ora2z
#include 区别
区间等值修改里，
lazy存的是子树中所有节点要修改的值或要修改成的值，根据题意决定初始化的值，如例题1中批量+v操作，初始化为0，例题2批量替换，初始化为v的定义域之外的值。
sum存的是子树所有节点sum的总和 ，一般初始化为0.
是一个修改时给节点打上lazy，遇到lazy时解开lazy的过程。
区间自适应修改里，
lazy作为一个bool变量，存的是当前节点是否能代表子树接受修改，根据题意决定初始化的值
sum只有在lazy为1时有实际意义，
存的是这颗所有节点的值都相同的子树里的这个相同的值
修改值时，直接修改节点的值