Remove Palindromic Subsequences

Remove Palindromic Subsequences - Problem

You are given a string s consisting only of letters 'a' and 'b'. In a single step you can remove one palindromic subsequence from s.

Return the minimum number of steps to make the given string empty.

A string is a subsequence of a given string if it is generated by deleting some characters of a given string without changing its order. Note that a subsequence does not necessarily need to be contiguous.

A string is called palindrome if it reads the same backward as well as forward.

Input & Output

Example 1 — Not a Palindrome

$ Input: s = "abab"

› Output: 2

💡 Note: String "abab" is not a palindrome. We can remove all 'a's in step 1 ("aa" is palindrome) and all 'b's in step 2 ("bb" is palindrome).

Example 2 — Already Palindrome

$ Input: s = "aba"

› Output: 1

💡 Note: String "aba" is already a palindrome, so we can remove the entire string in 1 step.

Example 3 — Empty String

$ Input: s = ""

› Output: 0

💡 Note: Empty string requires 0 steps as there are no characters to remove.

Constraints

0 ≤ s.length ≤ 1000
s consists only of letters 'a' and 'b'

Visualization

Tap to expand

Asked in

F Facebook 15 G Google 8

The key insight is that with only characters 'a' and 'b', any subsequence of the same character forms a palindrome. Best approach uses mathematical reasoning: return 0 for empty string, 1 if string is already palindrome, otherwise 2. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Check All Subsequences

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

Generate every possible subsequence of the string, check if each is a palindrome, and find the minimum number of palindromic subsequences needed to cover all characters.

Mathematical Insight - Binary Alphabet

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

The key insight is that since the string only contains 'a' and 'b', we can always remove all characters in at most 2 steps: first remove all 'a's (which forms a palindrome), then remove all 'b's (also a palindrome).

Two Pointers - Check Palindrome

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

Since we can remove any subsequence that forms a palindrome, we first check if the entire string is already a palindrome. If yes, return 1. If no, we can always remove all 'a's first, then all 'b's in 2 steps.

Brute Force - Check All Subsequences — Algorithm Steps

Generate all possible subsequences
Check if each subsequence is a palindrome
Use dynamic programming to find minimum subsequences needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all 2^n subsequences

Filter

Keep only palindromic ones

Optimize

Find minimum set covering all characters

Code -

solution.c — C

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

int isPalindrome(char* str) {
    int len = strlen(str);
    for (int i = 0; i < len/2; i++) {
        if (str[i] != str[len-1-i]) {
            return 0;
        }
    }
    return 1;
}

int solution(char* s) {
    int n = strlen(s);
    if (n == 0) return 0;
    
    // Generate palindromic subsequences
    int palindromes[10000];
    int palCount = 0;
    
    for (int mask = 1; mask < (1 << n); mask++) {
        char subseq[100] = {0};
        int idx = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subseq[idx++] = s[i];
            }
        }
        if (isPalindrome(subseq)) {
            palindromes[palCount++] = mask;
        }
    }
    
    // DP to find minimum palindromes
    int* dp = malloc((1 << n) * sizeof(int));
    for (int i = 0; i < (1 << n); i++) {
        dp[i] = INT_MAX;
    }
    dp[0] = 0;
    
    for (int state = 0; state < (1 << n); state++) {
        if (dp[state] == INT_MAX) continue;
        for (int i = 0; i < palCount; i++) {
            int newState = state | palindromes[i];
            if (dp[state] + 1 < dp[newState]) {
                dp[newState] = dp[state] + 1;
            }
        }
    }
    
    int result = dp[(1 << n) - 1];
    free(dp);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

Need to check all 2^n possible subsequences

✓ Linear Growth

Space Complexity

O(2ⁿ)

Store all possible subsequences

✓ Linear Space

28.0K Views

Medium Frequency

~15 min Avg. Time

892 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

Brute Force - Check All Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler