Open In App
Related Articles

Minimum number of deletions and insertions to transform one string into another

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Given two strings ‘str1’ and ‘str2’ of size m and n respectively. The task is to remove/delete and insert the minimum number of characters from/in str1 to transform it into str2. It could be possible that the same character needs to be removed/deleted from one point of str1 and inserted at some another point.

Example 1: 

Input : 
str1 = "heap", str2 = "pea"
Output :
Minimum Deletion = 2 and
Minimum Insertion = 1
Explanation:
p and h deleted from heap
Then, p is inserted at the beginning
One thing to note, though p was required yet
it was removed/deleted first from its position and
then it is inserted to some other position.
Thus, p contributes one to the deletion_count
and one to the insertion_count.

Pictorial Representation of pea

Example 2: 

Input : 
str1 = "geeksforgeeks", str2 = "geeks"
Output :
Minimum Deletion = 8
Minimum Insertion = 0

Pictorial Representation of geeksforgeeks

Simple Approach:
A simple approach is to consider all subsequences of str1 and for each subsequence calculate minimum deletions and insertions so as to transform it into str2. A very complex method and the time complexity of this solution is exponential.

Efficient Approach:
An efficient approach uses the concept of finding the length of the longest common subsequence of the given two sequences.

Algorithm: 

  • str1 and str2 be the given strings.
  • m and n be their lengths respectively.
  • len be the length of the longest common subsequence of str1 and str2
  • minimum number of deletions minDel = m – len (as we only need to delete from str1 because we are reducing it to str2)
  • minimum number of Insertions minInsert = n – len (as we are inserting x in str1 , x is a number of characters in str2 which are not taking part in the string which is longest common subsequence )

Below is the implementation of the above code:

C++

// Dynamic Programming C++ implementation to find
// minimum number of deletions and insertions
#include <bits/stdc++.h>
 
using namespace std;
 
// Returns length of longest common subsequence
// for str1[0..m-1], str2[0..n-1]
int lcs(string str1, string str2, int m, int n)
{
    int L[m + 1][n + 1];
    int i, j;
 
    // Following steps build L[m+1][n+1] in bottom
    // up fashion. Note that L[i][j] contains
    // length of LCS of str1[0..i-1] and str2[0..j-1]
    for (i = 0; i <= m; i++) {
        for (j = 0; j <= n; j++) {
            if (i == 0 || j == 0)
                L[i][j] = 0;
 
            else if (str1.at(i - 1) == str2.at(j - 1))
                L[i][j] = L[i - 1][j - 1] + 1;
 
            else
                L[i][j] = max(L[i - 1][j], L[i][j - 1]);
        }
    }
 
    // L[m][n] contains length of LCS
    // for X[0..n-1] and Y[0..m-1]
    return L[m][n];
}
 
// function to find minimum number
// of deletions and insertions
void printMinDelAndInsert(string str1, string str2)
{
    int m = str1.size();
    int n = str2.size();
 
    int len = lcs(str1, str2, m, n);
 
    cout << "Minimum number of deletions = " << (m - len)
         << endl;
 
    cout << "Minimum number of insertions = " << (n - len)
         << endl;
}
 
// Driver Code
int main()
{
    string str1 = "heap";
    string str2 = "pea";
   
      // Function Call
    printMinDelAndInsert(str1, str2);
    return 0;
}

                    

Java

// Dynamic Programming Java implementation
// to find minimum number of deletions and
// insertions
import java.io.*;
 
class GFG {
 
    // Returns length of length common
    // subsequence for str1[0..m-1],
    // str2[0..n-1]
    static int lcs(String str1, String str2, int m, int n)
    {
        int L[][] = new int[m + 1][n + 1];
        int i, j;
 
        // Following steps build L[m+1][n+1] in
        // bottom up fashion. Note that L[i][j]
        // contains length of LCS of str1[0..i-1]
        // and str2[0..j-1]
        for (i = 0; i <= m; i++) {
            for (j = 0; j <= n; j++) {
                if (i == 0 || j == 0)
                    L[i][j] = 0;
 
                else if (str1.charAt(i - 1)
                         == str2.charAt(j - 1))
                    L[i][j] = L[i - 1][j - 1] + 1;
 
                else
                    L[i][j] = Math.max(L[i - 1][j],
                                       L[i][j - 1]);
            }
        }
 
        // L[m][n] contains length of LCS
        // for X[0..n-1] and Y[0..m-1]
        return L[m][n];
    }
 
    // function to find minimum number
    // of deletions and insertions
    static void printMinDelAndInsert(String str1,
                                     String str2)
    {
        int m = str1.length();
        int n = str2.length();
 
        int len = lcs(str1, str2, m, n);
 
        System.out.println("Minimum number of "
                           + "deletions = ");
        System.out.println(m - len);
 
        System.out.println("Minimum number of "
                           + "insertions = ");
        System.out.println(n - len);
    }
 
    // Driver code
    public static void main(String[] args)
    {
        String str1 = new String("heap");
        String str2 = new String("pea");
       
          // Function Call
        printMinDelAndInsert(str1, str2);
    }
}
// This code is contributed by Prerna Saini

                    

Python3

# Dynamic Programming Python3
# implementation to find minimum
# number of deletions and insertions
 
# Returns length of length
# common subsequence for
# str1[0..m-1], str2[0..n-1]
 
 
def lcs(str1, str2, m, n):
 
    L = [[0 for i in range(n + 1)]
         for i in range(m + 1)]
 
    # Following steps build L[m+1][n+1]
    # in bottom up fashion. Note that
    # L[i][j] contains length of LCS
    # of str1[0..i-1] and str2[0..j-1]
    for i in range(m + 1):
        for j in range(n + 1):
            if (i == 0 or j == 0):
                L[i][j] = 0
            elif(str1[i - 1] == str2[j - 1]):
                L[i][j] = L[i - 1][j - 1] + 1
            else:
                L[i][j] = max(L[i - 1][j],
                              L[i][j - 1])
 
    # L[m][n] contains length of LCS
    # for X[0..n-1] and Y[0..m-1]
    return L[m][n]
 
# function to find minimum number
# of deletions and insertions
 
 
def printMinDelAndInsert(str1, str2):
    m = len(str1)
    n = len(str2)
    leng = lcs(str1, str2, m, n)
    print("Minimum number of deletions = ",
          m - leng, sep=' ')
    print("Minimum number of insertions = ",
          n - leng, sep=' ')
 
 
# Driver Code
str1 = "heap"
str2 = "pea"
 
# Function Call
printMinDelAndInsert(str1, str2)
 
# This code is contributed
# by sahilshelangia

                    

C#

// Dynamic Programming C# implementation
// to find minimum number of deletions and
// insertions
using System;
 
class GFG {
 
    // Returns length of length common
    // subsequence for str1[0..m-1],
    // str2[0..n-1]
    static int lcs(string str1, string str2, int m, int n)
    {
        int[, ] L = new int[m + 1, n + 1];
        int i, j;
 
        // Following steps build L[m+1][n+1] in
        // bottom up fashion. Note that L[i][j]
        // contains length of LCS of str1[0..i-1]
        // and str2[0..j-1]
        for (i = 0; i <= m; i++) {
            for (j = 0; j <= n; j++) {
                if (i == 0 || j == 0)
                    L[i, j] = 0;
 
                else if (str1[i - 1] == str2[j - 1])
                    L[i, j] = L[i - 1, j - 1] + 1;
 
                else
                    L[i, j] = Math.Max(L[i - 1, j],
                                       L[i, j - 1]);
            }
        }
 
        // L[m][n] contains length of LCS
        // for X[0..n-1] and Y[0..m-1]
        return L[m, n];
    }
 
    // function to find minimum number
    // of deletions and insertions
    static void printMinDelAndInsert(string str1,
                                     string str2)
    {
        int m = str1.Length;
        int n = str2.Length;
 
        int len = lcs(str1, str2, m, n);
 
        Console.Write("Minimum number of "
                      + "deletions = ");
        Console.WriteLine(m - len);
 
        Console.Write("Minimum number of "
                      + "insertions = ");
        Console.Write(n - len);
    }
 
    // Driver code
    public static void Main()
    {
        string str1 = new string("heap");
        string str2 = new string("pea");
       
          // Function Call
        printMinDelAndInsert(str1, str2);
    }
}
 
// This code is contributed by nitin mittal.

                    

Javascript

<script>
    // Dynamic Programming Javascript implementation
    // to find minimum number of deletions and
    // insertions
 
    // Returns length of length common
    // subsequence for str1[0..m-1],
    // str2[0..n-1]
    function lcs(str1, str2, m, n)
    {
        let L = new Array(m + 1);
             
        let i, j;
         
        for (i = 0; i <= m; i++)
        {
            L[i] = new Array(n + 1);
            for (j = 0; j <= n; j++)
            {
                L[i][j] = 0;
            }
        }
  
        // Following steps build L[m+1][n+1] in
        // bottom up fashion. Note that L[i][j]
        // contains length of LCS of str1[0..i-1]
        // and str2[0..j-1]
        for (i = 0; i <= m; i++) {
            for (j = 0; j <= n; j++) {
                if (i == 0 || j == 0)
                    L[i][j] = 0;
  
                else if (str1[i - 1]
                         == str2[j - 1])
                    L[i][j] = L[i - 1][j - 1] + 1;
  
                else
                    L[i][j] = Math.max(L[i - 1][j],
                                       L[i][j - 1]);
            }
        }
  
        // L[m][n] contains length of LCS
        // for X[0..n-1] and Y[0..m-1]
        return L[m][n];
    }
  
    // function to find minimum number
    // of deletions and insertions
    function printMinDelAndInsert(str1, str2)
    {
        let m = str1.length;
        let n = str2.length;
  
        let len = lcs(str1, str2, m, n);
  
        document.write("Minimum number of "
                           + "deletions = ");
        document.write((m - len) + "</br>");
  
        document.write("Minimum number of "
                           + "insertions = ");
        document.write((n - len) + "</br>");
    }
     
    let str1 = "heap";
    let str2 = "pea";
 
    // Function Call
    printMinDelAndInsert(str1, str2);
     
    // This code is contributed by rameshtravel07.
</script>

                    

Output
Minimum number of deletions = 2
Minimum number of insertions = 1





Time Complexity: O(m * n)
Auxiliary Space: O(m * n)

Method 2: Top-down approach using memoization

This method also uses the idea of finding the length of the longest common subsequence of the given two sequences. But this approach is using a top-down approach using memoization.

C++

// Dynamic Programming C++ implementation to find
// minimum number of deletions and insertions
// using memoization technique
#include <bits/stdc++.h>
 
using namespace std;
 
int dp[1001][1001];
 
// Returns length of longest common subsequence
int lcs(string& s1, string& s2, int i, int j)
{
    if (i == 0 || j == 0) {
        return 0;
    }
    if (dp[i][j] != -1) {
        return dp[i][j];
    }
    if (s1[i - 1] == s2[j - 1]) {
        return dp[i][j] = 1 + lcs(s1, s2, i - 1, j - 1);
    }
    else {
        return dp[i][j] = max(lcs(s1, s2, i, j - 1),
                              lcs(s1, s2, i - 1, j));
    }
}
 
// function to find minimum number
// of deletions and insertions
void printMinDelAndInsert(string str1, string str2)
{
    int m = str1.size();
    int n = str2.size();
 
    dp[m][n];
 
    //    initialising dp array as -1
    memset(dp, -1, sizeof(dp));
 
    int len = lcs(str1, str2, m, n);
 
    cout << "Minimum number of deletions = " << (m - len)
         << endl;
 
    cout << "Minimum number of insertions = " << (n - len)
         << endl;
}
 
// driver code
int main()
{
    string str1 = "heap";
    string str2 = "pea";
 
    // Function Call
    printMinDelAndInsert(str1, str2);
 
    return 0;
}
 
// This code is contributed by Arun Bang.

                    

Java

// Dynamic Programming Java implementation
// to find minimum number of deletions and
// insertions
import java.io.*;
import java.util.Arrays;
class GFG {
    public static int dp[][]=new int[1001][1001];
   
    static int lcs(String str1, String str2, int i, int j)
    {
         if (i == 0 || j == 0) {
                return 0;
        }
        if (dp[i][j] != -1) {
            return dp[i][j];
        }
        if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
            return dp[i][j] = 1 + lcs(str1, str2, i - 1, j - 1);
            }
            else {
            return dp[i][j] = Math.max(lcs(str1, str2, i, j - 1),
                              lcs(str1, str2, i - 1, j));
        }
         
    }
 
    // function to find minimum number
    // of deletions and insertions
    static void printMinDelAndInsert(String str1,
                                    String str2)
    {
        int m = str1.length();
        int n = str2.length();
 
        int len = lcs(str1, str2, m, n);
 
        System.out.println("Minimum number of "
                        + "deletions = "+(m - len));
         
 
        System.out.println("Minimum number of "
                        + "insertions = "+(n - len));
     
    }
 
    // Driver code
    public static void main(String[] args)
    {
        String str1 = new String("heap");
        String str2 = new String("pea");
        for(int i=0;i<1001;i++){
         Arrays.fill(dp[i],-1);
        }
       
        // Function Call
        printMinDelAndInsert(str1, str2);
    }
}
 
// This code is contributed by nikitamehrotra99.

                    

Python3

#  Dynamic Programming C++ implementation to find
#  minimum number of deletions and insertions
#  using memoization technique
dp = [[-1 for i in range(1001)]for j in range(1001)]
 
#  Returns length of longest common subsequence
def lcs(s1, s2, i, j):
    if i == 0 or j == 0:
        return 0
    if dp[i][j] != -1:
        return dp[i][j]
 
    if s1[i - 1] == s2[j - 1]:
        dp[i][j] = 1 + lcs(s1, s2, i-1, j-1)
        return dp[i][j]
    else:
        dp[i][j] = max(lcs(s1, s2, i, j-1), lcs(s1, s2, i-1, j))
        return dp[i][j]
 
#  function to find minimum number
#  of deletions and insertions
def printMinDelAndInsert(str1, str2):
    m = len(str1)
    n = len(str2)
 
    #     initialising dp array as -1
    dp = [[-1 for i in range(n)]for j in range(m)]
    length = lcs(str1, str2, m, n)
    print("Minimum number of deletions = ", (m - length))
    print("Minimum number of insertions = ", (n - length))
 
#  driver code
if __name__ == "__main__":
    str1 = "heap"
    str2 = "pea"
 
    # Function Call
    printMinDelAndInsert(str1, str2)
 
#  This code is contributed by Vivek Maddeshiya

                    

C#

using System;
 
namespace MinDelAndInsert {
  class Program {
    static int[, ] dp = new int[1001, 1001];
 
    // Returns length of longest common subsequence
    static int lcs(string s1, string s2, int i, int j)
    {
      if (i == 0 || j == 0) {
        return 0;
      }
      if (dp[i, j] != -1) {
        return dp[i, j];
      }
      if (s1[i - 1] == s2[j - 1]) {
        return dp[i, j] = 1 + lcs(s1, s2, i - 1, j - 1);
      }
      else {
        return dp[i, j]
          = Math.Max(lcs(s1, s2, i, j - 1),
                     lcs(s1, s2, i - 1, j));
      }
    }
 
    // function to find minimum number
    // of deletions and insertions
    static void PrintMinDelAndInsert(string str1,
                                     string str2)
    {
      int m = str1.Length;
      int n = str2.Length;
 
      // Initializing dp array as -1
      for (int i = 0; i <= m; i++) {
        for (int j = 0; j <= n; j++) {
          dp[i, j] = -1;
        }
      }
 
      int len = lcs(str1, str2, m, n);
 
      Console.WriteLine("Minimum number of deletions = "
                        + (m - len));
      Console.WriteLine("Minimum number of insertions = "
                        + (n - len));
    }
 
    static void Main(string[] args)
    {
      string str1 = "heap";
      string str2 = "pea";
 
      // Function Call
      PrintMinDelAndInsert(str1, str2);
    }
  }
}
 
// This code is contributed by divyansh2212

                    

Javascript

// Dynamic Programming JavaScript implementation to find
// minimum number of deletions and insertions
// using memoization technique
const dp = new Array(1001).fill(-1).map(() => new Array(1001).fill(-1));
 
// Returns length of longest common subsequence
const lcs = (s1, s2, i, j) => {
if (i === 0 || j === 0) {
return 0;
}
if (dp[i][j] !== -1) {
return dp[i][j];
}
if (s1[i - 1] === s2[j - 1]) {
dp[i][j] = 1 + lcs(s1, s2, i - 1, j - 1);
return dp[i][j];
}
else {
dp[i][j] = Math.max(lcs(s1, s2, i, j - 1), lcs(s1, s2, i - 1, j));
return dp[i][j];
}
};
 
// function to find minimum number
// of deletions and insertions
const printMinDelAndInsert = (str1, str2) => {
let m = str1.length;
let n = str2.length;
 
//    initialising dp array as -1
 
let len = lcs(str1, str2, m, n);
 
console.log(`Minimum number of deletions = ${m - len}`);
 
console.log(`Minimum number of insertions = ${n - len}`);
}
 
// driver code
 
let str1 = "heap";
let str2 = "pea";
 
// Function Call
printMinDelAndInsert(str1, str2);
 
// This code is contributed by lokeshpotta20.

                    

Output
Minimum number of deletions = 2
Minimum number of insertions = 1





Time Complexity: O(m * n)
Auxiliary Space: O(m * n)
 

Efficient approach: Space optimization

In previous approach the current value dp[i][j] is only depend upon the current and previous row values of DP. So to optimize the space complexity we use a single 1D array to store the computations.

Implementation steps:

  • Create a 1D vector dp of size n+1.
  • Set a base case by initializing the values of DP .
  • Now iterate over subproblems by the help of nested loop and get the current value from previous computations.
  • Now initialize a variable prev used to store the previous computations and a variable temp to store the current computation.
  • After every iteration assign the value of prev to temp for further iteration.
  • At last return and print the final answer stored in dp[0].

Implementation: 

C++

#include <algorithm>
#include <iostream>
#include <vector>
 
using namespace std;
 
int lcs(string str1, string str2)
{
    int m = str1.size();
    int n = str2.size();
 
    // Single vector to store the previous row
    vector<int> dp(n + 1, 0);
 
    for (int i = 1; i <= m; i++) {
 
        // Store the value of dp[j-1] from the previous
        // iteration
        int prev = 0;
 
        for (int j = 1; j <= n; j++) {
            // Store the current value of dp[j] before
            // modifying it
            int temp = dp[j];
 
            if (str1[i - 1] == str2[j - 1])
                dp[j] = prev + 1;
            else
                dp[j] = max(dp[j], dp[j - 1]);
 
            // Update prev for the next iteration
            prev = temp;
        }
    }
 
    return dp[n];
    // Return the length of the LCS
}
 
void printMinDelAndInsert(string str1, string str2)
{
    int len = lcs(str1, str2);
 
    int m = str1.size();
    int n = str2.size();
 
    cout << "Minimum number of deletions = " << (m - len)
         << endl;
    cout << "Minimum number of insertions = " << (n - len)
         << endl;
}
 
// Driver Code
int main()
{
    string str1 = "heap";
    string str2 = "pea";
 
    printMinDelAndInsert(str1, str2);
 
    return 0;
}
 
// -- by bhardwajji

                    

Java

import java.util.*;
import java.io.*;
 
public class GFG {
 
    public static int lcs(String str1, String str2) {
        int m = str1.length();
        int n = str2.length();
 
        // Single array to store the previous row
        int[] dp = new int[n + 1];
 
        for (int i = 1; i <= m; i++) {
 
            // Store the value of dp[j-1] from the previous iteration
            int prev = 0;
 
            for (int j = 1; j <= n; j++) {
                // Store the current value of dp[j] before modifying it
                int temp = dp[j];
 
                if (str1.charAt(i - 1) == str2.charAt(j - 1))
                    dp[j] = prev + 1;
                else
                    dp[j] = Math.max(dp[j], dp[j - 1]);
 
                // Update prev for the next iteration
                prev = temp;
            }
        }
 
        return dp[n];
        // Return the length of the LCS
    }
 
    public static void printMinDelAndInsert(String str1, String str2) {
        int len = lcs(str1, str2);
 
        int m = str1.length();
        int n = str2.length();
 
        System.out.println("Minimum number of deletions = " + (m - len));
        System.out.println("Minimum number of insertions = " + (n - len));
    }
    // Driver Code
    public static void main(String[] args) {
        String str1 = "heap";
        String str2 = "pea";
 
        printMinDelAndInsert(str1, str2);
    }
}
// by srihari2222

                    

Python3

def lcs(str1, str2):
    m = len(str1)
    n = len(str2)
 
    # Create a matrix to store the LCS lengths
    dp = [[0] * (n + 1) for _ in range(m + 1)]
 
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if str1[i - 1] == str2[j - 1]:
                # If characters match, extend LCS by 1
                dp[i][j] = dp[i - 1][j - 1] + 1
            else:
                # Otherwise, take the maximum LCS length from the previous row or column
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
 
    return dp[m][n]
 
def print_min_del_and_insert(str1, str2):
    len_lcs = lcs(str1, str2)  # Calculate the length of the Longest Common Subsequence
    m = len(str1)
    n = len(str2)
 
    # Calculate the minimum number of deletions and insertions
    min_deletions = m - len_lcs
    min_insertions = n - len_lcs
 
    print("Minimum number of deletions =", min_deletions)
    print("Minimum number of insertions =", min_insertions)
 
# Driver Code
if __name__ == "__main__":
    str1 = "heap"
    str2 = "pea"
 
    print_min_del_and_insert(str1, str2)

                    

C#

using System;
 
class Program
{
    static int LCS(string str1, string str2)
    {
        int m = str1.Length;
        int n = str2.Length;
 
        // Single array to store the previous row
        int[] dp = new int[n + 1];
 
        for (int i = 1; i <= m; i++)
        {
            // Store the value of dp[j-1] from the previous iteration
            int prev = 0;
 
            for (int j = 1; j <= n; j++)
            {
                // Store the current value of dp[j] before modifying it
                int temp = dp[j];
 
                if (str1[i - 1] == str2[j - 1])
                {
                    dp[j] = prev + 1;
                }
                else
                {
                    dp[j] = Math.Max(dp[j], dp[j - 1]);
                }
 
                // Update prev for the next iteration
                prev = temp;
            }
        }
 
        return dp[n];
        // Return the length of the LCS
    }
 
    static void PrintMinDelAndInsert(string str1, string str2)
    {
        int len = LCS(str1, str2);
 
        int m = str1.Length;
        int n = str2.Length;
 
        Console.WriteLine("Minimum number of deletions = " + (m - len));
        Console.WriteLine("Minimum number of insertions = " + (n - len));
    }
 
    static void Main()
    {
        string str1 = "heap";
        string str2 = "pea";
 
        PrintMinDelAndInsert(str1, str2);
    }
}

                    

Javascript

function lcs(str1, str2) {
    const m = str1.length;
    const n = str2.length;
 
    // Single array to store the previous row
    const dp = new Array(n + 1).fill(0);
 
    for (let i = 1; i <= m; i++) {
 
        // Store the value of dp[j-1] from the previous iteration
        let prev = 0;
 
        for (let j = 1; j <= n; j++) {
            // Store the current value of dp[j] before modifying it
            let temp = dp[j];
 
            if (str1[i - 1] === str2[j - 1]) {
                dp[j] = prev + 1;
            } else {
                dp[j] = Math.max(dp[j], dp[j - 1]);
            }
 
            // Update prev for the next iteration
            prev = temp;
        }
    }
 
    return dp[n];
    // Return the length of the LCS
}
 
function printMinDelAndInsert(str1, str2) {
    const len = lcs(str1, str2);
 
    const m = str1.length;
    const n = str2.length;
 
    console.log("Minimum number of deletions = " + (m - len));
    console.log("Minimum number of insertions = " + (n - len));
}
 
// Driver Code
const str1 = "heap";
const str2 = "pea";
 
printMinDelAndInsert(str1, str2);
// --> by srihari2222

                    

Output
Minimum number of deletions = 2
Minimum number of insertions = 1






Time Complexity: O(m * n)
Auxiliary Space: O(n)

This article is contributed by Ayush Jauhari.



Last Updated : 11 Nov, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads