Skip to content
Related Articles

Related Articles

Improve Article

Minimum Cost to make two Numeric Strings Identical

  • Difficulty Level : Medium
  • Last Updated : 05 May, 2021

Given two numeric strings, A and B. A numeric string is a string that contains only digits [‘0’-‘9’].
The task is to make both the strings equal in minimum cost. The only operation that you are allowed to do is to delete a character (i.e. digit) from any of the strings (A or B). The cost of deleting a digit D is D units.
Examples: 
 

Input : A = “7135”, B = “135” 
Output : 7 
To make both string identical we have to delete ‘7’ from string A.
Input : A = “9142”, B = “1429” 
Output : 14 
There are 2 ways to make string “9142” identical to “1429” i.e either by deleting ‘9’ from both the strings or by deleting ‘1’, ‘4’and ‘2’ from both the string. Deleting 142 from both the string will cost 2*(1+4+2)=14 which is more optimal than deleting ‘9’. 
 

 

This problem is a variation of a popular Dynamic Programming problem – Longest Common Subsequence. The idea is to find the maximum weight common subsequence which will be our required optimal identical string. To find the cost of deletion, subtract the sum of maximum weight common subsequence from the sum of string A and B.
 

Minimum weight to make string identical = costA + costB – 2*(cost of LCS)



Below is the implementation of the above idea: 
 

C++




// CPP program to find minimum cost to make
// two numeric strings identical
 
#include <bits/stdc++.h>
 
using namespace std;
 
typedef long long int ll;
 
// Function to find weight of LCS
int lcs(int dp[101][101], string a, string b,
        int m, int n)
{
    for (int i = 0; i < 100; i++)
        for (int j = 0; j < 100; j++)
            dp[i][j] = -1;
 
    if (m < 0 || n < 0) {
        return 0;
    }
 
    // if this state is already
    // calculated then return
    if (dp[m][n] != -1)
        return dp[m][n];
 
    int ans = 0;
    if (a[m] == b[n]) {
        // adding required weight for
        // particular match
        ans = int(a[m] - 48) + lcs(dp, a, b,
                                   m - 1, n - 1);
    }
    else
        // recurse for left and right child
        // and store the max
        ans = max(lcs(dp, a, b, m - 1, n),
                  lcs(dp, a, b, m, n - 1));
 
    dp[m][n] = ans;
    return ans;
}
 
// Function to calculate cost of string
int costOfString(string str)
{
    int cost = 0;
 
    for (int i = 0; i < str.length(); i++)
        cost += int(str[i] - 48);
 
    return cost;
}
 
// Driver code
int main()
{
    string a, b;
 
    a = "9142";
    b = "1429";
 
    int dp[101][101];
 
    // Minimum cost needed to make two strings identical
    cout << (costOfString(a) + costOfString(b) -
                       2 * lcs(dp, a, b, a.length() - 1,
                                       b.length() - 1));
 
    return 0;
}
Java



// Java program to find minimum cost to make
// two numeric strings identical
 
import java.io.*;
 
class GFG {
  
 
// Function to find weight of LCS
 static int lcs(int dp[][], String a, String b,
        int m, int n)
{
    for (int i = 0; i < 100; i++)
        for (int j = 0; j < 100; j++)
            dp[i][j] = -1;
 
    if (m < 0 || n < 0) {
        return 0;
    }
 
    // if this state is already
    // calculated then return
    if (dp[m][n] != -1)
        return dp[m][n];
 
    int ans = 0;
    if (a.charAt(m) == b.charAt(n)) {
        // adding required weight for
        // particular match
        ans = (a.charAt(m) - 48) + lcs(dp, a, b,
                                m - 1, n - 1);
    }
    else
        // recurse for left and right child
        // and store the max
        ans = Math.max(lcs(dp, a, b, m - 1, n),
                lcs(dp, a, b, m, n - 1));
 
    dp[m][n] = ans;
    return ans;
}
 
// Function to calculate cost of string
 static int costOfString(String str)
{
    int cost = 0;
 
    for (int i = 0; i < str.length(); i++)
        cost += (str.charAt(i) - 48);
 
    return cost;
}
 
// Driver code
    public static void main (String[] args) {
            String a, b;
 
    a = "9142";
    b = "1429";
 
    int dp[][] = new int[101][101];
 
    // Minimum cost needed to make two strings identical
    System.out.print( (costOfString(a) + costOfString(b) -
                    2 * lcs(dp, a, b, a.length() - 1,
                                    b.length() - 1)));
 
    }
}
// This code is contributed by anuj_67.
Python 3



# Python 3 program to find minimum cost
# to make two numeric strings identical
 
# Function to find weight of LCS
def lcs(dp, a, b, m, n):
 
    for i in range(100):
        for j in range(100):
            dp[i][j] = -1
 
    if (m < 0 or n < 0) :
        return 0
 
    # if this state is already calculated
    # then return
    if (dp[m][n] != -1):
        return dp[m][n]
 
    ans = 0
    if (a[m] == b[n]):
         
        # adding required weight for
        # particular match
        ans = (ord(a[m]) - 48) + lcs(dp, a, b,
                                     m - 1, n - 1)
     
    else:
         
        # recurse for left and right child
        # and store the max
        ans = max(lcs(dp, a, b, m - 1, n),
                  lcs(dp, a, b, m, n - 1))
 
    dp[m][n] = ans
    return ans
 
# Function to calculate cost of string
def costOfString(s):
     
    cost = 0
 
    for i in range(len(s)):
        cost += (ord(s[i]) - 48)
 
    return cost
 
# Driver code
if __name__ == "__main__":
 
    a = "9142"
    b = "1429"
 
    dp = [[0 for x in range(101)]
             for y in range(101)]
 
    # Minimum cost needed to make two
    # strings identical
    print(costOfString(a) + costOfString(b) - 2 *
           lcs(dp, a, b, len(a) - 1, len(b) - 1))
 
# This code is contributed by ita_c
C#



// C# program to find minimum cost to make
// two numeric strings identical
using System;
public class GFG {
 
// Function to find weight of LCS
static int lcs(int [,]dp, String a, String b,
        int m, int n)
{
    for (int i = 0; i < 100; i++)
        for (int j = 0; j < 100; j++)
            dp[i,j] = -1;
 
    if (m < 0 || n < 0) {
        return 0;
    }
 
    // if this state is already
    // calculated then return
    if (dp[m,n] != -1)
        return dp[m,n];
 
    int ans = 0;
    if (a[m] == b[n]) {
        // adding required weight for
        // particular match
        ans = (a[m] - 48) + lcs(dp, a, b, m - 1, n - 1);
    }
    else
        // recurse for left and right child
        // and store the max
        ans = Math.Max(lcs(dp, a, b, m - 1, n),
                lcs(dp, a, b, m, n - 1));
 
    dp[m,n] = ans;
    return ans;
}
 
// Function to calculate cost of string
static int costOfString(String str)
{
    int cost = 0;
 
    for (int i = 0; i < str.Length; i++)
        cost += (str[i] - 48);
 
    return cost;
}
 
// Driver code
    public static void Main () {
            String a, b;
 
    a = "9142";
    b = "1429";
 
    int [,]dp = new int[101,101];
 
    // Minimum cost needed to make two strings identical
    Console.Write( (costOfString(a) + costOfString(b) -
                2 * lcs(dp, a, b, a.Length- 1,
                b.Length - 1)));
 
    }
}
// This code is contributed by Rajput-Ji
Javascript



<script>
// Javascript program to find minimum cost to make
// two numeric strings identical
     
    // Function to find weight of LCS
    function lcs(dp,a,b,m,n)
    {
         
   
    if (m < 0 || n < 0) {
        return 0;
    }
   
    // if this state is already
    // calculated then return
    if (dp[m][n] != -1)
        return dp[m][n];
   
    let ans = 0;
    if (a[m] == b[n]) {
        // adding required weight for
        // particular match
        ans = (a[m].charCodeAt(0) - 48) + lcs(dp, a, b,
                                m - 1, n - 1);
    }
    else
        // recurse for left and right child
        // and store the max
        ans = Math.max(lcs(dp, a, b, m - 1, n),
                lcs(dp, a, b, m, n - 1));
   
    dp[m][n] = ans;
    return ans;
    }
     
    // Function to calculate cost of string
    function costOfString(str)
    {
        let cost = 0;
   
    for (let i = 0; i < str.length; i++)
        cost += (str[i].charCodeAt(0) - 48);
   
    return cost;
    }
     
    // Driver code
    let a = "9142";
    let b = "1429";
    let dp=new Array(101);
    for(let i=0;i<dp.length;i++)
    {
        dp[i]=new Array(101);
        for(let j=0;j<101;j++)
        {
            dp[i][j]=-1;
        }
    }
    // Minimum cost needed to make two strings identical
    document.write( (costOfString(a) + costOfString(b) -
                    2 * lcs(dp, a, b, a.length - 1,
                                    b.length - 1)));
     
    // This code is contributed by avanitrachhadiya2155
</script>
Output: 
14
 
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.



My Personal Notes
arrow_drop_up
Previous
Find four factors of N with maximum product and sum equal to N | Set-2
Next

Find a point such that sum of the Manhattan distances is minimized
Recommended Articles
Page :
Minimum cost to make two strings identical by deleting the digits
29, Nov 17
Minimum Cost To Make Two Strings Identical
26, Aug 16
Minimum cost to make two strings same
28, Feb 19
Remove uppercase, lowercase, special, numeric, and non-numeric characters from a String
05, Oct 20
Least number of manipulations needed to ensure two strings have identical characters
23, Aug 17
Minimum circular rotations to obtain a given numeric string by avoiding a set of given strings
22, May 20
Minimum cost to complete given tasks if cost of 1, 7 and 30 days are given
09, Jul 21
Find the GCD of an array made up of numeric strings
19, Jan 21
Minimum cost to sort strings using reversal operations of different costs
01, Jan 17
Minimize cost to empty given array where cost of removing an element is its absolute difference with Time instant
08, Dec 20
Count ways to make the number formed by K concatenations of a numeric string divisible by 5
10, Aug 21
Using Counter() in Python to find minimum character removal to make two strings anagram
10, Nov 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 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
Minimum insertions or deletions required to make two strings K-equivalent
19, Jan 21
Minimum swaps required between two strings to make one string strictly greater than the other
22, Jan 21
Minimum number of operations required to make two strings equal
07, May 20
Minimum number of flips or swaps of adjacent characters required to make two strings equal
12, Jul 21
Minimum Number of Manipulations required to make two Strings Anagram Without Deletion of Character
28, Aug 17
Minimum cost to make a string free of a subsequence
28, Feb 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Kushdeep_Mittal
@Kushdeep_Mittal
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