codeforces622E Ants in Leaves (dfs)-优快云博客

本文探讨了一种树形结构中，每个叶子节点有一只蚂蚁，蚂蚁可以移动到其父节点，求所有蚂蚁到达根节点的最短时间。通过深度优先搜索算法计算每个子树所需时间，并更新根节点所需最小时间。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Description
Tree is a connected graph without cycles. A leaf of a tree is any vertex connected with exactly one other vertex.

You are given a tree with n vertices and a root in the vertex 1. There is an ant in each leaf of the tree. In one second some ants can simultaneously go to the parent vertex from the vertex they were in. No two ants can be in the same vertex simultaneously except for the root of the tree.

Find the minimal time required for all ants to be in the root of the tree. Note that at start the ants are only in the leaves of the tree.

Input
The first line contains integer n (2 ≤ n ≤ 5·105) — the number of vertices in the tree.

Each of the next n - 1 lines contains two integers xi, yi (1 ≤ xi, yi ≤ n) — the ends of the i-th edge. It is guaranteed that you are given the correct undirected tree.

Output
Print the only integer t — the minimal time required for all ants to be in the root of the tree.

Sample Input
Input
12
1 2
1 3
1 4
2 5
2 6
3 7
3 8
3 9
8 10
8 11
8 12
Output
6
Input
2
2 1
Output

题意：给你一棵节点数为n的树，每一个叶子节点上有一只蚂蚁，每一秒树上的蚂蚁都可以走到父亲节点的位置，但是每一个节点（除根节点）最多只能有一只蚂蚁，问最少需要花费的时间。

思路：一定是先让深度小的蚂蚁走到根节点，因为如果有深度大的比深度低的先走到根节点，那么深度低的可能要先等深度大的，而自己没有走，但如果深度低的先走的话，那么深度大的和小的可以一起往根节点走，这样可以在相同的时间走更多的总步数。所以我们算出根节点下的每一个子树走完所要花的最大时间，然后更新答案就行。那么每一棵子树所要花的时间为t[i]=max(t[i-1]+1,deep[t]),即前面一个走到根节点的时间+1与其深度的较大值。

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<string>
#include<algorithm>
using namespace std;
typedef long long ll;
#define inf 99999999
#define pi acos(-1.0)
#define maxn 500050
vector<int>pos[maxn];
vector<int>::iterator it;
int a[maxn],tot,vis[maxn];
void dfs(int u,int father,int deep)
{
    int i,j;
    vis[u]=1;
    if(pos[u].size()==1){
        tot++;a[tot]=deep;
        return;
    }
    for(i=0;i<pos[u].size();i++){
        if(father!=pos[u][i] ){
            dfs(pos[u][i],u,deep+1 );
        }
    }
}
int main()
{
    int n,m,i,j,ans,c,d,len;
    while(scanf("%d",&n)!=EOF)
    {
        for(i=1;i<=n;i++)pos[i].clear();
        for(i=1;i<=n-1;i++){
            scanf("%d%d",&c,&d);
            pos[c].push_back(d);
            pos[d].push_back(c);
        }
        len=pos[1].size();
        ans=0;
        for(i=0;i<len;i++){
            tot=0;
            dfs(pos[1][i],1,1);
            sort(a+1,a+1+tot);
            a[0]=0;
            for(j=1;j<=tot;j++){
                a[j]=max(a[j-1]+1,a[j]);
            }
            ans=max(ans,a[tot]);
        }
        printf("%d\n",ans);
    }
    return 0;
}