[GeeksForGeeks] Longest Bitonic Subsequence

Given an array arr[0.....n-1] containing n positive integers, find the length of the longest bitonic subsequence. 

A subsequence of arr[] is called Bitonic if it is first increasing, then decreasing.

 

Analysis: 

This problem is a variation of the standard Longest Increasing Subsequence(LIS) problem.  In the standard LIS

problem, we use dynamic programming and create a 1D array lis[i], lis[i] is the length of the longest increasing subsequence 

that ends with arr[i]. 

 

In this problem, we construct two arrays lis[i] and ids[i] using dynamic programming.

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.

 

public class Solution {
    public int longestBitonicSubsequence(int[] arr){
        if(arr == null || arr.length == 0){
            return 0;
        }
        int[] lis = new int[arr.length];
        int[] lds = new int[arr.length];
        for(int i = 0; i < arr.length; i++){
            lis[i] = 1;
            lds[i] = 1;
        }
        for(int i = 0; i < arr.length; i++){
            for(int j = 0; j < i; j++){
                if(arr[i] > arr[j] && lis[i] < lis[j] + 1){
                    lis[i] = lis[j] + 1;
                }
            }
        }
        for(int i = arr.length - 1; i >= 0; i--){
            for(int j = arr.length - 1; j > i; j--){
                if(arr[i] > arr[j] && lds[i] < lds[j] + 1){
                    lds[i] = lds[j] + 1;
                }
            }
        }
        int max = 0;
        for(int i = 0; i < arr.length; i++){
            if(lis[i] + lds[i] - 1 > max){
                max = lis[i] + lds[i] - 1;
            }
        }
        return max;
    }
}

 

Related Problems

Longest Increasing Subsequence