数据结构：哈希表

用一个数组来存哈希后的元素，但不可避免出现不同元素哈希后成为同一元素，为了解决这种情况，有拉链法和开放寻址法

模拟散列表：

拉链法：用邻接表存哈希值相同的元素

#include <cstring>
#include <iostream>

using namespace std;

const int N = 1e5 + 3;  // 取大于1e5的第一个质数，取质数冲突的概率最小 可以百度

//* h是该哈希值的链上第一个元素索引。e就是链，ne存下一个位置，idx表示第几个元素
int h[N], e[N], ne[N], idx;//需要注意的是，e和ne是总链，并非是该哈希值的链
int n;

void insert(int x) 
{
    // c++中如果是负数，那他取模也是负的，所以加N再%N就一定是一个正数
    int k = (x % N + N) % N;//哈希函数，k就是哈希值
    //下面的操作：让新来的元素成为该链的第一个元素，即头插法，如上图所示
    e[idx] = x;//先把这个点存在链上
    ne[idx] = h[k];//这链的该位置的下一个为相同哈希值的第一个元素索引，即同一个链的第一个元素索引
    h[k] = idx++;//在该链的第一个元素索引为现在的元素索引
}

bool find(int x) 
{
    //用上面同样的 Hash函数 讲x映射到 从 0-1e5 之间的数
    int k = (x % N + N) % N;
    for (int i = h[k]; i != -1; i = ne[i]) {//从这个链的第一个元素开始向下找，其实就是用ne找总链的下一个相同哈希值的位置
        if (e[i] == x) {
            return true;
        }
    }
    return false;
}

int main() {
    scanf("%d",&n);//n次操作

    memset(h, -1, sizeof h);  //将哈希表先清空 空指针一般用 -1 来表示

    while (n--)
    {
        string op;//操作
        int x;
        cin >> op >> x;//要操作的数
        if (op == "I") insert(x);//插入
        else 
        {
            if (find(x)) printf("Yes\n");//找该元素是否存在
            else printf("No\n");
        }
    }
    return 0;
}

开放寻址法：在哈希后若该位置已经存在元素，则往后找一位，直到找到最后，若还没找到，则回到哈希表第一个位置找。该方法要求哈希表的空间一定是足够的

#include <cstring>
#include <iostream>

using namespace std;

//开放寻址法一般开 数据范围的 2~3倍, 这样大概率就没有冲突了
const int N = 2e5 + 3;        //大于数据范围的第一个质数
const int null = 0x3f3f3f3f;  //规定哈希后初始化为这个，这个值是超过了题目x的取值范围，所以若为这个值，则说明该位置没存x

int h[N];//h是哈希表的存元素索引

int find(int x) {
    int t = (x % N + N) % N;
    while (h[t] != null && h[t] != x)
    {//若该哈希值存的x不是初始化的null也不是该元素，就说明这个位置已经存了数，就往后找能存的位置
        t++;
        if (t == N) t = 0;//若找到了最后一个位置，就从0开始重新找，这里没找N，因为N本来就很大，不在乎这最后一个位置
    }
    return t;  //返回能存的位置
}

int main() {
    int n;
    cin >> n;

    memset(h, 0x3f3f3f3f, sizeof h);  //初始化哈希表每个元素为这个值

    while (n--) {
        string op;//操作
        int x;//要操作的数
        cin >> op >> x;
        if (op == "I") {
            h[find(x)] = x;//让哈希表这位置存x
        } else {
            if (h[find(x)] == null) {//若这个位置还未赋值，则返回No
                puts("No");
            } else {//若存了值，也可能是其他的元素存的，但在find函数中会判断该位置存的是不是该x,直到找到x存的位置
                puts("Yes");//所以if语句不能改成if (h[find(x)] != null)puts("Yes")
            }
        }
    }
    return 0;
}

---

字符串哈希：

/*公式: h[R] - h[L - 1] X P ^ (R - L + 1)

我们在预处理h[i] 数组的时候,是把左边看成高位,右边看成低位(这与我们的习惯是相同的)
下面给出例子,计算[4,5]之间"de" 的哈希值 高位h[r]  a       b   c   d    e  低位  
                                         h[l]              a   b    c  
                        这是数组的下标          1       2   3   L    R   
                        这里是P进制下位权      (p^4)  p^3  p^2 p^1   1

   我们在前缀和那节课已经学过了,怎么计算区间的部分和.  h[R] - h[L - 1].
   此时发现h[r]和h[l]的哈希值对应不上
   因此我们将字符串 "左移",为他们补上位权,这样子就能做到一一对应
                                    高位h[r]  a      b   c   d    e  低位  
                                        h[l]  a      b   c  '\0' '\0'
                        这是数组的下标         1      2   3    L   R   
                        这里是P进制下位权    (p^4)  p^3  p^2  p^1  1

    为了方便理解,我用"\0"表示无意义字符. 这个时候就能计算了对吧?
    那位移是多少呢?
    就是 R - L + 1,在本例中, 5 - 4 + 1 = 2,左移两位. 补齐低位.
    因此 h[R] - h[L - 1] * P ^ (R - L + 1)  */
#include<iostream>
using namespace std;

typedef unsigned long long ULL;
const int N = 1e5+5,P = 131;//p是哈希函数，p取131，或13331冲突概率最小
ULL h[N],p[N];//h是前缀哈希值，p是p的多少次方

ULL query(int l,int r)
{
    return h[r] - h[l-1]*p[r-l+1];//截取这段字符子串，乘以
}
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    string x;
    cin>>x;

    //字符串从1开始编号，h[1]为前一个字符的哈希值
    p[0] = 1;
    h[0] = 0;
    for(int i=0;i<n;i++)
    {
        p[i+1] = p[i]*P;            
        h[i+1] = h[i]*P +x[i];//前缀和求整个字符串的哈希值
    }

    while(m--)
    {
        int l1,r1,l2,r2;
        scanf("%d%d%d%d",&l1,&r1,&l2,&r2);
        if(query(l1,r1) == query(l2,r2)) printf("Yes\n");
        else printf("No\n");
    }
    return 0;
}