BZOJ4785 [Zjoi2017]树状数组

最新推荐文章于 2021-03-21 17:56:08 发布
最新推荐文章于 2021-03-21 17:56:08 发布
阅读量1.1k 收藏
点赞数
分类专栏： BZOJ CDQ分治 树状数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/neither_nor/article/details/67638696
版权
BZOJ 同时被 3 个专栏收录
382 篇文章 1 订阅
订阅专栏
树状数组
8 篇文章 0 订阅
订阅专栏
CDQ分治
2 篇文章 0 订阅
订阅专栏

扯淡：

昨天就在BZOJ上看到了题，但是光老师说今天考ZJOI的题，就一直没看

看完题看了看部分分，所有修改在所有询问之前？那这题是不是肯定是cdq啊

然后YYYY，YY了一个贼JB恶心的CDQ，写了9000B，然后发现我们测的时候开4秒，觉得在校OJ上4秒肯定跑不过就交了70分暴力

后来考试结束了发现标程跑了3秒9……于是把时限开到8s，6s就过了

如果上天再给我一次机会，我一定写一个树套树，不知道好写到哪里去了，常数也小

做法：

首先可以发现这个树状数组其实求的是后缀和

然后嘛，如果询问的l不等于1，则相当于询问l-1和r相等的概率，如果l等于一，就相当于询问1~r-1的和与r+1到n的和相等的概率

l等于1和不等于1差不多，都是下面做法，但是要分开

那么考虑朴素做法，每次查询的时候枚举所有修改，计算一下影响即可

比如l等于1的情况，那么考虑比如修改的区间是l~r，查询的右端点在l~r之间

那么p会变成p/(r-l+1)+(1-p)*(r-l)/(r-l+1)

其他的情况类似考虑

发现一次修改的影响就相当于把概率乘一个数再加一个数

而把询问的左端点看成横坐标，右端点看成纵坐标，修改就相当于矩形乘加，拿cdq或者线段树维护即可

因为这题的特殊性质，所以不同的乘加之间顺序是无所谓的，所以cdq也是可行的

#include<iostream>
#include<cstring>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<iomanip>
#include<cstdlib>
#include<cstdio>
#include<map>
#include<bitset>
#include<set>
#include<stack>
#include<vector>
#include<queue>
using namespace std;
#define MAXN 300010
#define MAXM 1010
#define ll long long
#define eps 1e-8
#define MOD 998244353
#define INF 1000000000
char xB[1<<15],*xS=xB,*xTT=xB;
#define getc() (xS==xTT&&(xTT=(xS=xB)+fread(xB,1,1<<15,stdin),xS==xTT)?0:*xS++)
#define isd(c) (c>='0'&&c<='9')
int read(){
	char xchh;
	int xaa;
    while(xchh=getc(),!isd(xchh));(xaa=xchh-'0');
    while(xchh=getc(),isd(xchh))xaa=xaa*10+xchh-'0';return xaa;
}
struct que{
	ll x;
	ll y;
	ll c;
	ll tim;
	ll A11,B11,A12,B12,A21,B21,A22,B22;
	ll nA11,nA12,nA21,nA22;
};
int n,m;
ll L[MAXN],R[MAXN];
ll ine[MAXN];
que a[MAXN];
que ta[MAXN];
int tot;
ll ans[MAXN];
ll ch[MAXN<<2],ad[MAXN<<2],col[MAXN<<2],flg[MAXN<<2];
bool qinding[MAXN];
ll frog[MAXN];
int son[MAXN<<2][2];
int TOT,rt;
bool FLAG;
bool cmpl(que x,que y){
	return x.x!=y.x?x.x<y.x:x.c>y.c;
}
void nn(int &x){
	if(!x){
		x=++TOT;
		ch[x]=1;
		ad[x]=0;
		col[x]=-1;
		flg[x]=0;
		son[x][0]=son[x][1]=0;
	}
}
ll mi(ll x,ll y){
	ll re=1;
	while(y){
		if(y&1){
			(re*=x)%=MOD;
		}
		(x*=x)%=MOD;
		y>>=1;
	}
	return re;
}
inline void tomul(int &x,ll y){
	nn(x);
	(ch[x]*=y)%=MOD;
	(ad[x]*=y)%=MOD;
}
inline void toad(int &x,ll y){
	nn(x);
	(ad[x]+=y)%=MOD;
}
inline void tocol(int &x,ll y){
	nn(x);
	col[x]=y;
}
inline void toch(int &x,ll y){
	nn(x);
	flg[x]+=y;
}
inline void pd(int &x){
	if(ch[x]!=1){
		tomul(son[x][0],ch[x]);
		tomul(son[x][1],ch[x]);
		ch[x]=1;
	}
	if(ad[x]){
		toad(son[x][0],ad[x]);
		toad(son[x][1],ad[x]);
		ad[x]=0;
	}
	if(col[x]!=-1){
		tocol(son[x][0],col[x]);
		tocol(son[x][1],col[x]);
		col[x]=-1;
	}
}
void change1(int &x,int y,int z,int l,int r,ll cv){
	
	if(l>r){
		return ;
	}
	nn(x);
	if(y==l&&z==r){
		tomul(x,cv);
		return ;
	}
	pd(x);
	int mid=y+z>>1;
	if(r<=mid){
		change1(son[x][0],y,mid,l,r,cv);
	}else if(l>mid){
		change1(son[x][1],mid+1,z,l,r,cv);
	}else{
		change1(son[x][0],y,mid,l,mid,cv);
		change1(son[x][1],mid+1,z,mid+1,r,cv);
	}
}
void change2(int &x,int y,int z,int l,int r,ll cv){
	if(l>r){
		return ;
	}
	nn(x);
	if(y==l&&z==r){
		toad(x,cv);
		return ;
	}
	pd(x);
	int mid=y+z>>1;
	if(r<=mid){
		change2(son[x][0],y,mid,l,r,cv);
	}else if(l>mid){
		change2(son[x][1],mid+1,z,l,r,cv);
	}else{
		change2(son[x][0],y,mid,l,mid,cv);
		change2(son[x][1],mid+1,z,mid+1,r,cv);
	}
}
void change3(int &x,int y,int z,int l,int r,ll cv){
	if(l>r){
		return ;
	}
	nn(x);
	if(y==l&&z==r){
		tocol(x,cv);
		return ;
	}
	pd(x);
	int mid=y+z>>1;
	if(r<=mid){
		change3(son[x][0],y,mid,l,r,cv);
	}else if(l>mid){
		change3(son[x][1],mid+1,z,l,r,cv);
	}else{
		change3(son[x][0],y,mid,l,mid,cv);
		change3(son[x][1],mid+1,z,mid+1,r,cv);
	}
}
void change4(int &x,int y,int z,int l,int r,ll cv){
	if(l>r){
		return ;
	}
	nn(x);
	if(y==l&&z==r){
		toch(x,cv);
		return ;
	}
	pd(x);
	int mid=y+z>>1;
	if(r<=mid){
		change4(son[x][0],y,mid,l,r,cv);
	}else if(l>mid){
		change4(son[x][1],mid+1,z,l,r,cv);
	}else{
		change4(son[x][0],y,mid,l,mid,cv);
		change4(son[x][1],mid+1,z,mid+1,r,cv);
	}
}
ll ask(int &x,int y,int z,int p,bool flag,ll X){
	nn(x);
	if(y==z){
		FLAG=flag||flg[x];
		return (flag||flg[x])?col[x]:(ch[x]*X%MOD+ad[x])%MOD;
	}
	int mid=y+z>>1;
	pd(x);
	if(p<=mid){
		return ask(son[x][0],y,mid,p,flag||flg[x],X);
	}else{
		return ask(son[x][1],mid+1,z,p,flag||flg[x],X);
	}
}
void cdq(int L,int R,int l,int r){
	if(L==R){
		return ;
	}
	int MID=L+R>>1;
	int i,j;
	int mid=l-1;
	for(i=l;i<=r;i++){
		if(a[i].tim<=MID){
			mid++;
		}
	}
	int tl=l,tr=mid+1;
	for(i=l;i<=r;i++){
		if(a[i].tim<=MID){
			ta[tl++]=a[i];
		}else{
			ta[tr++]=a[i];
		}
	}
	memcpy(a+l,ta+l,sizeof(que)*(r-l+1));
	cdq(L,MID,l,mid);
	rt=TOT=0;
	ll mul=1,ad=0;
	bool FLG=0,FLG2=0;
	for(i=l;i<=mid;i++){
		if(a[i].c==0||a[i].c==-1){
			FLG=1;
			break;
		}
	}
	for(i=mid+1;i<=r;i++){
		if(a[i].c==1||a[i].c==2){
			FLG2=1;
			break;
		}
	}
	if(FLG&&FLG2){
		for(i=l;i<=mid;i++){
			if(a[i].c==0){
				(mul*=a[i].A11)%=MOD;
				(ad*=a[i].A11)%=MOD;
				(ad+=a[i].B11)%=MOD;
				if(a[i].A22!=0){
					change1(rt,1,n,a[i].x,a[i].y,a[i].A22);
					change2(rt,1,n,a[i].x,a[i].y,a[i].B22);
				}else{
					change3(rt,1,n,a[i].x,a[i].y,a[i].B22);
					change4(rt,1,n,a[i].x,a[i].y,1);
				}
			}
		}
		int flag=0;
		ll ts;
		bool fro=1;
		for(i=l,j=mid+1;j<=r;j++){
			while(i<=mid&&a[i].x<=a[j].x){
				if(a[i].c==0){
					fro=0;
					(ad+=MOD-a[i].B11)%=MOD;
					(mul*=a[i].nA11)%=MOD;
					(ad*=a[i].nA11)%=MOD;
					if(a[i].A12==0){
						flag++;
						ts=a[i].B12;
					}else{
						(mul*=a[i].A12)%=MOD;
						(ad*=a[i].A12)%=MOD;
						(ad+=a[i].B12)%=MOD;
					}
					if(a[i].A22!=0){
						change2(rt,1,n,a[i].x,a[i].y,MOD-a[i].B22);
						change1(rt,1,n,a[i].x,a[i].y,a[i].nA22);
						change1(rt,1,n,a[i].y+1,n,a[i].A22);
						change2(rt,1,n,a[i].y+1,n,a[i].B22);
					}else{
						change4(rt,1,n,a[i].x,a[i].y,-1);
						change3(rt,1,n,a[i].y+1,n,a[i].B22);
						change4(rt,1,n,a[i].y+1,n,1);
					}
					if(a[i].A11!=0){
						change1(rt,1,n,a[i].x,a[i].y,a[i].A21);
						change2(rt,1,n,a[i].x,a[i].y,a[i].B21);
					}else{
						change3(rt,1,n,a[i].x,a[i].y,a[i].B21);
						change4(rt,1,n,a[i].x,a[i].y,1);
					}
				}
				if(a[i].c==-1){
					if(fro){
						i++;
						continue ;
					}
					if(a[i].nA12==0){
						flag--;
					}else{
						(ad+=MOD-a[i].B12)%=MOD;
						(mul*=a[i].nA12)%=MOD;
						(ad*=a[i].nA12)%=MOD;
					}
					(mul*=a[i].A11)%=MOD;
					(ad*=a[i].A11)%=MOD;
					(ad+=a[i].B11)%=MOD;
					//*
					swap(a[i].x,a[i].y);
					a[i].y--;
					//*/
					if(a[i].A22!=0){
						change2(rt,1,n,a[i].y+1,n,MOD-a[i].B22);
						change1(rt,1,n,a[i].y+1,n,a[i].nA22);
					}else{
						change4(rt,1,n,a[i].y+1,n,-1);
					}
					a[i].y++;
					swap(a[i].x,a[i].y);
				}
				i++;
			}
			if(a[j].c==1){
				fro=0;
				FLAG=0;
				ans[a[j].tim]=ask(rt,1,n,a[j].y,0,ans[a[j].tim]);
				if(FLAG){
					qinding[a[j].tim]=1;
					frog[a[j].tim]=ans[a[j].tim];
				}
			}
			if(a[j].c==2){
				fro=0;
				if(flag){
					qinding[a[j].tim]=1;
					frog[a[j].tim]=ts;
				}else{
					ans[a[j].tim]=(mul*ans[a[j].tim]+ad)%MOD;
				}
			}
		}
	}
	cdq(MID+1,R,mid+1,r);
	tl=l,tr=mid+1;
	for(i=l;i<=r;i++){
		if((cmpl(a[tl],a[tr])&&tl<=mid)||tr>r){
			ta[i]=a[tl++];
		}else{
			ta[i]=a[tr++];
		}
	}
	memcpy(a+l,ta+l,sizeof(que)*(r-l+1));
}
int main(){
	//*/
	memset(ans,-1,sizeof(ans));
	int i,j,o,x,y;
	ine[0]=ine[1]=1;
	for(i=2;i<MAXN;i++){
		ine[i]=(MOD-MOD/i)*ine[MOD%i]%MOD;
	}
	n=read();
	m=read();
	bool hhh=0;
	bool hhhh=1;
	for(i=1;i<=m;i++){
		o=read();
		if(o==1){
			tot++;
			a[tot].tim=i;
			a[tot].c=0;
			L[i]=read();
			R[i]=read();
			a[tot].x=L[i];
			a[tot].y=R[i];
			a[tot].A11=MOD-1;
			a[tot].B11=1;
			a[tot].A12=(L[i]-R[i]+1+MOD)*ine[R[i]-L[i]+1]%MOD;
			a[tot].B12=(R[i]-L[i])*ine[R[i]-L[i]+1]%MOD;
			a[tot].A21=(R[i]-L[i]-3+MOD)*ine[R[i]-L[i]+1]%MOD;
			a[tot].B21=2*ine[R[i]-L[i]+1]%MOD;
			a[tot].A22=(R[i]-L[i]-1+MOD)*ine[R[i]-L[i]+1]%MOD;
			a[tot].B22=ine[R[i]-L[i]+1];
			a[tot].nA11=mi(a[tot].A11,MOD-2);
			a[tot].nA12=mi(a[tot].A12,MOD-2);
			a[tot].nA21=mi(a[tot].A21,MOD-2);
			a[tot].nA22=mi(a[tot].A22,MOD-2);
			tot++;
			a[tot]=a[tot-1];
			a[tot].c=-1;
			swap(a[tot].x,a[tot].y);
			a[tot].x++;
		}
		if(o==2){
			hhh=1;
			tot++;
			a[tot].tim=i;
			a[tot].x=read();
			a[tot].y=read();
			if(a[tot].x==1){
				a[tot].x=a[tot].y;
				a[tot].c=2;
			}else{
				a[tot].x--;
				a[tot].c=1;
			}
			ans[i]=1;
		}
	}
	sort(a+1,a+tot+1,cmpl);
	cdq(1,m,1,tot);
	for(i=1;i<=tot;i++){
		if(ans[i]!=-1){
			if(qinding[i]){
				printf("%lld\n",frog[i]);
			}else{
				printf("%lld\n",ans[i]);
			}
		}
	}
	return 0;
}

/*
5 5
2 3 5
1 3 4
2 1 5
2 5 5
1 3 4




*/


neither_nor
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
bzoj 3730. 震波（动态点分治 + vector树状数组）
01-06
因为子树树形被破坏，在做减法时，子节点子树对父节点的贡献不能用子树维护的信息 + 连向父节点的边的贡献得到，考虑在每个节点再维护一个线段树，按距离建树用来统计子树内的节点到其父节点距离为 p 的点权和，这样...
ZJOI2017 树状数组
Akakii的博客
03-25 1348
题解可以注意到，假的树状数组实际上是求后缀和。那么对于每个询问，真的树状数组查询的和是[l,r][l,r]，假的查询的和是[l−1,r−1][l-1,r-1]，它们的区别只有l−1l-1和rr这两个端点。 考虑用一个树套树维护这个东西。第一维是左端点，第二维是右端点。 对于每个修改操作，都在对应地区间上打上保持不变的概率标记。 现在问题是如何合并两个保持不变的概率的标记。设两个概率为别为p1,
【ZJOI2017】树状数组
psc233的博客
03-21 151
题意：树状数组 解析：由于他把树状数组写反了，再由于树状数组维护信息的本质可得它实际上得到的值为区间[l-1,r-1]的值的和，于是我们就很容易的发现一个事实就是如果l-1与r两个位置上的值相同，那么最终询问就是正确的值（以下值均在膜2意义下） 但是由于是两个位置，一维的数据结构必然支撑不起这样的信息维护，那么我们就只能用二维的树套树（矩阵信息显然可以合并） 那么我们考虑一下修改时显然可以分...
[ZJOI2017]树状数组
七代目鸽影
03-21 127
树套树。
BZOJ4785: [Zjoi2017]树状数组
commonc的博客
03-29 1514
题目大意：给了一种错误的实现树状数组方式，每次随机在一个区间里修改一个值，问每次询问得到的答案是正确的概率首先我们可以慢慢琢磨一下这份代码：发现其实他就是在求后缀和 然后由于模2，其实整道题都相当于在异或 这样每次Query(L,R)=Find(R)−Find(L−1)=Xor(R,n)⊕Xor(L−1,n)=Xor(L−1,R−1)Query(L,R)=Find(R)-Find(L-1)=Xo
[BZOJ4785][ZJOI2017]树状数组（树套树）
女装的你，如此好看！
10-15 635
可以发现，这个树状数组实际上求的是后缀和。而这样子求出的区间和，只有l−1l-1和rr两个点的差别。于是第二问就转化成A[l−1]=A[r]A[l-1]=A[r]的概率，但是要特判l=1l=1的情况（l=1l=1时正确的概率为∑ri=1A[i]≡∑ni=rA[i](mod2)\sum_{i=1}^rA[i]\equiv\sum_{i=r}^nA[i](\mod 2)的概率）。 这里设f(i,j)f
BZOJ全代码
02-05
BZOJ平台全部代码，解压到一个文件夹在打开使用。BZOJ平台全部代码，解压到一个文件夹在打开使用。
BZOJ第一部分
11-03
BZOJ原题-BZOJP1000-P2000的题目，下载后可以离线做题。
BZOJ3230相似子串测试数据
08-19
BZOJ3230相似子串的测试数据，希望能够帮到大家。
bzoj problem
08-21
八中OJ所有题目
【ZJOI2017】树状数组 题解
Four's
03-25 1608
题目大意      ~~~~~~有一个错误的树状数组，它的修改往前走，询问往后走（find(0) 的时候返回 0）。       ~~~~~~现在有一个初始全 0 的序列，有两种操作：       ~~~~~~1 x y：在区间 [ x, y ] 中等概率随机一个 i，然后 a[i]=(a[i]+1)%2       ~~~~~~2 x y：询问 ( a[x]+…+a[y] )%2
[BZOJ4785][ZJOI2017]树状数组-二维线段树-概率与期望
「嫌われ者のフィロソフィ」
02-21 411
树状数组Description漆黑的晚上，九条可怜躺在床上辗转反侧。难以入眠的她想起了若干年前她的一次悲惨的OI 比赛经历。那是一道基础的树状数组题。给出一个长度为 n 的数组 A，初始值都为 0，接下来进行 m 次操作，操作有两种：1 x，表示将 Ax 变成 (Ax + 1) mod 2。 2 l r，表示询问 sigma(Ai) mod 2,L<=i<=r 尽管那个时候的可怜非常的 simp
BZOJ4785 [Zjoi2017]树状数组
Welcome to yjjr's blog!
02-13 362
标签：树套树 题目 题目传送门 Description 漆黑的晚上，九条可怜躺在床上辗转反侧。难以入眠的她想起了若干年前她的一次悲惨的OI 比赛经历。那是一道 基础的树状数组题。给出一个长度为 n 的数组 A，初始值都为 0，接下来进行 m 次操作，操作有两种： 1 x，表示将 Ax 变成 (Ax + 1) mod 2。 2 l r，表示询问 sigma(Ai) mod 2,L&...
[ZJOI2017] 树状数组
HT008的Blog
03-28 301
题目描述： 雾 题目分析： 那么对于每个询问，如果l!=1，那么我们查询的其实是[l−1,r−1]这段区间。而[l−1,r−1]与[l,r]仅有l−1和r这两个元素有区别。所以我们每次询问就是问l−1和r 的修改次数在模2意义下是否相等。 那么我们可以把每个询问看成(l−1,r) 这个点，那么这就是个二维选点问题了，我们用树套树来维护。外层的树维护第一维坐标，内层的树维护第二维坐标...
[Zjoi2017]bzoj4785 树状数组
chenyanbo1111的博客
03-31 686
这是一道神题。 结论题。 考场上我居然只打了暴搜，连dp都没敲。 省选debuff挺高的啊其实是因为我是蒟蒻智商不够 这题是非常可做的。 考完订正时，借着题解推了推，很快—— 当询问的l>1时，是问l-1~r-1与l~r的答案是否一样。 当l==1时，是询问到点r的前缀和是否等于后缀和。 无脑树套树啊。 我的常数丑了uoj上额外数据T了，97分；bzoj上约19.5s过了。 C
UOJ#291. 【ZJOI2017】树状数组
wxh010910
03-25 1149
链接:http://uoj.ac/problem/291 二维数点 首先推一推性质大概可以发现这是单点修改,求后缀和 (其实也可以理解为区间(前缀)修改,单点查询) 然后再简单推一推就可以知道如果i被修改了a[i]次,总共修改了sum次 如果l=1,算错的情况就是sum ^ a[r] = 1 否则就是a[l - 1] ^ a[r] = 1 然后如果只是单点查询,我们就可以直接线段树
bzoj4785 UOJ #291 ZJOI2017 Day1 树状数组
Jason Victor Yan's
03-24 993
解题思路可以打表发现 错误的树状数组ii对jj产生贡献当且仅当i≥ji\geq j. 正确的树状数组ii对jj产生贡献当且仅当i≤ji\leq j. 那么可以发现假如我的一个询问l,rl,r,产生贡献的位置只可能是l−1l-1或rr.那现在的操作就很简单了，对于一个修改，他的产生贡献的区间可以按照他的端点来分类讨论，然后就直接上树套树就好了。参考程序#include<cstdio> #incl
P3688 [ZJOI2017]树状数组
wamach的博客
03-29 792
Scarlet：为什么你爆零那么熟练？ wamach：QAQ
[Zjoi2017]树状数组
yzyyylx的博客
12-08 252
题面 题意 有点难以描述 将树状数组的两种操作写反后，维护单点异或（只有0和1），区间异或，则与答案正确的概率是多少。 做法 首先可以发现树状数组这样写反后维护的不是前缀和是后缀和，因此如果l-r的区间异或和与正确答案相同，则第l-1个数与第r个数相等，因此可以用而为线段树来维护x和y不同的概率，每次修改时根据修改位置与区间的关系讨论即可，而对于查询区间的左端点为1的情况则要特判，发现此时就是询问...
bzoj 1040 zjoi2008 骑士 树形dp
最新发布
08-08
我们可以使用树形dp来解决这个问题，具体来说，我们可以将这个图看作是一棵树，每个点的父节点是它的前驱或者后继，然后我们从根节点开始，依次向下遍历，对于每个节点，我们可以考虑它的两个儿子，如果它的两个儿子...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值