poj-2568 Decode the Tree

Decode the Tree

Time Limit:1000MS     Memory Limit:65536KB

Description
A tree (i.e. a connected graph without cycles) with vertices numbered by the integers 1, 2, ..., n is given. The "Prufer" code of such a tree is built as follows: the leaf (a vertex that is incident to only one edge) with the minimal number is taken. This leaf, together with its incident edge is removed from the graph, while the number of the vertex that was adjacent to the leaf is written down. In the obtained graph, this procedure is repeated, until there is only one vertex left (which, by the way, always has number n). The written down sequence of n-1 numbers is called the Prufer code of the tree. 
Your task is, to reconstruct a tree, given its Prufer code. The tree should be denoted by a word of the language specified by the following grammar: 

T ::= "(" N S ")"

S ::= " " T S

    | empty

N ::= number

That is, trees have parentheses around them, and a number denoting the identifier of the root vertex, followed by arbitrarily many (maybe none) subtrees separated by a single space character. As an example, take a look at the tree in the figure below which is denoted in the first line of the sample output. To generate further sample input, you may use your solution to Problem 2567. 
Note that, according to the definition given above, the root of a tree may be a leaf as well. It is only for the ease of denotation that we designate some vertex to be the root. Usually, what we are dealing here with is called an "unrooted tree".
Input
The input contains several test cases. Each test case specifies the Prufer code of a tree on one line. You will find n-1 numbers separated by a single space. Input is terminated by EOF. You may assume that 1<=n<=50.
Output

For each test case generate a single line containing the corresponding tree, denoted as described above. Note that, in general, there are many ways to denote such a tree: choose your favourite one. 

Sample Input
5 2 5 2 6 2 8
2 3
2 1 6 2 6
Sample Output
(8 (2 (3) (5 (1) (4)) (6 (7))))
(3 (2 (1)))

(6 (1 (4)) (2 (3) (5)))

题意：在树中，每次删去节点值最小的叶子结点。    
　　每删去一个点，就给出与这相连的点的值，直到最后只剩下一个根结点，给这N-1个数，重新建立这个树。

思路：

将当前测试用例节点保存到f[n]数组。ans[n]数组记录每个节点出现的次数；

定义vector<int> vec[n]。vec[x]中保存x节点的子节点；

创建优先队列，将ans中为0的节点入队列；

然后遍历f[i]（0<=i<=n）

{ 取出队列中值最小的节点x；

  将x存入[i]中；

ans[i]--;若ans[i]==0即i子节点已全部删除，则将i送入优先队列；

}

最后从根节点开始遍历（dfs）输出树；

注意：因为该题会出现n==1即输入数据（n-1）只有一个回车的情况，所以不能用scanf，getchar等。

可以用用sstream类库读取数据的方法

#include<iostream>
#include<stdio.h>
#include<queue>
#include<string.h>
#include<string>
#include<sstream>
#include<algorithm>
#include<vector>
using namespace std;
int f[55],ans[55];
vector<int> vec[55];
bool cmp(const int &a,const int &b)
{
	return a<b;
}
void dfs(int x)
{
	printf("(");
	printf("%d",x);
	int l=vec[x].size();
	sort(vec[x].begin(),vec[x].end(),cmp);//vector排序
	for(int i=0;i<l;i++)
	{
		printf(" ");
		dfs(vec[x][i]);
	}
	printf(")");
	vec[x].clear();//清空vector以防影响下组数据
}
int main()
{
	int i,n=0;
	char c;
	string line;
	memset(ans,0,sizeof(ans));
	while(getline(cin,line))//输入'EOF'停止
	{
		stringstream ss(line);//用sstream类库读取数据
		for(n=0;ss>>f[n];n++)//
			ans[f[n]]++;
		n--;
			priority_queue<int,vector<int>,greater<int> > leafs;
			for(i=1;i<=n+1;i++)
				if(!ans[i]) leafs.push(i);
			for(i=0;i<=n;i++)
			{
				int k=leafs.top();
				leafs.pop();
				vec[f[i]].push_back(k);
				if(--ans[f[i]]==0) leafs.push(f[i]);
			}
			if(n!=-1) dfs(f[n]);
			else printf("(1)");//输入为0
			printf("\n");
			memset(ans,0,sizeof(ans));
	}
}