Description

A rooted binary tree is a tree with a root node in which every node has at most two children.

Your task is to write a program which reads a rooted binary tree T and prints the following information for each node u of T:

• node ID of u
• parent of u
• sibling of u
• the number of children of u
• depth of u
• height of u
• node type (root, internal node or leaf)

If two nodes have the same parent, they are siblings. Here, if u and v have the same parent, we say u is a sibling of v (vice versa).

The height of a node in a tree is the number of edges on the longest simple downward path from the node to a leaf.

Here, the given binary tree consists of n nodes and evey node has a unique ID from 0 to n-1.

Input

The first line of the input includes an integer n, the number of nodes of the tree.

In the next n lines, the information of each node is given in the following format:

• id left right

id is the node ID, left is ID of the left child and right is ID of the right child. If the node does not have the left (right) child, the left(right) is indicated by -1.

Output

Print the information of each node in the following format:

node id: parent = p , sibling = s , degree = deg, depth = dep, height = h, type

p is ID of its parent. If the node does not have a parent, print -1.

s is ID of its sibling. If the node does not have a sibling, print -1.

deg, dep and h are the number of children, depth and height of the node respectively.

type is a type of nodes represented by a string (root, internal node or leaf. If the root can be considered as a leaf or an internal node, print root.

Please follow the format presented in a sample output below.

Constraints

• 1 ≤ n ≤ 25

Sample Input 1

9
0 1 4
1 2 3
2 -1 -1
3 -1 -1
4 5 8
5 6 7
6 -1 -1
7 -1 -1
8 -1 -1

Sample Output 1

node 0: parent = -1, sibling = -1, degree = 2, depth = 0, height = 3, root
node 1: parent = 0, sibling = 4, degree = 2, depth = 1, height = 1, internal node
node 2: parent = 1, sibling = 3, degree = 0, depth = 2, height = 0, leaf
node 3: parent = 1, sibling = 2, degree = 0, depth = 2, height = 0, leaf
node 4: parent = 0, sibling = 1, degree = 2, depth = 1, height = 2, internal node
node 5: parent = 4, sibling = 8, degree = 2, depth = 2, height = 1, internal node
node 6: parent = 5, sibling = 7, degree = 0, depth = 3, height = 0, leaf
node 7: parent = 5, sibling = 6, degree = 0, depth = 3, height = 0, leaf
node 8: parent = 4, sibling = 5, degree = 0, depth = 2, height = 0, leaf

Reference

Introduction to Algorithms, Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. The MIT Press.

这题太坑了，不，是我太弱了，从晚wa到早，一道很简单的题，好像是日本那边的题目，就是给你一棵树，然后叫你输出各个节点信息，双亲parent，兄弟sibling，度数degree，深度depth，高度height，类型type，我写了一个很强大的函数，一次性把所有都求出来了，但是就不知为什么一直就wa，后来我终于发现。
原来下面这种写法是错的

cin>>v>>tree[v].l>>tree[v].r;

这样才是对的

cin>>v>>l1>>r1;
tree[v].l=l1;
tree[v].r=r1;

切记。

AC代码

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int N=10000;
struct node{
    int l,r,p,s,deg,dep,h;
};
int n,v,l1,r1,tmp,root;
int vis[N]={0};
node tree[N];


int build(int k,int depth){
    if ((tree[k].l==-1)&&(tree[k].r==-1)) {
        tree[k].deg=0;
        tree[k].dep=depth;
        return tree[k].h=0;
    }
    else if ((tree[k].l!=-1)&&(tree[k].r!=-1)){
        tree[tree[k].l].p=k;
        tree[tree[k].r].p=k;
        tree[tree[k].l].s=tree[k].r;
        tree[tree[k].r].s=tree[k].l;
        tree[k].deg=2;
        tree[k].dep=depth;
        return tree[k].h=max(build(tree[k].l,depth+1),build(tree[k].r,depth+1))+1;
    }
    else if (tree[k].l!=-1){
        tree[tree[k].l].p=k;
        tree[tree[k].l].s=-1;
        tree[k].deg=1;
        tree[k].dep=depth;
        return tree[k].h=build(tree[k].l,depth+1)+1; 
    }
    else if (tree[k].r!=-1){
        tree[tree[k].r].p=k;
        tree[tree[k].r].s=-1;
        tree[k].deg=1;
        tree[k].dep=depth;
        return tree[k].h=build(tree[k].r,depth+1)+1; 
    }



}
int main(){
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>v>>l1>>r1;
        tree[v].l=l1;
        tree[v].r=r1;
        if (tree[v].l!=-1) vis[tree[v].l]=1;
        if (tree[v].r!=-1) vis[tree[v].r]=1;
    }
    for(int i=0;i<n;i++){
        if (vis[i]==0){
            root=i;
            break;
        }
    }
    build(root,0);
    tree[root].p=-1;
    tree[root].s=-1;
    for(int i=0;i<n;i++){
        printf("node %d: parent = %d, sibling = %d, degree = %d, depth = %d, height = %d, ",i,tree[i].p,tree[i].s,tree[i].deg,tree[i].dep,tree[i].h);
        if (i==root) printf("root");
        else if(tree[i].l==-1&&tree[i].r==-1) printf("leaf");
        else printf("internal node");
        printf("\n");
    }
    return 0;
}

不过，后来想了一下把所有东西写成一个函数，这种写法不太好，没有让函数模块化，什么都糅杂在一起，而且自己也不能很好的辨别，那些信息是需要遍历树才能获取的，那些信息时不需要遍历就能获取的。

还有，为什么markdown的C++代码这么丑