Count Different Palindromic Subsequences

Count Different Palindromic Subsequences - Problem

Given a string s, return the number of different non-empty palindromic subsequences in s. Since the answer may be very large, return it modulo 10⁹ + 7.

A subsequence of a string is obtained by deleting zero or more characters from the string. A sequence is palindromic if it is equal to the sequence reversed.

Two sequences a₁, a₂, ... and b₁, b₂, ... are different if there is some i for which aᵢ ≠ bᵢ.

Input & Output

Example 1 — Basic Case

$ Input: s = "bccb"

› Output: 6

💡 Note: The different palindromic subsequences are: "b", "c", "cc", "b" (from end), "bcb", "bccb". Total count is 6.

Example 2 — Single Character

$ Input: s = "abcdabcdabcdabcdabcdabcdabcdabcddcbadcbadcbadcbadcbadcbadcbadcba"

› Output: 104860361

💡 Note: Long string with many different characters creates exponentially many palindromic subsequences, result is modulo 10^9 + 7.

Example 3 — Repeated Characters

$ Input: s = "aaa"

› Output: 3

💡 Note: The palindromic subsequences are: "a" (appears 3 times but counted once), "aa" (appears 3 times but counted once), "aaa" (appears once). Total unique count is 3.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8 M Microsoft 6

The key insight is to use dynamic programming on substring intervals, carefully handling character matches while avoiding double counting of duplicate palindromes. Best approach is 2D DP with O(n³) time and O(n²) space complexity.

Common Approaches

✓ Optimized

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

2D Dynamic Programming

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

Build a 2D DP table where dp[i][j] represents the count of different palindromic subsequences in substring s[i...j]. Fill the table bottom-up, handling character matches and avoiding double counting through careful index tracking.

Generate All Subsequences

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

Generate every possible subsequence using bit manipulation or recursion, then check each subsequence to see if it's a palindrome. This approach ensures we find all palindromic subsequences but is extremely inefficient.

Recursive with Memoization

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

Recursively count palindromic subsequences by considering characters at the boundaries of substrings. Use memoization to avoid recalculating results for the same substring ranges, significantly improving efficiency over brute force.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    bool* houses;
    int size;
    int current;
} Street;

void openDoor(Street* street) {
    street->houses[street->current] = true;
}

void closeDoor(Street* street) {
    street->houses[street->current] = false;
}

bool isDoorOpen(Street* street) {
    return street->houses[street->current];
}

void moveRight(Street* street) {
    street->current = (street->current + 1) % street->size;
}

void moveLeft(Street* street) {
    street->current = (street->current - 1 + street->size) % street->size;
}

int solution(Street* street, int k) {
    // Remember initial state and flip the door to create a unique marker
    bool initialState = isDoorOpen(street);
    if (initialState) {
        closeDoor(street);
    } else {
        openDoor(street);
    }
    
    int count = 0;
    moveRight(street);
    
    // Count houses until we return to the starting position with flipped door
    while (isDoorOpen(street) == initialState) {
        count++;
        moveRight(street);
    }
    
    return count + 1; // +1 for the starting house
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    int k;
    scanf("%d", &k);
    
    // Parse boolean array (simplified)
    bool houses[100];
    int size = 0;
    char* token = strtok(line, ",");
    while (token != NULL && size < 100) {
        if (strstr(token, "true") != NULL) {
            houses[size] = true;
        } else {
            houses[size] = false;
        }
        size++;
        token = strtok(NULL, ",");
    }
    
    Street street = {houses, size, 0};
    int result = solution(&street, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

62.0K Views

Medium Frequency

~35 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