Pseudo-Palindromic Paths in a Binary Tree

Pseudo-Palindromic Paths in a Binary Tree - Problem

Imagine exploring every path from the root to a leaf in a binary tree, collecting digits along the way. Your mission is to count how many of these paths could be rearranged to form a palindrome!

Given a binary tree where each node contains a digit from 1 to 9, a path is considered pseudo-palindromic if we can rearrange the digits in that root-to-leaf path to create a palindrome.

Key insight: A sequence can form a palindrome if at most one digit appears an odd number of times (that digit would go in the middle).

Goal: Return the total count of pseudo-palindromic paths from root to leaf.

Input & Output

example_1.py — Basic Tree

$ Input: root = [2,3,1,3,1,null,1]

› Output: 2

💡 Note: Tree has 3 root-to-leaf paths: [2,3,3], [2,3,1], [2,1,1]. Paths [2,3,3] can form palindrome '323', and [2,1,1] can form '121'. Path [2,3,1] cannot form any palindrome arrangement.

example_2.py — All Valid Paths

$ Input: root = [2,1,1,1,3,null,null,null,null,null,1]

› Output: 1

💡 Note: Only one root-to-leaf path [2,1,1,1] exists. This can form palindrome '1211' → rearranged as '1121', so count is 1.

example_3.py — Single Node

$ Input: root = [9]

› Output: 1

💡 Note: Single node tree has one path [9], which is trivially a palindrome since single characters are palindromes.

Constraints

The number of nodes in the tree is in the range [1, 10⁵]
1 ≤ Node.val ≤ 9
Each path from root to leaf must be checked for palindrome possibility

Visualization

Tap to expand

Understanding the Visualization

The Magic Rule

A palindrome can have AT MOST one character appearing an odd number of times (it goes in the middle)

XOR Tracking

Use XOR bits to track parity - each digit toggles its bit when encountered

Power of 2 Check

At each leaf, check if bitmask is 0 or has exactly 1 bit set (power of 2)

Count Valid Paths

Sum up all paths that satisfy the palindrome formation condition

Key Takeaway

🎯 Key Insight: Use XOR bitmask to track digit parity - a path can form palindrome if at most 1 digit has odd frequency, elegantly checked with bit manipulation!

Asked in

G Google 28 a Amazon 22 f Meta 15 ⊞ Microsoft 12

The optimal approach uses bit manipulation with XOR during DFS traversal. Each bit represents the parity of digits 1-9, and XOR naturally toggles parity as we traverse. A path is pseudo-palindromic if the final bitmask has at most 1 bit set (checked using mask & (mask-1) == 0). This achieves O(n) time and O(h) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Bit Manipulation (Optimal)	O(n)	O(h)	Use XOR bitmask to efficiently track digit parity during DFS traversal

DFS with Bit Manipulation (Optimal) — Algorithm Steps

Use integer bitmask where bit i represents parity of digit i+1
During DFS, XOR current digit's bit into the mask
At leaf nodes, check if mask has ≤ 1 bit set (power of 2 or 0)
XOR same bit when backtracking (XOR is self-inverse)
Count all valid pseudo-palindromic paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize mask = 0

Start with all bits unset (even counts)

XOR toggle bits

Each digit flips its corresponding bit (tracks odd/even)

Check palindrome

At leaf: mask == 0 or has exactly 1 bit set

Auto backtrack

XOR is self-inverse, no manual cleanup needed!

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

int dfs(struct TreeNode* node, int mask) {
    if (!node) return 0;
    
    // Toggle bit for current digit (XOR)
    mask ^= (1 << node->val);
    
    int result = 0;
    if (!node->left && !node->right) {
        // Check if at most 1 bit is set (palindrome condition)
        if (mask == 0 || (mask & (mask - 1)) == 0) {
            result = 1;
        }
    } else {
        // Continue DFS - mask automatically backtracks due to XOR
        result = dfs(node->left, mask) + dfs(node->right, mask);
    }
    
    return result;
}

int pseudoPalindromicPaths(struct TreeNode* root) {
    return dfs(root, 0);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node once with O(1) bit operations

✓ Linear Growth

Space Complexity

O(h)

Only recursion stack space, no additional data structures

✓ Linear Space

67.2K Views

Medium Frequency

~18 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

DFS with Bit Manipulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler