Codestin Search App

Longest Palindromic Subsequence - Problem

Given a string s, find the longest palindromic subsequence within it and return its length.

A subsequence is derived from a string by deleting some or no characters without changing the order of the remaining characters. Unlike substrings, subsequences don't need to be contiguous.

What makes this challenging? A palindrome reads the same forwards and backwards (like "racecar"). You need to find the longest possible palindrome you can form by picking characters from the original string while maintaining their relative order.

Example: In the string "bbbab", you can pick characters at positions 0,1,2 and 4 to form "bbbb" (length 4), which is the longest palindromic subsequence.

Input & Output

example_1.py — Basic Case

$ Input: s = "bbbab"

› Output: 4

💡 Note: The longest palindromic subsequence is "bbbb" (taking characters at positions 0, 1, 2, and 4), which has length 4.

example_2.py — Mixed Characters

$ Input: s = "cbbd"

› Output: 2

💡 Note: The longest palindromic subsequence is "bb" (taking characters at positions 1 and 2), which has length 2.

example_3.py — Single Character

$ Input: s = "a"

› Output: 1

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

Constraints

1 ≤ s.length ≤ 1000
s consists only of lowercase English letters
Note: Subsequences don't need to be contiguous

Visualization

Tap to expand

Understanding the Visualization

Single Characters

Every single character is a palindrome of length 1 - this forms our base case

Character Matching

When characters at both ends match, we can include both and add 2 to the inner result

No Match

When characters don't match, we try excluding either the first or last character and take the better result

Build Solution

Work from smaller substrings to larger ones until we solve for the entire string

Key Takeaway

🎯 Key Insight: Use dynamic programming to break the problem into overlapping subproblems. When characters at the ends match, include both and solve the inner problem. When they don't match, try both possibilities and take the better result.

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses dynamic programming with time complexity O(n²). Create a 2D DP table where dp[i][j] represents the longest palindromic subsequence in substring s[i...j]. If characters at ends match, add 2 to the inner substring result; otherwise, take the maximum of excluding either end character.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n²)	O(n²)	Use 2D DP table to build solution from smaller subproblems

Dynamic Programming (Optimal) — Algorithm Steps

Create a 2D DP table where dp[i][j] = length of LPS in substring s[i...j]
Initialize diagonal elements (single characters) to 1
For each substring length from 2 to n, fill the DP table
If s[i] == s[j], then dp[i][j] = dp[i+1][j-1] + 2
Otherwise, dp[i][j] = max(dp[i+1][j], dp[i][j-1])
Return dp[0][n-1] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set diagonal elements to 1 (single characters)

Fill Table

Process substrings of increasing length

Character Match

If s[i] == s[j], add 2 to inner substring result

No Match

Take maximum of excluding either end character

Code -

solution.c — C

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

int max(int a, int b) {
    return (a > b) ? a : b;
}

int longestPalindromeSubseq(char* s) {
    int n = strlen(s);
    // dp[i][j] represents length of LPS in substring s[i:j+1]
    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 the table 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] = dp[i + 1][j - 1] + 2;
                }
            } else {
                dp[i][j] = max(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];
    scanf("%s", s);
    // Remove quotes if present
    if (s[0] == '"') {
        int len = strlen(s);
        memmove(s, s + 1, len - 2);
        s[len - 2] = '\0';
    }
    printf("%d\n", longestPalindromeSubseq(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We fill an n×n DP table, each cell taking O(1) time to compute

⚠ Quadratic Growth

Space Complexity

O(n²)

DP table of size n×n to store intermediate results

⚠ Quadratic Space

52.3K Views

High Frequency

~15 min Avg. Time

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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler