【ACM】- PAT.A1094 The Largest Generation【树的遍历】

题目链接

题目分析

查找树中结点最多的是哪一层；

解题思路

1、树的结点没有信息，故用 静态存储 的简化形式vecrot<int>[]；
2、先序遍历（DFS）层序遍历（BFS）都行；开一个数组level[]记录每层的结点数，最后遍历查找最大层即可。

---

静态存储 版本

/**************************
*@Author: 3stone
*@ACM: PAT.A1094 The Largest Generation  
*@Time: 18/7/30
*@IDE: VSCode 2018 + clang++
***************************/
#include<cstdio>
#include<cstring>
#include<vector>

using namespace std;

const int maxn = 110;

int level[maxn]; //统计每层结点数（层数最多为单链表时）

//树结点 (静态存储的简化形式)
vector<int> child[maxn];

//先根遍历 （DFS）
void pre_order(int root, int layer) {

    level[layer]++; //本层 节点数+1
    for(int i = 0; i < child[root].size(); i++){
        pre_order(child[root][i], layer + 1);
    }
}

int main() {

    int n, m, new_id, temp, temp_num;

    while(scanf("%d %d", &n, &m) != EOF) {

        //初始化
        for(int i = 0; i <= n; i++){
            child[i].clear();
        }
        memset(level, 0, sizeof(level)); //每层节点数初始化为0

        //获取非叶结点信息
        for(int i = 0; i < m; i++) {
            scanf("%d", &new_id);
            scanf("%d", &temp_num);
            for(int j = 0; j < temp_num; j++) {
                scanf("%d", &temp);
                child[new_id].push_back(temp);
            }
        }

        //(2)先根遍历，用level[]统计每层结点数
        pre_order(1, 1); //根节点是第1层

        //寻找最大层
        int max_level = 1;
        for(int i = 1; level[i] != 0; i++) {
            if(level[max_level] < level[i])
                max_level = i;
        }
        printf("%d %d\n", level[max_level], max_level);

    }//while-scanf

    return 0;
}

---

指针版本（C++）

/**************************
*@Author: 3stone
*@ACM: PAT.A1094 The Largest Generation  
*@Time: 18/7/30
*@IDE: VSCode 2018 + clang++
***************************/
#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

const int maxn = 110;

struct tree_key{
    int id;
    int child_num;
    int child[maxn];
}key[maxn];

int level[maxn]; //统计每层结点数（层数最多为单链表时）

//树结点
struct Node{
    int data;
    Node* child[maxn];
    int child_num;
};


//建树
Node* create(int k) {

    //if(key[k].id == -1) return NULL;

    Node* root = new Node;
    root->data = k;
    root->child_num = key[k].child_num;
    for(int i = 0; i < key[k].child_num; i++) {
        root->child[i] = create(key[k].child[i]);
    }
    return root;
}

//先根遍历 （DFS）
void pre_order(Node *root, int layer) {

    level[layer]++; //本层 节点数+1
    for(int i = 0; i < root->child_num; i++){
        pre_order(root->child[i], layer + 1);
    }
}

int main() {

    int n, m, new_id;

    while(scanf("%d %d", &n, &m) != EOF) {

        //初始化
        for(int i = 0; i <= n; i++){
            key[i].child_num = 0;
            key[i].id = -1;
        }
        memset(level, 0, sizeof(level)); //每层节点数初始化为0

        //获取非叶结点信息
        for(int i = 0; i < m; i++) {
            scanf("%d", &new_id);
            scanf("%d", &key[new_id].child_num);
            for(int j = 0; j < key[new_id].child_num; j++) {
                scanf("%d", &key[new_id].child[j]);
            }
        }

        //建树
        Node* root = create(1); // root ID = 01;
        //(1)层序遍历 寻找结点最多的层

        //(2)先根遍历，用level[]统计每层结点数
        pre_order(root, 1); //根节点是第1层

        //寻找最大层
        int max_level = 1;
        for(int i = 1; level[i] != 0; i++) {
            if(level[max_level] < level[i])
                max_level = i;
        }
        printf("%d %d\n", level[max_level], max_level);

    }//while-scanf

    return 0;
}