Longest Bitonic Subsequence - Problem

Advanced DP DP Array Hard

A bitonic subsequence is a subsequence that first strictly increases and then strictly decreases. Given an array of integers, find the length of the longest bitonic subsequence.

A subsequence is derived from the original array by deleting some or no elements without changing the order of the remaining elements.

Note: A purely increasing or purely decreasing subsequence is also considered bitonic.

Input & Output

Example 1 — Standard Bitonic

$ Input: nums = [1,11,2,10,4,5,2,1]

› Output: 6

💡 Note: The longest bitonic subsequence is [1,2,10,5,2,1] or [1,4,5,2,1]. Both have length 6 - they increase to a peak then decrease.

Example 2 — Pure Increasing

$ Input: nums = [1,2,3,4,5]

› Output: 5

💡 Note: The array is strictly increasing. A purely increasing sequence is also considered bitonic, so the answer is 5.

Example 3 — Pure Decreasing

$ Input: nums = [5,4,3,2,1]

› Output: 5

💡 Note: The array is strictly decreasing. A purely decreasing sequence is also considered bitonic, so the answer is 5.

Constraints

1 ≤ nums.length ≤ 1000
-10⁶ ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 25

The key insight is that every bitonic subsequence has a peak element. We compute the longest increasing subsequence ending at each position and the longest decreasing subsequence starting at each position, then combine them. Best approach uses dynamic programming in O(n²) time and O(n) space.

Common Approaches

✓ Generate All Subsequences

⏱️ Time: O(n × 2ⁿ) Space: O(n)

Generate every possible subsequence of the array and check if it follows the bitonic pattern (strictly increasing then strictly decreasing). Track the maximum length found.

Space-Optimized Single Pass

⏱️ Time: O(n²) Space: O(n)

Use a more efficient approach that computes the bitonic subsequence length without storing all intermediate results, focusing on the essential computations needed for the final answer.

Two-Pass Dynamic Programming

⏱️ Time: O(n²) Space: O(n)

First pass computes the longest increasing subsequence ending at each position. Second pass computes the longest decreasing subsequence starting from each position. Combine both to find the maximum bitonic length.

Generate All Subsequences — Algorithm Steps

Generate all 2^n possible subsequences using bit manipulation
For each subsequence, check if it's bitonic (has increasing then decreasing pattern)
Track the maximum length of valid bitonic subsequences

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all 2^n subsequences using bit manipulation

Validate

Check if each subsequence is bitonic (up then down)

Track Max

Keep track of longest valid bitonic subsequence

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

bool isBitonic(int* arr, int len) {
    if (len <= 1) return true;
    
    int i = 0;
    // Check increasing part
    while (i < len - 1 && arr[i] < arr[i + 1]) {
        i++;
    }
    
    // Check decreasing part
    while (i < len - 1 && arr[i] > arr[i + 1]) {
        i++;
    }
    
    return i == len - 1;
}

int solution(int* nums, int n) {
    int maxLength = 0;
    int subsequence[20];
    
    // Generate all possible subsequences
    for (int mask = 1; mask < (1 << n); mask++) {
        int len = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subsequence[len++] = nums[i];
            }
        }
        
        // Check if subsequence is bitonic
        if (isBitonic(subsequence, len)) {
            if (len > maxLength) {
                maxLength = len;
            }
        }
    }
    
    return maxLength;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    int nums[20];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9' || token[0] == '-') {
            nums[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2ⁿ)

Generate 2^n subsequences, each takes O(n) time to validate

✓ Linear Growth

Space Complexity

O(n)

Space for current subsequence and recursion stack

⚡ Linearithmic Space

28.0K Views

Medium-High Frequency

~25 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Longest Bitonic Subsequence - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Generate All Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler