【BZOJ 1858】 [Scoi2010]序列操作

1858: [Scoi2010]序列操作

Time Limit: 10 Sec Memory Limit: 64 MB
Submit: 1368 Solved: 712
[Submit][Status][Discuss]
Description

lxhgww最近收到了一个01序列，序列里面包含了n个数，这些数要么是0，要么是1，现在对于这个序列有五种变换操作和询问操作： 0 a b 把[a, b]区间内的所有数全变成0 1 a b 把[a, b]区间内的所有数全变成1 2 a b 把[a,b]区间内的所有数全部取反，也就是说把所有的0变成1，把所有的1变成0 3 a b 询问[a, b]区间内总共有多少个1 4 a b 询问[a, b]区间内最多有多少个连续的1 对于每一种询问操作，lxhgww都需要给出回答，聪明的程序员们，你们能帮助他吗？
Input

输入数据第一行包括2个数，n和m，分别表示序列的长度和操作数目 第二行包括n个数，表示序列的初始状态 接下来m行，每行3个数，op, a, b，（0<=op<=4，0<=a<=b
Output

对于每一个询问操作，输出一行，包括1个数，表示其对应的答案
Sample Input

10 10

0 0 0 1 1 0 1 0 1 1

1 0 2

3 0 5

2 2 2

4 0 4

0 3 6

2 3 7

4 2 8

1 0 5

0 5 6

3 3 9

Sample Output

5

2

6

5

HINT

对于30%的数据，1<=n, m<=1000
对于100%的数据，1<=n, m<=100000
Source

Day2

线段树操作。

对于每一个结点，要维护：
①0和1的左端，右端，整段的最长连续长度
（维护0的是因为会有反转操作）

②区间和

③是否被反转，是否被全部修改
对于反转和修改的顺序：
如果当前是修改，之前的一切标记都清空；
如果当前是反转，那么需要将区间反转。
也就是说，如果一个区间同时有修改和反转操作时，一定是先修改再反转。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#define M 100005
using namespace std;
int n,m,a[M];
struct Segtree
{
    int L,R,m[2],l[2],r[2],s,rev,c;
}t[M*5];
void read(int &tmp)
{
    tmp=0;
    char ch=getchar();
    for (;ch<'0'||ch>'9';ch=getchar());
    for (;ch>='0'&&ch<='9';ch=getchar())
        tmp=tmp*10+ch-'0';
}
Segtree Push_up(Segtree a,Segtree b)
{
    Segtree ans;
    ans.L=a.L,ans.R=b.R;
    ans.s=a.s+b.s;
    ans.rev=0,ans.c=-1;
    for (int i=0;i<2;i++)
    {
        ans.l[i]=a.l[i];
        if (a.l[i]==a.R-a.L+1)
            ans.l[i]+=b.l[i];
        ans.r[i]=b.r[i];
        if (b.r[i]==b.R-b.L+1)
            ans.r[i]+=a.r[i];
        ans.m[i]=max(a.m[i],max(b.m[i],a.r[i]+b.l[i]));
    }
    return ans;
}
void Push_down(int x)
{
    if (!t[x].rev&&t[x].c==-1) 
        return;
    if (t[x].rev&&t[x].c!=-1)
        t[x].rev=0,t[x].c^=1;
    if (t[x].rev)
    {
        for (int i=(x<<1);i<=(x<<1|1);i++)
            swap(t[i].l[0],t[i].l[1]),
            swap(t[i].r[0],t[i].r[1]),
            swap(t[i].m[0],t[i].m[1]),
            t[i].rev^=1,
            t[i].s=t[i].R-t[i].L+1-t[i].s;
        t[x].rev=0;
    }
    else
    {
        int k=t[x].c;
        for (int i=(x<<1);i<=(x<<1|1);i++)
        {
            int cnt=t[i].R-t[i].L+1;
            t[i].s=k*cnt;
            int p=k;
            for (int j=1;j<=2;j++)
            {
                t[i].l[p]=t[i].r[p]=t[i].m[p]=cnt;
                cnt=0,p^=1;
            }
            t[i].c=k,t[i].rev=0;
        }
        t[x].c=-1;
    }
}
void Build(int x,int l,int r)
{
    t[x].L=l,t[x].R=r;
    if (l==r)
    {
        t[x].c=-1,t[x].rev=0;
        t[x].s=a[l];
        if (a[l]==0) t[x].l[0]=t[x].r[0]=t[x].m[0]=1;
        else t[x].l[1]=t[x].r[1]=t[x].m[1]=1;
        return;
    }
    int m=(l+r)>>1;
    Build(x<<1,l,m);
    Build(x<<1|1,m+1,r);
    t[x]=Push_up(t[x<<1],t[x<<1|1]);
}
void Modify(int x,int l,int r,int k)
{
    if (t[x].L>=l&&t[x].R<=r)
    {
        int cnt=t[x].R-t[x].L+1;
        t[x].s=k*cnt;
        int p=k;
        for (int i=1;i<=2;i++)
        {
            t[x].l[p]=t[x].r[p]=t[x].m[p]=cnt;
            cnt=0,p^=1;
        }
        t[x].c=k,t[x].rev=0;
        return;
    }
    Push_down(x);
    int m=(t[x].L+t[x].R)>>1;
    if (l<=m)
        Modify(x<<1,l,r,k);
    if (r>m)
        Modify(x<<1|1,l,r,k);
    t[x]=Push_up(t[x<<1],t[x<<1|1]);
}
void Reverse(int x,int l,int r)
{
    if (t[x].L>=l&&t[x].R<=r)
    {
        swap(t[x].l[0],t[x].l[1]),
        swap(t[x].r[0],t[x].r[1]),
        swap(t[x].m[0],t[x].m[1]);
        t[x].s=t[x].R-t[x].L+1-t[x].s;
        t[x].rev^=1;
        return;
    }
    Push_down(x);
    int m=(t[x].L+t[x].R)>>1;
    if (l<=m)
        Reverse(x<<1,l,r);
    if (r>m)
        Reverse(x<<1|1,l,r);
    t[x]=Push_up(t[x<<1],t[x<<1|1]);
}
int Getsum(int x,int l,int r)
{
    if (t[x].L>=l&&t[x].R<=r)
        return t[x].s;
    Push_down(x);
    int m=(t[x].L+t[x].R)>>1,ans=0;
    if (l<=m) ans+=Getsum(x<<1,l,r);
    if (r>m) ans+=Getsum(x<<1|1,l,r);
    return ans;
}
Segtree Getcon(int x,int l,int r)
{
    if (t[x].L>=l&&t[x].R<=r)
        return t[x];
    Push_down(x);
    int m=(t[x].L+t[x].R)>>1;
    if (r<=m) return Getcon(x<<1,l,r);
    if (l>m) return Getcon(x<<1|1,l,r);
    return Push_up(Getcon(x<<1,l,r),Getcon(x<<1|1,l,r)); 
}
int main()
{
    read(n),read(m);
    for (int i=1;i<=n;i++)
        read(a[i]);
    Build(1,1,n);
    for (int i=1;i<=m;i++)
    {
        int op,l,r;
        read(op),read(l),read(r);
        l++,r++;
        switch(op)
        {
            case 0:
                Modify(1,l,r,0);
                break;
            case 1:
                Modify(1,l,r,1);
                break;
            case 2:
                Reverse(1,l,r);
                break;
            case 3:
                printf("%d\n",Getsum(1,l,r));
                break;
            case 4:
                printf("%d\n",Getcon(1,l,r).m[1]);
                break;
        }
    }
    return 0;
}

感悟：
代码中的标记都是用来下传的，因为本区间已经执行过标记了。