# Cost of creating smallest subsequence with sum of difference between adjacent elements maximum

Given two array of N integers arr[] and costArray[], representing removal cost associated with each element. The task is to find the subsequence from the given array of minimum cost such that the sum of the difference between adjacent elements is maximum. On removing each element, cost is incurred.
Examples:

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

Naive Approach:
The naive approach is simply to check all the subsequences by generating them by recursion and it takes the complexity of O(2^N) which is very high complexity. And from them choose the subsequence which follows the above condition with maximum absolute sum and a minimum length as mentioned above.
Efficient Approach:

1. We can observe the pattern, let us assume three numbers a, b, c such that a = L, b = L + 6, c = L + 10 (L is any integer here). If they are in a continuous pattern one after another eg a, b, c (such that a < b < c).
2. Then

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

3. here we can remove the middle element to reduce the size of the original sequence.
4. In this way, reducing the size of the array by removing a middle element from the sequence will not affect the sum and also reduce the length of the sequence.
5. Stores all the removed elements in the set. Add the cost of removed elements. Finally, calculate the sum sequence by excluding removed elements.
6. Then print the sum of elements of subsequence and cost incurred.

In this way, we reduce the exponential complexity O(2^N) to the linear complexity O(N).

Below is the implementation of the above approach:

## 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<``int``> 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<``int``> removedElements = ``new` `HashSet<``int``>();  ` `     `  `    ``// 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 `

Output:

```7, 1
```

Time Complexity: O(N) My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.