<p>You are given the <code>root</code> of a binary tree and an integer <code>distance</code>. A pair of two different <strong>leaf</strong> nodes of a binary tree is said to be good if the length of <strong>the shortest path</strong> between them is less than or equal to <code>distance</code>.</p>

<p>Return <em>the number of good leaf node pairs</em> in the tree.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/07/09/e1.jpg" style="width: 250px; height: 250px;" />
<pre>
<strong>Input:</strong> root = [1,2,3,null,4], distance = 3
<strong>Output:</strong> 1
<strong>Explanation:</strong> The leaf nodes of the tree are 3 and 4 and the length of the shortest path between them is 3. This is the only good pair.
</pre>

<p><strong class="example">Example 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/07/09/e2.jpg" style="width: 250px; height: 182px;" />
<pre>
<strong>Input:</strong> root = [1,2,3,4,5,6,7], distance = 3
<strong>Output:</strong> 2
<strong>Explanation:</strong> The good pairs are [4,5] and [6,7] with shortest path = 2. The pair [4,6] is not good because the length of ther shortest path between them is 4.
</pre>

<p><strong class="example">Example 3:</strong></p>

<pre>
<strong>Input:</strong> root = [7,1,4,6,null,5,3,null,null,null,null,null,2], distance = 3
<strong>Output:</strong> 1
<strong>Explanation:</strong> The only good pair is [2,5].
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li>The number of nodes in the <code>tree</code> is in the range <code>[1, 2<sup>10</sup>].</code></li>
	<li><code>1 &lt;= Node.val &lt;= 100</code></li>
	<li><code>1 &lt;= distance &lt;= 10</code></li>
</ul>

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

"""
convert binary tree to undirected graph
bfs - visit from all leaf nodes to leaf nodes
compare path length with distance
"""
from collections import defaultdict, deque
class Solution:
    def countPairs(self, root: TreeNode, distance: int) -> int:
        
        graph = defaultdict(list)
        leaf_nodes = set()
        
        def build_graph(curr_node, prev_node):
            # base case
            if not curr_node:
                return
            if curr_node.left is None and curr_node.right is None:
                leaf_nodes.add(curr_node)
            
            if curr_node and prev_node:
                graph[curr_node].append(prev_node)
                graph[prev_node].append(curr_node)
            
            # recursive calls
            if curr_node.left:
                build_graph(curr_node.left, curr_node)
            
            if curr_node.right:
                build_graph(curr_node.right, curr_node)
        
        # bfs to get shortest path from a leaf node to a leaf node
        def bfs(node):
            nonlocal ans
            queue = deque()
            queue.append((node, 0))
            seen = set()
            seen.add(node)
            while queue:
                curr_node, path = queue.popleft()
                if curr_node != node and curr_node in leaf_nodes and path <= distance:
                    ans += 1
                
                for neighbor in graph[curr_node]:
                    if neighbor not in seen:
                        seen.add(neighbor)
                        queue.append((neighbor, path + 1))
        
        build_graph(root, None)
        ans = 0
        for node in leaf_nodes:
            bfs(node)
        
        return ans // 2
18400