Divide a sorted array in K parts with sum of difference of max and min minimized in each part
Given an ascending sorted array arr[] of size N and an integer K, the task is to partition the given array into K non-empty subarrays such that the sum of differences of the maximum and the minimum of each subarray is minimized.
Examples:
Input: arr[] = {4, 8, 15, 16, 23, 42}, K = 3
Output: 12
Explanation:
The given array can be split into three sub arrays in the following way:
{4, 8}, {15, 16, 23}, {42}
Here, the sum of difference of the minimum and maximum element in each of the subarrays respectively are:
4 + 8 + 0 = 12.
Input: arr[] = {1, 2, 3, 4, 5}, K = 5
Output: 0
Approach: One observation that needs to be made is that we clearly know that the sum of the difference between the maximum and the minimum element of the subarray is minimum only when we choose the adjacent elements as the maximum and the minimum element of the subarray. So:
- Let’s say we have to split the array into K + 1 parts such that the first part will be arr[0 … i1-1], the second part will be arr[i1… i2-1], and so on.
- So, the sum of the differences between the K parts will be:
sum = arr[i1-1] – arr[0] + arr[i2-1] – arr[i1] + …. + arr[n] – arr[iK]
- After rearranging the above value, we get:
sum = -arr[0] – (arr[i1] – arr[i1 – 1]) – (arr[i2] – arr[i2 – 1]) – … -(arr[iK] – arr[iK – 1]) + arr[N – 1]
- Clearly, the value to be computed is formed from the difference between the adjacent elements of the array. If this difference is maximum, then the sum will be minimum.
- Therefore, the idea is to iterate over the array and store the difference between the adjacent elements of the array in another array.
- Now, sort this array in descending order. We know that the maximum values of the difference should be taken to get the minimum difference.
- Therefore, subtract the first K – 1 values from the difference of the first and the last element of the array. This gives the sum of the remaining differences of the K subarrays formed from the array.
Below is the implementation of the above approach:
C++
#include<bits/stdc++.h>
using namespace std;
int calculate_minimum_split( int n, int a[], int k)
{
int p[n - 1];
for ( int i = 1; i < n; i++)
p[i - 1] = a[i] - a[i - 1];
sort(p, p + n - 1, greater< int >());
int min_sum = 0;
for ( int i = 0; i < k - 1; i++)
min_sum += p[i];
int res = a[n - 1] - a[0] - min_sum;
return res;
}
int main()
{
int arr[6] = { 4, 8, 15, 16, 23, 42 };
int k = 3;
int n = sizeof (arr) / sizeof ( int );
cout << calculate_minimum_split(n, arr, k);
}
|
Java
import java.util.*;
class GFG{
static int calculate_minimum_split( int n, int a[],
int k)
{
Integer[] p = new Integer[n - 1 ];
for ( int i = 1 ; i < n; i++)
p[i - 1 ] = a[i] - a[i - 1 ];
Arrays.sort(p, new Comparator<Integer>()
{
public int compare(Integer a, Integer b)
{
return b - a;
}
});
int min_sum = 0 ;
for ( int i = 0 ; i < k - 1 ; i++)
min_sum += p[i];
int res = a[n - 1 ] - a[ 0 ] - min_sum;
return res;
}
public static void main(String[] args)
{
int arr[] = { 4 , 8 , 15 , 16 , 23 , 42 };
int k = 3 ;
int n = arr.length;
System.out.println(calculate_minimum_split(
n, arr, k));
}
}
|
Python3
def calculate_minimum_split(a, k):
p = []
n = len (a)
for i in range ( 1 , n):
p.append(a[i] - a[i - 1 ])
p.sort(reverse = True )
min_sum = sum (p[:k - 1 ])
res = a[n - 1 ] - a[ 0 ] - min_sum
return res
if __name__ = = "__main__" :
arr = [ 4 , 8 , 15 , 16 , 23 , 42 ]
K = 3
print (calculate_minimum_split(arr, K))
|
C#
using System;
class GFG{
static int calculate_minimum_split( int n, int [] a,
int k)
{
int [] p = new int [n - 1];
for ( int i = 1; i < n; i++)
p[i - 1] = a[i] - a[i - 1];
Array.Sort(p);
Array.Reverse(p);
int min_sum = 0;
for ( int i = 0; i < k - 1; i++)
min_sum += p[i];
int res = a[n - 1] - a[0] - min_sum;
return res;
}
static void Main()
{
int [] arr = { 4, 8, 15, 16, 23, 42 };
int k = 3;
int n = arr.Length;
Console.Write(calculate_minimum_split(
n, arr, k));
}
}
|
Javascript
<script>
function calculate_minimum_split(n, a, k)
{
let p = Array.from({length: n-1}, (_, i) => 0);
for (let i = 1; i < n; i++)
p[i - 1] = a[i] - a[i - 1];
p.sort((a, b) => a - b);
p.reverse();
let min_sum = 0;
for (let i = 0; i < k - 1; i++)
min_sum += p[i];
let res = a[n - 1] - a[0] - min_sum;
return res;
}
let arr = [ 4, 8, 15, 16, 23, 42 ];
let k = 3;
let n = arr.length;
document.write(calculate_minimum_split(
n, arr, k));
</script>
|
Time Complexity: O(N * log(N)), where N is the size of the array.
Auxiliary Space: O(N)
Last Updated :
22 Nov, 2021
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...