哈希表（C++）

基本思想

基本模板

一般哈希

(1) 拉链法
    int h[N], e[N], ne[N], idx;

    // 向哈希表中插入一个数
    void insert(int x)
    {
        int k = (x % N + N) % N;
        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 != -1; i = ne[i])
            if (e[i] == x)
                return true;

        return false;
    }

(2) 开放寻址法
    int h[N];

    // 如果x在哈希表中，返回x的下标；如果x不在哈希表中，返回x应该插入的位置
    int find(int x)
    {
        int t = (x % N + N) % N;
        while (h[t] != null && h[t] != x)
        {
            t ++ ;
            if (t == N) t = 0;
        }
        return t;
    }

作者：yxc
链接：https://www.acwing.com/blog/content/404/
来源：AcWing

字符串哈希

核心思想：将字符串看成P进制数，P的经验值是131或13331，取这两个值的冲突概率低
小技巧：取模的数用2^64，这样直接用unsigned long long存储，溢出的结果就是取模的结果

typedef unsigned long long ULL;
ULL h[N], p[N]; // h[k]存储字符串前k个字母的哈希值, p[k]存储 P^k mod 2^64

// 初始化
p[0] = 1;
for (int i = 1; i <= n; i ++ )
{
    h[i] = h[i - 1] * P + str[i];
    p[i] = p[i - 1] * P;
}

// 计算子串 str[l ~ r] 的哈希值
ULL get(int l, int r)
{
    return h[r] - h[l - 1] * p[r - l + 1];
}

作者：yxc
链接：https://www.acwing.com/blog/content/404/
来源：AcWing

经典例题

1、AcWing 840. 模拟散列表
维护一个集合，支持如下几种操作：

“I x”，插入一个数x；
“Q x”，询问数x是否在集合中出现过；
现在要进行N次操作，对于每个询问操作输出对应的结果。

输入格式
第一行包含整数N，表示操作数量。

接下来N行，每行包含一个操作指令，操作指令为”I x”，”Q x”中的一种。

输出格式
对于每个询问指令“Q x”，输出一个询问结果，如果x在集合中出现过，则输出“Yes”，否则输出“No”。

每个结果占一行。

数据范围
1≤N≤105
−109≤x≤109
输入样例：

5
I 1
I 2
I 3
Q 2
Q 5

输出样例：

Yes
No

开放寻址法

#include <cstring>
#include <iostream>

using namespace std;

const int N = 200003, null = 0x3f3f3f3f;/*开放寻址法:开辟一个输入个数的2～3倍的空间来存放值，避免冲突*/

int h[N];

int find(int x)
{
    int t = (x % N + N) % N;
    while (h[t] != null && h[t] != x)// 冲突,如果h[t]里面已经存了数，并且该数字与x不相等
    {
        t ++ ;//看h[t]后面的位置
        if (t == N) t = 0;//如果走到了数组结尾，跳到数组开头，判断是否有空位
    }
    return t;//返回x应该存放的位置
}

int main()
{
    memset(h, 0x3f, sizeof h);

    int n;
    scanf("%d", &n);

    while (n -- )
    {
        char op[2];
        int x;
        scanf("%s%d", op, &x);
        if (*op == 'I') h[find(x)] = x;
        else
        {
            if (h[find(x)] == null) puts("No");
            else puts("Yes");
        }
    }

    return 0;
}

作者：yxc
链接：https://www.acwing.com/activity/content/code/content/45308/
来源：AcWing

拉链法

#include <cstring>
#include <iostream>

using namespace std;

const int N = 100003;

int h[N], e[N], ne[N], idx;//h[]是哈希函数的一维数组//e[]是链表中存的值//ne[]是指针存的指向的地址//idx是当前指针

void insert(int x)
{
    int k = (x % N + N) % N;//对负数的处理,k是哈希值
    e[idx] = x;
    ne[idx] = h[k];
    h[k] = idx ++ ;
   //如果不同单链表的idx都是从0开始单独计数，那么不同链表之间可能会产生冲突。
  //这里的模型是这样的：e[]和ne[]相当于一个大池子，里面是单链表中的节点，会被所有单点表共用，idx相当于挨个分配池子中的节点的指针。
  //比如如果第0个节点被分配给了第一个单链表，那么所有单链表就只能从下一个节点开始分配，所以所有单链表需要共用一个idx。
}

bool find(int x)
{
    int k = (x % N + N) % N;//为了让负数在整数有映射,负数的取模还是负数,加上maxn后为正,再%即可
    // 如果多个数据的映射的结果相同，它们将被保存在同一根链表上
    // 先获取拉出的链表头结点，然后遍历直到命中或者全部不命中为止
    for (int i = h[k]; i != -1; i = ne[i])
        if (e[i] == x)
            return true;// 命中则返回true

    return false;//全部都无法命中，返回false
}

int main()
{
    int n;
    scanf("%d", &n);

    memset(h, -1, sizeof h);// 散列表初始化为空  所有槽都清空,对应的是单链表的头(head)[注:head存的是地址]指针为-1

    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;
}

作者：yxc
链接：https://www.acwing.com/activity/content/code/content/45308/
来源：AcWing

2、AcWing 841. 字符串哈希
给定一个长度为n的字符串，再给定m个询问，每个询问包含四个整数l1,r1,l2,r2，请你判断[l1,r1]和[l2,r2]这两个区间所包含的字符串子串是否完全相同。

字符串中只包含大小写英文字母和数字。

输入格式
第一行包含整数n和m，表示字符串长度和询问次数。

第二行包含一个长度为n的字符串，字符串中只包含大小写英文字母和数字。

接下来m行，每行包含四个整数l1,r1,l2,r2，表示一次询问所涉及的两个区间。

注意，字符串的位置从1开始编号。

输出格式
对于每个询问输出一个结果，如果两个字符串子串完全相同则输出“Yes”，否则输出“No”。

每个结果占一行。

数据范围
1≤n,m≤105
输入样例：

8 3
aabbaabb
1 3 5 7
1 3 6 8
1 2 1 2

输出样例：

Yes
No
Yes

#include <iostream>
#include <algorithm>

using namespace std;

typedef unsigned long long ULL; //由于前缀值的值会很大 所以应该将数组中的数据定义为ULL型

const int N = 100010, P = 131;//P为权重
                        //131为经验值 即P=131或13331时 哈希冲突的可能性最小

int n, m;
char str[N];
ULL h[N], p[N];//h[]存放字符串的前缀值
              //p[]存放各个位数的相应权值
// h[i]前i个字符的hash值
// 字符串变成一个p进制数字，体现了字符+顺序，需要确保不同的字符串对应不同的数字
// P = 131 或  13331 Q=2^64，在99%的情况下不会出现冲突
// 使用场景： 两个字符串的子串是否相同
ULL get(int l, int r)
{
    return h[r] - h[l - 1] * p[r - l + 1]; //这步其实是将h[l-1]左移
                                      //其目的事实上是为了将h[l-1]的高位与h[r]相对齐从而才可以未完成计算
}

int main()
{
    scanf("%d%d", &n, &m);
    scanf("%s", str + 1);

    p[0] = 1;//注意这步千万不要忘了 最开始的权值必须赋值为1 否则接下来就会出错
    for (int i = 1; i <= n; i ++ )
    {
        h[i] = h[i - 1] * P + str[i]; //计算字符串前缀值
                                    //最新加入的数的权值为p的0次 所以直接加上str[i]即可
        p[i] = p[i - 1] * P;//计算每个位上的相应权值
    }

    while (m -- )
    {
        int l1, r1, l2, r2;
        scanf("%d%d%d%d", &l1, &r1, &l2, &r2);

        if (get(l1, r1) == get(l2, r2)) puts("Yes");
        else puts("No");
    }

    return 0;
}

作者：yxc
链接：https://www.acwing.com/activity/content/code/content/45313/
来源：AcWing