# Minimum cost required to rearrange a given array to make it equal to another given array

Given two arrays A[] and B[] consisting of N and M integers respectively, and an integer C, the task is to find the minimum cost required to make the sequence A exactly the same as B(consists of distinct elements only) by performing the following operations on array A[]:

• Remove any element from the array with cost 0.
• Insert a new element anywhere in the array with cost C.

Examples:

Input: A[] = {1, 6, 3, 5, 10}, B[] = {3, 1, 5}, C = 2
Output: 2
Explanation:
Removing elements 1, 6, and 10 from the array costs 0. The array A[] becomes {3, 5}.
Add 1 in between 3 and 5, then the array arr[] becomes {3, 1, 5} which is the same as the array B[].
The cost of above operation is 2.

Input: A[] = {10, 5, 2, 4, 10, 5}, B[] = {5, 1, 2, 10, 4}, C = 3
Output: 6
Explanation:
Removing elements 10, 10, and 5 from the array costs 0. The array A[] becomes {5, 2, 4}.
Add element 1 and 10 in the array as {5, 1, 2, 10, 4} which is the same as the array B[].
The cost of above operation is 3*2 = 6.

Naive Approach: The simplest approach is to erase all the elements from array A[] which are not present in array B[] by using two for loops. After that generate all permutations of the remaining element in the array and for each sequence check for the minimum cost such that the array A[] is the same as the array B[]. Print the minimum cost of the same.

Time Complexity: O(N!*N*M), where N is the size of the array A[] and M is the size of the array B[].
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is to first find the length of the longest common subsequence of array A[] and B[] and subtract it from the size of array B[], which gives the number of elements to be added in array A[]. And add amount C into the cost for every new element added. Therefore, the total cost is given by:

Cost = C*(N – LCS(A, B))
where,
LCS is the longest common subsequence of the arrays A[] and B[],
N is the length of the array A[], and
C is the cost of adding each element in the array B[].

Follow the steps below to solve the problem:

• Create a new array say index[] and initialize it with -1 and an array nums[].
• Map each element of the array B[] to its corresponding index in the array index[].
• Traverse the given array A[] and insert the values with its mapped values i.e., index number into the array nums[] array and if the index number is not -1.
• Now find the Longest Increasing Subsequence of the array nums[] to obtain the length of the longest common subsequence of the two given arrays.
• After finding the LCS in the above steps, find the value of cost using the formula discussed above.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to find length of the` `// longest common subsequence` `int` `findLCS(``int``* nums, ``int` `N)` `{` `    ``int` `k = 0;` `    ``for` `(``int` `i = 0; i < N; i++) {`   `        ``// Find position where element` `        ``// is to be inserted` `        ``int` `pos = lower_bound(nums, nums + k,` `                              ``nums[i])` `                  ``- nums;` `        ``nums[pos] = nums[i];` `        ``if` `(k == pos) {` `            ``k = pos + 1;` `        ``}` `    ``}`   `    ``// Return the length of LCS` `    ``return` `k;` `}`   `// Function to find the minimum cost` `// required to convert the sequence A` `// exactly same as B` `int` `minimumCost(``int``* A, ``int``* B, ``int` `M,` `                ``int` `N, ``int` `C)` `{` `    ``// Auxiliary array` `    ``int` `nums;`   `    ``// Stores positions of elements of A[]` `    ``int` `index;`   `    ``// Initialize index array with -1` `    ``memset``(index, -1, ``sizeof``(index));`   `    ``for` `(``int` `i = 0; i < N; i++) {`   `        ``// Update the index array with` `        ``// index of corresponding` `        ``// elements of B` `        ``index[B[i]] = i;` `    ``}`   `    ``int` `k = 0;`   `    ``for` `(``int` `i = 0; i < M; i++) {`   `        ``// Place only A's array values` `        ``// with its mapped values` `        ``// into nums array` `        ``if` `(index[A[i]] != -1) {` `            ``nums[k++] = index[A[i]];` `        ``}` `    ``}`   `    ``// Find LCS` `    ``int` `lcs_length = findLCS(nums, k);`   `    ``// No of elements to be added` `    ``// in array A[]` `    ``int` `elements_to_be_added` `        ``= N - lcs_length;`   `    ``// Stores minimum cost` `    ``int` `min_cost` `        ``= elements_to_be_added * C;`   `    ``// Print the minimum cost` `    ``cout << min_cost;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given array A[]` `    ``int` `A[] = { 1, 6, 3, 5, 10 };` `    ``int` `B[] = { 3, 1, 5 };`   `    ``// Given C` `    ``int` `C = 2;`   `    ``// Size of arr A` `    ``int` `M = ``sizeof``(A) / ``sizeof``(A);`   `    ``// Size of arr B` `    ``int` `N = ``sizeof``(B) / ``sizeof``(B);`   `    ``// Function Call` `    ``minimumCost(A, B, M, N, C);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach ` `import` `java.io.*;`   `class` `GFG{` `    `  `// Function to find lower_bound` `static` `int` `LowerBound(``int` `a[], ``int` `k,` `                      ``int` `x)` `{ ` `    ``int` `l = -``1``;` `    ``int` `r = k;` `    `  `    ``while` `(l + ``1` `< r) ` `    ``{` `        ``int` `m = (l + r) >>> ``1``;` `        ``if` `(a[m] >= x) ` `        ``{` `            ``r = m;` `        ``}` `        ``else` `        ``{` `            ``l = m;` `        ``}` `    ``}` `    ``return` `r;` `}` `  `  `// Function to find length of the` `// longest common subsequence` `static` `int` `findLCS(``int``[] nums, ``int` `N)` `{` `    ``int` `k = ``0``;` `    ``for``(``int` `i = ``0``; i < N; i++)` `    ``{` `        `  `        ``// Find position where element` `        ``// is to be inserted ` `        ``int` `pos = LowerBound(nums, k,` `                             ``nums[i]);` `        ``nums[pos] = nums[i];` `        ``if` `(k == pos) ` `        ``{` `            ``k = pos + ``1``;` `        ``}` `    ``}` `    `  `    ``// Return the length of LCS` `    ``return` `k;` `}`   `// Function to find the minimum cost` `// required to convert the sequence A` `// exactly same as B` `static` `int`  `minimumCost(``int``[] A, ``int``[] B, ` `                        ``int` `M, ``int` `N, ``int` `C)` `{` `    `  `    ``// Auxiliary array` `    ``int``[] nums = ``new` `int``[``100000``];`   `    ``// Stores positions of elements of A[]` `    ``int``[] index = ``new` `int``[``100000``];`   `    ``// Initialize index array with -1` `    ``for``(``int` `i = ``0``; i < ``100000``; i++)` `        ``index[i] = -``1``;` `        `  `    ``for``(``int` `i = ``0``; i < N; i++)` `    ``{` `        `  `        ``// Update the index array with` `        ``// index of corresponding` `        ``// elements of B` `        ``index[B[i]] = i;` `    ``}`   `    ``int` `k = ``0``;`   `    ``for``(``int` `i = ``0``; i < M; i++)` `    ``{` `        `  `        ``// Place only A's array values` `        ``// with its mapped values` `        ``// into nums array` `        ``if` `(index[A[i]] != -``1``)` `        ``{` `            ``nums[k++] = index[A[i]];` `        ``}` `    ``}`   `    ``// Find LCS` `    ``int` `lcs_length = findLCS(nums, k);`   `    ``// No of elements to be added` `    ``// in array A[]` `    ``int` `elements_to_be_added = N - lcs_length;`   `    ``// Stores minimum cost` `    ``int` `min_cost = elements_to_be_added * C;`   `    ``// Print the minimum cost` `    ``System.out.println( min_cost);` `    ``return` `0``;` `}`   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    `  `    ``// Given array A[]` `    ``int``[] A = { ``1``, ``6``, ``3``, ``5``, ``10` `};` `    ``int``[] B = { ``3``, ``1``, ``5` `};` `    `  `    ``// Given C` `    ``int` `C = ``2``;` `    `  `    ``// Size of arr A` `    ``int` `M = A.length;` `    `  `    ``// Size of arr B` `    ``int` `N = B.length;` `    `  `    ``// Function call` `    ``minimumCost(A, B, M, N, C);` `}` `}`   `// This code is contributed by sallagondaavinashreddy7`

## C#

 `// C# program for the above approach ` `using` `System;` ` `  `class` `GFG{` `     `  `// Function to find lower_bound` `static` `int` `LowerBound(``int``[] a, ``int` `k,` `                      ``int` `x)` `{ ` `    ``int` `l = -1;` `    ``int` `r = k;` `     `  `    ``while` `(l + 1 < r) ` `    ``{` `        ``int` `m = (l + r) >> 1;` `        ``if` `(a[m] >= x) ` `        ``{` `            ``r = m;` `        ``}` `        ``else` `        ``{` `            ``l = m;` `        ``}` `    ``}` `    ``return` `r;` `}` `   `  `// Function to find length of the` `// longest common subsequence` `static` `int` `findLCS(``int``[] nums, ``int` `N)` `{` `    ``int` `k = 0;` `    `  `    ``for``(``int` `i = 0; i < N; i++)` `    ``{` `        `  `        ``// Find position where element` `        ``// is to be inserted ` `        ``int` `pos = LowerBound(nums, k,` `                             ``nums[i]);` `        ``nums[pos] = nums[i];` `        `  `        ``if` `(k == pos) ` `        ``{` `            ``k = pos + 1;` `        ``}` `    ``}` `    `  `    ``// Return the length of LCS` `    ``return` `k;` `}` ` `  `// Function to find the minimum cost` `// required to convert the sequence A` `// exactly same as B` `static` `int`  `minimumCost(``int``[] A, ``int``[] B, ` `                        ``int` `M, ``int` `N, ``int` `C)` `{` `    `  `    ``// Auxiliary array` `    ``int``[] nums = ``new` `int``;` ` `  `    ``// Stores positions of elements of A[]` `    ``int``[] index = ``new` `int``;` ` `  `    ``// Initialize index array with -1` `    ``for``(``int` `i = 0; i < 100000; i++)` `        ``index[i] = -1;` `         `  `    ``for``(``int` `i = 0; i < N; i++)` `    ``{` `         `  `        ``// Update the index array with` `        ``// index of corresponding` `        ``// elements of B` `        ``index[B[i]] = i;` `    ``}` ` `  `    ``int` `k = 0;` ` `  `    ``for``(``int` `i = 0; i < M; i++)` `    ``{` `         `  `        ``// Place only A's array values` `        ``// with its mapped values` `        ``// into nums array` `        ``if` `(index[A[i]] != -1)` `        ``{` `            ``nums[k++] = index[A[i]];` `        ``}` `    ``}` ` `  `    ``// Find LCS` `    ``int` `lcs_length = findLCS(nums, k);` ` `  `    ``// No of elements to be added` `    ``// in array A[]` `    ``int` `elements_to_be_added = N - lcs_length;` ` `  `    ``// Stores minimum cost` `    ``int` `min_cost = elements_to_be_added * C;` ` `  `    ``// Print the minimum cost` `    ``Console.WriteLine(min_cost);` `    ``return` `0;` `}` ` `  `// Driver code` `public` `static` `void` `Main()` `{` `    `  `    ``// Given array A[]` `    ``int``[] A = { 1, 6, 3, 5, 10 };` `    ``int``[] B = { 3, 1, 5 };` `     `  `    ``// Given C` `    ``int` `C = 2;` `     `  `    ``// Size of arr A` `    ``int` `M = A.Length;` `     `  `    ``// Size of arr B` `    ``int` `N = B.Length;` `     `  `    ``// Function call` `    ``minimumCost(A, B, M, N, C);` `}` `}`   `// This code is contributed by code_hunt`

Output:

```2

```

Time Complexity: O(N * Log N)
Auxiliary Space: O(N)

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.