园龄：3年10个月粉丝：25 关注：14

来北京随便做做题

CF680D *2400

呃这题真的搞了好久啊，理解能力变差了。

我们假设我们最大可以走到的下标是 $x_i$ ，最小可以走到的下标是 $x_j$ 。那么答案就是 $x_i-x_j+1$ 。

而我们发现这个下标一定是累计得到的，就比如第 $3$ 时刻的下标一定是 $a_1+a_2+a_3$ ，也就是前缀和。所以在不考虑往 $0$ 的地方填数的情况下，答案就是 $\max\{\max\{s\}-\min\{s\}+1\}$ 。

回到我们一开的假设，根据那个假设，我们可以把这只狗行走的部分分成三段。我们不妨设这只狗先走到最小的下标再走到最大的下标，反之亦然。

第一部分， $[1,x_{i-1}]$ 。这一段是这只狗从起点走到最小的下标的过程。
第二部分， $[1,x_j]$ 。这一段是这只狗从起点最大的下标的过程。
第三部分， $[1,n]$ 。这一段是这只狗经过了前面一系列移动最后又回到零点的过程。

那么我们发现，真正影响答案的就是 $[x_{i-1},x_j]$ 。这一部分向扩展的越多，那么我们答案也就越大。

考虑到 $n\le 3000$ ，那我们不妨 $O(n^2)$ 枚举 $x_i$ 和 $x_j$ 。

我们假设当前这段区间 $[x_i,x_j]$ 已知能扩展的和是 $\text{sum}$ ， $0$ 的个数是 $\text{zero}$ 那么这段区间最多能扩展到的地方是 $\text{sum}+\text{zero}\times k$ 。

但我们必须要明白一点，就是我们扩展到了最大值有些时候是无法回到零点的。所以我们同时也要算出这段区间外的两个区间总共走了多少，给我们留下了多少的走动空间，

我们不妨调整一下顺序，把 $[x_{i-1},x_j]$ 单独考虑。剩下两断合并到一起走，这样显然不影响结果。

那我们同样假设这两段已经扩展的和是 $\text{sum}$ ， $0$ 的个数是 $\text{zero}$ 。

那么这一段留给 $[x_{i-1},x_j]$ 空余能走的地方是 $\text{sum}-\text{zero}\times k$ 。至于为什么这里是减号，还记得我们一开始做的假设吗？我们设这只狗先走到最小的下标再走到最大的下标，所以 $[x_{i-1},x_j]$ 这一段一定是全部向右走，所以剩下两断区间合并起来就是全部向左走，因为最后要回到 $0$ 。

最后说一下无解的判断，如果这个数列 $|s_n|$ 的和大于零的个数乘以 $k$ 的话，那么必然无解，因为这样就算零的部分全填 $k$ （或 $-k$ ），都无法达到
$|s_n|$ 。

看看关键代码。

 	//sum 就是前缀和数组，d 是零的个数
	int tmp=sum[r]-sum[l-1];int cnt=d[r]-d[l-1];//这个是算[x_{i-1},x_j] 这个区间的和以及0的个数
	int tmpp=sum[n]-tmp;int cntt=d[n]-cnt;//剩下两个区间
	ans=max(ans,min(abs(tmp+cnt*k),abs(tmpp-cntt*k)));//先走到最小值再走到最大值
	ans=max(ans,min(abs(tmp-cnt*k),abs(tmpp+cntt*k)));//先走到最大值再走到最小值

CF1746F Kazaee *2800

我靠，难死我了。最后被 rand 卡了几个小时。

具体思路很有趣，xor hash，不过严格意义上这个是 sum hash。

这题题解太多了就不交了。

就是我们发现如果一段区间内每个数出现的次数都是 $k$ 的正整数倍，那么这一段区间的和一定是 $k$ 的倍数。

所以我们可以每次给 $a_i$ 随机加上一个权值 $w_i$ 然后每一次判断一下这一段的和是不是 $k$ 是不是 $k$ 的倍数。

具体地，我们使用卡时的方法，重复随机权值并计算。对于每次询问，只要有一次计算出不满足条件就输出 NO。

就好了。

 #include<bits/stdc++.h>
using namespace std;
#define int long long
const int N=7e5+10;
const int mod=1004535809;
int a[N],c[N],tmp[N],l[N],r[N],k[N],rd[N],lsh[N];
int n,sz,q;
bool ans[N];
mt19937 rnd(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count());
int randint(int L, int R) {
	uniform_int_distribution<int> dist(L, R);
	return dist(rnd);
}
int lowbit(int x){return x&-x;}
void add(int x,int k){
	while(x<=n){
		c[x]+=k;
		x+=lowbit(x);
	}
}
int gsum(int x){
	int sum=0;
	while(x){
		sum+=c[x];
		x-=lowbit(x);
	}
	return sum;
}
int query(int l,int r){
	return gsum(r)-gsum(l-1);
}
signed main(){
	srand(time(0));
	cin>>n>>q;for(int i=1;i<=n;i++){cin>>a[i];lsh[++sz]=a[i];}
	for(int i=1;i<=q;i++){
		int opt;cin>>opt;
		if(opt==1) {cin>>l[i]>>r[i];lsh[++sz]=r[i];}
		else{cin>>l[i]>>r[i]>>k[i];}
	}
	sort(lsh+1,lsh+1+sz);
	sz=unique(lsh+1,lsh+1+sz)-lsh-1;
	for(int i=1;i<=n;i++){a[i]=lower_bound(lsh+1,lsh+1+sz,a[i])-lsh;}
	for(int i=1;i<=q;i++){
		if(k[i]==0){
			r[i]=lower_bound(lsh+1,lsh+1+sz,r[i])-lsh;
		}
	}
	while(clock()<CLOCKS_PER_SEC*2.8){
		for(int i=1;i<=sz;i++) rd[i]=randint(0, mod-1);
		for(int i=1;i<=n;i++) c[i]=0;
		for(int i=1;i<=n;i++) tmp[i]=rd[a[i]];
	 	for(int i=1;i<=n;i++) add(i,tmp[i]);
	 	for(int i=1;i<=q;i++){
	 		if(k[i]==0) {
	 			add(l[i],rd[r[i]]-tmp[l[i]]);
	 			tmp[l[i]]=rd[r[i]];
                                //呃原理大概是 l[i]=tmp[l[i]] 所以 rd[r[i]]-tmp[l[i]]+tmp[l[i]]=rd[r[i]] 所以实现了改变？
	 		}
	 		else{
				if((r[i]-l[i]+1)%k[i]) {ans[i]=true;continue;}
	 			if(query(l[i],r[i])%k[i]) ans[i]=true;
	 		}
	 	}
	}
	for(int i=1;i<=q;i++) {if(k[i]){if(ans[i]==1) puts("NO");else puts("YES");}}
	return 0;
}

CF1646 Playing Around the Table *2900

讲真这题挺简单的，就是想到中间状态很难。

牛逼题。

1：1 2 3 4

2：2 3 4 1

3：3 4 1 2

4：4 1 2 3

我们发现，如果要是当前情况变成了这样，那么是一定可以用 $\frac{n \times (n-1)}{2}$ 步调整完毕。

具体地，循环移位，好像解释起来很困难。放一个中间结果理解一下 n=5。

点击查看代码

 1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
 
 
1 1 3 4 5
1 2 2 4 5
1 2 3 3 5
1 2 3 4 4
2 3 4 5 5
 
__________________
 
1 1 2 4 5
1 2 2 3 5
1 2 3 3 4
2 3 4 4 5
1 3 4 5 5
 
 
1 1 1 4 5
1 2 2 2 5
1 2 3 3 3
2 3 4 4 4
3 4 5 5 5
 
__________________
 
1 1 1 3 5
1 2 2 2 4
2 3 3 3 5
1 3 4 4 4
2 4 5 5 5
 
 
1 1 1 2 5
1 2 2 2 3
2 3 3 3 4
3 4 4 4 5
1 4 5 5 5
 
 
1 1 1 1 5
1 2 2 2 2
2 3 3 3 3
3 4 4 4 4
4 5 5 5 5
 
__________________
 
1 1 1 1 4
2 2 2 2 5
1 3 3 3 3
2 4 4 4 4
3 5 5 5 5
 
 
1 1 1 1 3
2 2 2 2 4
3 3 3 3 5
1 4 4 4 4
2 5 5 5 5
 
 
1 1 1 1 2
2 2 2 2 3
3 3 3 3 4 
4 4 4 4 5
1 5 5 5 5
 
 
1 1 1 1 1
2 2 2 2 2
3 3 3 3 3
4 4 4 4 4
5 5 5 5 5
 
__________________

这个状态我们称之为，中间态，那么如何调整成中间态呢。

注意，因为每个人手中的牌顺序不分先后，所以变成中间态后我们可以全部都当成由小到大排序处理，方便理解。

因此，我们只需要将每一个人手里的牌变成 $1 \to n$ 即可。方法很弱智。

每次找到第一个有重复元素的人，然后把重复的向下传递，下一个人如果有重复的就传递重复的，没有就把上一个人传递过来的传递到下一个人，以此类推。

这样必然可以在有限步内完成传递。可以证明这个步数是 $\frac{n \times (n-1)}{2}$ ，但具体证明我也不太会所以先咕着。

然后这题代码感觉很有难度，稍微写点注释。

 int check(){
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			if(cnt[i][j]>1) return i; //如果有重复的就返回当前人，这就找到了第一个有重复元素的人
		}
	}
	return 0;
}
void pre(){//变为目标状态
	while(1){
		int nwep=check();int las=0;//las 是当前传递的元素
		if(nwep==0) break;//如果没有找到有重复的就已经是中间态了，break出来
		sz++;//这是一次操作
		for(int j=1;j<=n;j++){
			if(cnt[nwep][j]>1){//找到重复元素
				cnt[nwep][j]--;//因为要传递下去，所以个数减一
				ans[sz][nwep]=las=j;//ans[i][j]表示第i步第j个人传递的数
                                //这里只给cnt[nwep][j]--的原因是你只知道要传递给谁但不知道谁传递给他，因为要绕一周才能传递回来
				break;
			}
		}
		for(int i=nwep%n+1;i!=nwep;i=i%n+1){//这样就很好的完成了一周的传递，技巧+1，这个枚举的是人
			bool flag=0;
			for(int j=1;j<=n;j++){
				if(cnt[i][j]>1){//如果当前这个元素重复
					cnt[i][j]--;cnt[i][las]++;//这里可以直接加是因为不用绕一圈，直接传过来了
					ans[sz][i]=las=j;//更新答案和接下来要继续传递的值		
					flag=1;
					break;
				}
			}
			if(flag==0) ans[sz][i]=las;//如果一次都没更新过证明当前人已经是目标状态了，把前面那个人船体过来的东西原封不动传递下去
		}
		cnt[nwep][las]++;//此时已经转了一圈回来了，所以更新第一个人的
	}
}
int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			int x;cin>>x;cnt[i][x]++;//提前记录出现次数
		}
	}
	pre();
	for(int i=2;i<=n;i++){//这里要开始传递了，这里是枚举第一个移动哪个，参考上面例子，语言解释不清楚了（
		for(int j=1;j<i;j++){
			sz++;//一步
			for(int k=1;k<=n;k++){
				int val=(k+i-j+n)%n;//这里就是阴间循环移位，k+i-j+n 对应了当前移动哪个
				if(val==0) val=n;
				ans[sz][k]=val;//改答案
                                //按理来讲这里还要改一下那个桶数组，不过因为不会用到就去掉了
			}
		}
	}
	cout<<sz<<"\n";
	for(int i=1;i<=sz;i++){
		for(int j=1;j<=n;j++){
			// if(ans[i][j]==0) cout<<"worng: "<<i<<endl;
			cout<<ans[i][j]<<" ";//输出
		}
		cout<<"\n";
	}
	return 0;
}

CF1646E Power Board *2200

呃蛮简单题。

第一行单独处理。

我们考虑如果第 $i$ 行的 $i$ 可以被表示为 $d^k$ 那么他就有可能重复。考虑如果 $d$ 不一样的话一定不会有重复，所以我们单独考虑 $k$ 。

显然 $k$ 的上限是 $\log_d^n$ 。

我们发现对于一个 $i$ ，他给答案的贡献是 $1\times 1, 1\times 2....1\times m, 2 \times 1, 2\times 2.....2\times m .....k\times 1....k\times m$ 中不同数的个数。

考虑到 $k$ 的最大值是 $20$ ，所以我们可以直接枚举 $k$ 和 $m$ 然后开个桶来预处理出每个 $k$ 的贡献。

计算的时候我们对于每一个 $i$ 求出他的 $k$ ，然后把所有 $\le n$ 并可以表示为 $i^x$ 的数标记掉，因为我们刚刚在计算 $i$ 的时候已经把他贡献算过了。

 #include<bits/stdc++.h>
using namespace std;
#define int long long
const int N=1e6+1e4;
bool vis[N*20];
int viss[N],cnt,ans[N],sum;
int n,m;
signed main(){
	cin>>n>>m;
	for(int i=1;i<=20;i++){
		for(int j=1;j<=m;j++){
			if(vis[i*j]==0){
				vis[i*j]=1;
				cnt++;
			}
		}
		ans[i]=cnt;
		// cout<<ans[i]<<" ";
	}
	// cout<<endl;
	for(int i=2;i<=n;i++){
		if(viss[i]==1) continue;
		int tmp=i,po=0;
		while(tmp<=n){
			// cout<<tmp<<"qwq\n";
			po++;
			// cout<<po<<endl;
//			cout<<tmp<<" "<<i<<" "<<tmp*i<<endl;
			tmp*=i;
			if(tmp>n) break;
//			cout<<tmp<<endl;
			viss[tmp]=1;
		}
		// cout<<tmp<<" "<<po<<endl;
		sum+=ans[po];
	}
	cout<<sum+1;
	return 0;
}

CF1545D AquaMoon and Wrong Coordinate *3000

这题他妈的就不是人能想出来的。

注意以下题解默认初始位置是 $1$ 时刻。

首先我们确定哪一行出了问题是平凡的。

在 $t$ 时刻时，这些点的坐标和应该是 $\sum_{i=1}^n x_i+t\times v_i$ 。

在 $t+1$ 时刻时，这些点的坐标和应该是 $\sum_{i=1}^n x_i+(t+1)\times v_i$ 。

然后把这两个式子相减发现是 $\sum{i=1}^n v_i$ ，至于这个 $v_i$ 是多少并不重要，因为 $v_i$ 不会变，所以我们把每个时刻的坐标和相减，我们找到 第一个 $x$ 使得第 $x$ 行减去第 $x-1$ 行的值与其他的值不同，那么问题出在第 $x$ 行上。

确定哪一行，如何确定具体该改多少呢。这里就要用到人类智慧了。

我们考虑记函数 $f(t)=\sum_{i=1}^m(x_i+t\times v_i)^2$ 即每一行位移的平方和。

我们展开一下 $f(t+1)$ 与 $f(t-1)$ ，发现一个式子。

$f(t+1)+f(t-1)-2*f(t)=\sum_{i=1}^m 2v_i$ 。

所以可以得到，任意连续三个时刻的坐标的平方和同样是固定的。

而我们又知道哪一时刻出了问题，所以我们枚举这一时刻的每一个坐标把他改成 $k$ ，如果哪一次改了之后上式的值与正常的值相等，那么这个位置就要改成 $k$ ，这题就做完了。

还有几个细节，第一个是应该改成什么。

我们假设两个时刻时间应该差 $x$ 但实际上差了 $y$ ，那么因为我们假设了其他位置没错，所以一定是这个位置的问题，所以说当前坐标应该 $-y+x$ 。

然后还有因为我们连续最后一步要连续取三个时刻当作标准值，所以如果问题出在前三个，那么标准值就取 $t=5,6,7$ 时刻的 $f(t)$ ，否则就取前三个。

具体看代码。

 	for(int i=2;i<=k;i++){
		if(mp[s[i]-s[i-1]]==1){
			flag=i;
			if(i<=3) flag2=5;
			else flag2=2;
			break;
		}
	}
	cout<<flag-1<<" ";//这里要减一是因为题目默认初始时刻是0，而我是按照1处理的
	int tmp=s[flag2+1]-s[flag2];int tmp2=v[flag2+1]+v[flag2-1]-2*v[flag2];
	for(int i=1;i<=n;i++){
		int ans=pos[flag][i]-(s[flag]-s[flag-1])+tmp;
		// cout<<ans<<" "<<tmp<<" "<<" "<<s[flag]-s[flag-1]<<endl;
		if(v[flag+1]+v[flag-1]-2*(v[flag]+ans*ans-pos[flag][i]*pos[flag][i])==tmp2){
			cout<<ans<<"\n";
			cout.flush();
			return 0;
		}	
	}

CF896C *2600

ODT 模板题。

大概思路就是用一个set来维护，然后就暴力。感觉很神奇，但复杂度为什么是对的我也不知道。

 // LUOGU_RID: 103272881
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int mod=1e9+7;
const int N=1e5+10;
int ksm(int a,int b,int mod){
	int ret=1;a%=mod;
	while(b){
		if(b&1) ret=ret*a%mod;
		a=a*a%mod;a%=mod;b>>=1;
	}
	return ret%mod;
}
int a[N],n,m,seed,vmax;
int rnd(){
	int ret=seed;
	seed=(seed*7+13)%mod;
	return ret;
}
struct node{
	int l,r;
	mutable int v;
	node(int l,int r=0,int v=0):l(l),r(r),v(v){}
	bool operator <(const node &a) const{
		return l<a.l;
	}
};
set<node> s;
set<node>::iterator split(int pos){
	set<node>::iterator it=s.lower_bound(node(pos));
	// cout<<it->v<<endl;
	if(it!=s.end() and it->l==pos){
		return it;
	}
	it--;if(it->r<pos) return s.end();
	int l=it->l;int r=it->r;int v=it->v;
	s.erase(it);s.insert(node(l,pos-1,v));
	return s.insert(node(pos,r,v)).first;
}
void add(int l,int r,int x){
	// cout<<"qwq\n";
	set<node>::iterator itr=split(r+1),itl=split(l);
	for(set<node>::iterator i=itl;i!=itr;i++){
		i->v+=x;
	}
	// cout<<"qwq\n";
}
void change(int l,int r,int x){
	set<node>::iterator itr=split(r+1),itl=split(l);
	s.erase(itl,itr);
	s.insert(node(l,r,x));
}
struct nodee{
	nodee(){}
	int num,cnt;
	bool operator <(const nodee &a) const{
		return num<a.num;
	}
	nodee(int num,int cnt): num(num),cnt(cnt){}
}rk[N];
int rnk(int l,int r,int x){
	set<node> ::iterator itr=split(r+1),itl=split(l);
	int sz=0;
	for(set<node>::iterator i=itl;i!=itr;i++){
		rk[++sz]=nodee(i->v,i->r-i->l+1);
	}
	sort(rk+1,rk+1+sz);
	int k;
	for(k=1;k<=sz;k++){
		if(x>rk[k].cnt) x-=rk[k].cnt;
		else break;
	}
	return rk[k].num;
 
}
int calc(int l,int r,int x,int y){
	set<node> ::iterator itr=split(r+1),itl=split(l);
	int ans=0;
	for(set<node>::iterator i=itl;i!=itr;i++){
		ans+=(ksm(i->v,x,y)*(i->r-i->l+1)%y)%y;
		ans%=y;
	}
	return ans;
}
signed main(){
	cin>>n>>m>>seed>>vmax;
	for(int i=1;i<=n;i++){
		a[i]=(rnd()%vmax)+1;
		s.insert(node(i,i,a[i]));
	}
	for(int i=1;i<=m;i++){
		int op=(rnd()%4)+1;
		int l=(rnd()%n)+1;
		int r=(rnd()%n)+1;int x=0,y=0;
		if(l>r) swap(l,r);
		if(op==3) x=(rnd()%(r-l+1))+1;
		else x=(rnd()%vmax)+1;
		if(op==4) y=(rnd()%vmax)+1;
		if(op==1){add(l,r,x);}
		if(op==2){change(l,r,x);}
		if(op==3){cout<<rnk(l,r,x)<<"\n";}
		if(op==4){cout<<calc(l,r,x,y)<<"\n";}
	}
	return 0;
}

把几个用珂朵莉树草过去的给挂着，思路不写，太简单了（

P4344 SHOI2015 脑洞治疗仪紫

CF817F MEX Queries *2300

P2572 [SCOI2010] 序列操作紫

思路不难想，类似小白逛公园。维护八个值，0/1 的个数，从左/右边开始的最长连续0/1的个数，整个区间的 0/1 个数，然后直接模仿小白逛公园就可以了。但为啥查询还有push_up啊，迷惑。写了 4.5k，困难的。

 #include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
struct node{
	int w,b,lw,lb,rw,rb,mw,mb,l,r,len,add,add2;//add 区间反转 add2 区间赋值
	// node(int w=0,int b=0,int lw=0,int lb=0,int rw=0,int rb=0,int mw=0,int mb=0,int l=0,int r=0,int len=0,int add=0,int add2=0): 
	// w(w),b(b),lw(lw),lb(lb),rw(rw),rb(rb),mw(mw),mb(mb),l(l),r(r),len(len),add(add),add2(add2){}
}t[N*4];
int n,m,a[N];
void out_put(int p){
	cout<<p<<" "<<t[p].add<<" "<<t[p].w<<" "<<t[p].b<<" "<<t[p].lw<<" "<<t[p].lb<<" "<<t[p].rw<<" "<<t[p].rb<<" "<<t[p].mw<<" "<<t[p].mb<<endl;
}
void push_up(int p){
	// if(p==4){
	// 	out_put(8);out_put(9);
	// }
	t[p].w=t[p*2].w+t[p*2+1].w;t[p].b=t[p*2].b+t[p*2+1].b;
	if(t[p*2].b==0) t[p].lw=(t[p*2].w+t[p*2+1].lw);
	else t[p].lw=t[p*2].lw;
	if(t[p*2].w==0) t[p].lb=(t[p*2].b+t[p*2+1].lb);
	else t[p].lb=t[p*2].lb;
	if(t[p*2+1].b==0) t[p].rw=(t[p*2].rw+t[p*2+1].w);
	else t[p].rw=t[p*2+1].rw;
	if(t[p*2+1].w==0) t[p].rb=(t[p*2].rb+t[p*2+1].b);
	else t[p].rb=t[p*2+1].rb;
	t[p].mw=max(max(t[p*2].mw,t[p*2+1].mw),t[p*2].rw+t[p*2+1].lw);
	t[p].mb=max(max(t[p*2].mb,t[p*2+1].mb),t[p*2].rb+t[p*2+1].lb);
	// if(p==2){cout<<"qwq ";out_put(p);out_put(p*2);out_put(p*4+1);}
}
void build(int l,int r,int p){
	t[p].l=l;t[p].r=r;t[p].len=r-l+1;t[p].add2=-1;
	if(l==r){
		if(a[l]==0){
			t[p].w=0;t[p].b=1;t[p].lw=0;t[p].lb=1;t[p].rw=0;t[p].rb=1;t[p].mw=0;t[p].mb=1;
		}
		else{
			t[p].w=1;t[p].b=0;t[p].lw=1;t[p].lb=0;t[p].rw=1;t[p].rb=0;t[p].mw=1;t[p].mb=0;
		}
		return ;
	}
	int mid=(l+r)/2;
	build(l,mid,p*2);build(mid+1,r,p*2+1);push_up(p);
}
void push_down(int p){
	if(t[p].add2==0){//区间赋0
		t[p*2].add2=0;t[p*2+1].add2=0;t[p*2].add=0;t[p*2+1].add=0;
		t[p*2].w=0;t[p*2].lw=0;t[p*2].rw=0;t[p*2].mw=0;
		t[p*2+1].w=0;t[p*2+1].lw=0;t[p*2+1].rw=0;t[p*2+1].mw=0;
		t[p*2].b=t[p*2].len;t[p*2].lb=t[p*2].len;t[p*2].rb=t[p*2].len;t[p*2].mb=t[p*2].len;
		t[p*2+1].b=t[p*2+1].len;t[p*2+1].lb=t[p*2+1].len;t[p*2+1].rb=t[p*2+1].len;t[p*2+1].mb=t[p*2+1].len;
		t[p].add2=-1;
	}
	if(t[p].add2==1){//区间赋1
		t[p*2].add2=1;t[p*2+1].add2=1;t[p*2].add=0;t[p*2+1].add=0;
		t[p*2].w=t[p*2].len;t[p*2].lw=t[p*2].len;t[p*2].rw=t[p*2].len;t[p*2].mw=t[p*2].len;
		t[p*2+1].w=t[p*2+1].len;t[p*2+1].lw=t[p*2+1].len;t[p*2+1].rw=t[p*2+1].len;t[p*2+1].mw=t[p*2+1].len;
		t[p*2].b=0;t[p*2].lb=0;t[p*2].rb=0;t[p*2].mb=0;
		t[p*2+1].b=0;t[p*2+1].lb=0;t[p*2+1].rb=0;t[p*2+1].mb=0;
		t[p].add2=-1;
	}
	if(t[p].add!=0){//区间反转
		t[p*2].add^=1;t[p*2+1].add^=1;
		swap(t[p*2].w,t[p*2].b);swap(t[p*2].lw,t[p*2].lb);swap(t[p*2].rw,t[p*2].rb);swap(t[p*2].mw,t[p*2].mb);
		swap(t[p*2+1].w,t[p*2+1].b);swap(t[p*2+1].lw,t[p*2+1].lb);swap(t[p*2+1].rw,t[p*2+1].rb);swap(t[p*2+1].mw,t[p*2+1].mb);
		t[p].add=0;
	}
}
void change(int l,int r,int p,int k){
	if(l<=t[p].l and t[p].r<=r){
		if(k==0){
			t[p].add=0;
			t[p].w=0;t[p].lw=0;t[p].rw=0;t[p].mw=0;
			t[p].b=t[p].len;t[p].lb=t[p].len;t[p].rb=t[p].len;t[p].mb=t[p].len;
			t[p].add2=0;
		} 
		if(k==1){
			t[p].add=0;
			t[p].b=0;t[p].lb=0;t[p].rb=0;t[p].mb=0;
			t[p].w=t[p].len;t[p].lw=t[p].len;t[p].rw=t[p].len;t[p].mw=t[p].len;
			t[p].add2=1;
		}
		if(k==2){
			swap(t[p].w,t[p].b);swap(t[p].lw,t[p].lb);swap(t[p].rw,t[p].rb);swap(t[p].mw,t[p].mb);
			t[p].add^=1;
		}
		// cout<<k<<" "<<t[p].l<<" "<<t[p].r<<" "<<t[p].add<<endl;
		// push_down(p);
		// out_put(p);
		// out_put(2);
		return ;
	}
	int mid=(t[p].l+t[p].r)/2;
	push_down(p);push_up(p);
	if(l<=mid) change(l,r,p*2,k);
	if(r>mid) change(l,r,p*2+1,k);
	push_down(p);push_up(p);
}
node query(int l,int r,int p){
	if(l<=t[p].l and t[p].r<=r)	return t[p];
	int mid=(t[p].l+t[p].r)/2;
	push_down(p);push_up(p);
	node ans;
	if(r<=mid)	ans=query(l,r,p*2);
	else if(l>mid)	ans=query(l,r,p*2+1);
	else{
		node tmp=query(l,r,p*2);
		node tmp2=query(l,r,p*2+1);
		ans.w=tmp.w+tmp2.w;
		ans.b=tmp.b+tmp2.b;
		if(tmp.b==0) ans.lw=(tmp.w+tmp2.lw);
		else ans.lw=tmp.lw;
		if(tmp.w==0) ans.lb=(tmp.b+tmp2.lb);
		else ans.lb=tmp.lb;
		if(tmp2.b==0) ans.rw=(tmp.rw+tmp2.w);
		else ans.rw=tmp2.rw;
		if(tmp2.w==0) ans.rb=(tmp.rb+tmp2.b);
		else ans.rb=tmp2.rb;
		ans.mw=max(max(tmp.mw,tmp2.mw),tmp.rw+tmp2.lw);
		ans.mb=max(max(tmp.mb,tmp2.mb),tmp.rb+tmp2.lb);
	}
	push_up(p);
	return ans;
}
int main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++) cin>>a[i];
	build(1,n,1);
	while(m--){
		int opt,l,r;cin>>opt>>l>>r;
		l++;r++;
		if(opt==0){
			change(l,r,1,0);
		}
		if(opt==1){
			change(l,r,1,1);
			// cout<<t[2].w<<endl;
		}
		if(opt==2){
			change(l,r,1,2);
		}
		else{
			if(opt==3) cout<<query(l,r,1).w<<"\n";
			else if(opt==4) cout<<query(l,r,1).mw<<"\n";
		}
	}
	return 0;
}

P4979 矿洞：坍塌蓝

线段树入门题。维护一个颜色就可以了，1/2/3 分别是全A/B/C，-1 表示混色。

最后查询不用直接返回合不合法，如果这个区间是纯色那么返回区间的颜色就可以了，否则返回 -1

判断合法的条件就是 [l,r] 返回值不为 -1 且 [l-1,l-1]，[r+1,r+1] 不相同。有两种情况例外，l=1 或者 r=n 。

 #include<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
char s[N];
int a[N],n,k;
struct node{
	int l,r,col,add;
}t[N*4];
void push_up(int p){
	if(t[p*2].col==t[p*2+1].col) t[p].col=t[p*2].col;
	else t[p].col=-1;
}
void push_down(int p){
	if(t[p].add!=-1){
		t[p*2].col=t[p].add;t[p*2+1].col=t[p].add;
		t[p*2].add=t[p].add;t[p*2+1].add=t[p].add;
		t[p].add=-1;
	}
}
void build(int l,int r,int p){
	t[p].l=l;t[p].r=r;t[p].add=-1;
	if(l==r){
		t[p].col=a[l];
		return ;
	}
	int mid=(l+r)>>1;
	build(l,mid,p*2);build(mid+1,r,p*2+1);push_up(p);
}
void change(int l,int r,int p,int k){
	// cout<<l<<" "<<r<<" "<<p<<" "<<k<<endl;
	if(l<=t[p].l and t[p].r<=r){
		t[p].add=k;t[p].col=k;
		push_down(p);
		return ;
	}
	push_down(p);
	int mid=(t[p].l+t[p].r)>>1;
	if(l<=mid) change(l,r,p*2,k);
	if(r>mid) change(l,r,p*2+1,k);
	push_up(p);
}
int query(int l,int r,int p){
	if(l==0 or r==n+1) return 0;
	if(l<=t[p].l and t[p].r<=r) return t[p].col;
	int mid=(t[p].l+t[p].r)>>1;
	push_down(p);
	int col1=0,col2=0;
	if(l<=mid) col1=query(l,r,p*2);
	if(r>mid) col2=query(l,r,p*2+1);
	if(col1==0) return col2;
	if(col2==0) return col1;
	if(col1==-1 or col2==-1) return -1;
	if(col1==col2) return col1;
	return -1;
}
int main(){
	cin>>n>>(s+1);
	for(int i=1;i<=n;i++){a[i]=s[i]-'A'+1;}
	build(1,n,1);
	cin>>k;
	while(k--){
		char opt,op;int x,y;
		cin>>opt>>x>>y;
		if(opt=='B'){
			int fr=query(x-1,x-1,1);int bc=query(y+1,y+1,1);
			int ret=query(x,y,1);
			// cout<<ret<<" "<<fr<<" "<<bc<<endl;
			if(ret==-1) cout<<"No\n";
			else if(ret!=-1 and (fr!=bc or x==1 or y==n)) cout<<"Yes\n";
			else cout<<"No\n";
		}
		if(opt=='A'){cin>>op;change(x,y,1,op-'A'+1);}
	}
	return 0;
}

上一篇模拟退火学习笔记

下一篇来宁波随便听听课做做题

本文作者：zplqwq

本文链接：https://www.cnblogs.com/zplqwq/p/17144367.html

posted @ 2023-02-22 14:54 zplqwq 阅读(77) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

残雪

来北京随便做做题

公告

常用链接

我的标签

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

	//sum 就是前缀和数组，d 是零的个数
	int tmp=sum[r]-sum[l-1];int cnt=d[r]-d[l-1];//这个是算[x_{i-1},x_j] 这个区间的和以及0的个数
	int tmpp=sum[n]-tmp;int cntt=d[n]-cnt;//剩下两个区间
	ans=max(ans,min(abs(tmp+cntk),abs(tmpp-cnttk)));//先走到最小值再走到最大值
	ans=max(ans,min(abs(tmp-cntk),abs(tmpp+cnttk)));//先走到最大值再走到最小值

	#include<bits/stdc++.h>
	using namespace std;
	#define int long long
	const int N=7e5+10;
	const int mod=1004535809;
	int a[N],c[N],tmp[N],l[N],r[N],k[N],rd[N],lsh[N];
	int n,sz,q;
	bool ans[N];
	mt19937 rnd(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count());
	int randint(int L, int R) {
	uniform_int_distribution<int> dist(L, R);
	return dist(rnd);
	}
	int lowbit(int x){return x&-x;}
	void add(int x,int k){
	while(x<=n){
	c[x]+=k;
	x+=lowbit(x);
	}
	}
	int gsum(int x){
	int sum=0;
	while(x){
	sum+=c[x];
	x-=lowbit(x);
	}
	return sum;
	}
	int query(int l,int r){
	return gsum(r)-gsum(l-1);
	}
	signed main(){
	srand(time(0));
	cin>>n>>q;for(int i=1;i<=n;i++){cin>>a[i];lsh[++sz]=a[i];}
	for(int i=1;i<=q;i++){
	int opt;cin>>opt;
	if(opt==1) {cin>>l[i]>>r[i];lsh[++sz]=r[i];}
	else{cin>>l[i]>>r[i]>>k[i];}
	}
	sort(lsh+1,lsh+1+sz);
	sz=unique(lsh+1,lsh+1+sz)-lsh-1;
	for(int i=1;i<=n;i++){a[i]=lower_bound(lsh+1,lsh+1+sz,a[i])-lsh;}
	for(int i=1;i<=q;i++){
	if(k[i]==0){
	r[i]=lower_bound(lsh+1,lsh+1+sz,r[i])-lsh;
	}
	}
	while(clock()<CLOCKS_PER_SEC*2.8){
	for(int i=1;i<=sz;i++) rd[i]=randint(0, mod-1);
	for(int i=1;i<=n;i++) c[i]=0;
	for(int i=1;i<=n;i++) tmp[i]=rd[a[i]];
	for(int i=1;i<=n;i++) add(i,tmp[i]);
	for(int i=1;i<=q;i++){
	if(k[i]==0) {
	add(l[i],rd[r[i]]-tmp[l[i]]);
	tmp[l[i]]=rd[r[i]];
	//呃原理大概是 l[i]=tmp[l[i]] 所以 rd[r[i]]-tmp[l[i]]+tmp[l[i]]=rd[r[i]] 所以实现了改变？
	}
	else{
	if((r[i]-l[i]+1)%k[i]) {ans[i]=true;continue;}
	if(query(l[i],r[i])%k[i]) ans[i]=true;
	}
	}
	}
	for(int i=1;i<=q;i++) {if(k[i]){if(ans[i]==1) puts("NO");else puts("YES");}}
	return 0;
	}

	1 2 3 4 5
	1 2 3 4 5
	1 2 3 4 5
	1 2 3 4 5
	1 2 3 4 5


	1 1 3 4 5
	1 2 2 4 5
	1 2 3 3 5
	1 2 3 4 4
	2 3 4 5 5

	__________________

	1 1 2 4 5
	1 2 2 3 5
	1 2 3 3 4
	2 3 4 4 5
	1 3 4 5 5


	1 1 1 4 5
	1 2 2 2 5
	1 2 3 3 3
	2 3 4 4 4
	3 4 5 5 5

	__________________

	1 1 1 3 5
	1 2 2 2 4
	2 3 3 3 5
	1 3 4 4 4
	2 4 5 5 5


	1 1 1 2 5
	1 2 2 2 3
	2 3 3 3 4
	3 4 4 4 5
	1 4 5 5 5


	1 1 1 1 5
	1 2 2 2 2
	2 3 3 3 3
	3 4 4 4 4
	4 5 5 5 5

	__________________

	1 1 1 1 4
	2 2 2 2 5
	1 3 3 3 3
	2 4 4 4 4
	3 5 5 5 5


	1 1 1 1 3
	2 2 2 2 4
	3 3 3 3 5
	1 4 4 4 4
	2 5 5 5 5


	1 1 1 1 2
	2 2 2 2 3
	3 3 3 3 4
	4 4 4 4 5
	1 5 5 5 5


	1 1 1 1 1
	2 2 2 2 2
	3 3 3 3 3
	4 4 4 4 4
	5 5 5 5 5

	__________________

	int check(){
	for(int i=1;i<=n;i++){
	for(int j=1;j<=n;j++){
	if(cnt[i][j]>1) return i; //如果有重复的就返回当前人，这就找到了第一个有重复元素的人
	}
	}
	return 0;
	}
	void pre(){//变为目标状态
	while(1){
	int nwep=check();int las=0;//las 是当前传递的元素
	if(nwep==0) break;//如果没有找到有重复的就已经是中间态了，break出来
	sz++;//这是一次操作
	for(int j=1;j<=n;j++){
	if(cnt[nwep][j]>1){//找到重复元素
	cnt[nwep][j]--;//因为要传递下去，所以个数减一
	ans[sz][nwep]=las=j;//ans[i][j]表示第i步第j个人传递的数
	//这里只给cnt[nwep][j]--的原因是你只知道要传递给谁但不知道谁传递给他，因为要绕一周才能传递回来
	break;
	}
	}
	for(int i=nwep%n+1;i!=nwep;i=i%n+1){//这样就很好的完成了一周的传递，技巧+1，这个枚举的是人
	bool flag=0;
	for(int j=1;j<=n;j++){
	if(cnt[i][j]>1){//如果当前这个元素重复
	cnt[i][j]--;cnt[i][las]++;//这里可以直接加是因为不用绕一圈，直接传过来了
	ans[sz][i]=las=j;//更新答案和接下来要继续传递的值
	flag=1;
	break;
	}
	}
	if(flag==0) ans[sz][i]=las;//如果一次都没更新过证明当前人已经是目标状态了，把前面那个人船体过来的东西原封不动传递下去
	}
	cnt[nwep][las]++;//此时已经转了一圈回来了，所以更新第一个人的
	}
	}
	int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
	for(int j=1;j<=n;j++){
	int x;cin>>x;cnt[i][x]++;//提前记录出现次数
	}
	}
	pre();
	for(int i=2;i<=n;i++){//这里要开始传递了，这里是枚举第一个移动哪个，参考上面例子，语言解释不清楚了（
	for(int j=1;j<i;j++){
	sz++;//一步
	for(int k=1;k<=n;k++){
	int val=(k+i-j+n)%n;//这里就是阴间循环移位，k+i-j+n 对应了当前移动哪个
	if(val==0) val=n;
	ans[sz][k]=val;//改答案
	//按理来讲这里还要改一下那个桶数组，不过因为不会用到就去掉了
	}
	}
	}
	cout<<sz<<"\n";
	for(int i=1;i<=sz;i++){
	for(int j=1;j<=n;j++){
	// if(ans[i][j]==0) cout<<"worng: "<<i<<endl;
	cout<<ans[i][j]<<" ";//输出
	}
	cout<<"\n";
	}
	return 0;
	}

	for(int i=2;i<=k;i++){
	if(mp[s[i]-s[i-1]]==1){
	flag=i;
	if(i<=3) flag2=5;
	else flag2=2;
	break;
	}
	}
	cout<<flag-1<<" ";//这里要减一是因为题目默认初始时刻是0，而我是按照1处理的
	int tmp=s[flag2+1]-s[flag2];int tmp2=v[flag2+1]+v[flag2-1]-2*v[flag2];
	for(int i=1;i<=n;i++){
	int ans=pos[flag][i]-(s[flag]-s[flag-1])+tmp;
	// cout<<ans<<" "<<tmp<<" "<<" "<<s[flag]-s[flag-1]<<endl;
	if(v[flag+1]+v[flag-1]-2(v[flag]+ansans-pos[flag][i]*pos[flag][i])==tmp2){
	cout<<ans<<"\n";
	cout.flush();
	return 0;
	}
	}

	// LUOGU_RID: 103272881
	#include<bits/stdc++.h>
	using namespace std;
	#define int long long
	const int mod=1e9+7;
	const int N=1e5+10;
	int ksm(int a,int b,int mod){
	int ret=1;a%=mod;
	while(b){
	if(b&1) ret=ret*a%mod;
	a=a*a%mod;a%=mod;b>>=1;
	}
	return ret%mod;
	}
	int a[N],n,m,seed,vmax;
	int rnd(){
	int ret=seed;
	seed=(seed*7+13)%mod;
	return ret;
	}
	struct node{
	int l,r;
	mutable int v;
	node(int l,int r=0,int v=0):l(l),r(r),v(v){}
	bool operator <(const node &a) const{
	return l<a.l;
	}
	};
	set<node> s;
	set<node>::iterator split(int pos){
	set<node>::iterator it=s.lower_bound(node(pos));
	// cout<<it->v<<endl;
	if(it!=s.end() and it->l==pos){
	return it;
	}
	it--;if(it->r<pos) return s.end();
	int l=it->l;int r=it->r;int v=it->v;
	s.erase(it);s.insert(node(l,pos-1,v));
	return s.insert(node(pos,r,v)).first;
	}
	void add(int l,int r,int x){
	// cout<<"qwq\n";
	set<node>::iterator itr=split(r+1),itl=split(l);
	for(set<node>::iterator i=itl;i!=itr;i++){
	i->v+=x;
	}
	// cout<<"qwq\n";
	}
	void change(int l,int r,int x){
	set<node>::iterator itr=split(r+1),itl=split(l);
	s.erase(itl,itr);
	s.insert(node(l,r,x));
	}
	struct nodee{
	nodee(){}
	int num,cnt;
	bool operator <(const nodee &a) const{
	return num<a.num;
	}
	nodee(int num,int cnt): num(num),cnt(cnt){}
	}rk[N];
	int rnk(int l,int r,int x){
	set<node> ::iterator itr=split(r+1),itl=split(l);
	int sz=0;
	for(set<node>::iterator i=itl;i!=itr;i++){
	rk[++sz]=nodee(i->v,i->r-i->l+1);
	}
	sort(rk+1,rk+1+sz);
	int k;
	for(k=1;k<=sz;k++){
	if(x>rk[k].cnt) x-=rk[k].cnt;
	else break;
	}
	return rk[k].num;

	}
	int calc(int l,int r,int x,int y){
	set<node> ::iterator itr=split(r+1),itl=split(l);
	int ans=0;
	for(set<node>::iterator i=itl;i!=itr;i++){
	ans+=(ksm(i->v,x,y)*(i->r-i->l+1)%y)%y;
	ans%=y;
	}
	return ans;
	}
	signed main(){
	cin>>n>>m>>seed>>vmax;
	for(int i=1;i<=n;i++){
	a[i]=(rnd()%vmax)+1;
	s.insert(node(i,i,a[i]));
	}
	for(int i=1;i<=m;i++){
	int op=(rnd()%4)+1;
	int l=(rnd()%n)+1;
	int r=(rnd()%n)+1;int x=0,y=0;
	if(l>r) swap(l,r);
	if(op==3) x=(rnd()%(r-l+1))+1;
	else x=(rnd()%vmax)+1;
	if(op==4) y=(rnd()%vmax)+1;
	if(op==1){add(l,r,x);}
	if(op==2){change(l,r,x);}
	if(op==3){cout<<rnk(l,r,x)<<"\n";}
	if(op==4){cout<<calc(l,r,x,y)<<"\n";}
	}
	return 0;
	}

	#include<bits/stdc++.h>
	using namespace std;
	const int N=1e6+10;
	char s[N];
	int a[N],n,k;
	struct node{
	int l,r,col,add;
	}t[N*4];
	void push_up(int p){
	if(t[p2].col==t[p2+1].col) t[p].col=t[p*2].col;
	else t[p].col=-1;
	}
	void push_down(int p){
	if(t[p].add!=-1){
	t[p2].col=t[p].add;t[p2+1].col=t[p].add;
	t[p2].add=t[p].add;t[p2+1].add=t[p].add;
	t[p].add=-1;
	}
	}
	void build(int l,int r,int p){
	t[p].l=l;t[p].r=r;t[p].add=-1;
	if(l==r){
	t[p].col=a[l];
	return ;
	}
	int mid=(l+r)>>1;
	build(l,mid,p2);build(mid+1,r,p2+1);push_up(p);
	}
	void change(int l,int r,int p,int k){
	// cout<<l<<" "<<r<<" "<<p<<" "<<k<<endl;
	if(l<=t[p].l and t[p].r<=r){
	t[p].add=k;t[p].col=k;
	push_down(p);
	return ;
	}
	push_down(p);
	int mid=(t[p].l+t[p].r)>>1;
	if(l<=mid) change(l,r,p*2,k);
	if(r>mid) change(l,r,p*2+1,k);
	push_up(p);
	}
	int query(int l,int r,int p){
	if(l==0 or r==n+1) return 0;
	if(l<=t[p].l and t[p].r<=r) return t[p].col;
	int mid=(t[p].l+t[p].r)>>1;
	push_down(p);
	int col1=0,col2=0;
	if(l<=mid) col1=query(l,r,p*2);
	if(r>mid) col2=query(l,r,p*2+1);
	if(col1==0) return col2;
	if(col2==0) return col1;
	if(col1==-1 or col2==-1) return -1;
	if(col1==col2) return col1;
	return -1;
	}
	int main(){
	cin>>n>>(s+1);
	for(int i=1;i<=n;i++){a[i]=s[i]-'A'+1;}
	build(1,n,1);
	cin>>k;
	while(k--){
	char opt,op;int x,y;
	cin>>opt>>x>>y;
	if(opt=='B'){
	int fr=query(x-1,x-1,1);int bc=query(y+1,y+1,1);
	int ret=query(x,y,1);
	// cout<<ret<<" "<<fr<<" "<<bc<<endl;
	if(ret==-1) cout<<"No\n";
	else if(ret!=-1 and (fr!=bc or x==1 or y==n)) cout<<"Yes\n";
	else cout<<"No\n";
	}
	if(opt=='A'){cin>>op;change(x,y,1,op-'A'+1);}
	}
	return 0;
	}