Minimize elements to be added to a given array such that it contains another given array as its subsequence

<script>

// JavaScript program for the above approach

// Function that finds the minimum number
// of the element must be added to make A
// as a subsequence in B
function transformSubsequence(n, m, A, B)
{
    
    // Base Case
    if (B.length == 0)
        return n;

    // dp[i][j] indicates the length of
    // LCS of A of length i & B of length j
    var dp = Array.from(Array(n+1), ()=>Array(m+1).fill(0));

    for(var i = 0; i < n + 1; i++)
    {
        for(var j = 0; j < m + 1; j++)
        {
            
            // If there are no elements
            // either in A or B then the
            // length of lcs is 0
            if (i == 0 || j == 0)
                dp[i][j] = 0;

            // If the element present at
            // ith and jth index of A and B
            // are equal then include in LCS
            else if (A[i - 1] == B[j - 1])
                dp[i][j] = 1 + dp[i - 1][j - 1];

            // If they are not equal then
            // take the max
            else
                dp[i][j] = Math.max(dp[i - 1][j],
                               dp[i][j - 1]);
        }
    }

    // Return difference of length
    // of A and lcs of A and B
    return n - dp[n][m];
}

// Driver Code

var N = 5;
var M = 6;

// Given sequence A and B
var A = [1, 2, 3, 4, 5 ];
var B = [2, 5, 6, 4, 9, 12 ];

// Function call
document.write( transformSubsequence(N, M, A, B));



</script> 

// Define a function that finds the minimum number
// of the element must be added to make A as a subsequence in B
function transformSubsequence(n, m, A, B) {
    // Base Case: if B is an empty list, then all elements of A 
    // need to be added to B to make A a subsequence of B
if (B.length === 0)
    return n;

// Define a dynamic programming array dp of length m+1 
// where dp[j] indicates the length of the longest common subsequence (LCS) 
// of A and B of length j
let dp = new Array(m + 1).fill(0);

// Loop through the elements of A
for(let i = 1; i < n + 1; i++) {
    // Define a variable prev to keep track of the value of dp[j-1] 
    // in the previous iteration
    let prev = dp[0];
    // Loop through the elements of B
    for(let j = 1; j < m + 1; j++) {
        // Define a variable curr to keep track of the value of dp[j] 
        // in the previous iteration
        let curr = dp[j];
        // If the ith element of A is equal to the jth element of B, 
        // include this element in the LCS
        if (A[i - 1] === B[j - 1])
            dp[j] = 1 + prev;
        // If the ith element of A is not equal to the jth element of B, 
        // then take the maximum of dp[j] and dp[j-1] to find the 
        // longest common subsequence so far
        else
            dp[j] = Math.max(dp[j], dp[j - 1]);
        // Update prev with the value of curr for the next iteration
        prev = curr;
    }
}

// Return the difference of the length of A and the LCS of A and B, which is the minimum number of elements that must be added to B to make A a subsequence of B
return n - dp[m];
}

// Test the function with the given input
let N = 5;
let M = 6;

let A = [1, 2, 3, 4, 5];
let B = [2, 5, 6, 4, 9, 12];

console.log(transformSubsequence(N, M, A, B));