Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Minimize removals to remove another string as a subsequence of a given string

  • Difficulty Level : Expert
  • Last Updated : 22 Jun, 2021

Given two strings str and X of length N and M respectively, the task is to find the minimum characters required to be removed from the string str such that string str doesn’t contain the string X as a subsequence.

Examples:

Input: str = “btagd”, X = “bad”
Output: 1
Explanation:
String “btag” has does not contain “bad” as a subsequence. Therefore, only one removal is required.

Input: str = “bbaaddd”, X = “bad”
Output: 2

 

Approach: This problem can be solved by Dynamic Programming. Follow the steps below to solve the problem:

  • Traverse the string.
  • Initialize a 2D array dp[N][M], where N is the length of string str and M is the length of string X.
  • dp[i][j] represents the minimum number of character removal required in the substring str[0, i] such that there is no occurrence of substring X[0, j] as a subsequence.
  • The two transition states are:
    • If str[i] is equal to X[j],
      • Case 1: Remove the character str[i]
      • Case 2: Maintain the character str[i], by ensuring that there is no occurrence of X[0, j-1] as a subsequence in str[0, i]
      • Update dp[i][j] = min(dp[i − 1][j − 1], dp[i − 1][j] + 1)
    • If str[i] is not equal to X[j], str[i] can be kept as it is.
      •  Update dp[i][j] = dp[i – 1][j]
  • Print the minimum removals i.e, dp[N – 1][M – 1]

Below is the implementation of the above approach:

C++




// C++ implementation of
// the above approach
#include <bits/stdc++.h>
 
using namespace std;
 
// Function to print the minimum number of
// character removals required to remove X
// as a subsequence from the string str
void printMinimumRemovals(string str, string X)
{
 
    // Length of the string str
    int N = str.size();
 
    // Length of the string X
    int M = X.size();
 
    // Stores the dp states
    int dp[N][M] = {};
 
    // Fill first row of dp[][]
    for (int j = 0; j < M; j++) {
 
        // If X[j] matches with str[0]
        if (str[0] == X[j]) {
 
            dp[0][j] = 1;
        }
    }
 
    for (int i = 1; i < N; i++) {
 
        for (int j = 0; j < M; j++) {
 
            // If str[i] is equal to X[j]
            if (str[i] == X[j]) {
 
                // Update state after removing str[i[
                dp[i][j] = dp[i - 1][j] + 1;
 
                // Update state after keeping str[i]
                if (j != 0)
                    dp[i][j]
                        = min(dp[i][j], dp[i - 1][j - 1]);
            }
 
            // If str[i] is not equal to X[j]
            else {
 
                dp[i][j] = dp[i - 1][j];
            }
        }
    }
 
    // Print the minimum number
    // of characters removals
    cout << dp[N - 1][M - 1];
}
 
// Driver Code
int main()
{
    // Input
    string str = "btagd";
    string X = "bad";
 
    // Function call to get minimum
    // number of character removals
    printMinimumRemovals(str, X);
 
    return 0;
}
Java



// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
class GFG {
 
  // Function to print the minimum number of
  // character removals required to remove X
  // as a subsequence from the string str
  static void printMinimumRemovals(String str, String X)
  {
 
    // Length of the string str
    int N = str.length();
 
    // Length of the string X
    int M = X.length();
 
    // Stores the dp states
    int dp[][] = new int[N][M];
 
    // Fill first row of dp[][]
    for (int j = 0; j < M; j++) {
 
      // If X[j] matches with str[0]
      if (str.charAt(0) == X.charAt(j)) {
 
        dp[0][j] = 1;
      }
    }
 
    for (int i = 1; i < N; i++) {
 
      for (int j = 0; j < M; j++) {
 
        // If str[i] is equal to X[j]
        if (str.charAt(i) == X.charAt(j)) {
 
          // Update state after removing str[i[
          dp[i][j] = dp[i - 1][j] + 1;
 
          // Update state after keeping str[i]
          if (j != 0)
            dp[i][j] = Math.min(
            dp[i][j], dp[i - 1][j - 1]);
        }
 
        // If str[i] is not equal to X[j]
        else {
 
          dp[i][j] = dp[i - 1][j];
        }
      }
    }
 
    // Print the minimum number
    // of characters removals
    System.out.println(dp[N - 1][M - 1]);
  }
 
  // Driver code
  public static void main(String[] args)
  {
    // Input
    String str = "btagd";
    String X = "bad";
 
    // Function call to get minimum
    // number of character removals
    printMinimumRemovals(str, X);
  }
}
 
// This code is contributed by Kingash.
Python3



# Python 3 implementation of
# the above approach
 
# Function to print the minimum number of
# character removals required to remove X
# as a subsequence from the string str
def printMinimumRemovals(s, X):
 
    # Length of the string str
    N = len(s)
 
    # Length of the string X
    M = len(X)
 
    # Stores the dp states
    dp = [[0 for x in range(M)] for y in range(N)]
 
    # Fill first row of dp[][]
    for j in range(M):
       
        # If X[j] matches with str[0]
        if (s[0] == X[j]):
            dp[0][j] = 1
 
    for i in range(1, N):
        for j in range(M):
           
            # If s[i] is equal to X[j]
            if (s[i] == X[j]):
 
                # Update state after removing str[i[
                dp[i][j] = dp[i - 1][j] + 1
 
                # Update state after keeping str[i]
                if (j != 0):
                    dp[i][j] = min(dp[i][j], dp[i - 1][j - 1])
 
            # If str[i] is not equal to X[j]
            else:
                dp[i][j] = dp[i - 1][j]
 
    # Print the minimum number
    # of characters removals
    print(dp[N - 1][M - 1])
 
# Driver Code
if __name__ == "__main__":
 
    # Input
    s = "btagd"
    X = "bad"
 
    # Function call to get minimum
    # number of character removals
    printMinimumRemovals(s, X)
 
    # This code is contributed by ukasp.
C#



// C# program for above approach
using System;
public class GFG
{
 
  // Function to print the minimum number of
  // character removals required to remove X
  // as a subsequence from the string str
  static void printMinimumRemovals(string str, string X)
  {
 
    // Length of the string str
    int N = str.Length;
 
    // Length of the string X
    int M = X.Length;
 
    // Stores the dp states
    int[,] dp = new int[N, M];
 
    // Fill first row of dp[][]
    for (int j = 0; j < M; j++) {
 
      // If X[j] matches with str[0]
      if (str[0] == X[j]) {
 
        dp[0, j] = 1;
      }
    }
 
    for (int i = 1; i < N; i++) {
 
      for (int j = 0; j < M; j++) {
 
        // If str[i] is equal to X[j]
        if (str[i] == X[j]) {
 
          // Update state after removing str[i[
          dp[i, j] = dp[i - 1, j] + 1;
 
          // Update state after keeping str[i]
          if (j != 0)
            dp[i, j] = Math.Min(
            dp[i, j], dp[i - 1, j - 1]);
        }
 
        // If str[i] is not equal to X[j]
        else {
 
          dp[i, j] = dp[i - 1, j];
        }
      }
    }
 
    // Print the minimum number
    // of characters removals
    Console.WriteLine(dp[N - 1, M - 1]);
  }
 
// Driver code
public static void Main(String[] args)
{
   
    // Input
    string str = "btagd";
    string X = "bad";
 
    // Function call to get minimum
    // number of character removals
    printMinimumRemovals(str, X);
}
}
 
// This code is contributed by sanjoy_62.
Javascript



<script>
 
// Javascript program for the above approach
 
// Function to print the minimum number of
// character removals required to remove X
// as a subsequence from the string str
function printMinimumRemovals(str,X)
{
    // Length of the string str
    let N = str.length;
  
    // Length of the string X
    let M = X.length;
  
    // Stores the dp states
    let dp = new Array(N);
    for(let i=0;i<N;i++)
    {
        dp[i]=new Array(M);
        for(let j=0;j<M;j++)
        {
            dp[i][j]=0;
        }
         
    }
  
    // Fill first row of dp[][]
    for (let j = 0; j < M; j++) {
  
      // If X[j] matches with str[0]
      if (str[0] == X[j]) {
  
        dp[0][j] = 1;
      }
    }
  
    for (let i = 1; i < N; i++) {
  
      for (let j = 0; j < M; j++) {
  
        // If str[i] is equal to X[j]
        if (str[i] == X[j]) {
  
          // Update state after removing str[i[
          dp[i][j] = dp[i - 1][j] + 1;
  
          // Update state after keeping str[i]
          if (j != 0)
            dp[i][j] = Math.min(
            dp[i][j], dp[i - 1][j - 1]);
        }
  
        // If str[i] is not equal to X[j]
        else {
  
          dp[i][j] = dp[i - 1][j];
        }
      }
    }
  
    // Print the minimum number
    // of characters removals
    document.write(dp[N - 1][M - 1]);
}
 
 // Driver code
let str = "btagd";
let X = "bad";
// Function call to get minimum
// number of character removals
printMinimumRemovals(str, X);
 
 
// This code is contributed by avanitrachhadiya2155
</script>
Output: 
1
 
Time Complexity: O(N * M)
Auxiliary Space: O(N * M)
 

My Personal Notes
arrow_drop_up
Previous
ZS Business Technology Solution Associate (BTA) Interview Experience | On-Campus Hiring
Next

BNY Mellon Interview Experience for Summer Internship (Off-Campus)
Recommended Articles
Page :
Maximum number of removals of given subsequence from a string
27, Dec 18
Minimize cost of removals required to make all remaining characters of the string unique
13, Jan 21
Minimize elements to be added to a given array such that it contains another given array as its subsequence
10, Sep 20
Minimize elements to be added to a given array such that it contains another given array as its subsequence | Set 2
12, Oct 20
Minimum number of removals required such that no subsequence of length 2 occurs more than once
18, Jun 21
Rearrange digits of a number to remove any subsequence of another given number
22, Dec 20
Minimum removals required such that given string consists only of a pair of alternating characters
16, Mar 21
Minimize partitions in given string to get another string
17, Jan 22
Rearrange a string S1 such that another given string S2 is not its subsequence
14, Feb 21
Length of smallest substring of a given string which contains another string as subsequence
06, Oct 20
Minimum removals required to make a given array Bitonic
04, Dec 20
Minimum removals required to convert given array to a Mountain Array
10, Dec 20
Minimum removals required to place all 0s before 1s in a Binary String
02, Mar 21
Minimum removals to make a string concatenation of a substring of 0s followed by a substring of 1s
14, Dec 20
Minimum substring removals required to make all remaining characters of a string same
03, Jan 21
Minimum removals required such that a string can be rearranged to form a palindrome
24, Feb 21
Count minimum substring removals required to reduce string to a single distinct character
07, Dec 20
Minimize length of prefix of string S containing all characters of another string T
28, Jul 20
Minimize a string by removing all occurrences of another string
16, Dec 20
Minimize length of a string by removing occurrences of another string from it as a substring
19, Jan 21
Longest Common Subsequence (LCS) by repeatedly swapping characters of a string with characters of another string
22, Mar 21
Check if a string is a subsequence of another string ( using Stacks )
03, May 21
Find the longest subsequence of a string that is a substring of another string
17, Jun 21
Find length of longest subsequence of one string which is substring of another string
09, Jul 17
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Kingash
@Kingash
Vote for difficulty
Current difficulty :
Expert





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!