模拟哈希+字符串哈希

模拟哈希

维护一个集合，支持如下几种操作：

1. I x，插入一个数 x；
2. Q x，询问数 x 是否在集合中出现过；

现在要进行 N 次操作，对于每个询问操作输出对应的结果。

输入格式

第一行包含整数 N，表示操作数量。

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

输出格式

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

每个结果占一行。

数据范围

1≤N≤10^5
−10^9≤x≤10^9

输入样例：

5
I 1
I 2
I 3
Q 2
Q 5

输出样例：

Yes
No

---

开放寻址法：

开放寻址法采用hash函数找到在hash数组中对应的位置，如果该位置上有值，并且这个值不是寻址的值，则出现冲突碰撞，需要解决冲突方案，该算法采用简单的向右继续寻址来解决问题。

//线性探测法
#include <iostream>
#include <cstring>
using namespace std;

const int N = 200003, null = 0x3f3f3f3f;  //线性探测法一般开2~3倍
int h[N];


int find(int x)
{
    int i = (x % N + N) % N;
    while (h[i] != null && h[i] != x){
        i ++;
        if (i == N) i = 0;
    }
    return i;
}

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

    int n;
    cin >> n;
    while (n --){
        char op;
        int x;
        cin >> op >> x;
        int i = find(x);
        if (op == 'I'){
            if (h[i] != x) h[i] = x;
        }
        else{
            if (h[i] == x) cout << "Yes" << endl;
            else cout << "No" << endl;
        }
    }
    return 0;
}

拉链法：

拉链法也是一种处理冲突的方法，当哈希函数将不同元素映射到同一哈希值时，我们将这些元素用链表存起来，哈希表中该位置存储该链表的头结点。插入时是将元素插入到哈希值对应位置的链表中，查询时遍历哈希值对应位置的链表，若找到则返回true，若遍历完链表仍未找到则返回false。

// 拉链法
#include <iostream>
#include <cstring>

using namespace std;

const int N = 100003;
int h[N], e[N], ne[N], idx;  // h中存-1或是下标

void insert(int x)
{
    int i = (x % N + N) % N;
    e[idx] = x;  //头插法
    ne[idx] = h[i];
    h[i] = idx ++;
}

bool find(int x)
{
    int k = (x % N + N) % N;
    for (int i = h[k]; i != -1; i = ne[i]) //直到下标为-1，即到达链表末尾
        if (e[i] == x) return true;
    return false;
}

int main()
{
    memset(h, -1, sizeof(h));
    int n;
    cin >> n;
    while (n --){
        char op;
        int x;
        cin >> op >> x;
        if (op == 'I'){
            insert(x);
        }
        else{
            if (find(x)) cout << "Yes" << endl;
            else cout << "No" << endl;
        }
    }
    return 0;
}

---

字符串哈希：

字符串哈希

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

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

输入格式

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

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

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

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

输出格式

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

每个结果占一行。

数据范围

1≤n,m≤10^5

输入样例：

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

输出样例：

Yes
No
Yes

---

思路：把字符串看成是一个 P 进制数，每个字符的 ASCII 码对应数的一位。ASCII 范围 0 - 127，最少 128 进制，经验上取 131 或 13331 冲突率低，这里取 P = 131。字符串很长，对应的数太大，通过模 2^64 把它映射到 [0, 2^64 - 1]，所以考虑用 unsigned long long 存储，溢出相当于对 2^64 取模。利用这个方法我们可以用前缀哈希直接求出子串哈希，例如：字串[l, r]的哈希值是用 前r位的哈希值 减去 前 l - 1 位的哈希值左移 l - r + 1位后的值 得到的结果。即：

注意：

不要把某一位映射成 P 进制 0，例如，A 如果是 0，则 AA 也是 0，就会出现冲突

#include <iostream>

using namespace std;
typedef unsigned long long ULL;
const int N = 100010, P = 131; //每个字符是P进制数的一位
char str[N];
int n, m;
ULL h[N], p[N];  //p[i] = p ^ i, h[i]表示str前i位的哈希值

ULL get(int l, int r)
{
    return h[r] - h[l - 1] * p[r - l + 1];
}

int main()
{
    cin >> n >> m;
    cin >> str + 1;
    p[0] = 1;
    for (int i = 1; i <= n; ++ i){
        h[i] = h[i - 1] * P + str[i];  //ULL自动对2^64取模了
        p[i] = p[i - 1] * P;
    }
    while (m --){
        int l1, r1, l2, r2;
        cin >> l1 >> r1 >> l2 >> r2;
        if (get(l1, r1) == get(l2, r2)) cout << "Yes" << endl;
        else cout << "No" << endl;
    }
    return 0;
}