Longest Palindromic Subsequence II - Practice Coding Problems

Longest Palindromic Subsequence II - Problem

Given a string s, you need to find the length of the longest "good palindromic subsequence". This is a special type of palindrome with strict rules!

A good palindromic subsequence must satisfy ALL of the following conditions:

It is a subsequence of the original string s
It reads the same forwards and backwards (palindrome)
It has an even length (2, 4, 6, 8, etc.)
No two consecutive characters are equal, except the two middle characters

Examples:

✅ "abba" - Even length, palindrome, no consecutive duplicates
❌ "bcb" - Odd length (not allowed)
❌ "bbbb" - Has consecutive equal characters
✅ "abccba" - Even length, only middle characters are equal

Your goal is to return the length of the longest such subsequence.

Input & Output

example_1.py — Python

$ Input: s = "bbcacabb"

› Output: 4

💡 Note: The longest good palindromic subsequence is "bccb" with length 4. It's even length, palindrome, and only the middle characters 'c','c' are consecutive and equal.

example_2.py — Python

$ Input: s = "aabaa"

› Output: 4

💡 Note: The longest good palindromic subsequence is "abba" with length 4. We skip the middle 'a' to avoid three consecutive 'a's in the palindrome.

example_3.py — Python

$ Input: s = "abc"

› Output: 0

💡 Note: No valid good palindromic subsequence exists. We need at least 2 matching characters to form an even-length palindrome.

Visualization

Tap to expand

Understanding the Visualization

Start from Ends

Begin matching characters from both ends of the string

Check Rules

Ensure no consecutive duplicates except middle pair

Build Inward

Recursively build the palindrome from outside to inside

Memoize Results

Cache results to avoid recomputing same subproblems

Key Takeaway

🎯 Key Insight: Use dynamic programming to match characters from both ends while tracking the last used character to prevent consecutive duplicates, building the longest valid palindromic subsequence efficiently.

Time & Space Complexity

Time Complexity

⏱️

O(n² × 26)

n² possible (left,right) pairs, 26 possible last characters to track

⚠ Quadratic Growth

Space Complexity

O(n² × 26)

Memoization table for all possible states

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 1000
s consists only of lowercase English letters
The subsequence must have even length
No consecutive equal characters except the middle pair

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 18

The optimal solution uses dynamic programming with memoization to build palindromes from both ends. Key insight: track the last character used to avoid consecutive duplicates while recursively matching characters from left and right positions. Time complexity: O(n² × 26).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Subsequences)	O(2^n × n)	O(n)	Generate all possible subsequences and check if each is a good palindromic subsequence
Dynamic Programming (Optimal)	O(n² × 26)	O(n² × 26)	Use memoized recursion to build palindromes from both ends while avoiding consecutive duplicates

Brute Force (Generate All Subsequences) — Algorithm Steps

Generate all possible subsequences using bit manipulation (2^n possibilities)
For each subsequence, check if it has even length
Check if the subsequence is a palindrome
Check if it has no consecutive equal characters except middle pair
Keep track of the maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsequences

Use bit masks to generate all 2^n possible subsequences

Check Even Length

Filter out odd-length subsequences

Validate Palindrome

Check if subsequence reads same forwards and backwards

Check Consecutive Rule

Ensure no consecutive equal chars except middle pair

Code -

solution.c — C

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

bool isGoodPalindrome(char* arr, int n) {
    // Must have even length
    if (n % 2 != 0) return false;
    
    // Check if palindrome
    for (int i = 0; i < n / 2; i++) {
        if (arr[i] != arr[n - 1 - i]) return false;
    }
    
    // Check no consecutive equal characters except middle pair
    for (int i = 0; i < n - 1; i++) {
        if (arr[i] == arr[i + 1]) {
            if (i != n / 2 - 1) return false;
        }
    }
    
    return true;
}

int longestPalindromicSubseqII(char* s) {
    int n = strlen(s);
    int maxLength = 0;
    
    // Generate all possible subsequences
    for (int mask = 1; mask < (1 << n); mask++) {
        char* subseq = (char*)malloc(n + 1);
        int len = 0;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subseq[len++] = s[i];
            }
        }
        subseq[len] = '\0';
        
        // Check if it's a good palindromic subsequence
        if (isGoodPalindrome(subseq, len)) {
            if (len > maxLength) {
                maxLength = len;
            }
        }
        
        free(subseq);
    }
    
    return maxLength;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    
    // Remove newline and quotes
    int len = strlen(s);
    if (s[len-1] == '\n') s[len-1] = '\0';
    if (s[0] == '"' && s[strlen(s)-1] == '"') {
        s[strlen(s)-1] = '\0';
        memmove(s, s+1, strlen(s));
    }
    
    printf("%d\n", longestPalindromicSubseqII(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n)

2^n subsequences to generate, each taking O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current subsequence and recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 1000
s consists only of lowercase English letters
The subsequence must have even length
No consecutive equal characters except the middle pair

38.2K Views

Medium Frequency

~25 min Avg. Time

1.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Generate All Subsequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler