Given two strings X and Y, and two values costX and costY. We need to find minimum cost required to make the given two strings identical. We can delete characters from both the strings. The cost of deleting a character from string X is costX and from Y is costY. Cost of removing all characters from a string is same.

**Examples :**

Input : X = "abcd", Y = "acdb", costX = 10, costY = 20. Output: 30 For Making both strings identical we have to delete character 'b' from both the string, hence cost will be = 10 + 20 = 30. Input : X = "ef", Y = "gh", costX = 10, costY = 20. Output: 60 For making both strings identical, we have to delete 2-2 characters from both the strings, hence cost will be = 10 + 10 + 20 + 20 = 60.

This problem is a variation of Longest Common Subsequence ( LCS ). The idea is simple, we first find the length of longest common subsequence of strings X and Y. Now subtracting len_LCS with lengths of individual strings gives us number of characters to be removed to make them identical.

// Cost of making two strings identical is SUM of following two // 1) Cost of removing extra characters (other than LCS) // from X[] // 2) Cost of removing extra characters (other than LCS) // from Y[] Minimum Cost to make strings identical = costX * (m - len_LCS) + costY * (n - len_LCS). m ==> Length of string X m ==> Length of string Y len_LCS ==> Length of LCS Of X and Y. costX ==> Cost of removing a character from X[] costY ==> Cost of removing a character from Y[] Note that cost of removing all characters from a string is same.

Below is the implementation of above idea.

## C++

`/* C++ code to find minimum cost to make two strings ` ` ` `identical */` `#include<bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `/* Returns length of 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 length ` ` ` `of 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; ` ` ` ` ` `else` `if` `(X[i-1] == Y[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]; ` `} ` ` ` `// Returns cost of making X[] and Y[] identical. costX is ` `// cost of removing a character from X[] and costY is cost ` `// of removing a character from Y[]/ ` `int` `findMinCost(` `char` `X[], ` `char` `Y[], ` `int` `costX, ` `int` `costY) ` `{ ` ` ` `// Find LCS of X[] and Y[] ` ` ` `int` `m = ` `strlen` `(X), n = ` `strlen` `(Y); ` ` ` `int` `len_LCS = lcs(X, Y, m, n); ` ` ` ` ` `// Cost of making two strings identical is SUM of ` ` ` `// following two ` ` ` `// 1) Cost of removing extra characters ` ` ` `// from first string ` ` ` `// 2) Cost of removing extra characters from ` ` ` `// second string ` ` ` `return` `costX * (m - len_LCS) + ` ` ` `costY * (n - len_LCS); ` `} ` ` ` `/* Driver program to test above function */` `int` `main() ` `{ ` ` ` `char` `X[] = ` `"ef"` `; ` ` ` `char` `Y[] = ` `"gh"` `; ` ` ` `cout << ` `"Minimum Cost to make two strings "` ` ` `<< ` `" identical is = "` `<< findMinCost(X, Y, 10, 20); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java code to find minimum cost to ` `// make two strings identical ` `import` `java.io.*; ` ` ` `class` `GFG { ` ` ` ` ` `// Returns length of 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 length ` ` ` `of 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` `; ` ` ` ` ` `else` `if` `(X.charAt(i - ` `1` `) == Y.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]; ` ` ` `} ` ` ` ` ` `// Returns cost of making X[] and Y[] identical. ` ` ` `// costX is cost of removing a character from X[] ` ` ` `// and costY is cost of removing a character from Y[]/ ` ` ` `static` `int` `findMinCost(String X, String Y, ` `int` `costX, ` `int` `costY) ` ` ` `{ ` ` ` `// Find LCS of X[] and Y[] ` ` ` `int` `m = X.length(); ` ` ` `int` `n = Y.length(); ` ` ` `int` `len_LCS; ` ` ` `len_LCS = lcs(X, Y, m, n); ` ` ` ` ` `// Cost of making two strings identical ` ` ` `// is SUM of following two ` ` ` `// 1) Cost of removing extra characters ` ` ` `// from first string ` ` ` `// 2) Cost of removing extra characters ` ` ` `// from second string ` ` ` `return` `costX * (m - len_LCS) + ` ` ` `costY * (n - len_LCS); ` ` ` `} ` ` ` ` ` `// Driver code ` ` ` `public` `static` `void` `main (String[] args) ` ` ` `{ ` ` ` `String X = ` `"ef"` `; ` ` ` `String Y = ` `"gh"` `; ` ` ` `System.out.println( ` `"Minimum Cost to make two strings "` ` ` `+ ` `" identical is = "` ` ` `+ findMinCost(X, Y, ` `10` `, ` `20` `)); ` ` ` ` ` `} ` `} ` ` ` `// This code is contributed by vt_m ` |

*chevron_right*

*filter_none*

## Python3

`# Python code to find minimum cost ` `# to make two strings identical ` ` ` `# Returns length of 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 length ` ` ` `# of 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` ` ` `elif` `X[i ` `-` `1` `] ` `=` `=` `Y[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] ` ` ` `# Returns cost of making X[] ` `# and Y[] identical. costX is ` `# cost of removing a character ` `# from X[] and costY is cost ` `# of removing a character from Y[] ` `def` `findMinCost(X, Y, costX, costY): ` ` ` ` ` `# Find LCS of X[] and Y[] ` ` ` `m ` `=` `len` `(X) ` ` ` `n ` `=` `len` `(Y) ` ` ` `len_LCS ` `=` `lcs(X, Y, m, n) ` ` ` ` ` `# Cost of making two strings ` ` ` `# identical is SUM of following two ` ` ` `# 1) Cost of removing extra ` ` ` `# characters from first string ` ` ` `# 2) Cost of removing extra ` ` ` `# characters from second string ` ` ` `return` `(costX ` `*` `(m ` `-` `len_LCS) ` `+` ` ` `costY ` `*` `(n ` `-` `len_LCS)) ` ` ` `# Driver Code ` `X ` `=` `"ef"` `Y ` `=` `"gh"` `print` `(` `'Minimum Cost to make two strings '` `, end ` `=` `'') ` `print` `(` `'identical is = '` `, findMinCost(X, Y, ` `10` `, ` `20` `)) ` ` ` `# This code is contributed ` `# by sahilshelangia ` |

*chevron_right*

*filter_none*

## C#

`// C# code to find minimum cost to ` `// make two strings identical ` `using` `System; ` ` ` `class` `GFG { ` ` ` ` ` `// Returns length of 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 length ` ` ` `of 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; ` ` ` ` ` `else` `if` `(X[i - 1] == Y[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]; ` ` ` `} ` ` ` ` ` `// Returns cost of making X[] and Y[] identical. ` ` ` `// costX is cost of removing a character from X[] ` ` ` `// and costY is cost of removing a character from Y[] ` ` ` `static` `int` `findMinCost(String X, String Y, ` ` ` `int` `costX, ` `int` `costY) ` ` ` `{ ` ` ` `// Find LCS of X[] and Y[] ` ` ` `int` `m = X.Length; ` ` ` `int` `n = Y.Length; ` ` ` `int` `len_LCS; ` ` ` `len_LCS = lcs(X, Y, m, n); ` ` ` ` ` `// Cost of making two strings identical ` ` ` `// is SUM of following two ` ` ` `// 1) Cost of removing extra characters ` ` ` `// from first string ` ` ` `// 2) Cost of removing extra characters ` ` ` `// from second string ` ` ` `return` `costX * (m - len_LCS) + ` ` ` `costY * (n - len_LCS); ` ` ` `} ` ` ` ` ` `// Driver code ` ` ` `public` `static` `void` `Main () ` ` ` `{ ` ` ` `String X = ` `"ef"` `; ` ` ` `String Y = ` `"gh"` `; ` ` ` `Console.Write( ` `"Minimum Cost to make two strings "` `+ ` ` ` `" identical is = "` `+ ` ` ` `findMinCost(X, Y, 10, 20)); ` ` ` `} ` `} ` ` ` `// This code is contributed by nitin mittal. ` |

*chevron_right*

*filter_none*

## PHP

`<?php ` `/* PHP code to find minimum cost to make two strings ` ` ` `identical */` ` ` `/* Returns length of LCS for X[0..m-1], Y[0..n-1] */` `function` `lcs(` `$X` `, ` `$Y` `, ` `$m` `, ` `$n` `) ` `{ ` ` ` `$L` `= ` `array_fill` `(0,(` `$m` `+1),` `array_fill` `(0,(` `$n` `+1),NULL)); ` ` ` ` ` `/* Following steps build L[m+1][n+1] in bottom ` ` ` `up fashion. Note that L[i][j] contains length ` ` ` `of 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; ` ` ` ` ` `else` `if` `(` `$X` `[` `$i` `-1] == ` `$Y` `[` `$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` `]; ` `} ` ` ` `// Returns cost of making X[] and Y[] identical. costX is ` `// cost of removing a character from X[] and costY is cost ` `// of removing a character from Y[]/ ` `function` `findMinCost(&` `$X` `, &` `$Y` `,` `$costX` `, ` `$costY` `) ` `{ ` ` ` `// Find LCS of X[] and Y[] ` ` ` `$m` `= ` `strlen` `(` `$X` `); ` ` ` `$n` `= ` `strlen` `(` `$Y` `); ` ` ` `$len_LCS` `= lcs(` `$X` `, ` `$Y` `, ` `$m` `, ` `$n` `); ` ` ` ` ` `// Cost of making two strings identical is SUM of ` ` ` `// following two ` ` ` `// 1) Cost of removing extra characters ` ` ` `// from first string ` ` ` `// 2) Cost of removing extra characters from ` ` ` `// second string ` ` ` `return` `$costX` `* (` `$m` `- ` `$len_LCS` `) + ` ` ` `$costY` `* (` `$n` `- ` `$len_LCS` `); ` `} ` ` ` `/* Driver program to test above function */` `$X` `= ` `"ef"` `; ` `$Y` `= ` `"gh"` `; ` `echo` `"Minimum Cost to make two strings "` `. ` ` ` `" identical is = "` `. findMinCost(` `$X` `, ` `$Y` `, 10, 20); ` `return` `0; ` `?> ` |

*chevron_right*

*filter_none*

Output:

Minimum Cost to make two strings identical is = 60

This article is contributed by **Shashank Mishra ( Gullu )**. This article is reviwed by team geeksforgeeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

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.

## Recommended Posts:

- Minimum cost to make two strings identical by deleting the digits
- Minimum Cost to make two Numeric Strings Identical
- Minimum cost to make two strings same
- Least number of manipulations needed to ensure two strings have identical characters
- Minimum Number of Manipulations required to make two Strings Anagram Without Deletion of Character
- Using Counter() in Python to find minimum character removal to make two strings anagram
- Minimum number of given operations required to make two strings equal
- Find the minimum number of preprocess moves required to make two strings equal
- Minimum number of pairs required to make two strings same
- Minimum swaps to make two strings equal by swapping only with third string
- Minimum number of operations required to make two strings equal
- Minimum characters to be deleted from the beginning of two strings to make them equal
- Minimum characters to be deleted from the end to make given two strings equal
- Minimum cost to make Longest Common Subsequence of length k
- Minimum cost to make a string free of a subsequence
- Minimum cost to sort strings using reversal operations of different costs
- Minimum move to end operations to make all strings equal
- Cost to make a string Panagram
- Cost to make a string Panagram | Set 2
- Reduce the string by removing K consecutive identical characters