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 2Explanation:

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:-1Explanation:

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*

## Java

`// Java program for the above approach ` `import` `java.util.*; ` `import` `java.io.*; ` ` ` `class` `GFG{ ` ` ` `// Function to generate the Queue ` `static` `void` `OriginalQueue(` `char` `A[], ` `int` `B[], ` ` ` `int` `N) ` `{ ` ` ` `// Making a pair ` ` ` `int` `[][] a = ` `new` `int` `[N][` `2` `]; ` ` ` ` ` `// Answer array ` ` ` `int` `[] ans = ` `new` `int` `[N]; ` ` ` `boolean` `possible = ` `true` `; ` ` ` ` ` `// Store the values in the pair ` ` ` `for` `(` `int` `i = ` `0` `; i < N; i++) ` ` ` `{ ` ` ` `a[i][` `0` `] = B[i]; ` ` ` `a[i][` `1` `] = (` `int` `)A[i]; ` ` ` `} ` ` ` ` ` `// Sort the pair ` ` ` `Arrays.sort(a, (o1, o2) -> o1[` `0` `] - o2[` `0` `]); ` ` ` ` ` `// Traverse the pairs ` ` ` `for` `(` `int` `i = ` `0` `; i < N; i++) ` ` ` `{ ` ` ` `int` `len = i - a[i][` `0` `]; ` ` ` ` ` `// If it is not possible to ` ` ` `// generate the Queue ` ` ` `if` `(len < ` `0` `) ` ` ` `{ ` ` ` `System.out.print(` `"-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` `k = ` `0` `; k < N; k++) ` ` ` `{ ` ` ` `System.out.println((` `char` `)a[k][` `1` `] + ` ` ` `" "` `+ (ans[k] + ` `1` `)); ` ` ` `} ` ` ` `} ` ` ` `} ` `} ` ` ` `// Driver Code ` `public` `static` `void` `main (String[] args) ` `{ ` ` ` `int` `N = ` `4` `; ` ` ` ` ` `// Given name of person as char ` ` ` `char` `A[] = { ` `'a'` `, ` `'b'` `, ` `'c'` `, ` `'d'` `}; ` ` ` ` ` `// Associated integers ` ` ` `int` `B[] = { ` `0` `, ` `2` `, ` `0` `, ` `0` `}; ` ` ` ` ` `// Function Call ` ` ` `OriginalQueue(A, B, N); ` `} ` `} ` ` ` `// This code is contributed by offbeat ` |

*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
- Reversing a Queue using another Queue
- Difference between Circular Queue and Priority Queue
- Count of numbers in the range [L, R] which satisfy the given conditions
- Find the last remaining Character in the Binary String according to the given conditions
- Queue using Stacks
- Applications of Queue Data Structure
- Find the largest multiple of 3 | Set 1 (Using Queue)
- Queue Interface In Java
- Implement a stack using single queue
- Circular Queue | Set 1 (Introduction and Array Implementation)
- Circular Queue | Set 2 (Circular Linked List Implementation)
- Queue - Linked List Implementation
- Queue | Set 1 (Introduction and Array Implementation)
- Priority Queue | Set 1 (Introduction)
- Applications of Priority Queue
- Queue based approach for first non-repeating character in a stream
- Reversing the first K elements of a Queue
- Reversing a Queue

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.