Skip to content
Related Articles
Minimum cost required to rearrange a given array to make it equal to another given array
• Difficulty Level : Medium
• Last Updated : 23 Apr, 2021

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`

## Python3

 `# Python3 program for the above approach` `# Function to find lower_bound``def` `LowerBound(a, k, x):``    ` `    ``l ``=` `-``1``    ``r ``=` `k``     ` `    ``while` `(l ``+` `1` `< r):``        ``m ``=` `(l ``+` `r) >> ``1``        ` `        ``if` `(a[m] >``=` `x):``            ``r ``=` `m``        ``else``:``            ``l ``=` `m``    ` `    ``return` `r``    ` `# Function to find length of the``# longest common subsequence``def` `findLCS(nums, N):` `    ``k ``=` `0``    ``for` `i ``in` `range``(N):``         ` `        ``# Find position where element``        ``# is to be inserted``        ``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``def`  `minimumCost(A, B, M, N, C):``    ` `    ``# Auxiliary array``    ``nums ``=` `[``0``] ``*` `100000`` ` `    ``# Stores positions of elements of A[]``    ``# Initialize index array with -1``    ``index ``=` `[``-``1``] ``*` `100000``         ` `    ``for` `i ``in` `range``(N):``        ` `        ``# Update the index array with``        ``# index of corresponding``        ``# elements of B``        ``index[B[i]] ``=` `i`` ` `    ``k ``=` `0`` ` `    ``for` `i ``in` `range``(M):``        ` `        ``# Place only A's array values``        ``# with its mapped values``        ``# into nums array``        ``if` `(index[A[i]] !``=` `-``1``):``            ``k ``+``=` `1``            ``nums[k] ``=` `index[A[i]]`` ` `    ``# Find LCS``    ``lcs_length ``=` `findLCS(nums, k)`` ` `    ``# No of elements to be added``    ``# in array A[]``    ``elements_to_be_added ``=` `N ``-` `lcs_length`` ` `    ``# Stores minimum cost``    ``min_cost ``=` `elements_to_be_added ``*` `C`` ` `    ``# Print the minimum cost``    ``print``( min_cost)` `# Driver Code` `# Given array A[]``A ``=` `[ ``1``, ``6``, ``3``, ``5``, ``10` `]``B ``=` `[ ``3``, ``1``, ``5` `]`` ` `# Given C``C ``=` `2`` ` `# Size of arr A``M ``=` `len``(A)`` ` `# Size of arr B``N ``=` `len``(B)`` ` `# Function call``minimumCost(A, B, M, N, C)` `# This code is contributed by divyeshrabadiya07`

## 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`

## Javascript

 ``
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up