Longest Univalue Path

Longest Univalue Path - Problem

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.

The length of the path between two nodes is represented by the number of edges between them.

Input & Output

Example 1 — Basic Tree

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

› Output: 2

💡 Note: The longest path with same values is 5→5→5 from root through right child to its right child, giving length 2 (2 edges)

Example 2 — Single Value Tree

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

› Output: 2

💡 Note: The longest same-value path is 4→4→4 in the left subtree, with length 2

Example 3 — All Same Values

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

› Output: 4

💡 Note: Multiple paths exist, longest goes through root connecting both subtrees: 1→1→1→1→1 with length 4

Constraints

The number of nodes in the tree is in the range [0, 10⁴].
-1000 ≤ Node.val ≤ 1000
The depth of the tree will not exceed 1000.

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22 M Microsoft 18

The key insight is to use DFS where each node returns the longest same-value path extending downward, while updating a global maximum with paths that pass through the current node. Best approach uses optimized DFS in a single traversal. Time: O(n), Space: O(h)

Common Approaches

✓ Bfs

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

Brute Force - Check All Paths

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

Visit every node as a potential starting point and perform DFS to find all paths with the same value. Keep track of the maximum path length found.

Optimized DFS

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

Use depth-first search to visit each node once. At each node, calculate the longest same-value path extending down from that node and update the global maximum by considering paths that go through the current node.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int i, j;
} Point;

int bfs(int** grid, int rows, int cols, int startI, int startJ) {
    Point* queue = (Point*)malloc(rows * cols * sizeof(Point));
    int front = 0, rear = 0;
    
    queue[rear++] = (Point){startI, startJ};
    grid[startI][startJ] = 0; // Mark as visited
    int area = 0;
    
    int directions[4][2] = {{0,1}, {0,-1}, {1,0}, {-1,0}};
    
    while (front < rear) {
        Point curr = queue[front++];
        area += 1;
        
        for (int d = 0; d < 4; d++) {
            int ni = curr.i + directions[d][0];
            int nj = curr.j + directions[d][1];
            if (ni >= 0 && ni < rows && nj >= 0 && nj < cols && grid[ni][nj] == 1) {
                grid[ni][nj] = 0; // Mark as visited
                queue[rear++] = (Point){ni, nj};
            }
        }
    }
    
    free(queue);
    return area;
}

int solution(int** grid, int rows, int cols) {
    if (rows == 0 || cols == 0) return 0;
    
    int maxArea = 0;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (grid[i][j] == 1) {
                int area = bfs(grid, rows, cols, i, j);
                if (area > maxArea) maxArea = area;
            }
        }
    }
    
    return maxArea;
}

void parseGrid(char* input, int*** grid, int* rows, int* cols) {
    if (strcmp(input, "[]") == 0) {
        *rows = 0;
        *cols = 0;
        *grid = NULL;
        return;
    }
    
    // Count rows
    *rows = 0;
    for (int i = 0; input[i]; i++) {
        if (input[i] == '[' && i > 0) (*rows)++;
    }
    if (*rows == 0 && strchr(input, '[')) *rows = 1;
    
    if (*rows == 0) return;
    
    // Allocate grid
    *grid = (int**)malloc(*rows * sizeof(int*));
    
    // Parse each row
    char* token = strtok(input, "[]");
    int rowIdx = 0;
    *cols = 0;
    
    while (token != NULL && rowIdx < *rows) {
        if (strlen(token) > 1) { // Skip empty tokens
            // Count columns in first row
            if (*cols == 0) {
                char* temp = strdup(token);
                char* num = strtok(temp, ",");
                while (num != NULL) {
                    (*cols)++;
                    num = strtok(NULL, ",");
                }
                free(temp);
            }
            
            (*grid)[rowIdx] = (int*)malloc(*cols * sizeof(int));
            
            char* num = strtok(token, ",");
            int colIdx = 0;
            while (num != NULL && colIdx < *cols) {
                (*grid)[rowIdx][colIdx] = atoi(num);
                colIdx++;
                num = strtok(NULL, ",");
            }
            rowIdx++;
        }
        token = strtok(NULL, "[]");
    }
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    input[strcspn(input, "\n")] = 0;
    
    int** grid;
    int rows, cols;
    parseGrid(input, &grid, &rows, &cols);
    
    int result = solution(grid, rows, cols);
    printf("%d\n", result);
    
    // Free memory
    for (int i = 0; i < rows; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

52.0K Views

Medium Frequency

~25 min Avg. Time

2.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