# C 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.

## C

`/* Dynamic Programming implementation of longest bitonic subsequence problem */` `#include<stdio.h>` `#include<stdlib.h>` ` ` `/* lbs() returns the length of the Longest Bitonic Subsequence in` ` ` `arr[] of size n. The function mainly creates two temporary arrays` ` ` `lis[] and lds[] and returns the maximum lis[i] + lds[i] - 1.` ` ` ` ` `lis[i] ==> Longest Increasing subsequence ending with arr[i]` ` ` `lds[i] ==> Longest decreasing subsequence starting with arr[i]` `*/` `int` `lbs( ` `int` `arr[], ` `int` `n )` `{` ` ` `int` `i, j;` ` ` ` ` `/* Allocate memory for LIS[] and initialize LIS values as 1 for` ` ` `all indexes */` ` ` `int` `*lis = ` `new` `int` `[n];` ` ` `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 */` ` ` `int` `*lds = ` `new` `int` `[n];` ` ` `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*/` ` ` `int` `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 program to test above function */` `int` `main()` `{` ` ` `int` `arr[] = {0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5,` ` ` `13, 3, 11, 7, 15};` ` ` `int` `n = ` `sizeof` `(arr)/` `sizeof` `(arr[0]);` ` ` `printf` `("Length of LBS is %d` `", lbs( arr, n ) );` ` ` `return` `0;` `}` |

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