Longest Path With Different Adjacent Characters

Longest Path With Different Adjacent Characters - Problem

Array String Tree Depth-First Search Graph Topological Sort Hard

You are given a tree (a connected, undirected graph with no cycles) rooted at node 0, consisting of n nodes numbered from 0 to n - 1. The tree structure is represented by a 0-indexed array parent of size n, where parent[i] is the parent of node i. Since node 0 is the root, parent[0] == -1.

Additionally, you have a string s of length n, where s[i] represents the character assigned to node i.

Your goal: Find the longest path in the tree such that no two adjacent nodes on the path have the same character. The path can start and end at any nodes in the tree.

Note: A path is a sequence of nodes where each adjacent pair is connected by an edge. The length of a path is the number of nodes in it.

Input & Output

example_1.py — Basic Tree

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

› Output: 3

💡 Note: The longest valid path is 2→0→3 with characters "aca". Nodes 2 and 0 have different characters ('a' and 'b'), and nodes 0 and 3 have different characters ('b' and 'c').

example_2.py — All Same Characters

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

› Output: 1

💡 Note: All nodes have the same character 'a', so no two adjacent nodes can have different characters. The longest valid path contains only one node.

example_3.py — Linear Tree

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

› Output: 4

💡 Note: This forms a linear tree 0→1→2→3 with characters "abcd". All adjacent nodes have different characters, so the entire path is valid with length 4.

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

Visualization

Tap to expand

Understanding the Visualization

Identify Tree Structure

Convert the parent array into a tree with proper parent-child relationships

DFS Traversal

Start from root and visit children first (post-order traversal)

Combine Child Paths

At each node, find the two longest valid paths from children with different characters

Update Maximum

The longest path through current node is the sum of the two longest child paths plus 1

Key Takeaway

🎯 Key Insight: The longest path in a tree can be found by considering each node as a potential 'bridge' connecting two longest downward paths, using DFS to avoid redundant computations.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 25

The optimal approach uses DFS tree traversal to solve this problem in O(n) time. The key insight is that the longest path in a tree either passes through a node (combining the two longest downward paths from that node) or lies entirely within a subtree. By processing children first and combining the two longest valid child paths at each node, we can find the answer in a single traversal.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Paths)	O(n³)	O(n)	Try starting from every node and explore all possible paths
DFS Tree Traversal (Optimal)	O(n)	O(n)	Single DFS pass computing longest paths through each node

Brute Force (Try All Paths) — Algorithm Steps

Build adjacency list representation of the tree
For each node as starting point, run DFS
In DFS, explore all neighbors with different characters
Keep track of maximum path length found
Use backtracking to explore all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Starting Node

Pick any node as the starting point for path exploration

Explore All Neighbors

From current node, visit all neighbors with different characters

Continue Recursively

Repeat the process for each valid neighbor, tracking path length

Backtrack and Try Next

Return and try other possible paths from the same starting node

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int dfs(int** graph, int* graph_sizes, char* s, int node, int prev, int pathLength) {
    int maxLength = pathLength;
    
    for (int i = 0; i < graph_sizes[node]; i++) {
        int neighbor = graph[node][i];
        if (neighbor != prev && s[neighbor] != s[node]) {
            maxLength = max(maxLength, dfs(graph, graph_sizes, s, neighbor, node, pathLength + 1));
        }
    }
    
    return maxLength;
}

int longestPath(int* parent, int parentSize, char* s) {
    int n = parentSize;
    
    // Build adjacency list
    int** graph = (int**)malloc(n * sizeof(int*));
    int* graph_sizes = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < n; i++) {
        graph[i] = (int*)malloc(n * sizeof(int));
    }
    
    for (int i = 1; i < n; i++) {
        graph[parent[i]][graph_sizes[parent[i]]++] = i;
        graph[i][graph_sizes[i]++] = parent[i];
    }
    
    int result = 1;
    for (int i = 0; i < n; i++) {
        result = max(result, dfs(graph, graph_sizes, s, i, -1, 1));
    }
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(graph[i]);
    }
    free(graph);
    free(graph_sizes);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of n nodes, we might explore all possible paths, which in worst case can be O(n²) per starting node

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and visited array

⚡ Linearithmic Space

52.0K Views

Medium-High Frequency

~25 min Avg. Time

1.4K 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 (Try All Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler