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.

**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. - Intialise the total difference(say
**diff**) as the difference of 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**K**subarray.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach ` `#include <bits/stdc++.h> ` `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[0]; ` ` ` ` ` `// 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; ` `} ` |

*chevron_right*

*filter_none*

## 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<Integer> v = ` `new` `Vector<Integer>(); ` ` ` ` ` `// 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 ` |

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

## 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[0]; ` ` ` ` ` `// 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 ` |

*chevron_right*

*filter_none*

**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.