Given a binary tree, return all duplicate subtrees. For each kind of duplicate subtrees, you only need to return the root node of any one of them.

Two trees are duplicate if they have the same structure with same node values.

Example 1:

        1
       / \
      2   3
     /   / \
    4   2   4
       /
      4

The following are two duplicate subtrees:

      2
     /
    4

and

    4

Therefore, you need to return above trees' root in the form of a list.

Runtime: 40 ms, faster than 18.69% of C++ online submissions for Find Duplicate Subtrees.

考的是怎麼把樹序列化表示，我的寫法比較繁瑣，執行時間也比較長。

/**
 * 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 {
private:
  unordered_map<string,int> map;
public:
  vector<TreeNode*> findDuplicateSubtrees(TreeNode* root) {
    vector
 
<TreeNode*> ret;
    helper(root, ret);
    //for(auto it : map) cout << it.first << endl;
    return ret;
  }
  string helper(TreeNode* root, vector<TreeNode*> & ret){
    if(!root) return "";
    string rootval = to_string(root->val);
    string tmp = rootval;
    if(!root->left && root->right){
      tmp = rootval + " Null " + helper(root->right, ret);
    }else if(root->left && !root->right){
      tmp = rootval + " " + helper(root->left,ret) + " Null ";
    } else if (root->left && root->right){
      tmp = rootval + " " + helper(root->right,ret) + " " + helper(root->left,ret);
    }
    //if(root->val == 4) cout << tmp << endl;
    if(map.count(tmp)) {
      if(map[tmp] == 1) {
        ret.push_back(root);
        map[tmp]++;
      }
    }else {
      map[tmp] = 1;
    }
    return tmp;
  }
};

下面是寫的比較順的一種。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

// We can serialize each subtree. Perform a depth-first search, where the recursive function returns the serialization of the tree. At each node, record the result in a map, and analyze the map after to determine duplicate subtrees.
class Solution {
public:
    vector<TreeNode*> findDuplicateSubtrees(TreeNode* root) {
        
        //store count of each serialized tree
        unordered_map<string, int>mymap;
        vector<TreeNode*> res;

        DFS(root,mymap,res);
        return res; 
    }
    
    string DFS(TreeNode* root, unordered_map<string, int> &mymap, vector<TreeNode*> &res){
        if(!root){
            return "#";
        }
        
        string s = to_string(root->val) + "," + DFS(root->left, mymap, res) + "," + DFS(root->right, mymap, res);
        if(++mymap[s]==2)
            res.push_back(root);
        return s;       
    }
};

更有人用了bit，驚了。

      long key=((static_cast<long>(node->val))<<32 | helper(node->left, ans)<<16 | helper(node->right, ans));