The Wayback Machine - https://web.archive.org/web/20210417231506/https://www.geeksforgeeks.org/minimum-cost-make-two-strings-identical-deleting-digits/
Skip to content
Related Articles

Related Articles

Minimum cost to make two strings identical by deleting the digits
  • Difficulty Level : Medium
  • Last Updated : 22 May, 2019
GeeksforGeeks - Summer Carnival Banner

Given two strings X and Y consisting of only digits ‘0’ to ‘9’. Find minimum cost required to make the given two strings identical. Only operation allowed is to delete characters from any of the string. The cost of operation of deleting the digit ‘d’ is d units.

Input:  X = 3759, Y = 9350
Output: 23
Explanation
For making both string identical, delete
characters 3, 7, 5 from first string and
delete characters 3, 5, 0 from second 
string. Total cost of operation is
3 + 7 + 5 + 3 + 5 + 0 = 23

Input:  X = 3198, Y = 98
Output: 4

This problem is a variation of Longest Common Subsequence( LCS ) and this one. The idea is simple, instead of finding the length of longest common subsequence, find the maximum cost by adding identical characters from both the string.

Now to find the minimum cost, subtract the above result from total cost of both strings i.e.,

costX = Cost of removing all characters
        from string 'X'
CostY = Cost of removing all characters 
        from string 'Y'
cost_Id = Cost of removing identical characters
          from both strings

Minimum cost to make both string identical = 
                      costX + costY - cost_Id

Below is the implementation of above approach:

C++




/* C++ code to find minimum cost to make two strings
   identical */
#include <bits/stdc++.h>
using namespace std;
  
/* Function to returns cost of removing the identical
   characters in LCS for X[0..m-1], Y[0..n-1] */
int lcs(char* X, char* Y, int m, int n)
{
    int L[m + 1][n + 1];
  
    /* Following steps build L[m+1][n+1] in bottom
       up fashion. Note that L[i][j] contains cost
       of removing identical characters in LCS of
       X[0..i-1] and Y[0..j-1] */
    for (int i = 0; i <= m; ++i) {
        for (int j = 0; j <= n; j++) {
  
            if (i == 0 || j == 0)
                L[i][j] = 0;
  
            // If both characters are same, add both
            // of them
            else if (X[i - 1] == Y[j - 1])
                L[i][j] = L[i - 1][j - 1] + 
                          2 * (X[i - 1] - '0');
  
            // Otherwise find the maximum cost among them
            else
                L[i][j] = max(L[i - 1][j], L[i][j - 1]);
        }
    }
  
    return L[m][n];
}
  
// Returns cost of making X[] and Y[] identical
int findMinCost(char X[], char Y[])
{
    // Find LCS of X[] and Y[]
    int m = strlen(X), n = strlen(Y);
  
    // Initialize the cost variable
    int cost = 0;
  
    // Find cost of all characters in
    // both strings
    for (int i = 0; i < m; ++i)
        cost += X[i] - '0';
  
    for (int i = 0; i < n; ++i)
        cost += Y[i] - '0';
  
    return cost - lcs(X, Y, m, n);
}
  
/* Driver program to test above function */
int main()
{
    char X[] = "3759";
    char Y[] = "9350";
    cout << "Minimum Cost to make two strings "
         << "identical is = " << findMinCost(X, Y);
    return 0;
}
Java



// Java code to find minimum cost to 
// make two strings identical
import java.util.*;
import java.lang.*;
  
public class GfG{
      
/* Function to returns cost of removing the identical
characters in LCS for X[0..m-1], Y[0..n-1] */
static int lcs(char[] X, char[] Y, int m, int n)
{
    int[][] L=new int[m + 1][n + 1];
  
    /* Following steps build L[m+1][n+1] in 
    bottom up fashion. Note that L[i][j] contains 
    cost of removing identical characters in 
    LCS of X[0..i-1] and Y[0..j-1] */
    for (int i = 0; i <= m; ++i) {
        for (int j = 0; j <= n; j++) {
  
            if (i == 0 || j == 0)
                L[i][j] = 0;
  
            // If both characters are same, 
            // add both of them
            else if (X[i - 1] == Y[j - 1])
                L[i][j] = L[i - 1][j - 1] + 
                        2 * (X[i - 1] - '0');
  
            // Otherwise find the maximum 
            // cost among them
            else
                L[i][j] = L[i - 1][j] > L[i][j - 1] ? 
                          L[i - 1][j] : L[i][j - 1];
        }
    }
  
    return L[m][n];
}
  
// Returns cost of making X[] and Y[] identical
static int findMinCost(char X[], char Y[])
{
    // Find LCS of X[] and Y[]
    int m = X.length, n = Y.length;
  
    // Initialize the cost variable
    int cost = 0;
  
    // Find cost of all characters in
    // both strings
    for (int i = 0; i < m; ++i)
        cost += X[i] - '0';
  
    for (int i = 0; i < n; ++i)
        cost += Y[i] - '0';
  
    return cost - lcs(X, Y, m, n);
}
  
// driver function
    public static void main(String argc[]){
  
    char X[] = ("3759").toCharArray();
    char Y[] = ("9350").toCharArray();
      
    System.out.println("Minimum Cost to make two strings"+
                 " identical is = " +findMinCost(X, Y));
    }
}
  
// This code is contributed by Prerna Saini
Python3



# Python3 code to find minimum cost to make two strings 
#   identical 
  
# Function to returns cost of removing the identical 
# characters in LCS for X[0..m-1], Y[0..n-1] 
def lcs(X, Y,  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 cost 
    # of removing identical characters in LCS of 
    # X[0..i-1] and Y[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
    
            # If both characters are same, add both 
            # of them 
            elif (X[i - 1] == Y[j - 1]): 
                L[i][j] = L[i - 1][j - 1] + 2 * (ord(X[i - 1]) - 48) 
    
            # Otherwise find the maximum cost among them 
            else:
                L[i][j] = max(L[i - 1][j], L[i][j - 1])
    return L[m][n]
    
# Returns cost of making X[] and Y[] identical 
def findMinCost( X,  Y): 
    # Find LCS of X[] and Y[] 
    m = len(X)
    n = len(Y) 
    # Initialize the cost variable 
    cost = 0 
    
    # Find cost of all acters in 
    # both strings 
    for i in range(m):
        cost += ord(X[i]) - 48
    
    for i in range(n):
        cost += ord(Y[i]) - 48
    ans=cost - lcs(X, Y, m, n)
    return ans
    
# Driver program to test above function 
X = "3759" 
Y = "9350" 
print("Minimum Cost to make two strings ",
     "identical is = " ,findMinCost(X, Y))
  
#this code is contributed by sahilshelangia
C#



// C# code to find minimum cost to 
// make two strings identical
using System;
  
public class GfG{
      
    /* Function to returns cost of removing the identical
    characters in LCS for X[0..m-1], Y[0..n-1] */
    static int lcs(string X, string Y, int m, int n)
    {
        int [,]L=new int[m + 1,n + 1];
      
        /* Following steps build L[m+1][n+1] in 
        bottom up fashion. Note that L[i][j] contains 
        cost of removing identical characters in 
        LCS of X[0..i-1] and Y[0..j-1] */
        for (int i = 0; i <= m; ++i) {
            for (int j = 0; j <= n; j++) {
      
                if (i == 0 || j == 0)
                    L[i,j] = 0;
      
                // If both characters are same, 
                // add both of them
                else if (X[i - 1] == Y[j - 1])
                    L[i,j] = L[i - 1,j - 1] + 
                            2 * (X[i - 1] - '0');
      
                // Otherwise find the maximum 
                // cost among them
                else
                    L[i,j] = L[i - 1,j] > L[i,j - 1] ? 
                            L[i - 1,j] : L[i,j - 1];
            }
        }
      
        return L[m,n];
    }
      
    // Returns cost of making X[] and Y[] identical
    static int findMinCost( string X, string Y)
    {
        // Find LCS of X[] and Y[]
        int m = X.Length, n = Y.Length;
      
        // Initialize the cost variable
        int cost = 0;
      
        // Find cost of all characters in
        // both strings
        for (int i = 0; i < m; ++i)
            cost += X[i] - '0';
      
        for (int i = 0; i < n; ++i)
            cost += Y[i] - '0';
      
        return cost - lcs(X, Y, m, n);
    }
      
    // Driver function
    public static void Main()
    {
        string X = "3759";
        string Y= "9350";
          
        Console.WriteLine("Minimum Cost to make two strings"+
                    " identical is = " +findMinCost(X, Y));
    }
}
  
// This code is contributed by vt_m
PHP



<?php
// PHP code to find minimum cost to 
// make two strings identical
  
/* Function to returns cost of removing the identical
characters in LCS for X[0..m-1], Y[0..n-1] */
function lcs( $X, $Y, $m, $n)
{
    $L = array($m + 1,$n+ 1);
  
    /* Following steps build L[m+1][n+1] in 
    bottom up fashion. Note that L[i][j] contains 
    cost of removing identical characters in 
    LCS of X[0..i-1] and Y[0..j-1] */
    for ($i = 0; $i <= $m; ++$i)
    {
        for ($j = 0; $j <= $n; $j++) 
        {
  
            if ($i == 0 || $j == 0)
                $L[$i][$j] = 0;
  
            // If both characters are same, 
            // add both of them
            else if ($X[$i - 1] == $Y[$j - 1])
                $L[$i][$j] = $L[$i - 1][$j - 1] + 
                        2 * ($X[$i - 1] - '0');
  
            // Otherwise find the maximum 
            // cost among them
            else
                $L[$i][$j] = $L[$i - 1][$j] > $L[$i][$j - 1] ? 
                        $L[$i - 1][$j] : $L[$i][$j - 1];
        }
    }
  
    return $L[$m][$n];
}
  
// Returns cost of making X[] and Y[] identical
function findMinCost($X, $Y)
{
    // Find LCS of X[] and Y[]
    $m = sizeof($X); $n = sizeof($Y);
  
    // Initialize the cost variable
    $cost = 0;
  
    // Find cost of all characters in
    // both strings
    for ($i = 0; $i < $m; ++$i)
        $cost += $X[$i] - '0';
  
    for ($i = 0; $i < $n; ++$i)
        $cost += $Y[$i] - '0';
  
    return $cost - lcs($X, $Y, $m, $n);
}
  
// Driver code
  
    $X = str_split("3759");
    $Y = str_split("9350");
      
    echo("Minimum Cost to make two strings".
                " identical is = " .findMinCost($X, $Y));
      
// This code is contributed by Code_Mech.

Output:
Minimum Cost to make two strings  identical is = 23

Time complexity: O(m*n)
Auxiliary space: O(m*n)
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
Previous
Minimum cost to make Longest Common Subsequence of length k
Next

Minimum time to finish tasks without skipping two consecutive
Recommended Articles
Page :
Minimum Cost to make two Numeric Strings Identical
04, Oct 18
Minimum Cost To Make Two Strings Identical
26, Aug 16
Number formed by deleting digits such that sum of the digits becomes even and the number odd
26, Feb 20
Least number of manipulations needed to ensure two strings have identical characters
23, Aug 17
Minimum digits to be removed to make either all digits or alternating digits same
15, Aug 20
Minimum cost to make two strings same
28, Feb 19
Append digits to the end of dupicate strings to make all strings in an array unique
16, Nov 20
Minimum steps to delete a string by deleting substring comprising of same characters
13, Mar 19
Recursive program to insert a star between pair of identical characters
30, Dec 18
Check three or more consecutive identical characters or numbers
20, Jun 20
Reduce the string by removing K consecutive identical characters
02, Nov 18
Minimize cost to empty given array where cost of removing an element is its absolute difference with Time instant
08, Dec 20
Minimum cost to sort strings using reversal operations of different costs
01, Jan 17
Minimum number of given operations required to make two strings equal
18, Nov 18
Find the minimum number of preprocess moves required to make two strings equal
15, Feb 19
Minimum number of pairs required to make two strings same
17, May 19
Minimum swaps to make two strings equal by swapping only with third string
04, Apr 20
Minimum number of operations required to make two strings equal
07, May 20
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
Using Counter() in Python to find minimum character removal to make two strings anagram
10, Nov 17
Minimum insertions or deletions required to make two strings K-equivalent
19, Jan 21
Minimum Number of Manipulations required to make two Strings Anagram Without Deletion of Character
28, Aug 17
Minimum swaps required between two strings to make one string strictly greater than the other
22, Jan 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Shubham Bansal 13
@Shubham Bansal 13
Vote for difficulty
Current difficulty :
Medium





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