Example 2:

Input:
parent = [-1,0,0,0], s = "aabc"
Output:
 3
Explanation: The longest path where each two adjacent nodes have different characters is the path: 2 -> 0 -> 3. The length of this path is 3, so 3 is returned.

Solution

Method 1 – DFS with Two Longest Paths Tracking

Intuition

The longest path in a tree with the constraint that adjacent nodes have different characters can be found by DFS. For each node, we track the two longest child paths that can be extended (i.e., child character differs from parent). The answer is the maximum sum of two such paths plus one (for the current node).

Approach

Build the tree as an adjacency list from the parent array.
Define a DFS function that returns the longest path starting from a node.
For each node, recursively compute the longest child paths where the child character differs from the current node.
Track the two longest such child paths for each node.
Update the global answer as the sum of the two longest child paths plus one.
Return the longest path found.

Code

[{"language":"Java","code":"class Solution {\n    int ans = 1;\n    public int longestPath(int[] parent, String s) {\n        int n = parent.length;\n        List<Integer>[] tree = new List[n];\n        for (int i = 0; i < n; i++) tree[i] = new ArrayList<>();\n        for (int i = 1; i < n; i++) tree[parent[i]].add(i);\n        dfs(0, tree, s);\n        return ans;\n    }\n    private int dfs(int u, List<Integer>[] tree, String s) {\n        int max1 = 0, max2 = 0;\n        for (int v : tree[u]) {\n            int len = dfs(v, tree, s);\n            if (s.charAt(u) != s.charAt(v)) {\n                if (len > max1) {\n                    max2 = max1;\n                    max1 = len;\n                } else if (len > max2) {\n                    max2 = len;\n                }\n            }\n        }\n        ans = Math.max(ans, max1 + max2 + 1);\n        return max1 + 1;\n    }\n}","lang":"java"},{"language":"C++","code":"class Solution {\npublic:\n    int ans = 1;\n    int longestPath(vector<int>& parent, string s) {\n        int n = parent.size();\n        vector<vector<int>> tree(n);\n        for (int i = 1; i < n; ++i) tree[parent[i]].push_back(i);\n        dfs(0, tree, s);\n        return ans;\n    }\n    int dfs(int u, vector<vector<int>>& tree, string& s) {\n        int max1 = 0, max2 = 0;\n        for (int v : tree[u]) {\n            int len = dfs(v, tree, s);\n            if (s[u] != s[v]) {\n                if (len > max1) {\n                    max2 = max1;\n                    max1 = len;\n                } else if (len > max2) {\n                    max2 = len;\n                }\n            }\n        }\n        ans = max(ans, max1 + max2 + 1);\n        return max1 + 1;\n    }\n};","lang":"cpp"},{"language":"Go","code":"func longestPath(parent []int, s string) int {\n    n := len(parent)\n    tree := make([][]int, n)\n    for i := 1; i < n; i++ {\n        tree[parent[i]] = append(tree[parent[i]], i)\n    }\n    ans := 1\n    var dfs func(u int) int\n    dfs = func(u int) int {\n        max1, max2 := 0, 0\n        for _, v := range tree[u] {\n            l := dfs(v)\n            if s[u] != s[v] {\n                if l > max1 {\n                    max2 = max1\n                    max1 = l\n                } else if l > max2 {\n                    max2 = l\n                }\n            }\n        }\n        if max1+max2+1 > ans {\n            ans = max1 + max2 + 1\n        }\n        return max1 + 1\n    }\n    dfs(0)\n    return ans\n}","lang":"go"},{"language":"Python","code":"class Solution:\n    def longestPath(self, parent: list[int], s: str) -> int:\n        n = len(parent)\n        tree = [[] for _ in range(n)]\n        for i in range(1, n):\n            tree[parent[i]

Related Tags