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:**

- 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).
- Then

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

here we can remove the middle element to reduce the size of the original sequence.

- 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.
- Stores all the removed elements in the set. Add the cost of removed elements. Finally, calculate the sum sequence by excluding removed elements.
- 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 <bits/stdc++.h> ` `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] or ` ` ` `// 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; ` `} ` |

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

**Output:**

7, 1

**Time Complexity: **O(N)

## Recommended Posts:

- Maximum subsequence sum with adjacent elements having atleast K difference in index
- Maximum length subsequence such that adjacent elements in the subsequence have a common factor
- Maximum subsequence sum of at most K-distant adjacent elements
- Minimal product subsequence where adjacent elements are separated by a maximum distance of K
- Smallest subsequence with sum of absolute difference of consecutive elements maximized
- Maximum sum of difference of adjacent elements
- Minimize the maximum difference between adjacent elements in an array
- Minimize the maximum difference of adjacent elements after at most K insertions
- Maximum length subarray with difference between adjacent elements as either 0 or 1
- Minimize the maximum absolute difference of adjacent elements in a circular array
- Missing occurrences of a number in an array such that maximum absolute difference of adjacent elements is minimum
- Minimize the cost to make all the adjacent elements distinct in an Array
- Minimum cost of reducing Array by merging any adjacent elements repetitively
- Length of the longest subsequence such that xor of adjacent elements is non-decreasing
- Longest subsequence such that adjacent elements have at least one common digit
- Length of the longest increasing subsequence such that no two adjacent elements are coprime
- Length of Smallest Subsequence such that sum of elements is greater than equal to K
- Sort elements of an array in increasing order of absolute difference of adjacent elements
- Maximum sum such that no two elements are adjacent | Set 2
- Maximum sum such that no two elements are adjacent

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.