# 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

**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(n^{2}).**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 <bits/stdc++.h>` `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<n; i++)` ` ` `{` ` ` `// initialize current length` ` ` `// for element arr[i] as 0` ` ` `int` `len = 0;` ` ` ` ` `// if 'arr[i]-1' is in 'inc'` ` ` `if` `(inc.find(arr[i]-1) != inc.end())` ` ` `len = inc[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` `(` `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.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<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 program to test above` `int` `main()` `{` ` ` `int` `arr[] = {1, 5, 2, 3, 4, 5, 3, 2};` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]);` ` ` `cout << ` `"Longest length strict bitonic subsequence = "` ` ` `<< longLenStrictBitonicSub(arr, n);` ` ` `return` `0;` `} ` |

## 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<Integer, Integer> inc = ` `new` `HashMap<Integer, Integer> ();` ` ` `HashMap<Integer, Integer> dcr = ` `new` `HashMap<Integer, Integer> ();` ` ` ` ` `// 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` |

## Javascript

`<script>` `// Javascript implementation to find length of longest` `// strict bitonic subsequence` ` ` `// function to find length of longest` `// strict bitonic subsequence` `function` `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` ` ` `var` `inc = ` `new` `Map(), dcr = ` `new` `Map();` ` ` ` ` `// arrays to store the length of increasing and` ` ` `// decreasing subsequences which end at them` ` ` `// or start from them ` ` ` `var` `len_inc = Array(n), len_dcr = Array(n);` ` ` ` ` `// to store the length of longest strict` ` ` `// bitonic subsequence` ` ` `var` `longLen = 0;` ` ` ` ` `// traverse the array elements` ` ` `// from left to right` ` ` `for` `(` `var` `i=0; i<n; i++)` ` ` `{` ` ` `// initialize current length` ` ` `// for element arr[i] as 0` ` ` `var` `len = 0;` ` ` ` ` `// if 'arr[i]-1' is in 'inc'` ` ` `if` `(inc.has(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.set(arr[i], len_inc[i]);` ` ` ` ` `}` ` ` ` ` `// traverse the array elements` ` ` `// from right to left` ` ` `for` `(` `var` `i=n-1; i>=0; i--)` ` ` `{` ` ` `// initialize current length` ` ` `// for element arr[i] as 0` ` ` `var` `len = 0;` ` ` ` ` `// if 'arr[i]-1' is in 'dcr'` ` ` `if` `(dcr.has(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.set(arr[i], len_dcr[i]);` ` ` `}` ` ` ` ` `// calculating the length of all the strict` ` ` `// bitonic subsequence` ` ` `for` `(` `var` `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 program to test above` `var` `arr = [1, 5, 2, 3, 4, 5, 3, 2];` `var` `n = arr.length;` `document.write( ` `"Longest length strict bitonic subsequence = "` ` ` `+ longLenStrictBitonicSub(arr, n));` `// This code is contributed by itsok.` `</script>` |

**Output:**

Longest length strict bitonic subsequence = 6

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

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. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.