Introduction

In this blog post, we will explore how to solve the LeetCode problem "1944" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, 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

There are n people standing in a queue, and they numbered from 0 to n - 1 in left to right order. You are given an array heights of distinct integers where heights[i] represents the height of the ith person. A person can see another person to their right in the queue if everybody in between is shorter than both of them. More formally, the ith person can see the jth person if i < j and min(heights[i], heights[j]) > max(heights[i+1], heights[i+2], ..., heights[j-1]). Return an array answer of length n where answer[i] is the number of people the ith person can see to their right in the queue. Example 1: Input: heights = [10,6,8,5,11,9] Output: [3,1,2,1,1,0] Explanation: Person 0 can see person 1, 2, and 4. Person 1 can see person 2. Person 2 can see person 3 and 4. Person 3 can see person 4. Person 4 can see person 5. Person 5 can see no one since nobody is to the right of them. Example 2: Input: heights = [5,1,2,3,10] Output: [4,1,1,1,0] Constraints: n == heights.length 1 <= n <= 105 1 <= heights[i] <= 105 All the values of heights are unique.

Explanation

Here's the solution to the problem, focusing on efficiency and optimality:

• Monotonic Stack: The core idea is to use a monotonic decreasing stack. This stack will help us efficiently keep track of potential "seeable" people to the right. As we iterate through the heights array from right to left, the stack maintains people taller than those to their right.
• Counting Visible People: For each person, we compare their height to the heights of people in the stack. We pop elements from the stack that are smaller than the current person because those are visible. Once we find an element on the stack that's not smaller, it means they block the view to people farther in the stack.

• Right-to-Left Iteration: Processing from right to left is crucial because it simplifies determining visibility to the right. It also aligns well with the monotonic stack's properties.

• Time Complexity: O(n), Space Complexity: O(n)

Code

    def can_see_persons_count(heights):
    n = len(heights)
    result = [0] * n
    stack = []  # Monotonically decreasing stack (stores indices)

    for i in range(n - 1, -1, -1):
        count = 0
        while stack and heights[i] > heights[stack[-1]]:
            stack.pop()
            count += 1

        if stack:
            count += 1  # Can see the next tallest person
        result[i] = count
        stack.append(i)

    return result