计算从节点到由相同值的节点组成的叶子的对角线路径

在二叉树中，从根节点到叶子节点经过的路径被称为对角线路径。本题的要求是计算从一个特定的节点开始，到由相同值的节点组成的叶子节点的对角线路径。

解题思路

首先，我们需要遍历整棵二叉树并找到所有的叶子节点。然后，对于每个叶子节点进行如下处理：

1. 判断该叶子节点的值是否与起始节点的值相同。
2. 如果相同，将该叶子节点加入到所在层级的节点列表中。
3. 对于每一层级的节点列表，判断其中是否有连续若干个节点的值相同，如果有，则记录下该节点的路径。

最终，我们得到的结果就是所有符合要求的对角线路径。

代码实现

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

class Solution(object):
    def findPath(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        paths = []
        
        def dfs(node, curPath):
            if not node:
                return
            
            curPath.append(node.val)
            
            if not node.left and not node.right:
                # 当前节点为叶子节点
                if node.val == curPath[0]:
                    # 如果叶子节点的值与起始节点的值相同，
                    # 则将该节点加入到所在层级的节点列表中
                    level = len(curPath) - 1
                    if level >= len(paths):
                        paths.append([node.val])
                    else:
                        paths[level].append(node.val)
            
            dfs(node.left, curPath)
            dfs(node.right, curPath)
            # 回溯
            curPath.pop()
        
        dfs(root, [])
        
        res = []
        
        for node_lst in paths:
            i, j = 0, len(node_lst) - 1
            while i < j:
                # 找到连续若干个节点的值相同的路径
                if node_lst[i] != node_lst[j]:
                    break
                i += 1
                j -= 1
            
            if i >= j:
                # 如果存在连续若干个节点的值相同，将该路径加入到结果中
                path = [node_lst[k] for k in range(i)]
                res.append(path)
        
        return res

复杂度分析

• 时间复杂度：$O(n^2)$，其中 $n$ 是二叉树的节点数。对于每个叶子节点，需要扫描所在层级所有节点，时间复杂度为 $O(n)$。一共有 $O(n)$ 个叶子节点，因此总时间复杂度为 $O(n^2)$。
• 空间复杂度：$O(n)$，其中 $n$ 是二叉树的节点数。空间复杂度主要取决于递归栈空间和路径存储空间。递归栈空间为 $O(\log n)$，路径存储空间最多为 $O(n)$。