最大化arr [j] – arr [i] + arr [l] – arr [k]，使得i <j <k <l

最大化arr [j] – arr [i] + arr [l] – arr [k]，使i

例子：

Let us say our array is {4, 8, 9, 2, 20}
Then the maximum such value is 23 (9 - 4 + 20 - 2)

蛮力法：
我们可以简单地找到具有给定约束的大小为4的所有组合。最大值将是必需的答案。这种方法效率很低。

高效方法(动态编程)：
我们将使用动态编程来解决此问题。为此，我们创建了四个一维DP表。

我们说有四个DP表，分别是– table1 []，table2 []，table3 []，table4 []

然后找到arr [l] – arr [k] + arr [j] – arr [i]的最大值，使得i

table1 []应该存储arr [l]的最大值
table2 []应该存储arr [l] – arr [k]的最大值
table3 []应该存储arr [l]的最大值– arr [k] + arr [j]
table4 []应该存储arr [l] – arr [k] + arr [j] – arr [i]的最大值

然后，最大值将出现在表4的索引0中，这将是我们所需的答案。

以下是上述想法的实现–

C++

/* A C++ Program to find maximum value of
arr[l] - arr[k] + arr[j] - arr[i] and i < j < k < l,
given that the array has atleast 4 elements */
#include 
using namespace std;
  
// To reprsent minus infinite
#define MIN -100000000
  
// A Dynamic Programing based function to find maximum
// value of arr[l] - arr[k] + arr[j] - arr[i] is maximum
// and i < j < k < l
int findMaxValue(int arr[], int n)
{
    // If the array has less than 4 elements
    if (n < 4)
    {
        printf("The array should have atlest 4 elements\n");
        return MIN;
    }
  
    // We create 4 DP tables
    int table1[n + 1], table2[n], table3[n - 1], table4[n - 2];
  
    // Initialize all the tables to MIN
    for (int i=0; i<=n; i++)
        table1[i] = table2[i] = table3[i] = table4[i] =  MIN;
  
    // table1[] stores the maximum value of arr[l]
    for (int i = n - 1; i >= 0; i--)
        table1[i] = max(table1[i + 1], arr[i]);
  
    // table2[] stores the maximum value of arr[l] - arr[k]
    for (int i = n - 2; i >= 0; i--)
        table2[i] = max(table2[i + 1], table1[i + 1] - arr[i]);
  
    // table3[] stores the maximum value of arr[l] - arr[k]
    // + arr[j]
    for (int i = n - 3; i >= 0; i--)
        table3[i] = max(table3[i + 1], table2[i + 1] + arr[i]);
  
    // table4[] stores the maximum value of arr[l] - arr[k]
    // + arr[j] - arr[i]
    for (int i = n - 4; i >= 0; i--)
        table4[i] = max(table4[i + 1], table3[i + 1] - arr[i]);
  
    /*for (int i = 0; i < n + 1; i++)
        cout << table1[i] << " " ;
    cout << endl;
  
    for (int i = 0; i < n; i++)
        cout << table2[i] << " " ;
    cout << endl;
  
    for (int i = 0; i < n - 1; i++)
        cout << table3[i] << " " ;
    cout << endl;
  
    for (int i = 0; i < n - 2; i++)
        cout << table4[i] << " " ;
    cout << endl;
    */
  
    // maximum value would be present in table4[0]
    return table4[0];
}
  
// Driver Program to test above functions
int main()
{
    int arr[] = { 4, 8, 9, 2, 20 };
    int n = sizeof(arr) / sizeof(arr[0]);
  
    printf("%d\n", findMaxValue(arr, n));
  
    return 0;
}

Java

/* A Java Program to find maximum value of 
arr[l] - arr[k] + arr[j] - arr[i] and i < j < k < l, 
given that the array has atleast 4 elements */
import java.util.Arrays;
  
class GFG
{
    // A Dynamic Programing based function 
    // to find maximum value of 
    // arr[l] - arr[k] + arr[j] - arr[i] 
    // is maximum and i < j < k < l
    static int findMaxValue(int[] arr, int n)
    {
  
        // If the array has less than 4 elements
        if (n < 4) 
        {
            System.out.println("The array should have" + 
                               " atleast 4 elements");
        }
  
        // We create 4 DP tables
        int table1[] = new int[n + 1];
        int table2[] = new int[n];
        int table3[] = new int[n - 1];
        int table4[] = new int[n - 2];
  
        // Initialize all the tables to minus Infinity
        Arrays.fill(table1, Integer.MIN_VALUE);
        Arrays.fill(table2, Integer.MIN_VALUE);
        Arrays.fill(table3, Integer.MIN_VALUE);
        Arrays.fill(table4, Integer.MIN_VALUE);
  
        // table1[] stores the maximum value of arr[l]
        for (int i = n - 1; i >= 0; i--)
        {
            table1[i] = Math.max(table1[i + 1], arr[i]);
        }
  
        // table2[] stores the maximum value of 
        // arr[l] - arr[k]
        for (int i = n - 2; i >= 0; i--) 
        {
            table2[i] = Math.max(table2[i + 1], 
                                 table1[i + 1] - arr[i]);
        }
  
        // table3[] stores the maximum value of 
        // arr[l] - arr[k] + arr[j]
        for (int i = n - 3; i >= 0; i--)
            table3[i] = Math.max(table3[i + 1], 
                                 table2[i + 1] + arr[i]);
  
        // table4[] stores the maximum value of 
        // arr[l] - arr[k] + arr[j] - arr[i]
        for (int i = n - 4; i >= 0; i--)
            table4[i] = Math.max(table4[i + 1],
                                 table3[i + 1] - arr[i]);
  
        return table4[0];
    }
  
    // Driver Code
    public static void main(String[] args)
    {
        int arr[] = { 4, 8, 9, 2, 20 };
        int n = arr.length;
        System.out.println(findMaxValue(arr, n));
    }
}
  
// This code is contributed by Vivekkumar Singh

Python3

# A Python3 Program to find maximum value of
# arr[l] - arr[k] + arr[j] - arr[i] and i < j < k < l,
# given that the array has atleast 4 elements
  
# A Dynamic Programing based function to find
# maximum value of arr[l] - arr[k] + arr[j] - arr[i]
# is maximum and i < j < k < l
def findMaxValue(arr, n):
  
    # If the array has less than 4 elements
    if n < 4:
      
        print("The array should have atlest 4 elements")
        return MIN
  
    # We create 4 DP tables
    table1, table2 = [MIN] * (n + 1), [MIN] * n
    table3, table4 = [MIN] * (n - 1), [MIN] * (n - 2)
  
    # table1[] stores the maximum value of arr[l]
    for i in range(n - 1, -1, -1):
        table1[i] = max(table1[i + 1], arr[i])
  
    # table2[] stores the maximum
    # value of arr[l] - arr[k]
    for i in range(n - 2, -1, -1):
        table2[i] = max(table2[i + 1], 
                        table1[i + 1] - arr[i])
  
    # table3[] stores the maximum value of
    # arr[l] - arr[k] + arr[j]
    for i in range(n - 3, -1, -1):
        table3[i] = max(table3[i + 1], 
                        table2[i + 1] + arr[i])
  
    # table4[] stores the maximum value of
    # arr[l] - arr[k] + arr[j] - arr[i]
    for i in range(n - 4, -1, -1):
        table4[i] = max(table4[i + 1], 
                        table3[i + 1] - arr[i])
  
    # maximum value would be present in table4[0]
    return table4[0]
  
# Driver Code
if __name__ == "__main__":
  
    arr = [4, 8, 9, 2, 20]
    n = len(arr)
      
    # To reprsent minus infinite
    MIN = -100000000
  
    print(findMaxValue(arr, n))
  
# This code is contributed by Rituraj Jain

C#

// C# Program to find maximum value of 
// arr[l] - arr[k] + arr[j] - arr[i] 
// and i < j < k < l, given that 
// the array has atleast 4 elements 
using System;
  
class GFG
{
    // A Dynamic Programing based function 
    // to find maximum value of 
    // arr[l] - arr[k] + arr[j] - arr[i] 
    // is maximum and i < j < k < l
    static int findMaxValue(int[] arr, int n)
    {
  
        // If the array has less than 4 elements
        if (n < 4) 
        {
            Console.WriteLine("The array should have" + 
                              " atleast 4 elements");
        }
  
        // We create 4 DP tables
        int []table1 = new int[n + 1];
        int []table2 = new int[n];
        int []table3 = new int[n - 1];
        int []table4 = new int[n - 2];
  
        // Initialize all the tables to minus Infinity
        fill(table1, int.MinValue);
        fill(table2, int.MinValue);
        fill(table3, int.MinValue);
        fill(table4, int.MinValue);
  
        // table1[] stores the maximum value of arr[l]
        for (int i = n - 1; i >= 0; i--)
        {
            table1[i] = Math.Max(table1[i + 1], arr[i]);
        }
  
        // table2[] stores the maximum value of 
        // arr[l] - arr[k]
        for (int i = n - 2; i >= 0; i--) 
        {
            table2[i] = Math.Max(table2[i + 1], 
                                 table1[i + 1] - arr[i]);
        }
  
        // table3[] stores the maximum value of 
        // arr[l] - arr[k] + arr[j]
        for (int i = n - 3; i >= 0; i--)
            table3[i] = Math.Max(table3[i + 1], 
                                 table2[i + 1] + arr[i]);
  
        // table4[] stores the maximum value of 
        // arr[l] - arr[k] + arr[j] - arr[i]
        for (int i = n - 4; i >= 0; i--)
            table4[i] = Math.Max(table4[i + 1],
                                 table3[i + 1] - arr[i]);
  
        return table4[0];
    }
    static void fill(int [] arr, int val)
    {
        for(int i = 0; i < arr.Length; i++)
            arr[i] = val;
    }
      
    // Driver Code
    public static void Main(String[] args)
    {
        int []arr = { 4, 8, 9, 2, 20 };
        int n = arr.Length;
        Console.WriteLine(findMaxValue(arr, n));
    }
}
  
// This code is contributed by Princi Singh

输出：

23

时间复杂度： O(n)，其中n是输入数组的大小
辅助空间：由于我们要创建四个表来存储值，因此空间为4 * O(n)= O(4 * n)= O(n)

读者练习：
这个问题既简单又强大。可以将问题推广到给定条件下的任何表达式。求出arr [j] – 2 * arr [i] + 3 * arr [l] – 7 * arr [k]的最大值，这样i