回溯_or_位运算_二叉树中的伪回文路径

题目描述

思路

解法一： 回溯

• 用一个字典统计遍历到的节点的值{key为node.val: value为node.val出现的次数}，遍历到叶节点之后，判断字典中奇数value出现的次数，若小于等于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 pseudoPalindromicPaths (self, root: TreeNode) -> int:
        def dfs(root, data_dict):
            if root:
                if root.val in data_dict:
                    data_dict[root.val] += 1
                else:
                    data_dict[root.val] = 1
                
                mid = 0
                if not root.left and not root.right:
                    # print(data_dict)
                    for v in data_dict.values():
                        if v%2:
                            mid += 1
                    if mid <= 1:
                        self.cnt += 1
                
                if root.left:
                    dfs(root.left, data_dict)
                    data_dict[root.left.val] -= 1  # 回溯
                if root.right:
                    dfs(root.right, data_dict)
                    data_dict[root.right.val] -= 1  # 回溯
        
        self.cnt = 0
        data_dict = {}
        dfs(root, data_dict)
        return self.cnt

• Time: O(n)
• Space: O(n) + O(n) – 递归占用的内存栈

解法二：位运算

• n & (n - 1) 可以用来消除最后一个1
• 回文串只会有两种情况 要么 1221 要么 121 所以异或后，要么是0 要么是个数为奇数的数字。
• 1<<root.val 是把 root.val 变为 $2^{root.val}$，$2^{root.val}$ 和 $2^{root.val}-1$ 的异或结果为0，这么做是为了解决上述121的情况。
• dfs中 参数n的作用域只在当前函数内，不会在递归时传到下一层，只是把值传到下一层。这样就无需回溯了，因为右分支right递归时，还是之前作用域的值。

class Solution:
    def pseudoPalindromicPaths (self, root: TreeNode) -> int:
        def dfs(root, temp):
            # 参数n的作用域只在当前函数内，不会在递归时传到下一层，只是把值传到下一层
            n = temp ^ (1<<root.val)  # 这样就无需回溯了，因为right递归时，还是之前作用域的值
            if not root.left and not root.right:
                if not n or not n & (n-1):
                    self.cnt += 1
            if root.left:
                dfs(root.left, n)
            if root.right:
                dfs(root.right, n)

        self.cnt = 0
        dfs(root, 0)
        return self.cnt

• Time: O(n)
• Space: O(1) + O(n) – 递归占用的内存栈