# Solving Leetcode Interviews in Seconds with AI: Find the Longest Valid Obstacle Course at Each Position


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1964" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> 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 ith 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 ith 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.   Example 1:  Input: obstacles = [1,2,3,2] Output: [1,2,3,3] Explanation: The longest valid obstacle course at each position is: - i = 0: [1], [1] has length 1. - i = 1: [1,2], [1,2] has length 2. - i = 2: [1,2,3], [1,2,3] has length 3. - i = 3: [1,2,3,2], [1,2,2] has length 3.  Example 2:  Input: obstacles = [2,2,1] Output: [1,2,1] Explanation: The longest valid obstacle course at each position is: - i = 0: [2], [2] has length 1. - i = 1: [2,2], [2,2] has length 2. - i = 2: [2,2,1], [1] has length 1.  Example 3:  Input: obstacles = [3,1,5,6,4,2] Output: [1,1,2,3,2,2] Explanation: The longest valid obstacle course at each position is: - i = 0: [3], [3] has length 1. - i = 1: [3,1], [1] has length 1. - i = 2: [3,1,5], [3,5] has length 2. [1,5] is also valid. - i = 3: [3,1,5,6], [3,5,6] has length 3. [1,5,6] is also valid. - i = 4: [3,1,5,6,4], [3,4] has length 2. [1,4] is also valid. - i = 5: [3,1,5,6,4,2], [1,2] has length 2.    Constraints:  n == obstacles.length 1 <= n <= 105 1 <= obstacles[i] <= 107  

	# Explanation
	Here's a breakdown of the solution approach:

*   **Tail Array:** Maintain a tail array `tail` where `tail[i]` stores the smallest tail of all increasing subsequences of length `i+1`.
*   **Binary Search:** For each obstacle, use binary search on the `tail` array to find the longest increasing subsequence ending with a value less than or equal to the current obstacle.
*   **Update Tail:**  Update the `tail` array to maintain the smallest tail values for each subsequence length.

*   **Runtime Complexity:** O(n log n), **Storage Complexity:** O(n)

	
	# Code
	```python
	def longestObstacleCourseAtEachPosition(obstacles):
    """
    Finds the length of the longest obstacle course at each position.

    Args:
        obstacles: A list of integers representing the height of each obstacle.

    Returns:
        A list of integers, where the i-th element is the length of the longest
        obstacle course for index i.
    """

    n = len(obstacles)
    tail = []  # tail[i] is the smallest tail of all increasing subsequences of length i+1
    ans = []

    for obstacle in obstacles:
        # Binary search to find the smallest tail that is greater than the current obstacle
        l, r = 0, len(tail)
        while l < r:
            mid = (l + r) // 2
            if tail[mid] <= obstacle:
                l = mid + 1
            else:
                r = mid

        # If we found a tail greater than the obstacle, we replace it with the obstacle
        if l < len(tail):
            tail[l] = obstacle
        else:
            # Otherwise, we extend the longest increasing subsequence by 1
            tail.append(obstacle)

        # The length of the longest increasing subsequence ending with the current obstacle is l + 1
        ans.append(l + 1)

    return ans
	```