[AHOI2008]聚会

题目描述

欢乐岛上有个非常好玩的游戏，叫做“紧急集合”。在岛上分散有N个等待点，有N-1条道路连接着它们，每一条道路都连接某两个等待点，且通过这些道路可以走遍所有的等待点，通过道路从一个点到另一个点要花费一个游戏币。

参加游戏的人三人一组，开始的时候，所有人员均任意分散在各个等待点上（每个点同时允许多个人等待），每个人均带有足够多的游戏币（用于支付使用道路的花费）、地图（标明等待点之间道路连接的情况）以及对话机（用于和同组的成员联系）。当集合号吹响后，每组成员之间迅速联系，了解到自己组所有成员所在的等待点后，迅速在N个等待点中确定一个集结点，组内所有成员将在该集合点集合，集合所用花费最少的组将是游戏的赢家。

小可可和他的朋友邀请你一起参加这个游戏，由你来选择集合点，聪明的你能够完成这个任务，帮助小可可赢得游戏吗？

输入输出格式

输入格式：

 

第一行两个正整数N和M（N<=500000，M<=500000），之间用一个空格隔开。分别表示等待点的个数（等待点也从1到N进行编号）和获奖所需要完成集合的次数。 随后有N-1行，每行用两个正整数A和B，之间用一个空格隔开，表示编号为A和编号为B的等待点之间有一条路。 接着还有M行，每行用三个正整数表示某次集合前小可可、小可可的朋友以及你所在等待点的编号。

 

输出格式：

 

一共有M行，每行两个数P,C，用一个空格隔开。其中第i行表示第i次集合点选择在编号为P的等待点，集合总共的花费是C个游戏币。

 

我仔细看看了,求点和求距离, 当然是LCA啦, 又想想...三个点的最短距离怎么求,  自己比划了样例, 感觉和中位数有点像, 发现要的是深度最大的lca, 我就兴冲冲的在询问中写了用了6个lca...结果TLE了, O2都不行...在自己想想可以把最深的lca拿出来, 再算另一个点到他的距离, 这样就只用4个lca. 但是做到这里就很玄学了, 有时能过, 有时就T了.

我就看了看别人的题解(luogu里的), 发现可以只用3个lca就能求出来答案, 并且说三个点的lca, 其中必有两个是一样的, 因为总能找到一个点, 使两个点在这边, 另一个点在那边...

#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <cmath>
const int MAXN = 5e5 + 600;
const int MAXB = 21;
using namespace std;
int n, m;
int deep[MAXN], ancestor[MAXN][MAXB];
struct Edge{
    int to, next;
} edges[MAXN << 1];
int ihead[MAXN], ecnt;
void init(){
    memset(deep, -1, sizeof(deep));

    memset(ihead, 0, sizeof(ihead));
    ecnt = 0;

    memset(ancestor, 0, sizeof(ancestor));
}
void insert(int u, int v){
    Edge & e = edges[++ecnt];
    e.to = v;
    e.next = ihead[u];
    ihead[u] = ecnt;
}
void bfs(){
    queue<int> q;
    q.push(1);
    deep[1] = 0;
    int u, v;
    while(q.size()){
        u = q.front();
        q.pop();
        for(int i = ihead[u]; i; i = edges[i].next){
            const Edge & e = edges[i];
            if(deep[e.to] != -1){
                continue;
            }
            deep[e.to] = deep[u] + 1;
            ancestor[e.to][0] = u;
            q.push(e.to);
        }
    }
    for(int level = 1; level < MAXB; ++level){
        for(int i = 1; i <= n; ++i){
            ancestor[i][level] = ancestor[ancestor[i][level - 1]][level - 1];
        }
    }
}
int lca(int x, int y){
    if(deep[x] < deep[y]){
        swap(x, y);
    }
    for(int i = MAXB - 1; i > - 1; --i){
        if(deep[ancestor[x][i]] >= deep[y]){
            x = ancestor[x][i];
        }
    }
    if(x == y){
        return x;
    }
    for(int i = MAXB - 1; i > -1; --i){
        if(ancestor[x][i] != ancestor[y][i]){
            x = ancestor[x][i];
            y = ancestor[y][i];
        }
    }
    return ancestor[x][0];
}
int dist(int u, int v){
    int a = lca(u, v);
    return deep[u] + deep[v] - (deep[a] << 1);
}
int main(){
    init();

    scanf("%d%d", &n, &m);
    int u, v;
    for(int i = 1; i < n; ++i){
        scanf("%d%d", &u, &v);
        insert(u, v);
        insert(v, u);
    }
    bfs();
    int x, y, z;
    while(m--){
        scanf("%d%d%d", &x, &y, &z);
        int xy = lca(x, y);
        int yz = lca(y, z);
        int xz = lca(x, z);
        int lowest;
        if(xy == yz){
            lowest = xz;
        }
        else if(xy == xz){
            lowest = yz;
        }
        else if(yz == xz){
            lowest = xy;
        }
        // printf("LCA\t%d %d %d %d\n", xy, yz, xz, lowest);
        int rst = deep[x] + deep[y] + deep[z] - deep[xy] - deep[yz] - deep[xz];
        printf("%d %d\n", lowest, rst);
    }
    return 0;
}

这道题感觉还是挺简单的.