bzoj千题计划177：bzoj1858: [Scoi2010]序列操作

http://www.lydsy.com/JudgeOnline/problem.php?id=1858

2018 自己写的第1题，一遍过

^_^

元旦快乐

#include<cstdio>
#include<iostream>
#include<algorithm>

using namespace std;

#define N 100001

struct node
{
    int siz;
    int L[],R[],con[];
    int sum[];
    bool rev;
    int cover;
}tr[N<<];

struct node_
{
    int L1,R1,con1;
    int siz;
};

node_ operator + (node_ l,node_ r)
{
    node_ res;
    res.L1=l.L1;
    if(l.L1==l.siz) res.L1+=r.L1;
    res.R1=r.R1;
    if(r.R1==r.siz) res.R1+=l.R1;
    res.con1=max(l.con1,r.con1);
    res.con1=max(res.con1,l.R1+r.L1);
    return res;
}

int x;

int ans;

void read(int &x)
{
    x=; char c=getchar();
    while(!isdigit(c)) c=getchar();
    while(isdigit(c)) { x=x*+c-''; c=getchar(); }
}

void update(int k)
{
    for(int i=;i<=;++i)
    {
        tr[k].L[i]=tr[k<<].L[i];
        if(tr[k<<].L[i]==tr[k<<].siz) tr[k].L[i]+=tr[k<<|].L[i];
        tr[k].R[i]=tr[k<<|].R[i];
        if(tr[k<<|].R[i]==tr[k<<|].siz) tr[k].R[i]+=tr[k<<].R[i];
        tr[k].con[i]=max(tr[k<<].con[i],tr[k<<|].con[i]);
        tr[k].con[i]=max(tr[k].con[i],tr[k<<].R[i]+tr[k<<|].L[i]);
        tr[k].sum[i]=tr[k<<].sum[i]+tr[k<<|].sum[i];
    }
}

void build(int k,int l,int r)
{
    tr[k].cover=-;
    tr[k].siz=r-l+;
    if(l==r)
    {
        read(x);
        tr[k].L[x]++;
        tr[k].R[x]++;
        tr[k].con[x]++;
        tr[k].sum[x]++;
        return;
    }
    int mid=l+r>>;
    build(k<<,l,mid);
    build(k<<|,mid+,r);
    update(k);
}

void reverse(int k)
{
    swap(tr[k].L[],tr[k].L[]);
    swap(tr[k].R[],tr[k].R[]);
    swap(tr[k].con[],tr[k].con[]);
    swap(tr[k].sum[],tr[k].sum[]);
    tr[k].rev^=;
    if(tr[k].cover!=-) tr[k].cover^=;
}

void down_rev(int k)
{
    reverse(k<<);
    reverse(k<<|);
    tr[k].rev^=;
}

void covering(int k,int w)
{
    tr[k].L[w]=tr[k].R[w]=tr[k].con[w]=tr[k].sum[w]=tr[k].siz;
    tr[k].L[w^]=tr[k].R[w^]=tr[k].con[w^]=tr[k].sum[w^]=;
    tr[k].cover=w;
    tr[k].rev=false;
}

void down_cov(int k)
{
    covering(k<<,tr[k].cover);
    covering(k<<|,tr[k].cover);
    tr[k].cover=-;
}

void Cover(int k,int l,int r,int opl,int opr,int w)
{
    if(l>=opl && r<=opr)
    {
        covering(k,w);
        return;
    }
    if(tr[k].rev) down_rev(k);
    if(tr[k].cover!=-) down_cov(k);
    int mid=l+r>>;
    if(opl<=mid) Cover(k<<,l,mid,opl,opr,w);
    if(opr>mid) Cover(k<<|,mid+,r,opl,opr,w);
    update(k);
}

void Reverse(int k,int l,int r,int opl,int opr)
{
    if(l>=opl && r<=opr)
    {
        reverse(k);
        return;
    }
    if(tr[k].rev) down_rev(k);
    if(tr[k].cover!=-) down_cov(k);
    int mid=l+r>>;
    if(opl<=mid) Reverse(k<<,l,mid,opl,opr);
    if(opr>mid) Reverse(k<<|,mid+,r,opl,opr);
    update(k);
}

void query(int k,int l,int r,int opl,int opr)
{
    if(l>=opl && r<=opr)
    {
        ans+=tr[k].sum[];
        return;
    }
    if(tr[k].rev) down_rev(k);
    if(tr[k].cover!=-) down_cov(k);
    int mid=l+r>>;
    if(opl<=mid) query(k<<,l,mid,opl,opr);
    if(opr>mid) query(k<<|,mid+,r,opl,opr);
}

node_ Query(int k,int l,int r,int opl,int opr)
{
    if(l>=opl && r<=opr)
    {
        node_ res;
        res.L1=tr[k].L[];
        res.R1=tr[k].R[];
        res.con1=tr[k].con[];
        res.siz=tr[k].siz;
        return res;
    }
    if(tr[k].rev) down_rev(k);
    if(tr[k].cover!=-) down_cov(k);
    int mid=l+r>>;
    if(opr<=mid) return Query(k<<,l,mid,opl,opr);
    if(opl>mid) return Query(k<<|,mid+,r,opl,opr);
    return Query(k<<,l,mid,opl,opr)+Query(k<<|,mid+,r,opl,opr);
}

int main()
{
    int n,m;
    read(n); read(m);
    build(,,n);
    int ty,l,r;
    while(m--)
    {
        read(ty); read(l); read(r);
        l++; r++;
        switch(ty)
        {
            case  : Cover(,,n,l,r,); break;
            case  : Cover(,,n,l,r,); break;
            case  : Reverse(,,n,l,r); break;
            case  : ans=; query(,,n,l,r); cout<<ans<<'\n'; break;
            case  : printf("%d\n",Query(,,n,l,r).con1); break;
        }
    }
}