创建最小子序列且相邻元素之间的差之和最大的成本

给定N个整数的两个数组arr []和costArray [] ，表示与每个元素关联的去除成本。任务是从给定的最小成本数组中找到子序列，以使相邻元素之间的差异之和最大。删除每个元素都会产生成本。
例子：

Input: N = 3, arr[] = { 3, 2, 1 }, costArray[] = {0, 1, 0} 
Output: 4, 1 
Explanation: 
There are 4 subsequences of length at least 2 : 
[ 3, 2 ] which gives us | 3 – 2 | = 1 
[ 3, 1 ] which gives us | 3 – 1 | = 2 
[ 2, 1 ] which gives us | 2 – 1 | = 1 
[ 3, 2, 1 ] which gives us | 3 – 2 | + | 2 – 1 | = 2 
So the answer is either [ 3, 1 ] or [ 3, 2, 1 ] . Since we want the subsequence to be as short as possible, the answer is [ 3, 1 ]. Cost incurrent removing element 2 is 1. 
So, the sum of the sequence is 4. 
and the cost is 1.

Input: N = 4, arr[] = { 1, 3, 4, 2}, costArray[] = {0, 1, 0, 0} 
Output: 7, 1

天真的方法：
天真的方法只是通过递归生成所有子序列来检查所有子序列，并且它采用了O(2 ^ N)的复杂度，这是非常高的复杂度。然后从它们中选择遵循上述条件的子序列，如上所述，该子序列具有最大绝对和和最小长度。
高效方法：

1. 我们可以观察到这种模式，让我们假设三个数字a，b，c使得a = L，b = L + 6，c = L + 10(L是此处的任何整数)。如果它们处于连续模式，例如a，b，c(例如a
2. 然后

   | b – a | + | c – b | = | a – c | = 10

3. 在这里，我们可以删除中间元素以减小原始序列的大小。
4. 这样，通过从序列中删除中间元素来减小数组的大小不会影响总和，也不会减小序列的长度。
5. 将所有已删除的元素存储在集合中。添加已删除元素的成本。最后，通过排除删除的元素来计算总和序列。
6. 然后打印子序列元素的总和和发生的成本。

这样，我们将指数复杂度O(2 ^ N)降低为线性复杂度O(N)。

下面是上述方法的实现：

C++

#include 
using namespace std;
  
void costOfSubsequence(
    int N, int arr[],
    int costArray[])
{
    int i, temp;
    // initialising cost=0
    int cost = 0;
  
    // to store the removed
    // element
    set removedElements;
  
    // this will store the sum
    // of the subsecquence
    int ans = 0;
  
    // checking all the element
    // of the vector
    for (i = 1; i < (N - 1); i++) {
        // storing the value of
        // arr[i] in temp variable
        temp = arr[i];
  
        // if the situation like
        // arr[i-1]arr[i]>arr[i+1] occur
        // remove arr[i] i.e, temp
        // from secquence
        if (((arr[i - 1] < temp)
             && (temp < arr[i + 1]))
            || ((arr[i - 1] > temp)
                && (temp > arr[i + 1]))) {
            // insert the element in the set
            // removedElements
            removedElements.insert(temp);
        }
    }
    for (i = 0; i < (N); i++) {
        // storing the value of
        // arr[i] in temp
        temp = arr[i];
        // taking the elemet not
        // in removedElements
        if (!(removedElements.count(temp) > 0)) {
            // adding the value of elements
            // of subsequence
            ans += arr[i];
        }
        else {
            // if we have to remove
            // the element then we
            // need to add the  cost
            // associated with the
            // element
            cost += costArray[i];
        }
    }
  
    // printing the sum of
    // the subsecquence with
    // minimum length possible
    cout << ans << ", ";
    // printint the cost incurred
    // in creating subsequence
    cout << cost << endl;
}
  
// Driver code
int main()
{
  
    int N;
    N = 4;
    int arr[N]
        = { 1, 3, 4, 2 };
    int costArray[N]
        = { 0, 1, 0, 0 };
  
    // calling the function
    costOfSubsequence(
        N, arr,
        costArray);
  
    return 0;
}

Java

import java.util.*; 
class GFG{
      
public static void costOfSubsequence(int N, int[] arr,
                                     int[] costArray) 
{ 
    int i, temp; 
      
    // Initialising cost=0 
    int cost = 0; 
      
    // To store the removed 
    // element 
    Set removedElements = new HashSet(); 
      
    // This will store the sum 
    // of the subsecquence 
    int ans = 0; 
      
    // Checking all the element 
    // of the vector 
    for(i = 1; i < (N - 1); i++)
    { 
          
       // Storing the value of 
       // arr[i] in temp variable 
       temp = arr[i]; 
         
       // If the situation like 
       // arr[i-1]arr[i]>arr[i+1] occur 
       // remove arr[i] i.e, temp 
       // from secquence 
       if (((arr[i - 1] < temp) && 
          (temp < arr[i + 1])) || 
           ((arr[i - 1] > temp) && 
          (temp > arr[i + 1]))) 
       { 
             
           // Insert the element in the set 
           // removedElements 
           removedElements.add(temp); 
       } 
    } 
    for(i = 0; i < (N); i++)
    { 
         
       // Storing the value of 
       // arr[i] in temp 
       temp = arr[i]; 
         
       // Taking the elemet not 
       // in removedElements 
       if (!(removedElements.contains(temp)))
       { 
             
           // Adding the value of elements 
           // of subsequence 
           ans += arr[i]; 
       } 
       else
       { 
             
           // If we have to remove 
           // the element then we 
           // need to add the cost 
           // associated with the 
           // element 
           cost += costArray[i]; 
       } 
    } 
      
    // Printing the sum of 
    // the subsecquence with 
    // minimum length possible 
    System.out.print(ans + ", ");
      
    // Printing the cost incurred 
    // in creating subsequence 
    System.out.print(cost);
}
  
// Driver code
public static void main(String[] args)
{
    int N; 
    N = 4; 
      
    int[] arr = { 1, 3, 4, 2 }; 
    int[] costArray = { 0, 1, 0, 0 }; 
      
    // Calling the function 
    costOfSubsequence(N, arr, costArray); 
}
}
  
// This code is contributed by divyeshrabadiya07

Python3

def costOfSubsequence(N, arr, costArray):
      
    # Initialising cost=0
    i, temp, cost = 0, 0, 0
  
    # To store the removed
    # element
    removedElements = {''}
  
    # This will store the sum
    # of the subsecquence
    ans = 0
  
    # Checking all the element
    # of the vector
    for i in range(1, N - 1):
          
        # Storing the value of
        # arr[i] in temp variable
        temp = arr[i]
  
        # If the situation like
        # arr[i-1]arr[i]>arr[i+1] occur
        # remove arr[i] i.e, temp
        # from secquence
        if (((arr[i - 1] < temp) and 
            (temp < arr[i + 1])) or 
            ((arr[i - 1] > temp) and 
            (temp > arr[i + 1]))) :
                  
            # Insert the element in the set
            # removedElements
            removedElements.add(temp)
  
    for i in range(0, N):
          
        # Storing the value of
        # arr[i] in temp
        temp = arr[i]
          
        # Taking the elemet not
        # in removedElements
        if(temp not in removedElements):
              
            # Adding the value of elements
            # of subsequence
            ans = ans + arr[i]
        else:
              
            # If we have to remove
            # the element then we
            # need to add the cost
            # associated with the
            # element
            cost += costArray[i]
  
    # Printing the sum of
    # the subsecquence with
    # minimum length possible
    print(ans, end = ", ")
      
    # Printint the cost incurred
    # in creating subsequence
    print(cost)
  
# Driver code
N = 4
arr = [ 1, 3, 4, 2 ]
costArray = [ 0, 1, 0, 0 ]
  
# Calling the function
costOfSubsequence(N, arr, costArray)
  
# This code is contributed by Sanjit_Prasad

C#

using System;
using System.Collections.Generic;
  
class GFG{
      
public static void costOfSubsequence(int N, int[] arr,
                                     int[] costArray) 
{ 
    int i, temp; 
      
    // Initialising cost=0 
    int cost = 0; 
      
    // To store the removed 
    // element 
    HashSet removedElements = new HashSet(); 
      
    // This will store the sum 
    // of the subsecquence 
    int ans = 0; 
      
    // Checking all the element 
    // of the vector 
    for(i = 1; i < (N - 1); i++)
    { 
          
        // Storing the value of 
        // arr[i] in temp variable 
        temp = arr[i]; 
              
        // If the situation like 
        // arr[i-1]arr[i]>arr[i+1] occur 
        // remove arr[i] i.e, temp 
        // from secquence 
        if (((arr[i - 1] < temp) && 
            (temp < arr[i + 1])) || 
            ((arr[i - 1] > temp) && 
            (temp > arr[i + 1]))) 
        { 
                  
            // Insert the element in the set 
            // removedElements 
            removedElements.Add(temp); 
        } 
    } 
    for(i = 0; i < (N); i++)
    { 
          
        // Storing the value of 
        // arr[i] in temp 
        temp = arr[i]; 
              
        // Taking the elemet not 
        // in removedElements 
        if (!(removedElements.Contains(temp)))
        { 
              
            // Adding the value of elements 
            // of subsequence 
            ans += arr[i]; 
        } 
        else
        { 
              
            // If we have to remove 
            // the element then we 
            // need to add the cost 
            // associated with the 
            // element 
            cost += costArray[i]; 
        } 
    } 
      
    // Printing the sum of 
    // the subsecquence with 
    // minimum length possible 
    Console.Write(ans + ", ");
      
    // Printing the cost incurred 
    // in creating subsequence 
    Console.Write(cost);
}
  
// Driver code
public static void Main(String[] args)
{
    int N; 
    N = 4; 
      
    int[] arr = { 1, 3, 4, 2 }; 
    int[] costArray = { 0, 1, 0, 0 }; 
      
    // Calling the function 
    costOfSubsequence(N, arr, costArray); 
}
}
  
// This code is contributed by Amit Katiyar

输出：

7, 1

时间复杂度： O(N)