Given an array **A[]** consisting of **N** distinct integers and another array **B[]** consisting of **M** integers, the task is to find the minimum number of elements to be added to the array **B[]** such that the array **A[]** becomes the subsequence of the array **B[]**.

**Examples:**

Input:N = 5, M = 6, A[] = {1, 2, 3, 4, 5}, B[] = {2, 5, 6, 4, 9, 12}Output:3Explanation:

Below are the element that are needed to be added:

1) Add 1 before element 2 of B[]

2) Add 3 after element 6 of B[]

3) Add 5 in the last position of B[].

Therefore, the resulting array B[] is {1, 2, 5, 6, 3, 4, 9, 12, 5}.

Hence, A[] is the subsequence of B[] after adding 3 elements.

Input:N = 5, M = 5, A[] = {3, 4, 5, 2, 7}, B[] = {3, 4, 7, 9, 2}Output:2Explanation:

Below are the elements that are needed to be added:

1) Add 5 after element 4.

2) Add 2 after element 5.

Therefore, the resulting array B[] is {3, 4, 5, 2, 7, 9, 2}.

Hence 2 elements are required to be added.

**Naive Approach:** The naive approach is to generate all the subsequences of the array **B** and then find that subsequence such that on adding a minimum number of elements from the array **A** to make it equal to the array **A**. Print the minimum count of element added.**Time Complexity:** O(N*2^{M})**Auxiliary Space:** O(M+N)

**Efficient Approach:** The above approach can be optimized using Dynamic Programming. The idea is to find the Longest Common Subsequence between the given two arrays **A** and **B**. The main observation is that the minimum number of elements to be added in **B[] **such that** A[]** becomes its subsequence can be found by subtracting the length of the longest common subsequence from the length of the array **A[]**.

Therefore, the difference between the length of the array **A[]** and length of the Longest Common Subsequence is the required result.

Below is the implementation of the above approach:

## C++14

`// C++14 program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function that finds the minimum number` `// of the element must be added to make A` `// as a subsequence in B` `int` `transformSubsequence(` `int` `n, ` `int` `m,` ` ` `vector<` `int` `> A,` ` ` `vector<` `int` `> B)` `{` ` ` ` ` `// Base Case` ` ` `if` `(B.size() == 0)` ` ` `return` `n;` ` ` `// dp[i][j] indicates the length of` ` ` `// LCS of A of length i & B of length j` ` ` `vector<vector<` `int` `>> dp(n + 1,` ` ` `vector<` `int` `>(m + 1, 0));` ` ` `for` `(` `int` `i = 0; i < n + 1; i++)` ` ` `{` ` ` `for` `(` `int` `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 or 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] = 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` `int` `main()` `{` ` ` `int` `N = 5;` ` ` `int` `M = 6;` ` ` `// Given sequence A and B` ` ` `vector<` `int` `> A = { 1, 2, 3, 4, 5 };` ` ` `vector<` `int` `> B = { 2, 5, 6, 4, 9, 12 };` ` ` `// Function call` ` ` `cout << transformSubsequence(N, M, A, B);` ` ` `return` `0;` `}` `// This code is contributed by mohit kumar 29` |

## Java

`// Java program for` `// the above approach` `import` `java.util.*;` `class` `GFG{` `// Function that finds the minimum number` `// of the element must be added to make A` `// as a subsequence in B` `static` `int` `transformSubsequence(` `int` `n, ` `int` `m,` ` ` `int` `[]A, ` `int` `[]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` ` ` `int` `[][]dp = ` `new` `int` `[n + ` `1` `][m + ` `1` `];` ` ` `for` `(` `int` `i = ` `0` `; i < n + ` `1` `; i++)` ` ` `{` ` ` `for` `(` `int` `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` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `N = ` `5` `;` ` ` `int` `M = ` `6` `;` ` ` `// Given sequence A and B` ` ` `int` `[]A = {` `1` `, ` `2` `, ` `3` `, ` `4` `, ` `5` `};` ` ` `int` `[]B = {` `2` `, ` `5` `, ` `6` `, ` `4` `, ` `9` `, ` `12` `};` ` ` `// Function call` ` ` `System.out.print(transformSubsequence(N, M, A, B));` `}` `}` `// This code is contributed by 29AjayKumar` |

## Python3

`# Python3 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` `def` `transformSubsequence(n, m, A, B):` ` ` `# Base Case` ` ` `if` `B ` `is` `None` `or` `len` `(B) ` `=` `=` `0` `:` ` ` `return` `n` ` ` `# dp[i][j] indicates the length of` ` ` `# LCS of A of length i & B of length j` ` ` `dp ` `=` `[[` `0` `for` `col ` `in` `range` `(m ` `+` `1` `)]` ` ` `for` `row ` `in` `range` `(n ` `+` `1` `)]` ` ` `for` `i ` `in` `range` `(n ` `+` `1` `):` ` ` `for` `j ` `in` `range` `(m ` `+` `1` `):` ` ` `# If there are no elements` ` ` `# either in A or B then the` ` ` `# length of lcs is 0` ` ` `if` `i ` `=` `=` `0` `or` `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` ` ` `elif` `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] ` `=` `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` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `N ` `=` `5` ` ` `M ` `=` `6` ` ` ` ` `# Given Sequence A and B` ` ` `A ` `=` `[` `1` `, ` `2` `, ` `3` `, ` `4` `, ` `5` `]` ` ` `B ` `=` `[` `2` `, ` `5` `, ` `6` `, ` `4` `, ` `9` `, ` `12` `]` ` ` `# Function Call` ` ` `print` `(transformSubsequence(N, M, A, B))` |

## C#

`// C# program for` `// the above approach` `using` `System;` `class` `GFG{` `// Function that finds the minimum number` `// of the element must be added to make A` `// as a subsequence in B` `static` `int` `transformSubsequence(` `int` `n, ` `int` `m,` ` ` `int` `[]A, ` `int` `[]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` ` ` `int` `[,]dp = ` `new` `int` `[n + 1, m + 1];` ` ` `for` `(` `int` `i = 0; i < n + 1; i++)` ` ` `{` ` ` `for` `(` `int` `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` `public` `static` `void` `Main(String[] args)` `{` ` ` `int` `N = 5;` ` ` `int` `M = 6;` ` ` `// Given sequence A and B` ` ` `int` `[]A = {1, 2, 3, 4, 5};` ` ` `int` `[]B = {2, 5, 6, 4, 9, 12};` ` ` `// Function call` ` ` `Console.Write(transformSubsequence(N, M,` ` ` `A, B));` `}` `}` `// This code is contributed by Rajput-Ji` |

**Output:**

3

**Time Complexity:** O(M*M), where N and M are the lengths of array A[] and B[] respectively.**Auxiliary Space:** O(M*N)