# Divide a sorted array in K parts with sum of difference of max and min minimized in each part – Set 2

• Last Updated : 18 Jan, 2022

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[] = { 10, 20, 70, 80 },  N = 4, K = 2
Output: 20
Explanation: The given array can be split in the following way
{10, 20} and {70, 80}. The differences are (20 – 10) = 10 and (80 – 70) = 10
The sum = 10 + 10 = 20

Input:  arr[] = { 5, 10, 50, 70 }, N = 4, K = 3
Output: 5
Explanation: The subarrays are {5, 10}, {50}, {70}
The differences are 10 – 5 = 5, 50 – 50 = 0, 70 – 70 = 0
The sum = 5 + 0 + 0 = 5

Approach: The other approaches are discussed in Set 1 of this article. Here, we are discussing the Binary Search approach.

Space Optimized Approach: The idea is to use binary search in order to find the answer. The answer lies in [ 0, ( arr[N-1] – arr) ]. See the following observation for justification.

• Assuming permission to make as many cuts as possible, the answer would be 0 because each element can form a subarray. Thus the minimum value would be 0.
• Now the other extreme case can be when only one subarray is allowed, In this case, the answer would be (arr[N-1] – arr). These were the two extreme cases and it is guaranteed that the answer would lie in between them.

Follow the steps below to solve the problem:

• Initialize the variable ans as 0 to store the answer.
• Apply binary search with low = 0, and high = arr[N-1] – arr.
• For each value of mid, check if a tape of length mid can cover all the holes within K cuts.
• If so then we have arrived at a potential answer. Store the value and check if it is possible to do the same for a smaller length of tape. (make high = mid – 1 )
• If not then find a larger value for mid (low = mid + 1).

Below is the implementation of the above approach.

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `bool` `isValid(vector<``int``> arr, ``int` `max_cuts, ``int` `len)` `{`   `    ``// Max_cuts is the maximum no. of` `    ``// allowed cuts.` `    ``int` `n = arr.size();` `    ``int` `start = 0;` `    ``int` `i = 1;` `    ``while` `(i < n) {`   `        ``// Start from covering as many holes` `        ``// as you can from start.` `        ``if` `(arr[i] - arr[start] <= len) {` `            ``i++;` `        ``}` `        ``else` `{`   `            ``// If an index is reached` `            ``// from where it's not possible` `            ``// to accommodate more elements` `            ``// in the current subarray` `            ``// then end this subarray` `            ``// and go further.` `            ``len = len - (arr[i - 1] - arr[start]);` `            ``max_cuts--;` `            ``start = i;` `            ``i++;` `        ``}`   `        ``// If at any point you run out` `        ``// of maximum subarrays or length` `        ``// then return false because it's` `        ``// impossible to obtain this` `        ``// value of mid.` `        ``if` `(max_cuts <= 0 || len <= 0)` `            ``return` `false``;` `    ``}`   `    ``// Covered all subarrays within` `    ``// the sum maximum number of subarrays` `    ``// so return true.` `    ``return` `true``;` `}`   `// Function to find the minimum sum` `void` `findMinTapeLength(vector<``int``> arr, ``int` `N, ``int` `K)` `{` `    ``// Initialise low and high` `    ``int` `high = arr[N - 1] - arr, low = 0;` `    ``int` `ans = 0;`   `    ``// Apply Binary Search` `    ``while` `(low <= high) {` `        ``int` `mid = low + (high - low) / 2;`   `        ``// IsValid() function checks if` `        ``// max value of mid is sufficient` `        ``// to break the array in K subarrays` `        ``if` `(isValid(arr, K, mid)) {`   `            ``// If true then set this as` `            ``// the current answer and divide` `            ``// your range to [low, mid-1]` `            ``// to check for a lower sum` `            ``ans = mid;` `            ``high = mid - 1;` `        ``}` `        ``// If false then that means need` `        ``// to increase the current length` `        ``// so set range to [mid+1, high]` `        ``else` `            ``low = mid + 1;` `    ``}` `    ``cout << ans;` `}`   `// Driver Code` `int` `main()` `{` `    ``vector<``int``> arr = { 10, 20, 70, 80 };` `    ``int` `N = 4, K = 2;` `    ``findMinTapeLength(arr, N, K);` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Java

 `// Java program for the above approach` `import` `java.io.*;`   `class` `GFG {`   `    ``// Function to find the minimum sum` `    ``static` `void` `findMinTapeLength(``int``[] arr, ` `                                  ``int` `N, ``int` `K)` `    ``{` `        ``// Initialise low and high` `        ``int` `high = arr[N - ``1``] - arr[``0``], low = ``0``;` `        ``int` `ans = ``0``;`   `        ``// Apply Binary Search` `        ``while` `(low <= high) {` `            ``int` `mid = low + (high - low) / ``2``;`   `            ``// IsValid() function checks if` `            ``// max value of mid is sufficient ` `            ``// to break the array in K subarrays` `            ``if` `(isValid(arr, K, mid)) {`   `                ``// If true then set this as ` `                ``// the current answer and divide ` `                ``// your range to [low, mid-1] ` `                ``// to check for a lower sum` `                ``ans = mid;` `                ``high = mid - ``1``;` `            ``}` `            ``// If false then that means need ` `            ``// to increase the current length ` `            ``// so set range to [mid+1, high]` `            ``else` `                ``low = mid + ``1``;` `        ``}` `        ``System.out.println(ans);` `    ``}`   `    ``static` `boolean` `isValid(``int``[] arr, ` `                           ``int` `max_cuts, ` `                           ``int` `len)` `    ``{`   `        ``// Max_cuts is the maximum no. of ` `        ``// allowed cuts.` `        ``int` `n = arr.length;` `        ``int` `start = ``0``;` `        ``int` `i = ``1``;` `        ``while` `(i < n) {`   `            ``// Start from covering as many holes` `            ``// as you can from start.` `            ``if` `(arr[i] - arr[start] <= ` `                ``len) {` `                ``i++;` `            ``}` `            ``else` `{`   `                ``// If an index is reached ` `                ``// from where it's not possible ` `                ``// to accommodate more elements` `                ``// in the current subarray ` `                ``// then end this subarray ` `                ``// and go further.` `                ``len = len - (arr[i - ``1``] - ` `                             ``arr[start]);` `                ``max_cuts--;` `                ``start = i;` `                ``i++;` `            ``}`   `            ``// If at any point you run out ` `            ``// of maximum subarrays or length ` `            ``// then return false because it's` `            ``// impossible to obtain this ` `            ``// value of mid.` `            ``if` `(max_cuts <= ``0` `|| len <= ``0``)` `                ``return` `false``;` `        ``}`   `        ``// Covered all subarrays within` `        ``// the sum maximum number of subarrays` `        ``// so return true.` `        ``return` `true``;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int``[] arr = { ``10``, ``20``, ``70``, ``80` `};` `        ``int` `N = ``4``, K = ``2``;` `        ``findMinTapeLength(arr, N, K);` `    ``}` `}`

## Python3

 `# Python code for the above approach`   `# Function to find the minimum sum` `def` `findMinTapeLength(arr, N, K):`   `    ``# Initialise low and high` `    ``high ``=` `arr[N ``-` `1``] ``-` `arr[``0``]` `    ``low ``=` `0` `    ``ans ``=` `0`   `    ``# Apply Binary Search` `    ``while` `(low <``=` `high):` `        ``mid ``=` `low ``+` `((high ``-` `low) ``/``/` `2``)`   `        ``# IsValid() function checks if` `        ``# max value of mid is sufficient` `        ``# to break the array in K subarrays` `        ``if` `(isValid(arr, K, mid)):`   `            ``# If true then set this as` `            ``# the current answer and divide` `            ``# your range to [low, mid-1]` `            ``# to check for a lower sum` `            ``ans ``=` `mid` `            ``high ``=` `mid ``-` `1`   `        ``# If false then that means need` `        ``# to increase the current length` `        ``# so set range to [mid+1, high]` `        ``else``:` `            ``low ``=` `mid ``+` `1` `    ``print``(ans)`     `def` `isValid(arr, max_cuts, _len):`   `    ``# Max_cuts is the maximum no. of` `    ``# allowed cuts.` `    ``n ``=` `len``(arr)` `    ``start ``=` `0` `    ``i ``=` `1` `    ``while` `(i < n):`   `        ``# Start from covering as many holes` `        ``# as you can from start.` `        ``if` `(arr[i] ``-` `arr[start] <``=` `_len):` `            ``i ``+``=` `1` `        ``else``:`   `            ``# If an index is reached` `            ``# from where it's not possible` `            ``# to accommodate more elements` `            ``# in the current subarray` `            ``# then end this subarray` `            ``# and go further.` `            ``_len ``=` `_len ``-` `(arr[i ``-` `1``] ``-` `arr[start])` `            ``max_cuts ``-``=` `1` `            ``start ``=` `i` `            ``i ``+``=` `1`   `        ``# If at any point you run out` `        ``# of maximum subarrays or length` `        ``# then return false because it's` `        ``# impossible to obtain this` `        ``# value of mid.` `        ``if` `(max_cuts <``=` `0` `or` `_len <``=` `0``):` `            ``return` `False`   `    ``# Covered all subarrays within` `    ``# the sum maximum number of subarrays` `    ``# so return true.` `    ``return` `True`     `# Driver Code` `arr ``=` `[``10``, ``20``, ``70``, ``80``]` `N ``=` `4` `K ``=` `2` `findMinTapeLength(arr, N, K)`   `# This code is contributed by gfgking`

## C#

 `// C# program for the above approach` `using` `System;` `class` `GFG {`   `  ``// Function to find the minimum sum` `  ``static` `void` `findMinTapeLength(``int``[] arr, ` `                                ``int` `N, ``int` `K)` `  ``{`   `    ``// Initialise low and high` `    ``int` `high = arr[N - 1] - arr, low = 0;` `    ``int` `ans = 0;`   `    ``// Apply Binary Search` `    ``while` `(low <= high) {` `      ``int` `mid = low + (high - low) / 2;`   `      ``// IsValid() function checks if` `      ``// max value of mid is sufficient ` `      ``// to break the array in K subarrays` `      ``if` `(isValid(arr, K, mid)) {`   `        ``// If true then set this as ` `        ``// the current answer and divide ` `        ``// your range to [low, mid-1] ` `        ``// to check for a lower sum` `        ``ans = mid;` `        ``high = mid - 1;` `      ``}`   `      ``// If false then that means need ` `      ``// to increase the current length ` `      ``// so set range to [mid+1, high]` `      ``else` `        ``low = mid + 1;` `    ``}` `    ``Console.WriteLine(ans);` `  ``}`   `  ``static` `bool` `isValid(``int``[] arr, ` `                      ``int` `max_cuts, ` `                      ``int` `len)` `  ``{`   `    ``// Max_cuts is the maximum no. of ` `    ``// allowed cuts.` `    ``int` `n = arr.Length;` `    ``int` `start = 0;` `    ``int` `i = 1;` `    ``while` `(i < n) {`   `      ``// Start from covering as many holes` `      ``// as you can from start.` `      ``if` `(arr[i] - arr[start] <= ` `          ``len) {` `        ``i++;` `      ``}` `      ``else` `{`   `        ``// If an index is reached ` `        ``// from where it's not possible ` `        ``// to accommodate more elements` `        ``// in the current subarray ` `        ``// then end this subarray ` `        ``// and go further.` `        ``len = len - (arr[i - 1] - ` `                     ``arr[start]);` `        ``max_cuts--;` `        ``start = i;` `        ``i++;` `      ``}`   `      ``// If at any point you run out ` `      ``// of maximum subarrays or length ` `      ``// then return false because it's` `      ``// impossible to obtain this ` `      ``// value of mid.` `      ``if` `(max_cuts <= 0 || len <= 0)` `        ``return` `false``;` `    ``}`   `    ``// Covered all subarrays within` `    ``// the sum maximum number of subarrays` `    ``// so return true.` `    ``return` `true``;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main()` `  ``{` `    ``int``[] arr = { 10, 20, 70, 80 };` `    ``int` `N = 4, K = 2;` `    ``findMinTapeLength(arr, N, K);` `  ``}` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`20`

Time Complexity: O(N*log(M)), where M is the maximum value of the array.
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :