Longest Common Subsequence with at most k changes allowed - GeeksforGeeks

10 Dec, 2021
Given two sequence P and Q of numbers. The task is to find Longest Common Subsequence of two sequences if we are allowed to change at most k element in first sequence to any value.
Examples: 
Input : P = { 8, 3 }
        Q = { 1, 3 }
        K = 1
Output : 2
If we change first element of first
sequence from 8 to 1, both sequences 
become same.

Input : P = { 1, 2, 3, 4, 5 }
        Q = { 5, 3, 1, 4, 2 }
        K = 1
Output : 3
By changing first element of first
sequence to 5 to get the LCS ( 5, 3, 4 }.
The idea is to use Dynamic Programming. Define a 3D matrix dp[][][], where dp[i][j][k] defines the Longest Common Subsequence for the first i numbers of first array, first j number of second array when we are allowed to change at max k number in the first array. 
Therefore, recursion will look like 
If P[i] != Q[j], 
    dp[i][j][k] = max(dp[i - 1][j][k], 
                      dp[i][j - 1][k], 
                      dp[i - 1][j - 1][k - 1] + 1) 
If P[i] == Q[j], 
    dp[i][j][k] = max(dp[i - 1][j][k], 
                      dp[i][j - 1][k], 
                      dp[i - 1][j - 1][k] + 1)
Below is the implementation of this approach:
C++
Java
Python3
C#
Javascript
// CPP program to find LCS of two arrays with// k changes allowed in first array.#include <bits/stdc++.h>using namespace std;#define MAX 10 // Return LCS with at most k changes allowed.int lcs(int dp[MAX][MAX][MAX], int arr1[], int n,                       int arr2[], int m, int k){    // If at most changes is less than 0.    if (k < 0)        return -1e7;     // If any of two array is over.    if (n < 0 || m < 0)        return 0;     // Making a reference variable to dp[n][m][k]    int& ans = dp[n][m][k];     // If value is already calculated, return    // that value.    if (ans != -1)        return ans;     // calculating LCS with no changes made.    ans = max(lcs(dp, arr1, n - 1, arr2, m, k),              lcs(dp, arr1, n, arr2, m - 1, k));     // calculating LCS when array element are same.    if (arr1[n-1] == arr2[m-1])        ans = max(ans, 1 + lcs(dp, arr1, n - 1,                                arr2, m - 1, k));     // calculating LCS with changes made.    ans = max(ans, 1 + lcs(dp, arr1, n - 1,                          arr2, m - 1, k - 1));     return ans;} // Driven Programint main(){    int k = 1;    int arr1[] = { 1, 2, 3, 4, 5 };    int arr2[] = { 5, 3, 1, 4, 2 };    int n = sizeof(arr1) / sizeof(arr1[0]);    int m = sizeof(arr2) / sizeof(arr2[0]);     int dp[MAX][MAX][MAX];    memset(dp, -1, sizeof(dp));     cout << lcs(dp, arr1, n, arr2, m, k) << endl;     return 0;}
// Java program to find LCS of two arrays with// k changes allowed in first array.class GFG{    static int MAX = 10;     // Return LCS with at most k changes allowed.    static int lcs(int[][][] dp, int[] arr1,                      int n, int[] arr2, int m, int k)    {         // If at most changes is less than 0.        if (k < 0)            return -10000000;         // If any of two array is over.        if (n < 0 || m < 0)            return 0;         // Making a reference variable to dp[n][m][k]        int ans = dp[n][m][k];         // If value is already calculated, return        // that value.        if (ans != -1)            return ans;         try        {             // calculating LCS with no changes made.            ans = Math.max(lcs(dp, arr1, n - 1, arr2, m, k),                           lcs(dp, arr1, n, arr2, m - 1, k));             // calculating LCS when array element are same.            if (arr1[n - 1] == arr2[m - 1])                ans = Math.max(ans, 1 + lcs(dp, arr1, n - 1,                                                arr2, m - 1, k));             // calculating LCS with changes made.            ans = Math.max(ans, 1 + lcs(dp, arr1, n - 1,                                            arr2, m - 1, k - 1));        } catch (Exception e) { }          // Storing the value in dp.          dp[n][m][k] = ans;        return ans;    }     // Driver Code    public static void main(String[] args)    {        int k = 1;        int[] arr1 = { 1, 2, 3, 4, 5 };        int[] arr2 = { 5, 3, 1, 4, 2 };        int n = arr1.length;        int m = arr2.length;         int[][][] dp = new int[MAX][MAX][MAX];        for (int i = 0; i < MAX; i++)            for (int j = 0; j < MAX; j++)                for (int l = 0; l < MAX; l++)                    dp[i][j][l] = -1;         System.out.println(lcs(dp, arr1, n, arr2, m, k));    }} // This code is contributed by// krishnat208026
# Python3 program to find LCS of two arrays# with k changes allowed in the first array.MAX = 10 # Return LCS with at most k changes allowed.def lcs(dp, arr1, n, arr2, m, k):      # If at most changes is less than 0.    if k < 0:        return -(10 ** 7)     # If any of two array is over.    if n < 0 or m < 0:        return 0     # Making a reference variable to dp[n][m][k]    ans = dp[n][m][k]     # If value is already calculated,    # return that value.    if ans != -1:        return ans     # calculating LCS with no changes made.    ans = max(lcs(dp, arr1, n - 1, arr2, m, k),            lcs(dp, arr1, n, arr2, m - 1, k))     # calculating LCS when array element are same.    if arr1[n-1] == arr2[m-1]:        ans = max(ans, 1 + lcs(dp, arr1, n - 1,                                arr2, m - 1, k))     # calculating LCS with changes made.    ans = max(ans, lcs(dp, arr1, n - 1,                        arr2, m - 1, k - 1))     return ans  # Driven Programif __name__ == "__main__":      k = 1    arr1 = [1, 2, 3, 4, 5]    arr2 = [5, 3, 1, 4, 2]     n = len(arr1)    m = len(arr2)     dp = [[[-1 for i in range(MAX)] for j in range(MAX)] for k in range(MAX)]         print(lcs(dp, arr1, n, arr2, m, k)) # This code is contributed by Rituraj Jain
// C# program to find LCS of two arrays with// k changes allowed in first array.using System; class GFG{    static int MAX = 10;     // Return LCS with at most    // k changes allowed.    static int lcs(int[,,] dp, int[] arr1,                        int n, int[] arr2,                        int m, int k)    {         // If at most changes is less than 0.        if (k < 0)            return -10000000;         // If any of two array is over.        if (n < 0 || m < 0)            return 0;         // Making a reference variable        // to dp[n,m,k]        int ans = dp[n, m, k];         // If value is already calculated,        // return that value.        if (ans != -1)            return ans;         try        {             // calculating LCS with no changes made.            ans = Math.Max(lcs(dp, arr1, n - 1,                                   arr2, m, k),                           lcs(dp, arr1, n,                                   arr2, m - 1, k));             // calculating LCS when            // array element are same.            if (arr1[n - 1] == arr2[m - 1])                ans = Math.Max(ans, 1 +                           lcs(dp, arr1, n - 1,                                   arr2, m - 1, k));             // calculating LCS with changes made.            ans = Math.Max(ans, 1 +                       lcs(dp, arr1, n - 1,                               arr2, m - 1, k - 1));        } catch (Exception e) { }        return ans;    }     // Driver Code    public static void Main(String[] args)    {        int k = 1;        int[] arr1 = { 1, 2, 3, 4, 5 };        int[] arr2 = { 5, 3, 1, 4, 2 };        int n = arr1.Length;        int m = arr2.Length;         int[,,] dp = new int[MAX, MAX, MAX];        for (int i = 0; i < MAX; i++)            for (int j = 0; j < MAX; j++)                for (int l = 0; l < MAX; l++)                    dp[i, j, l] = -1;         Console.WriteLine(lcs(dp, arr1, n,                                  arr2, m, k));    }} // This code is contributed by PrinciRaj1992
<script> // Javascript program to find LCS of two// arrays with k changes allowed in// first array.let MAX = 10; // Return LCS with at most k changes allowed.function lcs(dp, arr1, n, arr2, m, k){         // If at most changes is less than 0.    if (k < 0)        return -10000000;     // If any of two array is over.    if (n < 0 || m < 0)        return 0;     // Making a reference variable    // to dp[n][m][k]    let ans = dp;     // If value is already calculated,    // return that value.    if (ans != -1)        return ans;     try    {                 // Calculating LCS with no changes made.        ans = Math.max(lcs(dp, arr1, n - 1, arr2, m, k),                       lcs(dp, arr1, n, arr2, m - 1, k));         // Calculating LCS when array element are same.        if (arr1[n - 1] == arr2[m - 1])            ans = Math.max(ans, 1 + lcs(dp, arr1, n - 1,                                            arr2, m - 1, k));         // Calculating LCS with changes made.        ans = Math.max(ans, 1 + lcs(dp, arr1, n - 1,                                        arr2, m - 1, k - 1));    } catch (e) { }    return ans;} // Driver Codelet k = 0;let arr1 = [ 1, 2, 3, 4, 5 ];let arr2 = [ 5, 3, 1, 4, 2 ];let n = arr1.length;let m = arr2.length; let dp = new Array(MAX);for(let i = 0; i < MAX; i++)    for(let j = 0; j < MAX; j++)        for(let l = 0; l < MAX; l++)            dp = -1; document.write(lcs(dp, arr1, n, arr2, m, k)); // This code is contributed by shivanisinghss2110 </script>
Output: 
3
Time Complexity: O(N*M*K).
This article is contributed by Anuj Chauhan. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
rituraj_jain
aryaxoert
sanjeev2552
princiraj1992
shivanisinghss2110
krishnatripathi
LCS
Dynamic Programming
Dynamic Programming
LCS
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Bellman–Ford Algorithm | DP-23
Floyd Warshall Algorithm | DP-16
Subset Sum Problem | DP-25
Matrix Chain Multiplication | DP-8
Longest Palindromic Substring | Set 1
Travelling Salesman Problem | Set 1 (Naive and Dynamic Programming)
Edit Distance | DP-5
Sieve of Eratosthenes
Overlapping Subproblems Property in Dynamic Programming | DP-1
Maximum size square sub-matrix with all 1s