Minimum cost to make Longest Common Subsequence of length k
Last Updated :
23 Dec, 2023
Given two string X, Y and an integer k. Now the task is to convert string X with the minimum cost such that the Longest Common Subsequence of X and Y after conversion is of length k. The cost of conversion is calculated as XOR of old character value and new character value. The character value of ‘a’ is 0, ‘b’ is 1, and so on.
Examples:Â
Input : X = "abble",
Y = "pie",
k = 2
Output : 25
If you changed 'a' to 'z', it will cost 0 XOR 25.
The problem can be solved by slight change in Dynamic Programming problem of Longest Increasing Subsequence. Instead of two states, we maintain three states.Â
Note, that if k > min(n, m) then it’s impossible to attain LCS of atleast k length, else it’s always possible.Â
Let dp[i][j][p] stores the minimum cost to achieve LCS of length p in x[0…i] and y[0….j].Â
With base step as dp[i][j][0] = 0 because we can achieve LCS of 0 length without any cost and for i < 0 or j 0 in such case).Â
Else there are 3 cases:Â
1. Convert x[i] to y[j].Â
2. Skip ith character from x.Â
3. Skip jth character from y.
If we convert x[i] to y[j], then cost = f(x[i]) XOR f(y[j]) will be added and LCS will decrease by 1. f(x) will return the character value of x.Â
Note that the minimum cost to convert a character ‘a’ to any character ‘c’ is always f(a) XOR f(c) because f(a) XOR f(c) <= (f(a) XOR f(b) + f(b) XOR f(c)) for all a, b, c.Â
If you skip ith character from x then i will be decreased by 1, no cost will be added and LCS will remain the same.Â
If you skip jth character from x then j will be decreased by 1, no cost will be added and LCS will remain the same.
Therefore,
dp[i][j][k] = min(cost + dp[i - 1][j - 1][k - 1],
dp[i - 1][j][k],
dp[i][j - 1][k])
The minimum cost to make the length of their
LCS atleast k is dp[n - 1][m - 1][k]
C++
#include <bits/stdc++.h>
using namespace std;
const int N = 30;
int solve( char X[], char Y[], int l, int r,
int k, int dp[][N][N])
{
if (!k)
return 0;
if (l < 0 | r < 0)
return 1e9;
if (dp[l][r][k] != -1)
return dp[l][r][k];
int cost = (X[l] - 'a' ) ^ (Y[r] - 'a' );
return dp[l][r][k] = min({cost +
solve(X, Y, l - 1, r - 1, k - 1, dp),
solve(X, Y, l - 1, r, k, dp),
solve(X, Y, l, r - 1, k, dp)});
}
int main()
{
char X[] = "abble" ;
char Y[] = "pie" ;
int n = strlen (X);
int m = strlen (Y);
int k = 2;
int dp[N][N][N];
memset (dp, -1, sizeof dp);
int ans = solve(X, Y, n - 1, m - 1, k, dp);
cout << (ans == 1e9 ? -1 : ans) << endl;
return 0;
}
|
Java
import java.util.*;
import java.io.*;
class GFG
{
static int N = 30 ;
static int solve( char X[], char Y[], int l, int r,
int k, int dp[][][])
{
if (k == 0 )
{
return 0 ;
}
if (l < 0 | r < 0 )
{
return ( int ) 1e9;
}
if (dp[l][r][k] != - 1 )
{
return dp[l][r][k];
}
int cost = (X[l] - 'a' ) ^ (Y[r] - 'a' );
return dp[l][r][k] = Math.min(Math.min(cost +
solve(X, Y, l - 1 , r - 1 , k - 1 , dp),
solve(X, Y, l - 1 , r, k, dp)),
solve(X, Y, l, r - 1 , k, dp));
}
public static void main(String[] args)
{
char X[] = "abble" .toCharArray();
char Y[] = "pie" .toCharArray();
int n = X.length;
int m = Y.length;
int k = 2 ;
int [][][] dp = new int [N][N][N];
for ( int i = 0 ; i < N; i++)
{
for ( int j = 0 ; j < N; j++)
{
for ( int l = 0 ; l < N; l++)
{
dp[i][j][l] = - 1 ;
}
}
}
int ans = solve(X, Y, n - 1 , m - 1 , k, dp);
System.out.println(ans == 1e9 ? - 1 : ans);
}
}
|
Python3
N = 30
def solve(X, Y, l, r, k, dp):
if k = = 0 :
return 0
if l < 0 or r < 0 :
return 1000000000
if dp[l][r][k] ! = - 1 :
return dp[l][r][k]
cost = (( ord (X[l]) - ord ( 'a' )) ^
( ord (Y[r]) - ord ( 'a' )))
dp[l][r][k] = min ([cost + solve(X, Y, l - 1 ,
r - 1 , k - 1 , dp),
solve(X, Y, l - 1 , r, k, dp),
solve(X, Y, l, r - 1 , k, dp)])
return dp[l][r][k]
if __name__ = = "__main__" :
X = "abble"
Y = "pie"
n = len (X)
m = len (Y)
k = 2
dp = [[[ - 1 ] * N for __ in range (N)]
for ___ in range (N)]
ans = solve(X, Y, n - 1 , m - 1 , k, dp)
print ( - 1 if ans = = 1000000000 else ans)
|
C#
using System;
class GFG
{
static int N = 30;
static int solve( char []X, char []Y, int l, int r,
int k, int [,,]dp)
{
if (k == 0)
{
return 0;
}
if (l < 0 | r < 0)
{
return ( int ) 1e9;
}
if (dp[l,r,k] != -1)
{
return dp[l,r,k];
}
int cost = (X[l] - 'a' ) ^ (Y[r] - 'a' );
return dp[l,r,k] = Math.Min(Math.Min(cost +
solve(X, Y, l - 1, r - 1, k - 1, dp),
solve(X, Y, l - 1, r, k, dp)),
solve(X, Y, l, r - 1, k, dp));
}
public static void Main(String[] args)
{
char []X = "abble" .ToCharArray();
char []Y = "pie" .ToCharArray();
int n = X.Length;
int m = Y.Length;
int k = 2;
int [,,] dp = new int [N, N, N];
for ( int i = 0; i < N; i++)
{
for ( int j = 0; j < N; j++)
{
for ( int l = 0; l < N; l++)
{
dp[i,j,l] = -1;
}
}
}
int ans = solve(X, Y, n - 1, m - 1, k, dp);
Console.WriteLine(ans == 1e9 ? -1 : ans);
}
}
|
Javascript
<script>
const N = 30
function solve(X, Y, l, r, k, dp){
if (k == 0)
return 0
if (l < 0 || r < 0)
return 1000000000
if (dp[l][r][k] != -1)
return dp[l][r][k]
let cost = ((X[l].charCodeAt(0) - 'a' .charCodeAt(0)) ^ (Y[r].charCodeAt(0) - 'a' .charCodeAt(0)))
dp[l][r][k] = Math.min(Math.min(cost + solve(X, Y, l - 1, r - 1, k - 1, dp),solve(X, Y, l - 1, r, k, dp)),
solve(X, Y, l, r - 1, k, dp))
return dp[l][r][k]
}
let X = "abble"
let Y = "pie"
let n = X.length
let m = Y.length
let k = 2
let dp = new Array(N);
for (let i = 0; i < N; i++)
{
dp[i] = new Array(N);
for (let j = 0; j < N; j++)
{
dp[i][j] = new Array(N).fill(-1);
}
}
let ans = solve(X, Y, n - 1, m - 1, k, dp)
document.write((ans == 1000000000)? -1:ans)
</script>
|
Time Complexity: O(n3)
Auxiliary Space: O(n3)
Efficient approach: Using DP Tabulation method ( Iterative approach )
The approach to solve this problem is same but DP tabulation(bottom-up) method is better then Dp + memoization(top-down) because memoization method needs extra stack space of recursion calls.
Steps to solve this problem :
- Create a 3d DP to store the solution of the subproblems.
- Initialize the DP with base cases when k= 0 dp value is 0 and when n=0 or m=0 dp value is 1e9 and dp[0][0][0] = 0 .
- Now Iterate over subproblems to get the value of current problem form previous computation of subproblems stored in DP
- Return the final solution stored in dp[n][m][k].
Implementation :
C++
#include <bits/stdc++.h>
using namespace std;
const int N = 30;
int solve( char X[], char Y[], int n, int m, int k)
{
int dp[n + 1][m + 1][k + 1];
for ( int i = 0; i <= n; i++) {
for ( int j = 0; j <= m; j++) {
for ( int p = 0; p <= k; p++) {
if (k == 0) {
dp[i][j][p] = 0;
}
else if (i == 0 || j == 0) {
dp[i][j][p] = 1e9;
}
}
}
}
dp[0][0][0] = 0;
for ( int i = 1; i <= n; i++) {
for ( int j = 1; j <= m; j++) {
for ( int p = 1; p <= k; p++) {
int cost
= (X[i - 1] - 'a' ) ^ (Y[j - 1] - 'a' );
dp[i][j][p] = min(
{ cost + dp[i - 1][j - 1][p - 1],
dp[i - 1][j][p], dp[i][j - 1][p] });
}
}
}
return dp[n][m][k];
}
int main()
{
char X[] = "abble" ;
char Y[] = "pie" ;
int n = strlen (X);
int m = strlen (Y);
int k = 2;
int ans = solve(X, Y, n, m, k);
cout << (ans == 1e9 ? -1 : ans) << endl;
return 0;
}
|
Java
import java.util.*;
public class Main {
public static int solve( char X[], char Y[], int n, int m, int k) {
int dp[][][] = new int [n + 1 ][m + 1 ][k + 1 ];
for ( int i = 0 ; i <= n; i++) {
for ( int j = 0 ; j <= m; j++) {
for ( int p = 0 ; p <= k; p++) {
if (k == 0 ) {
dp[i][j][p] = 0 ;
} else if (i == 0 || j == 0 ) {
dp[i][j][p] = Integer.MAX_VALUE / 2 ;
}
}
}
}
dp[ 0 ][ 0 ][ 0 ] = 0 ;
for ( int i = 1 ; i <= n; i++) {
for ( int j = 1 ; j <= m; j++) {
for ( int p = 1 ; p <= k; p++) {
int cost = (X[i - 1 ]- 'a' ) ^ (Y[j - 1 ]- 'a' );
dp[i][j][p] = Math.min(Math.min(dp[i - 1 ][j - 1 ][p - 1 ] + cost, dp[i - 1 ][j][p]), dp[i][j - 1 ][p]);
}
}
}
return dp[n][m][k];
}
public static void main(String[] args) {
char X[] = "abble" .toCharArray();
char Y[] = "pie" .toCharArray();
int n = X.length;
int m = Y.length;
int k = 2 ;
int ans = solve(X, Y, n, m, k);
System.out.println(ans);
}
}
|
Python3
INF = float ( 'inf' )
def solve(X, Y, n, m, k):
dp = [[[ 0 for p in range (k + 1 )] for j in range (m + 1 )] for i in range (n + 1 )]
for i in range (n + 1 ):
for j in range (m + 1 ):
for p in range (k + 1 ):
if k = = 0 :
dp[i][j][p] = 0
elif i = = 0 or j = = 0 :
dp[i][j][p] = INF
dp[ 0 ][ 0 ][ 0 ] = 0
for i in range ( 1 , n + 1 ):
for j in range ( 1 , m + 1 ):
for p in range ( 1 , k + 1 ):
cost = ord (X[i - 1 ]) - ord ( 'a' ) ^ ord (Y[j - 1 ]) - ord ( 'a' )
dp[i][j][p] = min (cost + dp[i - 1 ][j - 1 ][p - 1 ],
dp[i - 1 ][j][p], dp[i][j - 1 ][p])
return - 1 if dp[n][m][k] = = INF else dp[n][m][k]
if __name__ = = '__main__' :
X = "abble"
Y = "pie"
n = len (X)
m = len (Y)
k = 2
ans = solve(X, Y, n, m, k)
print (ans)
|
C#
using System;
public class Program
{
public static int Solve( char [] X, char [] Y, int n, int m, int k)
{
int [][][] dp = new int [n + 1][][];
for ( int i = 0; i <= n; i++)
{
dp[i] = new int [m + 1][];
for ( int j = 0; j <= m; j++)
{
dp[i][j] = new int [k + 1];
for ( int p = 0; p <= k; p++)
{
if (k == 0)
{
dp[i][j][p] = 0;
}
else if (i == 0 || j == 0)
{
dp[i][j][p] = int .MaxValue / 2;
}
}
}
}
dp[0][0][0] = 0;
for ( int i = 1; i <= n; i++)
{
for ( int j = 1; j <= m; j++)
{
for ( int p = 1; p <= k; p++)
{
int cost = (X[i - 1] - 'a' ) ^ (Y[j - 1] - 'a' );
dp[i][j][p] = Math.Min(
Math.Min(dp[i - 1][j - 1][p - 1] + cost, dp[i - 1][j][p]),
dp[i][j - 1][p]);
}
}
}
return dp[n][m][k];
}
public static void Main( string [] args)
{
char [] X = "abble" .ToCharArray();
char [] Y = "pie" .ToCharArray();
int n = X.Length;
int m = Y.Length;
int k = 2;
int ans = Solve(X, Y, n, m, k);
Console.WriteLine(ans);
}
}
|
Javascript
const N = 30;
function solve(X, Y, n, m, k) {
const dp = new Array(n + 1).fill( null )
.map(() => new Array(m + 1).fill( null )
.map(() => new Array(k + 1).fill(0)));
for (let i = 0; i <= n; i++) {
for (let j = 0; j <= m; j++) {
for (let p = 0; p <= k; p++) {
if (k === 0) {
dp[i][j][p] = 0;
} else if (i === 0 || j === 0) {
dp[i][j][p] = Infinity;
}
}
}
}
dp[0][0][0] = 0;
for (let i = 1; i <= n; i++) {
for (let j = 1; j <= m; j++) {
for (let p = 1; p <= k; p++) {
const cost = (X[i - 1].charCodeAt() - 'a' .charCodeAt()) ^
(Y[j - 1].charCodeAt() - 'a' .charCodeAt());
dp[i][j][p] = Math.min(
cost + dp[i - 1][j - 1][p - 1],
dp[i - 1][j][p],
dp[i][j - 1][p]);
}
}
}
return dp[n][m][k];
}
const X = "abble" ;
const Y = "pie" ;
const n = X.length;
const m = Y.length;
const k = 2;
const ans = solve(X, Y, n, m, k);
console.log(ans === Infinity ? -1 : ans);
|
Time Complexity: O(n*m*k)
Auxiliary Space: O(n*m*k)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...