HDU 6115 Factory LCA求树上距离

题目：

http://acm.hdu.edu.cn/showproblem.php?pid=6115

题意：

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
对于每个询问，输出一行，表示答案。

思路

首先预处理一下LCA，并求出树根到每个点的距离。然后对于两个子公司的距离，暴力配对子公司下面的办公室，两两进行查询即可。板子都快给忘了，真是智障啊。。。错了好多次。。。有空整理下板子。。
倍增：

#include <bits/stdc++.h>

using namespace std;

const int N = 100010, INF = 0x3f3f3f3f;
struct edge
{
    int to, cost, next;
}g[N*2];
int cnt, head[N];
int dep[N];
int dis[N], p[N][20+5];
bool vis[N];

int n, m;
vector<int> vec[N];
void add_edge(int v, int u, int cost)
{
    g[cnt].to = u, g[cnt].cost = cost, g[cnt].next = head[v], head[v] = cnt++;
}
void dfs(int v, int fa, int cost)
{
    dis[v] = cost;
    for(int i = head[v]; i != -1; i = g[i].next)
    {
        int u = g[i].to;
        if(u == fa) continue;
        if(! dep[u])
            dep[u] = dep[v] + 1, p[u][0] = v, dfs(u, v, dis[v] + g[i].cost);
    }
}
void init()
{
    for(int j = 1; (1<<j) <= n; j++)
        for(int i = 1; i <= n; i++)
            p[i][j] = p[p[i][j-1]][j-1];
}
int LCA(int v, int u)
{
    if(dep[v] < dep[u]) swap(v, u);
    int d = dep[v] - dep[u];
    for(int i = 0; (d>>i) != 0; i++)
        if((d>>i) & 1) v = p[v][i];
    if(v == u) return v;
    for(int i = 20; i >= 0; i--)
        if(p[v][i] != p[u][i]) v = p[v][i], u = p[u][i];
    return p[v][0];
}
int main()
{
    int t, q;
    scanf("%d", &t);
    while(t--)
    {
        cnt = 0;
        memset(head, -1, sizeof head);
        scanf("%d%d", &n, &m);
        for(int i = 1; i <= n-1; i++)
        {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            add_edge(a, b, c), add_edge(b, a, c);
        }
        for(int i = 1; i <= m; i++)
        {
            int num, v;
            scanf("%d", &num);
            for(int j = 1; j <= num; j++)
            {
                scanf("%d", &v);
                vec[i].push_back(v);
            }
        }
        memset(dis, 0, sizeof dis);
        memset(dep, 0, sizeof dep);
        dfs(1, 0, 0);
        init();
        scanf("%d", &q);
        for(int i = 1; i <= q; i++)
        {
            int v, u, ans = INF;
            scanf("%d%d", &v, &u);
            for(size_t j = 0; j < vec[v].size(); j++)
                for(size_t k = 0; k < vec[u].size(); k++)
                    ans = min(ans, dis[vec[v][j]] + dis[vec[u][k]] - dis[LCA(vec[v][j], vec[u][k])] * 2);
            printf("%d\n", ans);
        }
        for(int i = 1; i <= m; i++) vec[i].clear();
    }
    return 0;
}

RMQ求LCA：

#include <bits/stdc++.h>

using namespace std;

const int N = 100010, INF = 0x3f3f3f3f;
struct edge
{
    int to, cost, next;
}g[N*2];
int cnt, head[N];
int tot, dep[N*2], ver[N*2], fat[N], fir[N], dp[20][N*2];
int dis[N];
bool vis[N];

int n, m;
vector<int> vec[N];
void add_edge(int v, int u, int cost)
{
    g[cnt].to = u, g[cnt].cost = cost, g[cnt].next = head[v], head[v] = cnt++;
}
void dfs(int v, int fa, int cur, int val)
{
    vis[v] = true, ver[++tot] = v, dep[tot] = cur, fir[v] = tot, fat[v] = fa;
    dis[v] = val;
    for(int i = head[v]; i != -1; i = g[i].next)
    {
        int u = g[i].to;
        if(! vis[u])
        {
            dfs(u, v, cur + 1, dis[v] + g[i].cost);
            ver[++tot] = v, dep[tot] = cur;
        }
    }
}
void ST(int n)
{
    for(int i = 1; i <= n; i++)
        dp[0][i] = i;
    for(int i = 1; (1<<i) <= n; i++)
        for(int j = 1; j <= n - (1<<i) + 1; j++)
            dp[i][j] = dep[dp[i-1][j]] < dep[dp[i-1][j+(1<<(i-1))]] ? dp[i-1][j] : dp[i-1][j+(1<<(i-1))];
}
int RMQ(int l, int r)
{
    int k = log(r - l + 1) / log(2.0);
    return dep[dp[k][l]] < dep[dp[k][r-(1<<k)+1]] ? dp[k][l] : dp[k][r-(1<<k)+1];
}
int LCA(int v, int u)
{
    v = fir[v], u = fir[u];
    if(v > u) swap(v, u);
    int res = RMQ(v, u);
    return ver[res];
}
int main()
{
    int t, q;
    scanf("%d", &t);
    while(t--)
    {
        cnt = 0;
        memset(head, -1, sizeof head);
        scanf("%d%d", &n, &m);
        for(int i = 1; i <= n-1; i++)
        {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            add_edge(a, b, c), add_edge(b, a, c);
        }
        for(int i = 1; i <= m; i++)
        {
            int num, v;
            scanf("%d", &num);
            for(int j = 1; j <= num; j++)
            {
                scanf("%d", &v);
                vec[i].push_back(v);
            }
        }
        memset(dis, 0, sizeof dis);
        memset(vis, 0, sizeof vis);
        tot = 0;
        dfs(1, 0, 1, 0);
        ST(2*n - 1);
        scanf("%d", &q);
        for(int i = 1; i <= q; i++)
        {
            int v, u, ans = INF;
            scanf("%d%d", &v, &u);
            for(size_t j = 0; j < vec[v].size(); j++)
                for(size_t k = 0; k < vec[u].size(); k++)
                    ans = min(ans, dis[vec[v][j]] + dis[vec[u][k]] - dis[LCA(vec[v][j], vec[u][k])] * 2);
            printf("%d\n", ans);
        }
        for(int i = 1; i <= m; i++) vec[i].clear();
    }
    return 0;
}