PAT 1004 Counting Leaves

问题：对于一个家谱树，你的任务是统计没有子女的家族成员的个数。原问题链接：https://pintia.cn/problem-sets/994805342720868352/problems/994805521431773184

解决方案：

生成邻接矩阵，利用DFS或者BFS遍历每个节点，在遍历过程中，更新每个节点的深度，并统计不同深度的节点的个数，存放在book数组中。

代码：

#include<iostream>
#include<vector>

using namespace std;

vector<int> v[100];        //邻接矩阵
int book[100] = { 0 };    //存放不同深度节点个数的矩阵
int maxDepth = -1;

void dsp(int index, int depth) {    //在DFS遍历过程中更新depth并统计不同深度的节点的个数
    if (v[index].size() == 0) {
        book[depth]++;
        if (maxDepth < depth)
            maxDepth = depth;
        return;
    }
    for (int i = 0; i < v[index].size(); i++) {
        dsp(v[index][i], depth + 1);
    }
}

int main() {
    int number, N, M, index, temp;
    cin >> N >> M;
    for (int i = 0; i < M; i++) {    //构造邻接矩阵
        cin >> index >> number;
        for (int j = 0; j < number; j++) {
            cin >> temp;
            v[index].push_back(temp);
        }
    }
    dsp(1, 0);
    cout << book[0];
    for (int i = 1; i <= maxDepth; i++)
        cout << " " << book[i];
    return 0;
}

上面的代码清晰，易理解，测试点也都能通过。不过我最开始不是这么写的，我之前的写法比较low。我是写一个class类（太麻烦了。。。），而且DFS递归过程中对于depth的更新也显得比较呆。。。具体就是下面的代码（还有两个测试点不能通过，也不知道是为啥。。。）

#include<iostream>
#include<algorithm>
#include<queue>

using namespace std;

class Node {
private:
    int number;
    int position;
    int* child;
    int depth;
public:
    Node() {
        this->number = 0;
        this->position = 0;
        this->child = NULL;
        this->depth = 0;
    }
    void setNode(int number) {
        this->number = number;
        this->child = new int[this->number]{ 0 };
    }
    int isChild() {
        return this->child == NULL ? 0 : 1;
    }
    void setChild(int num) {
        this->child[this->position] = num;
        this->position++;
    }
    void setDepth(int depth) {
        this->depth = depth;
    }
    int getDepth() {
        return this->depth;
    }
    int getNumber() {
        return this->number;
    }
    int getSub(int i) {
        return this->child[i];
    }
    ~Node() { delete[] this->child; };
};

int main() {
    int number, N, M, index, temp, p, maxdepth;
    int book[100] = { 0 };
    std::queue<int> q;
    cin >> N >> M;
    class Node* Array = new Node[N + 1];
    for (int i = 0; i < M; i++) {
        cin >> index >> number;
        Array[index].setNode(number);
        for (int j = 0; j < number; j++) {
            cin >> temp;
            Array[index].setChild(temp);
            Array[temp].setDepth(Array[index].getDepth() + 1);
        }
    }
    maxdepth = 0;
    q.push(1);
    while (!q.empty()) {
        p = q.front();
        q.pop();
        if (!Array[p].isChild()) {
            book[Array[p].getDepth()]++;
            if (maxdepth < Array[p].getDepth())
                maxdepth = Array[p].getDepth();
        }
        for (int i = 0; i < Array[p].getNumber(); i++) {
            q.push(Array[p].getSub(i));
        }
    }
    for (int i = 0; i < maxdepth; i++)
        cout << book[i] << " ";
    cout << book[maxdepth];
    return 0;
}

现在，我大概明白了为啥还有两个测试点不能通过，是因为第二个代码在更新depth的时候是在上面节点的基础上加一，看似很合理，但实际上在输入过程中，如果子节点在父节点之前输入就会出错，比如先输入节点02，再输入节点01，这样01和02的深度便都是0（在输入02后不会在01的基础上加一，而且输入01后不会更新02的深度），但是实际上01的深度为0，而02的深度为1。