1530 好叶子节点对的数量

题目描述：
给你二叉树的根节点 root 和一个整数 distance 。
如果二叉树中两个 叶 节点之间的 最短路径长度 小于或者等于 distance ，那它们就可以构成一组 好叶子节点对 。
返回树中 好叶子节点对的数量 。

示例 1：

输入：root = [1,2,3,null,4], distance = 3
输出：1
解释：树的叶节点是 3 和 4 ，它们之间的最短路径的长度是 3 。这是唯一的好叶子节点对。

示例 2：

输入：root = [1,2,3,4,5,6,7], distance = 3
输出：2
解释：好叶子节点对为 [4,5] 和 [6,7] ，最短路径长度都是 2 。但是叶子节点对 [4,6] 不满足要求，因为它们之间的最短路径长度为 4 。

示例 3：
输入：root = [7,1,4,6,null,5,3,null,null,null,null,null,2], distance = 3
输出：1
解释：唯一的好叶子节点对是 [2,5] 。

示例 4：
输入：root = [100], distance = 1
输出：0

示例 5：
输入：root = [1,1,1], distance = 2
输出：1

提示：
tree 的节点数在 [1, 2^10] 范围内。
每个节点的值都在 [1, 100] 之间。
1 <= distance <= 10

方法1：
主要思路：解题链接汇总
（1）使用后序遍历，找出左右子树中，各个叶子结点到当前子树根节点距离，判断两个子树中的叶子结点是否是好结点；
（2）为了减少判断子树中叶子结点是否是好结点对，可以使用multiset来对距离进行排序；

/**
 * 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:
    multiset<int> post_order(TreeNode*root,int&res,int distance){
        if(root==nullptr){
            return {};
        }
        if(root->left==nullptr&&root->right==nullptr){
            return {1};
        }
        multiset<int>left_set=post_order(root->left,res,distance);
        multiset<int>right_set=post_order(root->right,res,distance);
        for(const int&i:left_set){
            if(i>=distance){
                break;
            }
            int target=distance-i;
            for(const int&j:right_set){
                if(j>target){
                    break;
                }
                ++res;
            }
        }
        multiset<int> cur;
        for(const int&i:left_set){
            if(i+1<distance){
                cur.insert(i+1);
            }
        }
        for(const int&i:right_set){
            if(i+1<distance){
                cur.insert(i+1);
            }
        }
        return cur;
    }
    int countPairs(TreeNode* root, int distance) {
        int res=0;
        post_order(root,res,distance);
        return res;
    }
};

方法2：
主要思路：
（1）主要思路和方法1类型，只是使用数组直接存储各个叶子结点到当前结点的距离，不再进行距离的排序；
（2）但可能是由于数据量小，反而更快；

/**
 * 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:
    vector<int> post_order(TreeNode*root,int&res,int distance){
        if(root==nullptr){
            return {};
        }
        if(root->left==nullptr&&root->right==nullptr){
            return {1};
        }
        vector<int>left_set=post_order(root->left,res,distance);
        vector<int>right_set=post_order(root->right,res,distance);
        for(const int&i:left_set){
            int target=distance-i;
            for(const int&j:right_set){
                if(j<=target){
                    ++res;
                }
            }
        }
        vector<int> cur;
        for(const int&i:left_set){
            if(i+1<distance){
                cur.push_back(i+1);
            }
        }
        for(const int&i:right_set){
            if(i+1<distance){
                cur.push_back(i+1);
            }
        }
        return cur;
    }
    int countPairs(TreeNode* root, int distance) {
        int res=0;
        post_order(root,res,distance);
        return res;
    }
};

标签：distance,right,TreeNode,int,叶子,1530,root,节点,left
来源： https://blog.csdn.net/weixin_44171872/article/details/113814894