# Minimum number of subsequences required to convert one string to another

Given two strings **A** and **B** consisting of only lowercase letters, the task is to find the minimum number of subsequences required from A to form B.

**Examples:**

Input:A = “abbace” B = “acebbaae”

Output:3

Explanation:

Sub-sequences “ace”, “bba”, “ae” from string A used to form string B

Input:A = “abc” B = “cbacbacba”

Output:7

**Approach:**

- Maintain an array for each character of
**A**which will store its indexes in increasing order. - Traverse through each element of
**B**and increase the counter whenever there is a need for new subsequence. - Maintain a variable
**minIndex**which will show that elements greater than this index can be taken in current subsequence otherwise increase the counter and update the minIndex to -1.

Below is the implementation of the above approach.

## C++

`// C++ program to find the Minimum number ` `// of subsequences required to convert ` `// one string to another ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to find the no of subsequences ` `int` `minSubsequnces(string A, string B) ` `{ ` ` ` `vector<` `int` `> v[26]; ` ` ` `int` `minIndex = -1, cnt = 1, j = 0; ` ` ` `int` `flag = 0; ` ` ` ` ` `for` `(` `int` `i = 0; i < A.length(); i++) { ` ` ` ` ` `// Push the values of indexes of each character ` ` ` `int` `p = (` `int` `)A[i] - 97; ` ` ` `v[p].push_back(i); ` ` ` `} ` ` ` ` ` `while` `(j < B.length()) { ` ` ` `int` `p = (` `int` `)B[j] - 97; ` ` ` ` ` `// Find the next index available in the array ` ` ` `int` `k = upper_bound(v[p].begin(), ` ` ` `v[p].end(), minIndex) ` ` ` `- v[p].begin(); ` ` ` ` ` `// If Character is not in string A ` ` ` `if` `(v[p].size() == 0) { ` ` ` `flag = 1; ` ` ` `break` `; ` ` ` `} ` ` ` ` ` `// Check if the next index is not equal to the ` ` ` `// size of array which means there is no index ` ` ` `// greater than minIndex in the array ` ` ` `if` `(k != v[p].size()) { ` ` ` ` ` `// Update value of minIndex with this index ` ` ` `minIndex = v[p][k]; ` ` ` `j = j + 1; ` ` ` `} ` ` ` `else` `{ ` ` ` ` ` `// Update the value of counter ` ` ` `// and minIndex for next operation ` ` ` `cnt = cnt + 1; ` ` ` `minIndex = -1; ` ` ` `} ` ` ` `} ` ` ` `if` `(flag == 1) { ` ` ` `return` `-1; ` ` ` `} ` ` ` `return` `cnt; ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `string A1 = ` `"abbace"` `; ` ` ` `string B1 = ` `"acebbaae"` `; ` ` ` `cout << minSubsequnces(A1, B1) << endl; ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to find the Minimum number ` `# of subsequences required to convert ` `# one to another ` `from` `bisect ` `import` `bisect as upper_bound ` ` ` `# Function to find the no of subsequences ` `def` `minSubsequnces(A, B): ` ` ` `v ` `=` `[[] ` `for` `i ` `in` `range` `(` `26` `)] ` ` ` `minIndex ` `=` `-` `1` ` ` `cnt ` `=` `1` ` ` `j ` `=` `0` ` ` `flag ` `=` `0` ` ` ` ` `for` `i ` `in` `range` `(` `len` `(A)): ` ` ` ` ` `# Push the values of indexes of each character ` ` ` `p ` `=` `ord` `(A[i]) ` `-` `97` ` ` `v[p].append(i) ` ` ` ` ` `while` `(j < ` `len` `(B)): ` ` ` `p ` `=` `ord` `(B[j]) ` `-` `97` ` ` ` ` `# Find the next index available in the array ` ` ` `k ` `=` `upper_bound(v[p], minIndex) ` ` ` ` ` `# If Character is not in A ` ` ` `if` `(` `len` `(v[p]) ` `=` `=` `0` `): ` ` ` `flag ` `=` `1` ` ` `break` ` ` ` ` `# Check if the next index is not equal to the ` ` ` `# size of array which means there is no index ` ` ` `# greater than minIndex in the array ` ` ` `if` `(k !` `=` `len` `(v[p])): ` ` ` ` ` `# Update value of minIndex with this index ` ` ` `minIndex ` `=` `v[p][k] ` ` ` `j ` `=` `j ` `+` `1` ` ` `else` `: ` ` ` ` ` `# Update the value of counter ` ` ` `# and minIndex for next operation ` ` ` `cnt ` `=` `cnt ` `+` `1` ` ` `minIndex ` `=` `-` `1` ` ` `if` `(flag ` `=` `=` `1` `): ` ` ` `return` `-` `1` ` ` `return` `cnt ` ` ` `# Driver Code ` `A1 ` `=` `"abbace"` `B1 ` `=` `"acebbaae"` `print` `(minSubsequnces(A1, B1)) ` ` ` `# This code is contriuted by mohit kumar 29 ` |

*chevron_right*

*filter_none*

**Output:**

3

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

## Recommended Posts:

- Minimum number of subsequences required to convert one string to another using Greedy Algorithm
- Minimum number of given operations required to convert a string to another string
- Minimum operations required to convert a binary string to all 0s or all 1s
- Minimum swaps required to convert one binary string to another
- Minimum given operations required to convert a given binary string to all 1's
- Minimum splits required to convert a number into prime segments
- Minimum cuts required to convert a palindromic string to a different palindromic string
- Minimum number of palindromic subsequences to be removed to empty a binary string
- Minimum number of swaps required to make the string K periodic
- Minimum number of adjacent swaps to convert a string into its given anagram
- Minimum changes required to make first string substring of second string
- Number of K length subsequences with minimum sum
- Minimum rotations required to get the same String | Set-2
- Minimum rotations required to get the same string
- Given a number as a string, find the number of contiguous subsequences which recursively add up to 9 | Set 2

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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.