描述 一棵树有n个结点，已知树上所有的父子结点关系，请问该树的根是几号结点，哪个结点的子结点最多，该结点有哪些子结点。 输入描述 第一行，有1个整数n代表结点数量（0<n≤100） 接下来若干行；每行两个结点x和y，表示y是x的孩子(1≤x,y≤1000) 请注意：树上结点的编号不一定是连续的 输出描述 第一行输出树根的编号。 第二行输出孩子最多的结点编号（如果有多个结点的子结点都是最多的，则输出编号最大的那个）。 第三行输出第二行求出的孩子最多的结点，有哪些孩子，按照编号从小到大，输出这些孩子的编号，用空格隔开。使用通用方法C++实现

以下是使用C++实现的通用方法代码，可以处理任意树形结构，其中包括了一些常用的树形结构操作函数：

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

// 树的结点定义
template<typename T>
struct TreeNode {
    T val;
    vector<TreeNode*> children;
    TreeNode(T x) : val(x) {}
};

// 根据父子结点关系构建树
template<typename T>
TreeNode<T>* buildTree(vector<T>& parent, vector<vector<T>>& children) {
    int n = parent.size();
    vector<TreeNode<T>*> nodes(n);
    for (int i = 0; i < n; i++) {
        nodes[i] = new TreeNode<T>(i);
    }
    for (int i = 0; i < n; i++) {
        if (parent[i] == -1) continue;
        nodes[parent[i]]->children.push_back(nodes[i]);
    }
    return nodes[0];
}

// 深度优先遍历树
template<typename T>
void dfs(TreeNode<T>* root, vector<T>& result) {
    if (root == nullptr) return;
    result.push_back(root->val);
    for (auto child : root->children) {
        dfs(child, result);
    }
}

// 宽度优先遍历树
template<typename T>
void bfs(TreeNode<T>* root, vector<T>& result) {
    if (root == nullptr) return;
    queue<TreeNode<T>*> q;
    q.push(root);
    while (!q.empty()) {
        auto node = q.front();
        q.pop();
        result.push_back(node->val);
        for (auto child : node->children) {
            q.push(child);
        }
    }
}

// 找到树的根节点
template<typename T>
TreeNode<T>* findRoot(TreeNode<T>* node) {
    while (node->children.size() > 0) {
        node = node->children[0];
    }
    return node;
}

// 找到子节点最多的结点
template<typename T>
TreeNode<T>* findMaxChildNode(TreeNode<T>* root) {
    int maxChildCount = 0;
    vector<TreeNode<T>*> maxChildNodes;
    queue<TreeNode<T>*> q;
    q.push(root);
    while (!q.empty()) {
        auto node = q.front();
        q.pop();
        int childCount = node->children.size();
        if (childCount > maxChildCount) {
            maxChildCount = childCount;
            maxChildNodes.clear();
            maxChildNodes.push_back(node);
        } else if (childCount == maxChildCount) {
            maxChildNodes.push_back(node);
        }
        for (auto child : node->children) {
            q.push(child);
        }
    }
    return *max_element(maxChildNodes.begin(), maxChildNodes.end(), 
        [](TreeNode<T>* a, TreeNode<T>* b) { return a->val < b->val; });
}

// 找到指定结点的子节点列表
template<typename T>
vector<T> findChildren(TreeNode<T>* node) {
    vector<T> result;
    for (auto child : node->children) {
        result.push_back(child->val);
    }
    sort(result.begin(), result.end());
    return result;
}

int main() {
    int n;
    cin >> n;
    vector<int> parent(n), childCount(n);
    vector<vector<int>> children(n);

    // 读入父子结点关系，统计每个结点的子节点数和子节点列表
    for (int i = 0; i < n; i++) {
        int x, y;
        cin >> x >> y;
        parent[y] = x;
        children[x].push_back(y);
        childCount[x]++;
    }

    // 构建树
    auto root = buildTree<int>(parent, children);

    // 找到根节点
    auto rootNode = findRoot(root);
    cout << rootNode->val << endl;

    // 找到子节点最多的结点
    auto maxChildNode = findMaxChildNode(root);
    cout << maxChildNode->val << endl;

    // 输出子节点列表
    auto childrenList = findChildren(maxChildNode);
    for (auto child : childrenList) {
        cout << child << " ";
    }
    cout << endl;

    return 0;
}

注意，由于通用方法需要支持任意树形结构，因此代码较为复杂，包含了一些树形结构操作函数。如果只需要处理输入描述中给定的树形结构，可以使用更为简单的方法实现。