LCA应用——树结构求两点最短距离（倍增法和tarjan）

给出 n 个点的一棵树，多次询问两点之间的最短距离。

注意：

边是无向的。
所有节点的编号是 1,2,…,n 。
输入格式
第一行为两个整数 n 和 m 。 n 表示点数， m 表示询问次数；

下来 n−1 行，每行三个整数 x,y,k ，表示点 x 和点 y 之间存在一条边长度为 k ；

再接下来 m 行，每行两个整数 x,y ，表示询问点 x 到点 y 的最短距离。

树中结点编号从 1 到 n 。

输出格式
共 m 行，对于每次询问，输出一行询问结果。

数据范围
2≤n≤104 ,
1≤m≤2×104 ,
0<k≤100 ,
1≤x,y≤n
输入样例1：
2 2
1 2 100
1 2
2 1
输出样例1：
100
100
输入样例2：
3 2
1 2 10
3 1 15
1 2
3 2
输出样例2：
10
25

如果依旧采用倍增法的代码，在线做法，一个询问给出一个输出。

#include <bits/stdc++.h>

using namespace std;
const int N = 21010;
int n,m;
int deep[N];
int pre[N][22];
int head[N];
int cnt;
struct node
{
    int to,ne,w;
}a[N];
int dis[N];
void add(int x,int y,int z)
{
    cnt++;
    a[cnt].to=y;
    a[cnt].w = z;
    a[cnt].ne = head[x];
    head[x] = cnt;
}
void dfs(int x)
{
    for(int i = head[x];i!=-1;i=a[i].ne)
    {
        int now = a[i].to;
        if(!deep[now])
        {
            deep[now] = deep[x]+1;
            pre[now][0] = x;
            dis[now] = dis[x] +a[i].w;
            dfs(now);
        }
    }
}
int lca(int x,int y)
{
    if(deep[x]>deep[y])
    {
        swap(x,y);
        ans = 2;
    }
    for(int i=20;i>=0;i--)
    if(deep[pre[y][i]]>=deep[x])
    y = pre[y][i];
    if(x==y)
    return x;
    for(int i=20;i>=0;i--)
    if(pre[y][i]!=pre[x][i])
    y = pre[y][i],x=pre[x][i];
   return pre[x][0];
}
int main()
{
    cin >> n>>m;
    memset(head,-1,sizeof(head));
    for(int i=1;i<n;i++)
    {
        int x,y,z;
        cin >> x >>y >>z;
        add(x,y,z);
        add(y,x,z);
    }
    deep[1]=1;
    dfs(1);
    for(int i=1;i<=20;i++)
    for(int j = 1;j<=20010;j++)
    pre[j][i] = pre[pre[j][i-1]][i-1];
    for(int i=1;i<=m;i++)
    {
        int x,y;
        cin >> x>>y;
        if(x==y)
        cout <<"0"<<endl;
        else
        {
            int p = lca(x,y);
            cout <<dis[x]+dis[y]-2*dis[p]<<endl;
        }
    }
    return 0;
}

运用tarjan做法求LCA，离线做法，将所有询问保存下来，最后输出。
对询问元素的配对元素进行检查，若配对元素st[x]==2代表此元素已经回溯，可以用并查集求这个元素的祖先，找到的这个祖先就是双方元素的LCA。

#include <bits/stdc++.h>

using namespace std;
const int N = 20010;
int head[N],dis[N],pre[N],cnt,deep[N],ans[N],st[N];
int n,m;
vector<pair<int,int> > v[N];
struct node
{
    int to,w,ne;
} a[N];
void add(int x,int y,int z)
{
    cnt++;
    a[cnt].to = y;
    a[cnt].w = z;
    a[cnt].ne = head[x];
    head[x] = cnt;
}
int  ffind(int x)
{
    if(x==pre[x])
        return x;
    return pre[x]=ffind(pre[x]);
}
void dfs(int x)
{
    for(int i=head[x]; i!=-1; i=a[i].ne)
    {
        int now = a[i].to;
        if(!deep[now])
        {
            deep[now] = deep[x]+1;
            dis[now] = dis[x]+a[i].w;
            dfs(now);
        }
    }
}
void tarjan(int x)
{
    st[x] = 1;
    for(int i=head[x]; i!=-1; i=a[i].ne)
    {
        int now = a[i].to;
        if(!st[now])
        {
            tarjan(now);
            pre[now] = x;
        }
    }
    for(auto each:v[x])
    {
        int xx = each.first,yy = each.second;
        if(st[xx] == 2)
        {
            int k = ffind(xx);
            ans[yy] = dis[x]+dis[xx]-2*dis[k];
        }
    }

    st[x] = 2;
}
int main()
{
    memset(head,-1,sizeof(head));
    cin >> n >>m;
    for(int i=1; i<n; i++)
    {
        int x,y,z;
        cin >> x >>y >>z;
        add(x,y,z);
        add(y,x,z);
    }
    deep[1] = 1;
    for(int i=1; i<=n; i++)
        pre[i] = i;
    dfs(1);
    for(int i=1; i<=m; i++)
    {
        int x,y;
        cin >> x >>y;
        v[x].push_back({y,i});
        v[y].push_back({x,i});
    }
    tarjan(1);
    for(int i=1; i<=m; i++)
    {
        cout <<ans[i]<<endl;
    }
    return 0;
}