BFS + 贪心 - 最大化最短路 - acw 3797

BFS + 贪心 - 最大化最短路 - acw 3797

题意：

给定一个 n 个点 m 条边的无向连通图。

图中所有点的编号为 1∼n。

图中不含重边和自环。

指定图中的 k 个点为特殊点。

现在，你必须选择两个特殊点，并在这两个点之间增加一条边。

所选两点之间允许原本就存在边。

我们希望，在增边操作完成以后，点 1 到点 n 的最短距离尽可能大。

输出这个最短距离的最大可能值。

注意，图中所有边（包括新增边）的边长均为 1。

输入格式

第一行包含三个整数 n,m,k。

第二行包含 k 个整数 $a_1,a_2,\dots ,a_k$，表示 k 个特殊点的编号，$a_i$ 之间两两不同。

接下来 m 行，每行包含两个整数 x,y，表示点 x 和点 y 之间存在一条边。

输出格式

一个整数，表示最短距离的最大可能值。

数据范围

$2\le n\le 2\times 10^5，n-1\le m\le 2\times 10^5，2\le k\le n，1\le a_i\le n，1\le x,y\le n。$

输入样例1：

5 5 3
1 3 5
1 2
2 3
3 4
3 5
2 4

输出样例1：

3

输入样例2：

5 4 2
2 4
1 2
2 3
3 4
4 5

输出样例2：

3

---

分析：

$仔细思考，会发现：增加一条边只会使得最短路不变或更短。$

$详细讨论加边后的情况（划分解空间）：$

$①、增加的边不是原最短路上的边，则答案还是原最短路。$

$②、增加的边经过最短路，假设在点u和v之间建立一条无向边$

$则可能的解有三种情况：$

$Ⅰ、原最短路$

$Ⅱ、1\to u\to v\to n：min\_distance(1,u)+1+min\_distance(v,n)$

$Ⅲ、1\to v\to u\to n：min\_distance(1,v)+1+min\_distance(u,n)$

$记i号点到1号点的最短距离为d_1[i]，到n号点的最短距离为d_2[i]$

$则：$

$$ans=min(d_1[n],\underset{u,v\in a_i}{\max }(d_1[u]+1+d_2[v]),\underset{u,v\in a_i}{\max }(d_1[v]+1+d_2[u]))$$

注意： $$\begin{gathered} 对于情况Ⅱ，需满足d_1[v]>d_1[u]，也就是说点v的层次大于点u，我们不能够建一条往回走的边。 \\ 对情况Ⅲ同理 \end{gathered}$$

$所以，我们的目标实际上是要先求\underset{u,v\in a_i}{\max }(d_1[u]+1+d_2[v])，且d_1[v]>d_1[u]$

$若直接O(k^2)枚举，必然不行。$

$若能够将所有点分层，从低层（靠近1号点的层）向高层遍历，维护d_1[u]的最大值dis1，$

$那对于当前遍历到的点v=a_i，我们只需考虑在v与其前面的点u=a_j（j\in [1,i-1]）之间建边，$

$那就可以O(k)的时间复杂度更新答案：ans=\underset{j=a_i,i\in [1,k]}{\max }(dis1+d_2[j]+1)，其中dis1=\underset{u\in [1,i-1]}{\max }(d_1[a_u])$

Q：如何分层?

$将所有点按照距离1号点的距离排序即可。$

$然后我们取得情况Ⅱ的答案，记为AN{S}_1。$

$对于情况Ⅲ：\underset{u,v\in a_i}{\max }(d_1[v]+1+d_2[u])，同理可计算出答案，记为AN{S}_2。$

$则最终的答案为：$

$$ans=min(d_1[n],AN{S}_1,AN{S}_2)$$

代码：

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

using namespace std;

const int N = 200010, M = N * 2, inf = 0x3f3f3f3f;

int n, m, k;
int e[M], ne[M], h[N], idx;
int q[N], d1[N], d2[N], a[N];
int ans = inf;

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}

void bfs(int S, int d[])
{
    memset(d, 0x3f, sizeof d1);
    d[S] = 0; 
    int hh = 0, tt = -1;
    q[++ tt] = S;
    
    while(hh <= tt)
    {
        int u = q[hh ++];
        
        for(int i = h[u]; ~i; i = ne[i])
        {
            int v = e[i];
            
            if(d[v] > d[u] + 1)
            {
                d[v] = d[u] + 1;
                q[++ tt] = v;
            }
        }
    }
}

void solve(int d1[], int d2[])
{
    sort(a, a + k, [&](int a, int b){
        return d1[a] < d1[b];
    });
    
    int res = 0, dis1 = d1[a[0]];
    for(int i = 1; i < k; i ++)
    {
        int j = a[i];
        res = max(res, dis1 + d2[j] + 1);
        dis1 = max(dis1, d1[j]);
    }

    ans = min(res, ans);
}

int main()
{
    scanf("%d%d%d", &n, &m, &k);
    for(int i = 0; i < k; i ++) scanf("%d", &a[i]);
    
    memset(h, -1, sizeof h);
    int u, v;
    while(m --)
    {
        scanf("%d%d", &u, &v);
        add(u, v), add(v, u);
    }

    bfs(1, d1);
    bfs(n, d2);
    
    solve(d1, d2);
    solve(d2, d1);
    ans = min(ans, d1[n]);
    
    printf("%d\n", ans);

    return 0;
}

---

优化：

$事实上，我们可以通过一些性质进行排序，仅需计算情况Ⅱ，排除情况Ⅲ。$

$我们只需按照如下的性质对特殊点集进行排序：d_1[u]+d_2[v]\le d_1[v]+d_2[u]$

$就能够确保：AN{S}_1\le AN{S}_2恒成立$

$那么我们仅需计算情况Ⅱ的最大值AN{S}_1即可$

但是：

$$\begin{gathered} 我们需要考虑，这样排序后，所有的点能否按照层次排好序？ \\ 即当我们顺序遍历数组时，是否满足：序号在前的点的层次\le 序号在后的点的层次？ \end{gathered}$$

先挖个坑，等弄明白了再来继续写

代码：

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

using namespace std;

const int N = 200010, M = N * 2, inf = 0x3f3f3f3f;

int n, m, k;
int e[M], ne[M], h[N], idx;
int q[N], d1[N], d2[N], a[N];

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}

void bfs(int S, int d[])
{
    memset(d, 0x3f, sizeof d1);
    d[S] = 0; 
    int hh = 0, tt = -1;
    q[++ tt] = S;
    
    while(hh <= tt)
    {
        int u = q[hh ++];
        
        for(int i = h[u]; ~i; i = ne[i])
        {
            int v = e[i];
            
            if(d[v] > d[u] + 1)
            {
                d[v] = d[u] + 1;
                q[++ tt] = v;
            }
        }
    }
}

void solve()
{
    sort(a, a + k, [&](int a, int b){
        return d1[a] - d2[a] < d1[b] - d2[b];
    });
    
    int res = 0, dis1 = d1[a[0]];
    for(int i = 1; i < k; i ++)
    {
        int j = a[i];
        res = max(res, dis1 + d2[j] + 1);
        dis1 = max(dis1, d1[j]);
    }
    res = min(d1[n], res);
    
    printf("%d\n", res);
}

int main()
{
    scanf("%d%d%d", &n, &m, &k);
    for(int i = 0; i < k; i ++) scanf("%d", &a[i]);
    
    memset(h, -1, sizeof h);
    int u, v;
    while(m --)
    {
        scanf("%d%d", &u, &v);
        add(u, v), add(v, u);
    }

    bfs(1, d1);
    bfs(n, d2);
    
    solve();

    return 0;
}