pat09-散列3. Hashing

09-散列3. Hashing - Hard Version (30)

时间限制

200 ms

内存限制

65536 kB

代码长度限制

8000 B

判题程序

Standard

作者

HE, Qinming

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

---

提交代码

主要思路：

哈希表规模为n。对于输入的位置编号为i的元素a，如果：

1.i==a%n。说明a放i位置不是由于冲突，将a放入优先队列。

2.i>a%n。如果编号为a%n到n-1的元素之前已经填入哈希表(h1[j].exist=true)，则第i个元素可以进入优先队列。否则，如果编号为a%n到n-1的元素在位置编号为i的元素填入之后填入哈希表，意味着位置编号为i的元素插入哈希表时，发生冲突向后转移不可能到达位置i，而应该在i位置之前填入，矛盾。

3.i<a%n。与2同理。

#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
struct node{
    bool exist;
    node(){
        exist=false;
    }
};
node h1[1005];
priority_queue< pair<int,int>,vector<pair<int ,int> >,greater<pair<int,int> > > pq;//记录值和放的位置，按pair的第一个元素升序排列
pair<int,bool> input[1005];//标记元素有没有进入队列
queue<int> q;
int main(){
    //freopen("D:\INPUT.txt","r",stdin);
    int n,num,i,count=0;
    scanf("%d",&n);
    for(i=0;i<n;i++){
        scanf("%d",&num);
        input[i]=make_pair(num,false);
        if(num>=0){//记录不等于负数的元素个数
            count++;
        }
    }
    int j,k,post;
    for(i=0;i<count;i++){//复杂度n^2：扫数列count次，每次将当前满足条件的最小元素进入队列q
        for(j=0;j<n;j++){//遍历数列的每个元素
            if(!input[j].second&&input[j].first>=0){//寻找没有进入队列并且不等于-1的元素
                post=input[j].first%n;//元素本来应该在哈希表中的位置
                if(post==j){//本来要放的位置和现在在哈希表中的位置相同
                    pq.push(make_pair(input[j].first,j));
                    //h1[post].exist=true;//标记
                    input[j].second=true;
                    continue;
                }
                if(post<j){//本来要放的位置在现在的位置前面
                    for(k=post;k<j;k++){
                        if(!h1[k].exist){//前面没有元素填充
                            break;
                        }
                    }
                    if(k==j){//可以进队pq
                        pq.push(make_pair(input[j].first,j));
                        //h1[j].exist=true;
                        input[j].second=true;
                    }
                }
                else{//post>j
                    for(k=post;k<n;k++){//先由post开始向后遍历
                        if(!h1[k].exist){
                            break;
                        }
                    }
                    if(k==n){//满足条件后，由0开始向j遍历
                        for(k=0;k<j;k++){
                            if(!h1[k].exist){
                                break;
                            }
                        }
                        if(k==j){
                            pq.push(make_pair(input[j].first,j));
                            //h1[j].exist=true;
                            input[j].second=true;
                        }
                    }
                }
            }
        }
        pair<int,int> top=pq.top();
        pq.pop();
        q.push(top.first);//找到本次满足条件：在队列pq且最小的元素，进入输出队列q
        h1[top.second].exist=true;//意味着top.second位置已经放了元素
    }
    printf("%d",q.front());//对输出队列q进行输出
    q.pop();
    while(!q.empty()){
        printf(" %d",q.front());
        q.pop();
    }
    return 0;
}