【题解】P8817 [CSP-S 2022] 假期计划（bfs，dfs）

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

此题作为 CSP-S 的 T1，可以说是相当有难度了。感觉 T1 和 T2 换了个位置。（雾）

我作为场外 VP 选手赛时此题只得了 95pts（洛谷民间数据），靠着自己乱搞 dfs+剪枝水过去了 19 个点。

这里记录一下这道题。

---

题目链接

P8817 [CSP-S 2022] 假期计划

题意概述

给定一张 $n$ 个点 $m$ 条边的无向无权图，点有点权。需要找四个不同的点 $a,b,c,d$，使得 $1-a-b-c-d-1$ 构成五段路径，且每段路径满足路径长度小于等于 $k+1$。现在要使得四个点权之和最大，求最大的点权和。

思路分析

这个 $+1$ 看起来很难受，所以我们先将 $k$ 直接 $+1$。

为了方便说明这里自定义一些语言：

• 若 $x$ 到 $y$ 的最短路径 $\le k$ 我们就称 $x$ 到 $y$ 可达。
• 方便起见我们认为点 $x$ 到 $x$ 本身不可达、

95pts 乱搞

先讲述一下我乱搞 95pts 的做法。

我当时看到这道题，，第一眼感觉正解应该想不到，然后就去想办法乱搞。

最暴力的做法是，对于四个点从 $1$ 开始 dfs，考虑每个点应该选什么，暴力枚举每个点然后最后判断是否符合条件，并更新答案即可。

我们考虑如何优化。

首先由于每段路径的长度都 $\le k$，所以显然假如我们当前在 $x$，只有距离 $x$ 最短路径 $\le k$ 的点才能拓展。那么我们可以从每个点首先预处理出来下一步可以到达的点。

无权图上求最短路首先想到 bfs，这个显然可以枚举每个点然后预处理出来从每个点 $i$ 到其它的点 $j$ 的最短路 $dis_{i,j}$。单次 bfs 时间复杂度 $O(n)$，总时间复杂度 $O(n^2)$，这个数据范围是 $2500$ 级别的，可以随便过。

然后预处理出来对于每个点 $i$ 可达的点的集合 $f_x$，然后每次更新下一个点的时候只在当前点的可达点集合中更新即可。

另外还可以预处理出从 $1$ 开始走可达的点，把它们打上标记。然后搜完三个点之后就在 $f_c$ 里面找看是否有打上标记的点，若打上标记则直接更新答案。

考虑到 dfs 一定难逃剪枝，我们可以记录一下当前已经选过的点的点权和 $sum$ 和图中最大点权 $mx$，当剩下未选的点数 $(4-now)\times mx\le 当前答案~ ans$，那就说明一定不可行，直接剪掉即可。

需要注意的一点是，为了保证四个点不同，我们必须定义一个 $vis_i$ 数组表示 $i$ 是否被选过，若被选过就不能再选了。

然后这样做完，虽然看起来时间复杂度疑似 $O(n^4)$，但实际上我们在各种剪枝优化中剪掉了很多没用的情况，所以实际上可以跑得很快。洛谷民间数据 95pts，除了 T 掉的那个点之外其它最慢的点也只跑了 200ms 多。

正解

我们发现在刚刚的暴力过程中，我们只要确定了前三个点，然后再只需要在第三个点 $c$ 可达的点里面找被标记的点（$1$ 可达的点）即可。

那么这可以给我们思考正解带来启发：由于要权值和最大，当我们固定了 $a,b,c$ 之后，我们直接在 $c$ 可达的点中选择被标记的非 $a,b$ 且权值最大的点即可。

同理，由于环的对称性，可以发现当我们确定了 $b,c,d$ 后，可以贪心的选择权值最大的 $a$。

将上述两点结合起来，给了我们一种思路：

我们只需要枚举 $b,c$，然后再将 $b,c$ 可达的点按照权值从大到小排序，那么 $a$ 就是 $b$ 可达的点里面，且被标记的点中，非 $c,d$ 的权值最大的点，$d$ 就是 $c$ 可达的点里面，且被标记的点中，非 $a,b$ 的权值最大的点。

那么我们怎么做呢？难道直接枚举 $b,c$ 然后枚举 $b$ 可达的点的集合和 $c$ 可达的点的集合吗？

emmm……仔细算一算复杂度发现最坏情况下其实趋近于 $O(n^4)$……那你优化了个屁。（不是）

仔细思考这样一件事情：

我们对于 $a$ 有以下几条限制：

• 在 $b$ 可达的点中；
• 在被标记的点中（即 $1$ 可达的点中）
• 非 $c,d$；
• 权值最大。

实际上，我们可以把前两条放在一块来处理，即，我们通过 bfs 处理出来的集合 $f_x$ 可以不单单是每个点可达的点集，还可以让它满足同时是 $1$ 可达的点，只要在原来的代码上稍作改动即可。（之后见代码）

现在剩下最后两个条件。如果没有第三个条件。那么我们只需存 $f_x$ 中最大的直接更新即可。那么考虑到第三个条件，举个例子：假如当前 $f_x$ 中权值最大的点与 $c$ 冲突，那就要考虑权值次大的点，假如这个次大的点又与 $d$ 冲突那么就要考虑次次大点……所以实际上答案一定在 $f_x$ 的前三大中，我们只需要预处理出来每个 $f_x$ 中的前三大即可。

到这里其实大体思路已经梳理完了。现在考虑如何写。

如果我们直接分类讨论每个点会与哪个点冲突由于我们同时要考虑 $a$ 和 $d$ 这两个点的冲突情况，所以这里的细节非常复杂和麻烦。其实我们只需要枚举每个 $f_b$ 和 $f_c$ 的前三大然后直接更新答案即可。因为它只有最多 $9$ 种情况，所以时间复杂度相当于 $O(n^2)$ 带个 $9$ 的常数。

代码实现

95pts 乱搞做法

//A
#include<cstdio>
#include<iostream>
#include<queue>
#include<cstring>
#include<algorithm>
#define int long long
using namespace std;
const int maxn=2505;
int a[maxn],dis[maxn][maxn],vis[maxn],book[maxn];
int ans=0;
int n,m,k,mx;

basic_string<int>edge[maxn],edge2[maxn];

inline int read()
{
	int x=0,f=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=x*10+ch-48;ch=getchar();}
	return x*f;
}

void bfs(int x)
{
	queue<int>q;
	q.push(x);
	while(!q.empty())
	{
		int now=q.front();
		q.pop();
		for(int nxt:edge[now])
		{
			if(dis[x][nxt])continue;
			dis[x][nxt]=dis[x][now]+1;
			q.push(nxt);
		}
	}
}

void dfs(int x,int now,int sum)
{
	if(sum+(4-now)*mx<ans)return ;//剪枝
	if(now==3)
	{
		for(int y:edge2[x])
		{
			if(book[y]&&vis[y]==0)//如果这个点没选过且在 1 可达点集中则更新答案。
			{
				ans=max(ans,sum+a[y]);
			}
		}
		return ;
	}
	for(int y:edge2[x])
	{
		if(vis[y])continue;
		vis[y]++;
		dfs(y,now+1,sum+a[y]);
		vis[y]=0;
	}
}

signed main()
{
	n=read();m=read();k=read();k++;
	for(int i=2;i<=n;i++)a[i]=read(),mx=max(mx,a[i]);
	for(int i=1;i<=m;i++)
	{
		int u,v;
		u=read();v=read();
		edge[u]+=v;
		edge[v]+=u;
	}
	for(int i=1;i<=n;i++)
	{
		bfs(i);//对每个点 bfs 预处理出来 dis
	}
	for(int i=1;i<=n;i++)
	{
		for(int j=2;j<=n;j++)
		{
			if(i==j)continue;
			if(dis[i][j]&&dis[i][j]<=k)
			{
				edge2[i]+=j;//这份代码中的 edge2[i] 表示的就是 i 的可达点的集合。
			}
		}
	}
	for(int v:edge2[1])book[v]++;//标记所有的 1 可达的点。
	dfs(1,0,0);
	cout<<ans<<'\n';
	return 0;
}

正解

#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<algorithm>
#include<cstring>
#define int long long
using namespace std;
const int maxn=2505;
int ok[maxn][maxn],dis[maxn][maxn],w[maxn];//ok[i][j] 表示 i,j 是否可达。
int n,m,k,ans;

vector<int>f[maxn];

basic_string<int>edge[maxn];

inline int read()
{
	int x=0,f=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=x*10+ch-48;ch=getchar();}
	return x*f;
}

int cmp(int a,int b){return w[a]>w[b];}

void bfs(int x)
{
	queue<int>q;
	q.push(x);
	dis[x][x]=0;
	while(!q.empty())
	{
		int now=q.front();
		q.pop();
		if(now!=x)
		{
			ok[x][now]++;
			if(x!=1&&ok[1][now])//如果起点不为 1 且是 1 可达的点。
			{
				f[x].push_back(now);
				sort(f[x].begin(),f[x].end(),cmp);//按边权从大到小排序。
				if(f[x].size()>3)f[x].pop_back();//只保留前三大。
			}
		}
		if(dis[x][now]>=k)continue;//如果当前 dis 已经大于等于 k 就没必要再用，因为不可能更新。
		for(int nxt:edge[now])
		{
			if(dis[x][nxt]!=-1)continue;
			dis[x][nxt]=dis[x][now]+1;
			q.push(nxt);
		}
	}
}

signed main()
{
	memset(dis,-1,sizeof(dis));
	n=read();m=read();k=read();k++;
	for(int i=2;i<=n;i++)w[i]=read();
	for(int i=1;i<=m;i++)
	{
		int u,v;
		u=read();v=read();
		edge[u]+=v;
		edge[v]+=u;
	}
	for(int i=1;i<=n;i++)bfs(i);//这里的 bfs 处理的是 f[x]
    //暴力枚举每个 b，c，并对每对 b，c 枚举可能的 9 种答案。
	for(int b=2;b<=n;b++)
	{
		for(int c=2;c<=n;c++)
		{
			if(!ok[b][c])continue ;//b 必须可达 c。
			for(int a:f[b])
			{
				for(int d:f[c])
				{
					if(a!=c&&b!=d&&a!=d)//a 显然本身不可能与 b,d 不可能与 c 冲突。
					{
						ans=max(ans,w[a]+w[b]+w[c]+w[d]);//更新答案。
					}
				}
			}
		}
	}
	cout<<ans<<'\n';
	return 0;
}