将数组拆分为 K 个子数组，其中相邻元素之间的绝对差之和最小

给定一个大小为N的数组arr[]和一个整数K ，任务是将数组拆分为K个子数组，以最小化每个子数组的相邻元素之间的绝对差之和。

例子：

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

方法：根据以下观察可以解决给定的问题：

The idea is to slice the array arr[] at i^th 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.

请按照以下步骤解决问题：

1. 初始化一个数组，比如new_Arr[]和一个整数变量，比如ans ，以存储总绝对差和。
2. 遍历数组。
   • 将相邻元素的绝对差值，比如arr[i+1]和arr[i] 存储在new_Arr[]数组中。
   • 通过arr[i]和arr[i + 1]的绝对差来增加ans
3. 按降序对new_Arr[]数组进行排序。
4. 遍历数组从i = 0到i = K-1
   • 通过new_Arr[i]减少ans 。
5. 最后，打印ans。

下面是上述方法的实现：

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());
 
    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[0]);
 
    // 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

 
// Javascript program for the above approach
function reverse(array)
{
 
    // Length of the array
    let n = array.length;
     
    // Swaping the first half elements
    // with last half elements
    for(let i = 0; i < n / 2; i++)
    {
     
        // Storing the first half
        // elements temporarily
        let 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 leto K subarrays
// with minimum sum of absolute difference
// of adjacent elements in each of K subarrays
function absoluteDifference(arr, N, K)
{
 
    // Stores the absolute differences
    // of adjacent elements
    let new_Arr = new Array(N - 1).fill(0);
     
    // Stores the answer
    let ans = 0;
     
    // Stores absolute differences of
    // adjacent elements in new_Arr
    for(let 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
    new_Arr.sort();
    reverse(new_Arr);
     
    for(let i = 0; i < K - 1; i++)
    {
     
        // Removing K - 1 elements
        // with maximum sum
        ans -= new_Arr[i];
    }
     
    // Print the answer
    document.write(ans);
}
 
// Driver Code
 
// Given array arr[]
let arr = [ 1, 3, -2, 5, -1 ];
 
// Given K
let K = 2;
 
// Size of array
let N = arr.length;
 
// Function Call
absoluteDifference(arr, N, K);
 
// This code is contributed by splevel62
 

输出：

13

时间复杂度： O(N * Log(N))
辅助空间： O(N)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live