How far away ？ HDU - 2586(LCA Tarjan离线方法 or 倍增在线方法)

How far away ？ HDU - 2586

题目链接

题意：给出一棵树，问任意两点的间的最小距离；
思路：考虑本题，若t时a, b的LCA，r是树根那么dis[a, b]=dis[r, a]+dis[r, b]-2*dis[r, t]；
dis[r, p] (根到p点的距离) 可以通过dfs求得，那么找出[a, b]的LCA就万事大吉了；
首先是Tarjan离线方法：
1. 任选一个根节点；
2. 遍历当前节点u的所有子节点v，并标记；
3. 若当前点有子节点返回2， 否则进入下一步；
4. 用并查集合并将 v合并到u
5. 遍历所有询问中与当前点u相关的点v，如果x被标记(被访问过),那么lca(u, v)=find(v);
复杂度是O(n+q)；

#include <bits/stdc++.h>
#define inf 0x3f3f3f3f
using namespace std;
const int maxn=4e4+10;
struct node{
    int v, nxt, w;
}edge[maxn<<1];
int head[maxn], cnt;
void add(int u, int v, int w){
    edge[cnt]=node{v, head[u], w};
    head[u]=cnt++;
}   
int n, m;
int per[maxn], vis[maxn], dis[maxn];
vector<int> q[maxn];
map<pair<int, int>, int> mp;
void init(){
    cnt=0;
    mp.clear();
    for(int i=0; i<=n; i++){
        per[i]=i;
        head[i]=-1;
        vis[i]=0;
        q[i].clear();
    }
}
int find(int x){
    return per[x]==x?per[x]:per[x]=find(per[x]);
}
void Union(int u, int v){
    int fu=find(u), fv=find(v);
    per[fv]=fu;
}
struct query{
    int u, v;
}p[maxn];
void tarjan(int u, int fa){
    for(int i=head[u]; i!=-1; i=edge[i].nxt){
        int v=edge[i].v, w=edge[i].w;
        if(v==fa) continue;
        dis[v]=dis[u]+w;
        tarjan(v, u);
        Union(u, v);
        vis[v]=1;
    }
    for(int i=0; i<q[u].size(); i++){
        int v=q[u][i];
        if(vis[v]){
            int t=find(v);
            int d=dis[u]+dis[v]-2*dis[t];
            mp.insert(make_pair(make_pair(u, v), d));  
        }
    }
}
int main(){
    int T;
    scanf("%d", &T);
    while(T--){
        scanf("%d%d", &n, &m);
        init();
        for(int i=1; i<n; i++){
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            add(u, v, w);
            add(v, u, w);
        } 
        for(int i=0; i<m; i++){
            int u, v;
            scanf("%d%d", &u, &v);
            p[i]=query{u, v};
            q[u].push_back(v);
            q[v].push_back(u);
        }
        dis[1]=0;
        tarjan(1, 1);
        for(int i=0; i<m; i++){
            if(mp.count(make_pair(p[i].u, p[i].v))){
                printf("%d\n", mp[make_pair(p[i].u, p[i].v)]);
            }
            else if(mp.count(make_pair(p[i].v, p[i].u))){
                printf("%d\n", mp[make_pair(p[i].v, p[i].u)]);
            }
        }
    }

    return 0;
}

接着是倍增在线法：
解题步骤：
1. 将u, v调到同一深度；
2. 一起向上跳直到u=v；
我们当然可以一步步的向上跳，但是可想而知复杂度是O(n)的，然后q个询问，整体就是O(nq)的复杂度；显然不合适；那么久尽可能的跳的多一点；
令jump[i][j] 表示在i点向上跳2^j步，那么jump[i][j] = jump[jump[i][j-i]][j-1];

#include <bits/stdc++.h>
using namespace std;
const int maxn=4e4+10;
struct node{
    int v, nxt, w;
}edge[maxn<<1];
int head[maxn], cnt;
void add(int u, int v, int w){
    edge[cnt]=node{v, head[u], w};
    head[u]=cnt++;
}
int n, m, deep[maxn], jump[maxn][15], dis[maxn], k;
void dfs(int u, int fa, int d){
    deep[u]=d;
    for(int i=head[u]; i!=-1; i=edge[i].nxt){
        int v=edge[i].v, w=edge[i].w;
        if(v==fa) continue;
        dis[v]=dis[u]+w;
        jump[v][0]=u;
        for(int i=1; (1<<i)<=n; i++){
            jump[v][i]=jump[jump[v][i-1]][i-1];
            if(k<i) k=i;
        }
        dfs(v, u, d+1);
    }
}
void init(){
    memset(jump, 0, sizeof(jump));
    memset(deep, 0, sizeof(deep));
    dis[1]=0;
    dfs(1, 1, 0);
}
int LCA(int u, int v){
    if(deep[u]<deep[v]) swap(u, v);
    for(int j=k; j>=0; j--){
        if(deep[u]-(1<<j)>=deep[v]){
            u=jump[u][j];
        }
    }
    if(u==v) return u;
    for(int j=k; j>=0; j--){
        if(jump[u][j]!=jump[v][j]){
            u=jump[u][j];
            v=jump[v][j];
        }
    }
    return jump[u][0];
}
int main(){
    int T;
    scanf("%d", &T);
    while(T--){
        scanf("%d%d", &n, &m);
        memset(head, -1, sizeof(head));
        cnt=0;
        for(int i=1; i<n; i++){
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            add(u, v, w);
            add(v, u, w);
        }
        init();
        while(m--){
            int u, v;
            scanf("%d%d", &u, &v);
            int t=LCA(u, v);
            printf("%d\n", dis[u]+dis[v]-2*dis[t]);
        }
    }
    return 0;
}