Leetcode 687. 最长同值路径

1.题目描述

给定一个二叉树的 root ，返回 最长的路径的长度 ，这个路径中的 每个节点具有相同值 。 这条路径可以经过也可以不经过根节点。

两个节点之间的路径长度 由它们之间的边数表示。

输入：root = [5,4,5,1,1,5]
输出：2

输入：root = [1,4,5,4,4,5]
输出：2

提示:

• 树的节点数的范围是 [0, 10^4]
• -1000 <= Node.val <= 1000
• 树的深度将不超过 1000

2.思路分析

2.1 深度优先搜索

  将二叉树看成一个有向图(从父结点指向子结点的边)，定义同值有向路径为从某一结点出发，到达它的某一后代节点的路径，且经过的结点的值相同。

最长同值路径长度必定为某一节点的左最长同值有向路径长度与右最长同值有向路径长度之和

• 对根结点进行深度优先搜索，对于当前搜索的结点root，分别获取它左结点的最长同值有向路径长度 left，右结点的最长同值
  有向路径长度 right。

• 如果结点 root 的左结点非空且结点 root 的值与它的左结点的值相等，那么结点 root 的左最长同值有向路径长度 left1=left+1，否则 left1=0

• 如果结点 root 的右结点非空且结点 root 的值与它的右结点的值相等，那么结点 root 的右最长同值有向路径长度 right1= right+1，否则 right1=0

• 返回结点root 对应的最长同值有向路径长度max(left1 ,right1)。

3.代码实现

3.1 深度优先搜索

# 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 longestUnivaluePath(self, root: Optional[TreeNode]) -> int:
    # 写法1
        # 定义记录结果的变量result
        result = 0

        # 1.递归函数的参数以及返回值
        def traversal(root: Optional[TreeNode]) -> int:
            # 2.终止条件
            if not root:
                return 0
            # 3.单层搜索逻辑
            left = traversal(root.left)
            right = traversal(root.right)
            left1 = left + 1 if root.left and root.left.val == root.val else 0
            right1 = right + 1 if root.right and root.right.val == root.val else 0
            nonlocal result
            result = max(result, left1 + right1)
            return max(left1, right1)
        traversal(root)
        return result
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 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 longestUnivaluePath(self, root: Optional[TreeNode]) -> int:
    # 写法2
        # 定义记录结果的变量result
        result = 0

        # 1.递归函数的参数以及返回值
        def traversal(root: Optional[TreeNode], val: int) -> int:
            nonlocal result
            # 2.终止条件
            if not root:
                return 0
            # 3.单层搜索逻辑
            left = traversal(root.left, root.val)
            right = traversal(root.right, root.val)
            result = max(result, left + right)
            
            if root.val == val:
                return max(left, right) + 1
            else:
                return 0

        if not root:
            return 0
        traversal(root, root.val)
        return result
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

复杂度分析

• 时间复杂度：O(n)，其中 n 为树的结点数目。
• 空间复杂度：O(n)。递归栈最坏情况下需要 O(n)的空间。