Related Articles
Split a given array into K subarrays minimizing the difference between their maximum and minimum
• Last Updated : 14 Jul, 2020

Given a sorted array arr[] of N integers and an integer K, the task is to split the array into K subarrays such that the sum of the difference of maximum and minimum element of each subarray is minimized.

Examples:

Input: arr[] = {1, 3, 3, 7}, K = 4
Output: 0
Explanation:
The given array can be split into 4 subarrays as {1}, {3}, {3}, and {7}.
The difference between minimum and maximum of each subarray is:
1. {1}, difference = 1 – 1 = 0
2. {3}, difference = 3 – 3 = 0
3. {3}, difference = 3 – 3 = 0
4. {7}, difference = 7 – 7 = 0
Therefore, the sum all the difference is 0 which is minimized.

Input: arr[] = {4, 8, 15, 16, 23, 42}, K = 3
Output: 12
Explanation:
The given array can be split into 3 subarrays as {4, 8, 15, 16}, {23}, and {42}.
The difference between minimum and maximum of each subarray is:
1. {4, 8, 15, 16}, difference = 16 – 12 = 0
2. {23}, difference = 23 – 23 = 0
3. {42}, difference = 42 – 42 = 0
Therefore, the sum all the difference is 12 which is minimized.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: To split the given array into K subarrays with the given conditions, the idea is to split at indexes(say i) where the difference between elements arr[i+1] and arr[i] is largest. Below are the steps to implement this approach:

1. Store the difference between consecutive pairs of elements in the given array arr[] into another array(say temp[]).
2. Sort the array temp[] in increasing order.
3. Intialise the total difference(say diff) as the difference of first and last element of the given array arr[].
4. Add the first K – 1 values from the array temp[] to the above difference.
5. The value stored in diff is the minimum sum of the difference of maximum and minimum element of K subarray.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;`` ` `// Function to find the subarray``int` `find(``int` `a[], ``int` `n, ``int` `k)``{``    ``vector<``int``> v;`` ` `    ``// Add the difference to vectors``    ``for` `(``int` `i = 1; i < n; ++i) {``        ``v.push_back(a[i - 1] - a[i]);``    ``}`` ` `    ``// Sort vector to find minimum k``    ``sort(v.begin(), v.end());`` ` `    ``// Initialize result``    ``int` `res = a[n - 1] - a;`` ` `    ``// Adding first k-1 values``    ``for` `(``int` `i = 0; i < k - 1; ++i) {``        ``res += v[i];``    ``}`` ` `// Return the minimized sum``    ``return` `res;``}`` ` `// Driver Code``int` `main()``{``// Given array arr[]``    ``int` `arr[] = { 4, 8, 15, 16, 23, 42 };`` ` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(``int``);`` ` `// Given K``int` `K = 3;`` ` `// Function Call``    ``cout << find(arr, N, K) << endl;`` ` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;`` ` `class` `GFG{`` ` `// Function to find the subarray``static` `int` `find(``int` `a[], ``int` `n, ``int` `k)``{``    ``Vector v = ``new` `Vector();`` ` `    ``// Add the difference to vectors``    ``for``(``int` `i = ``1``; i < n; ++i)``    ``{``       ``v.add(a[i - ``1``] - a[i]);``    ``}`` ` `    ``// Sort vector to find minimum k``    ``Collections.sort(v);`` ` `    ``// Initialize result``    ``int` `res = a[n - ``1``] - a[``0``];`` ` `    ``// Adding first k-1 values``    ``for``(``int` `i = ``0``; i < k - ``1``; ++i)``    ``{``       ``res += v.get(i);``    ``}``     ` `    ``// Return the minimized sum``    ``return` `res;``}`` ` `// Driver Code``public` `static` `void` `main(String[] args)``{``     ` `    ``// Given array arr[]``    ``int` `arr[] = { ``4``, ``8``, ``15``, ``16``, ``23``, ``42` `};`` ` `    ``int` `N = arr.length;``     ` `    ``// Given K``    ``int` `K = ``3``;``     ` `    ``// Function Call``    ``System.out.print(find(arr, N, K) + ``"\n"``);``}``}`` ` `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program for the above approach`` ` `# Function to find the subarray``def` `find(a, n, k):``     ` `    ``v ``=` `[]``     ` `    ``# Add the difference to vectors``    ``for` `i ``in` `range``(``1``, n):``        ``v.append(a[i ``-` `1``] ``-` `a[i])``         ` `    ``# Sort vector to find minimum k``    ``v.sort()``     ` `    ``# Initialize result``    ``res ``=` `a[n ``-` `1``] ``-` `a[``0``]``     ` `    ``# Adding first k-1 values``    ``for` `i ``in` `range``(k ``-` `1``):``        ``res ``+``=` `v[i]``     ` `    ``# Return the minimized sum``    ``return` `res``     ` `# Driver code``arr ``=` `[ ``4``, ``8``, ``15``, ``16``, ``23``, ``42` `]`` ` `# Length of array``N ``=` `len``(arr)`` ` `K ``=` `3`` ` `# Function Call``print``(find(arr, N, K))`` ` `# This code is contributed by sanjoy_62`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;`` ` `class` `GFG{`` ` `// Function to find the subarray``static` `int` `find(``int` `[]a, ``int` `n, ``int` `k)``{``    ``List<``int``> v = ``new` `List<``int``>();`` ` `    ``// Add the difference to vectors``    ``for``(``int` `i = 1; i < n; ++i)``    ``{``       ``v.Add(a[i - 1] - a[i]);``    ``}`` ` `    ``// Sort vector to find minimum k``    ``v.Sort();`` ` `    ``// Initialize result``    ``int` `res = a[n - 1] - a;`` ` `    ``// Adding first k-1 values``    ``for``(``int` `i = 0; i < k - 1; ++i)``    ``{``       ``res += v[i];``    ``}``     ` `    ``// Return the minimized sum``    ``return` `res;``}`` ` `// Driver Code``public` `static` `void` `Main(String[] args)``{``     ` `    ``// Given array []arr``    ``int` `[]arr = { 4, 8, 15, 16, 23, 42 };``    ``int` `N = arr.Length;``     ` `    ``// Given K``    ``int` `K = 3;``     ` `    ``// Function Call``    ``Console.Write(find(arr, N, K) + ``"\n"``);``}``}`` ` `// This code is contributed by Amit Katiyar`
Output:
```12
```

Time Complexity: O(N), where N is the number of elements in the array.
Auxiliary Space: O(N), where N is the number of elements in the array. My Personal Notes arrow_drop_up