HDU-3397-线段树区间合并（巧用lazy标记）

!

题目链接

题意

​ 给出01区间 5种操作

​ 0就是区间全置0 ，1区间全置1，2 区间反转0-1、1-0 ，3就是求区间有多少个1，4就是求最大连续1的长度

题解

我们可以维护0和1的左连续，右连续，最大连续

然后，有多少个1，我们直接维护就可以，就是左右1的和

然后，主要是区间反转 和 区间置01的关系 ，因为传递lazy的时候，他们直接有关系

反转是一个lazy 01，也是一个lazy

首先，我们可以发现，如果你的区间先反转，在置01的时候，我们可以发现，你以前的反转没有用了

因为，我已经覆盖了01，反转没用了 ，所以，我们在置01的时候，把之前的反转lazy清掉

在update的时候，如果是置01，就把lazy01标上，然后吧反转lazy=0

这样我们在处理pushdown，当一个区间有反转和又有区间覆盖的时候，一定是先覆盖了，在区间反转

所以，我们在 pushdown的时候 ，先把覆盖往下穿，因为你先覆盖啊在反转，所以先处理覆盖

在传覆盖的时候，同时再把反转标记清空

然后在处理反转，传递反转的时候，如果子区间有覆盖了，那么就是父区间刚才传递下去的覆盖

所以这个时候，直接把覆盖反转一下就可以了，否则，我们把反转lazy，反转一下就可以了

AC代码

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
#define N 100005
struct node
{
    int l,r;
    int ls,rs,sum;
    int lazy;
    int ls2,rs2,sum2;
    int lazy01;
    int num;
};
node shu[N<<2];
int a[N];
void pushup(int rt)
{
    shu[rt].ls = shu[rt<<1].ls;
    shu[rt].rs = shu[rt<<1|1].rs;
    if(shu[rt<<1].ls==(shu[rt<<1].r - shu[rt<<1].l + 1))
    {
        shu[rt].ls += shu[rt<<1|1].ls;
    }
    if(shu[rt<<1|1].rs==(shu[rt<<1|1].r - shu[rt<<1|1].l + 1))
    {
        shu[rt].rs += shu[rt<<1].rs;
    }
    shu[rt].sum = max(max(shu[rt<<1].sum,shu[rt<<1|1].sum),
                      shu[rt<<1].rs+shu[rt<<1|1].ls);
    shu[rt].ls2 = shu[rt<<1].ls2;
    shu[rt].rs2 = shu[rt<<1|1].rs2;
    if(shu[rt<<1].ls2==(shu[rt<<1].r - shu[rt<<1].l + 1))
    {
        shu[rt].ls2 += shu[rt<<1|1].ls2;
    }
    if(shu[rt<<1|1].rs2==(shu[rt<<1|1].r - shu[rt<<1|1].l + 1))
    {
        shu[rt].rs2 += shu[rt<<1].rs2;
    }
    shu[rt].sum2 = max(max(shu[rt<<1].sum2,shu[rt<<1|1].sum2),
                       shu[rt<<1].rs2+shu[rt<<1|1].ls2);
    shu[rt].num = shu[rt<<1].num+shu[rt<<1|1].num;
}
void build(int rt,int l,int r)
{
    shu[rt].l = l,shu[rt].r = r;
    shu[rt].lazy = 0;
    shu[rt].lazy01 = -1;
    if(l==r)
    {
        if(a[l])
        {
            shu[rt].ls = shu[rt].rs = shu[rt].sum = 1;
            shu[rt].ls2 = shu[rt].rs2 = shu[rt].sum2 = 0;
            shu[rt].num = 1;
        }
        else
        {
            shu[rt].ls = shu[rt].rs = shu[rt].sum = 0;
            shu[rt].ls2 = shu[rt].rs2 = shu[rt].sum2 = 1;
            shu[rt].num = 0 ;
        }
        return;
    }
    int mid = (l+r)>>1;
    build(rt<<1,l,mid);
    build(rt<<1|1,mid+1,r);
    pushup(rt);
}
void pushdown(int rt)
{
    int v = shu[rt].lazy01;
    int len1 = shu[rt<<1].r - shu[rt<<1].l +1;
    int len2 = shu[rt<<1|1].r - shu[rt<<1|1].l +1;
    if(v != -1)
    {
        shu[rt<<1].ls = shu[rt<<1].rs = shu[rt<<1].sum =  shu[rt<<1].num = (v?len1:0);
        shu[rt<<1].ls2 = shu[rt<<1].rs2 = shu[rt<<1].sum2 = (v?0:len1);
        shu[rt<<1|1].ls = shu[rt<<1|1].rs = shu[rt<<1|1].sum = shu[rt<<1|1].num =
                                                (v?len2:0);
        shu[rt<<1|1].ls2 = shu[rt<<1|1].rs2 = shu[rt<<1|1].sum2 = (v?0:len2);
        shu[rt<<1].lazy = shu[rt<<1|1].lazy = 0 ; //注销子区间的反转 因为有覆盖了
        shu[rt<<1].lazy01 = shu[rt<<1|1].lazy01 = v ;
        shu[rt].lazy01 = -1;
    }
    if(shu[rt].lazy)
    {
        if(shu[rt<<1].lazy01>=0) //覆盖反转覆盖 因为有覆盖不用看反转
        {
            shu[rt<<1].lazy01 = 1 - shu[rt<<1].lazy01;
        }
        else shu[rt<<1].lazy ^= 1; //否则反转反转标记
        if(shu[rt<<1|1].lazy01>=0)
        {
            shu[rt<<1|1].lazy01 = 1 - shu[rt<<1|1].lazy01;
        }
        else shu[rt<<1|1].lazy ^= 1;
        shu[rt<<1].num = len1 - shu[rt<<1].num;
        shu[rt<<1|1].num = len2 - shu[rt<<1|1].num;
        swap(shu[rt<<1].ls,shu[rt<<1].ls2);
        swap(shu[rt<<1].rs,shu[rt<<1].rs2);
        swap(shu[rt<<1].sum,shu[rt<<1].sum2);
        swap(shu[rt<<1|1].ls,shu[rt<<1|1].ls2);
        swap(shu[rt<<1|1].rs,shu[rt<<1|1].rs2);
        swap(shu[rt<<1|1].sum,shu[rt<<1|1].sum2);
        shu[rt].lazy = 0;
    }
}
int Find(int rt,int l,int r)
{
    int L = shu[rt].l, R = shu[rt].r;
    if(L==l&&R==r)
    {
        return shu[rt].sum;
    }
    pushdown(rt);
    int ans = 0;
    int mid = (L+R)>>1;
    if(r<=mid)
    {
        ans = Find(rt<<1,l,r);
    }
    else if(l>mid)
    {
        ans = Find(rt<<1|1,l,r);
    }
    else
    {
        int v1 = Find(rt<<1,l,mid);
        int v2 = Find(rt<<1|1,mid+1,r);
        int v3 = min(shu[rt<<1].rs, mid-l+1) + min(shu[rt<<1|1].ls,r-mid-1+1);
        int v4 = max(v1,v2);
        ans = max(v3,v4);
    }
    pushup(rt);
    return ans;
}
int query(int rt,int l,int r)
{
    int L = shu[rt].l, R = shu[rt].r;
    if(l<=L&&R<=r)
    {
        return shu[rt].num;
    }
    else
    {
        pushdown(rt);
        int ans = 0;
        int mid = (L+R)>>1;
        if(l<=mid) ans+=query(rt<<1,l,r);
        if(r>mid) ans+= query(rt<<1|1,l,r);
        pushup(rt);
        return ans;
    }
}
void update01(int rt,int l,int r,int val)
{
    int L = shu[rt].l, R = shu[rt].r;
    if(l<=L&&R<=r)
    {
        if(val == 2)
        {
            swap(shu[rt].ls,shu[rt].ls2);
            swap(shu[rt].rs,shu[rt].rs2);
            swap(shu[rt].sum,shu[rt].sum2);
            shu[rt].num = (R-L+1) - shu[rt].num;
            shu[rt].lazy ^=1;
        }
        else
        {
            int k = R-L+1;
            shu[rt].ls = shu[rt].rs = shu[rt].sum = shu[rt].num = (val?k:0);
            shu[rt].ls2 = shu[rt].rs2 = shu[rt].sum2  =(val?0:k);
            shu[rt].lazy01 = val;
            shu[rt].lazy = 0;
        }
    }
    else
    {
        pushdown(rt);
        int mid = (L+R)>>1;
        if(l<=mid) update01(rt<<1,l,r,val);
        if(mid<r) update01(rt<<1|1,l,r,val);
        pushup(rt);
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n,m;
        scanf("%d%d",&n,&m);
        memset(shu,0,sizeof(shu));
        for(int i=1; i<=n; i++)
        {
            scanf("%d",&a[i]);
        }
        build(1,1,n);
        while(m--)
        {
            int x,l,r;
            scanf("%d%d%d",&x,&l,&r);
            l++,r++;
            if(x<=2)
            {
                update01(1,l,r,x);
            }
            else if(x==3)
            {
                printf("%d\n",query(1,l,r));
            }
            else if(x==4)
            {
                printf("%d\n",Find(1,l,r));
            }
        }
    }
}