# Length of longest strict bitonic subsequence

Given an array arr[] containing n integers. The problem is to find the length of the longest strict bitonic subsequence. A subsequence is called strict bitonic if it is first increasing and then decreasing with the condition that in both the increasing and decreasing parts the absolute difference between adjacents is 1 only. A sequence, sorted in increasing order is considered Bitonic with the decreasing part as empty. Similarly, decreasing order sequence is considered Bitonic with the increasing part as empty.

Examples:

```Input : arr[] = {1, 5, 2, 3, 4, 5, 3, 2}
Output : 6
The Longest Strict Bitonic Subsequence is:
{1, 2, 3, 4, 3, 2}.

Input : arr[] = {1, 2, 5, 3, 6, 7, 4, 6, 5}
Output : 5
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Method 1: The problem could be solved using the concept of finding the longest bitonic subsequence. The only condition that needs to be maintained is that the adjacents should have a difference of 1 only. It has a time complexity of O(n2).

Method 2 (Efficient Approach): The idea is to create two hash maps inc and dcr having tuples in the form (ele, len), where len denotes the length of the longest increasing subsequence ending with the element ele in map inc and length of the longest decreasing subsequence starting with element ele in map dcr respectively. Also create two arrays len_inc[] and len_dcr[] where len_inc[i] represents the length of the largest increasing subsequence ending with element arr[i] and len_dcr[i] represents the length of the largest decreasing subsequence starting with element arr[i]. Now, for each element arr[i] we can find the length of the value (arr[i]-1) if it exists in the hash table inc. Let this value be v (initially v will be 0). Now, the length of longest increasing subsequence ending with arr[i] would be v+1. Update this length along with the element arr[i] in the hash table inc and in the array len_inc[] at respective index i. Now, traversing the array from right to left we can similarly fill the hash table dcr and array len_dcr[] for longest decreasing subsequence. Finally, for each element arr[i] we calculate (len_inc[i] + len_dcr[i] – 1) and return the maximum value.

Note: Here increasing and decreasing subsequences only mean that the difference between adjacent elements is 1 only.

## C++

 `// C++ implementation to find length of longest  ` `// strict bitonic subsequence  ` `#include ` `using` `namespace` `std; ` `    `  `// function to find length of longest  ` `// strict bitonic subsequence  ` `int` `longLenStrictBitonicSub(``int` `arr[], ``int` `n) ` `{ ` `    ``// hash table to map the array element with the ` `    ``// length of the longest subsequence of which ` `    ``// it is a part of and is the last/first element of ` `    ``// that subsequence ` `    ``unordered_map<``int``, ``int``> inc, dcr; ` `     `  `    ``// arrays to store the length of increasing and ` `    ``// decreasing subsequences which end at them ` `    ``// or start from them   ` `    ``int` `len_inc[n], len_dcr[n]; ` `     `  `    ``// to store the length of longest strict  ` `    ``// bitonic subsequence ` `    ``int` `longLen = 0; ` `     `  `    ``// traverse the array elements ` `    ``// from left to right ` `    ``for` `(``int` `i=0; i=0; i--) ` `    ``{ ` `        ``// initialize current length  ` `        ``// for element arr[i] as 0 ` `        ``int` `len = 0; ` `           `  `        ``// if 'arr[i]-1' is in 'dcr'  ` `        ``if` `(dcr.find(arr[i]-1) != dcr.end()) ` `            ``len = dcr[arr[i]-1]; ` `           `  `        ``// update arr[i] subsequence length in 'dcr' ` `        ``// and in len_dcr[]     ` `        ``dcr[arr[i]] = len_dcr[i] = len + 1;  ` `    ``} ` `     `  `    ``// calculating the length of all the strict  ` `    ``// bitonic subsequence ` `    ``for` `(``int` `i=0; i

## Java

 `// Java implementation to find length of longest  ` `// strict bitonic subsequence  ` `import` `java.util.*; ` ` `  `class` `GfG  ` `{ ` `     `  `// function to find length of longest  ` `// strict bitonic subsequence  ` `static` `int` `longLenStrictBitonicSub(``int` `arr[], ``int` `n)  ` `{  ` `    ``// hash table to map the array element with the  ` `    ``// length of the longest subsequence of which  ` `    ``// it is a part of and is the last/first element of  ` `    ``// that subsequence  ` `    ``HashMap inc = ``new` `HashMap (); ` `    ``HashMap dcr = ``new` `HashMap ();  ` `     `  `    ``// arrays to store the length of increasing and  ` `    ``// decreasing subsequences which end at them  ` `    ``// or start from them  ` `    ``int` `len_inc[] = ``new` `int``[n]; ` `    ``int` `len_dcr[] = ``new` `int``[n];  ` `     `  `    ``// to store the length of longest strict  ` `    ``// bitonic subsequence  ` `    ``int` `longLen = ``0``;  ` `     `  `    ``// traverse the array elements  ` `    ``// from left to right  ` `    ``for` `(``int` `i = ``0``; i < n; i++)  ` `    ``{  ` `        ``// initialize current length  ` `        ``// for element arr[i] as 0  ` `        ``int` `len = ``0``;  ` `             `  `        ``// if 'arr[i]-1' is in 'inc'  ` `        ``if` `(inc.containsKey(arr[i] - ``1``))  ` `            ``len = inc.get(arr[i] - ``1``);  ` `             `  `        ``// update arr[i] subsequence length in 'inc'      ` `        ``// and in len_inc[]  ` `        ``len_inc[i] = len + ``1``; ` `        ``inc.put(arr[i], len_inc[i]); ` `    ``}  ` `     `  `    ``// traverse the array elements  ` `    ``// from right to left  ` `    ``for` `(``int` `i = n - ``1``; i >= ``0``; i--)  ` `    ``{  ` `        ``// initialize current length  ` `        ``// for element arr[i] as 0  ` `        ``int` `len = ``0``;  ` `             `  `        ``// if 'arr[i]-1' is in 'dcr'  ` `        ``if` `(dcr.containsKey(arr[i] - ``1``))  ` `            ``len = dcr.get(arr[i] - ``1``);  ` `             `  `        ``// update arr[i] subsequence length in 'dcr'  ` `        ``// and in len_dcr[]  ` `        ``len_dcr[i] = len + ``1``; ` `        ``dcr.put(arr[i], len_dcr[i]);  ` `    ``}  ` `     `  `    ``// calculating the length of all the strict  ` `    ``// bitonic subsequence  ` `    ``for` `(``int` `i = ``0``; i < n; i++)  ` `        ``if` `(longLen < (len_inc[i] + len_dcr[i] - ``1``))  ` `            ``longLen = len_inc[i] + len_dcr[i] - ``1``;  ` `         `  `    ``// required longest length strict  ` `    ``// bitonic subsequence  ` `    ``return` `longLen;      ` `}  ` `     `  `// Driver code  ` `public` `static` `void` `main(String[] args)  ` `{  ` `    ``int` `arr[] = {``1``, ``5``, ``2``, ``3``, ``4``, ``5``, ``3``, ``2``};  ` `    ``int` `n = arr.length;  ` `    ``System.out.println(``"Longest length strict "` `+  ` `                            ``"bitonic subsequence = "` `+  ` `                            ``longLenStrictBitonicSub(arr, n));  ` `} ` `}  ` ` `  `// This code is contributed by  ` `// prerna saini `

## Python3

 `# Python3 implementation to find length of  ` `# longest strict bitonic subsequence ` ` `  `# function to find length of longest ` `# strict bitonic subsequence ` `def` `longLenStrictBitonicSub(arr, n): ` ` `  `    ``# hash table to map the array element  ` `    ``# with the length of the longest subsequence  ` `    ``# of which it is a part of and is the  ` `    ``# last/first element of that subsequence ` `    ``inc, dcr ``=` `dict``(), ``dict``() ` ` `  `    ``# arrays to store the length of increasing ` `    ``# and decreasing subsequences which end at  ` `    ``# them or start from them ` `    ``len_inc, len_dcr ``=` `[``0``] ``*` `n, [``0``] ``*` `n ` ` `  `    ``# to store the length of longest strict ` `    ``# bitonic subsequence ` `    ``longLen ``=` `0` ` `  `    ``# traverse the array elements ` `    ``# from left to right ` `    ``for` `i ``in` `range``(n): ` ` `  `        ``# initialize current length ` `        ``# for element arr[i] as 0 ` `        ``len` `=` `0` ` `  `        ``# if 'arr[i]-1' is in 'inc' ` `        ``if` `inc.get(arr[i] ``-` `1``) ``in` `inc.values(): ` `            ``len` `=` `inc.get(arr[i] ``-` `1``) ` `         `  `        ``# update arr[i] subsequence length in 'inc'      ` `        ``# and in len_inc[]  ` `        ``inc[arr[i]] ``=` `len_inc[i] ``=` `len` `+` `1` `     `  `    ``# traverse the array elements ` `    ``# from right to left ` `    ``for` `i ``in` `range``(n ``-` `1``, ``-``1``, ``-``1``): ` ` `  `        ``# initialize current length ` `        ``# for element arr[i] as 0 ` `        ``len` `=` `0` ` `  `        ``# if 'arr[i]-1' is in 'dcr' ` `        ``if` `dcr.get(arr[i] ``-` `1``) ``in` `dcr.values(): ` `            ``len` `=` `dcr.get(arr[i] ``-` `1``) ` `         `  `        ``# update arr[i] subsequence length   ` `        ``# in 'dcr' and in len_dcr[]  ` `        ``dcr[arr[i]] ``=` `len_dcr[i] ``=` `len` `+` `1` `     `  `    ``# calculating the length of  ` `    ``# all the strict bitonic subsequence  ` `    ``for` `i ``in` `range``(n): ` `        ``if` `longLen < (len_inc[i] ``+` `len_dcr[i] ``-` `1``): ` `            ``longLen ``=` `len_inc[i] ``+` `len_dcr[i] ``-` `1` `     `  `    ``# required longest length strict  ` `    ``# bitonic subsequence  ` `    ``return` `longLen ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` `    ``arr ``=` `[``1``, ``5``, ``2``, ``3``, ``4``, ``5``, ``3``, ``2``] ` `    ``n ``=` `len``(arr) ` `    ``print``(``"Longest length strict bitonic subsequence ="``, ` `           ``longLenStrictBitonicSub(arr, n)) ` ` `  `# This code is contributed by sanjeev2552 `

## C#

 `// C# implementation to find length of longest  ` `// strict bitonic subsequence  ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GfG  ` `{  ` ` `  `    ``// function to find length of longest  ` `    ``// strict bitonic subsequence  ` `    ``static` `int` `longLenStrictBitonicSub(``int` `[]arr, ``int` `n)  ` `    ``{  ` `        ``// hash table to map the array  ` `        ``// element with the length of  ` `        ``// the longest subsequence of  ` `        ``// which it is a part of and  ` `        ``// is the last/first element of  ` `        ``// that subsequence  ` `        ``Dictionary<``int``, ``int``> inc = ``new` `Dictionary<``int``, ``int``> ();  ` `        ``Dictionary<``int``, ``int``> dcr = ``new` `Dictionary<``int``, ``int``> ();  ` ` `  `        ``// arrays to store the length  ` `        ``// of increasing and decreasing  ` `        ``// subsequences which end at them  ` `        ``// or start from them  ` `        ``int` `[]len_inc = ``new` `int``[n];  ` `        ``int` `[]len_dcr = ``new` `int``[n];  ` ` `  `        ``// to store the length of longest strict  ` `        ``// bitonic subsequence  ` `        ``int` `longLen = 0;  ` ` `  `        ``// traverse the array elements  ` `        ``// from left to right  ` `        ``for` `(``int` `i = 0; i < n; i++)  ` `        ``{  ` `            ``// initialize current length  ` `            ``// for element arr[i] as 0  ` `            ``int` `len = 0;  ` ` `  `            ``// if 'arr[i]-1' is in 'inc'  ` `            ``if` `(inc.ContainsKey(arr[i] - 1))  ` `                ``len = inc[arr[i] - 1];  ` ` `  `            ``// update arr[i] subsequence length       ` `            ``// in 'inc' and in len_inc[]  ` `            ``len_inc[i] = len + 1;  ` `            ``if` `(inc.ContainsKey(arr[i])) ` `            ``{ ` `                ``inc.Remove(arr[i]); ` `                ``inc.Add(arr[i], len_inc[i]);  ` `            ``} ` `            ``else` `                ``inc.Add(arr[i], len_inc[i]); ` `        ``}  ` ` `  `        ``// traverse the array elements  ` `        ``// from right to left  ` `        ``for` `(``int` `i = n - 1; i >= 0; i--)  ` `        ``{  ` `            ``// initialize current length  ` `            ``// for element arr[i] as 0  ` `            ``int` `len = 0;  ` ` `  `            ``// if 'arr[i]-1' is in 'dcr'  ` `            ``if` `(dcr.ContainsKey(arr[i] - 1))  ` `                ``len = dcr[arr[i] - 1];  ` ` `  `            ``// update arr[i] subsequence length in 'dcr'  ` `            ``// and in len_dcr[]  ` `            ``len_dcr[i] = len + 1;  ` `            ``if` `(dcr.ContainsKey(arr[i])) ` `            ``{ ` `                ``dcr.Remove(arr[i]); ` `                ``dcr.Add(arr[i], len_dcr[i]);  ` `            ``} ` `            ``else` `                ``dcr.Add(arr[i], len_dcr[i]);  ` `        ``}  ` ` `  `        ``// calculating the length of all the strict  ` `        ``// bitonic subsequence  ` `        ``for` `(``int` `i = 0; i < n; i++)  ` `            ``if` `(longLen < (len_inc[i] + len_dcr[i] - 1))  ` `                ``longLen = len_inc[i] + len_dcr[i] - 1;  ` ` `  `        ``// required longest length strict  ` `        ``// bitonic subsequence  ` `        ``return` `longLen;  ` `    ``}  ` ` `  `    ``// Driver code  ` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{  ` `        ``int` `[]arr = {1, 5, 2, 3, 4, 5, 3, 2};  ` `        ``int` `n = arr.Length;  ` `        ``Console.WriteLine(``"Longest length strict "` `+  ` `                            ``"bitonic subsequence = "` `+  ` `                            ``longLenStrictBitonicSub(arr, n));  ` `    ``}  ` `}  ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```Longest length strict bitonic subsequence = 6
```

Time Complexity: O(n).
Auxiliary Space: O(n).

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

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.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.