Check if DFS Strings Are Palindromes - Practice Coding Problems

Check if DFS Strings Are Palindromes - Problem

Array Hash Table String Tree Depth-First Search Hash Function Hard

Tree DFS Palindrome Checker

You're given a tree with n nodes (numbered 0 to n-1) rooted at node 0, represented by a parent array where parent[i] is the parent of node i (with parent[0] = -1 for the root). Each node has a character assigned from string s.

Your task is to perform a special DFS traversal starting from each node and determine if the resulting string is a palindrome.

DFS Rules:
1. Visit children in increasing order of their node numbers
2. After visiting all children, add the current node's character to the result string
3. This creates a post-order traversal pattern

Goal: Return a boolean array where answer[i] is true if the DFS string starting from node i forms a palindrome.

Example: If node 2 has children [4,5] and characters are "abcde", the DFS from node 2 would visit: 4→5→2, creating string based on their characters.

Input & Output

example_1.py — Basic Tree

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

› Output: [true,true,true,true,true]

💡 Note: All nodes have character 'a'. Since DFS from any single node produces string of only 'a' characters, all resulting strings are palindromes. For example, DFS from node 1 visits children 3,4 then node 1, producing "aaa".

example_2.py — Mixed Characters

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

› Output: [true,true,true,true,true]

💡 Note: Even with mixed characters, the tree structure creates palindromic DFS strings. DFS from root (node 0): visits 1→(3,4)→1→2, producing DFS string "aabaa" which is a palindrome.

example_3.py — Non-palindrome Case

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

› Output: [true,false,false]

💡 Note: DFS from node 0: visits 1,2 then 0, producing "bca" (palindrome). DFS from node 1: just "b" (palindrome). DFS from node 2: just "c" (palindrome). Wait, all single chars are palindromes, so this should be [true,true,true]. Let me reconsider... Actually the first should be "bca" which is not a palindrome.

Visualization

Tap to expand

Understanding the Visualization

Build Family Tree

Convert the parent relationships into a tree structure where we can easily find each person's children

Collect Stories

For each family member, visit their descendants first (in age order), then add their own letter to create the complete story

Check Palindromes

Determine if each person's family story reads the same forwards and backwards using efficient hash comparison

Key Takeaway

🎯 Key Insight: Rolling polynomial hash allows us to detect palindromes without building actual strings, making the solution much more efficient in practice while maintaining the same theoretical complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we perform DFS (O(subtree size)) and palindrome check (O(string length)). In worst case, this becomes O(n²)

⚠ Quadratic Growth

Space Complexity

O(n²)

We might store strings of total length O(n²) in worst case, plus recursion stack O(n)

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 10⁵
parent.length == n
parent[0] == -1
0 ≤ parent[i] ≤ n - 1 for i ≠ 0
parent represents a valid tree
s.length == n
s consists of only lowercase English letters

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal solution uses polynomial rolling hash to efficiently check palindromes during DFS traversal. Instead of building actual strings, we compute forward and reverse hashes simultaneously. A subtree forms a palindrome if and only if its forward hash equals its reverse hash. This achieves the same time complexity as the brute force approach but with much better practical performance and lower space usage.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force DFS + Palindrome Check	O(n²)	O(n²)	Build each DFS string explicitly and check if it's a palindrome
Optimized Brute Force with Rolling Hash	O(n²)	O(n)	Use polynomial rolling hash to check palindromes efficiently during DFS

Brute Force DFS + Palindrome Check — Algorithm Steps

Build adjacency list representation of the tree from parent array
For each node i from 0 to n-1, perform DFS starting from that node
During DFS: visit children in increasing order, then add current node's character
Check if the resulting DFS string is a palindrome using two pointers
Store the result in answer array

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Tree

Convert parent array to adjacency list representation

DFS Traversal

For each node, perform post-order DFS to build string

Palindrome Check

Use two pointers to check if DFS string is palindrome

Code -

solution.c — C

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

typedef struct {
    int* children;
    int size;
    int capacity;
} ChildList;

char* dfs(int node, ChildList* children, char* s, int* len) {
    char* result = malloc(1000 * sizeof(char));
    int pos = 0;
    
    // Visit children first
    for (int i = 0; i < children[node].size; i++) {
        int child = children[node].children[i];
        int childLen;
        char* childStr = dfs(child, children, s, &childLen);
        for (int j = 0; j < childLen; j++) {
            result[pos++] = childStr[j];
        }
        free(childStr);
    }
    
    // Then add current node's character
    result[pos++] = s[node];
    result[pos] = '\0';
    *len = pos;
    return result;
}

bool isPalindrome(char* str, int len) {
    int left = 0, right = len - 1;
    while (left < right) {
        if (str[left] != str[right]) {
            return false;
        }
        left++;
        right--;
    }
    return true;
}

bool* checkIfDFSStringsArePalindromes(int* parent, int parentSize, char* s, int* returnSize) {
    int n = parentSize;
    *returnSize = n;
    
    // Build adjacency list
    ChildList* children = malloc(n * sizeof(ChildList));
    for (int i = 0; i < n; i++) {
        children[i].children = malloc(n * sizeof(int));
        children[i].size = 0;
        children[i].capacity = n;
    }
    
    for (int i = 1; i < n; i++) {
        int p = parent[i];
        children[p].children[children[p].size++] = i;
    }
    
    bool* answer = malloc(n * sizeof(bool));
    for (int i = 0; i < n; i++) {
        int len;
        char* dfsString = dfs(i, children, s, &len);
        answer[i] = isPalindrome(dfsString, len);
        free(dfsString);
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(children[i].children);
    }
    free(children);
    
    return answer;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we perform DFS (O(subtree size)) and palindrome check (O(string length)). In worst case, this becomes O(n²)

⚠ Quadratic Growth

Space Complexity

O(n²)

We might store strings of total length O(n²) in worst case, plus recursion stack O(n)

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 10⁵
parent.length == n
parent[0] == -1
0 ≤ parent[i] ≤ n - 1 for i ≠ 0
parent represents a valid tree
s.length == n
s consists of only lowercase English letters

26.1K Views

Medium Frequency

~25 min Avg. Time

847 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 DFS + Palindrome Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler