# Split Array into K non-overlapping subset such that maximum among all subset sum is minimum

• Last Updated : 20 Aug, 2021

Given an array arr[] consisting of N integers and an integer K, the task is to split the given array into K non-overlapping subsets such that the maximum among the sum of all subsets is minimum.

Examples:

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[] = {1, 7, 9, 2, 12, 3, 3}, M = 3
Output: 13
Explanation:
One possible way to spit the array into 3 non-overlapping subsets is {arr, arr}, {arr, arr}, and {arr, arr, arr}.
The sum of each subset is 13, 12 and 12 respectively. Now, the maximum among all the sum of subsets is 13, which is the minimum possible sum.

Input: arr[] = {1, 2, 3, 4, 5}, M = 2
Output: 8

Approach: The given problem can be solved by the Greedy Approach by using the priority queue and sorting the given array. Follow the steps below to solve the problem:

Below is the implementation of the above approach:

+++++

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to split the array into M``// groups such that maximum of the sum``// of all elements of all the groups``// is minimized``int` `findMinimumValue(``int` `arr[], ``int` `N,``                     ``int` `M)``{``    ``// Sort the array in decreasing order``    ``sort(arr, arr + N, greater<``int``>());` `    ``// Initialize priority queue (Min heap)``    ``priority_queue<``int``, vector<``int``>,``                   ``greater<``int``> >``        ``pq;` `    ``// Push 0 for all the M groups``    ``for` `(``int` `i = 1; i <= M; ++i) {``        ``pq.push(0);``    ``}` `    ``// Traverse the array, arr[]``    ``for` `(``int` `i = 0; i < N; ++i) {` `        ``// Pop the group having the``        ``// minimum sum``        ``int` `val = pq.top();``        ``pq.pop();` `        ``// Increment val by arr[i]``        ``val += arr[i];` `        ``// Push the new sum of the``        ``// group into the pq``        ``pq.push(val);``    ``}` `    ``// Iterate while size of the pq``    ``// is greater than 1``    ``while` `(pq.size() > 1) {``        ``pq.pop();``    ``}` `    ``// Return result``    ``return` `pq.top();``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 7, 9, 2, 12, 3, 3 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``int` `K = 3;``    ``cout << findMinimumValue(arr, N, K);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``public` `class` `Main``{``    ``// Function to split the array into M``    ``// groups such that maximum of the sum``    ``// of all elements of all the groups``    ``// is minimized``    ``static` `int` `findMinimumValue(Vector arr, ``int` `N, ``int` `M)``    ``{``       ` `        ``// Sort the array in decreasing order``        ``Collections.sort(arr);``        ``Collections.reverse(arr);``       ` `        ``// Initialize priority queue (Min heap)``        ``Vector pq = ``new` `Vector();``       ` `        ``// Push 0 for all the M groups``        ``for` `(``int` `i = ``1``; i <= M; ++i) {``            ``pq.add(``0``);``        ``}``        ` `        ``Collections.sort(pq);``       ` `        ``// Traverse the array, arr[]``        ``for` `(``int` `i = ``0``; i < N; ++i) {``       ` `            ``// Pop the group having the``            ``// minimum sum``            ``int` `val = pq.get(``0``);``            ``pq.remove(``0``);``       ` `            ``// Increment val by arr[i]``            ``val += arr.get(i);``       ` `            ``// Push the new sum of the``            ``// group into the pq``            ``pq.add(val);``            ``Collections.sort(pq);``        ``}``       ` `        ``// Iterate while size of the pq``        ``// is greater than 1``        ``while` `(pq.size() > ``1``) {``            ``pq.remove(``0``);``        ``}``       ` `        ``// Return result``        ``return` `pq.get(``0``);``    ``}``    ` `    ``public` `static` `void` `main(String[] args) {``        ``Integer[] arr = { ``1``, ``7``, ``9``, ``2``, ``12``, ``3``, ``3` `};``        ``Vector Arr = ``new` `Vector();``        ``Collections.addAll(Arr, arr);``        ``int` `N = Arr.size();``        ``int` `K = ``3``;``        ``System.out.println(findMinimumValue(Arr, N, K));``    ``}``}` `// This code is contributed by divyesh072019.`

## Python3

 `# Python3 program for the above approach` `# Function to split the array into M``# groups such that maximum of the sum``# of all elements of all the groups``# is minimized``def` `findMinimumValue(arr, N, M):``   ` `    ``# Sort the array in decreasing order``    ``arr.sort()``    ``arr.reverse()``   ` `    ``# Initialize priority queue (Min heap)``    ``pq ``=` `[]``   ` `    ``# Push 0 for all the M groups``    ``for` `i ``in` `range``(``1``, M ``+` `1``):``        ``pq.append(``0``)``     ` `    ``pq.sort()``   ` `    ``# Traverse the array, arr[]``    ``for` `i ``in` `range``(N):``   ` `        ``# Pop the group having the``        ``# minimum sum``        ``val ``=` `pq[``0``]``        ``del` `pq[``0``]``   ` `        ``# Increment val by arr[i]``        ``val ``+``=` `arr[i]``   ` `        ``# Push the new sum of the``        ``# group into the pq``        ``pq.append(val)``        ``pq.sort()``   ` `    ``# Iterate while size of the pq``    ``# is greater than 1``    ``while` `(``len``(pq) > ``1``) :``        ``del` `pq[``0``]``   ` `    ``# Return result``    ``return` `pq[``0``]` `arr ``=` `[ ``1``, ``7``, ``9``, ``2``, ``12``, ``3``, ``3` `]``N ``=` `len``(arr)``K ``=` `3``print``(findMinimumValue(arr, N, K))` `# This code is contributed by suresh07.`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG {``    ` `    ``// Function to split the array into M``    ``// groups such that maximum of the sum``    ``// of all elements of all the groups``    ``// is minimized``    ``static` `int` `findMinimumValue(``int``[] arr, ``int` `N, ``int` `M)``    ``{``      ` `        ``// Sort the array in decreasing order``        ``Array.Sort(arr);``        ``Array.Reverse(arr);``      ` `        ``// Initialize priority queue (Min heap)``        ``List<``int``> pq = ``new` `List<``int``>();``      ` `        ``// Push 0 for all the M groups``        ``for` `(``int` `i = 1; i <= M; ++i) {``            ``pq.Add(0);``        ``}``        ` `        ``pq.Sort();``      ` `        ``// Traverse the array, arr[]``        ``for` `(``int` `i = 0; i < N; ++i) {``      ` `            ``// Pop the group having the``            ``// minimum sum``            ``int` `val = pq;``            ``pq.RemoveAt(0);``      ` `            ``// Increment val by arr[i]``            ``val += arr[i];``      ` `            ``// Push the new sum of the``            ``// group into the pq``            ``pq.Add(val);``            ``pq.Sort();``        ``}``      ` `        ``// Iterate while size of the pq``        ``// is greater than 1``        ``while` `(pq.Count > 1) {``            ``pq.RemoveAt(0);``        ``}``      ` `        ``// Return result``        ``return` `pq;``    ``}` `  ``static` `void` `Main() {``    ``int``[] arr = { 1, 7, 9, 2, 12, 3, 3 };``    ``int` `N = arr.Length;``    ``int` `K = 3;``    ``Console.Write(findMinimumValue(arr, N, K));``  ``}``}` `// This code is contributed by divyeshrabadiya07.`

## Javascript

 ``
Output:
`13`

Time Complexity: O(N*log K)
Auxiliary Space: O(M)

My Personal Notes arrow_drop_up