Longest Palindromic Subsequence II

Longest Palindromic Subsequence II - Problem

A subsequence of a string s is considered a good palindromic subsequence if:

It is a subsequence of s.
It is a palindrome (has the same value if reversed).
It has an even length.
No two consecutive characters are equal, except the two middle ones.

For example, if s = "abcabcabb", then "abba" is considered a good palindromic subsequence, while "bcb" (not even length) and "bbbb" (has equal consecutive characters) are not.

Given a string s, return the length of the longest good palindromic subsequence in s.

Input & Output

Example 1 — Basic Case

$ Input: s = "abcabc"

› Output: 4

💡 Note: The good palindromic subsequence "abba" can be formed by taking characters at indices 0,1,3,4 → a,b,b,a. Length is 4, it's a palindrome, has even length, and no consecutive duplicates except the middle bb.

Example 2 — No Valid Subsequence

$ Input: s = "aaa"

› Output: 0

💡 Note: Cannot form any good palindromic subsequence. "aa" would have consecutive equal characters but they're not in the middle positions.

Example 3 — Longer String

$ Input: s = "bbcacb"

› Output: 4

💡 Note: The good palindromic subsequence "bcab" can be formed by taking characters at indices 0,2,3,5 → b,c,a,b. Wait, that's "bcab" which is not a palindrome. Actually "bccb" from indices 0,1,2,5 gives b,b,c,b - not valid due to consecutive b's. The valid one is "bccb" but rearranged properly.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 F Facebook 12 A Amazon 8

The key insight is to use dynamic programming to track palindromic subsequences while ensuring the constraints: even length and no consecutive duplicates except the middle pair. The memoized recursion approach works well by trying to match characters from both ends and tracking the last characters used to prevent consecutive duplicates. Time: O(n² × 26²), Space: O(n² × 26²)

Common Approaches

✓ Greedy

⏱️ Time: N/A Space: N/A

Frequency Count

⏱️ Time: N/A Space: N/A

2D Dynamic Programming

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

Create a 2D DP table where dp[i][j] represents the longest good palindromic subsequence in substring s[i...j]. Build the solution bottom-up by considering all possible character pairs and ensuring constraints are met.

Brute Force - Generate All Subsequences

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

Generate every possible subsequence of the string, then check if each subsequence is a valid good palindromic subsequence by verifying it's a palindrome, has even length, and no consecutive equal characters except the middle pair.

Memoized Recursion

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

Define a recursive function that tries to build palindromes by matching characters from both ends, ensuring no consecutive duplicates. Use memoization to avoid recomputing the same subproblems.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return *(char*)a - *(char*)b;
}

int isAntiPalindrome(char* s, int n) {
    for (int i = 0; i < n; i++) {
        if (s[i] == s[n - i - 1]) {
            return 0;
        }
    }
    return 1;
}

char* solution(char* s) {
    int n = strlen(s);
    if (n % 2 == 1) {
        char* result = (char*)malloc(3 * sizeof(char));
        strcpy(result, "-1");
        return result;
    }
    
    // Count character frequencies
    int freq[256] = {0};
    for (int i = 0; i < n; i++) {
        freq[(int)s[i]]++;
    }
    
    // If any character appears more than n/2 times, impossible
    for (int i = 0; i < 256; i++) {
        if (freq[i] > n / 2) {
            char* result = (char*)malloc(3 * sizeof(char));
            strcpy(result, "-1");
            return result;
        }
    }
    
    // Try sorted arrangement first (lexicographically smallest)
    char* sortedS = (char*)malloc((n + 1) * sizeof(char));
    strcpy(sortedS, s);
    qsort(sortedS, n, sizeof(char), compare);
    
    if (isAntiPalindrome(sortedS, n)) {
        return sortedS;
    }
    
    // If sorted doesn't work, construct greedily
    char* result = (char*)malloc((n + 1) * sizeof(char));
    int* used = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < n / 2; i++) {
        int mirror = n - 1 - i;
        
        // Find smallest unused char for position i
        char char1 = 0;
        int idx1 = -1;
        for (int j = 0; j < n; j++) {
            if (!used[j]) {
                char1 = sortedS[j];
                idx1 = j;
                break;
            }
        }
        
        // Find smallest unused char != char1 for mirror
        char char2 = 0;
        int idx2 = -1;
        for (int j = 0; j < n; j++) {
            if (!used[j] && sortedS[j] != char1) {
                char2 = sortedS[j];
                idx2 = j;
                break;
            }
        }
        
        if (idx1 == -1 || idx2 == -1) {
            strcpy(result, "-1");
            return result;
        }
        
        result[i] = char1;
        result[mirror] = char2;
        used[idx1] = 1;
        used[idx2] = 1;
    }
    
    result[n] = '\0';
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

12.0K Views

Medium Frequency

~35 min Avg. Time

450 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