POJ 1986 Distance Queries (最近公共祖先，tarjan)

本题目输入格式同1984，这里的数据范围坑死我了！！！1984上的题目说边数m的范围40000，因为双向边，我开了80000+的大小，却RE。
后来果断尝试下开了400000的大小，AC。
题意：给出n个点，m条边。
　　接下来m行，每行对应u,v,len,字符（字符表示v位于u的哪个方向，在本题没有丝毫用处）
　　表示u和v的路径长度为len。注意本题是双向边！
　　给出k个查询，让你求两点间的距离。
思路：可以这样处理：先处理出每个节点i到根的距离dist[i]。
　　设根节点1到a的路径和1到b的路径的最后一个相同的节点为u，即a和b的最近公共祖先。
　　那么a和b之间的路径为au+ub。
　　au+ub=au+dis[u]+ub+dis[u]-2*dis[u]=dis[a]+dis[b]-2*dis[LCA(a,b)]
　　求最近公共祖先用tarjan算法

还有就是一开始不知道如何将两点之间的距离和对应的查询联系起来，参考了别人的思路后，恍然大悟。
在存储所要查询的内容时，同时记录对应的编号，之后再求LCA时只要将距离存入索引为对应编号的数组中去即可，详细情况见代码吧。

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>
#include <queue>
#include <math.h>
#include <map>

using namespace std;
const int maxn=50005;
const int INF=0x3f3f3f3f;
int n,m,k;
int head[maxn];
int tot=0;
int dis[maxn];  //存储节点到根节点1的距离
int vis[maxn]={0};  //用于LCA中的标记
int vis2[maxn]={0};  //用于标记是否被访问过
int result[10005];

struct Query{
    int u;  
    int id;  //该查询对应的编号
};

vector<Query>link[maxn];


struct Edge{
    int next,to,length;
}edge[maxn*10]; 
//POJ1984上面说边数大小最多40000，由于双向边，我开了80000+，结果RE，后来开了10倍，才AC。。。

void add(int u,int v,int l){
    edge[tot].next=head[u];
    edge[tot].to=v;
    edge[tot].length=l;
    head[u]=tot++;

    edge[tot].next=head[v];
    edge[tot].to=u;
    edge[tot].length=l;
    head[v]=tot++;
}
struct UF{
    int fa[maxn];
    void init(){
        for(int i=0;i<maxn;i++)
            fa[i]=i;
    }
    int find_root(int x){
        if(fa[x]!=x)
            fa[x]=find_root(fa[x]);
        return fa[x];
    }
    void Union(int u,int v){
        int x=find_root(u);
        int y=find_root(v);
        fa[y]=x;
    }
}uf;

void LCA(int u){
    vis2[u]=1;
    for(int k=head[u];k!=-1;k=edge[k].next){
        int v=edge[k].to;
        if(!vis2[v]){
            LCA(v);
            uf.Union(u,v);
        }
    }
    int v,idx,anc;
    vis[u]=1;
    for(int i=0;i<link[u].size();i++){
        v=link[u][i].u;
        if(vis[v]){
            //idx是u和v所对应的第几个询问
            idx=link[u][i].id;
            anc=uf.fa[uf.find_root(v)];
            result[idx]=dis[u]+dis[v]-2*dis[anc];
        }
    }
}
void dfs(int u,int l){
    vis2[u]=1;
    dis[u]=l;
    for(int k=head[u];k!=-1;k=edge[k].next){
        if(!vis2[edge[k].to])
            dfs(edge[k].to,l+edge[k].length);
    }
}
int main()
{
    int u,v,l;
    char str[5];
    memset(dis,1,sizeof(dis));
    memset(head,-1,sizeof(head));
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
        scanf("%d%d%d%s",&u,&v,&l,str);
        add(u,v,l);
        add(v,u,l);
    }
    cin>>k;
    Query tmp;
    for(int i=1;i<=k;i++){
        scanf("%d%d",&u,&v);
        tmp.u=v;tmp.id=i;  //这个方法妙啊，在存储查询内容时，记录下对应的编号。
        link[u].push_back(tmp);
        tmp.u=u;
        link[v].push_back(tmp);
    }
    memset(vis2,0,sizeof(vis2));
    //先求各节点到根节点的距离
    dfs(1,0);
    uf.init();
    memset(vis2,0,sizeof(vis2));
    //LCA求最近公共祖先
    LCA(1);
    for(int i=1;i<=k;i++){
        printf("%d
",result[i]);
    }
    return 0;
}