leetcode 5474——好叶子节点对的数量

题目链接：https://leetcode-cn.com/problems/number-of-good-leaf-nodes-pairs/

思路：

做题时，想的是记录每个点的父节点来回溯找到每个节点的第一个公共祖先，这样的时间复杂度是O(n^2)，太大了。

可以考虑以空间换时间的方式，针对每个叶子结点记录一条路径。找两个结点的最低公共祖先，每两个的时间复杂度为O(n)

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    // int dp[100];
    // vector<TreeNode*>vec;
    TreeNode* pre=nullptr;
    vector<pair<TreeNode*,vector<TreeNode*>>>node_route;
    // unordered_map<TreeNode*,TreeNode*>father_mapp;
    void DFS(TreeNode* root,vector<TreeNode*>trace)
    {
        if(root==nullptr)return;
        trace.push_back(root);
        if(root->left==nullptr&&root->right==nullptr)
        {
            node_route.push_back(make_pair(root,trace));
        }
        
        DFS(root->left,trace);
        DFS(root->right,trace);
    }
    int countPairs(TreeNode* root, int distance) {
        vector<TreeNode*>trace;
        int result=0;
        DFS(root,trace);
        int len_que=node_route.size();
       
        for(int i=0;i<len_que-1;i++)
        {
            for(int j=i+1;j<len_que;j++)
            {
               int route1=0;
               int route2=0;
               int k=0;
               while(node_route[i].second[k]==node_route[j].second[k])
               {
                   k++;
                   if(k==node_route[i].second.size()-1||k==node_route[j].second.size()-1)
                   {
                       break;
                   }
               }
               if(node_route[i].second.size()-k+node_route[j].second.size()-k<=distance)
               {
                   result++;
               }
            }
        }     
        return result;
    }
};