LeetCode 508. Most Frequent Subtree Sum

Given the root of a binary tree, return the most frequent subtree sum. If there is a tie, return all the values with the highest frequency in any order.

The subtree sum of a node is defined as the sum of all the node values formed by the subtree rooted at that node (including the node itself).

Example 1:

Input: root = [5,2,-3]
Output: [2,-3,4]

Example 2:

Input: root = [5,2,-5]
Output: [2]

Constraints:

• The number of nodes in the tree is in the range [1, 104].
• -105 <= Node.val <= 105

思路：使用深度优先搜索找到subTreeSub，然后统计出现次数并输出：

class Solution {
public:
    map<TreeNode*, int> node2sum;
    int SubTreeSum(TreeNode* root) {
        if (root == nullptr) {
            return 0;
        }
        if (node2sum.find(root) != node2sum.end()) {
            return node2sum[root];
        }

        int sum = root->val+SubTreeSum(root->left)+SubTreeSum(root->right);
        node2sum[root] = sum;
        return sum;
    }

    vector<int> findFrequentTreeSum(TreeNode* root) {
        SubTreeSum(root);
        map<int, int> countmap;
        int max_frequency = 0;
        for (pair<TreeNode *const, int> it : node2sum) {
            countmap[it.second]++;
            if (countmap[it.second] > max_frequency) {
                max_frequency = countmap[it.second];
            }
        }

        vector<int> result;
        for (pair<int, int> it : countmap) {
            if (it.second == max_frequency) {
                result.push_back(it.first);
            }
        }

        return result;
    }
};