Longest Special Path II

Longest Special Path II - Problem

Array Hash Table Tree Depth-First Search Prefix Sum Hard

You're exploring a tree structure where each node has a unique value. Your mission is to find the longest special path - a downward journey from any ancestor to its descendant with an interesting twist!

Given an undirected tree rooted at node 0 with n nodes (numbered 0 to n-1), represented by edges and node values, you need to find special paths where:

All node values are distinct, OR
At most one value appears exactly twice

Input:

edges: 2D array where edges[i] = [u_i, v_i, length_i] represents an edge between nodes u_i and v_i with given length
nums: Array where nums[i] is the value at node i

Output: Return [maxLength, minNodes] where:

maxLength: Length of the longest special path
minNodes: Minimum number of nodes among all longest special paths

Input & Output

example_1.py — Basic Tree

$ Input: edges = [[0,1,5], [1,2,3]], nums = [1,2,1]

› Output: [8, 3]

💡 Note: The longest special path is 0→1→2 with values [1,2,1]. Since value 1 appears twice (allowed), this path has length 5+3=8 and uses 3 nodes.

example_2.py — Complex Tree

$ Input: edges = [[0,1,2], [0,2,3], [1,3,4]], nums = [1,1,2,3]

› Output: [6, 3]

💡 Note: The longest special path is 0→1→3 with values [1,1,3]. The first duplicate is allowed, giving length 2+4=6 with 3 nodes. Path 0→2 has length 3 but only 2 nodes.

example_3.py — Single Node

$ Input: edges = [], nums = [5]

› Output: [0, 1]

💡 Note: With only one node, the longest path has length 0 (no edges) and uses 1 node.

Constraints

1 ≤ n ≤ 10⁵
edges.length == n - 1
edges[i] = [u_i, v_i, length_i]
0 ≤ u_i, v_i < n
1 ≤ length_i ≤ 10⁹
1 ≤ nums[i] ≤ 10⁵
The graph forms a valid tree

Visualization

Tap to expand

Asked in

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

The optimal approach uses DFS with frequency tracking to explore all possible paths efficiently. Key insights: maintain a frequency map during traversal, allow at most one duplicate value per path, and use proper backtracking to restore state. Time complexity: O(n²), Space complexity: O(n).

Common Approaches

✓ Dfs

⏱️ Time: N/A Space: N/A

Brute Force (Try All Paths)

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

For each node, explore all possible downward paths using DFS, checking if each path satisfies the special path condition (all distinct values or at most one duplicate). This approach is straightforward but inefficient.

DFS with Frequency Tracking (Optimal)

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

Use DFS to explore all possible paths while maintaining a frequency map of node values. The key insight is to handle the 'at most one duplicate' constraint by tracking frequency as we traverse and backtracking properly. This approach is optimal because it explores each path exactly once.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚠ Quadratic Space

32.4K Views

Medium-High Frequency

~25 min Avg. Time

1.2K 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