UESTC 1717 LCA+DIJ

/*
第一次写最近公共祖先问题，用的邻接表指针。

对于一棵有根树，就会有父亲结点，祖先结点，当然最近公共祖先就是这两个点所有的祖先结点中深度最大的一个结点。

       0

       |

       1

     /   \

   2      3

比如说在这里，如果0为根的话，那么1是2和3的父亲结点，0是1的父亲结点，0和1都是2和3的公共祖先结点，但是1才是最近的公共祖先结点，或者说1是2和3的所有祖先结点中距离根结点最远的祖先结点。

在求解最近公共祖先为问题上，用到的是Tarjan的思想，从根结点开始形成一棵深搜树，非常好的处理技巧就是在回溯到结点u的时候，u的子树已经遍历，这时候才把u结点放入合并集合中，这样u结点和所有u的子树中的结点的最近公共祖先就是u了，u和还未遍历的所有u的兄弟结点及子树中的最近公共祖先就是u的父亲结点。以此类推。。这样我们在对树深度遍历的时候就很自然的将树中的结点分成若干的集合，两个集合中的所属不同集合的任意一对顶点的公共祖先都是相同的，也就是说这两个集合的最近公共最先只有一个。对于每个集合而言可以用并查集来优化，时间复杂度就大大降低了，为O(n + q)，n为总结点数，q为询问结点对数。

另外Tarjan解法，是一个离线算法，就是说它必须将所有询问先记录下来，再一次性的求出每个点对的最近公共祖先，只有这样才可以达到降低时间复杂度。
*/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
const int maxn=100012;//node
const int INF=1<<29;
const int maxm=422252;//query
int n,m,c,list,head[maxn],Head[maxn],dis[maxn],vis[maxn],disu[maxn],disv[maxn],in[maxn],fa[maxn],ans[maxm],id[maxn],NE,cnt;
struct node
{
    int v,d,next;
    bool operator < (const node &a) const
    {
        return d > a.d;
    }
} Edge[maxm],edge[maxm],t1,t2;
void addEdge(int u,int v,int d)
{
    Edge[NE].v=v,Edge[NE].d=d,Edge[NE].next=head[u];
    head[u]=NE++;
}
void addedge(int u,int v,int d)
{
    edge[NE].v=v,edge[NE].d=d,edge[NE].next=Head[u];
    Head[u]=NE++;
}
int find(int i)
{
    return (fa[i]==i?i:fa[i]=find(fa[i]));
}
void Tarjan(int u)
{
    vis[u] = 1;
    fa[u] = u;
    for (int i = Head[u]; i!=-1; i=edge[i].next)
    {
        int v=edge[i].v;
        if(vis[v])
        {
            int rt=find(v); // 存的是最近公共祖先结点
            ans[edge[i].d]=dis[u]+dis[v]-2*dis[rt];
            int tmp=min(disu[u]+disv[v]+list,disv[u]+disu[v]+list);
            if(ans[edge[i].d]<tmp)ans[edge[i].d]=0;
            else ans[edge[i].d]=ans[edge[i].d]-tmp;
            //  cout<<"OK "<<edge[i].d<<" "<<ans[edge[i].d]<<endl;
        }
    }
    for(int i= head[u]; i!=-1; i=Edge[i].next)
    {
        int v=Edge[i].v;
        if(!vis[v])
        {
            dis[v] = dis[u] + Edge[i].d;
            Tarjan(v);
            fa[v] = u;
        }
    }
}
void dijstra(int  st)
{
    priority_queue<node> q;
    memset(vis,0,sizeof(vis));
    for(int i = head[st] ; i != -1 ; i = Edge[i].next)
    {
        int v = Edge[i].v;
        if(Edge[i].d<disu[v])
        {
            disu[v] = Edge[i].d;
            t1.d = disu[v];
            t1.v =  v;
            q.push(t1);
        }
    }
    disu[st]=0;//此句没加错了2次，囧~~~
    vis[st] = 1;
    while(!q.empty())
    {
        t1 = q.top();
        q.pop();
        int u = t1.v;
        if(vis[u]) continue;
        vis[u] = 1;
       // res += dis[u];
      //  ans=max(ans,dis[u]);
        for(int i = head[u]; i != -1; i = Edge[i].next)
        {
            int v = Edge[i].v;
            if(!vis[v] && disu[v]>disu[u]+Edge[i].d)
            {
                disu[v] =disu[u]+Edge[i].d;
                t2.v = v;
                t2.d = disu[v];
                q.push(t2);
            }
        }
    }
    return;
}
void Dijstra(int  st)
{
    priority_queue<node> q;
    memset(vis,0,sizeof(vis));
    for(int i = head[st] ; i != -1 ; i = Edge[i].next)
    {
        int v = Edge[i].v;
        if(Edge[i].d<disv[v])
        {
            disv[v] = Edge[i].d;
            t1.d = disv[v];
            t1.v =  v;
            q.push(t1);
        }
    }
    disv[st]=0;//此句没加错了2次，囧~~~
    vis[st] = 1;
    while(!q.empty())
    {
        t1 = q.top();
        q.pop();
        int u = t1.v;
        if(vis[u]) continue;
        vis[u] = 1;
       // res += dis[u];
      //  ans=max(ans,dis[u]);
        for(int i = head[u]; i != -1; i = Edge[i].next)
        {
            int v = Edge[i].v;
            if(!vis[v] && disv[v]>disv[u]+Edge[i].d)
            {
                disv[v] =disv[u]+Edge[i].d;
                t2.v = v;
                t2.d = disv[v];
                q.push(t2);
            }
        }
    }
    return;
}
int main()
{
    //freopen("//media/学习/ACM/input.txt","r",stdin);
    int i,j,u,v,d,T,st,ed,cas=1;
    cin>>T;
    while(T--)
    {
        scanf("%d%d",&n,&c);
        memset(head,-1,sizeof(int)*(n+1));
        memset(Head,-1,sizeof(int)*(n+1));
        memset(dis,0,sizeof(int)*(n+1));
        for(i = 0 ; i <=n+1;  i ++) disu[i] = INF;
        for(i = 0 ; i <=n+1;  i ++) disv[i] = INF;
        memset(ans,0,sizeof(int)*(n+1));
        memset(in,0,sizeof(int)*(n+1));
        for(NE=0,i=1; i<=n-1; i++)
        {
            fa[i]=i;
            scanf("%d%d%d",&u,&v,&d);
            addEdge(u,v,d);
            in[v]++;
            addEdge(v,u,d);
        }
        fa[n]=n;
        scanf("%d%d%d",&st,&ed,&list);
        dijstra(st);
        Dijstra(ed);
        memset(vis,0,sizeof(int)*(n+1));
        for(NE=0,i=1; i<=c; i++)
        {
            scanf("%d%d",&u,&v);
            addedge(u,v,i);
            addedge(v,u,i);
        }
        for(i=1; i<=n; i++)
        {
            if(!in[i])
            {
                Tarjan(i);
                break;
            }
        }
        printf("Case #%d:\n",cas++);
        for(i=1; i<=c; i++)
        {
            printf("%d\n",ans[i]);
        }
    }
    return 0;
}