Given **N** people standing in a queue and two arrays **A[]** and **B[]**. The array A[] represent the name of the person and array B[] represents how many people are taller than a particular person standing in front of that. Now the queue is shuffled. The task is to print the original sequence of the queue following the above property.

**Examples:**

Input:N = 4, A[] = {‘a’, ‘b’, ‘c’, ‘d’}, B[] = {0, 2, 0, 0}

Output:

a 1

c 3

d 4

b 2

Explanation:

Looking at the output queue and their generated heights, it can be easily understood that:

1) a is the first one in the queue and so we have the person with 0th index in front of him. So a is associated with 0 in the input.

2) c has only a in front of him/her but a is shorter than c. Therefore c is associated with 0 in the input.

3) d has c and a in front of him/her but they are both shorter than d . Therefore d is associated with 0 in the input.

4) b has d, c and a in front of b. But only c and d are taller than b. So, b is associated with 2 in the input.

Input:N = 4, A[] = { ‘a’, ‘b’, ‘c’, ‘d’}, B[] = { 0, 1, 3, 3}

Output:-1

Explanation:

The given order is the original order of the queue.

**Approach:**

- Firstly make a pair of the person’s name and their associated integers and sort the pairs.
- Create an array
**answer[]**to store the possible heights of the person. - Iterate over all the pair and if the number of persons standing in front of is taller and is greater than their current standing position, then return
**-1**. - Otherwise, store the difference between the current standing position and the height of the person taller than him, in the answer array.
- For every person iterate over the pair and if the value of the answer array for our current person is
**greater than the person with whom we are comparing**, increment in the answer array for current pair. - Finally, print the possible pairs from the given sequence according to values stored in
**answer[]**array.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to generate the Queue ` `void` `OriginalQueue(` `char` `A[], ` `int` `B[], ` ` ` `int` `N) ` `{ ` ` ` `// Making a pair ` ` ` `pair<` `int` `, string> a[N + 1]; ` ` ` ` ` `// Answer array ` ` ` `int` `ans[N + 1]; ` ` ` `bool` `possible = ` `true` `; ` ` ` ` ` `// Store the values in the pair ` ` ` `for` `(` `int` `i = 0; i < N; i++) { ` ` ` `a[i].second = A[i]; ` ` ` `a[i].first = B[i]; ` ` ` `} ` ` ` ` ` `// Sort the pair ` ` ` `sort(a, a + N); ` ` ` ` ` `// Traverse the pairs ` ` ` `for` `(` `int` `i = 0; i < N; i++) { ` ` ` ` ` `int` `len = i - a[i].first; ` ` ` ` ` `// If it is not possible to ` ` ` `// generate the Queue ` ` ` `if` `(len < 0) { ` ` ` ` ` `cout << ` `"-1"` `; ` ` ` `possible = ` `false` `; ` ` ` `} ` ` ` ` ` `if` `(!possible) ` ` ` `break` `; ` ` ` `else` `{ ` ` ` `ans[i] = len; ` ` ` ` ` `for` `(` `int` `j = 0; j < i; j++) { ` ` ` ` ` `// Increment the answer ` ` ` `if` `(ans[j] >= ans[i]) ` ` ` `ans[j]++; ` ` ` `} ` ` ` `} ` ` ` ` ` `// Finally printing the answer ` ` ` `if` `(i == N - 1 && possible) { ` ` ` `for` `(` `int` `i = 0; i < N; i++) { ` ` ` `cout << a[i].second << ` `" "` ` ` `<< ans[i] + 1 << endl; ` ` ` `} ` ` ` `} ` ` ` `} ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `int` `N = 4; ` ` ` ` ` `// Given name of person as char ` ` ` `char` `A[N] = { ` `'a'` `, ` `'b'` `, ` `'c'` `, ` `'d'` `}; ` ` ` ` ` `// Associated integers ` ` ` `int` `B[N] = { 0, 2, 0, 0 }; ` ` ` ` ` `// Function Call ` ` ` `OriginalQueue(A, B, N); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

a 1 c 3 d 4 b 2

**Time Complexity:** O(N^{2})

**Auxiliary Space:** O(N)

## Recommended Posts:

- Stack and Queue in Python using queue Module
- Check if a queue can be sorted into another queue using a stack
- Check if the given string is shuffled substring of another string
- Reversing a Queue using another Queue
- Generate elements of the array following given conditions
- Check if the Matrix satisfies the given conditions
- Find an integer in the given range that satisfies the given conditions
- Maximum length sub-array which satisfies the given conditions
- Count of numbers in the range [L, R] which satisfy the given conditions
- Number of terms in Geometric Series with given conditions
- Construct a Matrix of size NxN with values in range [1, N^2] as per given conditions
- Find the number of unique pairs satisfying given conditions
- Find the last remaining Character in the Binary String according to the given conditions
- Reversing a Queue
- Queue using Stacks
- Queue in Python
- Generate an array B[] from the given array A[] which satisfies the given conditions
- Breadth First Search without using Queue
- Queue of Pairs in C++ STL with Examples
- Sort the Queue using Recursion

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.