Count Different Palindromic Subsequences - Practice Coding Problems

Count Different Palindromic Subsequences - Problem

Given a string s, you need to find the number of different non-empty palindromic subsequences that can be formed from it. This is a challenging problem that combines string manipulation with dynamic programming!

🎯 What you need to do:

Count all possible palindromic subsequences (not substrings!)
A subsequence is formed by deleting zero or more characters while maintaining order
A sequence is palindromic if it reads the same forwards and backwards
Two subsequences are different if they differ at any position

⚠️ Important: Since the answer can be very large, return it modulo 10^9 + 7.

Example: For string "bccb", the palindromic subsequences are: "b", "c", "cc", "bcb", "bccb" → Answer: 6

Input & Output

example_1.py — Basic Case

$ Input: s = "bccb"

› Output: 6

💡 Note: The palindromic subsequences are: "b" (appears twice but we count unique strings), "c" (appears twice but counts as one), "cc", "bcb", "bccb". Total unique palindromic subsequences: 6

example_2.py — All Same Character

$ Input: s = "abcdabcdabcdabcdabcdabcdabcdabcddcbadcbadcbadcbadcbadcbadcbadcba"

› Output: 104860361

💡 Note: With repeating patterns, we get many different palindromic subsequences. The DP approach efficiently handles the exponential growth.

example_3.py — Single Character

$ Input: s = "a"

› Output: 1

💡 Note: Only one palindromic subsequence possible: "a"

Visualization

Tap to expand

Understanding the Visualization

Initialize Base Cases

Every single character is a palindrome by itself

Build Up Ranges

For each substring, decide based on whether endpoints match

Handle Matches

When endpoints match, we can form new palindromes by wrapping them around inner palindromes

Handle Non-matches

When endpoints don't match, combine counts from two overlapping subproblems

Apply Modular Arithmetic

Keep results within bounds using modulo 10^9 + 7

Key Takeaway

🎯 Key Insight: By recognizing that palindromes have symmetric structure, we can use dynamic programming to count them efficiently in O(n²) time instead of the brute force O(2^n) approach.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We solve O(n²) subproblems, each taking O(n) time in worst case

⚠ Quadratic Growth

Space Complexity

O(n²)

2D DP table to store results for all substrings

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 1000
s consists only of lowercase English letters
Return the answer modulo 10⁹ + 7

Asked in

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

The optimal solution uses Dynamic Programming with an O(n²) approach. We build a 2D DP table where dp[i][j] represents the count of palindromic subsequences in substring s[i:j+1]. The key insight is handling cases where the first and last characters match vs. don't match, using careful counting to avoid duplicates.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n²)	O(n²)	Use memoized recursion to count palindromic subsequences efficiently
Brute Force (Generate All Subsequences)	O(2^n × n)	O(n)	Generate all possible subsequences and check each for palindrome property

Dynamic Programming (Optimal) — Algorithm Steps

Create a 2D DP table where dp[i][j] = count of palindromic subsequences in s[i:j+1]
Handle base cases: single characters and empty strings
For each substring, check if first and last characters match
If they match: count palindromes that include both, exclude both, or include just one
If they don't match: count palindromes in two overlapping substrings, subtract intersection

Visualization

Tap to expand

Step-by-Step Walkthrough

Base Case

Initialize single characters as palindromes

Match Case

When characters match, we can form new palindromes

No Match

When characters don't match, combine results from subproblems

Final Result

The answer is in dp[0][n-1]

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_LEN 1000

int countPalindromicSubsequences(char* s) {
    int n = strlen(s);
    
    // dp[i][j] = number of different palindromic subsequences in s[i:j+1]
    long long dp[MAX_LEN][MAX_LEN];
    memset(dp, 0, sizeof(dp));
    
    // Single characters are palindromes
    for (int i = 0; i < n; i++) {
        dp[i][i] = 1;
    }
    
    // Fill for all lengths from 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]) {
                // Characters match - we can form new palindromes
                dp[i][j] = (2 * dp[i + 1][j - 1] + 2) % MOD;
                
                // Find the first and last occurrence of s[i] in s[i+1:j]
                int left = i + 1;
                int right = j - 1;
                
                while (left <= right && s[left] != s[i]) {
                    left++;
                }
                while (left <= right && s[right] != s[i]) {
                    right--;
                }
                
                if (left > right) {
                    // No occurrence of s[i] in between
                    continue;
                } else if (left == right) {
                    // One occurrence - subtract 1
                    dp[i][j] = (dp[i][j] - 1 + MOD) % MOD;
                } else {
                    // Multiple occurrences - subtract dp[left][right]
                    dp[i][j] = (dp[i][j] - dp[left][right] + MOD) % MOD;
                }
            } else {
                // Characters don't match
                dp[i][j] = (dp[i][j - 1] + dp[i + 1][j] - dp[i + 1][j - 1] + MOD) % MOD;
            }
        }
    }
    
    return (int)dp[0][n - 1];
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We solve O(n²) subproblems, each taking O(n) time in worst case

⚠ Quadratic Growth

Space Complexity

O(n²)

2D DP table to store results for all substrings

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 1000
s consists only of lowercase English letters
Return the answer modulo 10⁹ + 7

48.3K Views

Medium-High Frequency

~25 min Avg. Time

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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler