Number of Valid Subarrays
You can find the number of nonempty subarrays with the leftmost element of the subarray not larger than other elements in the subarray by using a stack. The stack will keep track of the elements that are in descending order. For each new element, you can count the number of valid subarrays ending at that element. Here’s a Python function to accomplish this:


The function works by iterating through the nums
array and using a stack to keep track of elements in descending order. When a new element is found that is less than the top of the stack, elements are popped from the stack until a smaller or equal element is found. The count is incremented by the length of the stack, representing the number of valid subarrays ending at that element.
This code will return the correct number of valid subarrays for the given constraints.
Categorization
The problem falls under the domain of “Array Manipulation” and “Combinatorial Enumeration”. It deals with counting specific types of contiguous subarrays.
‘What
 An integer array ’nums’ is given.
 A “valid subarray” is defined as a contiguous part of the array where the leftmost element is not larger than any other elements in the subarray.
 The objective is to count and return the number of such valid subarrays.
Classification
The problem can be further classified as a “Counting Problem”. The task revolves around enumerating certain types of subarrays based on the given condition. There’s no need to actually return these subarrays; just their count is required.
In summary, this problem is about combinatorial enumeration within the array domain. The main goal is to count the number of subarrays that satisfy a particular constraint concerning the relationship of the elements within each subarray. It does not involve rearranging the elements or modifying the array, making it a pure counting problem.
To solve this problem, you can use a stack data structure. Here is how it works:
Define Problem
What is the problem to be solved?
 Count the number of valid subarrays based on the condition that the leftmost element should be not larger than any other elements in the subarray.
What is the precondition? Where are you starting?
 You are starting with an integer array ’nums’.
What is the postcondition? Where is your destination?
 Your destination is to return an integer, the count of valid subarrays.
Define Step
The basic step is to iterate through the array while using a stack to keep track of valid leftmost elements.
Measure of Progress
Progress is measured by iterating through the array and successfully counting the subarrays that meet the condition.
Define Loop Invariant
The stack will always contain elements in descending order, ensuring that popping an element will allow us to count all valid subarrays ending with that element.
Main Steps


Make Progress
Each iteration updates ‘count’ by adding the length of the stack, making progress according to the measure of progress.
Maintain Loop Invariant
Appending and popping from the stack maintain the loop invariant. Stack stays in descending order, supporting the next iteration.
Establish the Loop Invariant
The loop invariant is established initially by having an empty stack.
Exit Condition
The loop exits when we’ve processed each element in the array.
Ending
Since the ‘count’ is updated during each iteration, the final value of ‘count’ is the answer to the problem, satisfying the postcondition.
Time complexity: O(n) Space complexity: O(n)
Invariant
In this problem, the loop invariant is that the stack will always contain elements in descending order. This ensures that whenever we pop an element from the stack, we can reliably count the number of valid subarrays that end with that element.
The loop invariant holds true at the start of each iteration and is reestablished at the end of each iteration. This invariant provides the mechanism for counting valid subarrays efficiently.
In the context of this problem, the terms “invariant” and “loop invariant” can refer to the same concept. The loop invariant is a specific type of invariant that must hold before, during, and after each iteration of a loop. Here, the invariantâ€”that the stack contains elements in descending orderâ€”serves as the loop invariant for the main loop where you iterate through the given nums
array. This is because this condition is crucial for the logic within the loop to function correctly.
Brute Force Solution
Steps:
 Initialize a variable
count
to 0.  Loop through each element
i
in the arraynums
. For each
i
, loop through its subarray ending atj
. Check if all elements in the subarray
nums[i:j+1]
are greater than or equal tonums[i]
.  If yes, increment
count
.
 Check if all elements in the subarray
 For each


Inefficiencies:
 Time Complexity: O(n^3) due to the two nested loops and the
all()
function inside.  Space Complexity: O(1)
Optimized Solution
Steps:
 Use a stack to keep track of elements in descending order.
 Loop through each element in the array.
 While the stack is not empty and the current element is greater than the top of the stack, pop the stack.
 Add the stack’s length to the
count
.  Push the current element onto the stack.


Optimizations:
 Using a stack reduces the need for a nested loop to check each subarray.
 By keeping the stack in descending order, we ensure the invariant is maintained.
Complexity:
 Time Complexity: O(n) for a single pass through the array.
 Space Complexity: O(n) for the stack.
By using a stack, we improved the time complexity from O(n^3) to O(n) and introduced a space complexity of O(n), which is much better than the bruteforce approach.
1. Initial Parameters
nums
: This is the list of integers provided as input. It signifies the array we are analyzing to count the number of valid subarrays.
2. Primary Loop
The primary loop iterates through each element in the array nums
. Each iteration represents the current element that is being considered as the “leftmost element” in possible subarrays. The loop advances the solution by determining how many valid subarrays have this element as their leftmost member.
3. Conditions or Branches
There’s a condition inside the loop: while stack and stack[1] > num
. This condition signifies whether the elements in the stack are greater than the current element. If they are, they are removed from the stack, maintaining its descending order.
4. Updates or Modifications
Within the loop, we update the count
variable and the stack
:
count
: Incremented by the current size of the stack plus one. This captures how many subarrays can be formed with the current element as the leftmost member.stack
: After popping out elements that are greater than the current element, the current element itself is pushed onto the stack.
5. Invariant
The stack serves as an invariant that’s maintained in descending order. At any given point, the stack holds all elements such that any new element n
will have all elements greater than or equal to n
to its left. This helps us to efficiently count valid subarrays for each element in a single scan of the input.
6. Significance of Final Output
The final output, stored in the count
variable, represents the total number of valid subarrays that meet the problem’s constraints. By returning this value, the solution satisfies the problem’s requirements by accurately counting these subarrays in an efficient manner.
1. Initial Parameters
nums
: This is the list of integers provided as input. It signifies the array we are analyzing to count the number of valid subarrays.
2. Primary Loop
The primary loop iterates through each element in the array nums
. Each iteration represents the current element that is being considered as the “leftmost element” in possible subarrays. The loop advances the solution by determining how many valid subarrays have this element as their leftmost member.
3. Conditions or Branches
There’s a condition inside the loop: while stack and stack[1] > num
. This condition signifies whether the elements in the stack are greater than the current element. If they are, they are removed from the stack, maintaining its descending order.
4. Updates or Modifications
Within the loop, we update the count
variable and the stack
:
count
: Incremented by the current size of the stack plus one. This captures how many subarrays can be formed with the current element as the leftmost member.stack
: After popping out elements that are greater than the current element, the current element itself is pushed onto the stack.
5. Invariant
The stack serves as an invariant that’s maintained in descending order. At any given point, the stack holds all elements such that any new element n
will have all elements greater than or equal to n
to its left. This helps us to efficiently count valid subarrays for each element in a single scan of the input.
6. Significance of Final Output
The final output, stored in the count
variable, represents the total number of valid subarrays that meet the problem’s constraints. By returning this value, the solution satisfies the problem’s requirements by accurately counting these subarrays in an efficient manner.
1. General Python Concepts Drills
Drill 1: Using a List as a Stack


Drill 2: Looping through an Array


Drill 3: Using a Variable to Keep Count


2. ProblemSpecific Concepts Drills
Drill 4: Checking Elements and Updating Count
This drill is essential for counting valid subarrays with the current element as the leftmost member.


Drill 5: Using a Stack to Keep Track of Elements
Keeping track of elements in descending order is crucial to solving this problem efficiently.


3. Integration for the Final Solution
 Initialize an empty stack and a variable
count
set to 0.  Iterate through each element in the input array
nums
. This is derived from Drill 2.
 Inside the loop, check elements and update
count
. For this, you’ll use the logic from Drill 4.
 Also inside the loop, update the stack.
 You can take help from Drill 5.
 Outside the loop, return the
count
variable.
Combining these drills, you can build the final solution to solve the initial problem effectively.
Here are 10 problems that use similar underlying concepts:
LeetCode 42: Trapping Rain Water
 This problem also uses a stack to keep track of heights, similar to how we kept track of elements in descending order.
LeetCode 739: Daily Temperatures
 This problem uses a stack to keep track of elements that need a match in the future, much like the stack usage in our original problem.
LeetCode 496: Next Greater Element I
 This problem involves finding the next greater element for each element in an array, which is conceptually similar to identifying subarrays based on a condition.
LeetCode 84: Largest Rectangle in Histogram
 Uses a stack to keep track of heights, much like we did for the elements in the array.
LeetCode 85: Maximal Rectangle
 Builds upon the stackbased histogram problem, showing the importance of data structure choice in solving problems.
LeetCode 503: Next Greater Element II
 Another nextgreaterelement problem that utilizes a stack to find greater elements in circular arrays.
LeetCode 907: Sum of Subarray Minimums
 This problem requires you to find minimums for all subarrays, akin to our requirement to identify subarrays based on conditions.
LeetCode 155: Min Stack
 This involves designing a stack that supports min retrieval, pushing, and popping, thereby showing the utility of a stack in array manipulation.
LeetCode 1019: Next Greater Node In Linked List
 Although not an array, the problem uses a stack to find the next greater node, which is a concept that is similar to our original problem.
LeetCode 901: Online Stock Span
 This problem keeps track of elements in a stack, pairing each with the span of stocks that are less than it, similar to how we kept track of valid subarrays.
These problems involve similar problemsolving strategies like stack manipulation, subarray identification, and element comparisons, making them conceptually related to our original problem.