<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
class Solution:
    def countPairs(self, root: TreeNode, distance: int) -> int:
        # convert to graph
        neighbors = defaultdict(lambda:[])
        leaves = set()

        # adds connection between node and two children. adds to leaves also
        def dfs(node):
            if not node:
                return
            if not node.left and not node.right:
                leaves.add(node)
            if node.left:
                neighbors[node].append(node.left)
                neighbors[node.left].append(node)
            if node.right:
                neighbors[node].append(node.right)
                neighbors[node.right].append(node)
            dfs(node.left)
            dfs(node.right)
        dfs(root)
    
        # dfs each node exactly distance steps. incr answer by 1 each time you find a leaf within that distance

        """
        looks in the graph for any nodes in leaves. only looks distance steps away.
        returns that number
        """
        def searchForPair(node, distance):
            if not node:
                return 0

            numFound = 0
            if node in leaves:
                print(node.val)
                numFound += 1
            
            if distance == 0:
                return numFound
            
            for neighbor in neighbors[node]:
                if neighbor not in visited:
                    visited.add(neighbor)
                    numFound += searchForPair(neighbor, distance - 1)
            return numFound




        result = 0
        for leaf in leaves:
            # visited must be reset each iteration because you can reuse the same path
            visited = set([leaf])
            result += (searchForPair(leaf, distance) - 1) # 1->0. search will always find itself.

        return result // 2

        
        
18700