題意：有n個點組成的一棵樹，讓在樹上選兩個點使得從這兩個點出發到達的最遠距離最小。（好繞OAO）

題解：如果在兩個點u，v之間選一個點滿足題意的話那麼顯然要選中間的點，如果在樹上選的話肯定是要選距離最長那條路線上的中間的點，顯然是樹的直徑上的點。

證明如下:
如果存在u，v不在直徑上，那麼u到直徑上的端點的距離要小於u到子樹端點的距離，這不滿足直徑的定義，所以u，v兩點必然都在直徑上。

根據如上推理，題目中要求得到兩個點，我們根據樹的直徑把當前的樹分為兩個子樹，然後從兩個子樹當中尋找直徑的終點最終分為四個子樹or三個子樹etc…，然後通過bfs再次尋找最短的最長距離（又繞起來了）

$ac\ code:$

#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;
}