Codeforces 1307D Cow and Fields

Description

给定一个有 $n$ 个节点 $m$ 条边的有向图，一个顶点集 $S$。

你需要选择两个顶点 $u,v$（$u e v,uin S,vin S$）并连接这两个顶点（允许 $u,v$ 之间已经有连边），求连接后从顶点 $1$ 到顶点 $n$ 最短路的最大值。

注意，该操作仅能进行一次。

保证给定的图联通。

Solution

我们可以预处理出 $1 o u$ 的最短路记为 $dis_{1 u}$，$u o n$ 的最短路记为 $dis_{2 u}$。

这个可以通过正反各 BFS 一遍得到。

接下来介绍两种不同的解法。

Solution1

对于 $u$，必须经过它 的最短路长度显然是 $dis_{1 u} + dis_{2 u}$。

现在，我们在 $u, v$ 之间添加了一条边。

那么，设想 $dis_{1 u}$ 的求解过程，它是可以从任何一个和 $u$ 相邻的点转移过来的，这些转移点中显然不包含 $v$。那么现在无非就是多了一种从 $v$ 转移的情况，也就是说，$dis_{1 u} gets min(dis_{1 u}, dis_{1, v} + 1)$。

如果原来 $dis_{1 u} le dis_{1, v} + 1$，那么这个转移就没意义了，所以只考虑有意义的情况。显然，$dis_{2 u}$ 是不变的，所以，新的最短路长度就是

$$ dis_{1 v} + 1 + dis_{2 u} $$

算出缩短的长度：

$Delta = (dis_{1 u} + dis_{2 u}) - (dis_{1 v} + 1 + dis_{2 u})$
$quad = dis_{1 u} - dis_{1 v} - 1$

想要让 $Delta$ 尽可能小，显然，我们选择的 $v$ 应当是满足 $dis_{1 u} - dis_{1 v}$ 最小的。而别忘了这里的条件是 $dis_{1 v} + 1 le dis_{1 u}$，也就是说，$dis_{1 v} < dis_{1 u}$。所以按照 $dis_1$ 对 $a$ 排序，边就一定是建在 $a_{i -1}$ 和 $a_i$ 之间的啦！

有人会问，$dis_{1 a_i} = dis_{1 a_{i -1}}$，不就不满足了吗？

没错，但是答案只和 $dis_1$ 的值有关，和 $a_i$ 无关，即便这里出现了一个无意义的建边，但是 $a_{i-1}$ 和它前面建的边，不就相当于 $a_i$ 和 $a_{i-1}$ 前面建的边吗？

时间复杂度 $mathcal O(n log n)$。

#include <bits/stdc++.h>
#define rep(i, x, y) for(register int i = x; i < y; i++)
#define REP(i, x, y) for(register int i = x; i <= y; i++)
using namespace std;
const int N = 2e5 + 5;
int n, m, k, ans;
int a[N], dis1[N], dis2[N];
vector<int> G[N];
queue<int> que;
inline bool cmp(int x, int y) { return dis1[x] < dis1[y]; }
int main()
{
    ios::sync_with_stdio(false);
    cin >> n >> m >> k;
    REP(i, 1, k) cin >> a[i];
    REP(i, 1, m)
    {
        int u, v;
        cin >> u >> v;
        G[u].push_back(v);
        G[v].push_back(u);
    }
    memset(dis1, -1, sizeof dis1);
    dis1[1] = 0;
    que.push(1);
    while(!que.empty())
    {
        int u = que.front();
        que.pop();
        for(int v : G[u]) if(dis1[v] == -1)
        {
            dis1[v] = dis1[u] + 1;
            que.push(v);
        }
    }
    memset(dis2, -1, sizeof dis2);
    dis2[n] = 0;
    que.push(n);
    while(!que.empty())
    {
        int u = que.front();
        que.pop();
        for(int v : G[u]) if(dis2[v] == -1)
        {
            dis2[v] = dis2[u] + 1;
            que.push(v);
        }
    }
    sort(a + 1, a + k + 1, cmp);
    ans = 0;
    rep(i, 1, k) ans = max(ans, min(dis1[n], min(dis1[a[i]] + dis2[a[i + 1]], dis1[a[i + 1]] + dis2[a[i]]) + 1));
    cout << ans << endl;
    return 0;
}

Solution 2

比如我们的边添加在 $u, v$ 之间。

一条 必须经过 $left< u, v ight>$ 的 $1 o n$ 路径长度怎么表示（不经过那么这条边就没意义了）？

$$ min(dis_{1 u} + dis_{2 v} + 1, dis_{1 v} + dis_{2 u} + 1)$$

原来最短路的长度显然是 $dis_{1 n}$，然后分类讨论一下。

1. 如果 $dis_{1 u} + dis_{2 v} + 1 le dis_{1 v} + dis_{2 u} + 1$

这时，新路径的长度为 $dis_{1 u} + dis_{2 v} + 1$。

路径的缩短长度 $Delta = dis_{1 n} - (dis_{1 u} + dis_{2 v} + 1)$，我们想要 $Delta$ 尽可能小。

$Delta = dis_{1 n} - dis_{1 u} - dis_{2 v} - 1$
$quad = dis_{1 n} - 1 - (dis_{1 u} + dis_{2 v})$

显然，$(dis_{1 u} + dis_{2 v})$ 取到 $max$ 时，$Delta$ 最小。

2. 如果 $dis_{1 u} + dis_{2 v} + 1 ge dis_{1 v} + dis_{2 u} + 1$

这时，新路径的长度为 $dis_{1 v} + dis_{2 u} + 1$。

路径的缩短长度 $Delta = dis_{1 n} - (dis_{1 v} + dis_{2 u} + 1)$，我们想要 $Delta$ 尽可能小。

$Delta = dis_{1 n} - dis_{1 v} - dis_{2 u} - 1$
$quad = dis_{1 n} - 1 - (dis_{1 v} + dis_{2 u})$

显然，$(dis_{1 v} + dis_{2 u})$ 取到 $max$ 时，$Delta$ 最小。

贪心吗？注意，我们虽然是想要一个东西取到 $max$，但是这是两种情况，我们满足了一种情况的 $max$ 时很可能会发现它的条件并不满足这种情况。

所以，排序一遍直接输出的想法告吹了 QwQ。

那么只好在满足条件的范围内取值。

第一种情况的条件移项后其实是什么？$dis_{1 u} - dis_{2 u} le dis_{1 v} - dis_{2 v}$。

第二种情况呢？$dis_{1 u} - dis_{2 u} > dis_{1 v} - dis_{2 v}$。

所以，我们只要把 $a$ 按照 $dis_1 - dis_2$ 升序排序，枚举一个 $a_i$ 作为 $v$，它前面的都是第一种情况，后面的都是第一种情况。所以，维护 前缀 $dis_1 max$ 作为 $u$，和 后缀 $dis_2 max$ 作为 $u$，都试一下就行了！

时间复杂度也是 $mathcal O(n log n)$。

#include <bits/stdc++.h>
#define rep(i, x, y) for(register int i = x; i < y; i++)
#define REP(i, x, y) for(register int i = x; i <= y; i++)
#define PER(i, x, y) for(register int i = x; i >= y; i--)
using namespace std;
const int N = 2e5 + 5;
int n, m, k, ans;
int a[N], dis1[N], dis2[N], pre[N], suf[N];
vector<int> G[N];
queue<int> que;
inline bool cmp(int x, int y) 
{
    return dis1[x] - dis2[x] < dis1[y] - dis2[y]; 
}
int main()
{
    ios::sync_with_stdio(false);
    cin >> n >> m >> k;
    REP(i, 1, k) cin >> a[i];
    REP(i, 1, m)
    {
        int u, v;
        cin >> u >> v;
        G[u].push_back(v);
        G[v].push_back(u);
    }
    memset(dis1, -1, sizeof dis1);
    dis1[1] = 0;
    que.push(1);
    while(!que.empty())
    {
        int u = que.front();
        que.pop();
        for(int v : G[u]) if(dis1[v] == -1)
        {
            dis1[v] = dis1[u] + 1;
            que.push(v);
        }
    }
    memset(dis2, -1, sizeof dis2);
    dis2[n] = 0;
    que.push(n);
    while(!que.empty())
    {
        int u = que.front();
        que.pop();
        for(int v : G[u]) if(dis2[v] == -1)
        {
            dis2[v] = dis2[u] + 1;
            que.push(v);
        }
    }
    sort(a + 1, a + k + 1, cmp);
    REP(i, 1, k) pre[i] = max(pre[i - 1], dis1[a[i]]);
    PER(i, k, 1) suf[i] = max(suf[i + 1], dis2[a[i]]);
    REP(i, 1, k)
    {
        if(i > 1) ans = max(ans, min(dis1[n], dis2[a[i]] + 1 + pre[i - 1]));
        if(i < k) ans = max(ans, min(dis1[n], dis1[a[i]] + 1 + suf[i + 1]));
    }
    cout << ans << endl;
    return 0;
}