给定树T = (V,E)，用C++设计一个高效的贪心算法求树的最大独立集的大小，由用户自行输入树的节点和连接关系

为了解决这个问题，我们可以使用贪心算法。具体来说，我们可以遍历树的每个节点，对于每个节点，我们可以选择将其加入最大独立集合中，或者不加入。为了使最大独立集合尽可能大，我们可以使用以下贪心策略：

1. 对于根节点，将其加入最大独立集合中。

2. 对于任意一个非叶子节点，若将其加入最大独立集合中，则其所有子节点都不能加入，因此我们跳过其所有子节点，对其所有的孙节点进行递归操作。

3. 对于任意一个叶子节点，我们可以选择将其加入最大独立集合中或不加入，选择其中一个不影响其他节点的选择。

使用这个贪心策略，我们可以递归地遍历整棵树，并得到最大独立集合的大小。具体的C++代码实现如下：

#include <iostream>
#include <vector>
#include <unordered_map>

using namespace std;

// 树节点的定义
struct TreeNode {
    int val;
    vector<TreeNode*> children;
    TreeNode(int x) : val(x) {}
};

// 计算以root为根节点的子树的最大独立集大小
int dfs(TreeNode* root, unordered_map<TreeNode*, int>& memo) {
    if (memo.find(root) != memo.end()) {
        return memo[root];
    }
    int size = 0;
    for (TreeNode* child : root->children) {
        // 对于非叶子节点，跳过其所有子节点，对其所有的孙节点进行递归操作
        if (!child->children.empty()) {
            for (TreeNode* grandchild : child->children) {
                size += dfs(grandchild, memo);
            }
        }
    }
    // 对于叶子节点，可以选择将其加入最大独立集合中或不加入
    int res = max(1 + size, size);
    memo[root] = res;
    return res;
}

// 计算树的最大独立集大小
int maxIndependentSet(TreeNode* root) {
    if (root == nullptr) {
        return 0;
    }
    // 根节点必须选择
    unordered_map<TreeNode*, int> memo;
    memo[root] = 1;
    int size = 0;
    for (TreeNode* child : root->children) {
        if (!child->children.empty()) {
            // 对于非叶子节点，跳过其所有子节点，对其所有的孙节点进行递归操作
            for (TreeNode* grandchild : child->children) {
                size += dfs(grandchild, memo);
            }
        }
    }
    return size + memo[root];
}

int main() {
    // 读入树的节点和连接关系
    int n;
    cin >> n;
    unordered_map<int, TreeNode*> nodes;
    for (int i = 1; i <= n; i++) {
        nodes[i] = new TreeNode(i);
    }
    for (int i = 0; i < n-1; i++) {
        int u, v;
        cin >> u >> v;
        nodes[u]->children.push_back(nodes[v]);
        nodes[v]->children.push_back(nodes[u]);
    }

    // 计算树的最大独立集大小
    int maxSize = maxIndependentSet(nodes[1]);
    cout << "Max independent set size: " << maxSize << endl;

    // 释放内存
    for (auto p : nodes) {
        delete p.second;
    }

    return 0;
}

注意，在实现中我们使用了一个哈希表memo来记录每个节点的最大独立集大小，避免重复计算。