# Maximize Sum possible by subtracting same value from all elements of a Subarray of the given Array

Given an array a[] consisting of N integers, the task is to find the maximum possible sum that can be achieved by deducting any value, say X, from all elements of a subarray.

Examples:

Input: N = 3, a[] = {80, 48, 82}
Output: 144
Explanation:
48 can be deducted from each array element. Therefore, sum obtained = 48 * 3 = 144

Input: N = a[] = {8, 40, 77}
Output: 80
Explanation:
Subtracting 8 from all array elements generates sum 24.
Subtracting 40 from arr and arr generates sum 80.
Subtracting 77 from arr generates sum 77.
Therefore, maximum possible sum is 80.

Approach:
Follow the steps below to solve the problem:

• Traverse the array
• For every element, find the element which is nearest smaller on its left and nearest smaller on its right.
• Calculate the sum possible by that element calculating current_element * ( j – i – 1 ) where j and i are the indices of the nearest smaller numbers on the left and right respectively.
• Find the maximum possible sum among all of them.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement ` `// the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to generate previous smaller  ` `// element for each array element ` `vector<``int``> findPrevious(vector<``int``> a, ``int` `n) ` `{ ` `    ``vector<``int``> ps(n); ` ` `  `    ``// The first element has no ` `    ``// previous smaller ` `    ``ps = -1; ` ` `  `    ``// Stack to keep track of elements ` `    ``// that have occurred previously ` `    ``stack<``int``> Stack; ` ` `  `    ``// Push the first index ` `    ``Stack.push(0); ` `     `  `    ``for``(``int` `i = 1; i < n; i++) ` `    ``{ ` `         `  `        ``// Pop all the elements until the previous ` `        ``// element is smaller than current element ` `        ``while` `(Stack.size() > 0 &&  ` `             ``a[Stack.top()] >= a[i]) ` `            ``Stack.pop(); ` ` `  `        ``// Store the previous smaller element ` `        ``ps[i] = Stack.size() > 0 ?  ` `                ``Stack.top() : -1; ` ` `  `        ``// Push the index of the current element ` `        ``Stack.push(i); ` `    ``} ` ` `  `    ``// Return the array ` `    ``return` `ps; ` `} ` ` `  `// Function to generate next smaller element ` `// for each array element ` `vector<``int``> findNext(vector<``int``> a, ``int` `n) ` `{ ` `    ``vector<``int``> ns(n); ` ` `  `    ``ns[n - 1] = n; ` ` `  `    ``// Stack to keep track of elements ` `    ``// that have occurring next ` `    ``stack<``int``> Stack; ` `    ``Stack.push(n - 1); ` ` `  `    ``// Iterate in reverse order ` `    ``// for calculating next smaller ` `    ``for``(``int` `i = n - 2; i >= 0; i--) ` `    ``{ ` `         `  `        ``// Pop all the elements until the ` `        ``// next element is smaller ` `        ``// than current element ` `        ``while` `(Stack.size() > 0 &&  ` `             ``a[Stack.top()] >= a[i]) ` `            ``Stack.pop(); ` ` `  `        ``// Store the next smaller element ` `        ``ns[i] = Stack.size() > 0 ?  ` `                ``Stack.top() : n; ` ` `  `        ``// Push the index of the current element ` `        ``Stack.push(i); ` `    ``} ` ` `  `    ``// Return the array ` `    ``return` `ns; ` `} ` ` `  `// Function to find the maximum sum by ` `// subtracting same value from all ` `// elements of a Subarray ` `int` `findMaximumSum(vector<``int``> a, ``int` `n) ` `{ ` `     `  `    ``// Stores previous smaller element ` `    ``vector<``int``> prev_smaller = findPrevious(a, n); ` ` `  `    ``// Stores next smaller element ` `    ``vector<``int``> next_smaller = findNext(a, n); ` ` `  `    ``int` `max_value = 0; ` `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{ ` `         `  `        ``// Calculate contribution ` `        ``// of each element ` `        ``max_value = max(max_value, a[i] *  ` `                       ``(next_smaller[i] -  ` `                        ``prev_smaller[i] - 1)); ` `    ``} ` ` `  `    ``// Return answer ` `    ``return` `max_value; ` `} ` ` `  `// Driver Code     ` `int` `main() ` `{ ` `    ``int` `n = 3; ` `    ``vector<``int``> a{ 80, 48, 82 }; ` `     `  `    ``cout << findMaximumSum(a, n); ` `     `  `    ``return` `0; ` `} ` ` `  `// This code is contributed by divyeshrabadiya07 `

## Java

 `// Java Program to implement ` `// the above approach ` `import` `java.util.*; ` ` `  `public` `class` `GFG { ` ` `  `    ``// Function to find the maximum sum by ` `    ``// subtracting same value from all ` `    ``// elements of a Subarray ` `    ``public` `static` `int` `findMaximumSum(``int``[] a, ``int` `n) ` `    ``{ ` `        ``// Stores previous smaller element ` `        ``int` `prev_smaller[] = findPrevious(a, n); ` ` `  `        ``// Stores next smaller element ` `        ``int` `next_smaller[] = findNext(a, n); ` ` `  `        ``int` `max_value = ``0``; ` `        ``for` `(``int` `i = ``0``; i < n; i++) { ` ` `  `            ``// Calculate contribution ` `            ``// of each element ` `            ``max_value ` `                ``= Math.max(max_value, ` `                        ``a[i] * (next_smaller[i] ` `                                ``- prev_smaller[i] - ``1``)); ` `        ``} ` ` `  `        ``// Return answer ` `        ``return` `max_value; ` `    ``} ` ` `  `    ``// Function to generate previous smaller element ` `    ``// for each array element ` `    ``public` `static` `int``[] findPrevious(``int``[] a, ``int` `n) ` `    ``{ ` `        ``int` `ps[] = ``new` `int``[n]; ` ` `  `        ``// The first element has no ` `        ``// previous smaller ` `        ``ps[``0``] = -``1``; ` ` `  `        ``// Stack to keep track of elements ` `        ``// that have occurred previously ` `        ``Stack stack = ``new` `Stack<>(); ` ` `  `        ``// Push the first index ` `        ``stack.push(``0``); ` `        ``for` `(``int` `i = ``1``; i < a.length; i++) { ` ` `  `            ``// Pop all the elements until the previous ` `            ``// element is smaller than current element ` `            ``while` `(stack.size() > ``0` `                ``&& a[stack.peek()] >= a[i]) ` `                ``stack.pop(); ` ` `  `            ``// Store the previous smaller element ` `            ``ps[i] = stack.size() > ``0` `? stack.peek() : -``1``; ` ` `  `            ``// Push the index of the current element ` `            ``stack.push(i); ` `        ``} ` ` `  `        ``// Return the array ` `        ``return` `ps; ` `    ``} ` ` `  `    ``// Function to generate next smaller element ` `    ``// for each array element ` `    ``public` `static` `int``[] findNext(``int``[] a, ``int` `n) ` `    ``{ ` `        ``int` `ns[] = ``new` `int``[n]; ` ` `  `        ``ns[n - ``1``] = n; ` ` `  `        ``// Stack to keep track of elements ` `        ``// that have occurring next ` `        ``Stack stack = ``new` `Stack<>(); ` `        ``stack.push(n - ``1``); ` ` `  `        ``// Iterate in reverse order ` `        ``// for calculating next smaller ` `        ``for` `(``int` `i = n - ``2``; i >= ``0``; i--) { ` ` `  `            ``// Pop all the elements until the ` `            ``// next element is smaller ` `            ``// than current element ` `            ``while` `(stack.size() > ``0` `                ``&& a[stack.peek()] >= a[i]) ` `                ``stack.pop(); ` ` `  `            ``// Store the next smaller element ` `            ``ns[i] = stack.size() > ``0` `? stack.peek() ` `                                    ``: a.length; ` ` `  `            ``// Push the index of the current element ` `            ``stack.push(i); ` `        ``} ` ` `  `        ``// Return the array ` `        ``return` `ns; ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `n = ``3``; ` `        ``int` `a[] = { ``80``, ``48``, ``82` `}; ` `        ``System.out.println(findMaximumSum(a, n)); ` `    ``} ` `} `

## Python3

 `# Python3 program to implement  ` `# the above approach  ` ` `  `# Function to find the maximum sum by  ` `# subtracting same value from all  ` `# elements of a Subarray  ` `def` `findMaximumSum(a, n): ` `     `  `    ``# Stores previous smaller element  ` `    ``prev_smaller ``=` `findPrevious(a, n) ` `     `  `    ``# Stores next smaller element ` `    ``next_smaller ``=` `findNext(a, n) ` `     `  `    ``max_value ``=` `0` `    ``for` `i ``in` `range``(n): ` `         `  `        ``# Calculate contribution  ` `        ``# of each element  ` `        ``max_value ``=` `max``(max_value, a[i] ``*` `                    ``(next_smaller[i] ``-` `                        ``prev_smaller[i] ``-` `1``)) ` `         `  `    ``# Return answer ` `    ``return` `max_value ` ` `  `# Function to generate previous smaller  ` `# element for each array element  ` `def` `findPrevious(a, n): ` `     `  `    ``ps ``=` `[``0``] ``*` `n ` `     `  `    ``# The first element has no  ` `    ``# previous smaller  ` `    ``ps[``0``] ``=` `-``1` `     `  `    ``# Stack to keep track of elements  ` `    ``# that have occurred previously  ` `    ``stack ``=` `[] ` `     `  `    ``# Push the first index ` `    ``stack.append(``0``) ` `     `  `    ``for` `i ``in` `range``(``1``, n): ` `         `  `        ``# Pop all the elements until the previous  ` `        ``# element is smaller than current element  ` `        ``while` `len``(stack) > ``0` `and` `a[stack[``-``1``]] >``=` `a[i]: ` `            ``stack.pop() ` `             `  `        ``# Store the previous smaller element  ` `        ``ps[i] ``=` `stack[``-``1``] ``if` `len``(stack) > ``0` `else` `-``1` `         `  `        ``# Push the index of the current element ` `        ``stack.append(i) ` `         `  `    ``# Return the array  ` `    ``return` `ps ` ` `  `# Function to generate next smaller  ` `# element for each array element  ` `def` `findNext(a, n): ` `     `  `    ``ns ``=` `[``0``] ``*` `n ` `    ``ns[n ``-` `1``] ``=` `n ` `     `  `    ``# Stack to keep track of elements  ` `    ``# that have occurring next  ` `    ``stack ``=` `[] ` `    ``stack.append(n ``-` `1``) ` `     `  `    ``# Iterate in reverse order  ` `    ``# for calculating next smaller ` `    ``for` `i ``in` `range``(n ``-` `2``, ``-``1``, ``-``1``): ` `         `  `        ``# Pop all the elements until the  ` `        ``# next element is smaller  ` `        ``# than current element  ` `        ``while` `(``len``(stack) > ``0` `and` `                ``a[stack[``-``1``]] >``=` `a[i]): ` `            ``stack.pop() ` `         `  `        ``# Store the next smaller element  ` `        ``ns[i] ``=` `stack[``-``1``] ``if` `len``(stack) > ``0` `else` `n ` `         `  `        ``# Push the index of the current element ` `        ``stack.append(i) ` `         `  `    ``# Return the array ` `    ``return` `ns ` ` `  `# Driver code ` `n ``=` `3` `a ``=` `[ ``80``, ``48``, ``82` `] ` ` `  `print``(findMaximumSum(a, n)) ` ` `  `# This code is contributed by Stuti Pathak `

## C#

 `// C# Program to implement ` `// the above approach ` `using` `System; ` `using` `System.Collections.Generic; ` `class` `GFG{ ` ` `  `// Function to find the maximum sum by ` `// subtracting same value from all ` `// elements of a Subarray ` `public` `static` `int` `findMaximumSum(``int``[] a, ``int` `n) ` `{ ` `    ``// Stores previous smaller element ` `    ``int` `[]prev_smaller = findPrevious(a, n); ` ` `  `    ``// Stores next smaller element ` `    ``int` `[]next_smaller = findNext(a, n); ` ` `  `    ``int` `max_value = 0; ` `    ``for` `(``int` `i = 0; i < n; i++) ` `    ``{ ` ` `  `    ``// Calculate contribution ` `    ``// of each element ` `    ``max_value = Math.Max(max_value, ` `                ``a[i] * (next_smaller[i] -  ` `                        ``prev_smaller[i] - 1)); ` `    ``} ` ` `  `    ``// Return answer ` `    ``return` `max_value; ` `} ` ` `  `// Function to generate previous smaller element ` `// for each array element ` `public` `static` `int``[] findPrevious(``int``[] a, ``int` `n) ` `{ ` `    ``int` `[]ps = ``new` `int``[n]; ` ` `  `    ``// The first element has no ` `    ``// previous smaller ` `    ``ps = -1; ` ` `  `    ``// Stack to keep track of elements ` `    ``// that have occurred previously ` `    ``Stack<``int``> stack = ``new` `Stack<``int``>(); ` ` `  `    ``// Push the first index ` `    ``stack.Push(0); ` `    ``for` `(``int` `i = 1; i < a.Length; i++) ` `    ``{ ` ` `  `    ``// Pop all the elements until the previous ` `    ``// element is smaller than current element ` `    ``while` `(stack.Count > 0 &&  ` `            ``a[stack.Peek()] >= a[i]) ` `        ``stack.Pop(); ` ` `  `    ``// Store the previous smaller element ` `    ``ps[i] = stack.Count > 0 ? stack.Peek() : -1; ` ` `  `    ``// Push the index of the current element ` `    ``stack.Push(i); ` `    ``} ` ` `  `    ``// Return the array ` `    ``return` `ps; ` `} ` ` `  `// Function to generate next smaller element ` `// for each array element ` `public` `static` `int``[] findNext(``int``[] a, ``int` `n) ` `{ ` `    ``int` `[]ns = ``new` `int``[n]; ` ` `  `    ``ns[n - 1] = n; ` ` `  `    ``// Stack to keep track of elements ` `    ``// that have occurring next ` `    ``Stack<``int``> stack = ``new` `Stack<``int``>(); ` `    ``stack.Push(n - 1); ` ` `  `    ``// Iterate in reverse order ` `    ``// for calculating next smaller ` `    ``for` `(``int` `i = n - 2; i >= 0; i--)  ` `    ``{ ` ` `  `    ``// Pop all the elements until the ` `    ``// next element is smaller ` `    ``// than current element ` `    ``while` `(stack.Count > 0 &&  ` `            ``a[stack.Peek()] >= a[i]) ` `        ``stack.Pop(); ` ` `  `    ``// Store the next smaller element ` `    ``ns[i] = stack.Count > 0 ? stack.Peek() ` `        ``: a.Length; ` ` `  `    ``// Push the index of the current element ` `    ``stack.Push(i); ` `    ``} ` ` `  `    ``// Return the array ` `    ``return` `ns; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String []args) ` `{ ` `    ``int` `n = 3; ` `    ``int` `[]a = { 80, 48, 82 }; ` `    ``Console.WriteLine(findMaximumSum(a, n)); ` `} ` `} ` ` `  `// This code is contributed by Amit Katiyar `

Output:

```144
```

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.