题目来源:AcWing 840. 模拟散列表
一、题目描述
维护一个集合,支持如下几种操作:
I x
,插入一个数 x x x;Q x
,询问数 x x x 是否在集合中出现过;
现在要进行 N N N 次操作,对于每个询问操作输出对应的结果。
输入格式
第一行包含整数
N
N
N,表示操作数量。
接下来
N
N
N 行,每行包含一个操作指令,操作指令为 I x
,Q x
中的一种。
输出格式
对于每个询问指令 Q x
,输出一个询问结果,如果
x
x
x 在集合中出现过,则输出 Yes
,否则输出 No
。
每个结果占一行。
数据范围
1
≤
N
≤
1
0
5
1≤N≤10^5
1≤N≤105
−
1
0
9
≤
x
≤
1
0
9
−10^9≤x≤10^9
−109≤x≤109
输入样例:
5
I 1
I 2
I 3
Q 2
Q 5
输出样例:
Yes
No
二、哈希表
哈希表的存储结构分为:链地址法、开放寻址法(常用)
我们下面的实现,本质上就是用数组模拟STL库中的std::unordered_set。
1. 拉链法
拉链法本质就是邻接表,将重复的元素挂在一条链上。
槽的大小:这里的槽就是指哈希表的单元格,指的就是
N
N
N,一般而言
N
N
N 取
1
0
5
10^5
105 或
1
0
6
10^6
106 后面的质数,如
1
e
5
+
3
1e^5+3
1e5+3 或者
1
e
6
+
3
1e^6+3
1e6+3 这种值。
哈希函数:
h
a
s
h
(
x
)
=
(
x
%
N
+
N
)
%
N
;
hash(x) = (x \% N + N) \% N;
hash(x)=(x%N+N)%N;
插入操作:利用哈希函数得到哈希值
k
k
k,然后确定的这个槽就是
h
[
k
]
h[k]
h[k]
void insert(int x)
{
int k = (x % N + N) % N; // 哈希函数
e[idx] = x, ne[idx] = h[k], h[k] = idx++; // 头插法
}
查询操作:与插入操作类似,如果一个 h a s h hash hash 值对应的槽有多个元素挂在上面,则顺序遍历即可。
bool query(int x)
{
int k = (x % N + N) % N;
for (int i = h[k]; ~i; i = ne[i])
if (e[i] == x) return true;
return false;
}
运行效果对比:使用该方法耗时 56 m s 56ms 56ms,使用STL库自带的unordered_set容器耗时 186 m s 186ms 186ms。
2. 开放寻址法(常用)
开放寻址法只开了一个数组,但是大小一要开到题目的数据范围的 2 2 2~ 3 3 3 倍的质数。例如,如果题目中要输入 1 e 5 1e^5 1e5 个数,那么这个数组的长度至少开到 2 e 5 2e^5 2e5~ 3 e 5 + c 3e^5 + c 3e5+c ,注意是一个质数,这样取是一个经验方法,冲突的概率比较低。该方法常用的原因是,可以使用更少的数组个数。
槽的大小:题目的数据范围的
2
2
2~
3
3
3 倍,同样也是一个质数。
哈希函数:
h
a
s
h
(
x
)
=
(
x
%
N
+
N
)
%
N
;
hash(x) = (x \% N + N) \% N;
hash(x)=(x%N+N)%N;
冲突处理:如果当前
h
[
k
]
h[k]
h[k] 已经被占用,则像上厕所一样一个一个坑位顺序往后找,直到找到第一个空的坑位为止。
find函数:开放寻址法的核心操作是 find 函数,也称为蹲坑法,
f
i
n
d
(
x
)
find (x)
find(x) 如果在哈希表中能找到
x
x
x,则返回
x
x
x 所在的位置;如果
x
x
x 在哈希表中不存在的话,则返回它应该存储的位置。
// null 这里要设置一个用不到的标志数,当做标志位
const int N = 200003, null = 0x3f3f3f3f3;
int h[N]; // 要先memset(h, 0x3f, sizeof h);
int find(int x)
{
int k = (x % N + N) % N;
while (h[k] != null && h[k] != x) // 要么找到x,要么找到空的坑位
{
k++;
if (k === N) k = 0; // 类似于循环队列
}
return k;
}
插入操作:
int k = find(x);
h[k] = x;
查找操作:
int k = find(x);
if (h[k] != null) puts("Yes");
else puts("No");
删除操作:类似于冲突处理,找到以后打一个标记。
运行效果对比:使用该方法耗时
62
m
s
62ms
62ms,使用STL库自带的unordered_set容器耗时
186
m
s
186ms
186ms。
三、代码
1. 链地址法
#include <iostream>
#include <cstring>
using namespace std;
// mod的这个数,一般要开质数
const int N = 100003;
int h[N], e[N], ne[N], idx;
// 头插法
void insert(int x)
{
int k = (x % N + N) % N; // k是hash值
e[idx] = x, ne[idx] = h[k], h[k] = idx++; // 邻接表的头插法
}
bool find(int x)
{
int k = (x % N + N) % N;
for (int i = h[k]; ~i; i = ne[i])
if (e[i] == x) return true;
return false;
}
int main()
{
int n;
scanf("%d", &n);
// 清空哈希表(邻接表)
memset(h, -1, sizeof h);
while (n--)
{
char op[2];
int x;
scanf("%s%d", op, &x);
if (*op == 'I') insert(x);
else
{
if (find(x)) puts("Yes");
else puts("No");
}
}
return 0;
}
2. 开放寻址法
#include <iostream>
#include <cstring>
using namespace std;
// 注意:N要开2~3倍数据范围的奇数, null是表示哈希槽尚未占用的标志
const int N = 2e5 + 3, null = 0x3f3f3f3f;
int h[N];
int n;
// 开放寻址法的核心函数
int find(int x)
{
int k = (x % N + N) % N;
while (h[k] != null && h[k] != x)
{
k++;
if (k == N) k = 0;
}
return k;
}
int main()
{
scanf("%d", &n);
// 要像使用邻接表那样初始化都为null
memset(h, 0x3f, sizeof h);
char op[2];
int x;
while (n--)
{
scanf("%s%d", op, &x);
int k = find(x);
if (*op == 'I') h[k] = x;
else
{
if (h[k] != null) puts("Yes");
else puts("No");
}
}
return 0;
}