11-散列4 Hashing - Hard Version （30 分）

Given a hash table of size N, we can define a hash function (. Suppose that the linear probing is used to solve collisions, we can easily obtain the status of the hash table with a given sequence of input numbers.

However, now you are asked to solve the reversed problem: reconstruct the input sequence from the given status of the hash table. Whenever there are multiple choices, the smallest number is always taken.

Input Specification:

Each input file contains one test case. For each test case, the first line contains a positive integer N (≤), which is the size of the hash table. The next line contains N integers, separated by a space. A negative integer represents an empty cell in the hash table. It is guaranteed that all the non-negative integers are distinct in the table.

Output Specification:

For each test case, print a line that contains the input sequence, with the numbers separated by a space. Notice that there must be no extra space at the end of each line.

Sample Input:

11
33 1 13 12 34 38 27 22 32 -1 21

Sample Output:

1 13 12 21 33 34 38 27 22 32

//参考
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int N = ;
int num[N], indegree[N];
struct cmp {
    bool operator()(int i, int j) {
        return num[i] > num[j];
    }
};
int main() {
    int i, j, n, m, k, flag = ;
    scanf("%d", &n);
    vector<vector<int> > g(n);
    priority_queue<int, vector<int>, cmp> q;
    for (i = ; i < n; i++)
        scanf("%d", &num[i]);

    for (i = ; i < n; i++) {
        if (num[i] > ) {
            k = num[i] % n;
            indegree[i] = (i + n - k) % n;
            if (indegree[i]) {
                for (j = ; j <= indegree[i]; j++)
                    g[(k + j) % n].push_back(i);
            }
            else q.push(i);
        }
    }

    while (!q.empty()) {
        i = q.top();
        q.pop();
        if (!flag) {
            flag = ;
            printf("%d", num[i]);
        }
        else printf(" %d", num[i]);
        for (j = ; j < g[i].size(); j++) {
            if (--indegree[g[i][j]] == )
                q.push(g[i][j]);
        }
    }
    return ;

}