HDU 3397 Sequence operation

裸线段树区间合并，题目本身不难，就是细节处理比较麻烦。

因为涉及到异或运算，所以连续0和连续1的个数都要记录一下。

操作的懒惰标记我只用了一个flag，注意flag更新时的细节，我分了三种情况：

flag == -1 或者 当前操作为0或1：更新时直接赋值。因为0， 1操作都可以直接覆盖前面的操作。

flag == 0或1，当前操作为2(xor)：flag ^= 1。前面标记过0或1，当前操作为异或，那么改变flag标记

flag == 2，当前操作为2(xor): flag = -1。前面只出现过异或运算，没出现过0,1运算。因为异或两次相当于没异或，所以清除标记即可。

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>

using namespace std;

#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

const int MAXN = 100010;

int N, Q, maxLen;
int cnt[ MAXN << 2 ];     // 1 的个数
int len[ MAXN << 2 ];     //最长连续1长度
int len0[ MAXN << 2 ];     //最长连续0长度
int flag[ MAXN << 2 ];    //懒惰标记
int Llen[ MAXN << 2 ];    //左端连续1长度
int Llen0[ MAXN << 2 ];    //左端连续0长度
int Rlen[ MAXN << 2 ];    //右端连续1长度
int Rlen0[ MAXN << 2 ];    //右端连续0长度
bool Lnode[ MAXN << 2 ];  //左端点是否为1
bool Rnode[ MAXN << 2 ];  //右端点是否为1

void PushUp( int rt, int l, int r, int m )
{
    int lc = rt << 1;
    int rc = rt << 1 | 1;

    cnt[rt] = cnt[lc] + cnt[rc];

    Lnode[rt] = Lnode[lc];
    Rnode[rt] = Rnode[rc];

    Llen[rt] = Llen[lc];
    Rlen[rt] = Rlen[rc];

    Llen0[rt] = Llen0[lc];
    Rlen0[rt] = Rlen0[rc];

    if ( Llen[lc] == m - l + 1 ) Llen[rt] += Llen[rc];
    if ( Llen0[lc] == m - l + 1 ) Llen0[rt] += Llen0[rc];

    if ( Rlen[rc] == r - m )     Rlen[rt] += Rlen[lc];
    if ( Rlen0[rc] == r - m )     Rlen0[rt] += Rlen0[lc];

    len[rt] = max( len[lc], len[rc] );
    len0[rt] = max( len0[lc], len0[rc] );
    if ( Rnode[lc] && Lnode[rc] )
    {
        len[rt] = max( len[rt], Rlen[lc] + Llen[rc] );
    }

    if ( !Rnode[lc] && !Lnode[rc] )
    {
        len0[rt] = max( len0[rt], Rlen0[lc] + Llen0[rc] );
    }

    return;
}

void chuli( int op, int rt, int l, int r )
{
    if ( op == 0 )
    {
        cnt[rt] = 0;
        Lnode[rt] = Rnode[rt] = false;
        len[rt] = Llen[rt] = Rlen[rt] = 0;
        len0[rt] = Llen0[rt] = Rlen0[rt] = r - l + 1;
    }
    else if ( op == 1 )
    {
        cnt[rt] = r - l + 1;
        Lnode[rt] = Rnode[rt] = true;
        len[rt] = Llen[rt] = Rlen[rt] = r - l + 1;
        len0[rt] = Llen0[rt] = Rlen0[rt] = 0;
    }
    else
    {
        cnt[rt] = r - l + 1 - cnt[rt];
        Lnode[rt] = !Lnode[rt];
        Rnode[rt] = !Rnode[rt];
        swap( Llen[rt], Llen0[rt] );
        swap( Rlen[rt], Rlen0[rt] );
        swap( len[rt], len0[rt] );
    }
    return;
}

void fuzhi( int rt, int c, int l, int r )
{
    if ( flag[rt] == -1 )
    {
        flag[rt] = c;
        return;
    }
    if ( c == 2 )
    {
        if ( flag[rt] == 0 || flag[rt] == 1 ) flag[rt] ^= 1;
        else if ( flag[rt] == 2 ) flag[rt] = -1;
    }
    else flag[rt] = c;

    return;
}

void PushDown( int rt, int l, int r, int m )
{
    int lc = rt << 1;
    int rc = rt << 1 | 1;
    if ( flag[rt] != -1 )
    {
        if ( flag[rt] == 0 || flag[rt] == 1 ) flag[lc] = flag[rc] = flag[rt];
        else
        {
            fuzhi( lc, flag[rt], l, m );
            fuzhi( rc, flag[rt], m + 1, r );
        }
        chuli( flag[lc], lc, l, m );
        chuli( flag[rc], rc, m + 1, r );
        flag[rt] = -1;
    }
    return;
}

void Build( int l, int r, int rt )
{
    flag[rt] = -1;
    if ( l == r )
    {
        int num;
        scanf( "%d", &num );
        if ( num == 1 )
        {
            cnt[rt] = 1;
            Llen[rt] = Rlen[rt] = len[rt] = 1;
            Llen0[rt] = Rlen0[rt] = len0[rt] = 0;
            Lnode[rt] = Rnode[rt] = true;
        }
        else
        {
            cnt[rt] = 0;
            Llen[rt] = Rlen[rt] = len[rt] = 0;
            Llen0[rt] = Rlen0[rt] = len0[rt] = 1;
            Lnode[rt] = Rnode[rt] = false;
        }
        return;
    }

    int m = ( l + r ) >> 1;
    Build( lson );
    Build( rson );
    PushUp( rt, l, r, m );

    return;
}

void Update( int L ,int R, int c, int l, int r, int rt )
{
    int m = ( l + r ) >> 1;

    if ( L <= l && r <= R )
    {
        fuzhi( rt, c, l, r );
        chuli( flag[rt], rt, l, r );
        return;
    }

    PushDown( rt, l, r, m );

    if ( L <= m ) Update( L, R, c, lson );
    if ( R > m )  Update( L, R, c, rson );
    PushUp( rt, l, r, m );

    return;
}

int Query( int L, int R, int l, int r, int rt )
{

    int m = ( l + r ) >> 1;
    if ( L <= l && r <= R )
    {
        maxLen = max( maxLen, len[rt] );
        return cnt[rt];
    }

    PushDown( rt, l, r, m );

    int ret = 0;
    if ( L <= m ) ret += Query( L, R, lson );
    if ( R > m )  ret += Query( L, R, rson );

    PushUp( rt, l, r, m );

    if ( Lnode[rt << 1 | 1] && Rnode[rt << 1] )
        maxLen = max( maxLen, min( Llen[rt << 1 | 1], R - m ) + min( Rlen[ rt << 1 ], m - L + 1 ) );


    return ret;
}

int main()
{
    //freopen( "in2.txt", "r", stdin );
    //freopen( "out.txt", "w", stdout );
    int T;
    scanf( "%d", &T );
    while ( T-- )
    {
        scanf( "%d%d", &N, &Q );
        Build( 0, N - 1, 1 );
        while ( Q-- )
        {
            int op, a, b;
            scanf( "%d%d%d", &op, &a, &b );
            {
                if ( op < 3 )
                    Update(a, b, op, 0, N - 1, 1 );
                else
                {
                    maxLen = 0;
                    int ans = Query( a, b, 0, N - 1, 1 );
                    if ( op == 3 ) printf( "%d\n", ans );
                    else printf( "%d\n", maxLen );
                }
            }
        }
    }
    return 0;
}