牛客编程巅峰赛：Tree III（BFS or DFS）

链接：https://ac.nowcoder.com/acm/contest/9557/C
来源：牛客网
 

题目描述

给出一棵有n个节点的节点标号为1~n的有根树（根为第一个节点，并给出从第2个节点到第n个节点的父结点），请你求解它的“第二直径”的长度，即树上任意两点距离非严格的第二长距离为多少（也就是说，如果存在两条不同的，长度均为max的路径，则返回max）。

树：一张有n个节点，n-1条边的无向连通图。

示例1

输入

[1,2,3,4]

返回值

3

说明

树构成了一条1-2-3-4-5的链，不难发现“第二直径”长度为3，其中1到4、2到5均满足要求。

示例2

输入

[1,1,1,1]

返回值

2

说明

树构成了一朵以1为中心的花，不难发现“第二直径”长度为2（当然此时的直径也为2）。

备注:

数据满足：3≤n≤10^5

对于某些容易爆栈的语言，我们强烈建议你使用bfs而不是dfs。

方法一：从树根开始搜，我们可以找到离树根最远和第二远的点，之后从最远的点为起点重复操作，我们仍然保存第二远的点，再从当前最远点重复第三次操作，可以证明第二直径就是这三个长度的最大值。

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 
     * @param e int整型一维数组 长度为n-1的数组，表示结点2到结点n的父结点
     * @return int整型
     */
    private int[] dis;
    private boolean[] vis;
    List<List<Integer>> edges;
    public int tree3 (int[] e) {
        // write code here
        int ans=0;
        int n=e.length+1;
        dis=new int[n+1];
        vis=new boolean[n+1];
        edges=new ArrayList<>();
        for(int i=0;i<=n;i++)
            edges.add(new ArrayList<>());
        for(int i=2;i<=n;i++){
            edges.get(i).add(e[i-2]);
            edges.get(e[i-2]).add(i);
        }
        bfs(1);
        int t1=findSec(n);
        int p=find(n);
        bfs(p);
        p=find(n);
        int t2=findSec(n);
        bfs(p);
        int t3=findSec(n);
        return Math.max(t1,Math.max(t2,t3));
    }
    private int findSec(int n){
        int mx1=-1,mx2=-1;
        for(int i=2;i<=n;i++){
            if(dis[i]>mx1){
                mx2=mx1;
                mx1=dis[i];
            }
            else if(dis[i]>mx2)
                mx2=dis[i];
        }
        return mx2;
    }
    private int find(int n){
        int p=2,mx=0;
        for(int i=2;i<=n;i++){
            if(dis[i]>mx){
                mx=dis[i];
                p=i;
            }
        }
        return p;
    }
    private void bfs(int start){
        Arrays.fill(dis,0);
        Arrays.fill(vis,false);
        Queue<Integer> q=new LinkedList<>();
        q.add(start);
        vis[start]=true;
        while(!q.isEmpty()){
            int now=q.poll();
            int size=edges.get(now).size();
            for(int i=0;i<size;i++){
                int v=edges.get(now).get(i);
                if(vis[v]) continue;
                q.add(v);
                vis[v]=true;
                dis[v]=dis[now]+1;
            }
        }
    }
}

方法二：额外开两个数组分别存储从叶子节点到当前点的最大和第二大距离的值，我们可以在dfs的过程中预处理出来每个子树中所能产生的最大距离和第二大距离。【由于java会爆栈，本方法采用C++】

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 
     * @param e int整型vector 长度为n-1的数组，表示结点2到结点n的父结点
     * @return int整型
     */
    vector<int>q[100005];
    int f[100005],g[100005],num[100005];
    void dfs(int u){
        f[u]=0;g[u]=-1;
        for(int v : q[u]){
            dfs(v);
            ++num[f[u]+f[v]+1];
            ++num[f[u]+g[v]+1];
            ++num[g[u]+f[v]+1];
            if(f[v]+1>f[u]){
                g[u]=max(g[v]+1,f[u]);
                f[u]=f[v]+1;
            } 
            else if(f[v]+1>g[u])
                g[u]=f[v]+1;
        }
    }
    int tree3(vector<int>& e) {
        // write code here
        int n=e.size()+1;
        memset(num,0,sizeof(num));
        for(int i=2;i<=n;i++)
            q[e[i-2]].push_back(i);
        dfs(1);
        bool flag=false;
        for(int i=n;i>0;i--){
            if(num[i]>0){
                if(!flag){
                    flag=true;
                    --num[i];
                }
            }
            if(num[i]>0)
               return i;
        }
        return 0;
    }
};