POJ 3437 Tree Grafting

Tree Grafting

Description

Trees have many applications in computer science. Perhaps the most commonly used trees are rooted binary trees, but there are other types of rooted trees that may be useful as well. One example is ordered trees, in which the subtrees for any given node are ordered. The number of children of each node is variable, and there is no limit on the number. Formally, an ordered tree consists of a finite set of nodes T such that

• there is one node designated as the root, denoted root(T);
  
• the remaining nodes are partitioned into subsets T1, T2, ..., Tm, each of which is also a tree (subtrees).

Also, define root(T1), ..., root(Tm) to be the children of root(T), with root(Ti) being the i-th child. The nodes root(T1), ..., root(Tm) are siblings.

It is often more convenient to represent an ordered tree as a rooted binary tree, so that each node can be stored in the same amount of memory. The conversion is performed by the following steps:

1. remove all edges from each node to its children;
2. for each node, add an edge to its first child in T (if any) as the left child;
3. for each node, add an edge to its next sibling in T (if any) as the right child.

This is illustrated by the following:

         0                             0       / | \                          /      1  2  3       ===>             1        / \                           \       4   5                           2                                      / \                                     4   3                                      \                                       5

In most cases, the height of the tree (the number of edges in the longest root-to-leaf path) increases after the conversion. This is undesirable because the complexity of many algorithms on trees depends on its height.

You are asked to write a program that computes the height of the tree before and after the conversion.

Input

The input is given by a number of lines giving the directions taken in a depth-first traversal of the trees. There is one line for each tree. For example, the tree above would give dudduduudu, meaning 0 down to 1, 1 up to 0, 0 down to 2, etc. The input is terminated by a line whose first character is #. You may assume that each tree has at least 2 and no more than 10000 nodes.

Output

For each tree, print the heights of the tree before and after the conversion specified above. Use the format:

 Tree t: h1 => h2 

where t is the case number (starting from 1), h1 is the height of the tree before the conversion, and h2 is the height of the tree after the conversion.

Sample Input

dudduduududdddduuuuudddduduuuudddduuduuu#

Sample Output

Tree 1: 2 => 4Tree 2: 5 => 5Tree 3: 4 => 5Tree 4: 4 => 4

分析：

题目意思就是把普通有序树转化成二叉树。输入'd'为向下新建一个结点，'u'为向上回溯一个结点。其实就是前序遍历。每一个结点当前深度为姐妹序号和父亲序号之和，如题目中的'4'结点就是姐妹序号1和父亲序号2之和3。很容易想到递归思想。除了递归，其实还可以这样做！把二叉树左右收拢成一条竖线，用数组来表示。

代码如下：

/*如果max()函数有问题的话，加上inline int max(int a,int b) {return a>b?a:b;}这个函数体试试*/#include <iostream>#include <cstdio>#include <cstring>#include <cstdlib>using namespace std;#define Max 10004char str[3*Max];int t[Max];  //当前结点序数int p[Max];  //当前路径深度int s[Max];  //子结点个数int main(){    int i, j, dp, len, plus=0;    while(gets(str) && strcmp(str,"#")!=0)    {        len = strlen(str);        memset(s, 0, sizeof(s));        for(j=0,i=0,dp=0,p[0]=0; j<len; j++)        {            switch(str[j])            {                case 'd' :                    i++;    //当前深度                    t[i] = s[i-1]+1;    //姐妹结点序号                    p[i] = 0;    //把该结点以下链长清零                    s[i] = 0;    //把该结点分叉数清零                    dp = max(i, dp);    //记录转化前树的深度                    break;                case 'u' :                    i--;    //当前深度                    p[i] = max(p[i], p[i+1]+t[i+1]);    //转化为二叉后该结点以下链长                    s[i] = t[i+1];    //转化为二叉前该结点分叉数                    break;            }        }        printf("Tree %d: %d => %d\n",++plus,dp,p[0]);    }    return 0;}