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 

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<Integer> A,
                    Queue<Integer> 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<Integer> A = new LinkedList<Integer>();
    A.add(3);
    A.add(2);
    A.add(1);
    A.add(4);

    // Order in which task need to be
    // executed
    Queue<Integer> B = new LinkedList<Integer>();
    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

<script>

// Javascript program to find the total
// time taken to execute the task
// in given order

// Function to calculate the
// total time taken to execute
// the given task in original order
function run_tasks(A, B)
{
    
    // To find the total time
    // taken for executing
    // the task
    let total_time = 0;
  
    // While A is not empty
    while (A.length != 0)
    {
  
        // Store the front element of
        // queue A and B
        let x = A[0];
        let y = B[0];
  
        // 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.shift();
            B.shift();
            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.shift();
            A.push(x);
            total_time += 2;
        }
    }
  
    // Return the total time taken
    return total_time;
}

// Driver code

// Given task to be executed
let A = [ 3, 2, 1, 4 ];

// Order in which task need to be
// executed
let B = [ 4, 1, 3, 2 ];

// Function the returns the total
// time taken to execute all the task
document.write(run_tasks(A, B));

// This code is contributed by patel2127

</script>
 

14

Time Complexity: O(N²), where N is the number of tasks.
Auxiliary Space: O(1), no extra space is required, so it is a constant.