hdu2586&&poj1330 求点间最短距&&最近公共祖先（在线&&离线处理）：：：可做模板

#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;

const int NN=50010;

int n,m;
vector<pair<int,int> > edge[NN],qe[NN];
vector<int> q1,q2;

int p[NN];
int find(int x)
{
if (p[x]!=x) p[x]=find(p[x]);
return p[x];
}

int sum=0,ans[NN],dis[NN];
bool vis[NN]={0};
void lca(int u,int fa)
{
p[u]=u;
for (int i=0; i<edge[u].size(); i++)
{
int v=edge[u][i].first;
if (v==fa) continue;
dis[v]=dis[u]+edge[u][i].second;
lca(v,u);
p[v]=u;
}
vis[u]=true;
if (sum==m) return;
for (int i=0; i<qe[u].size(); i++)
{
int v=qe[u][i].first;
if (vis[v])
ans[qe[u][i].second]=dis[u]+dis[v]-2*dis[find(v)];
}
}

int main()
{
int u,v,w;

int t;
scanf("%d",&t);
while(t--){
scanf("%d%d",&n,&m);
for (int i=1; i<=n; i++)
{
edge[i].clear();
}
for (int i=1; i<n; i++)
{
scanf("%d%d%d",&u,&v,&w);
edge[u].push_back(make_pair(v,w));
edge[v].push_back(make_pair(u,w));
}

for (int i=0; i<m; i++)
{
scanf("%d%d",&u,&v);
qe[u].push_back(make_pair(v,i));
qe[v].push_back(make_pair(u,i));
ans[i]=0;
}
dis[1]=0;
lca(1,0);
for (int i=0; i<m; i++) printf("%d\n",ans[i]);
}
return 0;
}

2
16
1 14
8 5
10 16
5 9
4 6
8 4
4 10
1 13
6 15
10 11
6 7
10 2
16 3
8 1
16 12
16 7
5
2 3
3 4
3 1
1 5
3 5

4
3

//这个tarjan算法使用了并查集+dfs的操作。中间的那个并查集操作的作用，只是将已经查找过的节点捆成一个集合然后再指向一个公共的祖先。另外，如果要查询LCA(a,b)，必须把(a,b)和(b,a)都加入邻接表。
//
//O(n+Q)

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>

using namespace std;

#define MAXN 10001

int n,fa[MAXN];
int rank[MAXN];
int indegree[MAXN];
int vis[MAXN];
vector<int> hash[MAXN],Qes[MAXN];
int ances[MAXN];//祖先

void init(int n)
{
for(int i=0;i<=n;i++)
{
fa[i]=i;
rank[i]=0;
indegree[i]=0;
vis[i]=0;
ances[i]=0;
hash[i].clear();
Qes[i].clear();
}
}

int find(int x)
{
if(x != fa[x])
fa[x]=find(fa[x]);
return fa[x];
}

void unio(int x,int y)
{
int fx=find(x),fy=find(y);
if(fx==fy) return ;
if(rank[fy]<rank[fx])
fa[fy]=fx;
else
{
fa[fx]=fy;
if(rank[fx]==rank[fy])
rank[fy]++;
}
}

void Tarjan(int u)
{
ances[u]=u;
int i,size = hash[u].size();
for(i=0;i<size;i++)
{
Tarjan(hash[u][i]);//递归处理儿子
unio(u,hash[u][i]);//将儿子父亲合并，合并时会将儿子的父亲改为u
ances[find(u)]=u;//此时find(u)仍为u,即
}
vis[u]=1;

//查询
size = Qes[u].size();
for(i=0;i<size;i++)
{
if(vis[Qes[u][i]]==1)//即查询的另一个结点开始已经访问过，当前的u在此回合访问。
{
printf("%d\n",ances[find(Qes[u][i])]);//由于递归，此时还是在u
return;
}
}
}

int main()
{
int t;
int i,j;
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
init(n);
int s,d;
for(i=1;i<=n-1;i++)
{
scanf("%d%d",&s,&d);
hash[s].push_back(d);
indegree[d]++;
}
scanf("%d%d",&s,&d);
//    if(s==d)//如果需要计数的时候注意
//            ans[d]++;
//        else
//        {
Qes[s].push_back(d);
Qes[d].push_back(s);
//        }
for(j=1;j<=n;j++)
{
if(indegree[j]==0)
{
Tarjan(j);
break;
}
}
}
return 0;
}