Check if DFS Strings Are Palindromes

Check if DFS Strings Are Palindromes - Problem

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

You are given a tree rooted at node 0, consisting of n nodes numbered from 0 to n - 1. The tree is represented by an array parent of size n, where parent[i] is the parent of node i. Since node 0 is the root, parent[0] == -1.

You are also given a string s of length n, where s[i] is the character assigned to node i.

Consider an empty string dfsStr, and define a recursive function dfs(int x) that takes a node x as a parameter and performs the following steps in order:

Iterate over each child y of x in increasing order of their numbers, and call dfs(y).
Add the character s[x] to the end of the string dfsStr.

Note that dfsStr is shared across all recursive calls of dfs.

You need to find a boolean array answer of size n, where for each index i from 0 to n - 1, you do the following:

Empty the string dfsStr and call dfs(i).
If the resulting string dfsStr is a palindrome, then set answer[i] to true. Otherwise, set answer[i] to false.

Return the array answer.

Input & Output

Example 1 — Basic Tree

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

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

💡 Note: Node 0 DFS: visit 3,4,1,2,0 → "abaaa" (not palindrome). Node 1 DFS: visit 3,4,1 → "aba" (palindrome). Nodes 2,3,4 are single characters or produce palindromes.

Example 2 — Mixed Characters

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

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

💡 Note: Node 0 DFS: visit 3,1,2,0 → "dcba" (not palindrome). Node 1 DFS: visit 3,1 → "db" (not palindrome). Nodes 2,3 are single characters (palindromes).

Example 3 — Single Node

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

› Output: [true]

💡 Note: Only root node, DFS produces "a" which is a palindrome.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15

The key insight is that DFS visits children first then adds current node, creating post-order traversal strings. Best approach uses single DFS pass with memoization to compute all subtree strings efficiently. Time: O(n²), Space: O(n²)

Common Approaches

✓ Brute Force DFS

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

Build the tree structure from parent array, then for each node perform DFS traversal to generate the string and check if it's a palindrome. This approach rebuilds the DFS string for every starting node.

Optimized with Precomputed Strings

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

Instead of running separate DFS for each node, we can compute all DFS strings in a single traversal. During post-order DFS, we build the string for each subtree and store it, then check palindromes.

Brute Force DFS — Algorithm Steps

Build adjacency list from parent array
For each node, perform DFS to build string
Check if resulting string is palindrome

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Tree

Convert parent array to adjacency list

DFS Each Node

For each node, perform post-order DFS

Check Palindrome

Verify if DFS string reads same forwards/backwards

Code -

solution.c — C

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

static int children[1000][1000];
static int childCount[1000];
static char s[1000];
static char dfsStr[2000];
static int dfsStrLen;

void dfs(int x) {
    // Visit children first
    for (int i = 0; i < childCount[x]; i++) {
        dfs(children[x][i]);
    }
    // Add current node's character
    dfsStr[dfsStrLen++] = s[x];
}

int isPalindrome(const char* str, int len) {
    for (int i = 0; i < len / 2; i++) {
        if (str[i] != str[len - 1 - i]) {
            return 0;
        }
    }
    return 1;
}

int cmp(const void* a, const void* b) {
    return *(int*)a - *(int*)b;
}

void solution(int* parent, int n, const char* nodeStr, int* answer) {
    strcpy(s, nodeStr);
    
    // Initialize
    for (int i = 0; i < n; i++) {
        childCount[i] = 0;
    }
    
    // Build adjacency list
    for (int i = 0; i < n; i++) {
        if (parent[i] != -1) {
            children[parent[i]][childCount[parent[i]]++] = i;
        }
    }
    
    // Sort children lists
    for (int i = 0; i < n; i++) {
        qsort(children[i], childCount[i], sizeof(int), cmp);
    }
    
    for (int i = 0; i < n; i++) {
        dfsStrLen = 0;
        dfs(i);
        dfsStr[dfsStrLen] = '\0';
        answer[i] = isPalindrome(dfsStr, dfsStrLen);
    }
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newline
    line2[strcspn(line2, "\n")] = 0;
    
    // Parse parent array
    int parent[1000];
    int n = 0;
    char* p = line1;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        if (*p == '-') {
            p++;
            parent[n++] = -(int)strtol(p, &p, 10);
        } else {
            parent[n++] = (int)strtol(p, &p, 10);
        }
    }
    
    int answer[1000];
    solution(parent, n, line2, answer);
    
    printf("[");
    for (int i = 0; i < n; i++) {
        if (i > 0) printf(",");
        printf(answer[i] ? "true" : "false");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we perform DFS which can visit up to n nodes

⚠ Quadratic Growth

Space Complexity

O(n)

Adjacency list storage and recursion stack depth up to n

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~35 min Avg. Time

286 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

Brute Force DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler