计蒜客习题：黑白石头

这道题目不知道从哪里开始分析

先给出所用函数与数据结构吧

函数

1、up向上传递。由此题可以加深向上传递的理解：向上传递，就是两个区间合并，并将相应信息合并的函数。

2、down向下传递（lazy标记传递）当父节点存在lazy标记时，将两棵树交换信息。记得添加子节点的lazy标记

3、build构建区间长度线段树以及区间线段树初始化。用处：维护len（区间长度）线段树；初始化

4、modify区间修改。改动不大，不做详细介绍

5、query区间查询。着重留意query的结构，与平常的query不一样。利用atom结构体，来完成区间的有机联系。

数据结构

1、线段树：s[p][2] 区间最大线段树，cl[p][2],cr[p][2]分别左区间最大，右区间最大。其各占两个线段树，分别对应黑白子。

2、atom结构体：用于query的有机关联的数据结构

3、区间长度线段树len[p][2]：具体实现看build函数体。其用于合并有机的左右区间，作用不小

4、初试数组：用于build的初始化

#include<bits/stdc++.h>
using namespace std;
const int MAX_N = 100050;
int s[4*MAX_N][2],cl[4*MAX_N][2],cr[4*MAX_N][2];
int len[4*MAX_N];///记录区间长度的线段树，用于左右区间的合并
int col[4*MAX_N];
int a[MAX_N]; ///初始键盘
int n, m, op, x, y;
void up(int p)
{
    for(int i=0;i<2;i++){   ///分别对黑白线段树进行维护
        s[p][i] = cr[2*p][i]+cl[2*p+1][i];///先让两区间中间棋子长度合并
        s[p][i] = max(s[p][i],s[2*p][i]);
        s[p][i] = max(s[p][i],s[2*p+1][i]);///在比较原来区间最长与合并后的关系
        cl[p][i] = cl[2*p][i];
        if(cl[2*p][i]==len[2*p]) cl[p][i]+=cl[2*p+1][i];
        cr[p][i] = cr[2*p+1][i];
        if(cr[2*p+1][i]==len[2*p+1]) cr[p][i]+=cr[2*p][i];///如果左侧==区间长度，那就要和右侧棋子进行合并，维护好边侧区间线段树
    }
}

//void down(int p,int l,int r)
///在down函数中传衡量工具l与r的目的是对区间进行(r-l+1)整数倍的运算
///而刚好区间的两个线段树又存在互补的关系，故不需要传l与r
///可以说明，l与r不是必须参数，也是见实际情况进行传参
///记住 down是父结点的向下传递
void down(int p)
{
	if (col[p]) // 如果需要下放 lazy 标记
	{
	    // 交换黑白颜色信息
		swap(s[p * 2][0], s[p * 2][1]);
		swap(s[p * 2 + 1][0], s[p * 2 + 1][1]);
		swap(cl[p * 2][0], cl[p * 2][1]);
		swap(cl[p * 2 + 1][0], cl[p * 2 + 1][1]);
		swap(cr[p * 2][0], cr[p * 2][1]);
		swap(cr[p * 2 + 1][0], cr[p * 2 + 1][1]);
		col[p * 2] ^= 1; // 标记下放    //因为lazy标记的特点是
		///修改完后只进行了向子节点传递了状态
		///当访问到子节点后才进行修改子节点的子节点
		col[p * 2 + 1] ^= 1;        ///%=2的另一种写法，但比%2功能更多，比如切换
		col[p] = 0; // 标记清空
	}
}

void build(int p,int l,int r)
{
    col[p] = 0; len[p] = r-l+1;///初始化lazy与区间长度全部传值
    if(l==r)    ///抵达叶节点
    {
        int v = a[l];
        s[p][v] = cl[p][v] = cr[p][v] = 1;///叶节点其三值相等
        v^=1;
        s[p][v] = cl[p][v] = cr[p][v] = 0;///对应的另一棵树在此点为0
        return ;
    }
    int mid = (l+r)/2;
    ///没有条件，因为要遍历整棵树
    build(2*p,l,mid);
    build(2*p+1,mid+1,r);
    up(p);
}
///因为modify只负责交换两棵树的信息关系
///不具有初始化的作用，故初始化在build内实现
///build->维护数的另一种方法

///modify的改动仍不是很大，详见下方
void modify(int p,int l,int r,int x,int y)  ///因为修改值已知，就是按位相加1取2模
{
    if(x<=l&&r<=y){
        swap(s[p][0],s[p][1]);
        swap(cl[p][0],cl[p][1]);
        swap(cr[p][0],cr[p][1]);
        col[p]^=1;
        return ;
    }
    down(p);
    int mid = (l+r)/2;
    if(x<=mid){
        modify(2*p,l,mid,x,y);
    }
    if(y>mid){
        modify(2*p+1,mid+1,r,x,y);
    }
    up(p);
}

struct atom ///区间黑色棋子的信息以及数量
{
    int sum,left,right;bool full;
    // sum 表示最多有多少连续黑色石子，
	//left 表示左端最多有多少连续黑色石子，
	//right 表示右端最多有多少连续黑色石子，
	//full 表示这一区间所有石子是否都是黑色石子
};
atom operator + (atom a,atom b)
{
    atom res;
    res.sum = a.right+b.left;
    res.sum = max(a.sum,res.sum);
    res.sum = max(b.sum,res.sum);
    res.left = a.left; if(a.full) res.left += b.left;
    res.right = b.right; if(b.full) res.right += a.right;
    res.full = a.full & b.full;// 这一段区间都是黑色石子当且仅
	//左右区间都全部是黑色石子
	return res;
}

atom query(int p,int l,int r,int x,int y)
{
    if(x<=l&&r<=y) return (atom){s[p][1],cl[p][1],cr[p][1],s[p][1]==len[p]};
    /** 找到区间，返回的结果，其中最后一位就是是不是都是黑色石子，
	那么只有这一段的最长连续黑色石子数与区间长度相等时才是**/
	down(p); int mid = (l+r)/2; ///询问函数不需要up，但要down
	if(y<=mid) return query(p*2,l,mid,x,y);
	else if(x>mid) return query(p*2+1,mid+1,r,x,y);///因为这两种情况一定是互斥事件，同时为下面的else作号前提条件
	else return query(p*2,l,mid,x,y) + query(p*2+1,mid+1,r,x,y);
	// 合并
    //这三行语句其实与if(x<=mid)+if(y>mid)的递归用处基本相同
    //而上者相加是无机相加或取最大值
    //但因为这两个区间是有合并关系的，所以
    //要不在区间左、右侧各自独立，要不就是在中间的时候
    //写个相加的关系函数，将其合并
}

int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    build(1,1,n);
    scanf("%d",&m);
    while(m--)
    {
        scanf("%d%d%d",&op,&x,&y);
        if(op==0)
        {
            atom ans = query(1,1,n,x,y);
            printf("%d\n",ans.sum);
        }
        else
            modify(1,1,n,x,y);
    }
    return 0;
}

思路：

大体程序里讲的比较详细，但还没有一个大一统的思想。先记到此处。