1e5个点n+100条边求任意两点之间的距离——最短路

传送门
题意
n个点m条边，q次询问求任意两点之间的距离。（n<=1e5，m<=n+100，所有边权为1，保证图连通）。
思路
这个多出的100多条边就很怪，先考虑如果没有多出边，就只有n-1条边，图连通，那么可以建立最小生成树，用LCA来做，任取一点为根，len[i]为i点到根的距离，dis(u,v) = len[u]+len[v]-2 * len[LCA(u,v)]。思考多出来的边(x,y)对答案有什么影响？两种情况：1.在u到v的最短路上 2.不在u到v的最短路上。如果在最短路上的话，那么可以求出以x和y为源点的单源最短路，dis(u,v) = min(len[u]+len[v]-2 * len[LCA(u,v)], d[x][u] + d[y][v] + 1, d[y][u] + d[x][v] + 1)（d[i][j]：i到j的最短路）。但是！对多出来的100条边，最多有200个点，依次做单源最短路超时。还可以优化，其实对于多出的一条边，只需要求出其中一个端点的最短路就可以了，也就是dis(u,v) = min(len[u]+len[v]-2 * len[LCA(u,v)], d[x][u] + d[x][v])。
还有一个问题就是，这里求单源最短路要用bfs来求，用优先队列优化的dijkstra更慢。

#include <bits/stdc++.h>
#define pr pair<int, int>
using namespace std;
const int maxn = 1e5 + 101, INF = 0x3f3f3f3f;
typedef long long ll;
int n, m, head[maxn], to[maxn<<1], nex[maxn<<1], tot;
vector<int> g[maxn];
int d[maxn][210], p[210], pt = 0;
void init() {
    memset(head, -1, sizeof(head));
    tot = 0;
}
void add(int x, int y) {
    to[tot] = y;
    nex[tot] = head[x];
    head[x] = tot++;
}
int ff[maxn];
int find(int x) {
    return ff[x] == x ? x : ff[x] = find(ff[x]);
}
int h[maxn], f[maxn][20], TT, len[maxn];
void dfs(int x, int fx) {
    h[x] = h[fx] + 1;
    f[x][0] = fx;
    for (int i = 1; i <= TT; i++) f[x][i] = f[f[x][i - 1]][i - 1];
    for (int i = 0; i < g[x].size(); i++) {
        int v = g[x][i];
        if(v != fx) {
            len[v] = len[x] + 1;
            dfs(v, x);
        }
    }
}
int LCA(int x, int y) {
    if(h[x] > h[y]) swap(x, y);
    for (int i = TT; i >= 0; i--)
        if(h[ f[y][i] ] >= h[x]) y = f[y][i];
    if(x == y) return x;
    for (int i = TT; i >= 0; i--)
        if(f[y][i] != f[x][i])
            y = f[y][i], x = f[x][i];
    return f[x][0];
}
set<int> sp;
bool final[maxn];
void dijkstra(int s, int id) {
    memset(final, 0, sizeof(final));
    queue<int> que;
    que.push(s);
    d[s][id] = 0;
    while (!que.empty()) {
        int u = que.front();
        que.pop();
        if(final[u]) continue;
        final[u] = 1;
        for (int i = head[u]; ~i; i = nex[i]) {
            int v = to[i];
            if(!final[v] && d[v][id] > d[u][id] + 1) {
                d[v][id] = d[u][id] + 1;
                que.push(v);
            }
        }
    }
}
int main()
{
    init();
    scanf("%d%d", &n, &m);
    int cnt = 0;
    for (int i = 1; i <= n; i++) ff[i] = i;
    for (int i = 1, x, y; i <= m; i++) {
        scanf("%d%d", &x, &y);
        add(x, y); add(y, x);
        if(cnt == n - 1) {//多余的边选取一个端点
            if(!sp.count(x)) sp.insert(x), p[++pt] = x;
            continue;
        }
        int fu = find(x), fv = find(y);
        if(fu == fv) {
            if(!sp.count(x)) sp.insert(x), p[++pt] = x;
            continue;
        }
        g[x].push_back(y); g[y].push_back(x);
        cnt++; ff[fv] = fu;
    }
    TT = int(log(n)/log(2)) + 1;
    dfs(1, 0);
    memset(d, INF, sizeof(d));
    for (int i = 1; i <= pt; i++)//对多出来的边的端点求单源最短路
        dijkstra(p[i], i);
//    for (int i = 1; i <= pt; i++) {
//        printf("start: %d\n", p[i]);
//        for (int j = 1; j <= n; j++)
//            printf("%d ", d[j][i]);
//        printf("\n");
//    }
    int q, u, v;
    scanf("%d", &q);
    while (q--) {
        scanf("%d%d", &u, &v);
        int ans = len[u] + len[v] - 2 * len[LCA(u, v)];
        for (int i = 1; i <= pt; i++) ans = min(ans, d[u][i] + d[v][i]);
        printf("%d\n", ans);
    }
}