CF1340F Nastya and CBS

首先考虑如何维护一段括号序列。

根据观察可知，对一个括号序列来说，若存在这种形式 '{ )' 则包含该区段的询问均不合法，反之不存在则说明可能构成合法的解。这启发我们可以将一个段都进行这样的缩区间，然后对于一个询问将其全部拼在一起，在拼的时候考虑一下是否满足上述情况。

对于的判断两个括号序列是否相同时采用 Hash 维护，具体来说维护一个左向开始的 Hash 和右向开始的 Hash，同种括号不同方向用绝对值即可

针对上述解法，分块无疑是最好写的，这也是大多数题解采用的方法，，复杂度为 \(O(n\sqrt n)\) （这里默认 \(n\) 与 \(q\) 同阶

这里给出一种官方题解做法：线段树套可持久化文艺平衡树，时间复杂度是 \(O(n \log^2n)\),空间复杂度是 \(O(n\log n + q\log n)\)。并且因为我太菜了，不会随时回收可持久化平衡树的节点，所以是每 \(10^4\) 次扫一遍线段树找出所有废弃节点，回收再利用。（用可持久化平衡树实现细节还挺多的，还是分块好写

虽然看起来是这玩意复杂度更优，但它常数实在是太大了……

#include<bits/stdc++.h>

using namespace std;

#define INF 1ll<<30
#define ill unsigned int

template<typename _T>
inline void read(_T &x)
{
	x=0;char s=getchar();int f=1;
	while(s<'0'||s>'9') {f=1;if(s=='-')f=-1;s=getchar();}
	while('0'<=s&&s<='9'){x=(x<<3)+(x<<1)+s-'0';s=getchar();}
	x*=f;
}
const int np = 1e5 + 5;
template<typename _T>
inline _T Abs(_T &x)
{
	return x < 0?-x:x;
}
int pare[np];
const int qt = 90;
int ch[2][qt * np],pri[np * qt],val[np * qt];
ill Hashl[np * qt],Hashr[np * qt];
const ill base = 29;
bitset<np * 90> use;
ill p_[np];
int siz[np * qt],tail = 1;//,cnt;//,tail;//,rot[23333]cnt;
#define ls(x) (ch[0][x])
#define rs(x) (ch[1][x])

inline int Rub()
{
	while(use[tail]) tail++;
	return tail++;
}

inline int New(int a)
{
//	++cnt;
	int cnt;
	cnt = Rub();
	val[cnt] = a;
	Hashl[cnt] = Hashr[cnt] = Abs(a);
	ls(cnt) =rs(cnt) = 0;
	pri[cnt] = rand();
	siz[cnt] = 1;
	return cnt;
}

inline void cop(int x,int y)
{
	ls(x) = ls(y),rs(x) = rs(y);
	pri[x] = pri[y],val[x] = val[y];
	Hashl[x] = Hashl[y],Hashr[x] = Hashr[y];
	siz[x] = siz[y];
}

inline void pushup(int x)
{
	siz[x] = siz[ls(x)] + siz[rs(x)] + 1;
	Hashl[x] = Hashl[rs(x)] + p_[siz[rs(x)]] * Abs(val[x]) + p_[(siz[rs(x)] + 1)] * Hashl[ls(x)]; // 左边比较高的哈希 
	Hashr[x] = Hashr[ls(x)] + p_[siz[ls(x)]] * Abs(val[x]) + p_[(siz[ls(x)] + 1)] * Hashr[rs(x)]; // 右边比较高的哈希 
}
//int flag = 0;
//inline void Debug(){int op;return;}
inline void split(int now,int k,int &x,int &y)
{
//	if(flag == 2333) Debug();
	if(!now) return (void)(x = y = 0);
	if(siz[ls(now)] + 1 <= k)
	{
		x = now;
		split(rs(now),k - siz[ls(now)] - 1,rs(x),y);
	}
	else
	{
		y = now;
		split(ls(now),k,x,ls(y));
	}
	pushup(now);
}

inline int Merge(int x,int y)
{
	if(!x || !y) return x | y;
	if(pri[x] < pri[y])
	{
		rs(x) = Merge(rs(x),y);
		pushup(x);
		return x;
	}
	else
	{
		ls(y) = Merge(x,ls(y));
		pushup(y);
		return y;
	}
}

inline void split_(int now,int k,int &x,int &y)
{
//	if(flag == 23) Debug(); 
	if(!now) return (void)(x = y = 0);
	if(siz[ls(now)] + 1 <= k)
	{
		x = Rub();//++cnt;
		cop(x,now);
		split_(rs(x),k - siz[ls(now)] - 1,rs(x),y);
		pushup(x);
	}
	else
	{
		y = Rub();//++cnt;
		cop(y,now);
		split_(ls(y),k,x,ls(y));
		pushup(y);
	}
}

#define Merge_ Merge

inline ill lHash(int p,int l,int r)
{
	if(l > r) return 0;
	int x,y,z;
	ill Ans(0);
	split(p,r,x,y);
	split(x,l-1,x,z);
	Ans = Hashl[z];
	p = Merge(Merge(x,z),y);
	return Ans;
}

//int flag = 0;
inline ill rHash(int p,int l,int r)//合并分裂之后树的形态是不变的所以不用新建节点
{
//	if(flag && l == 2 && r == 3) Debug();//flag = 2333,cerr<<siz[x]<<'\n',
	if(l > r) return 0;
	int x,y,z;
	ill Ans(0);
	split(p,r,x,y);
//	flag = 1;
	split(x,l-1,x,z);
	Ans = Hashr[z];
	p = Merge(Merge(x,z),y);
	return Ans;
}

inline void FHQ_rec(int x)
{
	if(ls(x)) FHQ_rec(ls(x));
	use[x] = 1;
	if(rs(x)) FHQ_rec(rs(x));
}

struct trans{
	int id,l_,r_;
};

struct Node{//建一棵线段树，每个节点维护一棵平衡树，平衡树中维护所有字符串
//同时维护左向哈希和右向哈希 
//	int l,r;
	int rt;
	short typ;
	int sl,sr;
	Node *ls,*rs;
//	int ls,rs;
	
	inline void rec()
	{
		if(ls) ls->rec();
		FHQ_rec(rt);
		if(rs) rs->rec();
	 } 
//	#define LS(x) 
	inline void cl(){rt = typ = sl = sr = 0;}
	inline bool inrange(int l,int r,int L,int R){return L <= l && r <= R;}
	inline bool outofrange(int l,int r,int L,int R){return r < L || R < l;}
	inline int debug(){int op =1;return op;}
	inline void pushup() // pushup -> O()
	{
//		if(flag && l == 1 && r == 5) debug(),flag = 23;
		typ = ls->typ & rs->typ;
		if(!typ) return;
		int ql , qr , q;
		ql = ls->sr,qr = rs->sl;
		q = min(ql,qr);
		ill a1 = lHash(rs->rt,1,q);
		ill a2 = rHash(ls->rt,siz[ls->rt] - q + 1,siz[ls->rt]);
		if(a1 == a2)
		{
			int x,y,a,b;
			split_(ls->rt,siz[ls->rt] - q,x,y);
			split_(rs->rt,q,a,b);
			rt = Merge_(x,b);
//			printf("ls->sl = %d ls->sr = %d q = %d\n",ls->sl,ls->sr,q);
//			printf("rs->sl = %d rs->sr = %d q = %d\n",rs->sl,rs->sr,q);
			sl =ls->sl + qr - q;
			sr =rs->sr + ql - q;
//			printf("rt = %d sl = %d sr = %d l = %d r = %d typ = %d\n",rt,sl,sr,l,r,typ);
		}
		else typ = 0;
	}
	
	inline trans query(int l,int r,int L,int R)
	{
		if(inrange(l,r,L,R))
		{
			return typ?(trans){rt,sl,sr}:(trans){-2,0,0};
		}
		else
		{
			if(!outofrange(l,r,L,R))
			{
				int mid = l + r >> 1;
				trans op1 = ls->query(l,mid,L,R),op2 = rs->query(mid+1,r,L,R);
				int r1 = op1.id;
				int r2 = op2.id;
				int x,y,a,b;
				if(r1 == -2 || r2 == -2) return (trans){-2,0,0};
				if(r1 != -1 && r2 != -1) 
				{
					int ql,qr,q;
					ql = op1.r_;
					qr = op2.l_;
					q = min(ql,qr);
					ill a1,a2;
					a1 = lHash(r2,1,q);
					a2 = rHash(r1,siz[r1] - q + 1,siz[r1]);
					if(a1 == a2)
					{
						split_(r1,siz[r1] - q,x,y);
						split_(r2,q,a,b);
						return (trans){Merge_(x,b),op1.l_ + qr - q,op2.r_ + ql - q};
					}
					else return (trans){-2,0,0};
				}
				else if(r1 != -1) return op1;
				else if(r2 != -1) return op2;
				
			}
			else return (trans){-1,0,0};
		}
	}
	
	inline void upd(int l,int r,int pos,int vl)
	{
		if(inrange(l,r,pos,pos))
		{
			cl();
			rt = New(vl);
//			sl = sr = 0;
			if(vl > 0) typ = sr = 1;
			else typ = sl = 1;
		}
		else
		{
			if(!outofrange(l,r,pos,pos))
			{
				int mid = l + r >> 1;
				ls->upd(l,mid,pos,vl);
				rs->upd(mid+1,r,pos,vl);
				cl();
				pushup();
			}
			
		}
	}
	
}mem[np * 2],*pool = mem,*rot;
inline Node *New(){return ++pool;}
inline Node *build(int L,int R)
{
	Node *u = New();
//	u->l = L,u->r = R;
	if(L == R)
	{
		u->ls = u->rs = NULL;
		u->rt = New(pare[L]);
		if(pare[L] > 0) u->typ = u->sr = 1;
		else u->typ=u->sl = 1;
	}
	else
	{
		int mid = L + R >> 1;
		u->ls = build(L,mid);
		u->rs = build(mid + 1,R);
		u->pushup();
	}
	return u;
}

signed  main()
{
	int n,k,q;
	p_[0] = 1;
//	cout<<"*";
//	cerr<<n<<" ";
	for(int i=1;i<=1e5;i++) p_[i] = p_[i - 1] * base;//cerr<<"*";
	read(n);
	read(k);//cerr<<"*";
//	cerr<<n<<'\n';
	for(int i=1;i<=n;i++) read(pare[i]);//,cerr<<i<<" ";
//	cerr<<"*";//scanf("%d",&pare[i]);cerr<<"*";//read(pare[i]),cerr<<"*";
//	cout<<"*";
	rot = build(1,n);
	read(q);
	
//	q = 30746;
	for(int i=1,opt,pos,vl,l,r;i <= q;i++)
	{
//		if(i == 30742) flag = 1;
//		else flag = 0;
		read(opt);
		switch(opt)
		{
			case 1:{
				read(pos);
				read(vl);
//				if(flag) rot->upd_(pos,vl);
//				else 
				rot->upd(1,n,pos,vl);
//				pare[pos] = vl;
				break;
			}
			case 2:{
//				cout<<i<<" ";
				read(l);
				read(r);
				trans ans = rot->query(1,n,l,r);
				if(ans.id == -2) printf("No\n");
				else if(ans.l_ || ans.r_) printf("No\n");
				
				else printf("Yes\n");
				
				break;
			}
		}
		if(i % 10000 == 0) 
		{
			use.reset();
			rot->rec();
			tail = 1;
		}

//		printf("rt = %d sl = %d sr = %d typ = %d\n",rot->rt,rot->sl,rot->sr,rot->typ);
				
	}
	return 0;
 }

敲了 400+ 行，真是吐了（其实还是代码能力不行