给定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)的复杂度，这是非常高的复杂度。然后从它们中选择遵循上述条件的子序列，如上所述，该子序列具有最大绝对和和最小长度。
高效方法：
- 我们可以观察到这种模式，让我们假设三个数字a，b，c使得a = L，b = L + 6，c = L + 10(L是此处的任何整数)。如果它们处于连续模式，例如a，b，c(例如a
- 然后
| b – a | + | c – b | = | a – c | = 10
- 在这里，我们可以删除中间元素以减小原始序列的大小。
- 这样，通过从序列中删除中间元素来减小数组的大小不会影响总和，也不会减小序列的长度。
- 将所有已删除的元素存储在集合中。添加已删除元素的成本。最后，通过排除删除的元素来计算总和序列。
- 然后打印子序列元素的总和和发生的成本。
这样，我们将指数复杂度O(2 ^ N)降低为线性复杂度O(N)。
下面是上述方法的实现：
C++
#include
using namespace std;
void costOfSubsequence(
int N, int arr[],
int costArray[])
{
int i, temp;
// initializing cost=0
int cost = 0;
// to store the removed
// element
set removedElements;
// this will store the sum
// of the subsequence
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 sequence
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 element 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 << ", ";
// printing 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;
// Initializing cost=0
int cost = 0;
// To store the removed
// element
Set removedElements = new HashSet();
// This will store the sum
// of the subsequence
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 sequence
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 element 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):
# Initializing cost=0
i, temp, cost = 0, 0, 0
# To store the removed
# element
removedElements = {''}
# This will store the sum
# of the subsequence
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 sequence
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 element 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 subsequence with
# minimum length possible
print(ans, end = ", ")
# Printing 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;
// Initializing cost=0
int cost = 0;
// To store the removed
// element
HashSet removedElements = new HashSet();
// This will store the sum
// of the subsequence
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 sequence
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 element 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 subsequence 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)
如果您希望与行业专家一起参加现场课程，请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。