Divide a sorted array in K parts with sum of difference of max and min minimized in each part - GeeksforGeeks

22 Nov, 2021
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++
Java
Python3
C#
Javascript
// C++ program to find the minimum// sum of differences possible for// the given array when the array// is divided into K subarrays#include<bits/stdc++.h>using namespace std; // Function to find the minimum// sum of differences possible for// the given array when the array// is divided into K subarraysint calculate_minimum_split(int n, int a[], int k){     // Array to store the differences    // between two adjacent elements    int p[n - 1];         // Iterating through the array    for(int i = 1; i < n; i++)             // Storing differences to p        p[i - 1] = a[i] - a[i - 1];             // Sorting p in descending order    sort(p, p + n - 1, greater<int>());         // Sum of the first k-1 values of p    int min_sum = 0;    for(int i = 0; i < k - 1; i++)        min_sum += p[i];             // Computing the result    int res = a[n - 1] - a[0] - min_sum;         return res;} // Driver codeint 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);} // This code is contributed by ishayadav181
// Java program to find the minimum// sum of differences possible for// the given array when the array// is divided into K subarraysimport java.util.*; class GFG{ // Function to find the minimum// sum of differences possible for// the given array when the array// is divided into K subarraysstatic int calculate_minimum_split(int n, int a[],                                   int k){         // Array to store the differences    // between two adjacent elements    Integer[] p = new Integer[n - 1];     // Iterating through the array    for(int i = 1; i < n; i++)         // Storing differences to p        p[i - 1] = a[i] - a[i - 1];     // Sorting p in descending order    Arrays.sort(p, new Comparator<Integer>()    {        public int compare(Integer a, Integer b)        {            return b - a;        }    });     // Sum of the first k-1 values of p    int min_sum = 0;    for(int i = 0; i < k - 1; i++)        min_sum += p[i];     // Computing the result    int res = a[n - 1] - a[0] - min_sum;     return res;} // Driver codepublic 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));}} // This code is contributed by offbeat
# Python3 program to find the minimum# sum of differences possible for# the given array when the array# is divided into K subarrays # Function to find the minimum# sum of differences possible for# the given array when the array# is divided into K subarraysdef calculate_minimum_split(a, k):     # Array to store the differences    # between two adjacent elements    p =[]    n = len(a)     # Iterating through the array    for i in range(1, n):                 # Appending differences to p        p.append(a[i]-a[i-1])     # Sorting p in descending order    p.sort(reverse = True)      # Sum of the first k-1 values of p    min_sum = sum(p[:k-1])      # Computing the result    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# program to find the minimum // sum of differences possible for // the given array when the array // is divided into K subarrays using System; class GFG{     // Function to find the minimum // sum of differences possible for // the given array when the array // is divided into K subarrays static int calculate_minimum_split(int n, int[] a,                                   int k) {          // Array to store the differences     // between two adjacent elements     int[] p = new int[n - 1];            // Iterating through the array     for(int i = 1; i < n; i++)                // Storing differences to p         p[i - 1] = a[i] - a[i - 1];                // Sorting p in descending order     Array.Sort(p);    Array.Reverse(p);           // Sum of the first k-1 values of p     int min_sum = 0;     for(int i = 0; i < k - 1; i++)         min_sum += p[i];                // Computing the result     int res = a[n - 1] - a[0] - min_sum;            return res; }  // Driver codestatic 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));}} // This code is contributed by divyeshrabadiya07
<script>// Javascript program to find the minimum// sum of differences possible for// the given array when the array// is divided into K subarrays  // Function to find the minimum// sum of differences possible for// the given array when the array// is divided into K subarraysfunction calculate_minimum_split(n, a, k){          // Array to store the differences    // between two adjacent elements    let p = Array.from({length: n-1}, (_, i) => 0);            // Iterating through the array    for(let i = 1; i < n; i++)                // Storing differences to p        p[i - 1] = a[i] - a[i - 1];                // Sorting p in descending order    p.sort((a, b) => a - b);    p.reverse();            // Sum of the first k-1 values of p    let min_sum = 0;    for(let i = 0; i < k - 1; i++)        min_sum += p[i];                // Computing the result    let res = a[n - 1] - a[0] - min_sum;            return res;} // Driver Code            let arr = [ 4, 8, 15, 16, 23, 42 ];    let k = 3;    let n = arr.length;      document.write(calculate_minimum_split(                       n, arr, k));               </script>
12
 
Time Complexity: O(N * log(N)), where N is the size of the array.
Auxiliary Space: O(N) 
ishayadav181
offbeat
divyeshrabadiya07
target_2
rishavmahato348
Kirti_Mangal
Algorithms
Arrays
Mathematical
Sorting
Arrays
Mathematical
Sorting
Algorithms
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
DSA Sheet by Love Babbar
Quadratic Probing in Hashing
SCAN (Elevator) Disk Scheduling Algorithms
K means Clustering - Introduction
Difference between Informed and Uninformed Search in AI
Arrays in Java
Arrays in C/C++
Program for array rotation
Stack Data Structure (Introduction and Program)
Largest Sum Contiguous Subarray