# Find time taken to execute the tasks in A based on the order of execution in B

Given two queues A and B, each of size N, the task is to find the minimum time taken to execute the tasks in A based on the order of execution in B where:

1. If the task found at the front of queue B is at the front of queue A, then pop this task and execute it.
2. If the task found at the front of queue B is not found at the front of queue A, then pop the current task from queue A and push it at the end.
3. Push and Pop operation in a queue costs one unit of time and the execution of a task is done in constant time.

Example

Input: A = { 3, 2, 1 }, B = { 1, 3, 2 }
Output: 7
Explanation:
For A = 3 and B = 1 => Since the front of queue A does not match with the front of queue B. Pop and Push 3 at the back of Queue. Then, A becomes { 2, 1, 3 } and time consumed = 2 ( 1 unit of time for each push and pop operation)
For A = 2 and B = 1 => Since the front of queue A does not match with the front of queue B. Pop and Push 2 at the back of Queue. Then, A becomes { 1, 3, 2 } and time = 2 + 2 = 4
For A = 1 and B = 1 => Since the front of queue, A equals to front of queue B. Pop 1 from both the queue and execute it, Then A becomes { 3, 2 } and B becomes { 3, 2 } and time = 4 + 1 = 5
For A = 3 and B = 3 => Since the front of queue, A equals to front of queue B. Pop 3 from both the queue and execute it, Then A becomes { 2 } and B becomes { 2 } and time = 5 + 1 = 6
For A = 2 and B = 2 => Since the front of the queue, A equals to front of queue B. Pop 2 from both the queue and execute it. All the tasks are executed. time = 6 + 1 = 7
Therefore the total time is 7.

Input: A = { 3, 2, 1, 4 }, B = { 4, 1, 3, 2 }
Output: 14

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:
For each task in queue A:

1. If the front task of queue A is the same as the front task of queue B. Pop the task from both the queues and execute it. Increment the total time by one unit.
2. If the front task of queue A is not the same as the front task of queue B. Pop the task from queue A and push it at the back of queue A and increment the total time by two units. (1 for pop operation and 1 for push operation)
3. Repeat the above steps till all the task in queue A is executed.

Below is the implementation of the above approach:

 `// C++ program to find the total ` `// time taken to execute the task ` `// in given order ` ` `  `#include "bits/stdc++.h" ` `using` `namespace` `std; ` ` `  `// Function to calculate the ` `// total time taken to execute ` `// the given task in original order ` `int` `run_tasks(queue<``int``>& A, ` `              ``queue<``int``>& B) ` `{ ` ` `  `    ``// To find the total time ` `    ``// taken for executing ` `    ``// the task ` `    ``int` `total_time = 0; ` ` `  `    ``// While A is not empty ` `    ``while` `(!A.empty()) { ` ` `  `        ``// Store the front element of queue A and B ` `        ``int` `x = A.front(); ` `        ``int` `y = B.front(); ` ` `  `        ``// If the front element of the queue A ` `        ``// is equal to the front element of queue B ` `        ``// then pop the element from both ` `        ``// the queues and execute the task ` `        ``// Increment total_time by 1 ` `        ``if` `(x == y) { ` `            ``A.pop(); ` `            ``B.pop(); ` `            ``total_time++; ` `        ``} ` ` `  `        ``// If front element of queue A is not equal ` `        ``// to front element of queue B then ` `        ``// pop the element from queue A & ` `        ``// push it at the back of queue A ` `        ``// Increment the total_time by 2 ` `        ``//(1 for push operation and ` `        ``// 1 for pop operation) ` `        ``else` `{ ` `            ``A.pop(); ` `            ``A.push(x); ` `            ``total_time += 2; ` `        ``} ` `    ``} ` ` `  `    ``// Return the total time taken ` `    ``return` `total_time; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``// Given task to be executed ` `    ``queue<``int``> A; ` `    ``A.push(3); ` `    ``A.push(2); ` `    ``A.push(1); ` `    ``A.push(4); ` ` `  `    ``// Order in which task need to be ` `    ``// executed ` `    ``queue<``int``> B; ` `    ``B.push(4); ` `    ``B.push(1); ` `    ``B.push(3); ` `    ``B.push(2); ` ` `  `    ``// Function the returns the total ` `    ``// time taken to execute all the task ` `    ``cout << run_tasks(A, B); ` ` `  `    ``return` `0; ` `} `

 `// Java program to find the total ` `// time taken to execute the task ` `// in given order ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` ` `  `// Function to calculate the ` `// total time taken to execute ` `// the given task in original order ` `static` `int` `run_tasks(Queue A, ` `                    ``Queue B) ` `{ ` ` `  `    ``// To find the total time ` `    ``// taken for executing ` `    ``// the task ` `    ``int` `total_time = ``0``; ` ` `  `    ``// While A is not empty ` `    ``while` `(!A.isEmpty()) ` `    ``{ ` ` `  `        ``// Store the front element of queue A and B ` `        ``int` `x = A.peek(); ` `        ``int` `y = B.peek(); ` ` `  `        ``// If the front element of the queue A ` `        ``// is equal to the front element of queue B ` `        ``// then pop the element from both ` `        ``// the queues and execute the task ` `        ``// Increment total_time by 1 ` `        ``if` `(x == y)  ` `        ``{ ` `            ``A.remove(); ` `            ``B.remove(); ` `            ``total_time++; ` `        ``} ` ` `  `        ``// If front element of queue A is not equal ` `        ``// to front element of queue B then ` `        ``// pop the element from queue A & ` `        ``// push it at the back of queue A ` `        ``// Increment the total_time by 2 ` `        ``//(1 for push operation and ` `        ``// 1 for pop operation) ` `        ``else` `        ``{ ` `            ``A.remove(); ` `            ``A.add(x); ` `            ``total_time += ``2``; ` `        ``} ` `    ``} ` ` `  `    ``// Return the total time taken ` `    ``return` `total_time; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``// Given task to be executed ` `    ``Queue A = ``new` `LinkedList(); ` `    ``A.add(``3``); ` `    ``A.add(``2``); ` `    ``A.add(``1``); ` `    ``A.add(``4``); ` ` `  `    ``// Order in which task need to be ` `    ``// executed ` `    ``Queue B = ``new` `LinkedList(); ` `    ``B.add(``4``); ` `    ``B.add(``1``); ` `    ``B.add(``3``); ` `    ``B.add(``2``); ` ` `  `    ``// Function the returns the total ` `    ``// time taken to execute all the task ` `    ``System.out.print(run_tasks(A, B)); ` ` `  `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

 `# Python3 program to find the total ` `# time taken to execute the task ` `# in given order ` `from` `collections ``import` `deque ` ` `  `# Function to calculate the ` `# total time taken to execute ` `# the given task in original order ` `def` `run_tasks(A, B): ` ` `  `    ``# To find the total time ` `    ``# taken for executing ` `    ``# the task ` `    ``total_time ``=` `0` ` `  `    ``# While A is not empty ` `    ``while` `(``len``(A) > ``0``): ` ` `  `        ``# Store the front element of queue A and B ` `        ``x ``=` `A.popleft() ` `        ``y ``=` `B.popleft() ` ` `  `        ``# If the front element of the queue A ` `        ``# is equal to the front element of queue B ` `        ``# then pop the element from both ` `        ``# the queues and execute the task ` `        ``# Increment total_time by 1 ` `        ``if` `(x ``=``=` `y): ` `            ``total_time ``+``=` `1` ` `  `        ``# If front element of queue A is not equal ` `        ``# to front element of queue B then ` `        ``# pop the element from queue A & ` `        ``# append it at the back of queue A ` `        ``# Increment the total_time by 2 ` `        ``#(1 for append operation and ` `        ``# 1 for pop operation) ` `        ``else``: ` `            ``B.appendleft(y) ` `            ``A.append(x) ` `            ``total_time ``+``=` `2` ` `  `    ``# Return the total time taken ` `    ``return` `total_time ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` ` `  `    ``# Given task to be executed ` `    ``A ``=` `deque() ` `    ``A.append(``3``) ` `    ``A.append(``2``) ` `    ``A.append(``1``) ` `    ``A.append(``4``) ` ` `  `    ``# Order in which task need to be ` `    ``# executed ` `    ``B ``=` `deque() ` `    ``B.append(``4``) ` `    ``B.append(``1``) ` `    ``B.append(``3``) ` `    ``B.append(``2``) ` ` `  `    ``# Function the returns the total ` `    ``# time taken to execute all the task ` `    ``print``(run_tasks(A, B)) ` ` `  `# This code is contributed by mohit kumar 29 `

 `// C# program to find the total ` `// time taken to execute the task ` `// in given order ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG ` `{ ` ` `  `// Function to calculate the ` `// total time taken to execute ` `// the given task in original order ` `static` `int` `run_tasks(Queue<``int``> A, ` `                    ``Queue<``int``> B) ` `{ ` ` `  `    ``// To find the total time ` `    ``// taken for executing ` `    ``// the task ` `    ``int` `total_time = 0; ` ` `  `    ``// While A is not empty ` `    ``while` `(A.Count != 0) ` `    ``{ ` ` `  `        ``// Store the front element of queue A and B ` `        ``int` `x = A.Peek(); ` `        ``int` `y = B.Peek(); ` ` `  `        ``// If the front element of the queue A ` `        ``// is equal to the front element of queue B ` `        ``// then pop the element from both ` `        ``// the queues and execute the task ` `        ``// Increment total_time by 1 ` `        ``if` `(x == y)  ` `        ``{ ` `            ``A.Dequeue(); ` `            ``B.Dequeue(); ` `            ``total_time++; ` `        ``} ` ` `  `        ``// If front element of queue A is not equal ` `        ``// to front element of queue B then ` `        ``// pop the element from queue A & ` `        ``// push it at the back of queue A ` `        ``// Increment the total_time by 2 ` `        ``//(1 for push operation and ` `        ``// 1 for pop operation) ` `        ``else` `        ``{ ` `            ``A.Dequeue(); ` `            ``A.Enqueue(x); ` `            ``total_time += 2; ` `        ``} ` `    ``} ` ` `  `    ``// Return the total time taken ` `    ``return` `total_time; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``// Given task to be executed ` `    ``Queue<``int``> A = ``new` `Queue<``int``>(); ` `    ``A.Enqueue(3); ` `    ``A.Enqueue(2); ` `    ``A.Enqueue(1); ` `    ``A.Enqueue(4); ` ` `  `    ``// Order in which task need to be ` `    ``// executed ` `    ``Queue<``int``> B = ``new` `Queue<``int``>(); ` `    ``B.Enqueue(4); ` `    ``B.Enqueue(1); ` `    ``B.Enqueue(3); ` `    ``B.Enqueue(2); ` ` `  `    ``// Function the returns the total ` `    ``// time taken to execute all the task ` `    ``Console.Write(run_tasks(A, B)); ` `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

Output:
```14
```

Time Complexity: O(N2), where N is the number of tasks.

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.

A computer Science ug student from lnmiit Interested in learning and sharing algorithmic knowledge Found near online Judges and food

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.

Improved By : princiraj1992, mohit kumar 29