 GFG App
Open App Browser
Continue

# Count of Subarrays whose first element is the minimum

Given an array arr[] of size N, the task is to find the number of subarrays whose first element is not greater than other elements of the subarray.

Examples:

Input: arr = {1, 2, 1}
Output: 5
Explanation: All subarray are: {1}, {1, 2}, {1, 2, 1}, {2}, {2, 1}, {1}
From above subarray the following meets the condition: {1}, {1, 2}, {1, 2, 1}, {2}, {1}

Input: arr[] = {1, 3, 5, 2}
Output: 8
Explanation: We have the following subarrays which meet the condition:
{1}, {1, 3}, {1, 3, 5}, {1, 3, 5, 2}, {3}, {3, 5}, {5}, {2}

Naive Approach: The naive approach is to run a nested loop and find all the subarrays with first element not bigger than the other elements in the subarray.

Below is the implementation of the above approach :

## C++

 `// C++ code to implement the approach`   `#include ` `using` `namespace` `std;`   `// Function to find all subarrays with first` `// element not bigger than other elements` `int` `countSubarrays(vector<``int``>& arr)` `{` `    ``int` `n = arr.size();`   `    ``// Cnt is initialised to n because` `    ``// atleast n subarrays will be there` `    ``// which is single element itself` `    ``int` `cnt = n;`   `    ``// Two loops to find the` `    ``// ending of each subarrays` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``for` `(``int` `j = i + 1; j < n; j++) {`   `            ``// Minimum element from` `            ``// [start+1, end] of each subarray` `            ``int` `mini_ele = *min_element(begin(arr) + i + 1,` `                                        ``begin(arr) + j + 1);`   `            ``// Checking if minimum of` `            ``// elements from [start+1, end] is` `            ``// not smaller than start element` `            ``// updating the count of subarrays` `            ``if` `(mini_ele >= arr[i])` `                ``cnt++;` `        ``}` `    ``}` `    ``return` `cnt;` `}`   `// Driver Code` `int` `main()` `{` `    ``vector<``int``> arr = { 1, 3, 5, 2 };`   `    ``// Function call` `    ``cout << countSubarrays(arr) << ``"\n"``;` `    ``return` `0;` `}`

## Java

 `// Java code to implement the approach`   `import` `java.io.*;` `import` `java.util.*; ` ` `  `class` `GFG` `{` `    ``// Function to find the minimum element in a given range` `    ``public` `static` `int` `min_element(``int` `arr[], ``int` `left, ``int` `right)` `    ``{` `        ``int` `x = Integer.MAX_VALUE;` `        ``for``(``int` `i=left;i= arr[i])` `                ``cnt++;` `            ``}` `        ``}` `        `  `        ``return` `cnt;` `    ``}` `    `  `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `arr[] = {``1``, ``3``, ``5``, ``2``};` `        `  `        ``// Function call` `        ``System.out.println(countSubarrays(arr) );` `    ``}` `}`   `// This code is contributed by Aditya Patil`

## Python3

 `# Python3 code to implement the approach`   `# Function to find all subarrays with first` `# element not bigger than other elements`   `# Function to find the minimum element in a given range` `import` `sys`   `def` `min_element(arr, left, right):` `    ``x ``=` `sys.maxsize`   `    ``for` `i ``in` `range``(left, right):` `        ``x ``=` `min``(arr[i], x)` `    ``return` `x`   `def` `countSubarrays(arr):` `    ``n ``=` `len``(arr)`   `    ``# Cnt is initialised to n because` `    ``# atleast n subarrays will be there` `    ``# which is single element itself` `    ``cnt ``=` `n`   `    ``# Two loops to find the` `    ``# ending of each subarrays` `    ``for` `i ``in` `range``(n):` `        ``for` `j ``in` `range``(i``+``1``,n):`   `            ``# Minimum element from` `            ``# [start+1, end] of each subarray` `            ``mini_ele ``=` `min_element(arr ,i ``+` `1``, j ``+` `1``)`   `            ``# Checking if minimum of` `            ``# elements from [start+1, end] is` `            ``# not smaller than start element` `            ``# updating the count of subarrays` `            ``if` `(mini_ele >``=` `arr[i]):` `                ``cnt ``+``=` `1` `    `  `    ``return` `cnt`   `# Driver Code` `arr ``=` `[ ``1``, ``3``, ``5``, ``2` `]`   `# Function call` `print``(countSubarrays(arr))`   `# This code is contributed by shinjanpatra`

## C#

 `// C# code to implement the approach` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG` `{` `  `  `  ``// Function to find the minimum element in a given range` `  ``public` `static` `int` `min_element(``int` `[]arr, ``int` `left, ``int` `right)` `  ``{` `    ``int` `x = ``int``.MaxValue;` `    ``for``(``int` `i=left;i= arr[i])` `          ``cnt++;` `      ``}` `    ``}`   `    ``return` `cnt;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(String[] args)` `  ``{` `    ``int` `[]arr = {1, 3, 5, 2};`   `    ``// Function call` `    ``Console.WriteLine(countSubarrays(arr) );` `  ``}` `}`   `// This code contributed by shikhasingrajput`

## Javascript

 ``

Output

`8`

Time Complexity: O(N3)
Auxiliary Space: O(1)

Efficient Approach:  The efficient approach is based on the concept of finding the next smaller element on the right of an element. To implement this concept stack is used. Follow the steps mentioned below:

• We use a monotonic stack to get the index of the next smaller of each element on the right because we want the subarray with first element as the minimum element.
• The total subarray’s in the range [i, j] having i as the starting index is (j – i).
• Compute the next smaller index for every index i, add (j-i) for each of them and keep updating the total count of valid subarrays.

Below is the implementation of the above approach.

## C++

 `// C++ code to implement the approach`   `#include ` `using` `namespace` `std;`   `// Function to find all subarrays with first` `// element not bigger than other elements` `int` `countSubarrays(vector<``int``>& arr)` `{` `    ``// Taking stack for find next smaller` `    ``// element to the right` `    ``stack<``int``> s;` `    ``int` `ans = 0;` `    ``int` `n = arr.size();`   `    ``// Looping from right side because we next` `    ``// smallest to the right` `    ``for` `(``int` `i = n - 1; i >= 0; i--) {` `        ``while` `(!s.empty() and arr[s.top()] >= arr[i])` `            ``s.pop();` `        ``// The index of next smaller element` `        ``// starting from i'th index` `        ``int` `last = (s.empty() ? n : s.top());`   `        ``// Adding the number of subarray which` `        ``// can be formed in the range [i, last]` `        ``ans += (last - i);` `        ``s.push(i);` `    ``}` `    ``return` `ans;` `}`   `// Driver Code` `int` `main()` `{` `    ``vector<``int``> arr = { 1, 3, 5, 2 };`   `    ``// Function call` `    ``cout << countSubarrays(arr) << ``"\n"``;` `    ``return` `0;` `}`

## Java

 `// JAVA code to implement the approach` `import` `java.util.*;` `class` `GFG {`   `  ``// Function to find all subarrays with first` `  ``// element not bigger than other elements` `  ``public` `static` `int` `countSubarrays(``int` `arr[])` `  ``{`   `    ``// Taking stack for find next smaller` `    ``// element to the right` `    ``Stack s = ``new` `Stack();` `    ``int` `ans = ``0``;` `    ``int` `n = arr.length;`   `    ``// Looping from right side because we next` `    ``// smallest to the right` `    ``for` `(``int` `i = n - ``1``; i >= ``0``; i--) {` `      ``while` `(s.empty() == ``false` `             ``&& arr[s.peek()] >= arr[i])` `        ``s.pop();` `      ``// The index of next smaller element` `      ``// starting from i'th index` `      ``int` `last = ((s.empty() == ``true``) ? n : s.peek());`   `      ``// Adding the number of subarray which` `      ``// can be formed in the range [i, last]` `      ``ans += (last - i);` `      ``s.push(i);` `    ``}` `    ``return` `ans;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `arr[] = ``new` `int``[] { ``1``, ``3``, ``5``, ``2` `};`   `    ``// Function call` `    ``System.out.println(countSubarrays(arr));` `  ``}` `}`   `// This code is contributed by Taranpreet`

## Python3

 `# Python 3 code to implement the approach`   `# Function to find all subarrays with first` `# element not bigger than other elements` `def` `countSubarrays(arr):`   `    ``# Taking stack for find next smaller` `    ``# element to the right` `    ``s ``=` `[]` `    ``ans ``=` `0` `    ``n ``=` `len``(arr)`   `    ``# Looping from right side because we next` `    ``# smallest to the right` `    ``for` `i ``in` `range``(n ``-` `1``, ``-``1``, ``-``1``):` `        ``while` `(``len``(s) !``=` `0` `and` `arr[s[``-``1``]] >``=` `arr[i]):` `            ``s.pop()` `            `  `        ``# The index of next smaller element` `        ``# starting from i'th index` `        ``if` `(``len``(s) ``=``=` `0``):` `            ``last ``=` `n` `        ``else``:` `            ``last ``=` `s[``-``1``]`   `        ``# Adding the number of subarray which` `        ``# can be formed in the range [i, last]` `        ``ans ``+``=` `(last ``-` `i)` `        ``s.append(i)`   `    ``return` `ans`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``arr ``=` `[``1``, ``3``, ``5``, ``2``]`   `    ``# Function call` `    ``print``(countSubarrays(arr))`   `    ``# This code is contributed by ukasp.`

## C#

 `// C# program to implement above approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG` `{` `  ``// Function to find all subarrays with first` `  ``// element not bigger than other elements` `  ``public` `static` `int` `countSubarrays(List<``int``> arr)` `  ``{` `    ``// Taking stack for find next smaller` `    ``// element to the right` `    ``Stack<``int``> s = ``new` `Stack<``int``>();` `    ``int` `ans = 0;` `    ``int` `n = arr.Count;`   `    ``// Looping from right side because we next` `    ``// smallest to the right` `    ``for` `(``int` `i = n - 1 ; i >= 0 ; i--) {` `      ``while` `(s.Count > 0 && arr[s.Peek()] >= arr[i]){` `        ``s.Pop();` `      ``}` `      ``// The index of next smaller element` `      ``// starting from i'th index` `      ``int` `last = (s.Count == 0 ? n : s.Peek());`   `      ``// Adding the number of subarray which` `      ``// can be formed in the range [i, last]` `      ``ans += (last - i);` `      ``s.Push(i);` `    ``}` `    ``return` `ans;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(``string``[] args){`   `    ``List<``int``> arr = ``new` `List<``int``>{` `      ``1, 3, 5, 2` `      ``};`   `    ``// Function call` `    ``Console.Write(countSubarrays(arr));` `  ``}` `}`   `// This code is contributed by subhamgoyal2014.`

## Javascript

 ``

Output

`8`

Time Complexity: Auxiliary Space: My Personal Notes arrow_drop_up