GFG App
Open App
Browser
Continue

# Php Program to Find the Longest Bitonic Subsequence

Given an array arr[0 … n-1] containing n positive integers, a subsequence of arr[] is called Bitonic if it is first increasing, then decreasing. Write a function that takes an array as argument and returns the length of the longest bitonic subsequence.Â
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, 11, 2, 10, 4, 5, 2, 1};
Output: 6 (A Longest Bitonic Subsequence of length 6 is 1, 2, 10, 4, 2, 1)

Input arr[] = {12, 11, 40, 5, 3, 1}
Output: 5 (A Longest Bitonic Subsequence of length 5 is 12, 11, 5, 3, 1)

Input arr[] = {80, 60, 30, 40, 20, 10}
Output: 5 (A Longest Bitonic Subsequence of length 5 is 80, 60, 30, 20, 10)```

Source: Microsoft Interview Question
Â

SolutionÂ
This problem is a variation of standard Longest Increasing Subsequence (LIS) problem. Let the input array be arr[] of length n. We need to construct two arrays lis[] and lds[] using Dynamic Programming solution of LIS problem. lis[i] stores the length of the Longest Increasing subsequence ending with arr[i]. lds[i] stores the length of the longest Decreasing subsequence starting from arr[i]. Finally, we need to return the max value of lis[i] + lds[i] – 1 where i is from 0 to n-1.
Following is the implementation of the above Dynamic Programming solution.Â
Â

## PHP

 ` Longest Increasing subsequence ` `              ``ending with arr[i] ` `   ``lds[i] ==> Longest decreasing subsequence  ` `              ``starting with arr[i] ` `*/` `function` `lbs(&``\$arr``, ``\$n``) ` `{ ` ` `  `    ``/* Allocate memory for LIS[] and initialize  ` `       ``LIS values as 1 for all indexes */` `    ``\$lis` `= ``array_fill``(0, ``\$n``, NULL); ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++) ` `        ``\$lis``[``\$i``] = 1; ` `     `  `    ``/* Compute LIS values from left to right */` `    ``for` `(``\$i` `= 1; ``\$i` `< ``\$n``; ``\$i``++) ` `        ``for` `(``\$j` `= 0; ``\$j` `< ``\$i``; ``\$j``++) ` `            ``if` `(``\$arr``[``\$i``] > ``\$arr``[``\$j``] &&  ` `                ``\$lis``[``\$i``] < ``\$lis``[``\$j``] + 1) ` `                ``\$lis``[``\$i``] = ``\$lis``[``\$j``] + 1; ` `     `  `    ``/* Allocate memory for lds and initialize  ` `       ``LDS values for all indexes */` `    ``\$lds` `= ``array_fill``(0, ``\$n``, NULL); ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++) ` `        ``\$lds``[``\$i``] = 1; ` `     `  `    ``/* Compute LDS values from right to left */` `    ``for` `(``\$i` `= ``\$n` `- 2; ``\$i` `>= 0; ``\$i``--) ` `        ``for` `(``\$j` `= ``\$n` `- 1; ``\$j` `> ``\$i``; ``\$j``--) ` `            ``if` `(``\$arr``[``\$i``] > ``\$arr``[``\$j``] &&  ` `                ``\$lds``[``\$i``] < ``\$lds``[``\$j``] + 1) ` `                ``\$lds``[``\$i``] = ``\$lds``[``\$j``] + 1; ` `     `  `    ``/* Return the maximum value of  ` `       ``lis[i] + lds[i] - 1*/` `    ``\$max` `= ``\$lis``[0] + ``\$lds``[0] - 1; ` `    ``for` `(``\$i` `= 1; ``\$i` `< ``\$n``; ``\$i``++) ` `        ``if` `(``\$lis``[``\$i``] + ``\$lds``[``\$i``] - 1 > ``\$max``) ` `            ``\$max` `= ``\$lis``[``\$i``] + ``\$lds``[``\$i``] - 1; ` `    ``return` `\$max``; ` `} ` ` `  `// Driver Code ` `\$arr` `= ``array``(0, 8, 4, 12, 2, 10, 6, 14,  ` `             ``1, 9, 5, 13, 3, 11, 7, 15); ` `\$n` `= sizeof(``\$arr``); ` `echo` `"Length of LBS is "` `. lbs( ``\$arr``, ``\$n` `); ` ` `  `// This code is contributed by ita_c ` `?> `

Output:Â

` Length of LBS is 7`

Time Complexity: O(n^2)Â
Auxiliary Space: O(n)
Â

Please refer complete article on Longest Bitonic Subsequence | DP-15 for more details!

My Personal Notes arrow_drop_up