Count Paths That Can Form a Palindrome in a Tree

Count Paths That Can Form a Palindrome in a Tree - Problem

Imagine you have a tree network where each connection (edge) is labeled with a character. Your mission is to find all pairs of nodes where the path between them contains characters that can be rearranged to form a palindrome!

You're given:

A tree with n nodes (numbered 0 to n-1) rooted at node 0
An array parent where parent[i] is the parent of node i
A string s where s[i] is the character on the edge between node i and its parent

Goal: Count all pairs (u, v) where u < v and the characters on the path from u to v can be rearranged to form a palindrome.

Key Insight: A string can form a palindrome if and only if at most one character appears an odd number of times!

Input & Output

example_1.py — Basic Tree

$ Input: parent = [-1,0,0,1,1,2], s = "abaaab"

› Output: 10

💡 Note: Tree has edges with characters a,b,a,a,b. Pairs like (0,1) have path 'a' which can form palindrome. Multiple valid pairs exist where characters can be rearranged to form palindromes.

example_2.py — Simple Chain

$ Input: parent = [-1,0,1], s = "aba"

› Output: 3

💡 Note: Tree: 0-a-1-b-2. Valid pairs: (0,1) path='a', (1,2) path='b', (0,2) path='ab'. All can form palindromes since single chars and pairs with different chars work.

example_3.py — No Valid Pairs

$ Input: parent = [-1,0,1], s = "abc"

› Output: 2

💡 Note: Tree: 0-a-1-b-2. Pairs (0,1) has path 'a', (1,2) has path 'b' - both single characters can form palindromes. Pair (0,2) has path 'ab' with 2 different odd characters, so cannot form palindrome.

Visualization

Tap to expand

Understanding the Visualization

Build Network Map

Convert parent array into adjacency list representing the tree structure

Start Journey

Begin DFS from root with bitmask=0, tracking character frequency parity

Check Compatibility

At each node, count paths that can combine with current path to form palindrome

Update Registry

Add current path's bitmask to hashmap for future compatibility checks

Continue Exploration

Recurse to children with updated bitmasks representing new character patterns

Key Takeaway

🎯 Key Insight: Using bitmasks to represent character frequency parity allows us to detect palindrome compatibility in O(1) time using XOR operations, making the overall solution optimal at O(n×26).

Time & Space Complexity

Time Complexity

⏱️

O(n·26)

O(n) for DFS traversal × O(26) for checking each possible single-bit difference

✓ Linear Growth

Space Complexity

O(n)

HashMap storing at most n different bitmask states during traversal

⚡ Linearithmic Space

Constraints

n == parent.length == s.length
1 ≤ n ≤ 10⁵
0 ≤ parent[i] ≤ n - 1 for all i ≥ 1
parent[0] == -1
parent represents a valid tree
s consists of only lowercase English letters
s[0] can be any character since it's ignored

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses DFS traversal with bitmask to represent character frequency parity. Each bit in the mask indicates if a character appears an odd number of times. Two paths can combine to form a palindrome if their masks are identical (all even counts) or differ by exactly one bit (one character with odd total count). This achieves O(n×26) time complexity with a single tree traversal.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Pairs)	O(n³)	O(n)	Check every pair of nodes and validate if path characters can form palindrome
DFS + Bitmask + HashMap (Optimal)	O(n·26)	O(n)	Use DFS with bitmask to represent character parity and count compatible paths efficiently

Brute Force (Check All Pairs) — Algorithm Steps

Build adjacency list representation of tree from parent array
For each pair (u,v) where u < v:
Find path from u to v using DFS or BFS
Collect all edge characters on the path
Count frequency of each character
Check if at most one character has odd frequency
Increment result counter if palindrome is possible

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Pair

Choose nodes u and v where u < v

Find Path

Traverse from u to v collecting edge characters

Check Palindrome

Count character frequencies to validate palindrome possibility

Code -

solution.c — C

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

typedef struct Edge {
    int to;
    char c;
    struct Edge* next;
} Edge;

int countPalindromePaths(int* parent, int parentSize, char* s) {
    int n = parentSize;
    Edge** adj = (Edge**)calloc(n, sizeof(Edge*));
    
    // Build adjacency list
    for (int i = 1; i < n; i++) {
        Edge* e1 = (Edge*)malloc(sizeof(Edge));
        e1->to = i; e1->c = s[i]; e1->next = adj[parent[i]];
        adj[parent[i]] = e1;
        
        Edge* e2 = (Edge*)malloc(sizeof(Edge));
        e2->to = parent[i]; e2->c = s[i]; e2->next = adj[i];
        adj[i] = e2;
    }
    
    int result = 0;
    for (int u = 0; u < n; u++) {
        for (int v = u + 1; v < n; v++) {
            char path[1000];
            int pathLen = 0;
            bool visited[1000] = {false};
            
            if (findPath(u, v, adj, visited, path, &pathLen)) {
                if (canFormPalindrome(path, pathLen)) {
                    result++;
                }
            }
        }
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        Edge* curr = adj[i];
        while (curr) {
            Edge* temp = curr;
            curr = curr->next;
            free(temp);
        }
    }
    free(adj);
    
    return result;
}

bool findPath(int start, int end, Edge** adj, bool* visited, char* path, int* pathLen) {
    if (start == end) return true;
    visited[start] = true;
    
    for (Edge* e = adj[start]; e; e = e->next) {
        if (!visited[e->to]) {
            path[(*pathLen)++] = e->c;
            if (findPath(e->to, end, adj, visited, path, pathLen)) {
                return true;
            }
            (*pathLen)--;
        }
    }
    return false;
}

bool canFormPalindrome(char* chars, int len) {
    int freq[26] = {0};
    for (int i = 0; i < len; i++) {
        freq[chars[i] - 'a']++;
    }
    int oddCount = 0;
    for (int i = 0; i < 26; i++) {
        if (freq[i] % 2 == 1) oddCount++;
    }
    return oddCount <= 1;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) pairs × O(n) to find path and check palindrome for each pair

⚠ Quadratic Growth

Space Complexity

O(n)

Space for adjacency list and path storage during traversal

⚡ Linearithmic Space

Constraints

n == parent.length == s.length
1 ≤ n ≤ 10⁵
0 ≤ parent[i] ≤ n - 1 for all i ≥ 1
parent[0] == -1
parent represents a valid tree
s consists of only lowercase English letters
s[0] can be any character since it's ignored

34.3K Views

Medium-High Frequency

~25 min Avg. Time

1.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler