二叉树中排列为回文的根到叶路径的计数

在二叉树中，如果从根节点到叶子节点的路径上经过的节点值可以组成一个回文序列，那么这条路径就是一个满足条件的路径。本文将介绍如何计算二叉树中排列为回文的根到叶路径的数量。

方法一：递归

我们可以采用递归的方式，从根节点开始遍历树。遍历过程中，我们维护一个哈希表，记录每一个节点出现的次数。当遍历到叶子节点时，我们判断当前路径是否满足条件，如果满足条件，将计数器加一。最后返回计数器即可。

下面是 Python 代码：

class Solution:
    def pseudoPalindromicPaths(self, root: TreeNode) -> int:
        self.res = 0
        self.count = collections.defaultdict(int)
        self.dfs(root)
        return self.res
    
    def dfs(self, node):
        if not node:
            return
        self.count[node.val] += 1
        if not node.left and not node.right:
            # 判断是否满足条件
            odd_count = 0
            for val in self.count.values():
                if val % 2 != 0:
                    odd_count += 1
                    if odd_count > 1:
                        break
            if odd_count <= 1:
                self.res += 1
        else:
            self.dfs(node.left)
            self.dfs(node.right)
        self.count[node.val] -= 1

方法二：位运算

我们可以考虑使用二进制表示节点的出现次数。假设当前节点的值为 x，那么它的二进制表示的第 x 位为 1。（比如，节点值为 3，那么它的二进制表示为 0010。）

当我们遍历到一个叶子节点时，我们判断当前路径是否满足条件。我们可以使用位运算来判断回文序列的性质：如果一个二进制数如果满足“只有 0 或 1 个 1 的位数最多有 1 个”，那么它就是一个回文序列。

下面是 Java 代码：

class Solution {
    private int res = 0;

    public int pseudoPalindromicPaths (TreeNode root) {
        if (root == null) {
            return 0;
        }
        dfs(root, 0);
        return res;
    }

    private void dfs(TreeNode node, int path) {
        path ^= 1 << node.val;
        if (node.left == null && node.right == null) {
            if ((path & (path - 1)) == 0) {
                res++;
            }
        } else {
            if (node.left != null) {
                dfs(node.left, path);
            }
            if (node.right != null) {
                dfs(node.right, path);
            }
        }
    }
}

总结

本文介绍了两种计算二叉树中排列为回文的根到叶路径数量的方法，一种是递归，一种是位运算。这两种方法的时间复杂度都为 O(NlogN)，其中 N 是节点个数。在实际编码中，可以根据具体情况选择使用哪种方法。