首师大附中集训第十六天综合模测

最新推荐文章于 2021-06-12 21:38:15 发布

原创最新推荐文章于 2021-06-12 21:38:15 发布 · 294 阅读

0 ·

CC 4.0 BY-SA版权

数论同时被 3 个专栏收录

49 篇文章

订阅专栏

搜索

20 篇文章

订阅专栏

思维好题

12 篇文章

订阅专栏

本文探讨了三道算法题目，包括字符串复制的最优路径选择、寻找满足特定条件的正整数数量，以及重新排列数组元素的策略。通过对各题目的深入解析，提出了解决方案并分享了实现代码。

正题

第一题：.字符串复制

定义一次变换： $S_i(j)=S_i(j-1)|S_{i-1}(j)$ 。

现在给出 $S_0,T$ ，问令 $S_i=T$ 的最小的 $i$ 是多少。

首先判断无解的方法就直接看一下下面出现字符的顺序是否可以对上S0中的一个子序列。

如果有的话，那么就可以构造一组解。考虑第一次变换之后是什么样子的：对于一个t中的连续子段 $l,r$ 必定对应一个S0中的位置x，那么我们将 $[x,min(r,next_x-1)]$ 覆盖，我们没办法覆盖下一个x的位置，否则下一个就没有办法覆盖。

我们知道第一次变换之后再考虑右端点每一次变换的移动，左端点是不用考虑的，因为是跟着上一个的右端点移动的。

很明显，假设第一次覆盖的右节点分别是 $r_1,r_2,...,r_k$ ，那么经过一次变换之后，每个右端点都会尽量往右靠。就会变成 $min(pos_1,r_2-1),min(pos_2,r_3-1),...,min(pos_ {n-1},r_{n-1}-1),r_n$ 。

其中pos_i表示的时候对应答案区间的右端点，一次变换不能覆盖下一个的右端点，因为覆盖的话下一个就没法移动了。

在经过一次变换之后就会发现会变成： $min(pos_i,r_{i+1}-1,r_{i+2}-2)$ 。

经过ty次变换之后就会发现会变成： $min(pos_i,r_{i+1}-1,r_{i+2}-2,...,r_{i+ty}-ty)$ 。

后面那个东西用一个单调队列维护就可以了。因为pos_i是单调的，所以产生贡献的 $r_i$ 会越来越少。

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<queue>
using namespace std;

queue<int> list;
int n,ans;
const int N=1e6+10;
char s[N],t[N];

int main(){
	scanf("%d",&n);
	scanf("%s %s",s+1,t+1);
	int pos=n;
	for(int i=n;i>=1;i--){
		if(t[i]==t[i-1]) continue;
		pos=min(pos,i);
		while(pos && s[pos]!=t[i]) pos--;
		if(!pos) {printf("-1");return 0;}
		while(!list.empty()){
			if(list.front()-list.size()+1>i) list.pop();
			else break;
		}
		list.push(pos);
		ans=max(ans,(int)list.size());
	}
	printf("%d",ans+1);
}

第二题：给出一个d，问有多少个正整数n满足 $rev(n)=n+d$ ，rev(n)表示n的翻转。

这题还是比较显然的：

把他表示成sigma的形式，就变成了：

$\\\sum_{i=0}^n a_{n-i}10^i=\sum_{i=0}^n a_i10^i +d \\\sum_{i=0}(a_{n-i}-a_i)10^i=d$

那么搜索我们每个位置上的差值，因为每一个位置上的差值最多只有两种。

因为不知道最后的正整数的位数，所以直接爆算20位，即可通过全部的测试点。

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
using namespace std;

int d,len=0;
int ans=0;
int p[25];

void dfs(int now,int d){
	if(now==len+1){
		int temp=9-abs(p[1]);
		for(int i=2;i<=(len+1)/2;i++) temp*=10-abs(p[i]);
		ans+=temp;
		return ;
	}
	if(now==len) {
		if(now==1) p[now]=d,dfs(now+1,0);
		else if(d+p[1]==0) dfs(now+1,0);
		return ;
	}
	if(now<=(len+1)/2){
		if(d%10==0) p[now]=0,dfs(now+1,d/10);
		else{
			p[now]=d%10;dfs(now+1,d/10);
			p[now]=d%10-10;dfs(now+1,d/10+1);
		}
	}
	else{
		if(d%10==0 && p[len-now+1]==0) dfs(now+1,d/10);
		else{
			if(d%10+p[len-now+1]==0) dfs(now+1,d/10);
			if(d%10-10+p[len-now+1]==0) dfs(now+1,d/10+1);
		}
	}
}

int main(){
	freopen("mirrored.in","r",stdin);
	freopen("mirrored.out","w",stdout);
	scanf("%d",&d);
	int x=d;while(x) len++,x/=10;
	int last=0;
	while(len<=20){
		dfs(1,d);
		if(ans==last) break;
		last=ans;
		len++;
	}
	printf("%d\n",ans);
}

第三题：rearranging

题解说很容易发现不互质的两对数的相对位置不变，所以就直接对于不互质的数，从小到大输出，对于互质的数，从大到小输出。

我也不知道为什么，想了半天。

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;

int n;
int a[2010];
vector<int> e[2010],next[2010];
bool vis[2010];
priority_queue<int> f;

int gcd(int x,int y){
	return y==0?x:gcd(y,x%y);
}

void ins(int x,int y){
	e[x].push_back(y);e[y].push_back(x);
}

void dfs(int x){
	vis[x]=true;
	for(int i=0;i<e[x].size();i++)
		if(!vis[e[x][i]]) next[x].push_back(e[x][i]),dfs(e[x][i]);
}

int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++) scanf("%d",&a[i]);
	sort(a+1,a+1+n);
	for(int i=1;i<=n;i++)
		for(int j=i+1;j<=n;j++) if(gcd(a[i],a[j])!=1) ins(i,j);
	for(int i=1;i<=n;i++) if(!vis[i]) dfs(i),f.push(i);
	while(!f.empty()){
		int x=f.top();f.pop();
		printf("%d ",a[x]);
		for(int i=0;i<next[x].size();i++) f.push(next[x][i]);
	}
}