HDU - 3397 Sequence operation(线段树)

这个题确实不该说难，只是把各种操作合并到了一个题里，也就麻烦了很多。

感觉这是一个不错的新手的线段树练手题，线段树专题的初步练习也快结束了，这个题帮我很好的理解了懒惰标记的意义。

WA了很多次，主要是pushdown里对懒惰标记的下推维护。

/********************************
*hardbird's Personal Training   *
*Segment Tree                   *
*HDU - 3397 Sequence operation  *
*2014.11.20                     *
********************************/

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
using namespace std;
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
const int maxn=100100;
int cov[maxn<<2], col[maxn<<2];//分别表示是否被01覆盖，是否xor
int num0[maxn<<2], num1[maxn<<2];//区间内0的总数，区间内1的总数
int lsum1[maxn<<2], rsum1[maxn<<2], msum1[maxn<<2];//分别表示左边、右边、最多有多少个连续的1
int lsum0[maxn<<2], rsum0[maxn<<2], msum0[maxn<<2];//分别表示左边、右边、最多有多少个连续的0

void pushup(int l, int r, int rt)
{
    int m=r-l+1;
    num1[rt]=num1[rt<<1]+num1[rt<<1|1];
    lsum1[rt]=lsum1[rt<<1];
    rsum1[rt]=rsum1[rt<<1|1];
    if(lsum1[rt]==m-(m>>1))lsum1[rt]+=lsum1[rt<<1|1];
    if(rsum1[rt]==m>>1)rsum1[rt]+=rsum1[rt<<1];
    msum1[rt]=max(rsum1[rt<<1]+lsum1[rt<<1|1], max(msum1[rt<<1], msum1[rt<<1|1]));

    num0[rt]=num0[rt<<1]+num0[rt<<1|1];
    lsum0[rt]=lsum0[rt<<1];
    rsum0[rt]=rsum0[rt<<1|1];
    if(lsum0[rt]==m-(m>>1))lsum0[rt]+=lsum0[rt<<1|1];
    if(rsum0[rt]==m>>1)rsum0[rt]+=rsum0[rt<<1];
    msum0[rt]=max(rsum0[rt<<1]+lsum0[rt<<1|1], max(msum0[rt<<1], msum0[rt<<1|1]));
}
void build(int l, int r, int rt)
{
    cov[rt]=-1;
    col[rt]=0;
    num1[rt]=lsum1[rt]=rsum1[rt]=msum1[rt]=0;
    num0[rt]=lsum0[rt]=rsum0[rt]=msum0[rt]=0;
    if(l==r)
    {
        int tmp;
        scanf("%d", &tmp);
        if(tmp)num1[rt]=lsum1[rt]=rsum1[rt]=msum1[rt]=1;
        else num0[rt]=lsum0[rt]=rsum0[rt]=msum0[rt]=1;
        return ;
    }
    int mid=(l+r)>>1;
    build(lson);
    build(rson);
    pushup(l, r, rt);
}
void pushdown(int l, int r, int rt)
{
    int m=r-l+1;
    if(cov[rt]!=-1)
    {
        cov[rt<<1]=cov[rt<<1|1]=cov[rt];
        col[rt<<1]=col[rt<<1|1]=col[rt]=0;

        num1[rt<<1]=lsum1[rt<<1]=rsum1[rt<<1]=msum1[rt<<1]= cov[rt] ? m-(m>>1) : 0;
        num0[rt<<1]=lsum0[rt<<1]=rsum0[rt<<1]=msum0[rt<<1]=cov[rt] ? 0 : m-(m>>1);
        num1[rt<<1|1]=lsum1[rt<<1|1]=rsum1[rt<<1|1]=msum1[rt<<1|1]= cov[rt] ? m>>1 : 0;
        num0[rt<<1|1]=lsum0[rt<<1|1]=rsum0[rt<<1|1]=msum0[rt<<1|1]= cov[rt] ? 0 : m>>1;

        cov[rt]=-1;
    }
    if(col[rt])
    {
        col[rt<<1]^=1;
        col[rt<<1|1]^=1;
        if(col[rt<<1] && cov[rt<<1]!=-1)cov[rt<<1]^=1, col[rt<<1]=0;
        if(col[rt<<1|1] && cov[rt<<1|1]!=-1)cov[rt<<1|1]^=1, col[rt<<1|1]=0;

        swap(num0[rt<<1], num1[rt<<1]);
        swap(lsum1[rt<<1], lsum0[rt<<1]);
        swap(rsum1[rt<<1], rsum0[rt<<1]);
        swap(msum1[rt<<1], msum0[rt<<1]);

        swap(num0[rt<<1|1], num1[rt<<1|1]);
        swap(lsum1[rt<<1|1], lsum0[rt<<1|1]);
        swap(rsum1[rt<<1|1], rsum0[rt<<1|1]);
        swap(msum1[rt<<1|1], msum0[rt<<1|1]);
        col[rt]=0;
    }
}

void XOR(int L, int R, int l, int r, int rt)
{
    if(L<=l && R>=r)
    {
        if(cov[rt]!=-1)
        {
            cov[rt]^=1;
            col[rt]=0;

            num1[rt]=lsum1[rt]=rsum1[rt]=msum1[rt]= cov[rt] ? r-l+1 : 0 ;
            num0[rt]=lsum0[rt]=rsum0[rt]=msum0[rt]= cov[rt] ? 0 : r-l+1 ;
        }
        else
        {
            swap(num1[rt], num0[rt]);
            swap(lsum1[rt], lsum0[rt]);
            swap(rsum1[rt], rsum0[rt]);
            swap(msum1[rt], msum0[rt]);
            col[rt]^=1;
        }
        return ;
    }
    pushdown(l ,r, rt);
    int mid=(l+r)>>1;
    if(L<=mid)XOR(L, R, lson);
    if(R>mid)XOR(L, R, rson);
    pushup(l, r, rt);
}
void update(int L, int R, int v, int l, int r, int rt)
{
    if(L<=l && R>=r)
    {
        col[rt]=0;
        cov[rt]=v;

        num1[rt]=lsum1[rt]=rsum1[rt]=msum1[rt]= cov[rt] ? r-l+1 : 0 ;
        num0[rt]=lsum0[rt]=rsum0[rt]=msum0[rt]= cov[rt] ? 0 : r-l+1 ;
        return ;
    }
    pushdown(l, r, rt);
    int mid=(l+r)>>1;
    if(L<=mid)update(L, R, v, lson);
    if(R>mid)update(L, R, v, rson);
    pushup(l, r, rt);
}
int query_sum(int L, int R, int l, int r, int rt)
{
    if(L<=l && R>=r)
        return num1[rt];
    pushdown(l, r, rt);
    int mid=(l+r)>>1, ans=0;
    if(L<=mid)ans+=query_sum(L, R, lson);
    if(R>mid)ans+=query_sum(L, R, rson);
    return ans;
}
int query_max_len(int L, int R, int l, int r, int rt)
{
    if(L<=l && R>=r)
        return msum1[rt];
    pushdown(l, r, rt);
    int mid=(l+r)>>1;
    if(R<=mid)return query_max_len(L, R, lson);
    if(L>mid)return query_max_len(L, R, rson);
    return max(max(query_max_len(L, R, lson), query_max_len(L, R, rson)), min(rsum1[rt<<1], mid-L+1)+min(lsum1[rt<<1|1], R-mid));
}

int main()
{
    int T;
    int n, m;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d", &n, &m);
        build(0, n-1, 1);
        while(m--)
        {
            int op, a, b;
            scanf("%d%d%d", &op, &a, &b);
            if(op==0 || op==1)
                update(a, b, op, 0, n-1, 1);
            else if(op==2)
                XOR(a, b, 0, n-1, 1);
            else if(op==3)
                printf("%d\n", query_sum(a, b, 0, n-1, 1));
            else printf("%d\n", query_max_len(a, b, 0, n-1, 1));
        }
    }
    return 0;
}