Maximize difference between the Sum of the two halves of the Array after removal of N elements

• Difficulty Level : Hard
• Last Updated : 29 Dec, 2020

Given an integer N and array arr[] consisting of 3 * N integers, the task is to find the maximum difference between first half and second half of the array after the removal of exactly N elements from the array.

Examples:

Input: N = 2, arr[] = {3, 1, 4, 1, 5, 9}
Output: 1
Explanation:
Removal of arr and arr from the array maximizes the difference = (3 + 4) – (1 + 5) = 7 – 6 = 1.

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

Approach:
Follow the steps given below to solve the problem

• Traverse the array from the beginning and keep updating the sum of the largest N elements from the beginning of the array.
• Similarly, keep updating the sum of the smallest N elements from the end of the array.
• Traverse these sums and calculate the differences at each point and update the maximum difference obtained.
• Print the maximum difference obtained.

Below is the implementation of the above approach:

C++

 // C++ Program to implement// the above approach#include using namespace std; // Function to print the maximum difference// possible between the two halves of the arraylong long FindMaxDif(vector a, int m){    int n = m / 3;     vector l(m + 5), r(m + 5);     // Stores n maximum values from the start    multiset s;     for (int i = 1; i <= m; i++) {         // Insert first n elements        if (i <= n) {             // Update sum of largest n            // elements from left            l[i] = a[i - 1] + l[i - 1];            s.insert(a[i - 1]);        }         // For the remaining elements        else {            l[i] = l[i - 1];             // Obtain minimum value            // in the set            long long d = *s.begin();             // Insert only if it is greater            // than minimum value            if (a[i - 1] > d) {                 // Update sum from left                l[i] -= d;                l[i] += a[i - 1];                 // Remove the minimum                s.erase(s.find(d));                 // Insert the current element                s.insert(a[i - 1]);            }        }    }     // Clear the set    s.clear();     // Store n minimum elements from the end    for (int i = m; i >= 1; i--) {         // Insert the last n elements        if (i >= m - n + 1) {             // Update sum of smallest n            // elements from right            r[i] = a[i - 1] + r[i + 1];            s.insert(a[i - 1]);        }         // For the remaining elements        else {             r[i] = r[i + 1];             // Obtain the minimum            long long d = *s.rbegin();             // Insert only if it is smaller            // than maximum value            if (a[i - 1] < d) {                 // Update sum from right                r[i] -= d;                r[i] += a[i - 1];                 // Remove the minimum                s.erase(s.find(d));                 // Insert the new element                s.insert(a[i - 1]);            }        }    }     long long ans = -9e18L;     for (int i = n; i <= m - n; i++) {         // Compare the difference and        // store the maximum        ans = max(ans, l[i] - r[i + 1]);    }     // Return the maximum    // possible difference    return ans;} // Driver Codeint main(){     vector vtr = { 3, 1, 4, 1, 5, 9 };    int n = vtr.size();     cout << FindMaxDif(vtr, n);     return 0;}

Python3

 # Python3 Program to implement# the above approach # Function to print the maximum difference# possible between the two halves of the arraydef FindMaxDif(a, m) :     n = m // 3     l =  * (m + 5)    r =  * (m + 5)     # Stores n maximum values from the start    s = []     for i in range(1, m + 1) :         # Insert first n elements        if (i <= n) :             # Update sum of largest n            # elements from left            l[i] = a[i - 1] + l[i - 1]            s.append(a[i - 1])         # For the remaining elements        else :            l[i] = l[i - 1]             # Obtain minimum value            # in the set            s.sort()            d = s             # Insert only if it is greater            # than minimum value            if (a[i - 1] > d) :                 # Update sum from left                l[i] -= d                l[i] += a[i - 1]                 # Remove the minimum                s.remove(d)                 # Insert the current element                s.append(a[i - 1])     # Clear the set    s.clear()     # Store n minimum elements from the end    for i in range(m, 0, -1) :         # Insert the last n elements        if (i >= m - n + 1) :             # Update sum of smallest n            # elements from right            r[i] = a[i - 1] + r[i + 1]            s.append(a[i - 1])         # For the remaining elements        else :             r[i] = r[i + 1]            s.sort()                         # Obtain the minimum            d = s[-1]             # Insert only if it is smaller            # than maximum value            if (a[i - 1] < d) :                 # Update sum from right                r[i] -= d                r[i] += a[i - 1]                 # Remove the minimum                s.remove(d)                 # Insert the new element                s.append(a[i - 1])     ans = -9e18     for i in range(n, m - n + 1) :         # Compare the difference and        # store the maximum        ans = max(ans, l[i] - r[i + 1])     # Return the maximum    # possible difference    return ans # Driver code vtr = [ 3, 1, 4, 1, 5, 9 ]n = len(vtr) print(FindMaxDif(vtr, n)) # This code is contributed by divyesh072019

C#

 // C# program to implement// the above approachusing System;using System.Collections.Generic; class GFG{     // Function to print the maximum difference// possible between the two halves of the arraystatic long FindMaxDif(List a, int m){    int n = m / 3;         long[] l = new long[m + 5];    long[] r = new long[m + 5];       // Stores n maximum values from the start    List s = new List();       for(int i = 1; i <= m; i++)    {                 // Insert first n elements        if (i <= n)        {                         // Update sum of largest n            // elements from left            l[i] = a[i - 1] + l[i - 1];            s.Add(a[i - 1]);        }                 // For the remaining elements        else        {            l[i] = l[i - 1];                         s.Sort();                         // Obtain minimum value            // in the set            long d = s;               // Insert only if it is greater            // than minimum value            if (a[i - 1] > d)            {                                 // Update sum from left                l[i] -= d;                l[i] += a[i - 1];                   // Remove the minimum                s.Remove(d);                   // Insert the current element                s.Add(a[i - 1]);            }        }    }       // Clear the set    s.Clear();       // Store n minimum elements from the end    for(int i = m; i >= 1; i--)    {                 // Insert the last n elements        if (i >= m - n + 1)        {                         // Update sum of smallest n            // elements from right            r[i] = a[i - 1] + r[i + 1];            s.Add(a[i - 1]);        }           // For the remaining elements        else        {            r[i] = r[i + 1];                         s.Sort();                         // Obtain the minimum            long d = s[s.Count - 1];               // Insert only if it is smaller            // than maximum value            if (a[i - 1] < d)            {                                 // Update sum from right                r[i] -= d;                r[i] += a[i - 1];                   // Remove the minimum                s.Remove(d);                   // Insert the new element                s.Add(a[i - 1]);            }        }    }       long ans = (long)(-9e18);       for(int i = n; i <= m - n; i++)    {                 // Compare the difference and        // store the maximum        ans = Math.Max(ans, l[i] - r[i + 1]);    }       // Return the maximum    // possible difference    return ans;} // Driver Codestatic void Main(){    List vtr = new List(        new long[]{ 3, 1, 4, 1, 5, 9 });    int n = vtr.Count;         Console.Write(FindMaxDif(vtr, n));}} // This code is contributed by divyeshrabadiya07
Output:
1

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

My Personal Notes arrow_drop_up