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.

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

Visualization

Tap to expand

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

✓ Brute Force (Check All Pairs)

⏱️ Time: O(n³) Space: O(n)

For each pair of nodes (u,v), find the path between them, collect all characters on edges, and check if they can form a palindrome by counting character frequencies.

DFS + Bitmask + HashMap (Optimal)

⏱️ Time: O(n·26) Space: O(n)

Traverse the tree once using DFS. For each node, maintain a bitmask representing which characters appear an odd number of times on the path from root. Use a HashMap to count paths that can combine to form palindromes.

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;

// Forward declarations
bool findPath(int start, int end, Edge** adj, bool* visited, char* path, int* pathLen);
bool canFormPalindrome(char* chars, int len);

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}; // Fresh visited array for each pair
            
            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;
}

int main() {
    char parentLine[10000], s[10000];
    fgets(parentLine, sizeof(parentLine), stdin);
    fgets(s, sizeof(s), stdin);
    
    // Remove newline
    parentLine[strcspn(parentLine, "\n")] = 0;
    s[strcspn(s, "\n")] = 0;
    
    // Parse parent array
    int parent[1000];
    int n = 0;
    char* token = strtok(parentLine, ",");
    while (token != NULL) {
        parent[n++] = atoi(token);
        token = strtok(NULL, ",");
    }
    
    int result = countPalindromePaths(parent, n, s);
    printf("%d\n", result);
    
    return 0;
}

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

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

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler