Check if a string can be obtained by appending subsequences of another string

0 0 7 minutes read

Given two strings str1 and str2 of lengths N and M respectively, the task is to check if str2 can be formed by appending subsequences of str1 multiple times. If possible, print the minimum number of append operations required. Otherwise, print -1.

Examples:

Input: str1 = “abb”, str2 = “ababbbbb”
Output: 4
Explanation:
String str2 can be formed by appending subsequences of str1 = “ab” + “abb” + “bb” + “b” = “ababbbbb”. Since at least 4 operations are required, print 4.

Input: str1 = “mt”, str2 = “atttm”
Output: -1
Explanation:
Since ‘a’ is not present in the string str1, str2 cannot be generated from str1. Therefore, print -1.

Approach: The idea is to use the concept of Hashing based on the following observations below:

Consider strings str1 = “abb” and str2 = “aba”. Find the position of character str2[0] in str1 whose index is greater than or equals to 0 i.e., index 0 of str1.
Again, find str2[1] in str1 such that its index is greater than or equals to 1 i.e., index 1 of str1.
Then, find str2[2] in str1 such that its index is greater than or equals to 2 which does not exist.
Therefore, start again from index 0 and find str2[2] in str1 having an index greater than or equals to index 0 i.e., index 0 of str1.
Hence, two subsequences “ab” and “a” can be appended to form “aba”.

Follow the below steps to solve the problem:

Initialize an array of vectors vec[] of length 26.
Push all the indices str1 having character ‘a’ in vec[0]. Similarly, push all indices having character ‘b’ in vec[1]. Do this for every character from ‘a’ to ‘z’.
Initialize a variable result with 1 and position with 0 to store the minimum operations and current position of str1.
Traverse the string str2 over the range [0, M] and for each character do the following:
- If vec[str2[i] – ‘a’] is empty then the character str2[i] is not present in str1. Hence, the answer is not possible. Therefore, print -1.
- Otherwise, find the lower bound of position in vec[str2[i] – ‘a’]. Let it be p. If p is equals the size of the vec[str2[i] – ‘a’] then increment the result by 1 and decrement i by 1 as answer for character str2[i] is not found yet and set position to 0.
- Otherwise, set position as (vec[p] + 1).
After traversing, print the result as the minimum operations required.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
 
#include <bits/stdc++.h>
 
using namespace std;
 
// Function to find minimum operations
// required to form str2 by adding
// subsequences of str1
void find(string str1, string str2)
{
 
    // Initialize vector of length 26
    vector<int> vec1[26];
 
    // Push indices of characters of str1
    for (int i = 0; i < str1.size(); i++)
        vec1[str1[i] - 'a'].push_back(i);
 
    // Initialize the result & position
    int result = 1, position = 0;
 
    // Traverse the string str2
    for (int i = 0; i < str2.size(); i++) 
    {
 
        char c = str2[i];
 
        // Return if no answer exist
        if (vec1.empty())
        {
            result = -1;
            break;
        }
 
        // Pointer of vec1[c-'a']
        vector<int>& vec2 = vec1;
 
        // Lower bound of position
        int p = lower_bound(vec2.begin(),
                            vec2.end(),
                            position)
                - vec2.begin();
 
        // If no index found
        if (p == vec2.size())
        {
            // Increment result
            result++;
            i--;
            position = 0;
            continue;
        }
 
        // Update the position
        else {
            position = vec2[p] + 1;
        }
    }
 
    // Print the result
    cout << result << '\n';
}
 
// Driver Code
int main()
{
    // Given string str1 & str2
    string str1 = "abb", str2 = "ababbbbb";
 
    // Function Call
    find(str1, str2);
 
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.util.*;
 
class GFG {
     
    static void find(String str1, String str2)
    {
 
        List<List<Integer> > vec1
            = new ArrayList<List<Integer> >();
 
        // Initialize vector of length 26
        for (int i = 0; i < 26; i++) {
            vec1.add(new ArrayList<Integer>());
        }
 
        // Push indices of characters of str1
        for (int i = 0; i < str1.length(); i++)
            vec1.get(str1.charAt(i) - 'a').add(i);
 
        // Initialize the result & position
        int result = 1, position = 0;
 
        // Traverse the string str2
        for (int i = 0; i < str2.length(); i++) 
        {
            char c = str2.charAt(i);
 
            // Return if no answer exist
            if (vec1.get(c - 'a').size() == 0) 
            {
                result = -1;
                break;
            }
 
            List<Integer> vec2 = vec1.get(c - 'a');
 
            // Lower bound of position
            int p = lower_bound(vec2, position);
 
            // If no index found
            if (p == vec2.size())
            {
 
                // Increment result
                result++;
                i--;
                position = 0;
                continue;
            }
 
            // Update the position
            else {
                position = vec2.get(p) + 1;
            }
        }
 
        // Print the result
        System.out.println(result);
    }
 
    // Driver Code
    static int lower_bound(List<Integer> vec2, int position)
    {
        int low = 0, high = vec2.size() - 1;
 
        while (low < high) {
            int mid = (low + high) / 2;
            if (vec2.get(mid) < position)
                low = mid + 1;
            else
                high = mid;
        }
        return (vec2.get(low) < position) ? low + 1 : low;
    }
 
    public static void main(String[] args)
    {
        // Given string str1 & str2
        String str1 = "abb", str2 = "ababbbbb";
 
        // Function Call
        find(str1, str2);
    }
}

Python3

# Python3 program for the above approach
from bisect import bisect_left
 
# Function to find minimum operations
# required to form str2 by adding
# subsequences of str1
def find(str1, str2):
   
    # Initialize vector of length 26
    vec1 = [[] for i in range(26)]
 
    # Push indices of characters of str1
    for i in range(len(str1)):
        vec1[ord(str1[i]) - ord('a')].append(i)
 
    # Initialize the result & position
    result = 1
    position = 0
 
    # Traverse the str2
    i = 0
    while i < len(str2):
        c = str2[i]
 
        # Return if no answer exist
        if (len(vec1[ord(c) - ord('a')]) == 0):
            result = -1
            break
 
        # Pointer of vec1[c-'a']
        vec2 = vec1[ord(c) - ord('a')]
 
        # Lower bound of position
        p = bisect_left(vec2, position)
         
        #print(c)
 
        # If no index found
        if (p == len(vec2)):
 
            # Increment result
            result += 1
             
            #i-=1
            position = 0
            continue
             
        # Update the position
        else:
            i += 1
            position = vec2[p] + 1
 
    # Print the result
    print(result)
 
# Driver Code
if __name__ == '__main__':
   
    # Given str1 & str2
    str1 = "abb"
    str2 = "ababbbbb"
 
    # Function Call
    find(str1, str2)
 
# This code is contributed by mohit kumar 29

C#

// C# program for the above approach
using System;
using System.Collections.Generic; 
 
class GFG{
 
// Function to find minimum operations
// required to form str2 by adding
// subsequences of str1    
static void find(string str1, string str2)
{
    List<List<int>> vec1 = new List<List<int>>();
     
    // Initialize vector of length 26
    for(int i = 0; i < 26; i++)
    {
        vec1.Add(new List<int>());
    }
     
    // Push indices of characters of str1
    for(int i = 0; i < str1.Length; i++)
    {
        vec1[str1[i] - 'a'].Add(i);
    }
     
    // Initialize the result & position
    int result = 1, position = 0;
     
    // Traverse the string str2
    for(int i = 0; i < str2.Length; i++)
    {
        char c = str2[i];
         
        // Return if no answer exist
        if (vec1.Count == 0)
        {
            result = -1;
            break;
        }
        List<int> vec2 = vec1;
         
        // Lower bound of position
        int p = lower_bound(vec2, position);
         
        // If no index found
        if (p == vec2.Count)
        {
             
            // Increment result
            result++;
            i--;
            position = 0;
            continue;
        }
         
        // Update the position
        else
        {
            position = vec2[p] + 1;
        }
    }
     
    // Print the result
    Console.WriteLine(result);
}
 
static int lower_bound(List<int> vec2,
                       int position)
{
    int low = 0, high = vec2.Count - 1;
     
    while (low < high)
    {
        int mid = (low + high) / 2;
         
        if (vec2[mid] < position)
        {
            low = mid + 1;
        }
        else
        {
            high = mid;
        }
    }
    return (vec2[low] < position) ?
                  low + 1 : low;
}
 
// Driver Code
static public void Main()
{
     
    // Given string str1 & str2
    string str1 = "abb", str2 = "ababbbbb";
     
    // Function Call
    find(str1, str2);
}
}
 
// This code is contributed by avanitrachhadiya2155

Javascript

// JavaScript program for the above approach
function find(str1, str2) {
    // Initialize vector of length 26
    const vec1 = new Array(26);
    for (let i = 0; i < 26; i++) {
        vec1[i] = [];
    }
 
    // Push indices of characters of str1
    for (let i = 0; i < str1.length; i++) {
        vec1[str1.charCodeAt(i) - 97].push(i);
    }
 
    // Initialize the result & position
    let result = 1;
    let position = 0;
 
    // Traverse the string str2
    for (let i = 0; i < str2.length; i++) {
        const c = str2.charAt(i);
 
        // Return if no answer exist
        if (vec1.length === 0) {
            result = -1;
            break;
        }
 
        const vec2 = vec1;
 
        // Lower bound of position
        const p = lower_bound(vec2, position);
 
        // If no index found
        if (p === vec2.length) {
 
            // Increment result
            result++;
            i--;
            position = 0;
            continue;
        }
 
        // Update the position
        else {
            position = vec2[p] + 1;
        }
    }
 
    // Print the result
    console.log(result);
}
 
// Driver Code
function main() {
    // Given string str1 & str2
    const str1 = "abb",
        str2 = "ababbbbb";
    // Function Call
    find(str1, str2);
}
 
function lower_bound(vec2, position) {
    let low = 0;
    let high = vec2.length - 1;
 
    while (low < high) {
        const mid = Math.floor((low + high) / 2);
        if (vec2[mid] < position) {
            low = mid + 1;
        } else {
            high = mid;
        }
    }
    return (vec2[low] < position) ? low + 1 : low;
}
 
main();
 
// Contributed by adityasha4x71

Output

Time Complexity: O(N + M log N)
Auxiliary Space: O(M + N)

Recommended

Solve DSA problems on GfG Practice.

Solve Problems

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 zambiatek!