Skip to content
Related Articles

Related Articles

Improve Article

Minimize the sum of pair which upon removing divides the Array into 3 subarrays

  • Last Updated : 16 Sep, 2021

Given an array arr of size N, the task is to find pair of elements having minimum sum, which on removal breaks the array into 3 non-empty subarrays of the original array. Print the sum of the elements in this pair.

Input: arr[]: {4, 2, 1, 2, 4}
Output: 4
Explanation:
Minimum sum pairs are values (2, 1) and (1, 2) but selecting a pair with adjacent indices won’t break the array into 3 parts. Next minimum value pair is (2, 2), which divides the array into {4}, {1}, {4}. Hence the answer is 2 + 2 = 4.

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = {5, 2, 4, 6, 3, 7}
Output: 5
Explanation:
Among all the pairs which break the array into 3 subparts, pair with values (2, 3) gives minimum sum.



 

Naive approach: To divide the array into three subarrays. Both elements which needs to be removed should follow these conditions:

  • any of the endpoints (index 0 and N-1) can’t be selected.
  • adjacent indices can’t be selected.

So, find all combinations of possible pairs and select the one which follows the above conditions and has the lowest sum of all.

Time Complexity: O(N2
Auxiliary space: O(N)

Efficient approach: Follow the below steps to solve this problem efficiently:

  1. Create an array prefixMin, in which ith element represents the minimum element from 0th to ith index in array arr.
  2. Create a variable ans, to store the final answer and initialise it with INT_MAX.
  3. Now, run a loop for i=3 to i=N-1 (starting from 3 as 0th can’t be selected and this loop is to select the second element of the pair, which means it even can’t be started from 2 because then the only remaining options for the first element are 1 & 2, which both don’t follow the given conditions) and in each iteration change ans to the minimum value out of ans and arr[i]+prefixMin[i-2].
  4. Print ans, after following the above steps.

Below is the implementation of the above approach:

C++




// C++ implementation of the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find minimum possible sum
// of pair which breaks the array into 3
// non-empty subarrays
int minSumPair(int arr[], int N)
{
 
    if (N < 5) {
        return -1;
    }
 
    int prefixMin[N];
    prefixMin[0] = arr[0];
 
    // prefixMin[i] contains minimum element till i
    for (int i = 1; i < N - 1; i++) {
        prefixMin[i] = min(arr[i], prefixMin[i - 1]);
    }
 
    int ans = INT_MAX;
 
    for (int i = 3; i < N - 1; i++) {
        ans = min(ans, arr[i] + prefixMin[i - 2]);
    }
 
    return ans;
}
 
// Driver Code
int main()
{
    // Given array
    int arr[] = { 5, 2, 4, 6, 3, 7 };
    int N = sizeof(arr) / sizeof(int);
 
    cout << minSumPair(arr, N) << endl;
 
    return 0;
}

Java




// Java implementation of the above approach
class GFG{
 
// Function to find minimum possible sum
// of pair which breaks the array into 3
// non-empty subarrays
static int minSumPair(int arr[], int N)
{
 
    if (N < 5) {
        return -1;
    }
 
    int []prefixMin = new int[N];
    prefixMin[0] = arr[0];
 
    // prefixMin[i] contains minimum element till i
    for (int i = 1; i < N - 1; i++) {
        prefixMin[i] = Math.min(arr[i], prefixMin[i - 1]);
    }
 
    int ans = Integer.MAX_VALUE;
 
    for (int i = 3; i < N - 1; i++) {
        ans = Math.min(ans, arr[i] + prefixMin[i - 2]);
    }
 
    return ans;
}
 
// Driver Code
public static void main(String[] args)
{
    // Given array
    int arr[] = { 5, 2, 4, 6, 3, 7 };
    int N = arr.length;
 
    System.out.print(minSumPair(arr, N) +"\n");
 
}
}
 
// This code is contributed by Princi Singh

Python3




# Python 3 implementation of the above approach
import sys
 
# Function to find minimum possible sum
# of pair which breaks the array into 3
# non-empty subarrays
def minSumPair(arr, N):
    if(N < 5):
        return -1
 
    prefixMin = [0 for i in range(N)]
    prefixMin[0] = arr[0]
 
    # prefixMin[i] contains minimum element till i
    for i in range(1,N - 1,1):
        prefixMin[i] = min(arr[i], prefixMin[i - 1])
 
    ans = sys.maxsize
 
    for i in range(3,N - 1,1):
        ans = min(ans, arr[i] + prefixMin[i - 2])
 
    return ans
 
# Driver Code
if __name__ == '__main__':
   
    # Given array
    arr = [5, 2, 4, 6, 3, 7]
    N = len(arr)
    print(minSumPair(arr, N))
     
    # This code is contributed by ipg201107.

C#




// C# implementation of the above approach
using System;
 
public class GFG{
 
// Function to find minimum possible sum
// of pair which breaks the array into 3
// non-empty subarrays
static int minSumPair(int []arr, int N)
{
 
    if (N < 5) {
        return -1;
    }
 
    int []prefixMin = new int[N];
    prefixMin[0] = arr[0];
 
    // prefixMin[i] contains minimum element till i
    for (int i = 1; i < N - 1; i++) {
        prefixMin[i] = Math.Min(arr[i], prefixMin[i - 1]);
    }
 
    int ans = int.MaxValue;
 
    for (int i = 3; i < N - 1; i++) {
        ans = Math.Min(ans, arr[i] + prefixMin[i - 2]);
    }
 
    return ans;
}
 
// Driver Code
public static void Main(String[] args)
{
   
    // Given array
    int []arr = { 5, 2, 4, 6, 3, 7 };
    int N = arr.Length;
 
    Console.Write(minSumPair(arr, N) +"\n");
 
}
}
 
// This code is contributed by shikhasingrajput

Javascript




<script>
        // JavaScript Program to implement
        // the above approach
 
        // Function to find minimum possible sum
        // of pair which breaks the array into 3
        // non-empty subarrays
        function minSumPair(arr, N) {
 
            if (N < 5) {
                return -1;
            }
 
            let prefixMin = new Array(N).fill(0);
            prefixMin[0] = arr[0];
 
            // prefixMin[i] contains minimum element till i
            for (let i = 1; i < N - 1; i++) {
                prefixMin[i] = Math.min(arr[i], prefixMin[i - 1]);
            }
 
            let ans = Number.MAX_VALUE;
 
            for (let i = 3; i < N - 1; i++) {
                ans = Math.min(ans, arr[i] + prefixMin[i - 2]);
            }
 
            return ans;
        }
 
        // Driver Code
 
        // Given array
        let arr = [5, 2, 4, 6, 3, 7];
        let N = arr.length;
 
        document.write(minSumPair(arr, N));
 
     // This code is contributed by Potta Lokesh
 
    </script>

 
 

Output
5

 

Time Complexity: O(n)

Space Complexity: O(n)

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :