树上选两点（使最短）树的直径+bfs

题意：

给你一颗树，让你放两个点，放在哪里的时候任意点到某个最近的消防站最远值最小。

思路：

树的直径类题目。

首先我们想两个点会把整棵树分成两个团，所以肯定会在树的某个链上切开。

而且要切一定切在树的直径上，如果不切在直径上，那有一个团的最场距离不就是（直径长度lenth/2了吗）。

所以我们取出直径，枚举切在哪里。

左右两半边的计算方法是一样的，如下图：

我们先算出直径上每个节点的最长距离，因为对于某一个节点，它的分支的长度它到不会超过到直径两端的长度，这样我们就很好算了。

跑两遍：第一次从左到右对左半边的团的直径前缀记录下来，第二次从右到左对右半边的直径后缀记录下来

（注意：1. 对lenth取max，2. 如果直径是偶数如：8，lenth要记为5，mid+1）

最后再跑一遍记录答案就行了。

#define IOS ios_base::sync_with_stdio(0); cin.tie(0);
#include <cstdio>//sprintf islower isupper
#include <cstdlib>//malloc  exit strcat itoa system("cls")
#include <iostream>//pair
#include <fstream>//freopen("C:\Users\13606\Desktop\草稿.txt","r",stdin);
#include <bitset>
//#include <map>
//#include<unordered_map>
#include <vector>
#include <stack>
#include <set>
#include <string.h>//strstr substr
#include <string>
#include <time.h>//srand(((unsigned)time(NULL))); Seed n=rand()%10 - 0~9;
#include <cmath>
#include <deque>
#include <queue>//priority_queue<int, vector<int>, greater<int> > q;//less
#include <vector>//emplace_back
//#include <math.h>
//#include <windows.h>//reverse(a,a+len);// ~ ! ~ ! floor
#include <algorithm>//sort + unique : sz=unique(b+1,b+n+1)-(b+1);+nth_element(first, nth, last, compare)
using namespace std;//next_permutation(a+1,a+1+n);//prev_permutation
#define fo(a,b,c) for(register int a=b;a<=c;++a)
#define fr(a,b,c) for(register int a=b;a>=c;--a)
#define mem(a,b) memset(a,b,sizeof(a))
#define pr printf
#define sc scanf
#define ls rt<<1
#define rs rt<<1|1
typedef long long ll;
void swapp(int &a,int &b);
double fabss(double a);
int maxx(int a,int b);
int minn(int a,int b);
int Del_bit_1(int n);
int lowbit(int n);
int abss(int a);
//const long long INF=(1LL<<60);
const double E=2.718281828;
const double PI=acos(-1.0);
const int inf=(1<<30);
const double ESP=1e-9;
const int mod=(int)1e9+7;
const int N=(int)1e6+10;

int n;

bool vis[N];
vector<vector<int> >G(N);
struct node{int now,val;};
void Init()
{
    for(int i=1;i<=n;++i)
        vis[i]=0;
}
int Val_bfs(node start)
{
    int ans=0;
    queue<node>q;
    q.push(start);
    while(!q.empty())
    {
        node v=q.front();q.pop();
        ans=max(ans,v.val);
        vis[v.now]=1;
        int sz=G[v.now].size();
        for(int i=0;i<sz;++i)
        {
            int to=G[v.now][i];
            if(!vis[to])
                q.push({to,v.val+1});
        }
    }
    return ans;
}

int Start,End;
void queue_dfs1(node start)
{
    Init();
    int max_=0;
    queue<node>q;
    q.push(start);
    while(!q.empty())
    {
        node v=q.front();q.pop();
        vis[v.now]=1;
        if(max_<v.val)max_=v.val,Start=v.now;
        int sz=G[v.now].size();
        for(int i=0;i<sz;++i)
        {
            int to=G[v.now][i];
            if(!vis[to])
                q.push({to,v.val+1});
        }
    }
}
int fa[N];
void queue_dfs2()
{
    for(int i=1;i<=n;++i)fa[i]=0;
    Init();
    int max_=0;
    queue<node>q;
    q.push({Start,1});
    while(!q.empty())
    {
        node v=q.front();q.pop();
        vis[v.now]=1;
        if(max_<v.val)max_=v.val,End=v.now;
        int sz=G[v.now].size();
        for(int i=0;i<sz;++i)
        {
            int to=G[v.now][i];
            if(!vis[to])
                q.push({to,v.val+1}),fa[to]=v.now;
        }
    }
}
int Line[N];
int get_line()
{
    Init();
    int pos=End;
    int cnt=0;
    while(fa[pos])
        Line[++cnt]=pos,vis[Line[cnt]]=1,pos=fa[pos];
    Line[++cnt]=pos,vis[Line[cnt]]=1;
    return cnt;
}
int Val[N];
struct mark
{
    int L,p1;
}memery[N],memery2[N];
void solve(int cnt)
{
    int p1;
    for(int i=1;i<=cnt;++i)
        Val[i]=Val_bfs({Line[i],0});
    memery[0]=memery2[cnt+1]={-1,-1};
    for(int i=1;i<=cnt-1;++i)
    {
        int lenth=(Val[i]+i+1)/2;
        if((Val[i]+i)%2==0)
            lenth++;
        p1=Line[lenth];
        if(lenth<memery[i-1].L)
            memery[i]=memery[i-1];
        else
            memery[i]={lenth,p1};
    }
    int p2;
    for(int i=cnt;i>=2;--i)
    {
        int lenth=(Val[i]+cnt+1-i+1)/2;
        if((Val[i]+cnt+1-i)%2==0)
            lenth++;
        p2=Line[cnt+1-lenth];
        if(lenth<memery2[i+1].L)
            memery2[i]=memery2[i+1];
        else
            memery2[i]={lenth,p2};
    }
    int L=inf,P1,P2;
    for(int i=1;i<=cnt-1;++i)
    {
        if(L>max(memery[i].L,memery2[i+1].L))
            L=max(memery[i].L,memery2[i+1].L),P1=memery[i].p1,P2=memery2[i+1].p1;
    }
    pr("%d %d %d
",L-1,P1,P2);
}

int main()
{
//    freopen("C:\Users\13606\Desktop\草稿.txt","r",stdin);
    int T;
    sc("%d",&T);
    while(T--)
    {
        sc("%d",&n);
        for(int i=1;i<=n;++i)
            G[i].clear();
        for(int i=1;i<=n-1;++i)
        {
            int u,v;
            sc("%d%d",&u,&v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        queue_dfs1({1,1});
        queue_dfs2();
        int lenth=get_line();
        solve(lenth);
    }
    return 0;
}

/**************************************************************************************/

int maxx(int a,int b)
{
    return a>b?a:b;
}

void swapp(int &a,int &b)
{
    a^=b^=a^=b;
}

int lowbit(int n)
{
    return n&(-n);
}

int Del_bit_1(int n)
{
    return n&(n-1);
}

int abss(int a)
{
    return a>0?a:-a;
}

double fabss(double a)
{
    return a>0?a:-a;
}

int minn(int a,int b)
{
    return a<b?a:b;
}