# Split array into equal length subsets with maximum sum of Kth largest element of each subset

Last Updated : 21 Apr, 2021

Given an array arr[] of size N, two positive integers M and K, the task is to partition the array into M equal length subsets such that the sum of the Kth largest element of all these subsets is maximum. If it is not possible to partition the array into M equal length subsets, then print -1.

Examples:

Input: arr[] = { 1, 2, 3, 4, 5, 6 }, M = 2, K = 2
Output:
Explanation:
Length of each subset = (N / M) = 3.
Possible subsets from the array are: { {1, 3, 4}, {2, 5, 6} }
Therefore, the sum of Kth largest element from each subset = 3 + 5 = 8

Input: arr[] = {11, 20, 2, 17}, M = 4, K = 1
Output: 50

Approach: The problem can be solved using Greedy technique. Follow the steps below to solve the problem:

• If N is not divisible M, then print -1.
• Initialize a variable, say maxSum, to store the maximum possible sum of Kth largest element of all the subsets of the array by partitioning the array into M equal length subset.
• Sort the array in descending order.
• Iterate over the range [1, M] using variable i and update maxSum += arr[i * K – 1].
• Finally, print the value of maxSum.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement` `// the above approach`   `#include ` `using` `namespace` `std;`   `// Function to find the maximum sum of Kth` `// largest element of M equal length partition` `int` `maximumKthLargestsumPart(``int` `arr[], ``int` `N,` `                             ``int` `M, ``int` `K)` `{` `    ``// Stores sum of K_th largest element` `    ``// of equal length partitions` `    ``int` `maxSum = 0;`   `    ``// If N is not` `    ``// divisible by M` `    ``if` `(N % M)` `        ``return` `-1;`   `    ``// Stores length of` `    ``// each partition` `    ``int` `sz = (N / M);`   `    ``// If K is greater than` `    ``// length of partition` `    ``if` `(K > sz)` `        ``return` `-1;`   `    ``// Sort array in` `    ``// descending porder` `    ``sort(arr, arr + N, greater<``int``>());`   `    ``// Traverse the array` `    ``for` `(``int` `i = 1; i <= M;` `         ``i++) {`   `        ``// Update maxSum` `        ``maxSum` `            ``+= arr[i * K - 1];` `    ``}`   `    ``return` `maxSum;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 1, 2, 3, 4, 5, 6 };` `    ``int` `M = 2;` `    ``int` `K = 1;` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``cout << maximumKthLargestsumPart(arr, N, M, K);`   `    ``return` `0;` `}`

## Java

 `// Java program to implement ` `// the above approach ` `import` `java.util.*;` `import` `java.util.Collections;`   `class` `GFG{` `     `  `// Function to find the maximum sum of Kth ` `// largest element of M equal length partition ` `static` `int` `maximumKthLargestsumPart(``int``[] arr, ``int` `N, ` `                                    ``int` `M, ``int` `K) ` `{ ` `    `  `    ``// Stores sum of K_th largest element ` `    ``// of equal length partitions ` `    ``int` `maxSum = ``0``; ` `    `  `    ``// If N is not ` `    ``// divisible by M ` `    ``if` `(N % M != ``0``) ` `        ``return` `-``1``; ` `   `  `    ``// Stores length of ` `    ``// each partition ` `    ``int` `sz = (N / M); ` `   `  `    ``// If K is greater than ` `    ``// length of partition ` `    ``if` `(K > sz) ` `        ``return` `-``1``; ` `   `  `    ``// Sort array in ` `    ``// descending porder ` `    ``Arrays.sort(arr);` `    ``int` `i, k, t; ` `    `  `    ``for``(i = ``0``; i < N / ``2``; i++)` `    ``{ ` `        ``t = arr[i]; ` `        ``arr[i] = arr[N - i - ``1``]; ` `        ``arr[N - i - ``1``] = t; ` `    ``}`   `    ``// Traverse the array ` `    ``for``(i = ``1``; i <= M; i++) ` `    ``{ ` `        `  `        ``// Update maxSum ` `        ``maxSum += arr[i * K - ``1``]; ` `    ``} ` `    ``return` `maxSum; ` `}` ` `  `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    ``int``[] arr = { ``1``, ``2``, ``3``, ``4``, ``5``, ``6` `}; ` `    ``int` `M = ``2``; ` `    ``int` `K = ``1``; ` `    ``int` `N = arr.length; ` `   `  `    ``System.out.println(maximumKthLargestsumPart(` `        ``arr, N, M, K)); ` `}` `}` ` `  `// This code is contributed by sanjoy_62`

## Python3

 `# Python3 program to implement` `# the above approach`   `# Function to find the maximum sum of Kth` `# largest element of M equal length partition` `def` `maximumKthLargestsumPart(arr, N, M, K):` `    `  `    ``# Stores sum of K_th largest element` `    ``# of equal length partitions` `    ``maxSum ``=` `0`   `    ``# If N is not` `    ``# divisible by M` `    ``if` `(N ``%` `M !``=` `0``):` `        ``return` `-``1`   `    ``# Stores length of` `    ``# each partition` `    ``sz ``=` `(N ``/` `M)`   `    ``# If K is greater than` `    ``# length of partition` `    ``if` `(K > sz):` `        ``return` `-``1`   `    ``# Sort array in` `    ``# descending porder` `    ``arr ``=` `sorted``(arr)`   `    ``for` `i ``in` `range``(``0``, N ``/``/` `2``):` `        ``t ``=` `arr[i]` `        ``arr[i] ``=` `arr[N ``-` `i ``-` `1``]` `        ``arr[N ``-` `i ``-` `1``] ``=` `t`   `    ``# Traverse the array` `    ``for` `i ``in` `range``(``1``, M ``+` `1``):` `        `  `        ``# Update maxSum` `        ``maxSum ``+``=` `arr[i ``*` `K ``-` `1``]`   `    ``return` `maxSum`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``arr ``=` `[ ``1``, ``2``, ``3``, ``4``, ``5``, ``6` `]` `    ``M ``=` `2` `    ``K ``=` `1` `    ``N ``=` `len``(arr)` `    `  `    ``print``(maximumKthLargestsumPart(arr, N, M, K))`   `# This code is contributed by Amit Katiyar`

## C#

 `// C# program to implement ` `// the above approach ` `using` `System;`   `class` `GFG{` `  `  `// Function to find the maximum sum of Kth ` `// largest element of M equal length partition ` `static` `int` `maximumKthLargestsumPart(``int``[] arr, ``int` `N, ` `                                    ``int` `M, ``int` `K) ` `{ ` `    `  `    ``// Stores sum of K_th largest element ` `    ``// of equal length partitions ` `    ``int` `maxSum = 0; ` `  `  `    ``// If N is not ` `    ``// divisible by M ` `    ``if` `(N % M != 0) ` `        ``return` `-1; ` `  `  `    ``// Stores length of ` `    ``// each partition ` `    ``int` `sz = (N / M); ` `  `  `    ``// If K is greater than ` `    ``// length of partition ` `    ``if` `(K > sz) ` `        ``return` `-1; ` `  `  `    ``// Sort array in ` `    ``// descending porder ` `    ``Array.Sort(arr); ` `    ``Array.Reverse(arr); ` `  `  `    ``// Traverse the array ` `    ``for``(``int` `i = 1; i <= M; i++) ` `    ``{ ` `        `  `        ``// Update maxSum ` `        ``maxSum += arr[i * K - 1]; ` `    ``} ` `    ``return` `maxSum; ` `}`   `// Driver code    ` `static` `void` `Main()` `{` `    ``int``[] arr = { 1, 2, 3, 4, 5, 6 }; ` `    ``int` `M = 2; ` `    ``int` `K = 1; ` `    ``int` `N = arr.Length; ` `  `  `    ``Console.WriteLine(maximumKthLargestsumPart(` `        ``arr, N, M, K)); ` `}` `}`   `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``

Output:

`11`

Time complexity: O(N * log(N))
Auxiliary space: O(1)

Article Tags :
Practice Tags :