HDU 2586 LCA

 题目大意：

多点形成一棵树，树上边有权值，给出一堆询问，求出每个询问中两个点的距离

这里求两个点的距离可以直接理解为求出两个点到根节点的权值之和，再减去2倍的最近公共祖先到根节点的距离

这是自己第一道lca题目

学习了两种方法

第一种在ST算法，利用RMQ思想预处理

/*在线ST算法*/
#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
#define N 40010

int first[N] , k;

struct Edge{
    int x , y , w , next;
    Edge(){}
    Edge(int x , int y , int w , int next):x(x),y(y),w(w),next(next){}
}e[N<<1];

void add_edge(int x , int y , int w)
{
    e[k] = Edge(x , y , w , first[x]);
    first[x] = k++;
}
int dp[N<<1][28];
int id[N<<1] , dep[N<<1] , dis[N] , No[N] , dfs_clock;
void dfs(int u , int f , int d)
{
    id[++dfs_clock] = u , No[u] = dfs_clock , dep[dfs_clock] = d;
    for(int i=first[u] ; ~i ; i=e[i].next){
        int v = e[i].y;
        if(v == f) continue;
        dis[v] = dis[u]+e[i].w;
        dfs(v , u , d+1);
        id[++dfs_clock] = u , dep[dfs_clock] = d;
    }
}

void ST(int n)
{
    for(int i=1 ; i<=n ; i++) dp[i][0] = i;
    for(int j=1 ; (1<<j)<=n ; j++){
        for(int i=1 ; i+(1<<j)-1<=n ; i++){
            int a = dp[i][j-1] , b = dp[i+(1<<(j-1))][j-1];
            dp[i][j] = dep[a]<dep[b]?a:b;
        }
    }
}

int RMQ(int l , int r)
{
    int k=0;
    while((1<<(k+1))<=r-l+1) k++;
    int a = dp[l][k] , b = dp[r-(1<<k)+1][k];
    return dep[a]<dep[b]?a:b;
}

int LCA(int u , int v)
{
    int x = No[u] , y = No[v];
    if(x>y) swap(x , y);
    return id[RMQ(x , y)];
}

int n , m;

int main()
{
   // freopen("in.txt" , "r" , stdin);
    int T , x , y , w;
    scanf("%d" , &T);
    while(T--)
    {
        scanf("%d%d" , &n , &m);
        memset(first , -1 , sizeof(first));
        k = 0;
        for(int i=1 ; i<n ; i++){
            scanf("%d%d%d" , &x , &y , &w);
            add_edge(x , y , w);
            add_edge(y , x , w);
        }
        dfs_clock = 0;
        dis[1] = 0;
        dfs(1 , 0 , 1);
        ST(2*n-1);
        while(m--){
            scanf("%d%d" , &x , &y);
            int anc = LCA(x , y);
            printf("%d
" , dis[x]-2*dis[anc]+dis[y]);
        }
    }
    return 0;
}

第二种是离线的Tarjan算法，利用并查集的思想解决

/*在线ST算法*/
#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
#define N 40010
#define M 205
int first[N] , k;

struct Edge{
    int x , y , w , next;
    Edge(){}
    Edge(int x , int y , int w , int next):x(x),y(y),w(w),next(next){}
}e[N<<1];

int _first[N] , _k;

struct Que{
    int v , lca , next;
    Que(){}
    Que(int v , int lca , int next):v(v),lca(lca),next(next){}
}eq[M<<1];

void add_edge(int x , int y , int w)
{
    e[k] = Edge(x , y , w , first[x]);
    first[x] = k++;
}

void add_que_edge(int x , int y)
{
    eq[_k] = Que(y , 0 , _first[x]);
    _first[x] = _k++;
}

int fa[N] , dis[N];
bool vis[N];
int find(int x){return x==fa[x]?x:fa[x]=find(fa[x]);}

void tarjan(int u)
{
    vis[u] = true , fa[u] = u;
    for(int i=first[u] ; ~i ; i=e[i].next){
        int v = e[i].y;
        if(vis[v]) continue;
        dis[v] = dis[u]+e[i].w;
        tarjan(v);
        fa[v] = u;
    }
    for(int i=_first[u] ; ~i ; i=eq[i].next){
        int v = eq[i].v;
        if(vis[v]) eq[i].lca = eq[i^1].lca = find(eq[i].v);
    }
}
int n , m;

int main()
{
   // freopen("in.txt" , "r" , stdin);
    int T , x , y , w;
    scanf("%d" , &T);
    while(T--)
    {
        scanf("%d%d" , &n , &m);
        memset(first , -1 , sizeof(first));
        k = 0;
        for(int i=1 ; i<n ; i++){
            scanf("%d%d%d" , &x , &y , &w);
            add_edge(x , y , w);
            add_edge(y , x , w);
        }
        memset(_first , -1 , sizeof(_first));
        _k = 0;
        for(int i=0 ; i<m ; i++){
            scanf("%d%d" , &x , &y);
            add_que_edge(x , y);
            add_que_edge(y , x);
        }
        memset(vis , 0 , sizeof(vis));
        tarjan(1);
        for(int i=0 ; i<m*2 ; i+=2){
            int lca = eq[i].lca;
            printf("%d
" , dis[eq[i].v]-2*dis[lca]+dis[eq[i^1].v]);
        }
    }
    return 0;
}