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

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 to 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.

Example 2:

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

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)

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.

Output

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

Time complexity: O(m * n)
This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.