序列操作（线段树）

最新推荐文章于 2019-10-22 16:21:12 发布

DZYO

最新推荐文章于 2019-10-22 16:21:12 发布

阅读量553

点赞数

分类专栏：线段树文章标签：线段树

本文链接：https://blog.csdn.net/qq_35649707/article/details/74355414

版权

线段树专栏收录该内容

33 篇文章 0 订阅

订阅专栏

Description

Lxhgww 最近收到了一个 01 序列，序列里面包含了 n（1≤n≤105）个数，这些书要么是 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（1≤m≤105）分别表示序列的长度和操作数目。
第二行包括 n 个数，表示序列的初始状态.
接下来 m 行，每行 3 个数，op，a，b（0≤op≤4，0≤a≤b＜n），表示对于区间[a，b]执行标号为 op 的操作。
Output
对于每次询问，输出单独的一行表示答案。
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
题解：线段树
先忽略掉修改区间的操作，考虑如可统计。对于1的个数，很好统计，
统计区间最长1的时候，考虑维护每个区间的从左边数的1的个数，和从右边数1的个数，以及区间中最长1的个数。
那么对于一个节点，统计最长1的个数时，可以从左右儿子更新， $lgest[k]=max(lgest[k<<1],lgest[k<<1|1],rmax[k<<1]+lmax[k<<1|1])$ 。
接下来考虑修改。
对于翻转操作，需要将区间内0,1对调，那么新维护0的个数，方法同1.
对于清空为0或1，直接打标记即可。
注意这里要考虑标记顺序。
1.如果打rev标记时有01标记，那么下传
2.如果打01标记时有其他标记，则全部清空。（其他标记已经无效，因为全部置为0或1）。
Code

#include<bits/stdc++.h>
using namespace std;

const int Maxn=3e5+50;

inline int read()
{
    char ch=getchar();int i=0,f=1;
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){i=(i<<3)+(i<<1)+ch-'0';ch=getchar();}
    return i*f;
}

int a[Maxn],n,m,L[Maxn],sum0[Maxn],sum1[Maxn],lmax0[Maxn],rmax0[Maxn],lmax1[Maxn],rmax1[Maxn],lgest0[Maxn],lgest1[Maxn],tag0[Maxn],tag1[Maxn],tagrev[Maxn];

inline void update(int k)
{
    int lc=k<<1,rc=k<<1|1;
    L[k]=L[lc]+L[rc];
    lmax0[k]=(lmax0[lc]==L[lc]?lmax0[lc]+lmax0[rc]:lmax0[lc]);
    lmax1[k]=(lmax1[lc]==L[lc]?lmax1[lc]+lmax1[rc]:lmax1[lc]);
    rmax0[k]=(rmax0[rc]==L[rc]?rmax0[rc]+rmax0[lc]:rmax0[rc]);
    rmax1[k]=(rmax1[rc]==L[rc]?rmax1[rc]+rmax1[lc]:rmax1[rc]);
    lgest0[k]=max(rmax0[lc]+lmax0[rc],max(lgest0[lc],lgest0[rc]));
    lgest1[k]=max(rmax1[lc]+lmax1[rc],max(lgest1[lc],lgest1[rc]));
    sum0[k]=sum0[lc]+sum0[rc];
    sum1[k]=sum1[lc]+sum1[rc];
    return;
}

inline void build(int k,int l,int r)
{
    if(l==r)
    {
        if(a[l]==0)
        {
            sum0[k]=L[k]=lmax0[k]=rmax0[k]=lgest0[k]=1;
            sum1[k]=0;
            return;
        }
        else
        {
            sum1[k]=L[k]=lmax1[k]=rmax1[k]=lgest1[k]=1;
            sum0[k]=0;
            return;
        }
    }
    int mid=(l+r)>>1;
    build(k<<1,l,mid);
    build(k<<1|1,mid+1,r);
    update(k);
}

inline void C0(int k)
{
    sum0[k]=lmax0[k]=rmax0[k]=lgest0[k]=L[k];
    sum1[k]=lmax1[k]=rmax1[k]=lgest1[k]=0;
}

inline void C1(int k)
{
    sum1[k]=lmax1[k]=rmax1[k]=lgest1[k]=L[k];
    sum0[k]=lmax0[k]=rmax0[k]=lgest0[k]=0;
}

inline void Rev(int k)
{
    swap(sum0[k],sum1[k]);
    swap(lmax0[k],lmax1[k]);
    swap(rmax0[k],rmax1[k]);
    swap(lgest0[k],lgest1[k]);
    return;
}

inline void Addtag0(int k);
inline void Addtag1(int k);
inline void Addtagrev(int k,int l,int r);

inline void pushdown1(int k,int l,int r)
{
    tag1[k]=0;
    if(l==r)return;
    int mid=(l+r)>>1;
    Addtag1(k<<1);
    Addtag1(k<<1|1);
}

inline void pushdown0(int k,int l,int r)
{
    tag0[k]=0;
    if(l==r)return;
    int mid=(l+r)>>1;
    Addtag0(k<<1);
    Addtag0(k<<1|1);
}

inline void pushdownrev(int k,int l,int r)
{
    tagrev[k]^=1;
    if(l==r)return;
    int mid=(l+r)>>1;
    Addtagrev(k<<1,l,mid);
    Addtagrev(k<<1|1,mid+1,r);
}

inline void Addtag0(int k)
{
    tag1[k]=tagrev[k]=0;
    tag0[k]=1;
    C0(k);
}

inline void Addtag1(int k)
{
    tag0[k]=tagrev[k]=0;
    tag1[k]=1;
    C1(k);
}

inline void Addtagrev(int k,int l,int r)
{
    if(tag0[k])pushdown0(k,l,r);
    if(tag1[k])pushdown1(k,l,r);
    Rev(k);
    tagrev[k]^=1;
}

inline void clear0(int k,int l,int r,int L,int R)
{
    if(l>=L&&r<=R)
    {
        Addtag0(k);
        return;
    }
    if(tag0[k])pushdown0(k,l,r);
    if(tag1[k])pushdown1(k,l,r);
    if(tagrev[k])pushdownrev(k,l,r);
    int mid=(l+r)>>1;
    if(L<=mid)clear0(k<<1,l,mid,L,R);
    if(R>mid)clear0(k<<1|1,mid+1,r,L,R);
    update(k);
    return;
}

inline void clear1(int k,int l,int r,int L,int R)
{
    if(l>=L&&r<=R)
    {
        Addtag1(k);
        return;
    }
    if(tag0[k])pushdown0(k,l,r);
    if(tag1[k])pushdown1(k,l,r);
    if(tagrev[k])pushdownrev(k,l,r);
    int mid=(l+r)>>1;
    if(L<=mid)clear1(k<<1,l,mid,L,R);
    if(R>mid)clear1(k<<1|1,mid+1,r,L,R);
    update(k);
    return;
}

inline void rev(int k,int l,int r,int L,int R)
{
    if(tag0[k])pushdown0(k,l,r);
    if(tag1[k])pushdown1(k,l,r);
    if(tagrev[k])pushdownrev(k,l,r);
    if(l>=L&&r<=R)
    {
        Addtagrev(k,l,r);
        return;
    }
    int mid=(l+r)>>1;
    if(L<=mid)rev(k<<1,l,mid,L,R);
    if(R>mid)rev(k<<1|1,mid+1,r,L,R);
    update(k);
    return;
}

inline int query1(int k,int l,int r,int L,int R)
{
    if(tag0[k])pushdown0(k,l,r);
    if(tag1[k])pushdown1(k,l,r);
    if(tagrev[k])pushdownrev(k,l,r);
    if(l>=L&&r<=R)return sum1[k];
    int mid=(l+r)>>1,res=0;
    if(L<=mid)res+=query1(k<<1,l,mid,L,R);
    if(R>mid)res+=query1(k<<1|1,mid+1,r,L,R);
    return res;
}

inline int querylgest1(int k,int l,int r,int L,int R)
{
    if(tag0[k])pushdown0(k,l,r);
    if(tag1[k])pushdown1(k,l,r);
    if(tagrev[k])pushdownrev(k,l,r);
    if(l>=L&&r<=R)return lgest1[k];
    int mid=(l+r)>>1;
    int res=0;
    if(L<=mid&&R>mid)
    {
        res+=min(mid-L+1,rmax1[k<<1]);
        res+=min(R-mid,lmax1[k<<1|1]);
    }
    if(L<=mid)res=max(res,querylgest1(k<<1,l,mid,L,R));
    if(R>mid)res=max(res,querylgest1(k<<1|1,mid+1,r,L,R));
    return res;
}

int main()
{
    n=read(),m=read();
    for(int i=1;i<=n;i++){a[i]=read();}
    build(1,1,n);
    while(m--)
    {
        int x=read(),l=read()+1,r=read()+1;
        switch(x)
        {
            case 0:
                {
                    clear0(1,1,n,l,r);
                    break;
                }
            case 1:
                {
                    clear1(1,1,n,l,r);
                    break;
                }
            case 2:
                {
                    rev(1,1,n,l,r);
                    break;
                }
            case 3:
                {
                    cout<<query1(1,1,n,l,r)<<endl;
                    break;
                }
            case 4:
                {
                    cout<<querylgest1(1,1,n,l,r)<<endl;
                    break;
                }
        }
    }
}