根据给定的条件还原经过改组的队列

给定N个人排队等候，并且有两个数组A []和B [] 。数组A []代表人物的名字，数组B []代表比站立在前面的特定人物高的人数。现在，队列被打乱了。任务是在上述属性之后打印队列的原始序列。

例子：

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.

方法：

• 首先，将人的名字及其相关的整数配对，然后对它们进行排序。
• 创建一个数组answer []来存储人的可能身高。
• 遍历所有对，如果站在前面的人数更高并且大于其当前的站立位置，则返回-1 。
• 否则，在答案数组中存储当前站立位置和比他高的人的身高之间的差。
• 对于每个人在该对上进行迭代，并且如果当前人的答案数组的值大于我们正在与之比较的人，则对当前人的答案数组进行递增。
• 最后，根据存储在answer []数组中的值，从给定序列中打印可能的对。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Function to generate the Queue
void OriginalQueue(char A[], int B[],
                   int N)
{
    // Making a pair
    pair 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;
}

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

Python3

# Python3 program for the above approach
 
# Function to generate the Queue
def OriginalQueue(A, B, N):
     
    # Making a pair
    a = [[0, ""] for i in range(N)]
 
    # Answer array
    ans = [0 for i in range(N)]
    possible = True
 
    # Store the values in the pair
    for i in range(N):
        a[i][1] = str(A[i])
        a[i][0] = B[i]
 
    # Sort the pair
    a.sort(reverse = False)
 
    # Traverse the pairs
    for i in range(N):
        len1 = i - a[i][0]
 
        # If it is not possible to
        # generate the Queue
        if (len1 < 0):
            print("-1",end = "")
            possible = False
 
        if (possible == False):
            break
        else:
            ans[i] = len1
 
            for j in range(i):
                 
                # Increment the answer
                if (ans[j] >= ans[i]):
                    ans[j] += 1
 
        # Finally printing the answer
        if (i == N - 1 and possible):
            for i in range(N):
                print(a[i][1], ans[i] + 1)
 
# Driver Code
if __name__ == '__main__':
     
    N = 4
 
    # Given name of person as char
    A = [ 'a', 'b', 'c', 'd' ]
 
    # Associated integers
    B = [ 0, 2, 0, 0 ]
 
    # Function Call
    OriginalQueue(A, B, N)
 
# This code is contributed by ipg2016107

输出：

a 1
c 3
d 4
b 2

时间复杂度： O(N ² )
辅助空间： O(N)

如果您希望与行业专家一起参加现场课程，请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。