Find the Longest Valid Obstacle Course at Each Position

Find the Longest Valid Obstacle Course at Each Position - Problem

Imagine you're designing an obstacle course where participants must navigate through barriers of increasing or equal heights. You have a series of obstacles with different heights, and for each position, you want to know the longest valid course you can create.

Given a 0-indexed integer array obstacles where obstacles[i] represents the height of the i-th obstacle, your task is to find the longest obstacle course ending at each position.

Rules for a valid obstacle course:

You can choose any obstacles from position 0 to the current position i
The obstacle at position i must be included
Obstacles must maintain their original order from the array
Each obstacle must be taller than or equal to the previous one

Return an array where result[i] is the length of the longest valid obstacle course ending at position i.

Example: For obstacles [1,2,3,2], the answer is [1,2,3,3] because at position 3, we can use obstacles [1,2,2] forming a course of length 3.

Input & Output

example_1.py — Basic Case

$ Input: obstacles = [1,2,3,2]

› Output: [1,2,3,3]

💡 Note: At position 0: course [1] has length 1. At position 1: course [1,2] has length 2. At position 2: course [1,2,3] has length 3. At position 3: course [1,2,2] has length 3 (we can't include the 3 since 3 > 2).

example_2.py — Decreasing Heights

$ Input: obstacles = [2,2,1]

› Output: [1,2,1]

💡 Note: At position 0: course [2] has length 1. At position 1: course [2,2] has length 2. At position 2: course [1] has length 1 (we can only use obstacles up to position 2, and since 1 < 2, we can't extend any previous course).

example_3.py — All Same Height

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

› Output: [1,1,2,3,2,2]

💡 Note: The longest courses ending at each position: [3], [1], [1,5], [1,5,6], [1,4], [1,2]. Notice how we can build different valid courses by choosing different subsets of previous obstacles.

Constraints

n == obstacles.length
1 ≤ n ≤ 10⁵
1 ≤ obstacles[i] ≤ 10⁷
Time limit: 1 second

Visualization

Tap to expand

Understanding the Visualization

Smart Placement

For each new obstacle, find the best position to place it using binary search

Maintain Options

Keep the smallest possible ending height for each course length

Optimal Choice

Either extend current best or replace to maintain better future possibilities

Key Takeaway

🎯 Key Insight: We only need to track the smallest ending height for each possible course length. Binary search efficiently finds the optimal placement for each new obstacle, giving us O(n log n) performance instead of O(n²).

Asked in

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

The optimal solution uses Binary Search with Patience Sorting technique in O(n log n) time. We maintain a 'tails' array storing the smallest ending height for each possible course length. For each obstacle, we use binary search to find where it belongs, either extending the longest course or replacing a larger element to keep better future possibilities. This approach is similar to the Longest Increasing Subsequence problem but allows equal heights.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Nested Loops)	O(n²)	O(n)	For each position, check all previous positions to find the longest valid sequence
Binary Search + Patience Sorting (Optimal)	O(n log n)	O(n)	Use binary search to efficiently find the position where each obstacle should be placed

Dynamic Programming (Nested Loops) — Algorithm Steps

Initialize dp array where dp[i] = 1 (each obstacle forms a course of length 1)
For each position i, check all previous positions j < i
If obstacles[j] <= obstacles[i], update dp[i] = max(dp[i], dp[j] + 1)
Return the dp array as result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set each position's initial course length to 1

Check Previous

For each position, examine all previous positions

Update Maximum

If heights are valid, update with maximum possible length

Code -

solution.c — C

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

int* longestObstacleCourseAtEachPosition(int* obstacles, int n, int* returnSize) {
    *returnSize = n;
    int* result = (int*)malloc(n * sizeof(int));
    
    for (int i = 0; i < n; i++) {
        result[i] = 1;
    }
    
    for (int i = 1; i < n; i++) {
        for (int j = 0; j < i; j++) {
            if (obstacles[j] <= obstacles[i]) {
                if (result[j] + 1 > result[i]) {
                    result[i] = result[j] + 1;
                }
            }
        }
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int obstacles[1000];
    int n = 0;
    char* token = strtok(line, "[],");
    while (token != NULL) {
        obstacles[n++] = atoi(token);
        token = strtok(NULL, "[],");
    }
    
    int returnSize;
    int* result = longestObstacleCourseAtEachPosition(obstacles, n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize-1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops - for each of n positions, we check all previous positions

⚠ Quadratic Growth

Space Complexity

O(n)

DP array to store results for each position

⚡ Linearithmic Space

43.7K Views

Medium-High Frequency

~25 min Avg. Time

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

Dynamic Programming (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler