hdu 2586(LCA在线ST)

How far away ？

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 12063    Accepted Submission(s): 4445

Problem Description
There are n houses in the village and some bidirectional roads connecting them. Every day peole always like to ask like this "How far is it if I want to go from house A to house B"? Usually it hard to answer. But luckily int this village the answer is always unique, since the roads are built in the way that there is a unique simple path("simple" means you can't visit a place twice) between every two houses. Yout task is to answer all these curious people.

Input
First line is a single integer T(T<=10), indicating the number of test cases.
For each test case,in the first line there are two numbers n(2<=n<=40000) and m (1<=m<=200),the number of houses and the number of queries. The following n-1 lines each consisting three numbers i,j,k, separated bu a single space, meaning that there is a road connecting house i and house j,with length k(0<k<=40000).The houses are labeled from 1 to n.
Next m lines each has distinct integers i and j, you areato answer the distance between house i and house j.

Output
For each test case,output m lines. Each line represents the answer of the query. Output a bland line after each test case.

Sample Input
2
3 2
1 2 10
3 1 15
1 2
2 3

2 2
1 2 100
1 2
2 1

Sample Output
10
25
100
100

LCA在线ST：对一颗有根树进行DFS搜索，无论递归还是回溯，每次到达一个节点都将节点的编号记录下来，这样就得到了一条长度为2*n-1的欧拉序列，这样在序列中，从u到v

一定会有u，v的祖先，而不会有u，v祖先节点的祖先，而且u，v之间深度最小的节点就是LCA（u，v），再使用ST算法求RMQ，这样每次查询的时间就能达到O（1）

#include <iostream>
#include <cstdio>
#include <cstring>
#define scan(x) scanf("%d",&x)
#define scan2(x,y) scanf("%d%d",&x,&y)
#define scan3(x,y,z) scanf("%d%d%d",&x,&y,&z)
using namespace std;
const int Max=40010;
const int E=40010*2;
int head[Max],nex[E],pnt[E],cost[E],edge;
int vex[Max<<1],R[Max<<1],vis[Max],dis[Max],first[Max],tot;
//!!vex R 长度要Max*2,因为算法特性会生成顶点数两倍的序列
int n;
void Addedge(int u,int v,int c)
{
pnt[edge]=v;cost[edge]=c;
nex[edge]=head[u];head[u]=edge++;
}
void dfs(int u,int deep)
{
vis[u]=1;
vex[++tot]=u;   //以tot为编号的的节点
first[u]=tot;   //u节点的编号为tot
R[tot]=deep;    //tot编号节点的深度
for(int x=head[u];x!=-1;x=nex[x])
{
int v=pnt[x],c=cost[x];
if(!vis[v])
{
dis[v]=dis[u]+c;
dfs(v,deep+1);
vex[++tot]=u;
R[tot]=deep;
}
}
}
int dp[Max<<1][25];
//!!dp长度要Max*2,,因为算法特性会生成顶点数两倍的序列
void ST(int n) //n是2*n-1
{
int x,y;
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++)
{
x=dp[i][j-1];y=dp[i+(1<<(j-1))][j-1];
dp[i][j]=(R[x]<R[y]?x:y);
}
}
}
int RMQ(int l,int r)
{
int k=0,x,y;
while((1<<(k+1))<=r-l+1) k++;
x=dp[l][k];y=dp[r-(1<<k)+1][k];
return (R[x]<R[y])?x:y;
}
int LCA(int u,int v)
{
int x=first[u],y=first[v];
if(x>y) swap(x,y);
int res=RMQ(x,y);  //在u,v之间的最小深度节点即为lca
return vex[res];
}
void Init()
{
edge=0;
memset(head,-1,sizeof(head));
memset(nex,-1,sizeof(nex));
memset(vis,0,sizeof(vis));
}
int main()
{
int T,Q;
for(scan(T);T;T--)
{
Init();
int u,v,c;
scan2(n,Q);
for(int i=0;i<n-1;i++)
{
scan3(u,v,c);
Addedge(u,v,c);
Addedge(v,u,c);
}
tot=0;dis[1]=0;
dfs(1,1);
ST(2*n);
while(Q--)
{
scan2(u,v);
int lca=LCA(u,v);
printf("%d\n",dis[u]+dis[v]-2*dis[lca]);
}
}
return 0;
}