1814 最长链

时间限制: 1 s

空间限制: 256000 KB

题目等级 : 钻石 Diamond

题目描述 Description

现给出一棵N个结点二叉树，问这棵二叉树中最长链的长度为多少，保证了1号结点为二叉树的根。

输入描述 Input Description

输入的第1行为包含了一个正整数N，为这棵二叉树的结点数，结点标号由1至N。

接下来N行，这N行中的第i行包含两个正整数l[i], r[i]，表示了结点i的左儿子与右儿子编号。如果l[i]为0，表示结点i没有左儿子，同样地，如果r[i]为0则表示没有右儿子。

输出描述 Output Description

输出包括1个正整数，为这棵二叉树的最长链长度。

样例输入 Sample Input

2 3

4 5

0 6

0 0

样例输出 Sample Output

数据范围及提示 Data Size & Hint

【样例说明】

　　4-2-1-3-6为这棵二叉树中的一条最长链。

【数据规模】

对于10%的数据，有N≤10；

对于40%的数据，有N≤100；

对于50%的数据，有N≤1000；

对于60%的数据，有N≤10000；

对于100%的数据，有N≤100000，且保证了树的深度不超过32768。

【提示】

关于二叉树：

二叉树的递归定义：二叉树要么为空，要么由根结点，左子树，右子树组成。左子树和右子树分别是一棵二叉树。

请注意，有根树和二叉树的三个主要差别：

1. 树的结点个数至少为1，而二叉树的结点个数可以为0；

2. 树中结点的最大度数没有限制，而二叉树结点的最大度数为2；

3. 树的结点无左、右之分，而二叉树的结点有左、右之分。

关于最长链：

最长链为这棵二叉树中一条最长的简单路径，即不经过重复结点的一条路径。可以容易证明，二叉树中最长链的起始、结束结点均为叶子结点。

分类标签 Tags 点此展开

最小生成树图论

题解：

自己做完了，再看看题解写的都好简单啊，现在讲述一下我高大上的思路：

1、建立单向边，记录出度

2、dfs 搜出每个点的深度，记录这棵树的最深深度

3、利用出度，O(n)扫除叶子节点，记录一下

4、扫描叶子节点，找出最深深度的叶子节点x

5、用点x依次与其他叶子节点求lca，依次取大，ans=max(ans,dep[其他叶子节点]-dep[zj]+dep[tx]-dep[zj]);//zj代表最近公共祖先 {易证}

6、输出ans->AC

AC代码：

#include<cstdio>
#include<vector>
using namespace std;
const int N=1e5+100;
int n,dep[N],g[N][21];
int dc[N],tc[N],exde,ans;
short out[N];
vector<int>e[N];
void dfs(int x,int de){
    exde=max(exde,de);
    for(int i=0;i<e[x].size();i++){
        if(!dep[e[x][i]]){
            dep[e[x][i]]=dep[x]+1;
            g[e[x][i]][0]=x;
            dfs(e[x][i],de+1);
        }
    }
}
int lca(int a,int b){
    if(dep[a]<dep[b]) swap(a,b);
    int t=dep[a]-dep[b];
    int ans=0x7fffffff; 
    for(int i=0;i<=20;i++){
        if((1<<i)&t){
            a=g[a][i]; 
        }
    }
    if(a==b) return a;
    for(int i=20;i>=0;i--){
        if(g[a][i]!=g[b][i]){
            a=g[a][i];
            b=g[b][i];  
        }
    }
    return min(g[a][0],g[b][0]);                       
}
int main(){
    scanf("%d",&n);
    if(n==1){printf("1
");return 0;}
    for(int i=1,x,y;i<=n;i++){
        scanf("%d%d",&x,&y);
        if(x) e[i].push_back(x),out[i]++;
        if(y) e[i].push_back(y),out[i]++;
    }
    for(int i=1;i<=n+1;i++) if(!out[i]) dc[++dc[0]]=i;
    dfs(1,0);
    for(int j=1;j<=20;j++){
        for(int i=1;i<=n;i++){
            g[i][j]=g[g[i][j-1]][j-1];
        }
    }
    int tx=0;
    for(int i=1;i<=dc[0];i++) if(dep[dc[i]]==exde) {tx=dc[i];break;}
    for(int i=1;i<tx;i++){
        int zj=lca(dc[i],tx);
        ans=max(ans,dep[dc[i]]-dep[zj]+dep[tx]-dep[zj]);
    }
    for(int i=tx+1;i<=dc[0];i++){
        int zj=lca(dc[i],tx);
        ans=max(ans,dep[dc[i]]-dep[zj]+dep[tx]-dep[zj]);
    }
    printf("%d
",ans);
    return 0;
}

AC代码2：

//朴素搜索：一遍dfs求出某个节点到到叶子节点的最长距离，记为len[i]，在求出以某个点为祖先的最长链长度，记为f[i]，取最大的f[i]即为答案
#include<cstdio>
#include<iostream>
#define M 100010
using namespace std;
int lch[M],rch[M],len[M],f[M],n;
inline const int read(){
    register int x=0,f=1;
    register char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
void dfs(int x){
    if(len[x])return;
    if(lch[x])dfs(lch[x]);
    if(rch[x])dfs(rch[x]);
    if(rch[x]||lch[x])len[x]=max(len[lch[x]],len[rch[x]])+1;
}
int main(){
    n=read();
    for(int i=1;i<=n;i++)lch[i]=read(),rch[i]=read();
    dfs(1);
    for(int i=1;i<=n;i++){
        f[i]=len[lch[i]]+len[rch[i]];
        if(lch[i])f[i]++;
        if(rch[i])f[i]++;
    }
    int ans=0;
    for(int i=1;i<=n;i++) ans=max(ans,f[i]);
    printf("%d",ans);
    return 0;
}

AC代码3：

//树形dp写的
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define N 100001
int n,l[N],r[N],ans;
int dfs(int k){
    if (k==0) return 0;
    int x=dfs(l[k]),y=dfs(r[k]);
    ans=max(ans,x+y);
    return max(x,y)+1;
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d%d",&l[i],&r[i]);
    ans=max(ans,dfs(1)-1);
    printf("%d",ans);
    return 0;
}