牡丹江.2014B(图论，树的直径）

B - Building Fire Stations

Time Limit:5000MS     Memory Limit:131072KB     64bit IO Format:%lld & %llu

Submit Status Practice ZOJ 3820

Appoint description:  System Crawler  (2015-08-15)

Description

Marjar University is a beautiful and peaceful place. There are N buildings and N - 1 bidirectional roads in the campus. These buildings are connected by roads in such a way that there is exactly one path between any two buildings. By coincidence, the length of each road is 1 unit.

To ensure the campus security, Edward, the headmaster of Marjar University, plans to setup two fire stations in two different buildings so that firefighters are able to arrive at the scene of the fire as soon as possible whenever fires occur. That means the longest distance between a building and its nearest fire station should be as short as possible.

As a clever and diligent student in Marjar University, you are asked to write a program to complete the plan. Please find out two proper buildings to setup the fire stations.

Input

There are multiple test cases. The first line of input contains an integer T indicating the number of test cases. For each test case:

The first line contains an integer N (2 <= N <= 200000).

For the next N - 1 lines, each line contains two integers X_i and Y_i. That means there is a road connecting building X_i and building Y_i(indexes are 1-based).

Output

For each test case, output three integers. The first one is the minimal longest distance between a building and its nearest fire station. The next two integers are the indexes of the two buildings selected to build the fire stations.

If there are multiple solutions, any one will be acceptable.

Sample Input

2
4
1 2
1 3
1 4
5
1 2
2 3
3 4
4 5

Sample Output

1 1 2
1 2 4

 

//#pragma comment(linker, "/STACK:1024000000,1024000000") 
using namespace std ;
const int M = 2e5 + 10 , inf = 111111111 ;
struct node {
        int L , R ;
        int dl , dr ;
        node () {}
        node (int L , int R , int dl , int dr) :
                L(L) , R(R) , dl(dl) , dr(dr) {}
}a[M] ;
int id , maxn ;
int n ;
vector<int> g[M] ;
bool vis[M] ;
vector<int> path ;
int N ;
int dfs (int o , int u) {
        a[u] = node (u , u , 1 , 1) ;
        for (vector<int>::iterator v = g[u].begin () ; v != g[u].end () ; v ++) {
                if (*v == o) continue ;
                int tmp = 1 + dfs (u , *v) ;
                if (tmp > a[u].dl) a[u] = node (a[*v].L , a[u].L , tmp , a[u].dl) ;
                else if (tmp > a[u].dr) a[u].R = a[*v].L , a[u].dr = tmp ;
        }
        if (a[u].dl + a[u].dr > maxn) maxn = a[u].dl + a[u].dr , id = u ;
        return a[u].dl ;
}

bool PATH (int o , int u) {
        for (vector<int>::iterator v = g[u].begin() ; v != g[u].end () ; v ++) {
                if (*v == o) continue ;
                if (PATH (u , *v)) {path.push_back (u) ; return true ;} 
        }
        if (u == a[id].R) {path.push_back (u) ; return true ;} 
        return false ;
}

void DFS (int o , int u , int dep , int deep) {
        if (dep > deep) return ;
        vis[u] = 1 ;
        for (vector<int>::iterator v = g[u].begin() ; v != g[u].end () ; v ++) {
                if (*v == o) continue ;
                DFS (u , *v , dep+1 , deep) ;
        }
}

bool judge (int x) {
        memset (vis , 0 , sizeof(vis)) ;
        DFS (-1 , path[x] , 0 ,  x ) ;
        DFS (-1 , N-x-1 == x ? path[x+1] : path[N-x-1] , 0 , x ) ;
        //printf ("x = %d
" , x ) ;
        //if (x == 1) for (int i = 1 ; i <= n ; i ++) if (!vis[i]) printf ("geng shi %d
" , i ) ;
        for (int i = 1 ; i <= n ; i ++) if (!vis[i]) return false ;
        return true ;
}

void solve () {
        N = path.size () ;
        int l = 0 , r = N / 2 ;
        int ret = r ;
        //printf ("l = %d , r = %d
" , l , r) ;
        while (l <= r) {
                int mid = l + r >> 1 ;
                if (judge (mid)) {
                        ret = mid ;
                        r = mid - 1 ;
                        //printf ("ret = %d
" , ret ) ;
                }
                else l = mid + 1 ;
        }
        printf ("%d %d %d
" , ret , path[ret] , ret == N-ret-1 ? path[ret+1] : path[N-ret-1] ) ;  
}

int main () {
        int T ;
        scanf ("%d" , &T ) ;
        while (T --) {
                scanf ("%d" , &n) ;
                path.clear () ;
                for (int i = 0 ; i <= n ; i ++) g[i].clear () ;
                for (int i = 0 ; i < n - 1 ; i ++) {
                        int u , v ;
                        scanf ("%d%d" , &u , &v) ;
                        g[u].push_back (v) ;
                        g[v].push_back (u) ;
                }

                maxn = -1 ;
                dfs (-1 , 1) ;
                //printf ("Dia = %d , Lnode = %d , Rnode = %d
" , maxn-1 , a[id].L , a[id].R) ;
                PATH (-1 , a[id].L) ;
                //for (vector<int>::iterator it = path.begin() ; it != path.end() ; it ++) printf ("%d " , *it) ; puts ("") ;
                solve () ;
        }
        return 0 ;
}

因为可行的两个点肯定是在树的直径上（对称的两点），所以我们可以二分答案，最优解肯定在0~dia/2 内。

另外找直径的方法可以换一下，可以从任意一点搜到任意一个深度最大的点v，在从v开始搜搜到此时深度最大的点u，则u，v就是树直径的两个端点。

我的方法是：

对于任何一个节点，他都有一个最深，和次深子节点L，R。所以从任意一个点u出发，用u的两个最深的子节点来更新，u.dl= v1.dl+1 , u.dr = v2.dl + 1 ;

u.L = v1 , u.R = v2 (深度（V1) >= 深度 (V2) ) ;

这样找一遍dfs就可以知道Dia是多少，并且知到该直径的两个端点分别是谁。

缺点是打印Dia路径时，需要再写一个dfs，hhhhh

还要注意，zoj坑爹的栈深度很低，20w就爆了，所以想要dfs过的话，就去cf上交吧：http://codeforces.com/gym/100554/problem/B