华为9.8笔试题C++

问题

给出一颗二叉树，每个节点有一个编号和一个值，该值可能为负数，请你找出一个最优节点(除根节点外)，使得在该节点将树分成两棵树后(原来的树移除这个节点及其子节点，新的树以该节点为根节点)，分成的两棵树各 节点的和之间的差绝对值最大。请输出该节点编号，如有多个相同的差，输出编号最小的节点。

输入

4

4 9 -7 -8

0 1

0 3

1 2

第一行，四个节点，编号0-3，范围为1-10000

第二行，节点0-3的权值

第三行到第五行，表示二叉树各节点间的父子关系

0 1 // 节点0的左节点是1

0 3 // 节点0的右节点是3

1 2 // 节点1的左节点是2

注意:左节点永远出现在右节点之前

0:4

/ \

1:9 3:-8

/

2:-7

输出

节点编号，示例中编号为3的节点是最优节点

解法

（我没有参与考试。。。我自己找的数据都可以过，逻辑应该是对的）

#include <iostream>
#include <sstream>
#include <vector>
#include <map>
#include <unordered_map>

using namespace std;
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    explicit TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};

TreeNode *creatTree(vector<int> &valArr, vector<vector<int>> &arr){
    unordered_map<int, TreeNode*> map;
    for(auto &it:arr){
        if(map.find(it[0]) == map.end()){
            auto node = new TreeNode(it[0]);
            map[it[0]] = node;
        }
        auto node = map[it[0]];
        if(node->left != nullptr){
            node->right = new TreeNode(it[1]);
            map[it[1]] = node->right;
        }else{
            node->left = new TreeNode(it[1]);
            map[it[1]] = node->left;
        }
    }
    return map[arr[0][0]];
}
unordered_map<int, int> hashMap;
int proOrderByRecur(TreeNode *node, vector<int> &valArr){
    if(node == nullptr){
        return 0;
    }
    int L = proOrderByRecur(node->left, valArr);
    int R = proOrderByRecur(node->right, valArr);
    hashMap[node->val] = L + R + valArr[node->val];
    return L + R + valArr[node->val];
}
void solution(TreeNode *head, vector<int> &valArr) {
    proOrderByRecur(head, valArr);
    int index ;
    int total = hashMap[head->val];
    int maxVal = 0;

    for(auto &it : hashMap){
        if(it.first == head->val) continue;
        if(abs(total - 2 * it.second) > maxVal){
            maxVal = abs(total - 2 * it.second);
            index = it.first;
        }else if(abs(total - 2 * it.second) == maxVal){
            index = min(index, it.first);
        }
    }
    cout<<index<<endl;
}
void test(){
    int n;
    while(cin >> n){
        cin.ignore();
        string s1;
        while(getline(cin, s1)){
            stringstream ss1(s1);
            vector<int> valArr;
            while(getline(ss1, s1, ' ')){
                valArr.push_back(stoi(s1));
            }
            vector<vector<int>> arr;

            for (int i = 0; i < n-1; ++i) {
                string s2;
                while(getline(cin, s2)){
                    stringstream ss2(s2);
                    vector<int> A;
                    while(getline(ss2, s2, ' ')){
                        A.push_back(stoi(s2));
                    }
                    arr.push_back(A);
                    break;
                }
            }
            auto head = creatTree(valArr, arr);
            solution(head, valArr);
            break;
        }
    }
}

int main() {
    test();
    return 0;
}