将数组拆分为子数组，以使它们的最大值和最小值之差之和最大

给定一个由N个整数组成的数组arr [] ，任务是将数组拆分为子数组，以使所有子数组的最大元素和最小元素之差之和为最大。

例子：

Input: arr[] = {8, 1, 7, 9, 2}
Output: 14
Explanation:
Consider splitting the given array into subarrays as {8, 1} and {7, 9, 2}. Now, the difference between maximum and minimum elements are:

• {8, 1}: Difference is (8 – 1) = 7.
• {7, 9, 2}: Difference is (9 – 2) = 7.

Therefore, the sum of the difference is 7 + 7 = 14.

Input: arr[] = {1, 2, 1, 0, 5}
Output: 6

方法：可以通过使用动态编程解决给定的问题。请按照以下步骤解决问题：

• 初始化一个数组，例如dp [] ，其中dp [i]表示第一个i数组元素的所有子数组的最大和最小元素之差的最大和。
• 将dp [0]初始化为0 。
• 在[1，N – 1]范围内遍历给定数组，然后执行以下步骤：
  • 初始化一个变量，例如min为arr [i] ，该变量存储范围为[0，i]的最小元素。
  • 初始化一个变量，例如max作为arr [i] ，该变量存储范围[0，i]内的最大元素。
  • 以相反的顺序使用变量j遍历[0，i]范围，并执行以下步骤：
    • 将min的值更新为min和arr [j]的最小值。
    • 将max的值更新为max和arr [j]的最小值。
    • DP [j]的值更新为最大DP [j]与的(最大-最小+ DP [I])。
• 完成上述步骤后，打印dp [N – 1]的值作为结果。

下面是上述方法的实现：

Java

// Java program for the above approach
  
import java.util.*;
public class Main {
  
    // Function to find maximum sum of
    // difference between maximums and
    // minimums in the splitted subarrays
    static int getValue(int[] arr, int N)
    {
        int dp[] = new int[N];
  
        // Base Case
        dp[0] = 0;
  
        // Traverse the array
        for (int i = 1; i < N; i++) {
  
            // Stores the maximum and
            // minimum elements upto
            // the i-th index
            int min = arr[i];
            int max = arr[i];
  
            // Traverse the range [0, i]
            for (int j = i; j >= 0; j--) {
  
                // Update the minimum
                min = Math.min(arr[j], min);
  
                // Update the maximum
                max = Math.max(arr[j], max);
  
                // Update dp[i]
                dp[i] = Math.max(
                    dp[i],
                    max - min + ((j >= 1)
                                     ? dp[j - 1]
                                     : 0));
            }
        }
  
        // Return the maximum
        // sum of difference
        return dp[N - 1];
    }
  
    // Driver Code
    public static void main(String args[])
    {
        int arr[] = { 8, 1, 7, 9, 2 };
        int N = arr.length;
        System.out.println(getValue(arr, N));
    }
}

输出：

14

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