Split array into K subsets to maximize their sum of maximums and minimums - GeeksforGeeks

24 Nov, 2021
Given an integer K and an array A[ ] whose length is multiple of K, the task is to split the elements of the given array into K subsets, each having an equal number of elements, such that the sum of the maximum and minimum elements of each subset is the maximum summation possible.
Examples: 
Input: K = 2, A[ ] = {1, 13, 7, 17, 6, 5} Output: 37 Explanation: 1st group: {1, 5, 17} maximum = 17, minimum = 1 2nd group: {6, 7, 13} maximum = 13, minimum = 6 Hence, maximum possible sum = 17 + 1 + 13 + 6 = 37
Input: K = 2, A[ ] = {10, 10, 10, 10, 11, 11} Output: 42 Explanation: 1st group: {11, 10, 10} maximum = 11, minimum = 10 2nd group: {11, 10, 10} maximum = 11, minimum = 10 Hence, maximum sum possible = 11 + 10 + 11 + 10 = 42
Naive Approach: The simplest approach to solve this problem is to generate all possible groups of K subsets of size N/K and for each group, find maximum and minimum in every subset and calculate their sum. Once the sum of all groups is calculated, print the maximum sum obtained. Time Complexity: O(2N) Auxiliary Space: O(N)
Efficient Approach: The idea is to optimize the above approach using the Greedy Technique. Since the maximum sum of the maximum and minimum element from each subset is needed, try to maximize the maximum element and minimum element. For the maximum element of each subset, take first K largest elements from the given array and insert each one to different subsets. For the minimum element of each subset, from the sorted array, starting from index 0, pick every next element at (N / K) – 1 interval since the size of each subset is N / K and each one already contains a maximum element.
Follow the steps below: 
Calculate the number of elements in each group i.e. (N/K).
Sort all the elements of A[ ] in non-descending order.
For the sum of maximum elements, add all K largest elements from the sorted array.
For the sum of minimum elements, starting from index 0, select K elements each with (N / K) – 1 interval and add them.
Finally, calculate the sum of maximum and the sum of minimum elements. Print the sum of their respective sums as the final answer. 
Below is the implementation of the above approach:
C++
Java
Python3
C#
Javascript
// C++ Program to implement// the above approach#include <bits/stdc++.h>using namespace std; // Function that prints// the maximum sum possiblevoid maximumSum(int arr[],                int n, int k){     // Find elements in each group    int elt = n / k;     int sum = 0;     // Sort all elements in    // non-descending order    sort(arr, arr + n);     int count = 0;    int i = n - 1;     // Add K largest elements    while (count < k) {        sum += arr[i];        i--;        count++;    }     count = 0;    i = 0;     // For sum of minimum    // elements from each subset    while (count < k) {        sum += arr[i];        i += elt - 1;        count++;    }     // Printing the maximum sum    cout << sum << "\n";} // Driver Codeint main(){    int Arr[] = { 1, 13, 7, 17, 6, 5 };     int K = 2;     int size = sizeof(Arr) / sizeof(Arr[0]);     maximumSum(Arr, size, K);     return 0;}
// Java program to implement// the above approachimport java.util.Arrays; class GFG{     // Function that prints// the maximum sum possiblestatic void maximumSum(int arr[],                       int n, int k){         // Find elements in each group    int elt = n / k;     int sum = 0;     // Sort all elements in    // non-descending order    Arrays.sort(arr);     int count = 0;    int i = n - 1;     // Add K largest elements    while (count < k)    {        sum += arr[i];        i--;        count++;    }    count = 0;    i = 0;     // For sum of minimum    // elements from each subset    while (count < k)    {        sum += arr[i];        i += elt - 1;        count++;    }     // Printing the maximum sum    System.out.println(sum);} // Driver codepublic static void main (String[] args){    int Arr[] = { 1, 13, 7, 17, 6, 5 };     int K = 2;     int size = Arr.length;     maximumSum(Arr, size, K);}} // This code is contributed by Shubham Prakash
# Python3 program to implement# the above approach # Function that prints# the maximum sum possibledef maximumSum(arr, n, k):       # Find elements in each group    elt = n // k;     sum = 0;     # Sort all elements in    # non-descending order    arr.sort();     count = 0;    i = n - 1;     # Add K largest elements    while (count < k):        sum += arr[i];        i -= 1;        count += 1;     count = 0;    i = 0;     # For sum of minimum    # elements from each subset    while (count < k):        sum += arr[i];        i += elt - 1;        count += 1;     # Printing the maximum sum    print(sum); # Driver codeif __name__ == '__main__':    Arr = [1, 13, 7, 17, 6, 5];     K = 2;     size = len(Arr);     maximumSum(Arr, size, K); # This code is contributed by sapnasingh4991
// C# program to implement// the above approachusing System; class GFG{     // Function that prints// the maximum sum possiblestatic void maximumSum(int []arr,                       int n, int k){         // Find elements in each group    int elt = n / k;     int sum = 0;     // Sort all elements in    // non-descending order    Array.Sort(arr);     int count = 0;    int i = n - 1;     // Add K largest elements    while (count < k)    {        sum += arr[i];        i--;        count++;    }    count = 0;    i = 0;     // For sum of minimum    // elements from each subset    while (count < k)    {        sum += arr[i];        i += elt - 1;        count++;    }     // Printing the maximum sum    Console.WriteLine(sum);} // Driver codepublic static void Main(String[] args){    int []Arr = { 1, 13, 7, 17, 6, 5 };     int K = 2;     int size = Arr.Length;     maximumSum(Arr, size, K);}} // This code is contributed by amal kumar choubey
<script> // Javascript program implementation// of the approach // Function that prints// the maximum sum possiblefunction maximumSum(arr, n, k){          // Find elements in each group    let elt = (n / k);      let sum = 0;      // Sort all elements in    // non-descending order    arr.sort((a, b) => a - b);      let count = 0;    let i = n - 1;      // Add K largest elements    while (count < k)    {        sum += arr[i];        i--;        count++;    }    count = 0;    i = 0;      // For sum of minimum    // elements from each subset    while (count < k)    {        sum += arr[i];        i += elt - 1;        count++;    }      // Printing the maximum sum    document.write(sum);} // Driver Code            let Arr = [ 1, 13, 7, 17, 6, 5 ];      let K = 2;      let size = Arr.length;      maximumSum(Arr, size, K);          </script>
37
 
Time complexity: O(N*logN) Auxiliary Space: O(1) 
shubham prakash 1
Amal Kumar Choubey
sapnasingh4991
souravghosh0416
simranarora5sos
subset
Arrays
Greedy
Mathematical
Sorting
Arrays
Greedy
Mathematical
Sorting
subset
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
Top 50 Array Coding Problems for Interviews
Stack Data Structure (Introduction and Program)
Introduction to Arrays
Multidimensional Arrays in Java
Dijkstra's shortest path algorithm | Greedy Algo-7
Kruskal’s Minimum Spanning Tree Algorithm | Greedy Algo-2
Prim’s Minimum Spanning Tree (MST) | Greedy Algo-5
Write a program to print all permutations of a given string
Huffman Coding | Greedy Algo-3