# 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:

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