LeetCode 508. Most Frequent Subtree Sum (c++)

最新推荐文章于 2020-07-14 18:50:41 发布

haotiangg

最新推荐文章于 2020-07-14 18:50:41 发布

阅读量265

点赞数

分类专栏： LeetCode tree C++ 文章标签： C++ LeetCode 二叉树

本文链接：https://blog.csdn.net/haotiangg/article/details/73560349

版权

tree 同时被 3 个专栏收录

10 篇文章 0 订阅

订阅专栏

C++

10 篇文章 0 订阅

订阅专栏

LeetCode

9 篇文章 0 订阅

订阅专栏

Given the root of a tree, you are asked to find the most frequent subtree sum. 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). So what is the most frequent subtree sum value? If there is a tie, return all the values with the highest frequency in any order.

Examples 1
Input:

  5
 /  \
2   -3

return [2, -3, 4], since all the values happen only once, return all of them in any order.

Examples 2
Input:

  5
 /  \
2   -5

return [2], since 2 happens twice, however -5 only occur once.

Note: You may assume the sum of values in any subtree is in the range of 32-bit signed integer.

思路一：map + 一个额外的vector用来保存sum的顺序。

class Solution {
public:
    vector<int> findFrequentTreeSum(TreeNode* root) {
        if (!root) return solution;
        dfs(root);

        for (vector<int>::iterator it = order.begin(); it != order.end(); ++it) {
            int sum = *it;
            if(sum_map[sum] == max_num) {
                solution.push_back(sum);
                sum_map[sum] = 0;
            }
        }
 
        return solution;
    }
    
    int dfs(TreeNode* root) {
        if(!root) return 0;
        int sum = root->val;
        sum += dfs(root->left);
        sum += dfs(root->right);

        order.push_back(sum);
        ++sum_map[sum];
        if(sum_map[sum] > max_num) max_num = sum_map[sum];
        return sum;
    }
private:
    vector<int> solution;
    vector<int> order;
    map<int,int> sum_map;
    int max_num = 0;
};

思路二：unordered_map

class Solution {
public:
    vector<int> findFrequentTreeSum(TreeNode* root) {
        unordered_map<int,int> counts;
        int maxCount = 0;
        countSubtreeSums(root, counts, maxCount);
        
        
        vector<int> maxSums;
        for(const auto& x :  counts){
            if(x.second == maxCount) maxSums.push_back(x.first);
        }
        return maxSums;
    }
    
    int countSubtreeSums(TreeNode *r, unordered_map<int,int> &counts, int& maxCount){
        if(r == nullptr) return 0;
        
        int sum = r->val;
        sum += countSubtreeSums(r->left, counts, maxCount);
        sum += countSubtreeSums(r->right, counts, maxCount);
        ++counts[sum];
        maxCount = max(maxCount, counts[sum]);
        return sum;
    }
};