### 思路
1. 使用广度优先搜索（BFS）遍历二叉树，记录每一层的节点数。
2. 使用队列来实现BFS，队列中存储节点和其对应的层数。
3. 在遍历过程中，更新每一层的节点数，并记录最大节点数。

### 伪代码
1. 定义二叉树节点结构 `TreeNode` 和二叉树指针 `Tree`.
2. 定义 `CreateTree` 函数：
   - 读取输入，构造二叉树。
3. 定义 `TreeWidth` 函数：
   - 使用队列进行BFS遍历。
   - 记录每一层的节点数，并更新最大节点数。
4. 在 `main` 函数中：
   - 调用 `CreateTree` 构造二叉树。
   - 调用 `TreeWidth` 计算二叉树的宽度。
   - 输出二叉树的宽度。

### C++代码

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

TreeNode* CreateTree(int n, vector<pair<int, int>>& edges) {
    vector<TreeNode*> nodes(n + 1, nullptr);
    for (int i = 1; i <= n; ++i) {
        nodes[i] = new TreeNode(i);
    }
    for (auto& edge : edges) {
        int parent = edge.first;
        int child = edge.second;
        if (!nodes[parent]->left) {
            nodes[parent]->left = nodes[child];
        } else {
            nodes[parent]->right = nodes[child];
        }
    }
    return nodes[1];
}

int TreeWidth(TreeNode* root) {
    if (!root) return 0;
    queue<pair<TreeNode*, int>> q;
    q.push({root, 0});
    vector<int> level_count(51, 0); // Since n <= 50
    int max_width = 0;
    while (!q.empty()) {
        auto node = q.front().first;
        int level = q.front().second;
        q.pop();
        level_count[level]++;
        max_width = max(max_width, level_count[level]);
        if (node->left) q.push({node->left, level + 1});
        if (node->right) q.push({node->right, level + 1});
    }
    return max_width;
}

int main() {
    int n;
    cin >> n;
    vector<pair<int, int>> edges(n - 1);
    for (int i = 0; i < n - 1; ++i) {
        cin >> edges[i].first >> edges[i].second;
    }
    TreeNode* root = CreateTree(n, edges);
    cout << TreeWidth(root) << endl;
    return 0;
}