• 哈希表


    哈希表存储结构

    • 最常用的两类:开放寻址法、拉链法

    模拟散列表

    拉链法
    #include <iostream>
    #include <cstring>
    
    using namespace std;
    
    //做hash时整个数组的长度取成质数,同时这个数离2的幂次最远
    const int N = 100003;  
    
    //寻找大于100000的第一个质数
    // for(int i = 100000; ; i ++ ) {
    // 	bool flag = true;
    // 	for(int j = 2; j * j <= i; j ++ ) {
    // 		if(i % j == 0) {
    // 			flag = false;
    // 			break;
    // 		}
    // 	}
    // 	if(flag) {
    // 		cout << i << endl;
    // 		break;
    // 	}
    // }
    
    //开一组hash槽,每个槽上拉一个链表
    int h[N], e[N], ne[N], idx;
    
    //插入
    void insert(int x) {
    	//c++中负数取模是负数,这样处理可以将所有结果映射到正数
    	//h[k]存储的是拉链中第一个点的下标
    	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;
    }
    
    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;
    }
    
    // memset 函数是内存赋值函数,用来给某一块内存空间进行赋值的;
    // 包含在<string.h>头文件中,可以用它对一片内存空间逐字节进行初始化;
    // 原型为 :void *memset(void *s, int v, size_t n);
    // 这里s可以是数组名,也可以是指向某一内在空间的指针;
    // v为要填充的值;
    // n为要填充的字节数
    
    开放寻址法
    //处理冲突的思路类似“上厕所”
    #include <cstring>
    #include <iostream>
    
    using namespace std;
    
    //一般开两倍空间
    const int N = 200003, null = 0x3f3f3f3f;
    
    int h[N];
    
    //找到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;
    }
    
    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;
    }
    

    字符串哈希

    • 很多字符串相关问题都可以用字符串哈希来处理,不一定用kmp

    字符串哈希

    //注意:1)不能映射成0; 2)假定不存在冲突情况
    //预处理成前缀哈希,用“p进制法”
    //可以用前缀哈希快速求得任意子串的哈希
    #include <iostream>
    
    using namespace std;
    
    //将哈希值定义成无符号数,可以自动处理大整数溢出的情况
    typedef unsigned long long ULL;
    
    //P表示进制,去131这个经验值
    const int N = 100010, P = 131;
    
    int n, m;
    char str[N];
    ULL h[N], p[N];
    
    //求子串哈希值
    ULL get(int l, int r) {
    	return h[r] - h[l - 1] * p[r - l + 1];
    }
    
    int main() {
    	scanf("%d%d%s", &n, &m, str + 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];//求前缀哈希
    	}
    
    	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;
    }
    
  • 相关阅读:
    C语言 数组排序 – 冒泡法排序
    类加载过程
    布隆过滤器的原理及应用
    回答两个被频繁问到的代码写法问题
    关于分布式事务的理解
    根据使用者反馈,对开源项目 go-gin-api 新增两个功能
    图书速度 | 《如何高效学习》
    报错kernel:NMI watchdog: BUG: soft lockup
    容器Jenkins中运行docker
    容器Jenkins中运行docker
  • 原文地址:https://www.cnblogs.com/huhu555/p/14671643.html
Copyright © 2020-2023  润新知