2021CCPC网络赛（重赛）题解

自己还是太菜了，五个小时一个题也没磕出来，还是队友牛逼！...

Primality Test

先看这个题，可能一上去就被$\frac{f(x)+f(f(x))}{2}$向下取整吓住了，但仔细想想，$f(x)$与$f(f(x))$不是相邻的质数吗？那么除2，向下取整，落点一定在两者之间，那么一定是合数。当然除了2,3的特例，这种特判下即可。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
int main()
{
	int T;cin>>T;
	while(T--)
	{
		ll x;cin>>x;
		if(x==1) cout<<"YES"<<endl;
		else cout<<"NO"<<endl;
	}
	return 0;
}

为什么这么简单的题，我当初看了那么长的时间都没看出来。

发现这个题的主要难点在于以当前i(c[i]='h')为结尾的字串为nunhehheh的方案数。我们大胆的设状态，仔细考虑dp所代表的的集合，以及进行转移。设f[i][j]表示前i位，其中第i位匹配到nunhehheh的第j位的方案数。那么若c[i]=s[j]，我们考虑枚举上一个字符也就是s[j-1]出现的位置，f[i][j]=f[k][j-1].其中c[k]==s[j-1].但这种方法显然是O(n^2)的。考虑转移时，其实f[k][j-1],只要是j-1即可，我们大可以用一个数组g[j]表示前i个字符中以某个点为j结尾的方案数。这样的话转移时就是O(1)的。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=1e5+10,P=998244353;
int T,n,f[N][12],cnt[N],g[12];
char c[N];
string s;
inline ll power(ll x,ll y)
{
	ll ans=1;
	while(y)
	{
		if(y&1) ans=ans*x%P;
		y>>=1;
		x=x*x%P;
	}
	return ans%P;
}
inline void clear()
{
	for(int i=0;i<=n+1;++i)
	{
		cnt[i]=0;
		for(int j=0;j<=10;++j) f[i][j]=0;
	}
	memset(g,0,sizeof(g));
}
int main()
{
	//freopen("1.in","r",stdin);
	scanf("%d",&T);
	s="2nunhehheh";
	while(T--)
	{
		scanf("%s",c+1);
		n=strlen(c+1);
		clear();
		for(int i=n;i>=1;--i)
		{
			cnt[i]=cnt[i+1];
			if(c[i]=='a') cnt[i]++;
		}
		ll ans=0;
		for(int i=1;i<=n;++i)
		{
			for(int j=9;j>=1;--j)//匹配nunhehheh的每一位。
			{
				if(c[i]==s[j])
				{
					f[i][j]=g[j-1];
					if(j==1) f[i][j]=1;
					g[j]=(g[j]+f[i][j])%P;
					if(j==9) ans=(ans+(ll)f[i][j]*(power(2,cnt[i])-1)%P)%P;
				}
			}
		}
		printf("%lld\n",ans);
	}
	return 0;
}

Monopoly

哎呀，这个题，感觉自己当时的思路已经很接近了，但是还是输给了对于分类讨论的复杂性的恐惧，加上当时没有一个完整的思路进行支撑，就弃疗了。

首先我们设$S$为整个序列的和，$s_i$为第i位的前缀和，那么可以有这个式子$s_i+kS=x(k>=0,1\leq i\leq n)$，其中只有$S,x$已知，我们做适当的调整，$kS=x-s_i$，这样的话$x-s_i$必须是$S$的正整数（以及0）的倍数。那么可以想到$x,s_i$对$S$同余，也就是说余数相同。这样的话，我们可以对$s_i$根据对$S$的余数进行分类，每次询问的x只在模数相同的一类中找。接下来考虑最小化$i+k*n$的值，这个时候我们可以讨论S>0，那么为了满足倍数的关系，必须满足$s_i\leq x$，同时为了k足够小，我们需要找到的$s_i$足够大，(你把这个过程放在数轴上想)。也就是小于等于x的最大值。这不是二分吗？我们再在每一类中进行排序，直接二分查找即可。接下来考虑S<0的情况，我们可以将序列中的每个数取反，再将x取反即可。注意当S=0时，系统会报错，单独讨论这种情况。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=1e5+10;
int T,n,m,num;
map<ll,int>mp;//map表示序列号。
map<ll,int>id[N];//余数为i的数字为j的最小的i。
vector<ll>ve[N];
ll s[N];
inline void clear()
{
	mp.clear();num=0;
	for(int i=0;i<=n;++i)
	{
		s[i]=0;
		id[i].clear();
		ve[i].clear();
	}
}
inline void solve()
{
	mp[0]=0;
	for(int i=1;i<=n;++i)
	{
		if(mp.find(s[i])==mp.end())
			mp[s[i]]=i;
	}
	for(int i=1;i<=m;++i)
	{
		ll x;scanf("%lld",&x);
		if(mp.find(x)==mp.end()) puts("-1");
		else printf("%d\n",mp[x]);
	}
}
int main()
{
//	freopen("1.in","r",stdin);
	scanf("%d",&T);
	while(T--)
	{
		scanf("%d%d",&n,&m);
		clear();
		for(int i=1;i<=n;++i)
		{
			ll x;scanf("%lld",&x);
			s[i]=s[i-1]+x;
		}
		if(s[n]==0) {solve();continue;}
		int op=1;if(s[n]<0) op=-1;
		ll S=s[n]*op;
		for(int i=0;i<=n;++i)
		{
			s[i]*=op;
			ll ps=(s[i]%S+S)%S;
			if(mp.find(ps)==mp.end()) mp[ps]=++num;
			if(id[mp[ps]].find(s[i])==id[mp[ps]].end())
			{
				id[mp[ps]][s[i]]=i;
				ve[mp[ps]].push_back(s[i]);
			}
		}
		for(int i=1;i<=num;++i) sort(ve[i].begin(),ve[i].end());
		for(int i=1;i<=m;++i)
		{
			ll x;scanf("%lld",&x);
			x*=op;
			if(x==0) {puts("0");continue;}
			ll ps=(x%S+S)%S;
			if(mp.find(ps)==mp.end()||ve[mp[ps]][0]>x) {puts("-1");continue;}
			int j=mp[ps];
			int k=upper_bound(ve[j].begin(),ve[j].end(),x)-ve[j].begin()-1;
			ll so=ve[j][k];
			ll ans=id[j][so]+((x-so)/S)*n;
			printf("%lld\n",ans);
		}
	}
	return 0;
}

Jumping Monkey

这个题当初还是队友做出来的，自己主要是思路就没想到那一块去。由于每次从一个点出发一直跳，跳的最多的点的个数，想想其实问你的就是从这个点出发能跳到哪些点去，因为这些点我们可以按点权从小到大排序依次跳就完事了。当初困在了DP的思维上，想不出来好的转移方式。后来看了看题解大大的做法，其实是图论的知识吧，也不对就是思维的问题吧。我们考虑先将所有的点从小到大排序，依次考虑每个点能否到达点i，这样点i一定比之前的点权大，只要联通即可。也就是重新建图加边的问题。考虑当前是一个空白的图，我们依次将每个点加进去，考虑哪些点能到达当前这个点的话，就是连通块的问题，若当前点能够连到某个连通块，则这个连通块内的所有点都能到达这个点，那么这些点的答案都加1.然后将这个点及其连到的点合并成一个新的连通块即可。考虑整个需要我们维护的操作就是加上点，连通块整个的值加1，合并连通块。对于连通块的做法，我只会并查集，其实并查集就是维护连通块是否联通的问题，顺带记录一些信息。接下来就是这个题的精妙之处，我们发现，我们每次都是将一个连通块的值都加1，我们可以将加进去的点i当做根节点，这样的话那些连通块的深度就加1，符合我们的要求，我们只需要将点i向原本这个连通块的根节点连边即可。但这样不就打乱了原本的土的结构了吗？其实我们没必要维护原本的土的结构，我们还需要在一个点i加进去之后，那些连通块的点都可以加1就行。

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int T,n,f[N],a[N],b[N],d[N];
vector<int>son[N];
vector<int>bian[N];
map<pair<int,int>,bool>mp;
inline void clear()
{
	mp.clear();
	for(int i=1;i<=n;++i)
	{
		son[i].clear();
		bian[i].clear();
		f[i]=i;b[i]=i;
		d[i]=0;
	}
}
inline bool cmp(int x,int y) {return a[x]<a[y];}
inline int getf(int x) {return f[x]==x?x:f[x]=getf(f[x]);}
inline void dfs(int x)
{
	for(auto y:bian[x])
	{
		d[y]=d[x]+1;
		dfs(y);
	}
}
int main()
{
//	freopen("1.in","r",stdin);
	scanf("%d",&T);
	while(T--)
	{
		scanf("%d",&n);
		clear();
		for(int i=1;i<n;++i)
		{
			int x,y;scanf("%d%d",&x,&y);
			son[x].push_back(y);
			son[y].push_back(x);
		}
		for(int i=1;i<=n;++i) scanf("%d",&a[i]);
		sort(b+1,b+n+1,cmp);
		for(int i=1;i<=n;++i)//依次加入每一个点。
		{
			int x=b[i];
			for(auto y:son[x])//遍历i的每一个出边
			{
				if(a[y]>a[x]) continue;
				int t=getf(y);
				if(mp.find({x,t})==mp.end())
				{
					mp[{x,t}]=1;
					bian[x].push_back(t);
					f[t]=x;
				}
			}
		}
		d[b[n]]=1;
		dfs(b[n]);
		for(int i=1;i<=n;++i) printf("%d\n",d[i]);
	}
	return 0;
}

Public Transport System

这个题当初也是想了好久没出来，显然因为如果$a_i>a_{i-1}$的话我们走当前的边权的值就为$a_i-b_i$，这就使得我们必须记录当前点的上一条边是哪一条，想了想，其实所有的状态数也不多，即m个状态，毕竟只有m条边，每条边对应一个状态。但这个记录就只能用map实现，如果再跑dijkstra总的复杂度为O(mlognlogm)，m的范围为$1.2\times10^6$，这算出来，$6\times10^9$,好吧，我觉得出题人肯定就是专门卡这个暴力的....

瞅瞅题解大大的做法，原来是要重新建图，又是建图的问题，这种题不是只在网络流中考察吗？好吧，这次确实拓了眼界。首先先将两种边分开，因为两种边权的图，毕竟没有单边权的方便。考虑边权$a_i$的边，我们没什么限制条件，但对于边权为$a_i-b_i$的边，我们必须满足一定条件，也就是前一条边的$a_i$必须小于当前的$a_i$。我们可以发现由于一个之前的边对应的可走的边权为$a_i-b_i$的边的$a_i$是在一个区间的，所以这就给我们的优化带来了可能。（不是我说的，是题解说的。）具体的，我们可以这样做：首先设d为当前点x的出度，我们将x拆分成d+1个点，$（x_0,x_1,x_2,...,x_d）$,让他们分别管理这些$a_i-b_i$出边，其中所有边权为$a_i$的边由$x_0$管理。我们将x所有边权为$a_i-b_i$的出边按照$a_i$的从大到小排序，接下来将他们依次交给$x_i$管理(也就是$x_i$连排过序后为i的边)。我们接下来i从0到d-1，从$x_{i+1}$向$x_{i}$连边权为0的边。这样由于提前排过序，能从小的$a_i$走$a_i-b_i$的特殊边，一定能从大的$a_i$走$a_i-b_i$的特殊边。之后我们只需要根据每个入边找到相对应能走的最大的$x_i$，满足它所管理的边的$a_i$大于他的入边即可。

具体的如下图：

这样，一共的点为n+m,一共的边为2*m,即使m是$1.2\times 10^6$的数据量，我们跑dijkstra也完全没有问题。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=4e5+10;
int du[N],n,m,l[N],link[N],tot,vis[N];
ll dis[N];
//l[i]记录每个点拆出来的d+1个点的第一个点的编号。
vector<int>son[N];//记录每个点，对应的边的编号。
struct bian{int x,y,A,B;}b[N];
struct wy{int y,v,next;}a[N<<1];
priority_queue<pair<ll,int> >q;
inline void add(int x,int y,int v)
{
	a[++tot].y=y;a[tot].v=v;a[tot].next=link[x];link[x]=tot;
}
inline void clear()
{
	tot=0;
    for(int i=1;i<=n+m;++i) link[i]=0;
    for(int i=1;i<=n;++i) son[i].clear(),du[i]=0;
}
inline bool cmp(int x,int y)
{
	return b[x].A>b[y].A;
}
inline int find(int x,int A)//有一个ai的入边应该连向点x中的哪个点
{
	if(!du[x]||A>=b[son[x][0]].A) return l[x];//返回x0的情况。
	int L=0,R=du[x]-1;
	while(L<R)//在x的边中查找>A的最小的边。
	{
		int mid=L+R+1>>1;
		if(b[son[x][mid]].A>A) L=mid;
		else R=mid-1;
	}
	return l[x]+L+1;
} 
inline void dijkstra()
{
	while(q.size()) q.pop();
	for(int i=1;i<=n+m;++i)
	{
		dis[i]=1e18;
		vis[i]=0;
	}
	dis[l[1]]=0;q.push({0,l[1]});
	while(!q.empty())
	{
		int x=q.top().second;q.pop();
		if(vis[x]) continue;
		vis[x]=1;
		for(int i=link[x];i;i=a[i].next)
		{
			int y=a[i].y;
			if(dis[x]+a[i].v<dis[y])
			{
				dis[y]=dis[x]+a[i].v;
				q.push({-dis[y],y});
			}
		}
	}
}
int main()
{
//	freopen("1.in","r",stdin);
	int T;scanf("%d",&T);
	while(T--)
	{
		scanf("%d%d",&n,&m);
		clear();
		for(int i=1;i<=m;++i)
		{
			scanf("%d%d%d%d",&b[i].x,&b[i].y,&b[i].A,&b[i].B);
			son[b[i].x].push_back(i);
			du[b[i].x]++;
		}
		for(int i=1;i<=n;++i)
		{
			if(son[i].size())
				sort(son[i].begin(),son[i].end(),cmp);
		}
		int num=0;
		for(int i=1;i<=n;++i)  //给每个点分配编号且处理内部的边。
		{
			l[i]=++num; //l[i] - l[i]+du[i]是这个点所有拆出来的点的编号。
			for(int j=du[i];j>=1;--j) add(l[i]+j,l[i]+j-1,0);
			num+=du[i];
		}
		for(int i=1;i<=n;++i)//处理点i的所有边
		{
			int js=son[i].size();
			for(int j=0;j<js;++j)//枚举i的所有出边
			{
				int id=son[i][j];
				int y=find(b[id].y,b[id].A);
				add(l[i],y,b[id].A);//先处理边权为ai的。
				add(l[i]+j+1,y,b[id].A-b[id].B);
			}
		}
		dijkstra();
		for(int i=1;i<=n;++i)
		{
			if(dis[l[i]]==1e18) dis[l[i]]=-1;
			printf("%lld",dis[l[i]]);
			if(i!=n) printf(" ");
		}
		printf("\n");
	}
	return 0;
}