模拟哈希表

模拟哈希表

模拟散列表

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

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

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

输入格式

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

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

输出格式

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

每个结果占一行。

数据范围

1≤N≤105
−109≤x≤109

//(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

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 100003;//大于数据量的最小质数
int h[N] , e[N] , ne[N] ; //变量参考单链表
int idx ;
int n;

void insert(int x ){
    int k = (x%N + N)%N; //当x为负数时才能处理
    e[idx] = x;       //模拟单链表的插入
    ne[idx] = h[k];
    h[k] = idx++;
}

bool query(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;
}

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


// 开放寻址法
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 200003 , null = 0x3f3f3f3f;  
//开两倍或者三倍的数组 空间为更大一点的质数  null为比1e9更大的数
int h[N] ;
int n;

int find(int x ){ //开放寻址法 寻找坑位
    int k = (x % N + N) % N;
    while(h[k] != null && h[k] != x){ 
//h[k] == x 返回x的下标 //h[k] == null 返回x该存放的位置
        k++;
        if( k == N ) k = 0 ;
    }
    return k; //返回的是x的下标或者x该存放的位置  
}

int main()
{
    cin>>n;
    memset(h, 0x3f, sizeof h);
    char op;
    int x ;
    while (n -- ){
        cin>>op>>x;
        int k = find(x) ;
        if(op=='I') h[k] = x; //直接存放
        else cout << (h[k]!=null ? "Yes" : "No") <<endl;
    }
    return 0;
}

 字符串哈希

给定一个长度为 n 的字符串，再给定 m 个询问，每个询问包含四个整数 l1,r1,l2,r2请你判断 [l1,r1][l1,r1] 和 [l2,r2][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 <cstring>
#include <algorithm>
#include <math.h>
using namespace std;
typedef unsigned long long ULL;
const int N = 100010, P = 131; //   P取 131 或  13331  在99.99%不会冲突
const ULL Q = pow(2,64) ;   // Q是避免哈希值过大 所以需要mod Q  Q取2^64 
int n, m;
char str[N];
ULL h[N], p[N]; //h[N]存哈希值
//h[N] 看作P进制数 即哈希值为P进制数
ULL get(int l , int r){ //获取字串的哈希值
    return h[r] -( h[l-1] * p[r - l + 1]) ;
}

int main()
{
    cin >> n >> m;
    scanf("%s", str+1); // 字符串从1开始

    p[0] = 1;
    for(int i = 1 ; i <= n ; i++ ){
        p[i] = p[i-1] * P;
        h[i] =( h[i-1] * P + str[i] ) % Q ;
    }
    while(m--){
        int l1 , r1 , l2 , r2 ;
        cin >> l1 >> r1 >> l2 >> r2 ;
        //如果两个子串的哈希值相等则说明两个字串相同
        cout << ( get(l1 , r1 ) == get( l2 , r2 ) ? "Yes" : "No") <<endl ; 
    }
}