简述难点
这种题极其友（e）好（xin），基本上就是 \(pushup\)，\(build\)，\(pushdown\)，\(update\)，\(query\)，传统线段树五套餐伺候，但是要维护的信息极多，关键还不太能想到要怎么样维护信息，而且维护代码极长。
题目一 子区间最大公约数
NC15557 连续区间的最大公约数
这道题没有修改，只有查询。查询最大公约数还是比较简单的，但是查询子区间的最大公约数也等于整个区间的最大公约数的数量，这就不这么快乐了。假设我们两个孩子区间的 \(gcd\) 和 他们子区间满足条件的数目 \(cnt_l,cnt_r\)，要合并成父亲区间，父亲区间的 \(gcd\) 就是对两孩子的 \(gcd\) 再取一个 \(gcd\) ，但是满足这个新的 \(gcd\) 的子区间数目没有办法仅从孩子的 \(cnt_l,cnt_r\) 解析出，因为子区间可能是两个孩子区间的一部分,这里我就记这种情况为“中间情况”。所以我们需要在节点中保存更多的信息来维护出“中间情况”。
有一个重要结论，也是做这道题最最关键的一个结论，就是随着区间变长， \(gcd\) 一定是不上升的 。也就是说，一个从端点扩展区间的 \(gcd\) 不可能是中间高两边低的，也不可能是两边高中间低的。那么，我们维护两个向量 \(l、r\) ，分别表示从区间左端点和右端点向另一端扩展的 \(gcd\) 变化情况。先给出定义代码：
struct myPair{
ll gcd, len; //扩展长度
};
struct node{
vectorl,r;
ll noGcdCnt = 0, gcd = 0,len = 0; //不是区间gcd的区间数目，区间gcd，区间长度
}t[maxn<<2];
先解释 \(vector\) 的含义，它的元素类型是我自定义的一个类型。下面的表格可以直观解释它的用法：
可以看出 \(l\) 是区间 \([1,i],i\in[1,7]\) 的 \(gcd\) 和能维持的长度 \(len\) ，在这个例子中 \(l\) 向量有 \(5\) 个元素; \(r\) 意义类似,是从右往左进行扩展。得到了从端点向中间扩展的 \(gcd\) 变化情况，加上一个 \(noGcdCnt\) 变量表示不是这个区间 \(gcd\) 的区间数目,即区间内部的情况，这三者就可以求出合并后新区间的 \(noGcdCnt\) 。也就是说，我们通过两孩子向量的扩展求出“中间情况”，通过两孩子的 \(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;
}
可能你会不太理解后面怎么计算“中间情况”，为什么不是两个向量同时从中间开始扩展，而是右区间向量一开始就在另一端？原因就是这样可以保证不漏区间的情况下时间复杂度最短。还记得上面那个结论吗？随着区间变长， \(gcd\) 一定是不上升的。所以如果下面这个条件成立：
Gcd(rr.l[last].gcd,r[i].gcd) == fa.gcd
那么对于所有大于等于 \(i\) 的左区间向量与右区间构成的中间区间 \(gcd\) 一定等于父亲的 \(gcd\) ，因为如果不等于的话只有可能是比父亲的 \(gcd\) 要小，这是不可能的，因为父亲的 \(gcd\) 已经是最小的了（区间长度最长），而这部分区间我们是要减掉的。所以减掉是正确的，因为后面用不到了。这样时间复杂度就是两个向量的长度和了。
来看一下这个帮了我们大忙的向量是怎么维护出来的,会比刚才维护 \(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} );
这里就是模拟一下扩展过程就行了，注意延长的条件。
剩下的和普通线段树差不多，没了修改就不需要 \(pushdown\) 和懒标记了。注意我是在建树的时候读入的，查询的时候返回的是一个节点。
\(Code\):
#include
using namespace std;
#define For(i,sta,en) for(int i = sta;i <= en;i++)
#define ls now<<1
#define rs now<<1|1
#define mid (l+r)/2
#define speedUp_cin_cout ios::sync_with_stdio(false);cin.tie(0); cout.tie(0);
typedef long long ll;
typedef __int128 lll;
const int maxn = 1e5+9;
int n,m,num[maxn];
ll Gcd(ll a,ll b){
if(a == 0) return b;
if(b == 0) return a;
while(b^=a^=b^=a%=b);
return a;
}
struct myPair{
ll gcd, len;
};
struct node{
vectorl,r;
ll noGcdCnt = 0, gcd = 0,len = 0;//不是区间gcd的区间数目，区间gcd，区间长度
//重载 + 运算符，用于合并本节点（左孩子）和另一个结点rr（右孩子），注意本节点在左边，rr在右边，返回新节点
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;
}
//父亲先继承左区间的左向量，右区间的右向量
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} );
return fa;
}
}t[maxn<<2];
void build(int now,int l,int r){
if(l == r){
t[now].len = 1;
t[now].noGcdCnt = 0;
cin>>t[now].gcd; //从这里读入数据，一个数gcd就是它本身
t[now].l.clear();
t[now].r.clear();
t[now].l.push_back({t[now].gcd,1});t[now].r.push_back({t[now].gcd,1});
return;
}
build(ls,l,mid);
build(rs,mid+1,r);
t[now] = t[ls] + t[rs]; //合并，相当于pushup
}
//注意返回的是一个节点
node query(int now,int l,int r,int x,int y){
if(x <= l&& r <= y ) return t[now];
node lef,rig;
rig.len = lef.len = -1;
if(x <= mid) lef = query(ls,l,mid,x,y);
if(y > mid) rig = query(rs,mid+1,r,x,y);
if(lef.len == -1) return rig; //无左区间
else if(rig.len == -1) return lef; //无右区间
return lef + rig; //左右区间都有，合并
}
int main(){
speedUp_cin_cout
int T,cas=0;int l,r;
cin>>T;
while( T-- ){
cout<<"Case #"<<(++cas)<<":"<>n;
build(1,1,n);
cin>>m;
while( m-- ){
cin>>l>>r;
node ans=query(1,1,n,l,r);
//区间左右可能的子区间数 - 不等于gcd的子区间数 = 等于gcd的子区间数
cout< 题目二 覆盖反转操作
- 牛客网 ：NC20279 [SCOI2010]序列操作
- 洛谷 ：P2572 [SCOI2010]序列操作
牛客做的人比较少，建议在洛谷上做。
3个操作，2个查询，线段树模拟大题。来想一想要维护什么信息。首先，\(0\) 和 \(1\)在这道题中反复转换，所以每种信息肯定给 \(0\) 和 \(1\) 分别维护一份，这样在反转时直接 \(swap\) 交换即可，用一个只有两个元素的数组搞定。
然后考虑查询 \(3\) 要维护的信息。 可以知道我们要维护每一个区间 \(0\) 和 \(1\) 的数目 \(cnt\) ，这还是比较好操作的，合并的时候直接加起来就好了，如果全部要变成 \(0\) 或 \(1\) ，就把这个数目改为区间长度。区间长度就等于 \(0\) 和 \(1\) 的数目之和 。
接着思考查询 \(4\) 要维护的信息，我们要维护最大连续的 \(0\) 和 \(1\) 的长度 \(len\) ，并且要让合并的时候也可以维护这个长度。根据上一道题的经验，我们可以维护两个从端点向中间扩展的最大长度，这样合并的时候最大连续长度就可以取以下三者的最大值：
①左区间 \(len_l\)。
②右区间 \(len_r\)。
③“中间情况”：从左区间的右端点向左扩展的最大连续长度 \(+\) 从右区间的左端点向右扩展最大连续长度。
最后涉及到区间修改，我们还要有一个状态懒标记 \(state\) ，我这里定义了它的四种情况：
① \(-1\) 表示没有发生过修改的状态。
② \(0\) 表示全部覆盖为0的状态。
③ \(1\) 表示全部覆盖为1的状态。
④ \(2\) 表示0和1反转状态。
好了，剩下就是漫长的模拟了，需要细心地打下每一个函数，为 \(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);
}
然后是有点烦人的 \(pushup\) ，注意我推荐是用一个 \(for\) 循环来节省代码量 ，因为 \(0\) 和 \(1\) 是处理是完全一样的，并且检查方便。我之前是复制后把0改成1，\(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];
}
}
然后是修改和 \(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;
}
主函数比较简单，我直接给出完整代码了。
\(Code\):
#include
using namespace std;
#define For(i,sta,en) for(int i = sta;i <= en;i++)
#define ls now<<1
#define rs now<<1|1
#define mid (l+r)/2
#define speedUp_cin_cout ios::sync_with_stdio(false);cin.tie(0); cout.tie(0);
const int maxn = 1e5+9;
struct node{
//状态，0或1连续的长度，0或1的数量，从两边扩展0或1的最大长度
int state,len[2],cnt[2],l[2],r[2];
}t[maxn<<2];
int n,m;
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];
}
}
void pushdown(int now,int len){
//全是0或者1状态
if(t[now].state == 0 || t[now].state == 1)
for(int i = 0;i <= 1;i++){
//全为0或者1
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;
}
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);
}
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);
}
//查询区间[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;
}
int main(){
speedUp_cin_cout
cin>>n>>m;int op,l,r;
build(1,1,n);
For(i,1,m){
cin>>op>>l>>r;
if(op <= 2) update(1,1,n,l+1,r+1,op);
else if(op == 3) cout< 这道题最好还是自己打过一遍，可以大大提高自己对线段树的理解。如果有发现哪里有笔误或者代码问题都可以找我，我也只是一个刚刚学线段树不够两周的小蒟蒻，希望得到各位的指点。