CodeForces 1307D BFS最短路 思维

原题链接

题意

• 给出一个简单无向图，边权全部为1，同时给我们k个特殊点，要求我们从这k个特殊点中选出两个来连一条边权为1的边。同时，我们的决策要保证1~n的最短路程最大，求最终这个最短路长度。

思路

• 首先因为边权都为1，所以我们可以BFS来求出最短路。而且可以顺带求出所有点的d1(1到i的路程)和d2(i到n的路程)

• 然后考虑如果连接i，j点，那么最终结果就是 \(min(d1[i] + d2[j] + 1, d1[n])\), 不过要注意的是，这里必须有 \(d1[i] + d2[j] \le d1[j] + d2[i]\),否则结果不符合最短路的定义。

• 因为n很大，所以我们需要一个低于n^2时间复杂度的算法，那么首先我们要将二维枚举优化为一维。这里可以看到

\[d1[i] + d2[j] \le d1[j] + d2[i]
\]

可以化为

\[d1[i] - d2[i] \le d1[j] - d2[j]
\]

• 那么我们可以按照这个变形后的式子来对点进行排序。然后可知，后面的点的d2总是可以和前面的点的d1配对，所以我们从前往后扫描，同时用同一个变量来维护d1的最大值即可得到答案。

AC代码

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;

const int N = 200000;

int n, k, m;
int fir[N + 5], nex[N * 2 + 5], vv[N * 2 + 5];
bool fl[N + 5];
struct ab
{
	int v[2];
	int l;
	bool operator < (const struct ab& c) const
	{
		return v[0] - v[1] < c.v[0] - c.v[1];
	}
} dis[N + 5];
int ff[N + 5];

void bfs(int s, int l)
{
	queue<int> qq;
	qq.push(s);
	dis[s].v[l] = 0;
	while (!qq.empty())
	{
		int cc = qq.front();
		qq.pop();
		for (int i = fir[cc]; i; i = nex[i])
		{
			if (dis[vv[i]].v[l] == -1)
			{
				dis[vv[i]].v[l] = dis[cc].v[l] + 1;
				qq.push(vv[i]);
			}
		}
	}
}

int main()
{
	scanf("%d%d%d", &n, &m, &k);
	memset(dis, -1, sizeof(dis));
	for (int i = 1; i <= n; ++i)
	{
		dis[i].l = i;
		ff[i] = i;
	}
	for (int i = 1; i <= k; ++i)
	{
		int x;
		scanf("%d", &x);
		fl[x] = true;
	}
	for (int i = 1; i <= m; ++i)
	{
		scanf("%d%d", &vv[i + m], &vv[i]);
		nex[i] = fir[vv[i + m]];
		fir[vv[i + m]] = i;
		nex[i + m] = fir[vv[i]];
		fir[vv[i]] = i + m;
	}
	bfs(1, 0);
	bfs(n, 1);
	int cc = dis[n].v[0];
	sort(dis + 1, dis + 1 + n);
	int ans = 0;
	int l1 = 1;
	while (!fl[dis[l1].l])
	{
		++l1;
	}
	int mx = dis[l1].v[0];
	for (int i = l1 + 1; i <= n; ++i)
	{
		if (fl[dis[i].l])
		{
			ans = max(mx + dis[i].v[1], ans);
			mx = max(dis[i].v[0], mx);
		}
	}
	printf("%d\n", min(ans + 1, cc));
	return 0;
}