Given an array of **n** elements. Make strictly increasing and strictly decreasing subsequences from the array such that each array element belongs to increasing subsequence or decreasing subsequence, but not both, or can be part of none of the subsequence. Minimize the number of elements which are not part of any of the subsequences and find the count of such elements.

**Examples:**

Input :arr[] = { 7, 8, 1, 2, 4, 6, 3, 5, 2, 1, 8, 7 }Output :2 Increasing sequence can be { 1, 2, 4, 5, 8 }. Decreasing sequence can be { 7, 6, 3, 2, 1 }. So, only 2 (8, 7) element is left which are not part of either of the subsequences.Input :arr[] = { 1, 4, 2, 3, 3, 2, 4, 1 }Output :0 Increasing sequence can be { 1, 2, 3, 4 }. Decreasing sequence can be { 4, 3, 2, 1 }. So, no element is left which is not part of either of the subsequences.

The idea is to make a decision on each index, starting from index 0, one by one. For each index there can be three possibilities, first, it can belong to increasing sequence, second, it can belong to decreasing sequence, third, it does not belong to any of these sequences.

So, for each index, check for the optimal answer (minimum element which is not part of any of the subsequences) by considering it once as a part of increasing subsequence or as a part of decreasing subsequence. If the optimal answer cannot be achieved by them then leave it as the element which is not part of any of the sequence.

To decrease the complexity (using Dynamic Programming), we can store the number of elements which are not part of any of the subsequences using 3D array dp[x][y][z], where x indicates the decision index, y indicates the last index of decreasing sequence, z indicates the last index of increasing sequence.

Below is the implementation of this approach:

## C++

`// C++ program to return minimum number of elements which ` `// are not part of increasing or decreasing subsequences. ` `#include<bits/stdc++.h> ` `#define MAX 102 ` `using` `namespace` `std; ` ` ` `// Return minimum number of elements which is not part of ` `// any of the sequence. ` `int` `countMin(` `int` `arr[], ` `int` `dp[MAX][MAX][MAX], ` `int` `n, ` `int` `dec, ` ` ` `int` `inc, ` `int` `i) ` `{ ` ` ` `// If already calculated, return value. ` ` ` `if` `(dp[dec][inc][i] != -1) ` ` ` `return` `dp[dec][inc][i]; ` ` ` ` ` `// If whole array is traversed. ` ` ` `if` `(i == n) ` ` ` `return` `0; ` ` ` ` ` `// calculating by considering element as part of ` ` ` `// decreasing sequence. ` ` ` `if` `(arr[i] < arr[dec]) ` ` ` `dp[dec][inc][i] = countMin(arr, dp, n, i, inc, i + 1); ` ` ` ` ` `// calculating by considering element as part of ` ` ` `// increasing sequence. ` ` ` `if` `(arr[i] > arr[inc]) ` ` ` `{ ` ` ` `// If cannot be calculated for decreasing sequence. ` ` ` `if` `(dp[dec][inc][i] == -1) ` ` ` `dp[dec][inc][i] = countMin(arr, dp, n, dec, i, i + 1); ` ` ` ` ` `// After considering once by decreasing sequence, now try ` ` ` `// for increasing sequence. ` ` ` `else` ` ` `dp[dec][inc][i] = min(countMin(arr, dp, n, dec, i, i + 1), ` ` ` `dp[dec][inc][i]); ` ` ` `} ` ` ` ` ` `// If element cannot be part of any of the sequence. ` ` ` `if` `(dp[dec][inc][i] == -1) ` ` ` `dp[dec][inc][i] = 1 + countMin(arr, dp, n, dec, inc, i + 1); ` ` ` ` ` `// After considering element as part of increasing and ` ` ` `// decreasing sequence trying as not part of any of the ` ` ` `// sequence. ` ` ` `else` ` ` `dp[dec][inc][i] = min(1 + countMin(arr, dp, n, dec, inc, i + 1), ` ` ` `dp[dec][inc][i]); ` ` ` ` ` `return` `dp[dec][inc][i]; ` `} ` ` ` `// Wrapper Function ` `int` `wrapper(` `int` `arr[], ` `int` `n) ` `{ ` ` ` `// Adding two number at the end of array, so that ` ` ` `// increasing and decreasing sequence can be made. ` ` ` `// MAX - 2 index is assigned INT_MAX for decreasing sequence ` ` ` `// because/ next number of sequence must be less than it. ` ` ` `// Similarly, for Increasing sequence INT_MIN is assigned to ` ` ` `// MAX - 1 index. ` ` ` `arr[MAX - 2] = INT_MAX; ` ` ` `arr[MAX - 1] = INT_MIN; ` ` ` ` ` `int` `dp[MAX][MAX][MAX]; ` ` ` `memset` `(dp, -1, ` `sizeof` `dp); ` ` ` ` ` `return` `countMin(arr, dp, n, MAX - 2, MAX - 1, 0); ` `} ` ` ` `// Driven Program ` `int` `main() ` `{ ` ` ` `int` `n = 12; ` ` ` `int` `arr[MAX] = { 7, 8, 1, 2, 4, 6, 3, 5, 2, 1, 8, 7 }; ` ` ` ` ` `cout << wrapper(arr, n) << endl; ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java program to return minimum number of ` `// elements which are not part of increasing ` `// or decreasing subsequences. ` `import` `java.util.*; ` ` ` `class` `GFG ` `{ ` ` ` `static` `int` `MAX = ` `102` `; ` ` ` `// Return minimum number of elements which is ` `// not part of any of the sequence. ` `static` `int` `countMin(` `int` `arr[], ` `int` `dp[][][], ` `int` `n, ` ` ` `int` `dec, ` `int` `inc, ` `int` `i) ` `{ ` ` ` `// If already calculated, return value. ` ` ` `if` `(dp[dec][inc][i] != -` `1` `) ` ` ` `return` `dp[dec][inc][i]; ` ` ` ` ` `// If whole array is traversed. ` ` ` `if` `(i == n) ` ` ` `return` `0` `; ` ` ` ` ` `// calculating by considering element as ` ` ` `// part of decreasing sequence. ` ` ` `if` `(arr[i] < arr[dec]) ` ` ` `dp[dec][inc][i] = countMin(arr, dp, n, i, ` ` ` `inc, i + ` `1` `); ` ` ` ` ` `// calculating by considering element as ` ` ` `// part of increasing sequence. ` ` ` `if` `(arr[i] > arr[inc]) ` ` ` `{ ` ` ` `// If cannot be calculated for ` ` ` `// decreasing sequence. ` ` ` `if` `(dp[dec][inc][i] == -` `1` `) ` ` ` `dp[dec][inc][i] = countMin(arr, dp, n, ` ` ` `dec, i, i + ` `1` `); ` ` ` ` ` `// After considering once by decreasing sequence, ` ` ` `// now try for increasing sequence. ` ` ` `else` ` ` `dp[dec][inc][i] = Math.min(countMin(arr, dp, n, ` ` ` `dec, i, i + ` `1` `), ` ` ` `dp[dec][inc][i]); ` ` ` `} ` ` ` ` ` `// If element cannot be part of any of the sequence. ` ` ` `if` `(dp[dec][inc][i] == -` `1` `) ` ` ` `dp[dec][inc][i] = ` `1` `+ countMin(arr, dp, n, ` ` ` `dec, inc, i + ` `1` `); ` ` ` ` ` `// After considering element as part of increasing and ` ` ` `// decreasing sequence trying as not part of any of the ` ` ` `// sequence. ` ` ` `else` ` ` `dp[dec][inc][i] = Math.min(` `1` `+ countMin(arr, dp, n, ` ` ` `dec, inc, i + ` `1` `), ` ` ` `dp[dec][inc][i]); ` ` ` ` ` `return` `dp[dec][inc][i]; ` `} ` ` ` `// Wrapper Function ` `static` `int` `wrapper(` `int` `arr[], ` `int` `n) ` `{ ` ` ` `// Adding two number at the end of array, ` ` ` `// so that increasing and decreasing sequence ` ` ` `// can be made. MAX - 2 index is assigned ` ` ` `// INT_MAX for decreasing sequence because ` ` ` `// next number of sequence must be less than it. ` ` ` `// Similarly, for Increasing sequence INT_MIN ` ` ` `// is assigned to MAX - 1 index. ` ` ` `arr[MAX - ` `2` `] = Integer.MAX_VALUE; ` ` ` `arr[MAX - ` `1` `] = Integer.MIN_VALUE; ` ` ` ` ` `int` `[][][]dp = ` `new` `int` `[MAX][MAX][MAX]; ` ` ` `for` `(` `int` `i = ` `0` `; i < MAX; i++) ` ` ` `{ ` ` ` `for` `(` `int` `j = ` `0` `; j < MAX; j++) ` ` ` `{ ` ` ` `for` `(` `int` `l = ` `0` `; l < MAX; l++) ` ` ` `dp[i][j][l] = -` `1` `; ` ` ` `} ` ` ` `} ` ` ` ` ` `return` `countMin(arr, dp, n, MAX - ` `2` `, ` ` ` `MAX - ` `1` `, ` `0` `); ` `} ` ` ` `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` ` ` `int` `n = ` `12` `; ` ` ` `int` `[] arr = ` `new` `int` `[MAX]; ` ` ` `arr[` `0` `] = ` `7` `; ` ` ` `arr[` `1` `] = ` `8` `; ` ` ` `arr[` `2` `] = ` `1` `; ` ` ` `arr[` `3` `] = ` `2` `; ` ` ` `arr[` `4` `] = ` `4` `; ` ` ` `arr[` `5` `] = ` `6` `; ` ` ` `arr[` `6` `] = ` `3` `; ` ` ` `arr[` `7` `] = ` `5` `; ` ` ` `arr[` `8` `] = ` `2` `; ` ` ` `arr[` `9` `] = ` `1` `; ` ` ` `arr[` `10` `] = ` `8` `; ` ` ` `arr[` `11` `] = ` `7` `; ` ` ` ` ` `System.out.println(wrapper(arr, n)); ` `} ` `} ` ` ` `// This code is contributed by 29AjayKumar ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to return minimum number of elements which ` `# are not part of increasing or decreasing subsequences. ` `MAX` `=` `102` ` ` `# Return minimum number of elements which is not part of ` `# any of the sequence. ` ` ` `def` `countMin(arr,dp,n,dec,inc,i): ` ` ` ` ` `# If already calculated, return value. ` ` ` `if` `dp[dec][inc][i] !` `=` `-` `1` `: ` ` ` `return` `dp[dec][inc][i] ` ` ` ` ` `# If whole array is traversed. ` ` ` `if` `i` `=` `=` `n: ` ` ` `return` `0` ` ` ` ` `# calculating by considering element as part of ` ` ` `# decreasing sequence. ` ` ` `if` `arr[i]<arr[dec]: ` ` ` `dp[dec][inc][i] ` `=` `countMin(arr, dp, n, i, inc, i ` `+` `1` `) ` ` ` ` ` `# calculating by considering ` ` ` `# element as part of ` ` ` `# increasing sequence. ` ` ` `if` `arr[i] > arr[inc]: ` ` ` ` ` `# If cannot be calculated for ` ` ` `# decreasing sequence. ` ` ` `if` `dp[dec][inc][i] ` `=` `=` `-` `1` `: ` ` ` `dp[dec][inc][i] ` `=` `countMin(arr, dp, n, dec, i, i ` `+` `1` `) ` ` ` ` ` `# After considering once by ` ` ` `# decreasing sequence, now try ` ` ` `# for increasing sequence. ` ` ` `else` `: ` ` ` `dp[dec][inc][i] ` `=` `min` `(countMin(arr,dp,n,dec,i,i` `+` `1` `),dp[dec][inc][i]) ` ` ` ` ` `# If element cannot be part ` ` ` `# of any of the sequence. ` ` ` `if` `dp[dec][inc][i] ` `=` `=` `-` `1` `: ` ` ` `dp[dec][inc][i] ` `=` `1` `+` `countMin(arr, dp, n, dec, inc, i ` `+` `1` `) ` ` ` ` ` `# After considering element as part of increasing and ` ` ` `# decreasing sequence trying as not part of any of the ` ` ` `# sequence. ` ` ` `else` `: ` ` ` `dp[dec][inc][i]` `=` `min` `(` `1` `+` `countMin(arr,dp,n,dec,inc,i` `+` `1` `),dp[dec][inc][i]) ` ` ` ` ` `return` `dp[dec][inc][i] ` ` ` `# Wrapper Function ` `def` `wrapper(arr,n) : ` ` ` ` ` `# Adding two number at the end of array, so that ` ` ` `# increasing and decreasing sequence can be made. ` ` ` `# MAX - 2 index is assigned INT_MAX for decreasing sequence ` ` ` `# because/ next number of sequence must be less than it. ` ` ` `# Similarly, for Increasing sequence INT_MIN is assigned to ` ` ` `# MAX - 1 index. ` ` ` `arr[` `MAX` `-` `2` `]` `=` `1000000000` ` ` `arr[` `MAX` `-` `1` `]` `=` `-` `1000000000` ` ` `dp` `=` `[[[` `-` `1` `for` `i ` `in` `range` `(` `MAX` `)] ` `for` `i ` `in` `range` `(` `MAX` `)] ` `for` `i ` `in` `range` `(` `MAX` `)] ` ` ` `return` `countMin(arr,dp,n,` `MAX` `-` `2` `,` `MAX` `-` `1` `,` `0` `) ` ` ` `# Driver code ` `if` `__name__` `=` `=` `'__main__'` `: ` ` ` `n` `=` `12` ` ` `arr` `=` `[ ` `7` `, ` `8` `, ` `1` `, ` `2` `, ` `4` `, ` `6` `, ` `3` `, ` `5` `, ` `2` `, ` `1` `, ` `8` `, ` `7` `] ` ` ` `for` `i ` `in` `range` `(` `MAX` `): ` ` ` `arr.append(` `0` `) ` ` ` `print` `(wrapper(arr,n)) ` ` ` `# This code is contributed by sahilshelangia ` |

*chevron_right*

*filter_none*

## C#

`// C# program to return minimum number of ` `// elements which are not part of increasing ` `// or decreasing subsequences. ` `using` `System; ` ` ` `class` `GFG ` `{ ` `static` `int` `MAX = 102; ` ` ` `// Return minimum number of elements ` `// which is not part of any of the sequence. ` `static` `int` `countMin(` `int` `[] arr, ` `int` `[,,] dp, ` `int` `n, ` ` ` `int` `dec, ` `int` `inc, ` `int` `i) ` `{ ` ` ` `// If already calculated, return value. ` ` ` `if` `(dp[dec, inc, i] != -1) ` ` ` `return` `dp[dec, inc, i]; ` ` ` ` ` `// If whole array is traversed. ` ` ` `if` `(i == n) ` ` ` `return` `0; ` ` ` ` ` `// calculating by considering element ` ` ` `// as part of decreasing sequence. ` ` ` `if` `(arr[i] < arr[dec]) ` ` ` `dp[dec, inc, i] = countMin(arr, dp, n, i, ` ` ` `inc, i + 1); ` ` ` ` ` `// calculating by considering element ` ` ` `// as part of increasing sequence. ` ` ` `if` `(arr[i] > arr[inc]) ` ` ` `{ ` ` ` `// If cannot be calculated for ` ` ` `// decreasing sequence. ` ` ` `if` `(dp[dec, inc, i] == -1) ` ` ` `dp[dec, inc, i] = countMin(arr, dp, n, ` ` ` `dec, i, i + 1); ` ` ` ` ` `// After considering once by decreasing ` ` ` `// sequence, now try for increasing sequence. ` ` ` `else` ` ` `dp[dec, inc, i] = Math.Min(countMin(arr, dp, n, ` ` ` `dec, i, i + 1), ` ` ` `dp[dec, inc, i]); ` ` ` `} ` ` ` ` ` `// If element cannot be part of any of the sequence. ` ` ` `if` `(dp[dec, inc, i] == -1) ` ` ` `dp[dec, inc, i] = 1 + countMin(arr, dp, n, dec, ` ` ` `inc, i + 1); ` ` ` ` ` `// After considering element as part of ` ` ` `// increasing and decreasing sequence ` ` ` `// trying as not part of any of the ` ` ` `// sequence. ` ` ` `else` ` ` `dp[dec, inc, i] = Math.Min(1 + countMin(arr, dp, n, ` ` ` `dec, inc, i + 1), ` ` ` `dp[dec, inc, i]); ` ` ` ` ` `return` `dp[dec, inc, i]; ` `} ` ` ` `// Wrapper Function ` `static` `int` `wrapper(` `int` `[] arr, ` `int` `n) ` `{ ` ` ` `// Adding two number at the end of array, ` ` ` `// so that increasing and decreasing sequence ` ` ` `// can be made. MAX - 2 index is assigned ` ` ` `// INT_MAX for decreasing sequence because next ` ` ` `// number of sequence must be less than it. ` ` ` `// Similarly, for Increasing sequence INT_MIN ` ` ` `// is assigned to MAX - 1 index. ` ` ` `arr[MAX - 2] = ` `int` `.MaxValue; ` ` ` `arr[MAX - 1] = ` `int` `.MinValue; ` ` ` ` ` `int` `[,,] dp = ` `new` `int` `[MAX, MAX, MAX]; ` ` ` `for` `(` `int` `i = 0; i < MAX; i++) ` ` ` `for` `(` `int` `j = 0; j < MAX; j++) ` ` ` `for` `(` `int` `k = 0; k < MAX; k++) ` ` ` `dp[i, j, k] = -1; ` ` ` ` ` `return` `countMin(arr, dp, n, MAX - 2, ` ` ` `MAX - 1, 0); ` `} ` ` ` `// Driver Code ` `static` `void` `Main() ` `{ ` ` ` `int` `n = 12; ` ` ` `int` `[] arr = ` `new` `int` `[MAX]; ` ` ` `arr[0] = 7; ` ` ` `arr[1] = 8; ` ` ` `arr[2] = 1; ` ` ` `arr[3] = 2; ` ` ` `arr[4] = 4; ` ` ` `arr[5] = 6; ` ` ` `arr[6] = 3; ` ` ` `arr[7] = 5; ` ` ` `arr[8] = 2; ` ` ` `arr[9] = 1; ` ` ` `arr[10] = 8; ` ` ` `arr[11] = 7; ` ` ` ` ` `Console.Write(wrapper(arr, n)); ` `} ` `} ` ` ` `// This code is contributed by DrRoot_ ` |

*chevron_right*

*filter_none*

**Output:**

2

**Time Complexity :** O(n^{3})

This article is contributed by ** Anuj Chauhan**. 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Maximize sum of all elements which are not a part of the Longest Increasing Subsequence
- Divide array into increasing and decreasing subsequence without changing the order
- Longest increasing subsequence which forms a subarray in the sorted representation of the array
- Longest Increasing Subsequence using Longest Common Subsequence Algorithm
- Pyramid form (increasing then decreasing) consecutive array using reduce operations
- Non-decreasing subsequence of size k with minimum sum
- Count the number of contiguous increasing and decreasing subsequences in a sequence
- Length of the longest subsequence such that xor of adjacent elements is non-decreasing
- Find longest bitonic sequence such that increasing and decreasing parts are from two different arrays
- Length of the longest increasing subsequence such that no two adjacent elements are coprime
- Longest Decreasing Subsequence
- Maximum Sum Decreasing Subsequence
- Maximize length of Non-Decreasing Subsequence by reversing at most one Subarray
- Maximize length of longest increasing prime subsequence from the given array
- Length of longest increasing prime subsequence from a given array
- Number of Permutations such that no Three Terms forms Increasing Subsequence
- Maximum length subsequence such that adjacent elements in the subsequence have a common factor
- Minimum cost of choosing 3 increasing elements in an array of size N
- Longest Increasing Subsequence Size (N log N)
- Longest Increasing Subsequence | DP-3