hdu 3911 Black And White

Black And White

Time Limit: 9000/3000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 3561    Accepted Submission(s): 1062

Problem Description

There are a bunch of stones on the beach; Stone color is white or black. Little Sheep has a magic brush, she can change the color of a continuous stone, black to white, white to black. Little Sheep like black very much, so she want to know the longest period of consecutive black stones in a range [i, j].

 

Input

  There are multiple cases, the first line of each case is an integer n(1<= n <= 10^5), followed by n integer 1 or 0(1 indicates black stone and 0 indicates white stone), then is an integer M(1<=M<=10^5) followed by M operations formatted as x i j(x = 0 or 1) , x=1 means change the color of stones in range[i,j], and x=0 means ask the longest period of consecutive black stones in range[i,j]

 

Output

When x=0 output a number means the longest length of black stones in range [i,j].

 

Sample Input

4

1 0 1 0

5

0 1 4

1 2 3

0 1 4

1 3 3

0 4 4

 

Sample Output

1

2

0

 

Source

2011 Multi-University Training Contest 8 - Host by HUST

 

/**
题意：两种操作
0 l ,r 查找区间[ L , R ]里最长的连续1的数目。
1 l ,r 更新区间[ L , R ]里的数字。0变成1,  1变成0

思路：
由于连续1的存在，我们需要保存lnum, rnum.  lmaxn, rmaxn maxn;
加上1操作，我们还要有个延迟标记才行。
bool  setFlag;

如果就设置这些参数。在更新的时候，
我们必须要找到一段连续相等数字的区间，对它进行延迟标记。
i f ( f[n].maxn == f[n].len || f[n].maxn == 0 )

 这样的话，我们有可能更新到叶子节点。这样的时间就多了。
 其实，我们最期望的就是一旦找到区间[ L ,R ]的时候，就进行延迟
 标记，然后返回。

 由此，我们还要加上统计0个数的数据。
 Zlmaxn,Zrmaxn,Zmaxn;
 1的操作本质上也是 0  和 1的转化，所以交换它们的值就可以了。

 同时，我们需要注意，对于setFlag ,只有奇数次的时候才标记为ture;

**/

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<cstdlib>
using namespace std;

struct node
{
    int l,r,len;
    int lnum,rnum;
    int lmaxn,rmaxn,maxn;
    int Zlmaxn,Zrmaxn,Zmaxn;
    bool setFlag;
}f[100002*4];
int date;

void up(int n)
{
    f[n].lnum = f[n*2].lnum;
    f[n].rnum = f[n*2+1].rnum;

    f[n].lmaxn = ( f[n*2].lmaxn==f[n*2].len && f[n*2].rnum==f[n*2+1].lnum ) ?
                     f[n*2].lmaxn+f[n*2+1].lmaxn:f[n*2].lmaxn;
    f[n].rmaxn = ( f[n*2+1].rmaxn == f[n*2+1].len && f[n*2].rnum == f[n*2+1].lnum) ?
                     f[n*2+1].rmaxn+f[n*2].rmaxn : f[n*2+1].rmaxn;
    f[n].maxn = max(f[n*2].maxn,f[n*2+1].maxn);
    if(f[n*2].rnum == 1 && f[n*2+1].lnum == 1)
        f[n].maxn = max(f[n].maxn,f[n*2].rmaxn+f[n*2+1].lmaxn);

    f[n].Zlmaxn = ( f[n*2].Zlmaxn==f[n*2].len && f[n*2].rnum==f[n*2+1].lnum ) ?
                     f[n*2].Zlmaxn+f[n*2+1].Zlmaxn:f[n*2].Zlmaxn;
    f[n].Zrmaxn = ( f[n*2+1].Zrmaxn == f[n*2+1].len && f[n*2].rnum == f[n*2+1].lnum) ?
                     f[n*2+1].Zrmaxn+f[n*2].Zrmaxn : f[n*2+1].Zrmaxn;
    f[n].Zmaxn = max(f[n*2].Zmaxn,f[n*2+1].Zmaxn);
    if(f[n*2].rnum == 0 && f[n*2+1].lnum == 0)
        f[n].Zmaxn = max(f[n].Zmaxn,f[n*2].Zrmaxn+f[n*2+1].Zlmaxn);
}
void build(int l,int r,int n)
{
    int mid=(l+r)/2;
    f[n].l = l;
    f[n].r = r;
    f[n].len = f[n].r-f[n].l+1;
    f[n].setFlag = false;
    f[n].lnum=f[n].rnum=0;
    f[n].lmaxn=f[n].rmaxn=f[n].maxn=0;
    f[n].Zlmaxn=f[n].Zrmaxn=f[n].Zmaxn=0;
    if(l==r)
    {
        scanf("%d",&date);
        f[n].lnum=f[n].rnum=date;
        f[n].lmaxn=f[n].rmaxn=f[n].maxn=date;
        f[n].Zlmaxn=f[n].Zrmaxn=f[n].Zmaxn=(date^1);
        return;
    }
    build(l,mid,n*2);
    build(mid+1,r,n*2+1);
    up(n);
}

void down(int n)
{
    f[n*2].setFlag = f[n*2].setFlag^1;
    /**传递的是奇数次，偶数次就抵消了，不需要向下更新**/
    swap(f[n*2].lmaxn,f[n*2].Zlmaxn);
    swap(f[n*2].rmaxn,f[n*2].Zrmaxn);
    swap(f[n*2].maxn,f[n*2].Zmaxn);
    f[n*2].lnum = (f[n*2].lnum^1);
    f[n*2].rnum = (f[n*2].rnum^1);

    f[n*2+1].setFlag = f[n*2+1].setFlag^1;
    /**传递的是奇数次，偶数次就抵消了，不需要向下更新**/
    swap(f[n*2+1].lmaxn,f[n*2+1].Zlmaxn);
    swap(f[n*2+1].rmaxn,f[n*2+1].Zrmaxn);
    swap(f[n*2+1].maxn,f[n*2+1].Zmaxn);
    f[n*2+1].lnum=(f[n*2+1].lnum^1);
    f[n*2+1].rnum=(f[n*2+1].rnum^1);

    f[n].setFlag = false;
}
void update(int l,int r,int n)
{
    int mid=(f[n].l + f[n].r)/2;
    if(f[n].l == l && f[n].r == r)
    {
        f[n].setFlag = (f[n].setFlag^1);
        /**传递的是奇数次，偶数次就抵消了，不需要向下更新**/
        f[n].lnum=(f[n].lnum^1);
        f[n].rnum=(f[n].rnum^1);
        swap(f[n].lmaxn,f[n].Zlmaxn);
        swap(f[n].rmaxn,f[n].Zrmaxn);
        swap(f[n].maxn,f[n].Zmaxn);
        return ;
    }
    if(f[n].setFlag==true) down(n);
    if(mid>=r) update(l,r,n*2);
    else if(mid<l) update(l,r,n*2+1);
    else
    {
        update(l,mid,n*2);
        update(mid+1,r,n*2+1);
    }
    up(n);
}

int query(int l,int r,int n)
{
    int mid=(f[n].l + f[n].r)/2;
    if(f[n].l == l && f[n].r==r)
    {
         return f[n].maxn;
    }
    if(f[n].setFlag==true) down(n);
    if(mid>=r) return query(l,r,n*2);
    else if(mid<l) return query(l,r,n*2+1);
    else
    {
        int lmaxn = query(l,mid,n*2);
        int rmaxn = query(mid+1,r,n*2+1);
        int maxn = max(lmaxn,rmaxn);
        if(f[n*2].rnum==1 && f[n*2+1].lnum ==1)
            maxn = max(  maxn,min(mid-l+1,f[n*2].rmaxn)+min(r-mid,f[n*2+1].lmaxn)  );
        return maxn;
    }
}

int main()
{
    int n,m,l,r,size1;
    while(scanf("%d",&n)>0)
    {
        build(1,n,1);
        scanf("%d",&m);
        while(m--)
        {
            scanf("%d%d%d",&size1,&l,&r);
            if(size1==1)
                update(l,r,1);
            else if(size1==0)
                printf("%d\n",query(l,r,1));
        }
    }
    return 0;
}