Longest Univalue Path - Practice Coding Problems

Longest Univalue Path - Problem

Longest Univalue Path challenges you to find the longest sequence of connected nodes in a binary tree where all nodes have the same value.

Given the root of a binary tree, return the length of the longest path where each node in the path has the same value. This path may or may not pass through the root node.

The length of the path is measured by the number of edges between nodes, not the number of nodes themselves. For example, a path with 3 nodes has length 2 (2 edges connecting them).

Key Points:

Path can start and end at any nodes
All nodes in the path must have identical values
Return the count of edges, not nodes
Path doesn't need to go through the root

Input & Output

example_1.py — Basic Tree

$ Input: root = [5,4,5,1,1,null,5]

› Output: 2

💡 Note: The longest univalue path is [5,5,5] which has length 2 (2 edges between 3 nodes). The path goes from one leaf node with value 5, through the root, to another node with value 5.

example_2.py — Single Value Tree

$ Input: root = [1,1,1,1,1,1,1]

› Output: 4

💡 Note: All nodes have the same value 1. The longest path goes through the root connecting both subtrees, giving us a path of length 4.

example_3.py — No Matching Values

$ Input: root = [1,2,3,4,5,6,7]

› Output: 0

💡 Note: No two adjacent nodes have the same value, so the longest univalue path has length 0.

Visualization

Tap to expand

Understanding the Visualization

Start at Any Tree

Begin DFS traversal from the root tree

Explore Both Directions

Check how far you can go left and right with same color

Combine Paths

The longest trail through this tree combines left and right distances

Track Maximum

Remember the longest trail found so far

Return Single Direction

Tell parent tree the longest single-direction path available

Key Takeaway

🎯 Key Insight: At each node, the longest univalue path through it equals the sum of longest same-value paths extending left and right

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially traverse the entire tree again

⚠ Quadratic Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
Node values are in the range [-1000, 1000]
The depth of the tree will not exceed 1000
Path length is measured by edges, not nodes

Asked in

G Google 45 f Facebook 32 a Amazon 28 ⊞ Microsoft 22

The optimal solution uses DFS traversal with a clever insight: the longest univalue path through any node equals the sum of the longest univalue paths extending left and right from that node. We track a global maximum while recursively calculating path lengths, achieving O(n) time complexity in a single pass.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Node)	O(n²)	O(h)	For each node, explore all possible univalue paths starting from that node
Optimized DFS (Single Pass)	O(n)	O(h)	Use DFS to calculate longest univalue paths in a single tree traversal

Brute Force (Check Every Node) — Algorithm Steps

Iterate through every node in the tree
For each node, start a DFS to find longest univalue path
Explore left and right subtrees recursively
Track the maximum path length found across all starting points
Return the global maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Starting Node

Choose a node to explore paths from

Explore Left Subtree

Find longest same-value path going left

Explore Right Subtree

Find longest same-value path going right

Combine Paths

Add left and right path lengths

Repeat for All Nodes

Try every node as potential path center

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

int getPathLength(struct TreeNode* node, int targetVal) {
    if (!node || node->val != targetVal) return 0;
    int leftLen = getPathLength(node->left, targetVal);
    int rightLen = getPathLength(node->right, targetVal);
    return (leftLen > rightLen ? leftLen : rightLen) + 1;
}

void getAllNodes(struct TreeNode* node, struct TreeNode** nodes, int* count) {
    if (node) {
        nodes[(*count)++] = node;
        getAllNodes(node->left, nodes, count);
        getAllNodes(node->right, nodes, count);
    }
}

int longestUnivaluePath(struct TreeNode* root) {
    if (!root) return 0;
    
    struct TreeNode* allNodes[1000];
    int nodeCount = 0;
    getAllNodes(root, allNodes, &nodeCount);
    
    int maxPath = 0;
    for (int i = 0; i < nodeCount; i++) {
        struct TreeNode* node = allNodes[i];
        int leftDepth = getPathLength(node->left, node->val);
        int rightDepth = getPathLength(node->right, node->val);
        int currentPath = leftDepth + rightDepth;
        if (currentPath > maxPath) {
            maxPath = currentPath;
        }
    }
    
    return maxPath;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially traverse the entire tree again

⚠ Quadratic Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
Node values are in the range [-1000, 1000]
The depth of the tree will not exceed 1000
Path length is measured by edges, not nodes

42.4K Views

Medium Frequency

~18 min Avg. Time

1.8K 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 (Check Every Node) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler