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 = 9350Output:23ExplanationFor 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 = 23Input:X = 3198, Y = 98Output: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.