Count All Palindromic Subsequence in a given String - GeeksforGeeks

04 Mar, 2022
Find how many palindromic subsequences (need not necessarily be distinct) can be formed in a given string. Note that the empty string is not considered as a palindrome. Examples: 
Input : str = "abcd"
Output : 4
Explanation :- palindromic  subsequence are : "a" ,"b", "c" ,"d" 

Input : str = "aab"
Output : 4
Explanation :- palindromic subsequence are :"a", "a", "b", "aa"

Input : str = "aaaa"
Output : 15
The above problem can be recursively defined. 
Initial Values : i= 0, j= n-1;

CountPS(i,j)
// Every single character of a string is a palindrome 
// subsequence 
if i == j
   return 1 // palindrome of length 1

// If first and last characters are same, then we 
// consider it as palindrome subsequence and check
// for the rest subsequence (i+1, j), (i, j-1)
Else if (str[i] == str[j)]
   return   countPS(i+1, j) + countPS(i, j-1) + 1;

else
   // check for rest sub-sequence and  remove common
   // palindromic subsequences as they are counted
   // twice when we do countPS(i+1, j) + countPS(i,j-1)
   return countPS(i+1, j) + countPS(i, j-1) - countPS(i+1, j-1)
If we draw recursion tree of above recursive solution, we can observe overlapping Subproblems. Since the problem has overlapping subproblems, we can solve it efficiently using Dynamic Programming. Below is Dynamic Programming based solution. 
C++
Java
Python3
C#
PHP
Javascript
// Counts Palindromic Subsequence in a given String#include <cstring>#include <iostream>using namespace std; // Function return the total palindromic subsequenceint countPS(string str){    int N = str.length();     // create a 2D array to store the count of palindromic    // subsequence    int cps[N + 1][N + 1];    memset(cps, 0, sizeof(cps));     // palindromic subsequence of length 1    for (int i = 0; i < N; i++)        cps[i][i] = 1;     // check subsequence of length L is palindrome or not    for (int L = 2; L <= N; L++) {        for (int i = 0; i <= N-L; i++) {            int k = L + i - 1;            if (str[i] == str[k])                cps[i][k]                    = cps[i][k - 1] + cps[i + 1][k] + 1;            else                cps[i][k] = cps[i][k - 1] + cps[i + 1][k]                            - cps[i + 1][k - 1];        }    }     // return total palindromic subsequence    return cps[0][N - 1];} // Driver programint main(){    string str = "abcb";    cout << "Total palindromic subsequence are : "         << countPS(str) << endl;    return 0;}
// Java code to Count Palindromic Subsequence// in a given Stringpublic class GFG {    // Function return the total palindromic    // subsequence    static int countPS(String str)    {        int N = str.length();         // create a 2D array to store the count        // of palindromic subsequence        int[][] cps = new int[N][N];         // palindromic subsequence of length 1        for (int i = 0; i < N; i++)            cps[i][i] = 1;         // check subsequence of length L is        // palindrome or not        for (int L = 2; L <= N; L++) {            for (int i = 0; i <= N-L; i++) {                int k = L + i - 1;              if (str.charAt(i) == str.charAt(k)) {                cps[i][k] = cps[i][k - 1]                                    + cps[i + 1][k] + 1;              }else{                cps[i][k] = cps[i][k - 1]                                    + cps[i + 1][k]                                    - cps[i + 1][k - 1];              }            }        }         // return total palindromic subsequence        return cps[0][N - 1];    }     // Driver program    public static void main(String args[])    {        String str = "abcb";        System.out.println("Total palindromic "                           + "subsequence are : "                           + countPS(str));    }}// This code is contributed by Sumit Ghosh
# Python3 code to Count Palindromic# Subsequence in a given String # Function return the total# palindromic subsequence  def countPS(str):     N = len(str)     # Create a 2D array to store the count    # of palindromic subsequence    cps = [[0 for i in range(N + 2)]for j in range(N + 2)]     # palindromic subsequence of length 1    for i in range(N):        cps[i][i] = 1     # check subsequence of length L    # is palindrome or not    for L in range(2, N + 1):         for i in range(N):            k = L + i - 1            if (k < N):                if (str[i] == str[k]):                    cps[i][k] = (cps[i][k - 1] +                                 cps[i + 1][k] + 1)                else:                    cps[i][k] = (cps[i][k - 1] +                                 cps[i + 1][k] -                                 cps[i + 1][k - 1])     # return total palindromic subsequence    return cps[0][N - 1]  # Driver programstr = "abcb"print("Total palindromic subsequence are : ", countPS(str))  # This code is contributed by Anant Agarwal.
// C# code to Count Palindromic Subsequence// Subsequence in a given Stringusing System; class GFG {     // Function return the total    // palindromic subsequence    static int countPS(string str)    {        int N = str.Length;         // create a 2D array to store the        // count of palindromic subsequence        int[, ] cps = new int[N + 1, N + 1];         // palindromic subsequence        // of length 1        for (int i = 0; i < N; i++)            cps[i, i] = 1;         // check subsequence of length        // L is palindrome or not        for (int L = 2; L <= N; L++) {            for (int i = 0; i <= N-L; i++) {                int k = L + i - 1;                if (k < N) {                    if (str[i] == str[k])                        cps[i, k] = cps[i, k - 1]                                    + cps[i + 1, k] + 1;                    else                        cps[i, k] = cps[i, k - 1]                                    + cps[i + 1, k]                                    - cps[i + 1, k - 1];                }            }        }         // return total palindromic        // subsequence        return cps[0, N - 1];    }     // Driver Code    public static void Main()    {        string str = "abcb";        Console.Write("Total palindromic "                      + "subsequence are : "                      + countPS(str));    }} // This code is contributed by nitin mittal.
<?php// Counts Palindromic Subsequence in// a given String // Function return the total// palindromic subsequencefunction countPS($str){    $N = strlen($str);     // create a 2D array to store the    // count of palindromic subsequence    $cps = array_fill(0, $N + 1,           array_fill(0, $N + 1, NULL));     // palindromic subsequence of length 1    for ($i = 0; $i < $N; $i++)        $cps[$i][$i] = 1;     // check subsequence of length L    // is palindrome or not    for ($L = 2; $L <= $N; $L++)    {        for ($i = 0; $i <= $N-$L; $i++)        {            $k = $L + $i - 1;            if ($str[$i] == $str[$k])                $cps[$i][$k] = $cps[$i][$k - 1] +                               $cps[$i + 1][$k] + 1;            else                $cps[$i][$k] = $cps[$i][$k - 1] +                               $cps[$i + 1][$k] -                               $cps[$i + 1][$k - 1];        }    }     // return total palindromic subsequence    return $cps[0][$N - 1];} // Driver Code$str = "abcb";echo "Total palindromic subsequence are : " .                        countPS($str) . "\n"; // This code is contributed by ita_c?>
<script> // Javascript code to Count Palindromic Subsequence// in a given String         // Function return the total palindromic    // subsequence    function countPS(str)    {        let N = str.length;          // create a 2D array to store the count        // of palindromic subsequence        let cps = new Array(N);        for(let i=0;i<N;i++)        {            cps[i]=new Array(N);            for(let j=0;j<N;j++)            {                cps[i][j]=0;            }        }          // palindromic subsequence of length 1        for (let i = 0; i < N; i++)            cps[i][i] = 1;          // check subsequence of length L is        // palindrome or not        for (let L = 2; L <= N; L++) {            for (let i = 0; i <= N-L; i++) {                let k = L + i - 1;              if (str[i] == str[k]) {                cps[i][k] = cps[i][k - 1]                                    + cps[i + 1][k] + 1;              }else{                cps[i][k] = cps[i][k - 1]                                    + cps[i + 1][k]                                    - cps[i + 1][k - 1];              }            }        }          // return total palindromic subsequence        return cps[0][N - 1];    }         // Driver program    let str = "abcb";    document.write("Total palindromic "                           + "subsequence are : "                           + countPS(str));         // This code is contributed by avanitrachhadiya2155     </script>
Output: 
Total palindromic subsequence are : 6
Time Complexity : O(N2)
Another approach: (Using recursion) 
C++
Java
Python 3
C#
PHP
Javascript
// C++ program to counts Palindromic Subsequence// in a given String using recursion#include <bits/stdc++.h>using namespace std; int n, dp[1000][1000];string str = "abcb"; // Function return the total// palindromic subsequenceint countPS(int i, int j){     if (i > j)        return 0;     if (dp[i][j] != -1)        return dp[i][j];     if (i == j)        return dp[i][j] = 1;     else if (str[i] == str[j])        return dp[i][j]               = countPS(i + 1, j) +                countPS(i, j - 1) + 1;     else        return dp[i][j] = countPS(i + 1, j) +                          countPS(i, j - 1) -                          countPS(i + 1, j - 1);} // Driver codeint main(){    memset(dp, -1, sizeof(dp));    n = str.size();    cout << "Total palindromic subsequence are : "         << countPS(0, n - 1) << endl;    return 0;}// this code is contributed by Kushdeep Mittal
// Java program to counts Palindromic Subsequence// in a given String using recursion class GFG {    static int n;    static int[][] dp = new int[1000][1000];     static String str = "abcb";     // Function return the total    // palindromic subsequence    static int countPS(int i, int j)    {         if (i > j)            return 0;         if (dp[i][j] != -1)            return dp[i][j];             if (i == j)            return dp[i][j] = 1;         else if (str.charAt(i) == str.charAt(j))            return dp[i][j]                = countPS(i + 1, j) +                    countPS(i, j - 1) + 1;         else            return dp[i][j] = countPS(i + 1, j) +                              countPS(i, j - 1) -                              countPS(i + 1, j - 1);    }     // Driver code    public static void main(String[] args)    {        for (int i = 0; i < 1000; i++)            for (int j = 0; j < 1000; j++)                dp[i][j] = -1;         n = str.length();        System.out.println("Total palindromic subsequence"                           + "are : " + countPS(0, n - 1));    }} // This code is contributed by Ryuga
# Python 3 program to counts Palindromic# Subsequence in a given String using recursion str = "abcb" # Function return the total# palindromic subsequence  def countPS(i, j):     if(i > j):        return 0     if(dp[i][j] != -1):        return dp[i][j]     if(i == j):        dp[i][j] = 1        return dp[i][j]     else if (str[i] == str[j]):        dp[i][j] = (countPS(i + 1, j) +                    countPS(i, j - 1) + 1)        return dp[i][j]    else:        dp[i][j] = (countPS(i + 1, j) +                    countPS(i, j - 1) -                    countPS(i + 1, j - 1))        return dp[i][j]  # Driver codeif __name__ == "__main__":     dp = [[-1 for x in range(1000)]          for y in range(1000)]     n = len(str)    print("Total palindromic subsequence are :",          countPS(0, n - 1)) # This code is contributed by ita_c
// C# program to counts Palindromic Subsequence// in a given String using recursionusing System; class GFG {    static int n;    static int[, ] dp = new int[1000, 1000];     static string str = "abcb";     // Function return the total    // palindromic subsequence    static int countPS(int i, int j)    {         if (i > j)            return 0;         if (dp[i, j] != -1)            return dp[i, j];         if (i == j)            return dp[i, j] = 1;         else if (str[i] == str[j])            return dp[i, j]                = countPS(i + 1, j) +                countPS(i, j - 1) + 1;         else            return dp[i, j] = countPS(i + 1, j)                              + countPS(i, j - 1)                              - countPS(i + 1, j - 1);    }     // Driver code    static void Main()    {        for (int i = 0; i < 1000; i++)            for (int j = 0; j < 1000; j++)                dp[i, j] = -1;         n = str.Length;        Console.Write("Total palindromic subsequence"                      + "are : " + countPS(0, n - 1));    }} // This code is contributed by DrRoot_
<?php// PHP program to counts Palindromic Subsequence// in a given String using recursion$dp = array_fill(0, 100,      array_fill(0, 1000, -1)); $str = "abcb";$n = strlen($str); // Function return the total// palindromic subsequencefunction countPS($i, $j){    global $str, $dp, $n;         if($i > $j)        return 0;         if($dp[$i][$j] != -1)        return $dp[$i][$j];         if($i == $j)        return $dp[$i][$j] = 1;         else if ($str[$i] == $str[$j])        return $dp[$i][$j] = countPS($i + 1, $j) +                             countPS($i, $j - 1) + 1;         else        return $dp[$i][$j] = countPS($i + 1, $j) +                             countPS($i, $j - 1) -                             countPS($i + 1, $j - 1);} // Driver codeecho "Total palindromic subsequence are : " .                          countPS(0, $n - 1);         // This code is contributed by mits?>
<script>// Javascript program to counts Palindromic Subsequence// in a given String using recursion         let n;    let dp=new Array(1000);    for(let i=0;i<1000;i++)    {        dp[i]=new Array(1000);        for(let j=0;j<1000;j++)        {            dp[i][j]=-1;        }    }              let str = "abcb";      // Function return the total    // palindromic subsequence    function countPS(i,j)    {        if (i > j)            return 0;          if (dp[i][j] != -1)            return dp[i][j];              if (i == j)            return dp[i][j] = 1;          else if (str[i] == str[j])            return dp[i][j]                = countPS(i + 1, j) +                    countPS(i, j - 1) + 1;          else            return dp[i][j] = countPS(i + 1, j) +                              countPS(i, j - 1) -                              countPS(i + 1, j - 1);    }         // Driver code     n = str.length;     document.write("Total palindromic subsequence"                           + "are : " + countPS(0, n - 1));         // This code is contributed by rag2127     </script>
Output: 
Total palindromic subsequence are : 6
This article is contributed by Nishant_sing(pintu). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
nitin mittal
Kushdeep_Mittal
ukasp
DrRoot_
ankthon
Mithun Kumar
Ankur Goel
parasmadan15
ralph0609
VishalSingh58
akscodebay
avanitrachhadiya2155
rag2127
surinderdawra388
palindrome
subsequence
Dynamic Programming
Dynamic Programming
palindrome
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Bellman–Ford Algorithm | DP-23
Floyd Warshall Algorithm | DP-16
Subset Sum Problem | DP-25
Matrix Chain Multiplication | DP-8
Coin Change | DP-7
Travelling Salesman Problem | Set 1 (Naive and Dynamic Programming)
Edit Distance | DP-5
Sieve of Eratosthenes
Overlapping Subproblems Property in Dynamic Programming | DP-1
Find minimum number of coins that make a given value