B - Building Fire Stations ZOJ - 3820[BFS+思维+乱搞]

题意：有n个点组成的一棵树，让在树上选两个点使得从这两个点出发到达的最远距离最小。（好绕OAO）

---

题解：如果在两个点u，v之间选一个点满足题意的话那么显然要选中间的点，如果在树上选的话肯定是要选距离最长那条路线上的中间的点，显然是树的直径上的点。

证明如下:
如果存在u，v不在直径上，那么u到直径上的端点的距离要小于u到子树端点的距离，这不满足直径的定义，所以u，v两点必然都在直径上。

根据如上推理，题目中要求得到两个点，我们根据树的直径把当前的树分为两个子树，然后从两个子树当中寻找直径的终点最终分为四个子树or三个子树etc…，然后通过bfs再次寻找最短的最长距离（又绕起来了）

---

$accode:$

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for(int i = a; i <= b; i++)
#define per(i, a, b) for(int i = a; i >= b; i--)
#define met(a, b) memset(a, b, sizeof(a))
#define pii pair<int, int>
#define pb push_back
#define fi first
#define se second

const int maxn = 2e5 + 10;
const int inf = 0x3f3f3f3f;
vector<int> g[maxn];
int n;
void init() {
    rep(i, 0, maxn - 1) g[i].clear();
    int u, v;
    scanf("%d", &n);
    rep(i, 1, n - 1) {
        scanf("%d%d", &u, &v);
        g[u].pb(v);
        g[v].pb(u);
    }
}

int pre[maxn]; bool vis[maxn], vis1[maxn];

int bfs(int s) {
    met(vis, false);
    met(pre, -1);
    int res = -1, MAX = -1;
    queue<pii> q;
    q.push(pii(s, 0));
    vis[s] = true;
    while(!q.empty()) {
        pii u = q.front();
        if(u.se > MAX) {
            MAX = u.se;
            res = u.fi;
        }
        q.pop();
        int len = g[u.fi].size();
        rep(i, 0, len - 1) {
            pii v = pii(g[u.fi][i], u.se + 1);
            if(!vis[v.fi]) {
                pre[v.fi] = u.fi;
                vis[v.fi] = true;
                q.push(v);
            }
        }
    }
    return res;
}
int lenn[maxn];

int dis = 0;

int bfs1(int s) {
    int T = 0;
    met(pre, -1);
    queue<int> q;
    while(!q.empty()) q.pop();
    q.push(s);
    vis1[s] = true;
    lenn[s] = 0;
    while(!q.empty()) {
        int u = q.front();
        T = u;
        dis = max(dis, lenn[u]);
        //cout << u << endl;
        q.pop();
        int len = g[u].size();
        rep(i, 0, len - 1) {
            int v = g[u][i];
            if(!vis1[v]) {
                lenn[v] = lenn[u] + 1;
                q.push(v);
                vis1[v] = true;
                pre[v] = u;
            }
        }
    }
    vector<int> res;
    res.clear();
    while(T != -1) {
        res.pb(T);
        T = pre[T];
    }
    int pos = res.size() / 2;
    reverse(res.begin(), res.end());
//    cout << res.size() << " " << pos << endl;
    return res[pos];
}

void solve() {
    met(lenn, 0);
    int last = bfs(bfs(1));
    vector<int> ans;
    ans.clear();
    while(last != -1) {
        ans.pb(last);
        last = pre[last];
    }
    int len = ans.size();
    met(vis1, false);
    vis1[ans[ans.size() / 2]] = true;
    int id1 = bfs1(ans[0]);
    vis1[ans[ans.size() / 2]] = false;
    int id2 = bfs1(ans[ans.size() - 1]);
    dis = 0;
    met(vis1, false);
    vis1[ans[ans.size() / 2]] = true;
    bfs1(id1);
    vis1[ans[ans.size() / 2]] = false;
    bfs1(id2);
    printf("%d %d %d\n", dis, id1, id2);
}

int main() {
    int T;
    scanf("%d", &T);
    while(T--) {
        init();
        solve();
    }
    return 0;
}