Skip to content
Related Articles

Related Articles

Length of longest substring to be deleted to make a string equal to another string
  • Last Updated : 18 Sep, 2020

Given two strings str1 and str2, where str2 is a subsequence of str1, the task is to find the length of the longest substring of str1 which when removed, makes the strings str2 and str1 equal.

Examples:

Input: str1 = “programmingbloods”, str2 = “ibloods”
Output: 8
Explanation:
Substrings to be removed from str1 are [“programm”, “ng”]. Therefore, the length of the longest deleted substring is 8.

Input: str1=“GeeksforGeeks”, str2=“forks”
Output: 5

Naive Approach: The simplest approach is to generate all possible substrings of str1 and for each substring, remove it from str1 and check if the resulting string becomes equal to str2 or not. Print the length of longest such substrings.



Time Complexity: O(2N)
Auxiliary Space: O(N)

Efficient Approach: To optimize the above approach, the idea is to find the occurrence of str2 in str1. Traverse both strings from left to right and check if both characters are equal or not. If found to be true, proceed to the right in both strings. Otherwise, proceed to the right only in str2. Similarly, to find the last occurrence of str2 in str1, traverse both strings from right to left and proceed similarly. Follow the steps below to solve the problem:

  1. Initialize a variable, res=0 to store the length of the longest deleted substring.
  2. Create an array, pos[] to store the position of the first occurrence of str2 in str1.
  3. Traverse both strings from left to right and store the position of the first occurrence of str2 by deleting some characters of str1.
  4. Initialize a variable, lastPos = length(str1)-1 to store the position of the current character in the last occurrence of str2 by deleting some characters of str1.
  5. Traverse both strings from right to left and check if both characters match then find the position of the current character of str2 in pos[] else continue.
  6. If res > (lastPos – pos[i-1]-1) then update the res = lastPos – pos[i-1]-1.
  7. Finally, return the res.

Below is the implementation of the above approach:

C++




// C++ Program to implement
// the above approach
  
#include <bits/stdc++.h>
using namespace std;
  
// Function to print the length
// of longest substring to be deleted
int longDelSub(string str1, string str2)
{
    // Stores the length of string
    int N = str1.size();
    int M = str2.size();
  
    // Store the position of
    // previous matched
    // character of str1
    int prev_pos = 0;
  
    // Store the position of first
    // occurrence of str2 in str1
    int pos[M];
  
    // Find the position of the
    // first occurrence of str2
    for (int i = 0; i < M; i++) {
  
        // Store the index of str1
        int index = prev_pos;
  
        // If both characters not matched
        while (index < N
               && str1[index] != str2[i]) {
            index++;
        }
  
        pos[i] = index;
        prev_pos = index + 1;
    }
  
    // Store the length of the
    // longest deleted substring
    int res = N - prev_pos;
  
    prev_pos = N - 1;
  
    // Store the position of last
    // occurrence of str2 in str1
    for (int i = M - 1; i >= 0; i--) {
        int index = prev_pos;
  
        // If both characters not matched
        while (index >= 0
               && str1[index] != str2[i]) {
            index--;
        }
  
        // Update res
        if (i != 0) {
            res = max(
                res,
                index - pos[i - 1] - 1);
        }
  
        prev_pos = index - 1;
    }
  
    // Update res.
    res = max(res, prev_pos + 1);
  
    return res;
}
  
// Driver Code
int main()
{
    // Given string
    string str1 = "GeeksforGeeks";
    string str2 = "forks";
  
    // Function Call
    cout << longDelSub(str1, str2);
    return 0;
}
Java



// Java program to implement 
// the above approach 
import java.io.*;
  
class GFG{
  
// Function to print the length
// of longest substring to be deleted
static int longDelSub(String str1, String str2)
{
      
    // Stores the length of string
    int N = str1.length();
    int M = str2.length();
  
    // Store the position of
    // previous matched
    // character of str1
    int prev_pos = 0;
  
    // Store the position of first
    // occurrence of str2 in str1
    int pos[] = new int[M];
  
    // Find the position of the
    // first occurrence of str2
    for(int i = 0; i < M; i++)
    {
          
        // Store the index of str1
        int index = prev_pos;
  
        // If both characters not matched
        while (index < N && 
               str1.charAt(index) != 
               str2.charAt(i))
        {
            index++;
        }
  
        pos[i] = index;
        prev_pos = index + 1;
    }
  
    // Store the length of the
    // longest deleted substring
    int res = N - prev_pos;
  
    prev_pos = N - 1;
  
    // Store the position of last
    // occurrence of str2 in str1
    for(int i = M - 1; i >= 0; i--)
    {
        int index = prev_pos;
  
        // If both characters not matched
        while (index >= 0 && 
               str1.charAt(index) != 
               str2.charAt(i)) 
        {
            index--;
        }
  
        // Update res
        if (i != 0)
        {
            res = Math.max(res, 
                           index - 
                           pos[i - 1] - 1);
        }
        prev_pos = index - 1;
    }
  
    // Update res.
    res = Math.max(res, prev_pos + 1);
  
    return res;
}
  
// Driver Code
public static void main (String[] args)
{
      
    // Given string
    String str1 = "GeeksforGeeks";
    String str2 = "forks";
  
    // Function call
    System.out.print(longDelSub(str1, str2));
}
}
  
// This code is contributed by code_hunt
Python3



# Python3 program to implement 
# the above approach 
  
# Function to prthe length
# of longest substring to be deleted
def longDelSub(str1, str2):
      
    # Stores the length of string
    N = len(str1)
    M = len(str2)
  
    # Store the position of
    # previous matched
    # character of str1
    prev_pos = 0
  
    # Store the position of first
    # occurrence of str2 in str1
    pos = [0] * M
  
    # Find the position of the
    # first occurrence of str2
    for i in range(M):
  
        # Store the index of str1
        index = prev_pos
  
        # If both characters not matched
        while (index < N and 
          str1[index] != str2[i]):
            index += 1
          
        pos[i] = index
        prev_pos = index + 1
      
    # Store the length of the
    # longest deleted substring
    res = N - prev_pos
  
    prev_pos = N - 1
  
    # Store the position of last
    # occurrence of str2 in str1
    for i in range(M - 1, -1, -1):
        index = prev_pos
  
        # If both characters not matched
        while (index >= 0 and 
          str1[index] != str2[i]):
            index -= 1
          
        # Update res
        if (i != 0) :
            res = max(res, 
                      index - 
                      pos[i - 1] - 1)
          
        prev_pos = index - 1
      
    # Update res.
    res = max(res, prev_pos + 1)
  
    return res
  
# Driver Code
  
# Given string
str1 = "GeeksforGeeks"
str2 = "forks"
  
# Function call
print(longDelSub(str1, str2))
  
# This code is contributed by code_hunt
C#



// C# program to implement 
// the above approach 
using System;
  
class GFG{
      
// Function to print the length
// of longest substring to be deleted
static int longDelSub(string str1,
                      string str2)
{
      
    // Stores the length of string
    int N = str1.Length;
    int M = str2.Length;
  
    // Store the position of
    // previous matched
    // character of str1
    int prev_pos = 0;
  
    // Store the position of first
    // occurrence of str2 in str1
    int[] pos = new int[M];
  
    // Find the position of the
    // first occurrence of str2
    for(int i = 0; i < M; i++) 
    {
  
        // Store the index of str1
        int index = prev_pos;
  
        // If both characters not matched
        while (index < N && 
          str1[index] != str2[i])
        {
            index++;
        }
  
        pos[i] = index;
        prev_pos = index + 1;
    }
  
    // Store the length of the
    // longest deleted substring
    int res = N - prev_pos;
  
    prev_pos = N - 1;
  
    // Store the position of last
    // occurrence of str2 in str1
    for(int i = M - 1; i >= 0; i--)
    {
        int index = prev_pos;
  
        // If both characters not matched
        while (index >= 0 && 
          str1[index] != str2[i])
        {
            index--;
        }
  
        // Update res
        if (i != 0)
        {
            res = Math.Max(res, 
                           index - 
                           pos[i - 1] - 1);
        }
        prev_pos = index - 1;
    }
  
    // Update res.
    res = Math.Max(res, prev_pos + 1);
  
    return res;
}
  
// Driver code
public static void Main()
{
      
    // Given string
    string str1 = "GeeksforGeeks";
    string str2 = "forks";
  
    // Function call
    Console.Write(longDelSub(str1, str2));
}
}
  
// This code is contributed by code_hunt
Output:
5

Time Complexity: O(N + M)
Auxiliary Space: O(M)
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.
My Personal Notes
arrow_drop_up
first_page
Previous
Difference between LoRaWAN and NB-IoT
Next
last_page
Remove all duplicate adjacent characters from a string using Stack
Recommended Articles
Page :
Find length of longest subsequence of one string which is substring of another string
09, Jul 17
Minimum characters to be deleted from the beginning of two strings to make them equal
05, Jun 20
Minimum characters to be deleted from the end to make given two strings equal
05, Jun 20
Generate an N-length string having longest palindromic substring of length K
14, Dec 20
Length of the largest substring which have character with frequency greater than or equal to half of the substring
29, May 19
Count columns to be deleted to make each row sorted
20, Dec 18
Length of the longest substring with equal 1s and 0s
25, Oct 17
Length of smallest substring of a given string which contains another string as subsequence
06, Oct 20
Minimize length of a string by removing occurrences of another string from it as a substring
19, Jan 21
Minimum removals to make a string concatenation of a substring of 0s followed by a substring of 1s
14, Dec 20
Check whether two strings can be made equal by reversing substring of equal length from both strings
15, Jul 20
Minimum length of substring whose rotation generates a palindromic substring
21, May 20
Smallest prefix to be deleted such that remaining array can be rearranged to form a sorted array
22, Sep 20
Length of the longest substring that do not contain any palindrome
08, May 19
Length of the longest substring with no consecutive same letters
08, Apr 19
Find length of longest substring with at most K normal characters
26, Apr 20
Length of Longest Palindrome Substring
30, Sep 20
Length of the longest substring with every character appearing even number of times
01, Nov 20
Length of longest substring having all characters as K
16, Jul 19
Minimize count of 0s required to be removed to maximize length of longest substring of 1s
22, Jan 21
Length of the longest substring without repeating characters
02, Dec 11
Length of the longest valid substring
29, Sep 15
Longest Even Length Substring such that Sum of First and Second Half is same
19, Dec 14
Construct a string of length L such that each substring of length X has exactly Y distinct letters
30, Apr 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
rohitprasadswn
@rohitprasadswn
Vote for difficulty





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