HDU 3397 Sequence operation(线段…

题意：给个一只有0，1 的序列，有以下5种操作
0 a b change all characters into '0's in [a , b] //把a，b间的都改为0
1 a b change all characters into '1's in [a , b] //把a，b间都改为1
2 a b change all '0's into '1's and change all '1's into '0's in [a, b] //1的改为0，0的改为1
Output operations:
3 a b output the number of '1's in [a, b]  //a，b间1 的数量
4 a b output the length of the longest continuous '1' string in [a , b]//a，b间最大连续的1的个数

思路：经典的线段树，只是操作过多，但其实很简单，相当于把以前做过的题的操作合在一块 什么值的更改，区间和的查询，最开连续的个数 。所以没什么特殊的

//1312MS    8836K
#include <stdio.h>
#define L(x) (x<<1)
#define R(x) (x<<1|1)
#define M 100010

struct tree
{
    int l,r,len;  //len 是该区间的长度
    int sum,cover;   //sum 是该区间1的数量，cover 有3个值-1，0，1分别表示该区间是否被0，1完全覆盖
    int lm,rm,ma;    //lm rm ma 分别表示 左连续 右连续 和最大的连续1的个数
} node[M*4];

int num[M];

int max (int a,int b)
{
    return a > b ? a : b;
}
int min (int a ,int b)
{
    return a > b ? b : a;
}
void Union (int u)  //区间合并，由子结点修改父结点的信息
{                     //常用手法 就不多解释了
    node[u].sum = node[L(u)].sum + node[R(u)].sum;
    if (node[L(u)].len == node[L(u)].lm)
        node[u].lm = node[L(u)].len + node[R(u)].lm;
    else
        node[u].lm = node[L(u)].lm;
    if (node[R(u)].len == node[R(u)].rm)
        node[u].rm = node[R(u)].len + node[L(u)].rm;
    else
        node[u].rm = node[R(u)].rm;
    int a = max (node[L(u)].ma,node[R(u)].ma);
    int b = max (node[u].lm,node[u].rm);
    node[u].ma = max (max (a,b),node[L(u)].rm + node[R(u)].lm);
}
void Build (int u,int left,int right)
{
    node[u].l = left;
    node[u].r = right;
    node[u].len = right - left + 1;
    node[u].cover = -1;
    if (left == right)
    {
        if (num[left])
        {
            node[u].sum = 1;
            node[u].cover = 1;
            node[u].lm = node[u].rm = node[u].ma = 1;
        }
        else
        {
            node[u].sum = 0;
            node[u].cover = 0;
            node[u].lm = node[u].rm = node[u].ma = 0;
        }
        return ;
    }
    int mid = (left + right)>>1;
    Build (L(u),left,mid);
    Build (R(u),mid+1,right);
    Union (u);
}
void getdown (int u)     //延迟操作，由父结点修改子结点
{                        //也是常用手法
    node[L(u)].cover = node[u].cover;
    node[R(u)].cover = node[u].cover;
    if (node[u].cover)
    {
        node[L(u)].lm = node[L(u)].rm = node[L(u)].ma = node[L(u)].len;
        node[L(u)].sum = node[L(u)].len;
        node[R(u)].lm = node[R(u)].rm = node[R(u)].ma = node[R(u)].len;
        node[R(u)].sum = node[R(u)].len;
    }
    else
    {

        node[L(u)].lm = node[L(u)].rm = node[L(u)].ma = 0;
        node[L(u)].sum = 0;
        node[R(u)].lm = node[R(u)].rm = node[R(u)].ma = 0;
        node[R(u)].sum = 0;
    }
    node[u].cover = -1;
}
void Update1 (int u,int left,int right,int flag) //下面这两个Update1,Update2 也算是经典了
{                                                //都是一个套路 左边，右边，或一起更新
    if (node[u].l == left &&node[u].r == right)
    {
        node[u].cover = flag;
        if (flag)
        {
            node[u].lm = node[u].rm = node[u].ma = node[u].r - node[u].l + 1;
            node[u].sum = node[u].ma;
        }
        else
        {
            node[u].lm = node[u].rm = node[u].ma = 0;
            node[u].sum = 0;
        }
        return ;
    }
    if (node[u].cover != -1)
        getdown (u);
    int mid = (node[u].l + node[u].r)>>1;
    if (right <= mid)
        Update1 (L(u),left,right,flag);
    else if (left >= mid + 1)
        Update1(R(u),left,right,flag);
    else
    {
        Update1(L(u),left,mid,flag);
        Update1(R(u),mid+1,right,flag);
    }
    Union (u);
}
void Update2 (int u,int left,int right)
{
    if (node[u].l == left&&node[u].r == right&&(node[u].sum == 0||node[u].sum == node[u].len))
    {
        if (node[u].sum > 0)
        {
            node[u].lm = node[u].rm = node[u].ma = 0;
            node[u].sum = 0;
            node[u].cover = 0;
        }
        else
        {
            node[u].lm = node[u].rm = node[u].ma = node[u].len;
            node[u].sum = node[u].len;
            node[u].cover = 1;
        }
        return ;
    }
    if (node[u].cover != -1)
        getdown (u);
    int mid = (node[u].l + node[u].r)>>1;
    if (right <= mid)
        Update2(L(u),left,right);
    else if (left >= mid + 1)
        Update2(R(u),left,right);
    else
    {
        Update2(L(u),left,mid);
        Update2(R(u),mid + 1,right);
    }
    Union (u);
}

int Query (int u,int left,int right,int flag) //查询操作 因为根据flag不同返回不同的值
{
    if (node[u].l == left &&node[u].r == right)
    {
        if (flag)
            return node[u].ma;
        else
            return node[u].sum;
    }
    if (node[u].cover != -1)
        getdown (u);
    int mid = (node[u].l + node[u].r)>>1;
    if (right <= mid)
        return Query(L(u),left,right,flag);
    else if (left >= mid + 1)
        return Query(R(u),left,right,flag);
    else       //这是的return得注意，当返回 连续1的个数时 注意中间断开的情况
    {          //min (node[L(u)].rm,node[L(u)].r-left+1) 这是求左子结点右边最大的连续 右子结点同理
        if (flag)
        {
            int a = max (Query(L(u),left,mid,flag),Query(R(u),mid+1,right,flag));
            return max (a,min (node[L(u)].rm,node[L(u)].r-left+1) + min (node[R(u)].lm,right-node[R(u)].l + 1));
        }
        else
            return (Query(L(u),left,mid,flag) + Query(R(u),mid+1,right,flag));
    }
}
int main ()
{
    int T,n,m,op,a,b;
    scanf ("%d",&T);
    while (T --)
    {
        scanf ("%d%d",&n,&m);
        for (int i = 1; i <= n; i ++)
            scanf ("%d",&num[i]);
        Build (1,1,n);
        while (m --)
        {
            scanf ("%d%d%d",&op,&a,&b);
            a ++,b++;
            if (op == 0)
                Update1(1,a,b,0);
            else if (op == 1)
                Update1 (1,a,b,1);
            else if (op == 2)
                Update2 (1,a,b);
            else if (op == 3)
                printf ("%d\n",Query (1,a,b,0)); //0 return sum;
            else
                printf ("%d\n",Query (1,a,b,1)); //1 return ma
        }
    }
    return 0;
}