Find the Longest Valid Obstacle Course at Each Position - Problem

You want to build some obstacle courses. You are given a 0-indexed integer array obstacles of length n, where obstacles[i] describes the height of the i^th obstacle.

For every index i between 0 and n - 1 (inclusive), find the length of the longest obstacle course in obstacles such that:

You choose any number of obstacles between 0 and i inclusive.
You must include the i^th obstacle in the course.
You must put the chosen obstacles in the same order as they appear in obstacles.
Every obstacle (except the first) is taller than or the same height as the obstacle immediately before it.

Return an array ans of length n, where ans[i] is the length of the longest obstacle course for index i as described above.

Input & Output

Example 1 — Basic Sequence

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

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

💡 Note: At index 0: longest course is [1] with length 1. At index 1: longest course is [1,2] with length 2. At index 2: longest course is [1,2,3] with length 3. At index 3: longest course is [1,2] with length 2 (can't include 3 since 3 > 2).

Example 2 — Decreasing Sequence

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

› Output: [1,2,1]

💡 Note: At index 0: longest course is [2] with length 1. At index 1: longest course is [2,2] with length 2. At index 2: longest course is [1] with length 1 (can't use previous obstacles since they're taller).

Example 3 — All Same Heights

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

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

💡 Note: At each position, we find the longest non-decreasing subsequence ending at that position. For example, at index 3 (value 6), the longest course is [1,5,6] with length 3.

Constraints

1 ≤ obstacles.length ≤ 10⁵
1 ≤ obstacles[i] ≤ 10⁷

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

This problem is a variant of the Longest Increasing Subsequence (LIS) where we need to find the longest non-decreasing subsequence ending at each position. The key insight is to use binary search with patience sorting to efficiently maintain the smallest tail element for each possible length. Best approach is Binary Search with Time: O(n log n), Space: O(n).

Common Approaches

✓ Sliding Window

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

Binary Search with Patience Sorting

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

Maintain an array that tracks the smallest tail element for each possible length. Use binary search to find where each new element should be placed, similar to patience sorting algorithm.

Brute Force Dynamic Programming

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

Use a DP array where dp[i] represents the length of longest obstacle course ending at position i. For each position, check all previous positions to see if they can extend the sequence.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int binarySearch(int* arr, int size, int target) {
    int left = 0, right = size;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] <= target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

int* longestObstacleCourseAtEachPosition(int* obstacles, int obstaclesSize, int* returnSize) {
    *returnSize = obstaclesSize;
    int* result = (int*)malloc(obstaclesSize * sizeof(int));
    int* lis = (int*)malloc(obstaclesSize * sizeof(int));
    int lisSize = 0;
    
    for (int i = 0; i < obstaclesSize; i++) {
        int pos = binarySearch(lis, lisSize, obstacles[i]);
        
        if (pos == lisSize) {
            lis[lisSize++] = obstacles[i];
        } else {
            lis[pos] = obstacles[i];
        }
        
        result[i] = pos + 1;
    }
    
    free(lis);
    return result;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int obstacles[100000];
    int obstaclesSize = 0;
    
    // Find start and end of array
    char* start = strchr(line, '[');
    if (start) {
        start++; // Skip '['
        char* end = strchr(start, ']');
        if (end) {
            *end = '\0'; // Null terminate before ']'
        }
        
        // Parse numbers
        char* ptr = start;
        while (*ptr) {
            while (*ptr == ' ' || *ptr == ',') ptr++;
            if (*ptr == '\0') break;
            
            obstacles[obstaclesSize++] = (int)strtol(ptr, &ptr, 10);
        }
    }
    
    int returnSize;
    int* result = longestObstacleCourseAtEachPosition(obstacles, obstaclesSize, &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

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.0K Views

Medium Frequency

~25 min Avg. Time

892 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