508. Most Frequent Subtree Sum

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记录每次子和出现的次数，最后遍历获得结果；

知识点：map的遍历使用指针；vector.clear( )

代码1：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    map<int,int> tongji;
    
    int cal(TreeNode* root){
        if(!root->left && !root->right){
            tongji[root->val]++;
            return root->val;
        }
        int leftsum=0,sum=0,rightsum=0;
        if(root->left){leftsum=cal(root->left);}
        if(root->right){rightsum=cal(root->right);}
        sum=leftsum+rightsum+root->val;
        tongji[sum]++;
        return sum;
    }
    
    vector<int> findFrequentTreeSum(TreeNode* root) {
        vector<int> result;
        if(!root){return result;}
        int temp=cal(root);
        int max = tongji.begin()->second;
        for(map<int,int>::iterator it = tongji.begin();it != tongji.end();it++){
            if(it->second > max){
                max = it->second;
                result.clear();
                result.push_back(it->first);
            }
            else if(it->second == max){result.push_back(it->first);}
        }
        return result;
    }
};

代码2：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    map<int,int> m;
    int helper(TreeNode* root){
        if(root->left==NULL && root->right==NULL){
            m[root->val]++;
            return root->val;
        }
        int res= root->val;
        if(root->left!=NULL){
            res += helper(root->left);
        }
        if(root->right!=NULL){
            res += helper(root->right);
        }
        m[res]++;
        return res;
    }
    
    vector<int> findFrequentTreeSum(TreeNode* root) {
        vector<int> res;
        if(root==NULL){return res;}
        int temp=helper(root);
        temp=0;
        map<int,int>::iterator mp=m.begin();
        while(mp!=m.end()){
            if(mp->second>temp){
                res.clear();
                res.push_back(mp->first);
                temp=mp->second;
            }
            else if(mp->second==temp){res.push_back(mp->first);}
            mp++;
        }
        return res;
    }
};

代码3：

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;
    }
};