HDU 2586 How far away ？（Tarjan离线算法）

题意：给你n个点以及它们两点之间的距离（不成环），询问m次，求两个城市之间的距离。

Tarjan离线算法的模拟过程：http://www.cnblogs.com/JVxie/p/4854719.html

Tarjan离线算法的基本思路：
1、任选一个点为根结点，从根结点开始
2、遍历该点u所有的子节点v（DFS），标记这些子节点已访问过
3、若是v还有子节点，返回2，否则继续下一步
4、合并v到u上，即把v的父节点变为u（并查集）<合并完后如果没有子树就返回上一个父节点>
5、寻找与当前点u有询问关系的点v（离线处理）
6、如果v已经被访问过，则LCA（u,v）=v被合并到的父亲节点a

首先要把这个图传进来，对于所有的无向边，我们需要能访问到这条边的两个结点以及距离，因此用vector储存一个边数组，同时vector还能保存一个结点发出的所有边的数量。我们通过edge[u][i]访问以u为节点到达的第i条边，这条边有两个属性：另一个节点v，和距离dis；

对于询问操作，我们也需要用同样的方式储存，并且要给每条边order参数表示它在原询问的顺序，通过ans[order]按顺序输出结果；

用pre[i]表示i的父节点，dis[i]表示第i个点到我们选定根结点的距离，vis[i]表示第i个点的访问情况；

最后我们求得的询问点(u,v)的距离就是dis[u]+dis[v]-2*dis[LCA(u,v)]；

假设先选定①作为根节点，初始化vis[1]=1,dis[1]=0；
第一重循环0~edge[u].size()，访问以u为节点的所有边；
设每条边另一个节点为v，标记，
继续递归访问，直到不能继续访问；
让v的父节点变为u；
　第二重循环0~query[v].size()，访问以v为节点的询问；
　设询问的另一个节点为qv；
　如果qv访问过，且qv与v不在同一个子树，计算ans；

最后把所有的ans按order顺序输出即可；

TIPS：关于（ans[query[v][j].order]==0）这个判定条件：
考虑情况：$① \xrightarrow{5} ② \xrightarrow{6} ③$
询问(1,3)，(2,3)
如果没有该条件：

vis[1]=1 dis[1]=1
　vis[2]=1 dis[2]=1
　　vis[3]=1 dis[3]=1
　　pre[3]=2
　　qv=1 ans[1]=dis[3]+dis[1]-2*dis[1]=11
　　qv=2 ans[2]=dis[3]+dis[2]-2*dis[2]=6
　pre[2]=1
　qv=3 ans[2]=dis[2]+dis[3]-2*dis[1]=16

可以发现ans[2]修改了两次，并且第二次修改时取值发生错误。
为什么会出现这种情况？
因为对于(2,3)，它们的LCA应该为2，但是当再次访问2时，它们的LCA被修改为1，就会发生距离重复求解，这种错误会发生在询问位于同一子树的点时。

贴代码：

#include <iostream>
#include <cstdio>
#include <vector>
#include <cstring>
using namespace std;
const int N1=40005;
const int N2=205;

struct TreeEdge{
    int v,dis;
    TreeEdge(int a=0,int b=0){v=a;dis=b;}  
};
vector<TreeEdge> edge[2*N1];

struct QueryEdge{
    int v,order;
    QueryEdge(int a=0,int b=0){v=a;order=b;}  
};
vector<QueryEdge> query[2*N2];

int pre[N1],dis[N1],vis[N1],ans[N2];
int find(int i){    
    return pre[i]==i?i:pre[i]=find(pre[i]);    
}    

void tarjan(int u){
//    system("pause");
    for(int i=0;i<edge[u].size();i++){
        int v=edge[u][i].v;
        if(vis[v]) continue;
        vis[v]=1;
        dis[v]=dis[u]+edge[u][i].dis;
        tarjan(v);
        pre[v]=u;
        for(int j=0;j<query[v].size();j++){
            int qv=query[v][j].v;
            if(vis[qv]&&ans[query[v][j].order]==0){

                ans[query[v][j].order]=dis[v]+dis[qv]-2*dis[find(qv)];
            }
        }
    }
}
int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        int n,m;
        scanf("%d %d",&n,&m);

        memset(vis,0,sizeof(vis));
        memset(ans,0,sizeof(ans));

        for(int i=0;i<=n;i++){
            pre[i]=i;
            query[i].clear();
            edge[i].clear();

        }


        for(int i=1;i<n;i++){
            int u,v,w;
            scanf("%d %d %d",&u,&v,&w);
            edge[u].push_back(TreeEdge(v,w));
            edge[v].push_back(TreeEdge(u,w));

        }
        for(int i=1;i<=m;i++){
            int u,v;
            scanf("%d %d",&u,&v);
            query[u].push_back(QueryEdge(v,i));
            query[v].push_back(QueryEdge(u,i));
        }
        vis[1]=1;  
        dis[1]=0; 
        tarjan(1);

        for(int i=1;i<=m;i++){
            printf("%d\n",ans[i]);
        }

    }
}
/*
2
3 3
1 2 5
2 3 6
1 2
2 3
1 3


2 2
1 2 100
1 2
2 1
*/