线段树合并+模拟大题
更好的观看体验
简述难点
这种题极其友（e）好（xin），基本上就是 p u s h u p pushup pushup， b u i l d build build， p u s h d o w n pushdown pushdown， u p d a t e update update， q u e r y query query，传统线段树五套餐伺候，但是要维护的信息极多，关键还不太能想到要怎么样维护信息，而且维护代码极长，特别建议刚刚入门线段树来锻炼一下。
题目一 子区间最大公约数
NC15557 连续区间的最大公约数
这道题没有修改，只有查询。查询最大公约数还是比较简单的，但是查询子区间的最大公约数也等于整个区间的最大公约数的数量，这就不这么快乐了。假设我们两个孩子区间的 g c d gcd gcd 和 他们子区间满足条件的数目 c n t l , c n t r cnt_l,cnt_r cntl,cntr，要合并成父亲区间，父亲区间的 g c d gcd gcd 就是对两孩子的 g c d gcd gcd 再取一个 g c d gcd gcd ，但是满足这个新的 g c d gcd gcd 的子区间数目没有办法仅从孩子的 c n t l , c n t r cnt_l,cnt_r cntl,cntr 解析出，因为子区间可能是两个孩子区间的一部分,这里我就记这种情况为“中间情况”。所以我们需要在节点中保存更多的信息来维护出“中间情况”。
有一个重要结论，也是做这道题最最关键的一个结论，就是随着区间变长， g c d gcd gcd 一定是不上升的 。也就是说，一个从端点扩展区间的 g c d gcd gcd 不可能是中间高两边低的，也不可能是两边高中间低的。那么，我们维护两个向量 l 、 r l、r l、r ，分别表示从区间左端点和右端点向另一端扩展的 g c d gcd gcd 变化情况。先给出定义代码：
struct myPair{
ll gcd, len; //扩展长度
};
struct node{
vector<myPair>l,r;
ll noGcdCnt = 0, gcd = 0,len = 0; //不是区间gcd的区间数目，区间gcd，区间长度
}t[maxn<<2];
先解释 v e c t o r vector vector 的含义，它的元素类型是我自定义的一个类型。下面的表格可以直观解释它的用法：
可以看出 l l l 是区间 [ 1 , i ] , i ∈ [ 1 , 7 ] [1,i],i\in[1,7] [1,i],i∈[1,7] 的 g c d gcd gcd 和能维持的长度 l e n len len ，在这个例子中 l l l 向量有 5 5 5 个元素; r r r 意义类似,是从右往左进行扩展。得到了从端点向中间扩展的 g c d gcd gcd 变化情况，加上一个 n o G c d C n t noGcdCnt noGcdCnt 变量表示不是这个区间 g c d gcd gcd 的区间数目,即区间内部的情况，这三者就可以求出合并后新区间的 n o G c d C n t noGcdCnt noGcdCnt 。也就是说，我们通过两孩子向量的扩展求出“中间情况”，通过两孩子的 n o G c d C n t noGcdCnt noGcdCnt 求出在孩子区间内部的其他情况。来分析一下这个合并代码求 n o G c d C n t noGcdCnt noGcdCnt 的那部分（还有一部分要求合并的向量，先不写），需要用到结构体运算符重载的知识，不会的可以查一下这方面的知识。
node operator+(const node & rr)const{
node fa; //用于返回的合并节点
fa.gcd = Gcd(gcd, rr.gcd); //新区间gcd是两节点的gcd再取gcd
fa.len = len + rr.len; //长度直接加
/*计算noGcdCnt部分：
* ①判断孩子的gcd是否等于父亲的gcd，等于就直接加上原来的noGcdCnt，
* ②否则孩子任何一个子区间的gcd都不可能等于父亲的gcd，因为父亲的gcd一定是最小的，
* 孩子区间的gcd一定大于等于父亲区间的gcd，
* 假如孩子的一个子区间gcd等于父亲的gcd，但是整体的gcd却大于这个子区间，这是不可能的
* 所以直接加上孩子所有子区间的数目，即(len + 1) * len / 2
* */
fa.noGcdCnt += (fa.gcd == gcd) ? noGcdCnt : (len + 1) * len / 2;
fa.noGcdCnt += (fa.gcd == rr.gcd) ? rr.noGcdCnt : (rr.len + 1) * rr.len / 2;
/*计算“中间情况”
* ① tot记录右区间rr从左端点扩展的子区间 和 左区间从右端点扩展的子区间
* 构成的中间区间的gcd不等于父亲gcd的情况下，右区间rr从左端点扩展的子区间长度(耐心理解一下)。
* ②last记录右区间rr的向量l 最后一个满足上述情况的向量下标。
*/
ll tot = rr.len,last = rr.l.size()-1;
//左区间从它的右端点向左扩展
For(i,0,r.size()-1) {
//子区间构成的区间的gcd如果等于父亲的gcd，减去
while(last >= 0 && Gcd(rr.l[last].gcd,r[i].gcd) == fa.gcd ) tot -= rr.l[last--].len;
//否则加上子区间的子区间所有不等于父亲gcd的数目
fa.noGcdCnt += r[i].len * tot;
}
return fa;
}
可能你会不太理解后面怎么计算“中间情况”，为什么不是两个向量同时从中间开始扩展，而是右区间向量一开始就在另一端？原因就是这样可以保证不漏区间的情况下时间复杂度最短。还记得上面那个结论吗？随着区间变长， g c d gcd gcd 一定是不上升的。所以如果下面这个条件成立：
Gcd(rr.l[last].gcd,r[i].gcd) == fa.gcd
那么对于所有大于等于 i i i 的左区间向量与右区间构成的中间区间 g c d gcd gcd 一定等于父亲的 g c d gcd gcd ，因为如果不等于的话只有可能是比父亲的 g c d gcd gcd 要小，这是不可能的，因为父亲的 g c d gcd gcd 已经是最小的了（区间长度最长），而这部分区间我们是要减掉的。所以减掉是正确的，因为后面用不到了。这样时间复杂度就是两个向量的长度和了。
来看一下这个帮了我们大忙的向量是怎么维护出来的,会比刚才维护 n o G c d C n t noGcdCnt noGcdCnt 好理解。
//父亲先继承左区间的左向量，右区间的右向量
fa.l = l, fa.r = rr.r;
//维护父亲左向量
For(i,0,rr.l.size()-1)
//如果右区间的左向量的一个区间是父亲左向量的倍数（注意谁是谁的倍数），长度延长
if(rr.l[i].gcd % fa.l.back().gcd == 0) fa.l.back().len += rr.l[i].len;
//否则，加入新向量
else fa.l.push_back({
Gcd(rr.l[i].gcd, fa.l.back().gcd), rr.l[i].len} );
//维护父亲右向量，类似
For(i,0,r.size()-1)
if(r[i].gcd % fa.r.back().gcd == 0) fa.r.back().len += r[i].len;
else fa.r.push_back({
Gcd(r[i].gcd, fa.r.back().gcd), r[i].len} );
这里就是模拟一下扩展过程就行了，注意延长的条件。
剩下的和普通线段树差不多，没了修改就不需要 p u s h d o w n pushdown pushdown 和懒标记了。注意我是在建树的时候读入的，查询的时候返回的是一个节点。
C o d e Code Code:
#include题目二 覆盖反转操作
- 牛客网 ：NC20279 [SCOI2010]序列操作
- 洛谷 ：P2572 [SCOI2010]序列操作
牛客做的人比较少，建议在洛谷上做。
3个操作，2个查询，线段树模拟大题。来想一想要维护什么信息。首先， 0 0 0 和 1 1 1在这道题中反复转换，所以每种信息肯定给 0 0 0 和 1 1 1 分别维护一份，这样在反转时直接 s w a p swap swap 交换即可，用一个只有两个元素的数组搞定。
然后考虑查询 3 3 3 要维护的信息。 可以知道我们要维护每一个区间 0 0 0 和 1 1 1 的数目 c n t cnt cnt ，这还是比较好操作的，合并的时候直接加起来就好了，如果全部要变成 0 0 0 或 1 1 1 ，就把这个数目改为区间长度。区间长度就等于 0 0 0 和 1 1 1 的数目之和 。
接着思考查询 4 4 4 要维护的信息，我们要维护最大连续的 0 0 0 和 1 1 1 的长度 l e n len len ，并且要让合并的时候也可以维护这个长度。根据上一道题的经验，我们可以维护两个从端点向中间扩展的最大长度，这样合并的时候最大连续长度就可以取以下三者的最大值：
①左区间 l e n l len_l lenl。
②右区间 l e n r len_r lenr。
③“中间情况”：从左区间的右端点向左扩展的最大连续长度 + + + 从右区间的左端点向右扩展最大连续长度。
最后涉及到区间修改，我们还要有一个状态懒标记 s t a t e state state ，我这里定义了它的四种情况：
① − 1 -1 −1 表示没有发生过修改的状态。
② 0 0 0 表示全部覆盖为0的状态。
③ 1 1 1 表示全部覆盖为1的状态。
④ 2 2 2 表示0和1反转状态。
好了，剩下就是漫长的模拟了，需要细心地打下每一个函数，为 d e b u g debug debug 减轻负担 []~(￣▽￣)~*。看到这里可以自己尝试了，如果有不清楚的可以看我的分部分（介绍顺序不一定是在主函数中定义的顺序）讲解。
首先是节点结构体定义和建树部分：
struct node{
//状态，0或1连续的长度，0或1的数量，从两边扩展0或1的最大长度
int state,len[2],cnt[2],l[2],r[2];
}t[maxn<<2];
void build(int now,int l,int r){
if(l == r){
bool b; cin >> b;
//读入原序列0或1，!b表示取相反，0->1,1->0，也可以用异或
t[now].len[b] = t[now].cnt[b] = t[now].l[b] = t[now].r[b] = 1;
t[now].len[!b] = t[now].cnt[!b] = t[now].l[!b] = t[now].r[!b] =0;
t[now].state = -1;
return;
}
build(ls,l,mid);
build(rs,mid+1,r);
pushup(now);
}
然后是有点烦人的 p u s h u p pushup pushup ，注意我推荐是用一个 f o r for for 循环来节省代码量 ，因为 0 0 0 和 1 1 1 是处理是完全一样的，并且检查方便。我之前是复制后把0改成1， W A WA WA 了好多次才发现是哪里忘记改了。
void pushup(int now){
t[now].state = -1;
int lenL,lenR; //左区间的长度，右区间的长度
lenL = t[ls].cnt[0] + t[ls].cnt[1];
lenR = t[rs].cnt[0] + t[rs].cnt[1];
for(int i = 0;i <= 1;i++){
//0或1的数量
t[now].cnt[i] = t[ls].cnt[i] + t[rs].cnt[i];
//连续的长度在三者取最大
t[now].len[i] = max(t[ls].len[i] ,max(t[rs].len[i],t[ls].r[i]+t[rs].l[i]));
//0或1的延展长度
t[now].l[i] = t[ls].l[i];
t[now].r[i] = t[rs].r[i];
//判断是否左或右区间全是0或1
if(t[ls].l[i] == lenL) t[now].l[i] += t[rs].l[i];
if(t[rs].r[i] == lenR) t[now].r[i] += t[ls].r[i];
}
}
然后是修改和 p u s h d o w n pushdown pushdown 操作，更长，需要考虑到懒标记的变换了。
void update(int now,int l,int r,int x,int y,int op){
if(x <= l && r <= y){
//如果命令是全部变成0，或者命令是反转并且原来全是1，执行的结果是一样的
if(op == 0 || (t[now].state == 1 && op == 2)){
t[now].state = 0;
t[now].cnt[0] = t[now].l[0] = t[now].r[0] = t[now].len[0] = r-l+1;
t[now].cnt[1] =t[now].l[1] = t[now].r[1] = t[now].len[1] = 0;
}else if(op == 1|| (t[now].state == 0 && op == 2)){
t[now].state = 1;
t[now].cnt[1] = t[now].l[1] = t[now].r[1] = t[now].len[1] = r-l+1;
t[now].cnt[0] =t[now].l[0] = t[now].r[0] = t[now].len[0] = 0;
}else{
if(t[now].state == 2) t[now].state = -1;
else t[now].state = 2;
swap(t[now].l[0],t[now].l[1]);swap(t[now].r[0],t[now].r[1]);
swap(t[now].cnt[0],t[now].cnt[1]);swap(t[now].len[0],t[now].len[1]);
}
return;
}
if(t[now].state != -1) pushdown(now, r - l + 1);
if(x <= mid) update(ls,l,mid,x,y,op);
if(y > mid) update(rs,mid+1,r,x,y,op);
pushup(now);
}
void pushdown(int now,int len){
//全是0或者1状态
if(t[now].state == 0 || t[now].state == 1)
for(int i = 0;i <= 1;i++){
if(t[now].state == i){
t[ls].state = t[rs].state = i;
t[ls].len[i] = t[ls].r[i] = t[ls].l[i] = t[ls].cnt[i] = len-len/2;
t[rs].len[i] = t[rs].r[i] = t[rs].l[i] = t[rs].cnt[i] = len/2;
t[ls].len[i^1] = t[ls].r[i^1] = t[ls].l[i^1] = t[ls].cnt[i^1] = 0;
t[rs].len[i^1] = t[rs].r[i^1] = t[rs].l[i^1] = t[rs].cnt[i^1] = 0;
}
}
//全部反转状态
else{
//如果原来就处于反转状态了，就变成正常状态的-1
if(t[ls].state == 2) t[ls].state = -1;
//如果原来是0或者1，就变成相反的状态，0变成1,1,变成0
else if(t[ls].state != -1)t[ls].state ^= 1;
//否则，就是从正常状态变成反转状态2
else t[ls].state = 2;
//右孩子同理处理
if(t[rs].state == 2) t[rs].state = -1;
else if(t[rs].state != -1)t[rs].state ^= 1;
else t[rs].state = 2;
//全部交换，8个swap，左孩子4个，右孩子4个
swap(t[ls].l[0],t[ls].l[1]);swap(t[ls].r[0],t[ls].r[1]);
swap(t[ls].cnt[0],t[ls].cnt[1]);swap(t[ls].len[0],t[ls].len[1]);
swap(t[rs].l[0],t[rs].l[1]);swap(t[rs].r[0],t[rs].r[1]);
swap(t[rs].cnt[0],t[rs].cnt[1]);swap(t[rs].len[0],t[rs].len[1]);
}
t[now].state = -1;
}
然后是两个查询操作：
//查询区间[x,y]中1的数目
int query_tot(int now,int l,int r,int x,int y){
if(x <= l && r <= y) return t[now].cnt[1];
if(t[now].state != -1) pushdown(now, r - l + 1);
int ans = 0;
if(x <= mid) ans += query_tot(ls,l,mid,x,y);
if(y > mid) ans+= query_tot(rs,mid+1,r,x,y);
return ans;
}
//查询区间[x,y]中连续的1最长长度，返回节点
node query_len(int now, int l, int r, int x, int y){
if(x <= l && r <= y) return t[now];
if(t[now].state != -1) pushdown(now, r - l + 1);
int lenL,lenR;
node fa,lef,rig;
if(x <= mid) lef = query_len(ls,l,mid,x,y);
if(y > mid) rig = query_len(rs,mid+1,r,x,y);
//和pushup合并类似
if( x <= mid && y > mid){
lenL = lef.cnt[0] + lef.cnt[1];
lenR = rig.cnt[0] + rig.cnt[1];
for(int i = 0;i <= 1;i++){
//0或1的数量
fa.cnt[i] = lef.cnt[i] + rig.cnt[i];
//连续的长度在三者取最大
fa.len[i] = max(lef.len[i] , max(rig.len[i], lef.r[i] + rig.l[i]));
//0或1的延展长度
fa.l[i] = lef.l[i], fa.r[i] = rig.r[i];
//判断是否左或右区间全是0或1
if(lef.l[i] == lenL) fa.l[i] += rig.l[i];
if(rig.r[i] == lenR) fa.r[i] += lef.r[i];
}
return fa;
}else if(x <= mid) return lef;
else if(y > mid) return rig;
}
主函数比较简单，我直接给出完整代码了。
C o d e Code Code:
#include这道题最好还是自己打过一遍，可以大大提高自己对线段树的理解。如果有发现哪里有笔误或者代码问题都可以找我，我也只是一个刚刚学线段树不够两周的小蒟蒻，希望得到各位的指点。