SPOJ 913 QTREE系列- Query on a tree II (倍增LCA)

题目地址：QTREE2 - Query on a tree II

LCA学了离线与在线转RMQ方法后就去做这道题，于是想了好长时间也没想到怎么做。看了题解都是用的倍增LCA。。于是又去学了下倍增法求LCA，这才发现用倍增法做简直是水题。。。因为求路径的第k个点可以转化成求第k个父节点，然而倍增法的原理就是根据的父节点，于是这题就很容易解决了。。

求距离很好求。关键是求路径第k个点，显然这个点要么是u的第k个父节点，要么是v的第k个父节点，于是乎，先求一次LCA，判断是u还是v的，然后用倍增法找到那个点即可。

代码如下：

#include <iostream>
#include <string.h>
#include <math.h>
#include <queue>
#include <algorithm>
#include <stdlib.h>
#include <map>
#include <set>
#include <stdio.h>
using namespace std;
#define LL long long
#define PI acos(-1.0)
const int mod=1e7+3;
const int INF=0x3f3f3f3f;
const double eqs=1e-9;
const int MAXN=10000+10;
int dep[MAXN], dis[MAXN], dp[MAXN][30];
int head[MAXN], cnt, n;
struct node
{
        int u, v, w, next;
}edge[MAXN<<1];
void add(int u, int v, int w)
{
        edge[cnt].v=v;
        edge[cnt].w=w;
        edge[cnt].next=head[u];
        head[u]=cnt++;
}
void dfs(int u, int fa)
{
        for(int i=head[u];i!=-1;i=edge[i].next){
                int v=edge[i].v;
                if(v==fa) continue ;
                dep[v]=dep[u]+1;
                dis[v]=dis[u]+edge[i].w;
                dfs(v,u);
                dp[v][0]=u;
        }
}
struct BZ
{
        int i, j;
        void init()
        {
                for(j=1;(1<<j)<=n;j++){
                        for(i=1;i<=n;i++){
                                if(dp[i][j-1]!=-1)
                                dp[i][j]=dp[dp[i][j-1]][j-1];
                        }
                }
        }
        int Query(int u, int v)
        {
                if(dep[u]<dep[v]) swap(u,v);
                for(i=0;(1<<i)<=dep[u];i++) ;
                i--;
                for(j=i;j>=0;j--){
                        if(dep[u]-(1<<j)>=dep[v])
                                u=dp[u][j];
                }
                if(u==v) return u;
                for(j=i;j>=0;j--){
                        if(dp[u][j]!=dp[v][j]){
                                u=dp[u][j];
                                v=dp[v][j];
                        }
                }
                return dp[u][0];
        }
        int kth(int u, int v, int k)
        {
                int root=Query(u,v), ans;
                if(dep[u]-dep[root]+1>=k){
                        ans=dep[u]-k+1;
                        for(i=0;(1<<i)<=dep[u];i++) ;
                        i--;
                        for(j=i;j>=0;j--){
                                if(dep[u]-(1<<j)>=ans)
                                        u=dp[u][j];
                        }
                        return u;
                }
                else{
                        ans=dep[root]+k-(dep[u]-dep[root]+1);
                        for(i=0;(1<<i)<=dep[v];i++) ;
                        i--;
                        for(j=i;j>=0;j--){
                                if(dep[v]-(1<<j)>=ans)
                                        v=dp[v][j];
                        }
                        return v;
                }
        }
}bz;
void init()
{
        memset(head,-1,sizeof(head));
        memset(dep,0,sizeof(dep));
        memset(dis,0,sizeof(dis));
        memset(dp,-1,sizeof(dp));
        cnt=0;
}
int main()
{
        int T, i, u, v, w, k;
        char s[10];
        scanf("%d",&T);
        while(T--){
                scanf("%d",&n);
                init();
                for(i=1;i<n;i++){
                        scanf("%d%d%d",&u,&v,&w);
                        add(u,v,w);
                        add(v,u,w);
                }
                dfs(1,-1);
                bz.init();
                while(scanf("%s",s)!=EOF&&s[1]!=‘O‘){
                        if(s[1]==‘I‘){
                                scanf("%d%d",&u,&v);
                                printf("%d\n",dis[u]+dis[v]-2*dis[bz.Query(u,v)]);
                        }
                        else{
                                scanf("%d%d%d",&u,&v,&k);
                                printf("%d\n",bz.kth(u,v,k));
                        }
                }
        }
        return 0;
}