[CSP-S 2022] 假期计划 题解

题目描述

洛谷题目见此

小熊的地图上有 $n$ 个点，其中编号为 $1$ 的是它的家、编号为 $2,3,\dots ,n$ 的都是景点。部分点对之间有双向直达的公交线路。如果点 $x$ 与 $z_1$、$z_1$ 与 $z_2$、……、$z_{k-1}$ 与 $z_k$、$z_k$ 与 $y$ 之间均有直达的线路，那么我们称 $x$ 与 $y$ 之间的行程可转车 $k$ 次通达；特别地，如果点 $x$ 与 $y$ 之间有直达的线路，则称可转车 $0$ 次通达。

很快就要放假了，小熊计划从家出发去 $4$ 个不同的景点游玩，完成 $5$ 段行程后回家：家 $\to$ 景点 A $\to$ 景点 B $\to$ 景点 C $\to$ 景点 D $\to$ 家且每段行程最多转车 $k$ 次。转车时经过的点没有任何限制，既可以是家、也可以是景点，还可以重复经过相同的点。例如，在景点 A $\to$ 景点 B 的这段行程中，转车时经过的点可以是家、也可以是景点 C，还可以是景点 D $\to$ 家这段行程转车时经过的点。

假设每个景点都有一个分数，请帮小熊规划一个行程，使得小熊访问的四个不同景点的分数之和最大。

输入格式

第一行包含三个正整数 $n,m,k$，分别表示地图上点的个数、双向直达的点对数量、每段行程最多的转车次数。

第二行包含 $n-1$ 个正整数，分别表示编号为 $2,3,\dots ,n$ 的景点的分数。

接下来 $m$ 行，每行包含两个正整数 $x,y$，表示点 $x$ 和 $y$ 之间有道路直接相连，保证 $1\le x,y\le n$，且没有重边，自环。

输出格式

输出一个正整数，表示小熊经过的 $4$ 个不同景点的分数之和的最大值。

样例 #1

样例输入 #1

8 8 1
9 7 1 8 2 3 6
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 1

样例输出 #1

27

样例 #2

样例输入 #2

7 9 0
1 1 1 2 3 4
1 2
2 3
3 4
1 5
1 6
1 7
5 4
6 4
7 4

样例输出 #2

7

提示

【样例解释 #1】

当计划的行程为 $1\to 2\to 3\to 5\to 7\to 1$ 时，$4$ 个景点的分数之和为 $9+7+8+3=27$，可以证明其为最大值。

行程 $1\to 3\to 5\to 7\to 8\to 1$ 的景点分数之和为 $24$、行程 $1\to 3\to 2\to 8\to 7\to 1$ 的景点分数之和为 $25$。它们都符合要求，但分数之和不是最大的。

行程 $1\to 2\to 3\to 5\to 8\to 1$ 的景点分数之和为 $30$，但其中 $5\to 8$ 至少需要转车 $2$ 次，因此不符合最多转车 $k=1$ 次的要求。

行程 $1\to 2\to 3\to 2\to 3\to 1$ 的景点分数之和为 $32$，但游玩的并非 $4$ 个不同的景点，因此也不符合要求。

【样例 #3】

见附件中的 holiday/holiday3.in 与 holiday/holiday3.ans。

【数据范围】

对于所有数据，保证 $5\le n\le 2500$，$1\le m\le 10000$，$0\le k\le 100$，所有景点的分数 $1\le s_i\le {10}^{18}$。保证至少存在一组符合要求的行程。

测试点编号	$n\le$	$m\le$	$k\le$
$1\sim 3$	$10$	$20$	$0$
$4\sim 5$	$10$	$20$	$5$
$6\sim 8$	$20$	$50$	$100$
$9\sim 11$	$300$	$1000$	$0$
$12\sim 14$	$300$	$1000$	$100$
$15\sim 17$	$2500$	$10000$	$0$
$18\sim 20$	$2500$	$10000$	$100$

题目分析

对于景点间的路，需要建图来进行保存来为接下来的计算做准备

void add(int x,int y)//建边 
{
	e[++idx]=y;//当前边的一点 
	ne[idx]=h[x]; //当前边的另一点 
	h[x]=idx;//更新邻接表队头 
}

为避免两点间距离进行重复，导致程序超时，我们需要提前计算两点是否可达，特殊的，自己不能到达自己

void bfs(int a)
{
	queue<int>q;
	int di[3000];
	memset(di,0x3f3f3f,sizeof(di));
	di[a]=0;
	q.push(a);
	while(q.size())
	{
		int t=q.front();
		q.pop();
		if(di[t]==k+1) continue;//如果距离大于k，停止搜索
		for(int i=h[t];i;i=ne[i])
		{
			int b=e[i];
			if(di[b]>di[t]+1)
			{
				mp[a][b]=1;
				di[b]=di[t]+1;
				q.push(b);
			}
		}
	}
}

遍历思路(75%)

考虑到每次需要到四个景点，我们可以分别遍历四个景点，并取能达到的最大值（注意运用剪枝，避免进行无意义的循环以减小时间复杂度）

	for(int i=2;i<=n;i++)
	{
		if(!mp[1][i]) continue;
		for(int j=2;j<=n;j++)
		{
			if((!mp[i][j])) continue;
			for(int l=2;l<=n;l++)
			{
				if((!mp[j][l])||i==l) continue;
				for(int a=2;a<=n;a++)
				{
					if((!mp[a][l])||(!mp[1][a])||i==l||a==i||a==j) continue;
					ans=max(ans,val[i]+val[l]+val[a]+val[j]);
				}
			}
		}
	}

遍历思路(100%)

显然，前面的代码在剪枝后仍然会超时（毕竟 $n$ 最大能到2500），我们可以只取中间两点，再取这两点到 $1$ 间的最大可取点，这样能大大减小时间复杂度，但是中间的最大点可能与另一个点或另一个点的最大值相重合，所以我们需要存最大的三个点，最后再遍历即可

	for(int i=2;i<=n;i++)
	{
		for(int j=2;j<=n;j++)//进行二次处理
		{
			if(i==j||!mp[i][j]||!mp[1][j]) continue;//不能到达就跳过
			if(val[j]>val[mx[i][1]])
			{
				mx[i][3]=mx[i][2];
				mx[i][2]=mx[i][1];
				mx[i][1]=j;
			}
			else if(val[j]>val[mx[i][2]])
			{
				mx[i][3]=mx[i][2];
				mx[i][2]=j;
			}
			else if(val[j]>val[mx[i][3]])
			{
				mx[i][3]=j;
			}
		}
	}

满分代码

#include <bits/stdc++.h>
using namespace std;
int n,m,k;
long long ans;
long long val[3000];
bool mp[3000][3000],mxp[3000][3000];
long long h[3500],idx,e[21000],ne[21000];
long long mx[3500][4];
void add(int x,int y)//建边 
{
	e[++idx]=y;//当前边的一点 
	ne[idx]=h[x]; //当前边的另一点 
	h[x]=idx;//更新邻接表队头 
}
void bfs(int a)
{
	queue<int>q;
	int di[3000];
	memset(di,0x3f3f3f,sizeof(di));
	di[a]=0;
	q.push(a);
	while(q.size())
	{
		int t=q.front();
		q.pop();
		if(di[t]==k+1) continue;
		for(int i=h[t];i;i=ne[i])
		{
			int b=e[i];
			if(di[b]>di[t]+1)
			{
				mp[a][b]=1;
				di[b]=di[t]+1;
				q.push(b);
			}
		}
	}
}
int main()
{
	cin>>n>>m>>k;
	for(int i=2;i<=n;i++)
	{
		cin>>val[i];
	}
	for(int i=1;i<=m;i++)
	{
		int a,b;
		cin>>a>>b;
		add(a,b);
		add(b,a);
	}
	for(int i=1;i<=n;i++)
	{
		bfs(i);
	}
	for(int i=2;i<=n;i++)
	{
		for(int j=2;j<=n;j++)
		{
			if(i==j||!mp[i][j]||!mp[1][j]) continue;
			if(val[j]>val[mx[i][1]])
			{
				mx[i][3]=mx[i][2];
				mx[i][2]=mx[i][1];
				mx[i][1]=j;
			}
			else if(val[j]>val[mx[i][2]])
			{
				mx[i][3]=mx[i][2];
				mx[i][2]=j;
			}
			else if(val[j]>val[mx[i][3]])
			{
				mx[i][3]=j;
			}
		}
	}
	for(int i=2;i<=n;i++)
	{
		for(int j=2;j<=n;j++)
		{
			if(mp[i][j]==0) continue;
			for(int a=1;a<=3;a++)
			{
				for(int b=1;b<=3;b++)
				{
					if(mx[i][a]==mx[j][b]||mx[i][a]==j||mx[j][b]==i||mx[j][b]==0||mx[i][a]==0) continue;
					ans=max(ans,val[i]+val[j]+val[mx[i][a]]+val[mx[j][b]]);
				}
			}
		}
	}
	cout<<ans;
	return 0;
}