11-散列4 Hashing - Hard Version (30 分)

11-散列4 Hashing - Hard Version (30 分)

Given a hash table of size N, we can define a hash function H(x)=x%N. 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 (≤1000), 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

Note

1. 利用有向边确定元素的先后关系， 转换问题为拓扑排序（每次输出的值必须是最小）， 利用临界矩阵存储有向边，套用拓扑排序， 把队列改为map<int, int> 利用其自动排序的功能
2. 最后一点超时， 可以考虑用堆优化

Code

#include<iostream>
#include<map>
using namespace std;
#define MAX 10000
int a[MAX][MAX], degree[MAX],  Hash[MAX], visited[MAX];
int main(){
    int num, cnt = 0;
    cin >> num;
    for(int i = 0; i < num; i++) {
        for(int j = 0; j < num; j++){
            a[i][j] = 0;
        }
        degree[i] = 0;
        visited[i] = 0;
    }
    for(int i = 0; i < num; i++){
        cin >> Hash[i];
    }
    for(int i = 0; i < num; i++){
        if(Hash[i] >= 0 && Hash[i] % num != i){
            int probe = Hash[i] % num;
            while(Hash[probe] != Hash[i]){
                a[probe][i] = 1;
                degree[i]++;
                probe = (probe + 1) % num;
            }
        }
        else if(Hash[i] < 0) degree[i] = -1;
    }
    map <int, int> m;
    int flag = 0;
    for(int i = 0; i < num; i++){
        if(degree[i] == 0) {
            cnt++;
            m[Hash[i]] = i;
        }
    }
    while(cnt > 0){    //map is not empty
        int temp;
        for(auto it = m.begin(); it != m.end(); it++){
            if(visited[it->first] == 0){
                temp = it->second;
                if(flag == 0) { cout << Hash[temp]; flag = 1;}
                else cout << " " << Hash[temp];
                visited[it->first] = 1;
                cnt--;
				break;
            }
        }
        for(int i = 0; i < num; i++){
            if(a[temp][i] > 0){
                degree[i]--;
                if(degree[i] == 0){
                    cnt++;
                    m[Hash[i]] = i;
                }
            }
        }
    }
    return 0;
}

Note2

1. 利用优先队列（堆）存要删除的节点， 求各节点的临边和度的地方优化， 利用vector存储

Code

#include<iostream>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;
int Hash[1010];
struct cmp {
    bool operator()(int i, int j) {
        return Hash[i] > Hash[j];
    }
};
int main(){
    int num;
    cin >> num;
    vector<int> degree(num);
    vector<vector<int>> a(num);
    priority_queue<int, vector<int>, cmp> q;
    for(int i = 0; i < num; i++){
        cin >> Hash[i];
    }   
    for(int i = 0; i < num; i++){
        if(Hash[i] > 0){
            int probe = Hash[i] % num;
            degree[i] = (num + i - probe) % num; //?
            if(degree[i]){
                for(int j = 0; j <= degree[i]; j++){
                    a[(probe + j) % num].push_back(i);
                }
            }
            else q.push(i);
        }
    }
    int flag = 0;
    while(!q.empty()){
        int temp = q.top();
        q.pop();
        if(flag == 0){ flag = 1; cout << Hash[temp]; }
        else cout << " " << Hash[temp];
        for(int j = 0; j < a[temp].size(); j++){
            if(--degree[a[temp][j]] == 0){
                q.push(a[temp][j]);
            }
        }
    }
    return 0;
}