Cuckoo for Hashing（hash）hunnuoj

Problem B:
Cuckoo for Hashing
An integer hash table is a data structure that supports insert, delete and lookup of integer values in
constant time. Traditional hash structures consist of an array (the hash table) of some size n, and a
hash function f(x) which is typically f(x) = x mod n. To insert a value x into the table, you compute
its hash value f(x) which serves as an index into the hash table for the location to store x. For example,
if x = 1234 and the hash table has size 101, then 1234 would be stored in location 22 = 1234 mod 101.
Of course, it’s possible that some other value is already stored in location 22 (x = 22 for example),
which leads to a collision. Collisions can be handled in a variety of ways which you can discuss with
your faculty advisor on the way home from the contest.
Cuckoo hashing is a form of hashing that employs two hash tables T1and T2, each with its own hash
function f1(x) and f2(x). Insertion of a value x proceeds as follows: you first try to store x in T1using
f1(x). If that location is empty, then simply store x there and you’re done. Otherwise there is a collision
which must be handled. Let y be the value currently in that location. You replace y with x in T1, and
then try to store y in T2 using f2(y). Again, if this location is empty, you store y there and you’re
done. Otherwise, replace the value there (call it z) with y, and now try to store z back in T1using
f1(z), and so on. This continues, bouncing back and forth between the two tables until either you find
an empty location, or until a certain number of swaps have occurred, at which point you rehash both
tables (again, something to discuss with your faculty advisor). For the purposes of this problem, this
latter occurrence will never happen, i.e., the process should always continue until an empty location is
found, which will be guaranteed to happen for each inserted value.
Given the size of the two tables and a series of insertions, your job is to determine what is stored in
each of the tables.
(For those interested, cuckoo hashing gets its name from the behavior of the cuckoo bird, which is
known to fly to other bird’s nests and lay its own eggs in it alongside the eggs already there. When
the larger cuckoo chick hatches, it pushes the other chicks out of the nest, thus getting all the food for
itself. Gruesome but efficient.)
Input
Input for each test case starts with 3 positive integers n1n2m, where n1and n2are the sizes of the
tables T1 and T2 (with n1,n2 ≤ 1000 and n1 6= n2) and m is the number of inserts. Following this
will be m integer values which are the values to be inserted into the tables. All of these values will be
non-negative. Each table is initially empty, and table Tiuses the hash function fi(x) = x mod ni. A
line containing 3 zeros will terminate input.
Output
For each test case, output the non-empty locations in T1followed by the non-empty locations in T2.
Use one line for each such location and the form i:v, where i is the index location of the table, and v
is the value stored there. Output values in each table from lowest index to highest. If either table is
empty, output nothing for that table.
2013 East Central Regional Contest
4
Sample Input
5 7 4
8 18 29 4
6 7 4
8 18 29 4
1000 999 2
1000
2000
0 0 0
Sample Output
Case 1:
Table 1
3:8
4:4
Table 2
1:29
4:18
Case 2:
Table 1
0:18
2:8
4:4
5:29
Case 3:
Table 1
0:2000
Table 2
1:1000

 

题意 ：意思就是哈希来的，具体大意就是说有两个哈希表，然后有这样一组数据，

让你把这组数据存到这两个哈希表里，然后不能重复，先让数据往表1里存，就是对

表1的长度进行取余，如果余数这个位置没有数就存上，如果有的话，就存上这个数，

让原来的数再去表2里存，也是按照这个方式。就是来回踢。。。我觉得。。。。

//思路：两个哈希表，一个循环找即可。。。

>>题目链接<<

#include <stdio.h>
#include <string.h>
#include <map>
#include <iostream>

using namespace std ;
int ch[1100];
int sh[1100];
int main()
{
    int n1,n2,k ;
    int t = 1 ;
    while(scanf("%d%d%d",&n1,&n2,&k)!=EOF)
    {
        if(n1 == 0&&n2==0&&k==0) break;
        memset(ch,-1,sizeof(ch));
        memset(sh,-1,sizeof(sh)) ;

        int x ;
        for(int i = 1 ; i <= k ; i++)
        {
            scanf("%d",&x);
            while(1)
            {
                int s=x%n1;
                if(ch[s] == -1)
                {
                    ch[s]=x;
                    break;
                }
                else
                {
                    int temp=ch[s];
                    ch[s]=x;
                    int tt=temp%n2;
                    if(sh[tt]==-1)
                    {
                        sh[tt]=temp;
                        break;
                    }
                    else
                    {
                        x=sh[tt];
                        sh[tt]=temp;
                    }
                }
            }
        }
        printf("Case %d:
",t);
        t++;
        int flag = 0 ;
        for(int i = 0 ; i < n1 ; i++)
        {
            if(ch[i] != -1)
            {
                flag = 1 ;
                break ;
            }
        }
        if(flag)
        {
            printf("Table 1
");
            for(int i = 0 ; i < n1 ; i++)
            {
                if(ch[i] != -1)
                {
                    printf("%d:%d
",i,ch[i]);
                }
            }
        }
        flag = 0 ;
        for(int i = 0 ; i < n2 ; i++)
        {
            if(sh[i] != -1)
            {
                flag = 1 ;
                break ;
            }
        }
        if(flag)
        {
            printf("Table 2
");
            for(int i = 0 ; i < n2 ; i++)
            {
                if(sh[i] != -1)
                {
                    printf("%d:%d
",i,sh[i]) ;
                }
            }
        }
    }
    return 0 ;
}