2017"百度之星"程序设计大赛 - 初赛（B）1002 Factory （lca+暴力）

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
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
1
0
0

思路：先生成一棵树后套Lca模板求出最近公共祖先，那么两个点u，v之间的最短距离即dir[u] + dir[v] - 2*dir[lca]（lca为u和v的最近公共祖先点）。每次询问两个子公司之间的距离时直接暴力遍历一遍，求出两个集合中的每两个办公室的距离，取其中最短距离即可。
（这么水的模板题当时竟然没去写。，。，。好气啊）

代码如下

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

const int N =100005;  
const int M =25;  
int dp[2*N][M];  //这个数组记得开到2*N，因为遍历后序列长度为2*n-1  
bool vis[N];  
vector<int>comp[100005];
struct edge  
{  
    int v,w,next;  
}e[2*N];  //链式向前星存边
int tot,head[N];  
int tol; 
inline void add(int u ,int v ,int w )  
{  
    e[tol].v = v; e[tol].w = w;  
    e[tol].next = head[u]; head[u] = tol++;  
    u = u^v; v = u^v; u = u^v;  
    e[tol].v = v; e[tol].w = w;  
    e[tol].next = head[u]; head[u] = tol++;  
}  

int ver[2*N],R[2*N],first[N],dir[N];  
//ver:节点编号 R：深度 first：点编号位置 dir：距离  
void dfs(int u ,int dep)  
{  
    vis[u] = true; ver[++tot] = u; first[u] = tot; R[tot] = dep;  
    for(int k=head[u]; k!=-1; k=e[k].next)  
        if( !vis[e[k].v] )  
        {  
            int v = e[k].v , w = e[k].w;  
            dir[v] = dir[u] + w;  
            dfs(v,dep+1);  
            ver[++tot] = u; R[tot] = dep;  
        }  
}  
void ST(int n)  
{  
    for(int i=1;i<=n;i++)  
        dp[i][0] = i;  
    for(int j=1;(1<<j)<=n;j++)  
    {  
        for(int i=1;i+(1<<j)-1<=n;i++)  
        {  
            int a = dp[i][j-1] , b = dp[i+(1<<(j-1))][j-1];  
            dp[i][j] = R[a]<R[b]?a:b;  
        }  
    }  
}  
//中间部分是交叉的。  
int RMQ(int l,int r)  
{  
    int k=0;  
    while((1<<(k+1))<=r-l+1)  
        k++;  
    int a = dp[l][k], b = dp[r-(1<<k)+1][k]; //保存的是编号  
    return R[a]<R[b]?a:b;  
}  

int LCA(int u ,int v)  
{  
    int x = first[u] , y = first[v];  
    if(x > y) swap(x,y);  
    int res = RMQ(x,y);  
    return ver[res];  
}  

int main()  
{  

    int cas; 
    int n,m; 
    scanf("%d",&cas);  
    while(cas--)  
    {  
        int n,q;  
        tol=0;
        scanf("%d%d",&n,&m);  
        memset(head,-1,sizeof(head));  
        memset(vis,false,sizeof(vis));  
        for(int i=1; i<n; i++)  
        {  
            int u,v,w;  
            scanf("%d%d%d",&u,&v,&w);  
            add(u,v,w);  
        }  
        tot = 0; dir[1] = 0;  
        dfs(1,1);  
        ST(2*n-1); 

        for(int i=0;i<=100000;i++)
        comp[i].clear();

        for(int i=1;i<=m;i++)
        {
            int num;
            scanf("%d",&num);
            while(num--)
            {
                int x;
                scanf("%d",&x);
                comp[i].push_back(x);
            }
        }
        scanf("%d",&q);
        while(q--)  
        {  
            int x,y;  
            scanf("%d%d",&x,&y);
            int minn=1e9;
            int s1=comp[x].size();
            int s2=comp[y].size();
            for(int i=0;i<s1;i++)
            for(int j=0;j<s2;j++)
            {
                int u=comp[x][i];
                int v=comp[y][j];
                int lca = LCA(u,v);  
                minn=min(minn,dir[u] + dir[v] - 2*dir[lca]);
                //printf("%d\n",dir[u] + dir[v] - 2*dir[lca]); 
            }
            printf("%d\n",minn);
        }  
    }  
    return 0;  
}