LeetCode1315: 祖父节点值为偶数的节点和

题目介绍

描述：

给你一棵二叉树，请你返回满足以下条件的所有节点的值之和：

该节点的祖父节点的值为偶数。（一个节点的祖父节点是指该节点的父节点的父节点。）如果不存在祖父节点值为偶数的节点，那么返回 0 。

image.png

输入：root = [6,7,8,2,7,1,3,9,null,1,4,null,null,null,5]
输出：18
解释：图中红色节点的祖父节点的值为偶数，蓝色节点为这些红色节点的祖父节点。

解题思路：

递归算法的关键是要明确函数的「定义」是什么，然后相信这个定义，利用这个定义推导最终结果。

写树相关的算法，简单说就是，先搞清楚当前 root 节点该做什么，然后根据函数定义递归调用子节点，递归调用会让孩子节点做相同的事情。

二叉树题目的一个难点在于如何通过题目的要求思考出每一个节点需要做什么

二叉树解题策略

一递归二队列 + 迭代（层次遍历）三栈 + 迭代（非递归遍历）四其它

三种基本的遍历方式，都可以用递归来实现。写递归算法的时候，需要注意递归退出条件以及递归操作的表达。

自己的解法实现

def sumEvenGrandparent4(self, root):
        if not root and (not root.left or root.right):
            return 0
        stack, res = [root], 0
        while stack:
            node = stack.pop()
            if node.val % 2 == 0:
                if node.left:
                    if node.left.left:
                        res += node.left.left.val
                    if node.left.right:
                        res += node.left.right.val
                if node.right:
                    if node.right.right:
                        res += node.right.right.val
                    if node.right.left:
                        res += node.right.left.val
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
        return res

网上比较优秀的解法

解法一

方法一：深度优先搜索我们可以通过深度优先搜索找出所有满足题目要求的节点。

具体地，在进行搜索时，搜索状态除了当前节点之外，还需要存储该节点的祖父节点和父节点，即三元组 (grandparent, parent, node)。如果节点 grandparent 的值为偶数，那么就将节点 node 的值加入答案。在这之后，我们继续搜索节点 node 的左孩子 (parent, node, node.left) 以及右孩子 (parent, node, node.right)，直到搜索结束。

def sumEvenGrandparent(self, root):
        if not root and (not root.left or root.right):
            return 0
        res = 0
        def dfs(grandparent, parent, node):
            if not node: return
            if grandparent.val % 2 == 0:
                nonlocal res
                res += node.val
            dfs(parent, node, node.left)
            dfs(parent, node, node.right)
        if root.left:
            dfs(root, root.left, root.left.left)
            dfs(root, root.left, root.left.right)
        if root.right:
            dfs(root, root.right, root.right.right)
            dfs(root, root.right, root.right.left)
        return res

解法二

根节点没有父节点，根节点的子节点没有祖父节点，那么搜索状态中的grandparent 和 parent 无法进行表示，因此我们必须从根节点的孙子节点（即子节点的子节点）开始搜索。而我们发现，在搜索状态三元组 (grandparent, parent, node) 中，grandparent 和 parent 这两项我们只使用了它的值，而不使用节点本身，因此我们可以在搜索状态中用值来替换这些节点。

def sumEvenGrandparent2(self, root):
        res = 0
        def dfs(gp_val, p_val, node):
            if not node: return
            if gp_val % 2 == 0:
                nonlocal res
                res += node.val
            dfs(p_val, node.val, node.left)
            dfs(p_val, node.val, node.right)
        dfs(1, 1, root)
        return res

解法三

方法二：广度优先搜索既然要找出祖父节点的值为偶数的节点，我们不如找到所有值为偶数的节点，并对这些节点的孙子节点（即子节点的子节点）统计答案。

这样我们就可以使用广度优先搜索遍历整棵树，当我们找到一个值为偶数的节点时，我们将该节点的所有孙子节点的值加入答案。

def sumEvenGrandparent3(self, root):
        from collections import deque
        queue, res = deque([root]), 0

        while queue:
            node = queue.popleft()
            if node.val %2 == 0:
                if node.left:
                    if node.left.left:
                        res += node.left.left.val
                    if node.left.right:
                        res += node.left.right.val
                if node.right:
                    if node.right.right:
                        res += node.right.right.val
                    if node.right.left:
                        res += node.right.left.val
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)

        return res

解法四

直接二叉树遍历，但是需要在递归过程中传入父节点和祖父节点的值

def sumEvenGrandparent5(self, root):
        self.res = 0
        def recursion(node, level2, level1):
            if node:
                recursion(node.left, level1, node.val)
                recursion(node.right, level1, node.val)

                if level2 % 2 == 0 and level2 != 0:
                    self.res += node.val
        recursion(root, 0, 0)
        return self.res

解法五

nonlocal关键字用来在函数或其他作用域中使用外层(非全局)变量。

def sumEvenGrandparent6(self, root):
        if not root and (not root.left or root.right):
            return 0
        res = 0
        def dfs(node, cur):
            if not node: return
            nonlocal res
            cur.append(node.val)
            if len(cur) >= 3 and cur[-3]%2 == 0:    # 用列表记录当前路径上的点的值
                res += node.val
            dfs(node.left, cur[:])
            dfs(node.right, cur[:])
        dfs(root, [])
        return res