uva 10410 - Tree Reconstruction

此题是给定树的dfs序列和bfs序列然后求每个节点的孩子节点。此题有点像给定二叉树的中序和后序序列然后构建这棵树一样。

核心在于找到bfs和dfs序列的对应关系然后就可以解题了。

bfs中是按照每层的节点以节点的序号的大小出现，而dfs是的结构是  r（根节点）子节点child1....子节点child2.....子节点child3...

很容易发现，这个程序使用递归来写是最方便的，我们找到根节点，然后就找到它的子节点（通过bfs序列和dfs序列的节点的位置），这样就得到了一个子树的dfs序列，然后就可以找到这颗子树在bfs中的第一层孩子节点出现的位置，就可以使用递归函数来解决。

具体的实现细节可以查看代码

//
//  main.cpp
//  uva  10410 - Tree Reconstruction
//
//  Created by XD on 15/7/25.
//  Copyright (c) 2015年 XD. All rights reserved.
//


#include <iostream>
#include <string>
#include <queue>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include<vector>
#include <string.h>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <cstdio>
using namespace std ;
int bfs[1010] ;
int dfs[1010] ;
int bl[1010] ;
int dl[1010] ;
int n  ;
set<int> node[1010] ;

//递归函数 参数为根节点，bfs序列的开始节点 ，当前子树在dfs序列中的结束的位置（两者都是闭区间）
void treeReBuilder(int root , int s1,int e2 )
{
    //按照bfs来构建树
    int pre = s1 ;
    for (int i = s1+1; i < n; i++) {

        //如果当前前一个节点的序号大于当前的节点或者当前节点的序号在dfs序列中的位置大于边界，说明当前节点不是根节点的孩子，那么后面也不会出现根节点的孩子

        if (bfs[pre] > bfs[i] || dl[bfs[i]] > e2 ) {
            break ;
        }
        else{
            //如果前一个孩子和当前节点在dfs序列中相邻，说明了前一个节点没有孩子节点
            if (dl[bfs[pre]] + 1 == dl[bfs[i]]) {
                node[root].insert(bfs[pre]) ;
                pre = i ;
                continue ;
            }

          //如果前一个节点在dfs中的位置大于当前节点子啊dfs序列中的位置，那么当前节点不是根节点的孩子节点，退出循环
            else if(dl[bfs[pre]] > dl[bfs[i]])
            {
                break ;
            }
            else{

               //将前一个节点插入根节点孩子集合中
                node[root].insert(bfs[pre]) ;

               //如果dfs序列中跟节点的孩子节点的下一个节点的在bfs中位置小于孩子节点在bfs中的位置或者超过n-1，那么说明了此孩子节点是叶子节点
                if (bl[dfs[dl[bfs[pre]]+1]] < bl[bfs[pre]] ||bl[dfs[dl[bfs[pre]]+1]] > n-1 ) {
                    continue ;
                }
                
                treeReBuilder(bfs[pre], bl[dfs[dl[bfs[pre]]+1]] ,dl[bfs[i]]- 1) ;
                pre=i;
            }
        }
    }
    
    if(pre == n-1)
    {
        if(root == bfs[pre])
        {
            return ;
        }
        else{
            node[root].insert(bfs[pre]) ;
            return ;
        }
    }
    node[root].insert(bfs[pre]) ;
    if (bl[dfs[dl[bfs[pre]]+1]] < bl[bfs[pre]] ||bl[dfs[dl[bfs[pre]]+1]] > n-1) {
        return ;
    }
    treeReBuilder(bfs[pre],bl[dfs[dl[bfs[pre]]+1]],e2 );
  
}

int main() {
    
    while (scanf("%d" ,&n)==1) {
        
        memset(dfs, 0, sizeof(dfs)) ;
        memset(bfs, 0, sizeof(bfs)) ;
        for (int i = 0; i < n; i++) {
            scanf("%d" ,&bfs[i]) ;
            bl[bfs[i]] = i ;        }
        for (int i = 0; i < n; i++) {
            scanf("%d" ,&dfs[i]) ;
            dl[dfs[i]] = i ;
        }
        for (int i = 0; i <=n ; i++) {
            node[i].clear() ;
        }
        if (n==1) {
            printf("%d:\n",bfs[0]) ;
            continue ;
        }
        treeReBuilder(bfs[0], 1,n-1) ;
        for (int i = 1; i <= n ; i++) {
            printf("%d:", i) ;
            for (set<int >::iterator it =  node[i].begin(); it!=node[i].end(); it++) {
                printf(" %d" , *it) ;
            }
            printf("\n") ;
        }
    }    return 0;
}