Minimize operations to delete all elements of permutation A by removing a subsequence having order as array B

• Last Updated : 24 Oct, 2021

Given two permutation arrays A[] and B[] of the first N Natural Numbers, the task is to find the minimum number of operations required to remove all array elements A[] such that in each operation remove the subsequence of array elements A[] whose order is the same as in the array B[].

Example:

Input: A[] = { 4, 2, 1, 3 }, B[] = { 1, 3, 2, 4 }
Output: 3
Explanation:
The given example can be solved by following the given steps:

1. During the 1st operation, integers at index 2 and 3 in the array A[] can be deleted. Hence, the array A[] = {4, 2}.
2. During the 2st operation, integer at index 1 in the array A[] can be deleted. Hence, the array A[] = {4}.
3. During the 3rd operation, integer at index 0 in the array A[] can be deleted. Hence, the array A[] = {}.

The order in which the elements are deleted is {1, 3, 2, 4} which is equal to B. Hence a minimum of 3 operations is required.

Input: A[] = {2, 4, 6, 1, 5, 3}, B[] = {6, 5, 4, 2, 3, 1}
Output: 4

Approach: The given problem can be solved using the steps discussed below:

1. Create two variables i and j, where i keeps track of the index of the current element of B that is to be deleted next and j keeps track of the current element of A. Initially, both i=0 and j=0.
2. Traverse the permutation array A[] using j for all values of j in range [0, N-1]. If A[j] = B[i], increment the value of i by 1 and continue traversing the array A[].
3. After the array A[] has been traversed completely, increment the value of cnt variable which maintains the count of required operations.
4. Repeat steps 2 and 3 till i<N.
5. After completing the above steps, the value stored in cnt is the required answer.

Below is the implementation of the above approach:

C++

 // C++ program for the above approach #include using namespace std;   // Function to find the minimum number of // operations to delete all elements of // permutation A in order described by B int minOperations(int A[], int B[], int N) {     // Stores the count of operations     int cnt = 0;       // Stores the index of current integer     // in B to be deleted     int i = 0;       // Loop to iterate over all values of B     while (i < N) {           // Stores the current index in A         int j = 0;           // Iterate over all values A         while (j < N && i < N) {               // If current integer of B and A             // equal, increment the index of             // the current integer of B             if (B[i] == A[j]) {                 i++;             }             j++;         }           // As the permutation A has been         // traversed completelly, increment         // the count of operations by 1         cnt++;     }       // Return Answer     return cnt; }   // Driver Code int main() {     int A[] = { 2, 4, 6, 1, 5, 3 };     int B[] = { 6, 5, 4, 2, 3, 1 };     int N = sizeof(A) / sizeof(A);       cout << minOperations(A, B, N);       return 0; }

Java

 // Java program for the above approach import java.util.*;   class GFG{   // Function to find the minimum number of // operations to delete all elements of // permutation A in order described by B static int minOperations(int A[], int B[], int N) {         // Stores the count of operations     int cnt = 0;       // Stores the index of current integer     // in B to be deleted     int i = 0;       // Loop to iterate over all values of B     while (i < N) {           // Stores the current index in A         int j = 0;           // Iterate over all values A         while (j < N && i < N) {               // If current integer of B and A             // equal, increment the index of             // the current integer of B             if (B[i] == A[j]) {                 i++;             }             j++;         }           // As the permutation A has been         // traversed completely, increment         // the count of operations by 1         cnt++;     }       // Return Answer     return cnt; }   // Driver Code public static void main(String[] args) {     int A[] = { 2, 4, 6, 1, 5, 3 };     int B[] = { 6, 5, 4, 2, 3, 1 };     int N = A.length;       System.out.print(minOperations(A, B, N));   } }   // This code is contributed by 29AjayKumar

Python3

 # Python 3 program for the above approach   # Function to find the minimum number of # operations to delete all elements of # permutation A in order described by B def minOperations(A, B, N):         # Stores the count of operations     cnt = 0       # Stores the index of current integer     # in B to be deleted     i = 0       # Loop to iterate over all values of B     while(i < N):                 # Stores the current index in A         j = 0           # Iterate over all values A         while (j < N and i < N):               # If current integer of B and A             # equal, increment the index of             # the current integer of B             if (B[i] == A[j]):                 i += 1             j += 1           # As the permutation A has been         # traversed completely, increment         # the count of operations by 1         cnt += 1       # Return Answer     return cnt   # Driver Code if __name__ == '__main__':     A = [2, 4, 6, 1, 5, 3]     B = [6, 5, 4, 2, 3, 1]     N = len(A)       print(minOperations(A, B, N))       # This code is contributed by SURENDRA_GANGWAR.

C#

 // C# program for the above approach using System;   class GFG {       // Function to find the minimum number of     // operations to delete all elements of     // permutation A in order described by B     static int minOperations(int[] A, int[] B, int N)     {           // Stores the count of operations         int cnt = 0;           // Stores the index of current integer         // in B to be deleted         int i = 0;           // Loop to iterate over all values of B         while (i < N) {               // Stores the current index in A             int j = 0;               // Iterate over all values A             while (j < N && i < N) {                   // If current integer of B and A                 // equal, increment the index of                 // the current integer of B                 if (B[i] == A[j]) {                     i++;                 }                 j++;             }               // As the permutation A has been             // traversed completely, increment             // the count of operations by 1             cnt++;         }           // Return Answer         return cnt;     }       // Driver Code     public static void Main(string[] args)     {         int[] A = { 2, 4, 6, 1, 5, 3 };         int[] B = { 6, 5, 4, 2, 3, 1 };         int N = A.Length;           Console.WriteLine(minOperations(A, B, N));     } }   // This code is contributed by ukasp.

Javascript



Output:

4

Time Complexity: O(N2)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :