【序列操作I】线段树

题目描述

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

输入格式

输入数据第一行包括 2 个数，n 和 m（1≤m≤105）分别表示序列的长度和操作数目。
第二行包括 n 个数，表示序列的初始状态.
接下来 m 行，每行 3 个数，op，a，b（0≤op≤4，0≤a≤b＜n），表示对于区间[a，b]执行标号为 op 的操作。

输出格式

对于每次询问，输出单独的一行表示答案。

样例数据 1

输入

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

输出

5 
2 
6 
5

题目分析

　　线段树裸题，关于区间最大连续的问题，都是维护左端最长连续，右端最长连续，和总的最长连续，更新即可。

　　比较坑的是下标的下放顺序：无论是否有反转标记都可以直接覆盖，把反转标志置为false。但若是有覆盖标记，就必须先进行覆盖标记的下传，再进行反转。

code

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
using namespace std;

const int N = 1e5 + ;
int n, m, data[N];
struct node{
    int len, cnt, tag;
    bool rev;
    int lx0, rx0, lx1, rx1, mx0, mx1;
    node():tag(-){}
};
inline void wr(int);
namespace SegTree{
    node tr[N << ];
    inline void upt(int k){
        tr[k].cnt = tr[k << ].cnt + tr[k <<  | ].cnt;
        tr[k].lx0 = tr[k << ].lx0, tr[k].lx1 = tr[k << ].lx1;
        tr[k].rx0 = tr[k <<  | ].rx0, tr[k].rx1 = tr[k <<  | ].rx1;
        if(tr[k << ].cnt == tr[k << ].len)
            tr[k].lx1 += tr[k <<  | ].lx1;
        if(tr[k << ].cnt == )
            tr[k].lx0 += tr[k <<  | ].lx0;
        if(tr[k <<  | ].cnt == tr[k <<  | ].len)
            tr[k].rx1 += tr[k << ].rx1;
        if(tr[k <<  | ].cnt == )
            tr[k].rx0 += tr[k << ].rx0;
        tr[k].mx0 = max(tr[k << ].mx0, tr[k <<  | ].mx0);
        tr[k].mx0 = max(tr[k].mx0, tr[k << ].rx0 + tr[k <<  | ].lx0);
        tr[k].mx1 = max(tr[k << ].mx1, tr[k <<  | ].mx1);
        tr[k].mx1 = max(tr[k].mx1, tr[k << ].rx1 + tr[k <<  | ].lx1);
    }
    inline void cover(int , int);
    inline void Rev(int k){
        if(tr[k].tag != -){
            if(tr[k].len > )
                cover(k << , tr[k].tag),
                cover(k <<  | , tr[k].tag);
            tr[k].tag = -;
        }
        tr[k].cnt = tr[k].len - tr[k].cnt;
        swap(tr[k].lx1, tr[k].lx0);
        swap(tr[k].rx1, tr[k].rx0);
        swap(tr[k].mx0, tr[k].mx1);
        tr[k].rev ^= ;
    }
    inline void cover(int k, int v){
        tr[k].rev = ;
        tr[k].cnt = tr[k].lx1 = tr[k].rx1 = tr[k].mx1 = (v == ) * tr[k].len;
        tr[k].lx0 = tr[k].rx0 = tr[k].mx0 = (v == ) * tr[k].len;
        tr[k].tag = v;
    }
    inline void pushdown(int k){
        if(tr[k].tag != -){
            if(tr[k].len > )
                cover(k << , tr[k].tag),
                cover(k <<  | , tr[k].tag);
            tr[k].tag = -;
        }
        if(tr[k].rev){
            tr[k].rev = ;
            if(tr[k].len > )
                Rev(k << ),
                Rev(k <<  | );
        }
    }
    inline int queryCnt(int k, int l, int r, int x, int y){
        pushdown(k);
        if(x <= l && r <= y)
            return tr[k].cnt;
        int mid = l + r >> , ret = ;
        if(x <= mid) ret += queryCnt(k << , l, mid, x, y);
        if(y > mid) ret += queryCnt(k <<  | , mid + , r, x, y);
        return ret;
    }
    inline node queryMx(int k, int l, int r, int x, int y){
        pushdown(k);
        if(l == x && r == y) return tr[k];
        int mid = l + r >> ;
        if(y <= mid) return queryMx(k << , l, mid, x, y);
        else if(x > mid) return queryMx(k <<  | , mid + , r, x, y);
        else{
            node ret1 = queryMx(k << , l, mid, x, mid);
            node ret2 = queryMx(k <<  | , mid + , r, mid + , y);
            node ret;
            ret.lx1 = ret1.lx1;
            ret.rx1 = ret2.rx1;
            if(ret1.cnt == ret1.len)
                ret.lx1 += ret2.lx1;
            if(ret2.cnt == ret2.len)
                ret.rx1 += ret1.rx1;
            ret.mx1 = max(ret1.mx1,ret2.mx1);
            ret.mx1 = max(ret.mx1, ret1.rx1 + ret2.lx1);
            return ret;
        }
    }
    inline void build(int k, int l, int r){
        tr[k].len = r - l + ;
        if(l == r){
            tr[k].lx1 = tr[k].rx1 = tr[k].mx1 = tr[k].cnt = (data[l] == );
            tr[k].lx0 = tr[k].rx0 = tr[k].mx0 = (data[l] == );
            tr[k].rev = ;
            tr[k].tag = -;
            return;
        }
        int mid = l + r >> ;
        build(k << , l, mid);
        build(k <<  | , mid + , r);
        upt(k);
    }
    inline void modify(int k, int l, int r, int x, int y, int opt){
        pushdown(k);
        if(x <= l && r <= y){
            switch(opt){
                case : cover(k,  ); break;
                case : cover(k,  ); break;
                case : Rev(k); break;
            }
            return;
        }
        int mid = l + r >> ;
        if(x <= mid) modify(k << , l, mid, x, y, opt);
        if(y > mid) modify(k <<  | , mid + , r, x, y, opt);
        upt(k);
    }
}using namespace SegTree;

inline int read(){
    int i = , f = ; char ch = getchar();
    for(; (ch < '' || ch > '') && ch != '-'; ch = getchar());
    if(ch == '-') f = -, ch = getchar();
    for(; ch >= '' && ch <= ''; ch = getchar())
        i = (i << ) + (i << ) + (ch - '');
    return i * f;
}

inline void wr(int x){
    if(x < ) putchar('-'), x = -x;
    if(x > ) wr(x / );
    putchar(x %  + '');
}

int main(){
    n = read();
    m = read();
    for(int i = ; i <= n; i++)
        data[i] = read();
    build(, , n);
    for(int i = ; i <= m; i++){
        int opt = read();
        int a = read() + , b = read() + ;
        if(opt ==  || opt ==  || opt == )
            modify(, , n, a, b, opt);
        else if(opt == ) wr(queryCnt(, , n, a, b)), putchar('\n');
        else wr((queryMx(, , n, a, b)).mx1), putchar('\n');
    }
    return ;
}