最大同构子树

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型
     */

    map<int, vector<TreeNode*>> omap;
    
    int maxSubTree(TreeNode* root) {
        // write code here
        if (root == nullptr) return 0;
        // 
        count(root);
        auto rit = omap.rbegin();
        rit++; // 最大的值当然是root的，root只有一个，不用管它

        while (rit != omap.rend()) {
            vector<TreeNode*> line = rit->second;
            for (int i = 0; i < line.size(); i++) {
                for (int j = i + 1; j < line.size(); j++) {
                    if (cmp(line[i], line[j])) return rit->first;
                }
            }

            rit++;
        }

        return 0;
    }

    // 计算当前节点下的子树有多少个节点
    /* map<int, vector<TreeNode*>> omap;
       具有相同节点数int存放到同一个vector里面
       例如 输入二叉树[1,2,3,4,#,5,#]
       omap根据节点数量排序omap
            
    */
    int count(TreeNode* root) {
        if (root == nullptr) return 0;
        int now = count(root->left) + count(root->right) + 1;

        omap[now].push_back(root);
        return now;
    }

    // 比较两颗数是否为同构的,
    // 默认传入的两棵树具有相同的节点数量
    bool cmp(TreeNode* a, TreeNode* b) {
        // 要是超时了用一下记忆化递归，空间换时间嘛
        if (a == nullptr && b == nullptr) return true;
        else if (a != nullptr && b != nullptr) {
            return cmp(a->left, b->left) && cmp(a->right, b->right);
        }
        else return false;
    }

};

/**
 * struct TreeNode {
 *  int val;
 *  struct TreeNode *left;
 *  struct TreeNode *right;
 *  TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
  public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param root TreeNode类
     * @return int整型
     */

    map<int, vector<TreeNode*>> omap;
    //用例输入{1，2，3，4，#，5,#}
    int maxSubTree(TreeNode* root) {
        // write code here
        if (root == nullptr) return 0;
        count(root);
        auto rit = omap.rbegin();

        cout<<endl<<"omapsize:"<<omap.size()<<endl;// omapsize:3 map具有排序
        cout<<"omap0:"<<rit->first<<endl;         // omap0:5 <5,(1)> <节点数，（头节点）>

        rit++; // 最大的值当然是root的，root只有一个，不用管它
        cout<<"omap1:"<<rit->first<<endl;        // omap1:2  <2,(2 3)>
        rit++; 
        cout<<"omap2:"<<rit->first<<endl;rit--;  // omap2:1  <1,(4 5)>

        while (rit != omap.rend()) {
            vector<TreeNode*> line = rit->second; //line 也就是上面的omap1的vector(2 3)

            cout<<"linesize:"<< line.size()<<endl;//linesize:2 
            cout<<"line0:"<<line[0]->val<<endl;   //line0:2 左子树头节点
            cout<<"line1:"<<line[1]->val<<endl;   //line1:3 右子树头节点

            for (int i = 0; i < line.size(); i++) {
                for (int j = i + 1; j < line.size(); j++) {
                    if (cmp(line[i], line[j])){// 以头节点（2 3）的两棵子树同构
                        return rit->first;
                    } 
                }
            }

            rit++;
        }

        return 0;
    }

    // 计算当前节点下的子树有多少个节点
    int count(TreeNode* root) {
        if (root == nullptr) return 0;
        int now = count(root->left) + count(root->right) + 1;
        omap[now].push_back(root);
        cout<<"now:"<<now;//1 2 1 2 5
        return now;
    }

    // 比较两颗数是否为同构的,
    // 默认传入的两棵树具有相同的节点数量
    bool cmp(TreeNode* a, TreeNode* b) {
        // 要是超时了用一下记忆化递归，空间换时间嘛
        if (a == nullptr && b == nullptr) return true;
        else if (a != nullptr && b != nullptr) {
            return cmp(a->left, b->left) && cmp(a->right, b->right);
        } else return false;
    }
};