北邮机试 | bupt oj | 109. 中序遍历树 | 图的遍历

中序遍历树

时间限制 1000 ms 内存限制 65536 KB

题目描述

给一棵树，你可以把其中任意一个节点作为根节点。每个节点都有一个小写字母，中序遍历，得到一个字符串，求所有能得到的字符串的字典序最小串。因为这棵树不一定是二叉树，所以中序遍历时，先中序遍历以节点序号最小的节点为根的子树，然后再遍历根节点，最后根据节点序号从小到大依次中序遍历剩下的子树。

HINT

意思就是请枚举所有的点为根，然后中序遍历
最后输出所有结果中字典序最小的
比如说第二组数据
以0为根时结果为 bacd
以1为根时结果为 cadb

以2为根时结果为 badc
以3为根时结果为 bacd
所以字典序最小的是bacd

 

 

输入格式

多组数据，以EOF结束。

第一行一个数n（0<n<=100）,表示树的节点的个数，节点从0开始。

然后一个长度为n的串，第i（0<=i<n）个字符表示节点i的字符。
接下来n-1行，每行两个数a，b,(0<=a,b<n),表示a和b之间有一条无向边。

输出格式

题中要求的最小的字符串

输入样例

3
bac
0 1
1 2
4
abcd
0 1
0 2
0 3

输出样例

bac
bacd

AC代码

代码量很大，机试时候肯定做不出来，最后几天了，花时间准备笔试，代码基本都是抄一抄看看思路

代码参考：

https://blog.youkuaiyun.com/u012963208/article/details/64165144

#include<bits/stdc++.h>
#define For(i,start,end) for(int i=start;i<end;i++)
#define MAXN 110
using namespace std;
struct Edge{
    int end;
    Edge(int end):end(end){}
    bool operator < (const Edge &e) const{
        return end<e.end;
    }
};
struct Value{
    char data;
    Value(char data):data(data){}
};
struct Set{
    int setSize;
    vector<Edge> edge[MAXN];
    vector<Value> value;
    bool visited[MAXN];

    void inputValue(char *data){
        For(i,0,setSize){
            Value temp(data[i]);
            value.push_back(temp);
        }
    }
    void inputEdge(int end){
        int x,y;
        For(i,0,end){
            scanf("%d%d",&x,&y);
            edge[x].push_back(Edge(y));
            edge[y].push_back(Edge(x));//***这个用法第一次用，可以学习一波
        }

    }
    void initSet(int setSize){
        this->setSize=setSize;
        For (i,0,setSize){
            edge[i].clear();
        }
        value.clear();
        initVisited();
    }
    void initVisited(){
        For (i,0,setSize){
            visited[i]=false;
        }
    }
    void inOrder(string &s,int root){
        if (visited[root]==false){
            int p=0;
            visited[root]=true;
            //找第一个子节点
            int SIZE = edge[root].size();
            For (p,0,SIZE){
                if (visited[edge[root][p].end]==false){
                    inOrder(s,edge[root][p].end);
                    break;
                }
            }
            s+=value[root].data;
            //添加剩下的子节点
            SIZE = edge[root].size();
            for (;p<SIZE;p++){
                inOrder(s,edge[root][p].end);
            }
        }
    }
};
char tmp[110];
int main()
{
    int n;
    Set set;
    while (scanf("%d",&n)!=EOF){
        set.initSet(n);
        scanf("%s",tmp);
        set.inputValue(tmp);
        set.inputEdge(n-1);
        //保证按照题目要求遍历
        for (int i=0;i<n;i++){
            sort(set.edge[i].begin(),set.edge[i].end());
        }
        string s1="",s2="";
        set.inOrder(s1,0);
        For(i,1,n){
            set.initVisited();
            s2="";
            set.inOrder(s2,i);
            if (s2<s1){
                s1=s2;
            }
        }
        cout<<s1<<endl;
    }
    return 0;
}