学习笔记7:线段树（懒标记+合并子信息）

F - Vacation Query (atcoder.jp)

题目中有两种操作，区间修改和区间查询，带懒标记的线段树刚好专业对口

难点在于如何维护合并时的信息，看似简单的信息维护，但是细节也很多

在本题中我使用了7个变量来维护当前的信息

1.前缀是1的长度

2.前缀是0的长度

3.后缀是1的长度

4.后缀是0的长度

5.区间是1的长度

6.区间是0的长度

7.懒标记

在合并时，我们（在pushup和query都要用到）需要格外注意

当前节点的左节点 前缀1 等于左节点对应 长度 时，需要接上右节点的 前缀1?

当前节点的左节点 前缀0?等于左节点对应 长度 时，需要接上右节点的 前缀0

当前节点的右节点 后缀1 等于右节点对应 长度 时，需要接上左节点的 后缀1?

当前节点的右节点 后缀0?等于右节点对应 长度 时，需要接上左节点的 后缀0

当前节点的 区间1 除了可是 左右节点的区间1，还可以是左节点的后缀1+右节点的前缀1

#include <iostream>
#include <cstring>
#include<array>
#include <algorithm>
using namespace std;

const int N = 1000010;
int n,q;
    string x;
struct Node
{
    int l, r;
    int pre1;
    int pre0;
    int nex1;
    int nex0;
    int edge1;
    int edge0;
    int tag;
}tr[N * 4];

void pushup(int u)
{
    //前缀
    tr[u].pre1=tr[u<<1].pre1;
    if(tr[u].pre1==tr[u<<1].r-tr[u<<1].l+1){
        tr[u].pre1+=tr[u<<1|1].pre1;
    }
    tr[u].pre0=tr[u<<1].pre0;
    if(tr[u].pre0==tr[u<<1].r-tr[u<<1].l+1){
        tr[u].pre0+=tr[u<<1|1].pre0;
    }
    
    //后缀
    tr[u].nex1=tr[u<<1|1].nex1;
    tr[u].nex0=tr[u<<1|1].nex0;
    if(tr[u].nex1==tr[u<<1|1].r-tr[u<<1|1].l+1){
        tr[u].nex1+=tr[u<<1].nex1;
    }
    tr[u].nex0=tr[u<<1|1].nex0;
    if(tr[u].nex0==tr[u<<1|1].r-tr[u<<1|1].l+1){
        tr[u].nex0+=tr[u<<1].nex0;
    }
    
    tr[u].edge1=max(tr[u<<1].edge1,tr[u<<1|1].edge1);
    tr[u].edge1=max(tr[u].edge1,tr[u<<1].nex1+tr[u<<1|1].pre1);
    
    tr[u].edge0=max(tr[u<<1].edge0,tr[u<<1|1].edge0);
    tr[u].edge0=max(tr[u].edge0,tr[u<<1].nex0+tr[u<<1|1].pre0);
}
void pushdown(int u)
{
    if(tr[u].tag){
        tr[u<<1].tag^=tr[u].tag;
        tr[u<<1|1].tag^=tr[u].tag;
        swap(tr[u<<1].pre1,tr[u<<1].pre0);
        swap(tr[u<<1].nex1,tr[u<<1].nex0);
        swap(tr[u<<1].edge1,tr[u<<1].edge0);

        swap(tr[u<<1|1].pre1,tr[u<<1|1].pre0);
        swap(tr[u<<1|1].nex1,tr[u<<1|1].nex0);
        swap(tr[u<<1|1].edge1,tr[u<<1|1].edge0);
        tr[u].tag=0;
    }
}

void build(int u, int l, int r)
{
    if (l == r){
        int now=x[r]-'0';
        tr[u] = {l, r,now,now^1,now,now^1,now,now^1,0};
    } 
    else
    {
        tr[u] = {l, r,0,0,0,0,0,0,0};
        int mid = l + r >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}

void update(int u, int l, int r)
{
    if (tr[u].l >= l && tr[u].r <= r)
    {
        tr[u].tag^=1;
        swap(tr[u].pre1,tr[u].pre0);
        swap(tr[u].nex1,tr[u].nex0);
        swap(tr[u].edge1,tr[u].edge0);
    }
    else
    {
        pushdown(u);
        int mid = tr[u].l + tr[u].r >> 1;
        if (l <= mid) update(u << 1, l, r);
        if (r > mid) update(u << 1 | 1, l, r);
        pushup(u);
    }
}

array<int,3> query(int u, int l, int r)
{
    if (tr[u].l >= l && tr[u].r <= r)
    {
        return {tr[u].pre1,tr[u].edge1,tr[u].nex1}; 
    }
    else
    {
        pushdown(u);
        int mid = tr[u].l + tr[u].r >> 1;
        array<int,3> ans={0,0,0},ll={0,0,0},rr={0,0,0};
        int f=0;
        if (l <= mid ){
            ans = query(u << 1, l, r);
            f=1;
        } 
        if (r > mid){
            rr = query(u << 1 | 1, l, r);
            if(f){
                if(ans[0]==tr[u<<1].r-tr[u<<1].l+1){
                    ans[0]+=rr[0];
                }
                ans[1]=max(ans[1],max(rr[1],ans[2]+rr[0]));
                if(rr[2]==tr[u<<1|1].r-tr[u<<1|1].l+1){
                    ans[2]+=rr[2];
                }else{
                    ans[2]=rr[2];
                }
            }else ans=rr;
        } 
        return ans;
    }
}
signed main(){
    cin>>n>>q;
    cin>>x;
    x="."+x;
    build(1,1,n);
    while(q--){
        int op,l,r;
        cin>>op>>l>>r;
        if(op==1){
            update(1,l,r);
        }else{
            auto t=query(1,l,r);
            int ans=max(t[0],max(t[1],t[2]));
            cout<<ans<<endl;
        }
    }
}

数据结构真难调(