2025年华为杯广东工业大学程序设计竞赛（A最短路，生成树，G数学，最大公因数，I贪心）

线上同步赛链接

最近有点堕落，在捣鼓一个 $bot$。然后实验室管事老师硬性要求所有实验室成员必须打这个线上赛，就随便签了一下到就润了。但是事后感觉这场 $A$ 还真不错，遂回来写一篇题解。感觉每次打比赛都能遇上两个好题，真是学无止境啊。

---

A 出勤规划

思路：

算是撞在我的好球区了，两眼秒了。这个题需要对 $dijkstra$ 和 $prim$ 算法思想的原理理解透彻，然后把这两个算法的思想结合起来。

$dijkstra$ 的主要思想是每次选取距离源点最近的点，并通过这个点尝试对其他点的距离进行松弛。核心代码如下：

struct Edge{
	int v,w;
};
vector<Edge> e[maxn];
struct Node{
	int u,dis;
	bool operator<(const Node a)const{
		return dis>a.dis;
	}
};
priority_queue<Node> h;

int d[maxn];
void dijkstra(int root){
	for(int i=1;i<=n;i++)d[i]=inf;
	d[root]=0;
	h.push({root,d[root]});
	while(!h.empty()){
		auto [u,dist]=h.top();
		h.pop();
		if(dist>d[u])continue;
		for(auto [v,w]:e[u]){
			if(d[u]+w<d[v]){
				d[v]=d[u]+w;
				h.push({v,d[v]});
			}
		}
	}
}

有些写法里有的会带上一个 $vis$ 数组，用来标记某个点是否已经访问过了。不过这里可以不写，因为可以保证取过的点一定不会被再次松弛了。

朴素的 $dijkstra$ 中，每次取出一个点，这个点（到源点）的距离就固定了，以后都不可能再变。因为当前堆中存在的点的距离都比当前取出的点的距离要大，同时这个图还不存在负环，这意味着你无论通过什么点，走什么路径，当你回到这个点的时候，距离一定不可能现在的距离要小了。因此你只需要每个点各取出过一次，单源最短路就算完了。

我一直觉得 $dijkstra$ 是一个动态规划问题，只不过它松弛的策略很聪明，能快速地进行剪枝，不需要枚举全部可能的转移。对于一些 $dijkstra$ 的变种问题，如果你以动态规划的思路去想，就会比较容易理解（一般都是每个点再开上一两维，以准确描述状态）。所以对变种问题，某个状态第一次从堆中取出它的时候，距离就确定了，性质依然成立。

一个 $dijkstra$ 变种题：Codeforces Round 918 (Div. 4) G. Bicycles

---

同理再来看看 $prim$ 算法。它的思想是每次选取距离生成树最近的点，并通过这个点尝试对其他点的距离进行松弛。核心代码如下：

struct Edge{
	int v,w;
};
vector<Edge> e[maxn];
struct Node{
	int u,dis;
	bool operator<(const Node a)const{
		return dis>a.dis;
	}
};
priority_queue<Node> h;

int d[maxn],ans;
bool vis[maxn];
void prim(int root){
	for(int i=1;i<=n;i++)d[i]=inf;
	d[root]=0;
	h.push({root,d[root]});
	while(!h.empty()){
		auto [u,dist]=h.top();
		h.pop();
		if(vis[u])continue;
		else vis[u]=true;
		for(auto [v,w]:e[u]){
			if(!vis[v] && w<d[v]){
				d[v]=w;
				h.push({v,d[v]});
			}
		}
	}
}

大体上没什么变化，除了多了一个 $vis$ 数组和判断条件。这里需要写 $vis$ 是因为不能保证取过的点不会被再次松弛。

判断条件变化是因为我们的 $d$ 数组的含义发生了变化，在最短路中它的含义是到源点的最短距离，在生成树中它的含义是到生成树的最短距离。你把加入生成树的所有点看成一个整体，把它看成一个大源点，就可以很好理解为什么判断条件是 $w<d[v]$ 了。

其实这里还有另一种理解方式：当某个点加入生成树后，它距离生成树的距离就变为了 $0$，然后我们再以这个点为中转点去松弛周围的点，所以判断条件就是 $d[u]+w<d[v]\Rightarrow 0+w<d[v]\Rightarrow w<d[v]$。这样理解，其实 $prim$ 算法还可以理解为就是一个最短路算法。

---

回到这个题，这个题 $n,m$ 均是 $5\times 10^5$，所以需要写一个 $n\log$ 的算法。这意味着我们只能跑一个最短路或者生成树。那怎么在跑出 $k$ 个关心点之间的最短路，然后找到生成树呢？

如果我们只看 $k$ 个关心点，而忽视掉其他的点和互相的路径，那么它就是要给 $k$ 个点跑最小生成树。而在某个生成树边上，两个点之间却是跑了一个最短路。

那么我们套用上面 $prim$ 的第二种方式，在整张图上跑最短路，每当一个关心点加入生成树时，就把它到生成树的距离置为 $0$，然后继续向其他点跑最短路不就好了。

code：

#include <iostream>
#include <cstdio>
#include <queue>
#include <set>
#define debug(x) cout<<#x<<":"<<x<<endl 
using namespace std;
typedef long long ll;
const int maxn=5e5+5;
const ll linf=1e18;

ll T,n,m,k;
set<ll> nd;
ll head[maxn],ent;
struct edge{
	ll v,w,nxt;
}e[maxn<<1];
void add(int u,int v,ll w){
	e[++ent]={v,w,head[u]};
	head[u]=ent;
}

struct Node{
	ll u,dis;
	bool operator<(const Node a)const{
		return dis>a.dis;
	}
};
ll dis[maxn];
bool vis[maxn];
priority_queue<Node> heap;
ll ans=0;
void dij_prim(ll root){
	for(int i=1;i<=n;i++)dis[i]=linf,vis[i]=false;
	dis[root]=0;
	ans=0;
	heap.push({root,0});
	while(!heap.empty()){
		auto [u,distance]=heap.top();
		heap.pop();
		
		if(distance>dis[u])continue;
		if(nd.find(u)!=nd.end())
			if(vis[u])continue;
			else {//加入生成树 
				vis[u]=true;
				ans+=dis[u];
				dis[u]=0;
			}

		for(int i=head[u];i;i=e[i].nxt){
			auto [v,w,nxt]=e[i];
			if(dis[u]+w<dis[v]){
				dis[v]=dis[u]+w;
				heap.push({v,dis[v]});
			}
		}
	}
}

int main(){
	cin>>T;
	while(T--){
		cin>>n>>m>>k;
		ent=0;
		for(int i=1;i<=n;i++)head[i]=0;
		nd.clear();
		for(int i=1,u,v,w;i<=m;i++){
			cin>>u>>v>>w;
			add(u,v,w);
			add(v,u,w);
		}
		for(int i=1,t;i<=k;i++){
			cin>>t;
			nd.insert(t);
		}
		
		dij_prim(*nd.begin());
		
		cout<<ans<<endl;
	}
	return 0;
}

---

G Jump Sort

思路：

挺有意思的数学题。

想象一下，如果某个数排序前的位置是 $a$，排序后的位置是 $b$，那么它需要移动 $dis=|a-b|$ 的距离。那么你选择的 $x$ 就必须是 $dis$ 的因数。否则 $dis$ 无法整除 $x$ 的话，就无法通过整数次移动正好得到 $dis$ 的距离。

同理，对每个数都有一个 $dis$，我们必须保证 $x$ 同时是 $n$ 个 $dis$ 的因数，也就是 $x$ 是且仅是 $n$ 个 $dis$ 的最大公因数的因数。

因为这个题给的是一个排列，所以 $a=i,b=a_i$，$di{s}_i=abs(i-a_i)$。求它们的最大公因数，再求取公因数的因数个数即为答案。

不过可能有人会质疑这样选取 $x$ 的可行性，认为选取了 $x$ 只能保证一个数一定能到达正确位置，不能保证每个数都可以到达正确位置。证明：对于间隔正好为 $x$ 的一串数（比如 $a_s,a_{s+x},a_{s+2x},\dots$），我们可以通过冒泡排序的思想把它排为有序。其实我们如果人为去规定每个数的大小，那么我们就可以实现一个任意的排序序列，也就是说通过相邻数交换的这种操作我们可以给一串数任意排列，这样，我们就可以实现所有数都到达正确位置了。

最后提醒一下，规定上 $\gcd (0,a)=a$，所以不需要特判 $dis=0$ 的情况。
特殊情况：当序列已经有序的时候，答案是 $n$。

code：

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn=5e5+5;
typedef pair<int,int> pii;

int n,d;

int gcd(int a,int b){
	while(b)b^=a^=b^=a%=b;
	return a;
}

int main(){
	cin>>n;
	for(int i=1,t,dis;i<=n;i++){
		cin>>t;
		dis=abs(t-i);
		d=gcd(d,dis);
	}
	int cnt=0;
	for(int i=1;i*i<=d;i++){
		if(d%i==0){
			cnt++;
			if(i*i!=d)cnt++;
		}
	}
	if(d)cout<<cnt;
	else cout<<n;
	return 0;
}

---

I 好想成为人类啊

思路：

这个题其实很简单的，不知道为什么通过数这么少。

首先每组的 $n,m\le 10^3$，而且 $\sum n,m\le 2^{14}\approx 15000$，这意味着我们跑 $O(n^2)$ 算法都没问题，可以直接暴力判断字符串是否匹配。假设匹配位置为 $l$，那么 $r=l+m-1$，我们只要 $l\sim r$ 里选取一个点即可。

然后问题就转化为了区间选点问题，而且这个题每个区间长度还都是固定的，直接贪心就做完了

code：

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

int T;
int n,m;
string s,t;

vector<int> match;

int main(){
	cin>>T;
	while(T--){
		cin>>n>>m>>s>>t;
		match.clear();
		for(int i=0;i<=n-m;i++)
			if(s.substr(i,m)==t)
				match.push_back(i);
		
		int ans=0,len=match.size();
		for(int l=0,r;l<len;l=r+1){
			r=upper_bound(match.begin(),match.end(),match[l]+m-1)-match.begin()-1;
			ans++;
		}
		cout<<ans<<endl;
	}
	return 0;
}