# Count subarrays for every array element in which they are the minimum

• Last Updated : 23 May, 2022

Given an array arr[] consisting of N integers, the task is to create an array brr[] of size N where brr[i] represents the count of subarrays in which arr[i] is the smallest element.

Examples:

Input: arr[] = {3, 2, 4}
Output: {1, 3, 1}
Explanation:
For arr[0], there is only one subarray in which 3 is the smallest({3}).
For arr[1], there are three such subarrays where 2 is the smallest({2}, {3, 2}, {2, 4}).
For arr[2], there is only one subarray in which 4 is the smallest({4}).

Input: arr[] = {1, 2, 3, 4, 5}
Output: {5, 4, 3, 2, 1}

Naive Approach: The simplest approach is to generate all subarrays of the given array and for every array element arr[i], count the number of subarrays in which it is the smallest element.

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

Efficient Approach: To optimize the above approach, the idea is to find the boundary index for every element, up to which it is the smallest element. For each element let L and R be the boundary indices on the left and right side respectively up to which arr[i] is the minimum. Therefore, the count of all subarrays can be calculated by:

(L + R + 1)*(R + 1)

Follow the steps below to solve the problem:

1. Store all the indices of array elements in a Map.
2. Sort the array in increasing order.
3. Initialize an array boundary[].
4. Iterate over the sorted array arr[] and simply insert the index of that element using Binary Search. Suppose it got inserted at index i, then its left boundary is boundary[i â€“ 1] and its right boundary is boundary[i + 1].
5. Now, using the above formula, find the number of subarrays and keep track of that count in the resultant array.
6. After completing the above steps, print all the counts stored in the resultant array.

Below is the implementation of the above approach:

## C++14

 `// C++14 program for the above approach``#include ``using` `namespace` `std;` `// Function to find the boundary of every``// element within which it is minimum``int` `binaryInsert(vector<``int``> &boundary, ``int` `i)``{``    ``int` `l = 0;``    ``int` `r = boundary.size() - 1;` `    ``// Perform Binary Search``    ``while` `(l <= r)``    ``{``        ` `        ``// Find mid m``        ``int` `m = (l + r) / 2;` `        ``// Update l``        ``if` `(boundary[m] < i)``            ``l = m + 1;` `        ``// Update r``        ``else``            ``r = m - 1;``    ``}` `    ``// Inserting the index``    ``boundary.insert(boundary.begin() + l, i);` `    ``return` `l;``}` `// Function to required count subarrays``vector<``int``> countingSubarray(vector<``int``> arr, ``int` `n)``{``    ` `    ``// Stores the indices of element``    ``unordered_map<``int``, ``int``> index;` `    ``for``(``int` `i = 0; i < n; i++)``        ``index[arr[i]] = i;` `    ``vector<``int``> boundary = {-1, n};``    ``sort(arr.begin(), arr.end());` `    ``// Initialize the output array``    ``vector<``int``> ans(n, 0);` `    ``for``(``int` `num : arr)``    ``{``        ``int` `i = binaryInsert(boundary, index[num]);` `        ``// Left boundary, till the``        ``// element is smallest``        ``int` `l = boundary[i] - boundary[i - 1] - 1;` `        ``// Right boundary, till the``        ``// element is smallest``        ``int` `r = boundary[i + 1] - boundary[i] - 1;` `        ``// Calculate the number of subarrays``        ``// based on its boundary``        ``int` `cnt = l + r + l * r + 1;` `        ``// Adding cnt to the ans``        ``ans[index[num]] += cnt;``    ``}``    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``int` `N = 5;``    ` `    ``// Given array arr[]``    ``vector<``int``> arr = { 3, 2, 4, 1, 5 };``    ` `    ``// Function call``    ``auto` `a = countingSubarray(arr, N);``    ` `    ``cout << ``"["``;``    ``int` `n = a.size() - 1;``    ``for``(``int` `i = 0; i < n; i++)``        ``cout << a[i] << ``", "``;``        ` `    ``cout << a[n] << ``"]"``;``    ` `    ``return` `0;``}` `// This code is contributed by mohit kumar 29`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{``  ` `// Function to find the boundary of every``// element within which it is minimum``static` `int` `binaryInsert(ArrayList boundary,``                        ``int` `i)``{``    ``int` `l = ``0``;``    ``int` `r = boundary.size() - ``1``;``  ` `    ``// Perform Binary Search``    ``while` `(l <= r)``    ``{``      ` `        ``// Find mid m``        ``int` `m = (l + r) / ``2``;``  ` `        ``// Update l``        ``if` `(boundary.get(m) < i)``            ``l = m + ``1``;``  ` `        ``// Update r``        ``else``            ``r = m - ``1``;``    ``}``  ` `    ``// Inserting the index``    ``boundary.add(l, i);``  ` `    ``return` `l;``}``  ` `// Function to required count subarrays``static` `int``[] countingSubarray(``int``[] arr,``                              ``int` `n)``{``  ` `    ``// Stores the indices of element``    ``Map index = ``new` `HashMap<>();``    ``for``(``int` `i = ``0``; i < n; i++)``        ``index.put(arr[i], i);``  ` `    ``ArrayList boundary = ``new` `ArrayList<>();``    ``boundary.add(-``1``);``    ``boundary.add(n);` `    ``Arrays.sort(arr);` `    ``// Initialize the output array``    ``int``[] ans = ``new` `int``[n];``  ` `    ``for``(``int` `num : arr)``    ``{``        ``int` `i = binaryInsert(boundary,``                             ``index.get(num));``  ` `        ``// Left boundary, till the``        ``// element is smallest``        ``int` `l = boundary.get(i) -``                ``boundary.get(i - ``1``) - ``1``;``  ` `        ``// Right boundary, till the``        ``// element is smallest``        ``int` `r = boundary.get(i + ``1``) -``                ``boundary.get(i) - ``1``;``  ` `        ``// Calculate the number of subarrays``        ``// based on its boundary``        ``int` `cnt = l + r + l * r + ``1``;``  ` `        ``// Adding cnt to the ans``        ``ans[index.get(num)] += cnt;``    ``}``    ``return` `ans;``}``  ` `// Driver code``public` `static` `void` `main (String[] args)``{``    ``int` `N = ``5``;``      ` `    ``// Given array arr[]``    ``int``[] arr = { ``3``, ``2``, ``4``, ``1``, ``5` `};``      ` `    ``// Function call``    ``int``[] a = countingSubarray(arr, N);``      ` `    ``System.out.print(``"["``);``    ``int` `n = a.length - ``1``;``    ``for``(``int` `i = ``0``; i < n; i++) ``        ``System.out.print(a[i] + ``", "``);``          ` `    ``System.out.print(a[n] + ``"]"``);``}``}` `// This code is contributed by offbeat`

## Python3

 `# Python3 program for the above approach` `# Function to find the boundary of every``# element within which it is minimum``def` `binaryInsert(boundary, i):` `    ``l ``=` `0``    ``r ``=` `len``(boundary) ``-` `1` `    ``# Perform Binary Search``    ``while` `l <``=` `r:``        ` `        ``# Find mid m``        ``m ``=` `(l ``+` `r) ``/``/` `2``        ` `        ``# Update l``        ``if` `boundary[m] < i:``            ``l ``=` `m ``+` `1``            ` `        ``# Update r``        ``else``:``            ``r ``=` `m ``-` `1` `    ``# Inserting the index``    ``boundary.insert(l, i)` `    ``return` `l` `# Function to required count subarrays``def` `countingSubarray(arr, n):` `    ``# Stores the indices of element``    ``index ``=` `{}` `    ``for` `i ``in` `range``(n):``        ``index[arr[i]] ``=` `i` `    ``boundary ``=` `[``-``1``, n]``    ``arr.sort()` `    ``# Initialize the output array``    ``ans ``=` `[``0` `for` `i ``in` `range``(n)]` `    ``for` `num ``in` `arr:``        ``i ``=` `binaryInsert(boundary, index[num])` `        ``# Left boundary, till the``        ``# element is smallest``        ``l ``=` `boundary[i] ``-` `boundary[i ``-` `1``] ``-` `1` `        ``# Right boundary, till the``        ``# element is smallest``        ``r ``=` `boundary[i ``+` `1``] ``-` `boundary[i] ``-` `1` `        ``# Calculate the number of subarrays``        ``# based on its boundary``        ``cnt ``=` `l ``+` `r ``+` `l ``*` `r ``+` `1` `        ``# Adding cnt to the ans``        ``ans[index[num]] ``+``=` `cnt` `    ``return` `ans`  `# Driver Code` `N ``=` `5` `# Given array arr[]``arr ``=` `[``3``, ``2``, ``4``, ``1``, ``5``]` `# Function Call``print``(countingSubarray(arr, N))`

## C#

 `// C# program for``// the above approach``using` `System;``using` `System.Collections;``using` `System.Collections.Generic;``class` `GFG{``   ` `// Function to find the``// boundary of every element``// within which it is minimum``static` `int` `binaryInsert(ArrayList boundary,``                        ``int` `i)``{``  ``int` `l = 0;``  ``int` `r = boundary.Count - 1;` `  ``// Perform Binary Search``  ``while` `(l <= r)``  ``{``    ``// Find mid m``    ``int` `m = (l + r) / 2;` `    ``// Update l``    ``if` `((``int``)boundary[m] < i)``      ``l = m + 1;` `    ``// Update r``    ``else``      ``r = m - 1;``  ``}` `  ``// Inserting the index``  ``boundary.Insert(l, i);` `  ``return` `l;``}``   ` `// Function to required count subarrays``static` `int``[] countingSubarray(``int``[] arr,``                              ``int` `n)``{``  ``// Stores the indices of element``  ``Dictionary<``int``,``             ``int``> index = ``new` `Dictionary<``int``,``                                         ``int``>();``  ``for``(``int` `i = 0; i < n; i++)``    ``index[arr[i]] = i;` `  ``ArrayList boundary = ``new` `ArrayList();``  ``boundary.Add(-1);``  ``boundary.Add(n);``  ``Array.Sort(arr);` `  ``// Initialize the output array``  ``int``[] ans = ``new` `int``[n];` `  ``foreach``(``int` `num ``in` `arr)``  ``{``    ``int` `i = binaryInsert(boundary,``                         ``index[num]);` `    ``// Left boundary, till the``    ``// element is smallest``    ``int` `l = (``int``)boundary[i] -``            ``(``int``)boundary[i - 1] - 1;` `    ``// Right boundary, till the``    ``// element is smallest``    ``int` `r = (``int``)boundary[i + 1] -``            ``(``int``)boundary[i] - 1;` `    ``// Calculate the number of ``    ``// subarrays based on its boundary``    ``int` `cnt = l + r + l * r + 1;` `    ``// Adding cnt to the ans``    ``ans[index[num]] += cnt;``  ``}``  ``return` `ans;``}``   ` `// Driver code``public` `static` `void` `Main(``string``[] args)``{``    ``int` `N = 5;``       ` `    ``// Given array arr[]``    ``int``[] arr = {3, 2, 4, 1, 5};``       ` `    ``// Function call``    ``int``[] a = countingSubarray(arr, N);``       ` `    ``Console.Write(``"["``);``    ``int` `n = a.Length - 1;``    ``for``(``int` `i = 0; i < n; i++) ``        ``Console.Write(a[i] + ``", "``);``           ` `    ``Console.Write(a[n] + ``"]"``);``}``}` `// This code is contributed by Rutvik_56`

## Javascript

 ``

Output

`[1, 4, 1, 8, 1]`

Time Complexity: O(N log N)
Auxiliary Space: O(N)

Most efficient approach:

To optimize the above approach we can use a Stack Data Structure.

1. Idea is that, For each (1â‰¤ i â‰¤ N) we will try to find index(R) of next smaller element right to it  and index(L) of next smaller element left to it.
2. Now we have our boundary index(L,R) in which arr[i] is minimum so total number of subarrays for each i(0-base) will be (R-i)*(i-L) .

Below is the implementation of the idea:

## C++14

 `// C++ implementation of the above approach``#include ``using` `namespace` `std;` `// Function to required count subarrays``vector<``int``> countingSubarray(vector<``int``> arr, ``int` `n)``{``    ``// For storing count of subarrays``    ``vector<``int``> a(n);``    ` `    ``// For finding next smaller``    ``// element left to a element``    ``// if there is no next smaller``    ``// element left to it than taking -1.``    ``vector<``int``> nsml(n, -1);``    ` `    ``// For finding next smaller``    ``// element right to a element``    ``// if there is no next smaller``    ``// element right to it than taking n.``    ``vector<``int``> nsmr(n, n);` `    ``stack<``int``> st;``    ``for` `(``int` `i = n - 1; i >= 0; i--)``    ``{``        ``while` `(!st.empty() && arr[st.top()] >= arr[i])``            ``st.pop();``        ``nsmr[i] = (!st.empty()) ? st.top() : n;``        ``st.push(i);``    ``}``    ``while` `(!st.empty())``        ``st.pop();` `    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``while` `(!st.empty() && arr[st.top()] >= arr[i])``            ``st.pop();``        ``nsml[i] = (!st.empty()) ? st.top() : -1;``        ``st.push(i);``    ``}` `    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``// Taking exact boundaries``        ``// in which arr[i] is``        ``// minimum``        ``nsml[i]++;``        ` `        ``// Similarly for right side``        ``nsmr[i]--;``        ``int` `r = nsmr[i] - i + 1;``        ``int` `l = i - nsml[i] + 1;``        ``a[i] = r * l;``    ``}` `    ``return` `a;``}` `// Driver Code``int` `main()``{` `    ``int` `N = 5;` `    ``// Given array arr[]``    ``vector<``int``> arr = { 3, 2, 4, 1, 5 };` `    ``// Function call``    ``auto` `a = countingSubarray(arr, N);` `    ``cout << ``"["``;``    ``int` `n = a.size() - 1;``    ``for` `(``int` `i = 0; i < n; i++)``        ``cout << a[i] << ``", "``;` `    ``cout << a[n] << ``"]"``;` `    ``return` `0;``}`

## Java

 `// Java implementation of the above approach``import` `java.util.*;``public` `class` `gfg``{``  ``// Function to required count subarrays``  ``static` `int``[] countingSubarray(``int` `arr[], ``int` `n)``  ``{` `    ``// For storing count of subarrays``    ``int` `a[] = ``new` `int``[n];` `    ``// For finding next smaller``    ``// element left to a element``    ``// if there is no next smaller``    ``// element left to it than taking -1.``    ``int` `nsml[] = ``new` `int``[n];``    ``Arrays.fill(nsml, -``1``);` `    ``// For finding next smaller``    ``// element right to a element``    ``// if there is no next smaller``    ``// element right to it than taking n.``    ``int` `nsmr[] = ``new` `int``[n];``    ``Arrays.fill(nsmr, n);` `    ``Stack st = ``new` `Stack();``    ``for``(``int` `i = n - ``1``; i >= ``0``; i--)``    ``{``      ``while` `(st.size() > ``0` `&&``             ``arr[(``int``)st.peek()] >= arr[i])``        ``st.pop();` `      ``nsmr[i] = (st.size() > ``0``) ? (``int``)st.peek() : n;``      ``st.push(i);``    ``}``    ``while` `(st.size() > ``0``)``      ``st.pop();   ``    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``      ``while` `(st.size() > ``0` `&&``             ``arr[(``int``)st.peek()] >= arr[i])``        ``st.pop();``      ``nsml[i] = (st.size() > ``0``) ? (``int``)st.peek() : -``1``;``      ``st.push(i);``    ``}``    ``for``(``int` `i = ``0``; i < n; i++)``    ``{` `      ``// Taking exact boundaries``      ``// in which arr[i] is``      ``// minimum``      ``nsml[i]++;` `      ``// Similarly for right side``      ``nsmr[i]--;``      ``int` `r = nsmr[i] - i + ``1``;``      ``int` `l = i - nsml[i] + ``1``;``      ``a[i] = r * l;``    ``}``    ``return` `a;``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `N = ``5``;` `    ``// Given array arr[]``    ``int` `arr[] = { ``3``, ``2``, ``4``, ``1``, ``5` `};` `    ``// Function call``    ``int` `a[] = countingSubarray(arr, N);``    ``System.out.print(``"["``);``    ``int` `n = a.length - ``1``;``    ``for``(``int` `i = ``0``; i < n; i++)``      ``System.out.print(a[i] + ``", "``);``    ``System.out.print(a[n] + ``"]"``);``  ``}``}` `// This code is contributed by divyesh072019.`

## Python3

 `# Python implementation of the above approach` `# Function to required count subarrays``def` `countingSubarray(arr, n):``  ` `    ``# For storing count of subarrays``    ``a ``=` `[``0` `for` `i ``in` `range``(n)]``    ` `    ``# For finding next smaller``    ``# element left to a element``    ``# if there is no next smaller``    ``# element left to it than taking -1.``    ``nsml ``=` `[``-``1` `for` `i ``in` `range``(n)]``    ` `    ``# For finding next smaller``    ``# element right to a element``    ``# if there is no next smaller``    ``# element right to it than taking n.``    ``nsmr ``=` `[n ``for` `i ``in` `range``(n)]``    ``st ``=` `[]``    ``for` `i ``in` `range``(n ``-` `1``, ``-``1``, ``-``1``):``        ``while``(``len``(st) > ``0` `and` `arr[st[``-``1``]] >``=` `arr[i]):``            ``del` `st[``-``1``]``        ``if``(``len``(st) > ``0``):``            ``nsmr[i] ``=` `st[``-``1``]``        ``else``:``            ``nsmr[i] ``=` `n``        ``st.append(i)``    ``while``(``len``(st) > ``0``):``        ``del` `st[``-``1``]``    ` `    ``for` `i ``in` `range``(n):``        ``while``(``len``(st) > ``0` `and` `arr[st[``-``1``]] >``=` `arr[i]):``            ``del` `st[``-``1``]``        ` `        ``if``(``len``(st) > ``0``):``            ``nsml[i] ``=` `st[``-``1``]``        ``else``:``            ``nsml[i] ``=` `-``1``        ``st.append(i)``    ` `    ``for` `i ``in` `range``(n):``        ` `        ``# Taking exact boundaries``        ``# in which arr[i] is``        ``# minimum``        ``nsml[i] ``+``=` `1``        ` `        ``# Similarly for right side``        ``nsmr[i] ``-``=` `1``        ``r ``=` `nsmr[i] ``-` `i ``+` `1``;``        ``l ``=` `i ``-` `nsml[i] ``+` `1``;``        ``a[i] ``=` `r ``*` `l;  ``    ``return` `a;` `# Driver code``N ``=` `5` `# Given array arr[]``arr ``=` `[``3``, ``2``, ``4``, ``1``, ``5` `]` `# Function call``a ``=` `countingSubarray(arr, N)``print``(a)` `# This code is contributed by rag2127`

## C#

 `// C# implementation of the above approach``using` `System;``using` `System.Collections;` `class` `GFG{``    ` `// Function to required count subarrays``static` `int``[] countingSubarray(``int``[] arr, ``int` `n)``{``    ` `    ``// For storing count of subarrays``    ``int``[] a = ``new` `int``[n];``    ` `    ``// For finding next smaller``    ``// element left to a element``    ``// if there is no next smaller``    ``// element left to it than taking -1.``    ``int``[] nsml = ``new` `int``[n];``    ``Array.Fill(nsml, -1);``    ` `    ``// For finding next smaller``    ``// element right to a element``    ``// if there is no next smaller``    ``// element right to it than taking n.``    ``int``[] nsmr = ``new` `int``[n];``    ``Array.Fill(nsmr, n);`` ` `    ``Stack st = ``new` `Stack();``    ``for``(``int` `i = n - 1; i >= 0; i--)``    ``{``        ``while` `(st.Count > 0 &&``               ``arr[(``int``)st.Peek()] >= arr[i])``            ``st.Pop();``            ` `        ``nsmr[i] = (st.Count > 0) ? (``int``)st.Peek() : n;``        ``st.Push(i);``    ``}``    ``while` `(st.Count > 0)``        ``st.Pop();`` ` `    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``while` `(st.Count > 0 &&``               ``arr[(``int``)st.Peek()] >= arr[i])``            ``st.Pop();``            ` `        ``nsml[i] = (st.Count > 0) ? (``int``)st.Peek() : -1;``        ``st.Push(i);``    ``}`` ` `    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ` `        ``// Taking exact boundaries``        ``// in which arr[i] is``        ``// minimum``        ``nsml[i]++;``         ` `        ``// Similarly for right side``        ``nsmr[i]--;``        ``int` `r = nsmr[i] - i + 1;``        ``int` `l = i - nsml[i] + 1;``        ``a[i] = r * l;``    ``}``    ``return` `a;``}` `// Driver code``static` `void` `Main()``{``    ``int` `N = 5;``    ` `    ``// Given array arr[]``    ``int``[] arr = { 3, 2, 4, 1, 5 };``    ` `    ``// Function call``    ``int``[] a = countingSubarray(arr, N);``    ` `    ``Console.Write(``"["``);``    ``int` `n = a.Length - 1;``    ` `    ``for``(``int` `i = 0; i < n; i++)``        ``Console.Write(a[i] + ``", "``);``    ` `    ``Console.Write(a[n] + ``"]"``);``}``}` `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``

Output

`[1, 4, 1, 8, 1]`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up