Factory

Accepts: 100
Submissions: 383
Time Limit: 20000/10000 MS (Java/Others)
Memory Limit: 132768/132768 K (Java/Others) Problem Description

我们将A省简化为由N个城市组成，某些城市之间存在双向道路，而且A省的交通有一个特点就是任意两个城市之间都能通过道路相互到达，且在不重复经过城市的情况下任意两个城市之间的到达方案都是唯一的。聪明的你一定已经发现，这些城市构成了树这样一个结构。

现在百度陆续开了许许多多的子公司。每家子公司又会在各城市中不断兴建属于该子公司的办公室。

由于各个子公司之间经常有资源的流动，所以公司员工常常想知道，两家子公司间的最小距离。 我们可以把子公司看成一个由办公室组成的集合。那么两个子公司A和B的最小距离定义为min(dist(x，y))（x∈A，y∈B）。其中dist(x，y)表示两个办公室之间的最短路径长度。

现在共有Q个询问，每次询问分别在两个子公司间的最小距离。

Input

第一行一个正整数T，表示数据组数。

对于每组数据：

第一行两个正整数N和M。城市编号为1至N，子公司编号为1至M。

接下来N-1行给定所有道路的两端城市编号和道路长度。

接下来M行，依次按编号顺序给出各子公司办公室所在位置，每行第一个整数G，表示办公室数，接下来G个数为办公室所在位置。

接下来一个整数Q，表示询问数。

接下来Q行，每行两个正整数a,b(a不等于b），表示询问的两个子公司。

【数据范围】

0<=边权<=100

1<=N,M,Q,工厂总数<=100000

Output

对于每个询问，输出一行，表示答案。

Sample Input Copy

1
3 3
1 2 1
2 3 1
2 1 1
2 2 3
2 1 3
3
1 2
2 3
1 3

Sample Output Copy

1
0
0

题目链接：http://bestcoder.hdu.edu.cn/contests/contest_showproblem.php?cid=776&pid=1002

这个题我记得我学LCA的时候见过这种题，直接预处理两个点的LCA，容斥算距离暴力即可，可能是数据水了，宇航告诉我这种方法有数据可以卡死，我没有算时间复杂度，我记得我学LCA的时候做过，就直接上了，还好过了，我想了一下，如果考虑时间复杂度的话，我可以用比格思茅，大于sqrt的用bfs，小于的直接暴力，大体算了一下时间复杂度，不超时，其实正解应该是虚树，为什么我没有想到，虚树学的不到家。

代码：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#define inf 0x3f3f3f3f
using namespace std;
int fa[100010],anc[100010][32],deep[100010],dis[100010];
struct node{
    int to,val;
};
vector<struct node>edge[100010];
vector<int>vec[100010];
int T,n,m;
void dfs(int x){
    anc[x][0]=fa[x];
    for(int i=1;i<=31;i++)
    anc[x][i]=anc[anc[x][i-1]][i-1];
    int len=edge[x].size();
    for(int i=0;i<len;i++){
        struct node next=edge[x][i];
        if(next.to!=fa[x]){
            fa[next.to]=x;
            deep[next.to]=deep[x]+1;
            dis[next.to]=dis[x]+next.val;
            dfs(next.to);
        }
    }
}
int LCA(int x,int y){
    if(deep[x]<deep[y])
        swap(x,y);
    for(int i=31;i>=0;i--){
        if(deep[y]<=deep[anc[x][i]]){
            x=anc[x][i];
        }
    }
    if(x==y)
        return x;
    for(int i=31;i>=0;i--){
        if(anc[x][i]!=anc[y][i]){
            x=anc[x][i];
            y=anc[y][i];
        }
    }
    return anc[x][0];
}
void Init(){
    for(int i=0;i<=n;i++){
        edge[i].clear();
        vec[i].clear();
    }
    memset(fa,0,sizeof(fa));
    memset(anc,0,sizeof(anc));
}
int main(){
    scanf("%d",&T);
    while(T--){
        int u,v,w;
        scanf("%d%d",&n,&m);
        Init();
        for(int i=1;i<n;i++){
            scanf("%d%d%d",&u,&v,&w);
            edge[u].push_back((node){v,w});
            edge[v].push_back((node){u,w});
        }
        for(int i=1;i<=m;i++){
            int x;
            scanf("%d",&x);
            for(int j=1;j<=x;j++){
                int y;
                scanf("%d",&y);
                vec[i].push_back(y);
            }
        }
        fa[1]=1;
        dfs(1);
        //for(int i=1;i<=n;i++){
        //    printf("%d ",dis[i]);
        //}
        //cout<<endl;
        int q;
        scanf("%d",&q);
        while(q--){
            int ans=inf;
            scanf("%d%d",&u,&v);
            int l1=vec[u].size();
            int l2=vec[v].size();
            for(int i=0;i<l1;i++){
                for(int j=0;j<l2;j++){
                    int lca=LCA(vec[u][i],vec[v][j]);
                    //printf("%d\n",lca);
                    ans=min(ans,dis[vec[u][i]]+dis[vec[v][j]]-dis[lca]*2);
                }
            }
            printf("%d\n",ans);
        }
    }
    return 0;
}