Open In App

Maximum sum of smallest and second smallest in an array

Improve
Improve
Like Article
Like
Save
Share
Report

Given an array, find maximum sum of smallest and second smallest elements chosen from all possible subarrays. More formally, if we write all (nC2) subarrays of array of size >=2 and find the sum of smallest and second smallest, then our answer will be maximum sum among them. 

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 <iostream>
#include <climits>
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;
}


Java




// Java code for above approach
import java.io.*;
  
public 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)
    {
        int maxSum = Integer.MIN_VALUE;
  
        // 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 (String[] args)
    {
        int[] arr = { 4, 3, 1, 5, 6 };
        int N = arr.length;
  
        System.out.println(PairWithMaxSum(arr, N));
    }
}
  
// This code is contributed by Vaibhav Nandan


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 <bits/stdc++.h>
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<N-1; i++)
      res = max(res, arr[i] + arr[i+1]);
  
   return res;
}
  
//  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;
}


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<N-1; i++)
    res = Math.max(res, arr[i] + arr[i+1]);
  
return res;
}
  
// Driver program
public static void main(String[] args)
{
    int arr[] = {4, 3, 1, 5, 6};
    int N = arr.length;
    System.out.println(pairWithMaxSum(arr, N));
}
}
//This code is contributed by
//Smitha Dinesh Semwal


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.


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.


PHP




<?php
// PHP 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.
    $res = $arr[0] + $arr[1];
    for($i = 1; $i < $N - 1; $i++)
        $res = max($res, $arr[$i] + 
                    $arr[$i + 1]);
      
    return $res;
}
  
    // Driver Code
    $arr = array(4, 3, 1, 5, 6);
    $N = count($arr);
  
    echo pairWithMaxSum($arr, $N);
  
// This code is contributed by anuj_67.
?>


Output

11

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

Thanks to Md Mishfaq Ahmed for suggesting this approach.
 



Last Updated : 19 Sep, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads