There is a straight line of students of various heights. The students' heights are given…
- User
There is a straight line of students of various heights. The students' heights are given in the form of an array, in the order they are standing in the line.
ALL
Consider the region of a student as the length of the largest subarray that includes that student's position, and in which that student's height is equal to maximum height among all students present in that subarray. Return the sum of the region of all students.
For example-
• heights = [3, 5, 6]
• The longest subarray in which the first student's height is equal to the maximum height among all
other students is [3]; thus, the length of the region of the first student is 1.
• The longest subarray in which the second student's height is equal to maximum height among all other students is [3, 5]; thus, the length of the region of the second student is 2.
• The longest subarray in which the third student's height is equal to the maximum height among all other students is [3, 5, 6]; thus, the length of the region of the third student is 3.
• Thus, the sum of the lengths of all regions of all students is 1+2+3=6.
Function Description
Complete the function calculateTotalRegion in the editor below. The function must return the desired sum of all regions.
calculateTotal Region has the following parameter(s): heights: an array of the heights of students standing in the line
Constraints
1 <= length of heights ≤ 10^5
1 <= heights[i] ≤ 10^9
La
▼Input Format For Custom Testing The first line contains the only integer n that denotes the size of the array heights.
The next in lines contain one integer that denotes heights[i].
▼Sample Case 0
Sample Input For Custom Testing
3
1
2
1
Sample Output
5
Explanation
Subarrays for values 1, 2, and 1 are [1], [1, 2, 1], and [1]. The sum of their lengths is 1 + 3 + 1 = 5,
▼Sample Case 1
Sample Input For Custom Testing
4
1
1
1
1
Sample Output
16
Explanation For example:
heights [1,1,1,1]
All elements are the same, so each subarray contains 4 elements. 4+4+4+4=16.
- Assistant
To solve this problem efficiently, we'll use a stack-based approach to determine the "region" for each student in the lineup. Here's a step-by-step breakdown of the solution:
-
Understanding the Region:
- For each student at position
i, we need to find the largest subarray that includesiwhere the height of the student atiis the maximum in that subarray. - To achieve this, we need to find:
- The first student to the left of
iwho is taller thani(left[i]). - The first student to the right of
iwho is taller thani(right[i]).
- The first student to the left of
- The length of the region for student
iis then calculated asright[i] - left[i] - 1.
- For each student at position
-
Using Stacks to Find
left[i]andright[i]:- Previous Greater Element (Left):
- Iterate through the array from left to right.
- Use a stack to keep track of the indices of students. For each student, pop elements from the stack until you find a student taller than the current one.
- If the stack is empty, it means there is no taller student to the left, so
left[i] = -1. Otherwise,left[i] = stack[-1].
- Next Greater Element (Right):
- Iterate through the array from right to left.
- Use a similar stack approach to find the first taller student to the right.
- If the stack is empty,
right[i] = n(wherenis the length of the array). Otherwise,right[i] = stack[-1].
- Previous Greater Element (Left):
-
Calculating the Total Region Sum:
- Once we have both
left[i]andright[i]for all students, compute the region length for each student asright[i] - left[i] - 1. - Sum up these lengths to get the total region sum.
- Once we have both
-
Implementation:
- Below is the Python function implementing the above logic. This function efficiently handles large input sizes (up to (10^5) elements) by using stacks to maintain the order of processing.
def calculateTotalRegion(heights): n = len(heights) left = [-1] * n right = [n] * n # Compute previous greater elements stack = [] for i in range(n): while stack and heights[stack[-1]] <= heights[i]: stack.pop() if stack: left[i] = stack[-1] else: left[i] = -1 stack.append(i) # Compute next greater elements stack = [] for i in range(n-1, -1, -1): while stack and heights[stack[-1]] <= heights[i]: stack.pop() if stack: right[i] = stack[-1] else: right[i] = n stack.append(i) # Compute the sum of regions total = 0 for i in range(n): total += right[i] - left[i] -1 return totalExplanation with Sample Inputs:
-
Sample Input 0:
heights = [1, 2, 1]- Left Indices:
[-1, -1, 1] - Right Indices:
[1, 3, 3] - Region Lengths:
[1, 3, 1] - Total Sum:
1 + 3 + 1 = 5
- Left Indices:
-
Sample Input 1:
heights = [1, 1, 1, 1]- Left Indices:
[-1, -1, -1, -1] - Right Indices:
[4, 4, 4, 4] - Region Lengths:
[4, 4, 4, 4] - Total Sum:
4 + 4 + 4 + 4 = 16
- Left Indices:
-
Additional Test Case:
heights = [2, 1, 2, 1, 2]- Left Indices:
[-1, 0, -1, 2, -1] - Right Indices:
[5, 2, 5, 4, 5] - Region Lengths:
[5, 1, 5, 1, 5] - Total Sum:
5 + 1 + 5 + 1 + 5 = 17
- Left Indices:
This approach ensures that the solution is both correct and efficient, handling the constraints effectively.
-