E - Hit and Away

news/2025/10/29 10:36:31/文章来源:https://www.cnblogs.com/onlyblues/p/19173638

E - Hit and Away

Problem Statement

You are given a simple connected undirected graph $G$ with $N$ vertices and $M$ edges.
The vertices and edges of $G$ are numbered as vertices $1,2,\ldots,N$ and edges $1,2,\ldots,M$, respectively, and edge $i$ connects vertices $U_i$ and $V_i$.
You can move bidirectionally between vertices connected by an edge in time $1$.

Additionally, each vertex is either safe or dangerous, and this state is given by a string $S$ of length $N$ consisting of S and D.
Specifically, vertex $i$ is safe when the $i$-th character $(1\leq i\leq N)$ of $S$ is S, and vertex $i$ is dangerous when it is D.
It is guaranteed that there are at least two safe vertices and at least one dangerous vertex.

For each dangerous vertex $v$, find the following value:

The minimum possible time to start from some safe vertex, pass through $v$, and move to a safe vertex different from the starting vertex.

Constraints

$3\leq N\leq 2\times 10^5$
$N-1\leq M\leq 2\times 10^5$
$1\leq U_i,V_i\leq N$
$U_i\neq V_i$
If $i\neq j$, then $\{ U_i,V_i \}\neq \{ U_j,V_j \}$.
$S$ is a string of length $N$ consisting of S and D.
$N,M,U_i,V_i$ are all integers.
$G$ is connected.
There are at least two safe vertices.
There is at least one dangerous vertex.

Input

The input is given from Standard Input in the following format:

$N$ $M$
$U_1$ $V_1$
$U_2$ $V_2$
$\vdots$
$U_M$ $V_M$
$S$

Output

Let $K$ be the number of dangerous vertices in $G$, and print $K$ lines.
On the $i$-th line $(1\leq i\leq K)$, print the answer for the $i$-th dangerous vertex when the dangerous vertices are arranged in ascending order of vertex number.

Sample Input 1

Sample Output 1

2
3

The dangerous vertices are (in ascending order of vertex number) vertices $3$ and $4$.

For vertex $3$, moving from vertex $1$ $\to$ vertex $3$ $\to$ vertex $2$ (for example) satisfies the condition.
The time required for this movement is $2$, and this is the minimum.
Therefore, print $2$ on the $1$st line.

For vertex $4$, moving from vertex $1$ $\to$ vertex $3$ $\to$ vertex $4$ $\to$ vertex $5$ (for example) satisfies the condition.
The time required for this movement is $3$, and there is no way to move that satisfies the condition with time $2$ or less, so this is the minimum.
Therefore, print $3$ on the $2$nd line.

Sample Input 2

Sample Output 2

The dangerous vertex is vertex $3$.

Moving from vertex $1$ $\to$ vertex $2$ $\to$ vertex $3$ $\to$ vertex $2$ (for example) satisfies the condition.
The time required for this movement is $3$, and this is the minimum.
Note that movements such as vertex $2$ $\to$ vertex $3$ $\to$ vertex $2$ do not satisfy the condition that the destination is "different from the starting vertex".

解题思路

一个从安全点出发、经过一个危险点再到达另一个不同安全点的路径，可以表示为 $S_1 \to D \to S_2$，其中 $S_1 \ne S_2$。由于是无向图，这条路径可以被拆分为两个独立的部分：$D \to S_1$ 和 $D \to S_2$。为了使整体路径长度最小，需要分别求出 $D \to S_1$ 和 $D \to S_2$ 的最短距离。因此本题就是对每个危险点 $D_i$，找到距离其最近的两个不同的安全点 $S_1$ 和 $S_2$。显然如果对每个危险点 $D_i$ 分别跑一次 bfs，时间复杂度将达到 $O\left(n(n+m)\right)$。

本题需要在多源 bfs 的基础上进行修改，但由于对 bfs 的原理理解得还不够深刻，赛时没做出来。下面先给出具体做法，再解释其正确性。

我们首先只考虑计算每个 $D_i$ 到最近安全点的距离。此时将所有的安全点作为源点跑一次多源 bfs，就能得到每个 $D_i$ 到其最近安全点的最短距离，记作 $d_1$。但我们现在还需要考虑 $D_i$ 到另一个不同的安全点的最短距离，把这个距离记作 $d_2$。为了确保 $d_2$ 对应的安全点与 $d_1$ 不同，我们需要在计算 $d_1$ 时记录其对应的源点 $f_1$。同样在计算 $d_2$ 时，也记录其对应的源点 $f_2$。在 bfs 的过程中，如果 $u$ 的 $d_1[u]$（或 $d_2[u]$）可以更新 $v$ 的 $d_2[v]$，那么只有当 $f_1[u] \ne f_1[v]$（或 $f_2[u] \ne f_1[v]$）时，才允许更新。

整个修改后的多源 bfs 流程如下代码所示，其中队列 q 中的元素是一个三元组 $(d,u,p)$，表示 $u$ 到安全点 $p$ 的最短距离 $d$，$p$ 是该距离对应的源安全点。

queue<array<int, 3>> q;
for (int i = 1; i <= n; i++) {
    if (s[i] == 'S') {
        q.push({0, i, i});
        d1[i] = 0;
        f1[i] = i;
    }
}
while (!q.empty()) {
    auto [d, u, p] = q.front();
    q.pop();
    for (int i = h[u]; i != -1; i = ne[i]) {
        int v = e[i];
        if (d1[v] > d + 1) {
            d1[v] = d + 1;
            f1[v] = p;
            q.push({d1[v], v, p});
        }
        else if (d2[v] > d + 1 && f1[v] != p) {
            d2[v] = d + 1;
            f2[v] = p
            q.push({d2[v], v, p});
        }
    }
}

接下来将解释为什么上述方法是正确的，可以找到每个危险点 $D$ 到两个不同安全点的最短距离。

首先，需要了解（单源/多源）bfs 的正确性原理，即 bfs 会按距离递增的顺序依次访问节点。具体来说，从源点集合出发，bfs 会访问距离源点集合为 $0$ 的节点，然后再访问距离为 $1$ 的节点，以此类推。这样，当某个节点第一次被访问时，此时的距离一定是该节点到源点集合的最短距离。此外，节点在第一次被访问并更新后会被加入队列，以更新其相邻节点。如果节点不是第一次被访问，则不会更新，也不会被重新加入队列。正如前面所提到的，bfs 会按照距离递增的顺序访问节点，当再次访问某个节点时，此时的距离一定不小于该节点第一次访问时的距离，因此不会更新，也不会重新入队（因为相邻节点已经被用最短距离更新过了）。

修改后的多源 bfs 仍然保持了按距离递增的顺序来访问节点的特性。与朴素的 bfs 一样，更新操作发生时，新的节点会被加入到队列，并且这些节点的距离比当前（更新它的）节点大 $1$。因此从该特性可以推断出，得到的 $d_2$ 一定是来自与 $d_1$ 不同源点的最短距离。

但有一点可能引起疑惑：为什么在更新了 $v$ 的 $d_2$ 后，还需要将 $v$ 再次入队？这是因为 $v$ 的 $d_2$ 更新后，可能会更新其相邻节点的 $d_2$。举例来说，如果 $v$ 的 $d_1$ 更新了其相邻节点的 $d_1$，那么在更新了 $v$ 的 $d_2$ 后，有可能会继续更新相邻节点的 $d_2$。因此，重新将 $v$ 入队是必要的，以确保所有节点的最短路径都得到更新。

AC 代码如下，时间复杂度为 $O(n + m)$：

#include <bits/stdc++.h>
using namespace std;typedef long long LL;const int N = 2e5 + 5, M = N * 2;char s[N];
int h[N], e[M], ne[M], idx;
int d1[N], d2[N], f[N];void add(int u, int v) {
    e[idx] = v, ne[idx] = h[u], h[u] = idx++;
}int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m;
    cin >> n >> m;
    memset(h, -1, sizeof(h));
    while (m--) {
        int u, v;
        cin >> u >> v;
        add(u, v), add(v, u);
    }
    cin >> s;
    memmove(s + 1, s, n + 1);
    memset(d1, 0x3f, sizeof(d1));
    memset(d2, 0x3f, sizeof(d2));
    queue<array<int, 3>> q;
    for (int i = 1; i <= n; i++) {
        if (s[i] == 'S') {
            q.push({0, i, i});
            d1[i] = 0;
            f[i] = i;
        }
    }
    while (!q.empty()) {
        auto [d, u, p] = q.front();
        q.pop();
        for (int i = h[u]; i != -1; i = ne[i]) {
            int v = e[i];
            if (d1[v] > d + 1) {
                d1[v] = d + 1;
                f[v] = p;
                q.push({d1[v], v, p});
            }
            else if (d2[v] > d + 1 && f[v] != p) {
                d2[v] = d + 1;
                q.push({d2[v], v, p});
            }
        }
    }
    for (int i = 1; i <= n; i++) {
        if (s[i] == 'D') cout << d1[i] + d2[i] << '\n';
    }
    
    return 0;
}