CodeForces-1307D Vaca y Campos BFS Buscando Distancia + Pensamiento

CodeForces - 1307D Vaca y campos

Dirección del título original:

http://codeforces.com/contest/1307/problem/D

Tema:
para un gráfico no dirigido y una serie de puntos, puede elegir cualquiera de estos dos puntos y conectar un borde para hacer que el camino más corto sea 1 -> n el más grande. Pregunte cuál es el camino más corto más grande.

Idea básica:
primero encuentre la ruta más corta de 1 a estos puntos mediante bfs dos veces, y regístrela en la matriz dis1; la ruta más corta de n a estos puntos, regístrela en la matriz dis2;
luego, si el par de bordes 1-> n es el más corto El camino tiene un efecto, es decir, la ruta más corta máxima después de conectar los bordes es mayor que la ruta más corta original, entonces la respuesta es la ruta más corta máxima después de conectar los bordes, de lo contrario se toma la ruta más corta original.
Consideramos cómo encontrar la ruta más corta máxima después de conectar bordes, la ruta más corta máxima es max (min (dis1 [a] + dis2 [b] +1, dis1 [b] + dis2 [a] + 1)) (a, b es Cualquiera de los dos puntos dados anteriormente), también podríamos asumir dis1 [a] + dis2 [b] <= dis2 [b] + dis1 [a], entonces solo necesitamos encontrar dis1 [a] + dis2 [b] El valor máximo de la desigualdad de desplazamiento es dis1 [a] -dis2 [a] <= dis1 [b] -dis2 [b] De acuerdo con este orden, enumeramos el dis1 más grande actualizado cada vez y lo actualizamos al mismo tiempo La respuesta es dis1 [a] + dis2 [b] + 1.
Finalmente, recuerde comparar con el camino más corto original.

Código de implementación:

#include <bits/stdc++.h>
using namespace std;
#define IO std::ios::sync_with_stdio(false)
#define int long long
#define INF 0x3f3f3f3f

const int maxn = 2e5+10;
int n,m,k;
int a[maxn];
int dis1[maxn],dis2[maxn];
vector<int> G[maxn];
void bfs(int *dis,int s) {
    fill(dis, dis + n + 1, INF);
    queue<int> q;
    q.push(s);
    dis[s] = 0;
    while (!q.empty()) {
        int v = q.front();
        q.pop();
        for (auto it : G[v]) {
            if (dis[it] == INF) {
                dis[it] = dis[v] + 1;
                q.push(it);
            }
        }
    }
}
struct Node {
    int x, y;

    Node(int _x, int _y) { x = _x, y = _y; }

    bool operator<(const Node &no) const {
        return x < no.x;
    }
};
vector<Node> memo;
signed main() {
    IO;
    cin >> n >> m >> k;
    for (int i = 0; i < k; i++) cin >> a[i];
    for (int i = 0; i < m; i++) {
        int u, v;
        cin >> u >> v;
        G[u].push_back(v);
        G[v].push_back(u);
    }
    bfs(dis1, 1);
    bfs(dis2, n);
    for (int i = 0; i < k; i++) memo.emplace_back(Node(dis1[a[i]] - dis2[a[i]], a[i]));
    sort(memo.begin(), memo.end());
    int ans = 0;
    int mx = -INF;
    for (auto it : memo) {
        ans = max(ans, mx + dis2[it.y] + 1);
        mx = max(mx, dis1[it.y]);
    }
    ans = min(ans, dis1[n]);
    cout << ans << endl;
    return 0;
}