Longest Palindromic Subsequence

Longest Palindromic Subsequence - Problem

Given a string s, find the longest palindromic subsequence's length in s.

A subsequence is a sequence that can be derived from another sequence by deleting some or no elements without changing the order of the remaining elements.

For example, "ace" is a subsequence of "aec" (by removing 'e'), but "aec" is not a subsequence of "ace".

Input & Output

Example 1 — Basic Case

$ Input: s = "bbbab"

› Output: 4

💡 Note: One possible longest palindromic subsequence is "bbbb" (indices 0,1,2,4). We can also form "bbb" of length 3, but "bbbb" is longer.

Example 2 — All Different Characters

$ Input: s = "cbbd"

› Output: 2

💡 Note: One possible longest palindromic subsequence is "bb" (indices 1,2). Each single character is also a palindrome of length 1.

Example 3 — Single Character

$ Input: s = "a"

› Output: 1

💡 Note: The entire string "a" is a palindrome, so the longest palindromic subsequence has length 1.

Constraints

1 ≤ s.length ≤ 1000
s consists only of lowercase English letters

Visualization

Tap to expand

Asked in

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

The key insight is that a palindromic subsequence either has matching characters at both ends or doesn't. We can solve this using 2D Dynamic Programming where dp[i][j] represents the longest palindromic subsequence in substring s[i...j]. Time: O(n²), Space: O(n²)

Common Approaches

✓ 2D Dynamic Programming

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

This is the optimal bottom-up approach. We create a 2D table where dp[i][j] represents the length of the longest palindromic subsequence in substring s[i...j]. We fill the table by considering all possible substrings, starting from smaller lengths and building up to the full string.

Brute Force - Try All Subsequences

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

This approach generates every possible subsequence of the string and checks if it's a palindrome. For each character, we have two choices: include it or exclude it from the subsequence. We keep track of the longest palindromic subsequence found.

Recursive with Memoization

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

This approach uses recursion to solve the problem by comparing characters at both ends of the string. If they match, we include both in the palindrome. If not, we try excluding either the first or last character and take the maximum. Memoization prevents recalculating the same subproblems.

2D Dynamic Programming — Algorithm Steps

Create 2D DP table dp[i][j] for substring s[i...j]
Fill diagonal with 1s (single characters)
For each substring length, fill the table bottom-up
If s[i] == s[j], dp[i][j] = 2 + dp[i+1][j-1], else max of neighbors

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Fill diagonal with 1s (single characters)

Build Up

Process substrings by increasing length

Result

Answer is in dp[0][n-1]

Code -

solution.c — C

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

int solution(char* s) {
    int n = strlen(s);
    if (n == 0) return 0;
    
    // dp[i][j] represents longest palindromic subsequence in s[i...j]
    int** dp = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        dp[i] = (int*)calloc(n, sizeof(int));
    }
    
    // Every single character is a palindrome of length 1
    for (int i = 0; i < n; i++) {
        dp[i][i] = 1;
    }
    
    // Fill for substrings of length 2 to n
    for (int length = 2; length <= n; length++) {
        for (int i = 0; i <= n - length; i++) {
            int j = i + length - 1;
            
            if (s[i] == s[j]) {
                if (length == 2) {
                    dp[i][j] = 2;
                } else {
                    dp[i][j] = 2 + dp[i + 1][j - 1];
                }
            } else {
                dp[i][j] = (dp[i + 1][j] > dp[i][j - 1]) ? dp[i + 1][j] : dp[i][j - 1];
            }
        }
    }
    
    int result = dp[0][n - 1];
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    int result = solution(s);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops iterate over all n² possible substrings

⚠ Quadratic Growth

Space Complexity

O(n²)

2D DP table of size n×n to store results for all substrings

⚠ Quadratic Space

85.0K Views

High Frequency

~25 min Avg. Time

4.2K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

2D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler