# Count ways to increase LCS length of two strings by one

Given two strings of lower alphabet characters, we need to find the number of ways to insert a character in the first string such that length of LCS of both strings increases by one.

Examples:

Input : str1 = “abab”, str2 = “abc” Output : 3 LCS length of given two strings is 2. There are 3 ways of insertion in str1, to increase the LCS length by one which are enumerated below, str1 = “abcab” str2 = “abc” LCS length = 3 str1 = “abacb” str2 = “abc” LCS length = 3 str1 = “ababc” str2 = “abc” LCS length = 3 Input : str1 = “abcabc”, str2 = “abcd” Output : 4

The idea is try all 26 possible characters at each position of first string, if length of str1 is m then a new character can be inserted in (m + 1) positions, now suppose at any time character c is inserted at ith position in str1 then we will match it with all positions having character c in str2. Suppose one such position is j, then for total LCS length to be one more than previous, below condition should satisfy,

LCS(str1[1, m], str2[1, n]) = LCS(str1[1, i], str2[1, j-1]) + LCS(str1[i+1, m], str2[j+1, n])

Above equation states that sum of LCS of the suffix and prefix substrings at inserted character must be same as total LCS of strings, so that when the same character is inserted in first string it will increase the length of LCS by one.

In below code two 2D arrays, lcsl and lcsr are used for storing LCS of prefix and suffix of strings respectively. Method for filling these 2D arrays can be found here.

Please see below code for better understanding,

## C++

`// C++ program to get number of ways to increase ` `// LCS by 1 ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `#define M 26 ` ` ` `// Utility method to get integer position of lower ` `// alphabet character ` `int` `toInt(` `char` `ch) ` `{ ` ` ` `return` `(ch - ` `'a'` `); ` `} ` ` ` `// Method returns total ways to increase LCS length by 1 ` `int` `waysToIncreaseLCSBy1(string str1, string str2) ` `{ ` ` ` `int` `m = str1.length(), n = str2.length(); ` ` ` ` ` `// Fill positions of each character in vector ` ` ` `vector<` `int` `> position[M]; ` ` ` `for` `(` `int` `i = 1; i <= n; i++) ` ` ` `position[toInt(str2[i-1])].push_back(i); ` ` ` ` ` `int` `lcsl[m + 2][n + 2]; ` ` ` `int` `lcsr[m + 2][n + 2]; ` ` ` ` ` `// Initializing 2D array by 0 values ` ` ` `for` `(` `int` `i = 0; i <= m+1; i++) ` ` ` `for` `(` `int` `j = 0; j <= n + 1; j++) ` ` ` `lcsl[i][j] = lcsr[i][j] = 0; ` ` ` ` ` `// Filling LCS array for prefix substrings ` ` ` `for` `(` `int` `i = 1; i <= m; i++) ` ` ` `{ ` ` ` `for` `(` `int` `j = 1; j <= n; j++) ` ` ` `{ ` ` ` `if` `(str1[i-1] == str2[j-1]) ` ` ` `lcsl[i][j] = 1 + lcsl[i-1][j-1]; ` ` ` `else` ` ` `lcsl[i][j] = max(lcsl[i-1][j], ` ` ` `lcsl[i][j-1]); ` ` ` `} ` ` ` `} ` ` ` ` ` `// Filling LCS array for suffix substrings ` ` ` `for` `(` `int` `i = m; i >= 1; i--) ` ` ` `{ ` ` ` `for` `(` `int` `j = n; j >= 1; j--) ` ` ` `{ ` ` ` `if` `(str1[i-1] == str2[j-1]) ` ` ` `lcsr[i][j] = 1 + lcsr[i+1][j+1]; ` ` ` `else` ` ` `lcsr[i][j] = max(lcsr[i+1][j], ` ` ` `lcsr[i][j+1]); ` ` ` `} ` ` ` `} ` ` ` ` ` `// Looping for all possible insertion positions ` ` ` `// in first string ` ` ` `int` `ways = 0; ` ` ` `for` `(` `int` `i=0; i<=m; i++) ` ` ` `{ ` ` ` `// Trying all possible lower case characters ` ` ` `for` `(` `char` `c=` `'a'` `; c<=` `'z'` `; c++) ` ` ` `{ ` ` ` `// Now for each character, loop over same ` ` ` `// character positions in second string ` ` ` `for` `(` `int` `j=0; j<position[toInt(c)].size(); j++) ` ` ` `{ ` ` ` `int` `p = position[toInt(c)][j]; ` ` ` ` ` `// If both, left and right substrings make ` ` ` `// total LCS then increase result by 1 ` ` ` `if` `(lcsl[i][p-1] + lcsr[i+1][p+1] == lcsl[m][n]) ` ` ` `ways++; ` ` ` `} ` ` ` `} ` ` ` `} ` ` ` ` ` `return` `ways; ` `} ` ` ` `// Driver code to test above methods ` `int` `main() ` `{ ` ` ` `string str1 = ` `"abcabc"` `; ` ` ` `string str2 = ` `"abcd"` `; ` ` ` `cout << waysToIncreaseLCSBy1(str1, str2); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Python3

`# Python program to get number of ways to increase ` `# LCS by 1 ` ` ` `M ` `=` `26` ` ` `# Method returns total ways to increase LCS length by 1 ` `def` `waysToIncreaseLCSBy1(str1, str2): ` ` ` `m ` `=` `len` `(str1) ` ` ` `n ` `=` `len` `(str2) ` ` ` ` ` `# Fill positions of each character in vector ` ` ` `# vector<int> position[M]; ` ` ` `position ` `=` `[[] ` `for` `i ` `in` `range` `(M)] ` ` ` `for` `i ` `in` `range` `(` `1` `, n` `+` `1` `, ` `1` `): ` ` ` `position[` `ord` `(str2[i` `-` `1` `])` `-` `97` `].append(i) ` ` ` ` ` `# Initializing 2D array by 0 values ` ` ` `lcsl ` `=` `[[` `0` `for` `i ` `in` `range` `(n` `+` `2` `)] ` `for` `j ` `in` `range` `(m` `+` `2` `)] ` ` ` `lcsr ` `=` `[[` `0` `for` `i ` `in` `range` `(n` `+` `2` `)] ` `for` `j ` `in` `range` `(m` `+` `2` `)] ` ` ` ` ` `# Filling LCS array for prefix substrings ` ` ` `for` `i ` `in` `range` `(` `1` `, m` `+` `1` `, ` `1` `): ` ` ` `for` `j ` `in` `range` `(` `1` `, n` `+` `1` `,` `1` `): ` ` ` `if` `(str1[i` `-` `1` `] ` `=` `=` `str2[j` `-` `1` `]): ` ` ` `lcsl[i][j] ` `=` `1` `+` `lcsl[i` `-` `1` `][j` `-` `1` `] ` ` ` `else` `: ` ` ` `lcsl[i][j] ` `=` `max` `(lcsl[i` `-` `1` `][j], ` ` ` `lcsl[i][j` `-` `1` `]) ` ` ` ` ` `# Filling LCS array for suffix substrings ` ` ` `for` `i ` `in` `range` `(m, ` `0` `, ` `-` `1` `): ` ` ` `for` `j ` `in` `range` `(n, ` `0` `, ` `-` `1` `): ` ` ` `if` `(str1[i` `-` `1` `] ` `=` `=` `str2[j` `-` `1` `]): ` ` ` `lcsr[i][j] ` `=` `1` `+` `lcsr[i` `+` `1` `][j` `+` `1` `] ` ` ` `else` `: ` ` ` `lcsr[i][j] ` `=` `max` `(lcsr[i` `+` `1` `][j], ` ` ` `lcsr[i][j` `+` `1` `]) ` ` ` ` ` `# Looping for all possible insertion positions ` ` ` `# in first string ` ` ` `ways ` `=` `0` ` ` `for` `i ` `in` `range` `(` `0` `, m` `+` `1` `,` `1` `): ` ` ` `# Trying all possible lower case characters ` ` ` `for` `C ` `in` `range` `(` `0` `, ` `26` `,` `1` `): ` ` ` `# Now for each character, loop over same ` ` ` `# character positions in second string ` ` ` `for` `j ` `in` `range` `(` `0` `, ` `len` `(position[C]),` `1` `): ` ` ` `p ` `=` `position[C][j] ` ` ` ` ` `# If both, left and right substrings make ` ` ` `# total LCS then increase result by 1 ` ` ` `if` `(lcsl[i][p` `-` `1` `] ` `+` `lcsr[i` `+` `1` `][p` `+` `1` `] ` `=` `=` `lcsl[m][n]): ` ` ` `ways ` `+` `=` `1` ` ` `return` `ways ` ` ` ` ` `# Driver code to test above methods ` `str1 ` `=` `"abcabc"` `str2 ` `=` `"abcd"` `print` `(waysToIncreaseLCSBy1(str1, str2)) ` ` ` `# This code is contributed by ankush_953 ` |

*chevron_right*

*filter_none*

**Output:**

4

**
Time Complexity :** O(mn)

**Auxiliary Space :**O(mn)

This article is contributed by **Utkarsh Trivedi**. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@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.

## Recommended Posts:

- Number of ways to insert a character to increase the LCS by one
- Count of sub-strings of length n possible from the given string
- Maximum count of sub-strings of length K consisting of same characters
- Count number of binary strings such that there is no substring of length greater than or equal to 3 with all 1's
- Array of Strings in C++ (3 Different Ways to Create)
- Count of strings that become equal to one of the two strings after one removal
- Number of ways to make binary string of length N such that 0s always occur together in groups of size K
- Sub-strings of length K containing same character
- All possible strings of any length that can be formed from a given string
- Check if all the palindromic sub-strings are of odd length
- Number of ways to divide string in sub-strings such to make them in lexicographically increasing sequence
- Number of strings of length N with no palindromic sub string
- Number of Binary Strings of length N with K adjacent Set Bits
- Generate all binary strings of length n with sub-string "01" appearing exactly twice
- Find the number of binary strings of length N with at least 3 consecutive 1s