# Count common subsequence in two strings

Given two string **S** and **Q**. The task is to count the number of the common subsequence in S and T.

**Examples:**

Input : S = “ajblqcpdz”, T = “aefcnbtdi”

Output : 11

Common subsequences are : { “a”, “b”, “c”, “d”, “ab”, “bd”, “ad”, “ac”, “cd”, “abd”, “acd” }Input : S = “a”, T = “ab”

Output : 1

To find the number of common subsequences in two string, say S and T, we use Dynamic Programming by defining a 2D array **dp[][]**, where dp[i][j] is the number of common subsequences in the string S[0…i-1] and T[0….j-1].

Now, we can define dp[i][j] as

= dp[i][j-1] + dp[i-1][j] + 1, when S[i-1] is equal to T[j-1]

This is because when S[i-1] == S[j-1], using the above fact all the previous common sub-sequences are doubled as they get appended by one more character. Both dp[i][j-1] and dp[i-1][j] contain dp[i-1][j-1] and hence it gets added two times in our recurrence which takes care of doubling of count of all previous common sub-sequences. Addition of 1 in recurrence is for the latest character match : common sub-sequence made up of s1[i-1] and s2[j-1]

= dp[i-1][j] + dp[i][j-1] – dp[i-1][j-1], when S[i-1] is not equal to T[j-1]

Here we subtract dp[i-1][j-1] once because it is present in both dp[i][j – 1] and dp[i – 1][j] and gets added twice.

Below is the implementation of this approach:

## C++

`// C++ program to count common subsequence in two strings` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// return the number of common subsequence in` `// two strings` `int` `CommomSubsequencesCount(string s, string t)` `{` ` ` `int` `n1 = s.length();` ` ` `int` `n2 = t.length();` ` ` `int` `dp[n1+1][n2+1];` ` ` `for` `(` `int` `i = 0; i <= n1; i++) {` ` ` `for` `(` `int` `j = 0; j <= n2; j++) {` ` ` `dp[i][j] = 0;` ` ` `}` ` ` `}` ` ` `// for each character of S` ` ` `for` `(` `int` `i = 1; i <= n1; i++) {` ` ` `// for each character in T` ` ` `for` `(` `int` `j = 1; j <= n2; j++) {` ` ` `// if character are same in both` ` ` `// the string` ` ` `if` `(s[i - 1] == t[j - 1])` ` ` `dp[i][j] = 1 + dp[i][j - 1] + dp[i - 1][j]; ` ` ` `else` ` ` `dp[i][j] = dp[i][j - 1] + dp[i - 1][j] -` ` ` `dp[i - 1][j - 1]; ` ` ` `}` ` ` `}` ` ` `return` `dp[n1][n2];` `}` `// Driver Program` `int` `main()` `{` ` ` `string s = ` `"ajblqcpdz"` `;` ` ` `string t = ` `"aefcnbtdi"` `;` ` ` `cout << CommomSubsequencesCount(s, t) << endl;` ` ` `return` `0;` `}` |

## Java

`// Java program to count common subsequence in two strings` `public` `class` `GFG {` ` ` ` ` `// return the number of common subsequence in` ` ` `// two strings` ` ` `static` `int` `CommomSubsequencesCount(String s, String t)` ` ` `{` ` ` `int` `n1 = s.length();` ` ` `int` `n2 = t.length();` ` ` `int` `dp[][] = ` `new` `int` `[n1+` `1` `][n2+` `1` `];` ` ` `char` `ch1,ch2 ;` ` ` ` ` `for` `(` `int` `i = ` `0` `; i <= n1; i++) {` ` ` `for` `(` `int` `j = ` `0` `; j <= n2; j++) {` ` ` `dp[i][j] = ` `0` `;` ` ` `}` ` ` `}` ` ` ` ` `// for each character of S` ` ` `for` `(` `int` `i = ` `1` `; i <= n1; i++) {` ` ` ` ` `// for each character in T` ` ` `for` `(` `int` `j = ` `1` `; j <= n2; j++) {` ` ` ` ` `ch1 = s.charAt(i - ` `1` `);` ` ` `ch2 = t.charAt(j - ` `1` `);` ` ` ` ` `// if character are same in both ` ` ` `// the string ` ` ` `if` `(ch1 == ch2) ` ` ` `dp[i][j] = ` `1` `+ dp[i][j - ` `1` `] + dp[i - ` `1` `][j]; ` ` ` `else` ` ` `dp[i][j] = dp[i][j - ` `1` `] + dp[i - ` `1` `][j] - ` ` ` `dp[i - ` `1` `][j - ` `1` `]; ` ` ` `}` ` ` `}` ` ` ` ` `return` `dp[n1][n2];` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `main (String args[]){` ` ` ` ` `String s = ` `"ajblqcpdz"` `;` ` ` `String t = ` `"aefcnbtdi"` `;` ` ` ` ` `System.out.println(CommomSubsequencesCount(s, t));` ` ` ` ` `}` `// This code is contributed by ANKITRAI1` `}` |

## Python3

`# Python3 program to count common` `# subsequence in two strings` `# return the number of common subsequence` `# in two strings` `def` `CommomSubsequencesCount(s, t):` ` ` `n1 ` `=` `len` `(s)` ` ` `n2 ` `=` `len` `(t)` ` ` `dp ` `=` `[[` `0` `for` `i ` `in` `range` `(n2 ` `+` `1` `)]` ` ` `for` `i ` `in` `range` `(n1 ` `+` `1` `)]` ` ` `# for each character of S` ` ` `for` `i ` `in` `range` `(` `1` `, n1 ` `+` `1` `):` ` ` `# for each character in T` ` ` `for` `j ` `in` `range` `(` `1` `, n2 ` `+` `1` `):` ` ` `# if character are same in both` ` ` `# the string` ` ` `if` `(s[i ` `-` `1` `] ` `=` `=` `t[j ` `-` `1` `]):` ` ` `dp[i][j] ` `=` `(` `1` `+` `dp[i][j ` `-` `1` `] ` `+` ` ` `dp[i ` `-` `1` `][j]) ` ` ` `else` `:` ` ` `dp[i][j] ` `=` `(dp[i][j ` `-` `1` `] ` `+` `dp[i ` `-` `1` `][j] ` `-` ` ` `dp[i ` `-` `1` `][j ` `-` `1` `]) ` ` ` ` ` `return` `dp[n1][n2]` `# Driver Code` `s ` `=` `"ajblqcpdz"` `t ` `=` `"aefcnbtdi"` `print` `(CommomSubsequencesCount(s, t))` `# This code is contributed by Mohit Kumar` |

## C#

`// C# program to count common` `// subsequence in two strings` `using` `System;` `class` `GFG` `{` `// return the number of common` `// subsequence in two strings` `static` `int` `CommomSubsequencesCount(` `string` `s,` ` ` `string` `t)` `{` ` ` `int` `n1 = s.Length;` ` ` `int` `n2 = t.Length;` ` ` `int` `[,] dp = ` `new` `int` `[n1 + 1, n2 + 1];` ` ` ` ` `for` `(` `int` `i = 0; i <= n1; i++)` ` ` `{` ` ` `for` `(` `int` `j = 0; j <= n2; j++)` ` ` `{` ` ` `dp[i, j] = 0;` ` ` `}` ` ` `}` ` ` ` ` `// for each character of S` ` ` `for` `(` `int` `i = 1; i <= n1; i++)` ` ` `{` ` ` ` ` `// for each character in T` ` ` `for` `(` `int` `j = 1; j <= n2; j++)` ` ` `{` ` ` ` ` `// if character are same in` ` ` `// both the string ` ` ` `if` `(s[i - 1] == t[j - 1])` ` ` `dp[i, j] = 1 + dp[i, j - 1] +` ` ` `dp[i - 1, j]; ` ` ` `else` ` ` `dp[i, j] = dp[i, j - 1] +` ` ` `dp[i - 1, j] -` ` ` `dp[i - 1, j - 1]; ` ` ` `}` ` ` `}` ` ` ` ` `return` `dp[n1, n2];` `}` `// Driver code` `public` `static` `void` `Main ()` `{` ` ` `string` `s = ` `"ajblqcpdz"` `;` ` ` `string` `t = ` `"aefcnbtdi"` `;` ` ` ` ` `Console.Write(CommomSubsequencesCount(s, t));` `}` `}` `// This code is contributed` `// by ChitraNayal` |

## PHP

`<?php` `// PHP program to count common subsequence` `// in two strings` `// return the number of common subsequence` `// in two strings` `function` `CommomSubsequencesCount(` `$s` `, ` `$t` `)` `{` ` ` `$n1` `= ` `strlen` `(` `$s` `);` ` ` `$n2` `= ` `strlen` `(` `$t` `);` ` ` `$dp` `= ` `array` `();` ` ` `for` `(` `$i` `= 0; ` `$i` `<= ` `$n1` `; ` `$i` `++)` ` ` `{` ` ` `for` `(` `$j` `= 0; ` `$j` `<= ` `$n2` `; ` `$j` `++)` ` ` `{` ` ` `$dp` `[` `$i` `][` `$j` `] = 0;` ` ` `}` ` ` `}` ` ` `// for each character of S` ` ` `for` `(` `$i` `= 1; ` `$i` `<= ` `$n1` `; ` `$i` `++)` ` ` `{` ` ` `// for each character in T` ` ` `for` `(` `$j` `= 1; ` `$j` `<= ` `$n2` `; ` `$j` `++)` ` ` `{` ` ` `// if character are same in both` ` ` `// the string` ` ` `if` `(` `$s` `[` `$i` `- 1] == ` `$t` `[` `$j` `- 1])` ` ` `$dp` `[` `$i` `][` `$j` `] = 1 + ` `$dp` `[` `$i` `][` `$j` `- 1] +` ` ` `$dp` `[` `$i` `- 1][` `$j` `]; ` ` ` `else` ` ` `$dp` `[` `$i` `][` `$j` `] = ` `$dp` `[` `$i` `][` `$j` `- 1] +` ` ` `$dp` `[` `$i` `- 1][` `$j` `] -` ` ` `$dp` `[` `$i` `- 1][` `$j` `- 1]; ` ` ` `}` ` ` `}` ` ` `return` `$dp` `[` `$n1` `][` `$n2` `];` `}` `// Driver Code` `$s` `= ` `"ajblqcpdz"` `;` `$t` `= ` `"aefcnbtdi"` `;` `echo` `CommomSubsequencesCount(` `$s` `, ` `$t` `) .` `"\n"` `;` `// This code is contributed` `// by Akanksha Rai` `?>` |

## Javascript

`<script>` `// Javascript program to count common subsequence in two strings` `// return the number of common subsequence in` `// two strings` `function` `CommomSubsequencesCount(s, t)` `{` ` ` `var` `n1 = s.length;` ` ` `var` `n2 = t.length;` ` ` `var` `dp = Array.from(Array(n1+1), ()=> Array(n2+1));` ` ` `for` `(` `var` `i = 0; i <= n1; i++) {` ` ` `for` `(` `var` `j = 0; j <= n2; j++) {` ` ` `dp[i][j] = 0;` ` ` `}` ` ` `}` ` ` `// for each character of S` ` ` `for` `(` `var` `i = 1; i <= n1; i++) {` ` ` `// for each character in T` ` ` `for` `(` `var` `j = 1; j <= n2; j++) {` ` ` `// if character are same in both` ` ` `// the string` ` ` `if` `(s[i - 1] == t[j - 1])` ` ` `dp[i][j] = 1 + dp[i][j - 1] + dp[i - 1][j]; ` ` ` `else` ` ` `dp[i][j] = dp[i][j - 1] + dp[i - 1][j] -` ` ` `dp[i - 1][j - 1]; ` ` ` `}` ` ` `}` ` ` `return` `dp[n1][n2];` `}` `// Driver Program` `var` `s = ` `"ajblqcpdz"` `;` `var` `t = ` `"aefcnbtdi"` `;` `document.write( CommomSubsequencesCount(s, t));` `</script>` |

**Output:**

11

**Time Complexity :** O(n1 * n2) **Auxiliary Space : **O(n1 * n2)**Source :** StackOverflow

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.