[英雄星球七月集训LeetCode解题日报] 第15日 二叉树

日报

题目

一、 2331. 计算布尔二叉树的值

链接: 2331. 计算布尔二叉树的值

1. 题目描述

2. 思路分析

直接递归模拟

3. 代码实现

class Solution:
    def evaluateTree(self, root: Optional[TreeNode]) -> bool:
        def dfs(root):
            if root.val < 2:
                return root.val 
            if root.val == 2:
                return self.evaluateTree(root.left) or self.evaluateTree(root.right)
            else:
                return self.evaluateTree(root.left) and self.evaluateTree(root.right)
        return [False,True][dfs(root)]

二、 1992. 找到所有的农场组

链接: 1992. 找到所有的农场组

1. 题目描述

2. 思路分析

找到左上角之后找右下角。

3. 代码实现

class Solution:
    def findFarmland(self, land: List[List[int]]) -> List[List[int]]:
        ans = []
        m,n = len(land),len(land[0])
        def is_left_up(i,j):
            return land[i][j] == 1 and (i==0 or land[i-1][j] == 0) and (j==0 or land[i][j-1]==0)
        for i in range(m):
            for j in range(n):
                if is_left_up(i,j):
                    x = i 
                    while x<m and land[x][j]==1:
                        x += 1
                    y = j 
                    while y<n and land[i][y]==1:
                        y += 1
                    ans.append([i,j,x-1,y-1])
        return ans

三、 951. 翻转等价二叉树

链接: 951. 翻转等价二叉树

1. 题目描述

2. 思路分析

• 标题有点模糊，实际是判断这个二叉树经过翻转后是否等价。
• 那么等价的概念其实是，根 = 根且（左=左且右=右 或 左=右且右=左）。
• 递归即可。

3. 代码实现

class Solution:
    def flipEquiv(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> bool:
        if not root1 and not root2:
            return True
        if root1 and not root2:
            return False
        if not root1 and root2:
            return False 
        if root1.val != root2.val:
            return False  

        return (self.flipEquiv(root1.left,root2.left) and self.flipEquiv(root1.right,root2.right)) or (self.flipEquiv(root1.left,root2.right) and self.flipEquiv(root1.right,root2.left))

四、 652. 寻找重复的子树

链接: 652. 寻找重复的子树

1. 题目描述

2. 思路分析

只能想到序列化做法于是看了题解。

• 官解二的做法是把序列化的字符串映射成自增序号，然后对自增序号进行count，复杂度从N²变成N。
• 解释一下，因为dfs返回的是个数字，因此key的长度永远都很低，拼接字符串的消耗可以看做是O(1)。那么只有遍历n个节点的开销了。
• 朴素序列化由于永远要带上一整串字符串，最坏的字符串长度是N，因此是N²。

3. 代码实现

class Solution:
    def findDuplicateSubtrees(self, root: Optional[TreeNode]) -> List[Optional[TreeNode]]:
        trees = defaultdict()
        trees.default_factory = trees.__len__
        cnt = Counter()
        ans = []
        def dfs(node):
            if not node :
                return 
            uid = trees[node.val,dfs(node.left),dfs(node.right)]
            cnt[uid] += 1
            if cnt[uid] == 2:
                ans.append(node)
            return uid 
        dfs(root)
        return ans