Split a given array into K subarrays minimizing the difference between their maximum and minimum
Last Updated :
21 Aug, 2021
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 – 4 = 12
2. {23}, difference = 23 – 23 = 0
3. {42}, difference = 42 – 42 = 0
Therefore, the sum all the difference is 12 which is minimized.
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:
- Store the difference between consecutive pairs of elements in the given array arr[] into another array(say temp[]).
- Sort the array temp[] in increasing order.
- Initialise the total difference(say diff) as the difference of the first and last element of the given array arr[].
- Add the first K – 1 values from the array temp[] to the above difference.
- The value stored in diff is the minimum sum of the difference of maximum and minimum element of the K subarray.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int find( int a[], int n, int k)
{
vector< int > v;
for ( int i = 1; i < n; ++i) {
v.push_back(a[i - 1] - a[i]);
}
sort(v.begin(), v.end());
int res = a[n - 1] - a[0];
for ( int i = 0; i < k - 1; ++i) {
res += v[i];
}
return res;
}
int main()
{
int arr[] = { 4, 8, 15, 16, 23, 42 };
int N = sizeof (arr) / sizeof ( int );
int K = 3;
cout << find(arr, N, K) << endl;
return 0;
}
|
Java
import java.util.*;
class GFG{
static int find( int a[], int n, int k)
{
Vector<Integer> v = new Vector<Integer>();
for ( int i = 1 ; i < n; ++i)
{
v.add(a[i - 1 ] - a[i]);
}
Collections.sort(v);
int res = a[n - 1 ] - a[ 0 ];
for ( int i = 0 ; i < k - 1 ; ++i)
{
res += v.get(i);
}
return res;
}
public static void main(String[] args)
{
int arr[] = { 4 , 8 , 15 , 16 , 23 , 42 };
int N = arr.length;
int K = 3 ;
System.out.print(find(arr, N, K) + "\n" );
}
}
|
Python3
def find(a, n, k):
v = []
for i in range ( 1 , n):
v.append(a[i - 1 ] - a[i])
v.sort()
res = a[n - 1 ] - a[ 0 ]
for i in range (k - 1 ):
res + = v[i]
return res
arr = [ 4 , 8 , 15 , 16 , 23 , 42 ]
N = len (arr)
K = 3
print (find(arr, N, K))
|
C#
using System;
using System.Collections.Generic;
class GFG{
static int find( int []a, int n, int k)
{
List< int > v = new List< int >();
for ( int i = 1; i < n; ++i)
{
v.Add(a[i - 1] - a[i]);
}
v.Sort();
int res = a[n - 1] - a[0];
for ( int i = 0; i < k - 1; ++i)
{
res += v[i];
}
return res;
}
public static void Main(String[] args)
{
int []arr = { 4, 8, 15, 16, 23, 42 };
int N = arr.Length;
int K = 3;
Console.Write(find(arr, N, K) + "\n" );
}
}
|
Javascript
<script>
function find(a , n , k) {
var v = [];
for (i = 1; i < n; ++i) {
v.push(a[i - 1] - a[i]);
}
v.sort((a,b)=>a-b);
var res = a[n - 1] - a[0];
for (i = 0; i < k - 1; ++i) {
res += v[i];
}
return res;
}
var arr = [ 4, 8, 15, 16, 23, 42 ];
var N = arr.length;
var K = 3;
document.write(find(arr, N, K) + "\n" );
</script>
|
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.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...