GFG App
Open App
Browser
Continue

# Maximum sum of smallest and second smallest in an array

#### Examples:

```Input : arr[] = [4, 3, 1, 5, 6]
Output : 11
Subarrays with smallest and second smallest are,
[4, 3]        smallest = 3    second smallest = 4
[4, 3, 1]    smallest = 1    second smallest = 3
[4, 3, 1, 5]    smallest = 1    second smallest = 3
[4, 3, 1, 5, 6]    smallest = 1    second smallest = 3
[3, 1]         smallest = 1    second smallest = 3
[3, 1, 5]     smallest = 1    second smallest = 3
[3, 1, 5, 6]    smallest = 1    second smallest = 3
[1, 5]        smallest = 1    second smallest = 5
[1, 5, 6]    smallest = 1    second smallest = 5
[5, 6]         smallest = 5    second smallest = 6
Maximum sum among all above choices is, 5 + 6 = 11

Input : arr[] =  {5, 4, 3, 1, 6}
Output : 9```
Recommended Practice

Brute Force Approach:

The brute force approach to solve this problem is to generate all subarrays of size >= 2 and calculate the sum of the smallest and second smallest elements for each subarray. Finally, we return the maximum sum obtained among all subarrays.

Below is the implementation of the above approach:

## C++

 `#include ` `#include ` `using` `namespace` `std;`   `/* Method returns maximum obtainable sum value` `   ``of smallest and the second smallest value` `   ``taken over all possible subarrays */` `int` `pairWithMaxSum(``int` `arr[], ``int` `N)` `{` `    ``int` `maxSum = INT_MIN;` `    `  `    ``// Generate all subarrays of size >= 2` `    ``for` `(``int` `i = 0; i < N - 1; i++)` `    ``{` `        ``for` `(``int` `j = i + 1; j < N; j++)` `        ``{` `            ``// Calculate the sum of the smallest and second smallest elements` `            ``int` `sum = arr[i] + arr[j];` `            `  `            ``// Check if the sum is greater than the current maximum sum` `            ``if` `(sum > maxSum)` `            ``{` `                ``maxSum = sum;` `            ``}` `        ``}` `    ``}` `    `  `    ``return` `maxSum;` `}`   `// Driver code to test above methods` `int` `main()` `{` `    ``int` `arr[] = {4, 3, 1, 5, 6};` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(``int``);`   `    ``cout << pairWithMaxSum(arr, N) << endl;` `    ``return` `0;` `}`

## Python3

 `# code` `import` `sys`   `# Method returns maximum obtainable sum value ` `# of smallest and the second smallest value ` `# taken over all possible subarrays` `def` `pairWithMaxSum(arr, N):` `    ``maxSum ``=` `-``sys.maxsize ``-` `1`   `    ``# Generate all subarrays of size >= 2` `    ``for` `i ``in` `range``(N ``-` `1``):` `        ``for` `j ``in` `range``(i ``+` `1``, N):` `            ``# Calculate the sum of the smallest and second smallest elements` `            ``sum` `=` `arr[i] ``+` `arr[j]`   `            ``# Check if the sum is greater than the current maximum sum` `            ``if` `sum` `> maxSum:` `                ``maxSum ``=` `sum`   `    ``return` `maxSum`   `# Driver code to test above method` `if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``4``, ``3``, ``1``, ``5``, ``6``]` `    ``N ``=` `len``(arr)`   `    ``print``(pairWithMaxSum(arr, N))`

## C#

 `using` `System;`   `public` `class` `Program` `{` `    ``/* Method returns maximum obtainable sum value` `       ``of smallest and the second smallest value` `       ``taken over all possible subarrays */` `    ``static` `int` `PairWithMaxSum(``int``[] arr, ``int` `N)` `    ``{` `        ``int` `maxSum = ``int``.MinValue;`   `        ``// Generate all subarrays of size >= 2` `        ``for` `(``int` `i = 0; i < N - 1; i++)` `        ``{` `            ``for` `(``int` `j = i + 1; j < N; j++)` `            ``{` `                ``// Calculate the sum of the smallest and second smallest elements` `                ``int` `sum = arr[i] + arr[j];`   `                ``// Check if the sum is greater than the current maximum sum` `                ``if` `(sum > maxSum)` `                ``{` `                    ``maxSum = sum;` `                ``}` `            ``}` `        ``}`   `        ``return` `maxSum;` `    ``}`   `    ``// Driver code to test above methods` `    ``public` `static` `void` `Main()` `    ``{` `        ``int``[] arr = { 4, 3, 1, 5, 6 };` `        ``int` `N = arr.Length;`   `        ``Console.WriteLine(PairWithMaxSum(arr, N));` `    ``}` `}`

## Javascript

 `/* Method returns maximum obtainable sum value` `   ``of smallest and the second smallest value` `   ``taken over all possible subarrays */` `function` `pairWithMaxSum(arr, N) {` `    ``let maxSum = Number.MIN_SAFE_INTEGER;` `    `  `    ``// Generate all subarrays of size >= 2` `    ``for` `(let i = 0; i < N - 1; i++) {` `        ``for` `(let j = i + 1; j < N; j++) {` `            ``// Calculate the sum of the smallest and second smallest elements` `            ``let sum = arr[i] + arr[j];` `            `  `            ``// Check if the sum is greater than the current maximum sum` `            ``if` `(sum > maxSum) {` `                ``maxSum = sum;` `            ``}` `        ``}` `    ``}` `    `  `    ``return` `maxSum;` `}`   `// Driver code to test above methods` `let arr = [4, 3, 1, 5, 6];` `let N = arr.length;`   `console.log(pairWithMaxSum(arr, N));`

Output

`11`

Time Complexity: O(N^2)

Auxiliary Space: O(1)

An efficient solution is based on the observation that this problem reduces to finding a maximum sum of two consecutive elements in array.

If (x,y) is the pair ,such that (x+y) is the answer , then x and y must be consecutive elements in the array.

#### Proof:

For a subarray with 2 elements , 1st and 2nd smallest elements are those 2 elements.

Now x and y are present in some subarray such thatthey are the endpoints.

Now, x, y must be the smallest 2 elements of that subarray. If there are other elements Z1 , Z2, ……., ZK  between x and y, they are greater than or equal to x and y,

#### Case1 :

• If there is one element z between x and y , then the smaller subarray with the elements max(x,y) and z , should be the answer , because max(x,y) + z >= x + y

#### Case2:

• If there are more than one elements between x and y , then the subarray within x and y will have all consecutive elements  (Zi + Zi+1) >= (x+y),  so (x,y) pair can’t be the answer.
• So, by contradictions, x and y must be consecutive elements in the array.

Implementation:

## CPP

 `// C++ program to get max sum with smallest` `// and second smallest element from any subarray` `#include ` `using` `namespace` `std;`   `/*  Method returns maximum obtainable sum value` `    ``of smallest and the second smallest value` `    ``taken over all possible subarrays */` `int` `pairWithMaxSum(``int` `arr[], ``int` `N)` `{` `   ``if` `(N < 2)` `     ``return` `-1;`   `   ``// Find two consecutive elements with maximum` `   ``// sum.` `   ``int` `res = arr[0] + arr[1];` `   ``for` `(``int` `i=1; i

## JAVA

 `// Java program to get max sum with smallest` `// and second smallest element from any subarray` `import` `java.lang.*;` `class` `num{`   `// Method returns maximum obtainable sum value` `// of smallest and the second smallest value` `// taken over all possible subarrays */` `static` `int` `pairWithMaxSum(``int``[] arr, ``int` `N)` `{` `if` `(N < ``2``)` `    ``return` `-``1``;`   `// Find two consecutive elements with maximum` `// sum.` `int` `res = arr[``0``] + arr[``1``];` `for` `(``int` `i=``1``; i

## Python3

 `# Python 3 program to get max ` `# sum with smallest and second` `# smallest element from any ` `# subarray`   `# Method returns maximum obtainable` `# sum value of smallest and the` `# second smallest value taken ` `# over all possible subarrays ` `def` `pairWithMaxSum(arr, N):`   `    ``if` `(N < ``2``):` `        ``return` `-``1` `    `  `    ``# Find two consecutive elements with` `    ``# maximum sum.` `    ``res ``=` `arr[``0``] ``+` `arr[``1``] ` `    `  `    ``for` `i ``in` `range``(``1``, N``-``1``):` `        ``res ``=` `max``(res, arr[i] ``+` `arr[i ``+` `1``]) ` `    `  `    ``return` `res ` `    `  `# Driver code` `arr ``=` `[``4``, ``3``, ``1``, ``5``, ``6``] ` `N ``=` `len``(arr)`   `print``(pairWithMaxSum(arr, N)) `   `# This code is contributed by Smitha Dinesh Semwal`

## C#

 `// C# program to get max sum with smallest` `// and second smallest element from any subarray` `using` `System;`   `class` `GFG {`   `// Method returns maximum obtainable sum value` `// of smallest and the second smallest value` `// taken over all possible subarrays ` `static` `int` `pairWithMaxSum(``int` `[]arr, ``int` `N)` `{` `    `  `if` `(N < 2)` `    ``return` `-1;`   `// Find two consecutive elements ` `// with maximum sum.` `int` `res = arr[0] + arr[1];` `for` `(``int` `i = 1; i < N - 1; i++)` `    ``res = Math.Max(res, arr[i] + arr[i + 1]);`   `return` `res;` `}`   `// Driver code` `public` `static` `void` `Main()` `{` `    ``int` `[]arr = {4, 3, 1, 5, 6};` `    ``int` `N = arr.Length;` `    ``Console.Write(pairWithMaxSum(arr, N));` `}` `}`   `// This code is contributed by Nitin Mittal.`

## PHP

 ``

## Javascript

 `// javascript program to get max sum with smallest` `// and second smallest element from any subarray` `  `  `// Method returns maximum obtainable sum value` `// of smallest and the second smallest value` `// taken over all possible subarrays `   `function` `pairWithMaxSum(arr,  N)` `{` `      `  `if` `(N < 2)` `    ``return` `-1;` `  `  `// Find two consecutive elements ` `// with maximum sum.`   `var` `res = arr[0] + arr[1];` `for` `(``var` `i = 1; i < N - 1; i++)` `    ``res = Math.max(res, arr[i] + arr[i + 1]);` `  `  `return` `res;` `}` `  `  `// Driver code`   `    ``var` `arr = [4, 3, 1, 5, 6]` `    ``var` `N = arr.length;` `    ``document.write(pairWithMaxSum(arr, N));`   `// This code is contributed by bunnyram19.`

Output

`11`

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

Thanks to Md Mishfaq Ahmed for suggesting this approach.
This article is contributed by Utkarsh Trivedi. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up