Given an array **arr[]**, the task is to find the sum of the minimum elements of every possible sub-array of the array.

**Examples:**

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

Output:15

All possible sub-arrays are {1}, {2}, {3}, {1, 3}, {3, 2} and {1, 3, 2}

And, the sum of all the minimum elements is 1 + 2 + 3 + 1 + 2 + 1 = 10

Input:arr[] = {3, 1}

Output:5

A **simple method** is to generate all the sub-arrays and then sum the minimum elements in all of them. The time complexity of this solution will be O(n^{3}).

**Better method:**

The key for optimization is the question-

In how many segments, the value at an index will be minimum?

The next idea that might come into our mind will be for every index **i** in the array **arr**, we try to find:

**Left count:** We iterate towards left of the index **i** till we don’t encounter an element **strictly lesser** than **arr[i]** or we don’t reach the left end of the array. Let us call this count for the index **i** of the given array as **CLi**.

**Right count:** We iterate towards right of the index till we don’t encounter an element **less than or equal to** the value at the index or we don’t reach the right end. Let us call this count for the index **i** of the given array as **CRi**.

**(CLi + 1) * (CRi + 1)** will be the number of sub-arrays for the current index **i** in which its value will be minimum because there are **CLi + 1** ways to choose elements from left side (including choosing no element) and **CRi + 1** ways to choose elements from the right side.

The time complexity of this approach will be O(n

^{2})

**Best method:**

This problem can be solved using stack data structure in **O(n)** time. The idea remains the same as is in the previous approach. For the sake of saving some time, we will use stack from the Standard Template Library of C++.

**Left count:** Let **CLi** represent the left count for an index **i**. **CLi** for an index **i** can be defined as the number of elements between the index **i** and the right most element whose value is strictly less than **arr[i]** having index less than **i**. If, there is no such element, then **CLi** for an element will be equal to the number of elements to the left of the index **i**.

To achieve this, we will insert only the index of the elements from left to right into the stack. Let us suppose, we are inserting an index **i** in the stack and **j** be the index of the topmost element currently present in the stack. While the value **arr[i]** is **less than or equal to** the value at the top most index in the stack and the stack is not empty, keep popping the elements in the stack. Whenever, an element is popped, the left count(CLi) of the current index(i) is updated as **CLi = CLi + CLj + 1**.

**Right count:** We calculate the right count for all the indexes in the similar way. The only difference is we push the elements in stack while traversing right to left in the array. While **arr[i]** is **strictly less** than the value at the top most index in the stack and the stack is not empty, keep popping the elements. Whenever, an element is popped, the right count of the current index(i) is updated as **CRi = CRi + CRj + 1**.

**Final step:** Let **ans** be the variable containing the final answer. We will initialize it with **0**. Then, we will iterate through all the indexes from **1** to **n** of the array and update the **ans** as **ans = ans + (CLi + 1) * (CRi + 1) * arr[i]** for all possible values of **i** from **1** to **n**.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach ` `#include <iostream> ` `#include <stack> ` `using` `namespace` `std; ` ` ` `// Function to return the required sum ` `int` `findMinSum(` `int` `arr[], ` `int` `n) ` `{ ` ` ` `// Arrays for maintaining left and right count ` ` ` `int` `CL[n] = { 0 }, CR[n] = { 0 }; ` ` ` ` ` `// Stack for storing the indexes ` ` ` `stack<` `int` `> q; ` ` ` ` ` `// Calculate left count for every index ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` `while` `(q.size() != 0 && arr[q.top()] >= arr[i]) { ` ` ` `CL[i] += CL[q.top()] + 1; ` ` ` `q.pop(); ` ` ` `} ` ` ` `q.push(i); ` ` ` `} ` ` ` ` ` `// Clear the stack ` ` ` `while` `(q.size() != 0) ` ` ` `q.pop(); ` ` ` ` ` `// Calculate right count for every index ` ` ` `for` `(` `int` `i = n - 1; i >= 0; i--) { ` ` ` `while` `(q.size() != 0 && arr[q.top()] > arr[i]) { ` ` ` `CR[i] += CR[q.top()] + 1; ` ` ` `q.pop(); ` ` ` `} ` ` ` `q.push(i); ` ` ` `} ` ` ` ` ` `// Clear the stack ` ` ` `while` `(q.size() != 0) ` ` ` `q.pop(); ` ` ` ` ` `// To store the required sum ` ` ` `int` `ans = 0; ` ` ` ` ` `// Calculate the final sum ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `ans += (CL[i] + 1) * (CR[i] + 1) * arr[i]; ` ` ` ` ` `return` `ans; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `arr[] = { 1, 3, 2 }; ` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]); ` ` ` `cout << findMinSum(arr, n); ` `} ` |

*chevron_right*

*filter_none*

## Python3

# Python3 implementation of the approach

# Function to return the required sum

def findMinSum(arr, n):

# Arrays for maintaining left and

# right count

CL = [0] * n

CR = [0] * n

# Stack for storing the indexes

q = []

# Calculate left count for every index

for i in range(0, n):

while (len(q) != 0 and

arr[q[-1]] >= arr[i]):

CL[i] += CL[q[-1]] + 1

q.pop()

q.append(i)

# Clear the stack

while len(q) != 0:

q.pop()

# Calculate right count for every index

for i in range(n – 1, -1, -1):

while (len(q) != 0 and

arr[q[-1]] > arr[i]):

CR[i] += CR[q[-1]] + 1

q.pop()

q.append(i)

# Clear the stack

while len(q) != 0:

q.pop()

# To store the required sum

ans = 0

# Calculate the final sum

for i in range(0, n):

ans += (CL[i] + 1) * (CR[i] + 1) * arr[i]

return ans

# Driver code

if __name__ == “__main__”:

arr = [1, 3, 2]

n = len(arr)

print(findMinSum(arr, n))

# This code is contributed by Rituraj Jain

**Output:**

10

**Time complexity:** O(n)

## Recommended Posts:

- Sum of minimum elements of all subarrays
- Sum of minimum difference between consecutive elements of an array
- Minimum number of operations on an array to make all elements 0
- Choose atleast two elements from array such that their GCD is 1 and cost is minimum
- Minimum array elements to be changed to make it a Lucas Sequence
- Print Minimum of all Subarrays using set in C++ STL
- Sum of Bitwise-OR of all subarrays of a given Array | Set 2
- Find elements of array using XOR of consecutive elements
- Minimum elements to be added so that two matrices can be multiplied
- Minimum number of moves to make all elements equal
- Sum of the minimum elements in all connected components of an undirected graph
- Minimum operations of given type to make all elements of a matrix equal
- Minimum number of adjacent swaps for arranging similar elements together
- Design a stack to retrieve original elements and return the minimum element in O(1) time and O(1) space
- Sum of elements from an array having even parity