Related Articles

# Split array into K subarrays with minimum sum of absolute difference between adjacent elements

• Last Updated : 05 May, 2021

Given an array, arr[] of size N and an integer K, the task is to split the array into K subarrays minimizing the sum of absolute difference between adjacent elements of each subarray.

Examples:

Input: arr[] = {1, 3, -2, 5, -1}, K = 2
Output: 13
Explanation: Split the array into following 2 subarrays: {1, 3, -2} and {5, -1}.

Input: arr[] = {2, 14, 26, 10, 5, 12}, K = 3
Output: 24
Explanation: Splitting array into following 3 subarrays: {2, 14}, {26}, {10, 5, 12}.

Approach: The given problem can be solved based on the following observations:

The idea is to slice the array arr[] at ith index which gives maximum absolute difference of adjacent elements. Subtract it from the result. Slicing at K – 1 places will give K subarrays with minimum sum of absolute difference of adjacent elements.

Follow the steps below to solve the problem:

1. Initialize an array, say new_Arr[], and an integer variable, say ans, to store total absolute difference sum.
2. Traverse the array .
• Store absolute difference of adjacent elements, say arr[i+1] and arr[i] in new_Arr[] array.
• Increment ans by absolute difference of arr[i] and arr[i + 1]
3. Sort the new_Arr[] array in descending order.
4. Traverse the array from i = 0 to i = K-1
• Decrement ans by new_Arr[i].
5. Finally, print ans.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to split an array into K subarrays``// with minimum sum of absolute difference``// of adjacent elements in each of K subarrays``void` `absoluteDifference(``int` `arr[], ``int` `N, ``int` `K)``{` `    ``// Stores the absolute differences``    ``// of adjacent elements``    ``int` `new_Arr[N - 1];` `    ``// Stores the answer``    ``int` `ans = 0;` `    ``// Stores absolute differences of``    ``// adjacent elements in new_Arr``    ``for` `(``int` `i = 0; i < N - 1; i++) {``        ``new_Arr[i] = ``abs``(arr[i] - arr[i + 1]);` `        ``// Stores the sum of all absolute``        ``// differences of adjacent elements``        ``ans += new_Arr[i];``    ``}` `    ``// Sorting the new_Arr``    ``// in decreasing order``    ``sort(new_Arr, new_Arr + N - 1,``         ``greater<``int``>());` `    ``for` `(``int` `i = 0; i < K - 1; i++) {` `        ``// Removing K - 1 elements``        ``// with maximum sum``        ``ans -= new_Arr[i];``    ``}` `    ``// Prints the answer``    ``cout << ans << endl;``}` `// Driver code``int` `main()``{``    ``// Given array arr[]``    ``int` `arr[] = { 1, 3, -2, 5, -1 };` `    ``// Given K``    ``int` `K = 2;` `    ``// Size of array``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``// Function Call``    ``absoluteDifference(arr, N, K);``    ``return` `0;``}`

## Java

 `//  java program for the above approach``import` `java.util.*;``import` `java.util.Arrays;``class` `GFG``{``    ` ` ``public` `static` `void` `reverse(``int``[] array)`` ``{` `   ``// Length of the array``   ``int` `n = array.length;` `   ``// Swaping the first half elements with last half``   ``// elements``   ``for` `(``int` `i = ``0``; i < n / ``2``; i++)``   ``{` `     ``// Storing the first half elements temporarily``     ``int` `temp = array[i];` `     ``// Assigning the first half to the last half``     ``array[i] = array[n - i - ``1``];` `     ``// Assigning the last half to the first half``     ``array[n - i - ``1``] = temp;``   ``}`` ``}` `  ``// Function to split an array into K subarrays``  ``// with minimum sum of absolute difference``  ``// of adjacent elements in each of K subarrays``  ``public` `static` `void` `absoluteDifference(``int` `arr[],``                                        ``int` `N, ``int` `K)``  ``{` `    ``// Stores the absolute differences``    ``// of adjacent elements``    ``int` `new_Arr[] = ``new` `int``[N - ``1``];` `    ``// Stores the answer``    ``int` `ans = ``0``;` `    ``// Stores absolute differences of``    ``// adjacent elements in new_Arr``    ``for` `(``int` `i = ``0``; i < N - ``1``; i++)``    ``{``      ``new_Arr[i] = Math.abs(arr[i] - arr[i + ``1``]);` `      ``// Stores the sum of all absolute``      ``// differences of adjacent elements``      ``ans += new_Arr[i];``    ``}` `    ``// Sorting the new_Arr``    ``// in decreasing order``    ``Arrays.sort(new_Arr);``    ``reverse(new_Arr);` `    ``for` `(``int` `i = ``0``; i < K - ``1``; i++)``    ``{` `      ``// Removing K - 1 elements``      ``// with maximum sum``      ``ans -= new_Arr[i];``    ``}` `    ``// Prints the answer``    ``System.out.println(ans);``  ``}` `  ``// Driver code``  ``public` `static` `void` `main (String[] args)``  ``{` `    ``// Given array arr[]``    ``int` `arr[] = { ``1``, ``3``, -``2``, ``5``, -``1` `};` `    ``// Given K``    ``int` `K = ``2``;` `    ``// Size of array``    ``int` `N = arr.length;` `    ``// Function Call``    ``absoluteDifference(arr, N, K);``   ``}``}` `// This code is contributed by AnkThon`

## Python3

 `# Python3 program for the above approach` `# Function to split an array into K subarrays``# with minimum sum of absolute difference``# of adjacent elements in each of K subarrays``def` `absoluteDifference(arr, N, K):``    ` `    ``# Stores the absolute differences``    ``# of adjacent elements``    ``new_Arr ``=` `[``0` `for` `i ``in` `range``(N ``-` `1``)]` `    ``# Stores the answer``    ``ans ``=` `0` `    ``# Stores absolute differences of``    ``# adjacent elements in new_Arr``    ``for` `i ``in` `range``(N ``-` `1``):``        ``new_Arr[i] ``=` `abs``(arr[i] ``-` `arr[i ``+` `1``])` `        ``# Stores the sum of all absolute``        ``# differences of adjacent elements``        ``ans ``+``=` `new_Arr[i]` `    ``# Sorting the new_Arr``    ``# in decreasing order``    ``new_Arr ``=` `sorted``(new_Arr)[::``-``1``]` `    ``for` `i ``in` `range``(K ``-` `1``):` `        ``# Removing K - 1 elements``        ``# with maximum sum``        ``ans ``-``=` `new_Arr[i]` `    ``# Prints the answer``    ``print` `(ans)` `# Driver code``if` `__name__ ``=``=` `'__main__'``:` `    ``# Given array arr[]``    ``arr ``=` `[ ``1``, ``3``, ``-``2``, ``5``, ``-``1` `]` `    ``# Given K``    ``K ``=` `2` `    ``# Size of array``    ``N ``=` `len``(arr)` `    ``# Function Call``    ``absoluteDifference(arr, N, K)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{`` ` `public` `static` `void` `reverse(``int``[] array)``{``    ` `    ``// Length of the array``    ``int` `n = array.Length;``    ` `    ``// Swaping the first half elements with``    ``// last half elements``    ``for``(``int` `i = 0; i < n / 2; i++)``    ``{``    ` `        ``// Storing the first half elements``        ``// temporarily``        ``int` `temp = array[i];``        ` `        ``// Assigning the first half to``        ``// the last half``        ``array[i] = array[n - i - 1];``        ` `        ``// Assigning the last half to``        ``// the first half``        ``array[n - i - 1] = temp;``    ``}``}``    ` `// Function to split an array into K subarrays``// with minimum sum of absolute difference``// of adjacent elements in each of K subarrays``public` `static` `void` `absoluteDifference(``int``[] arr,``                                      ``int` `N, ``int` `K)``{``    ` `    ``// Stores the absolute differences``    ``// of adjacent elements``    ``int``[] new_Arr = ``new` `int``[N - 1];``    ` `    ``// Stores the answer``    ``int` `ans = 0;``    ` `    ``// Stores absolute differences of``    ``// adjacent elements in new_Arr``    ``for``(``int` `i = 0; i < N - 1; i++)``    ``{``        ``new_Arr[i] = Math.Abs(arr[i] -``                              ``arr[i + 1]);``        ` `        ``// Stores the sum of all absolute``        ``// differences of adjacent elements``        ``ans += new_Arr[i];``    ``}``    ` `    ``// Sorting the new_Arr``    ``// in decreasing order``    ``Array.Sort(new_Arr);``    ``reverse(new_Arr);``    ` `    ``for``(``int` `i = 0; i < K - 1; i++)``    ``{``        ` `        ``// Removing K - 1 elements``        ``// with maximum sum``        ``ans -= new_Arr[i];``    ``}``    ` `    ``// Prints the answer``    ``Console.WriteLine(ans);``}` `// Driver Code``public` `static` `void` `Main ()``{``    ` `    ``// Given array arr[]``    ``int``[] arr = { 1, 3, -2, 5, -1 };``    ` `    ``// Given K``    ``int` `K = 2;``    ` `    ``// Size of array``    ``int` `N = arr.Length;``    ` `    ``// Function Call``    ``absoluteDifference(arr, N, K);``}``}` `// This code is contributed by susmitakundugoaldanga`

## Javascript

 ``
Output:
`13`

Time Complexity: O(N * Log(N))
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up