[xsy2369]取名字

真是道挺好的题，做一道题学了挺多东西

从操作入手比较困难，所以对硬币进行讨论

考虑一个硬币$(A,B)$，假设$A\lt B$，那么我们可以把操作分成三类

第一类$T_j\lt A$，这种操作是没用的

第二类$A\leq T_j\lt B$，只要有这种操作，最后一次第二类操作后，这个硬币一定$B$面朝上

第三类$T_j\geq B$，这类操作强制把硬币翻面

所以对于每个硬币，只需要①找最后一个第二类操作，②统计之后第三类操作的奇偶性即可

①相当于是找最大的$j$满足$A\leq T_j\lt B$，设答案为$p$

②相当于是找$T_j\geq B$且$j\gt p$的数量

浓厚的树套树气息扑面而来...

所以建线段树套树状数组，外层操作时间内层$T_j$，注意内层要离散化，内层查询先二分找到下标再在树状数组上跑

最后是找哪些询问覆盖某个硬币$i$

把询问按左端点排序，用优先队列维护右端点即可，每次加入$l\leq i$的，删除$r\lt i$的

做这种全是区间操作，但是要以序列中的元素为观察点的题，这个方法再套上数据结构是挺好的

以前一直以为树状数组是不可以做内层树套树的（因为下标要访问到$n$）但是实际上加个离散化后，内层用树状数组完全没有问题

p.s.一开始写线段树套treap，T到爆炸，这个常数啊，excited！

#include<stdio.h>
#include<algorithm>
#include<queue>
using namespace std;
#define ll long long
struct quev{
	int r,id;
	quev(int a=0,int b=0){r=a;id=b;}
};
bool operator<(quev a,quev b){return a.r>b.r;}
priority_queue<quev>pq;
struct coin{
	int a,b;
}c[100010];
struct ask{
	int l,r,t,id;
}q[100010];
struct seg{
	int*c,*t,len;
	seg(){c=t=0;}
}t[400010];
int m;
bool cmp(ask a,ask b){return a.l<b.l;}
void build(int l,int r,int x){
	t[x].len=r-l+1;
	t[x].c=new int[t[x].len+2];
	t[x].t=new int[t[x].len+2];
	for(int i=l;i<=r;i++){
		t[x].c[i-l+1]=q[i].t;
		t[x].t[i-l+1]=0;
	}
	sort(t[x].c+1,t[x].c+t[x].len+1);
	if(l==r)return;
	int mid=(l+r)>>1;
	build(l,mid,x<<1);
	build(mid+1,r,x<<1|1);
}
int lowbit(int x){return x&-x;}
int getsum(int x,int p){
	if(p<t[x].c[1])return 0;
	p=upper_bound(t[x].c+1,t[x].c+t[x].len+1,p)-t[x].c-1;
	int s=0;
	while(p){
		s+=t[x].t[p];
		p-=lowbit(p);
	}
	return s;
}
void modify(int x,int p,int d){
	p=lower_bound(t[x].c+1,t[x].c+t[x].len+1,p)-t[x].c;
	while(p<=t[x].len){
		t[x].t[p]+=d;
		p+=lowbit(p);
	}
}
void tmodify(int p,int T,int d){
	int l=1,r=m,x=1,mid;
	while(1){
		modify(x,T,d);
		if(l==r)return;
		mid=(l+r)>>1;
		if(p<=mid){
			r=mid;
			x<<=1;
		}else{
			l=mid+1;
			x=x<<1|1;
		}
	}
}
int query1(int L,int R){
	int l=1,r=m,x=1,mid;
	while(l!=r){
		mid=(l+r)>>1;
		if(getsum(x<<1|1,R)-getsum(x<<1|1,L-1)!=0){
			l=mid+1;
			x=x<<1|1;
		}else{
			r=mid;
			x<<=1;
		}
	}
	return(getsum(x,R)-getsum(x,L-1)!=0)?l:0;
}
int query2(int p,int T){
	int l=1,r=m,x=1,res=0,mid;
	while(1){
		mid=(l+r)>>1;
		if(l==p)return res+getsum(x,1000000001)-getsum(x,T-1);
		if(p<=mid){
			res+=getsum(x<<1|1,1000000001)-getsum(x<<1|1,T-1);
			r=mid;
			x<<=1;
		}else{
			l=mid+1;
			x=x<<1|1;
		}
	}
}
int query(int x){
	int s=0,a=c[x].a,b=c[x].b,f=0;
	if(a>b)swap(a,b);
	if(a<b)s=query1(a,b-1);
	if(s!=0&&c[x].a<c[x].b)f=1;
	if(s<m)s++;
	if(query2(s,b)&1)f^=1;
	return f?c[x].b:c[x].a;
}
int main(){
	int n,i,nq;
	ll ans;
	scanf("%d",&n);
	for(i=1;i<=n;i++)scanf("%d",&c[i].a);
	for(i=1;i<=n;i++)scanf("%d",&c[i].b);
	scanf("%d",&m);
	for(i=1;i<=m;i++){
		scanf("%d%d%d",&q[i].l,&q[i].r,&q[i].t);
		q[i].id=i;
	}
	build(1,m,1);
	sort(q+1,q+m+1,cmp);
	nq=1;
	ans=0;
	for(i=1;i<=n;i++){
		while(nq<=m&&q[nq].l<=i){
 			tmodify(q[nq].id,q[nq].t,1);
 			pq.push(quev(q[nq].r,nq));
			nq++;
		}
		while(!pq.empty()&&pq.top().r<i){
			tmodify(q[pq.top().id].id,q[pq.top().id].t,-1);
			pq.pop();
		}
		ans+=query(i);
	}
	printf("%lld\n",ans);
}