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

1

题意:给你一棵节点数为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;
}


### Codeforces 887E Problem Solution and Discussion The problem **887E - The Great Game** on Codeforces involves a strategic game between two players who take turns to perform operations under specific rules. To tackle this challenge effectively, understanding both dynamic programming (DP) techniques and bitwise manipulation is crucial. #### Dynamic Programming Approach One effective method to approach this problem utilizes DP with memoization. By defining `dp[i][j]` as the optimal result when starting from state `(i,j)` where `i` represents current position and `j` indicates some status flag related to previous moves: ```cpp #include <bits/stdc++.h> using namespace std; const int MAXN = ...; // Define based on constraints int dp[MAXN][2]; // Function to calculate minimum steps using top-down DP int minSteps(int pos, bool prevMoveType) { if (pos >= N) return 0; if (dp[pos][prevMoveType] != -1) return dp[pos][prevMoveType]; int res = INT_MAX; // Try all possible next positions and update 'res' for (...) { /* Logic here */ } dp[pos][prevMoveType] = res; return res; } ``` This code snippet outlines how one might structure a solution involving recursive calls combined with caching results through an array named `dp`. #### Bitwise Operations Insight Another critical aspect lies within efficiently handling large integers via bitwise operators instead of arithmetic ones whenever applicable. This optimization can significantly reduce computation time especially given tight limits often found in competitive coding challenges like those hosted by platforms such as Codeforces[^1]. For detailed discussions about similar problems or more insights into solving strategies specifically tailored towards contest preparation, visiting forums dedicated to algorithmic contests would be beneficial. Websites associated directly with Codeforces offer rich resources including editorials written after each round which provide comprehensive explanations alongside alternative approaches taken by successful contestants during live events. --related questions-- 1. What are common pitfalls encountered while implementing dynamic programming solutions? 2. How does bit manipulation improve performance in algorithms dealing with integer values? 3. Can you recommend any online communities focused on discussing competitive programming tactics? 4. Are there particular patterns that frequently appear across different levels of difficulty within Codeforces contests?
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值