树上选两点（使最短）树的直径+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=(<<);
 const double ESP=1e-;
 const int mod=(int)1e9+;
 const int N=(int)1e6+;

 int n;

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

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

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

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

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

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

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