【数据结构】哈希表

已于 2022-08-07 18:27:23 修改
阅读量110 收藏
点赞数
于 2021-10-17 09:18:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51948235/article/details/120807247
版权

字符串哈希 回文子串 二维哈希 编程竞赛 AC代码
关键词由CSDN通过智能技术生成

博客链接：

字符串哈希模板：

struct stringhash{
    LL h[N], w[N], base, mod;

    void init(LL b, LL m){  // 基数模数初始化
        h[0] = 0, w[0] = 1, base = b, mod = m;
		for(int i=1; i<N; i++) w[i] = w[i - 1] * base % mod;
    }

    void add(char * str)    // 构造哈希表
    {
        int len = strlen(str + 1);
        for(int i=1; i<=len; i++)
            h[i] = (h[i - 1] * base + str[i]) % mod;
    }

    LL get(int l, int r){   // 获得区间哈希
        return (h[r] - h[l - 1] * w[r - l + 1] % mod + mod) % mod;
    }
}ha1, ha2;

更新模板：

cstr_hash:
struct cstr_hash{
    LL h[N], w[N], n, base, mod;

    void init(LL b, LL m){  // 基数模数初始化
        h[0] = 0, w[0] = 1, base = b, mod = m;
		for(int i = 1; i < N; i ++ )
            w[i] = w[i - 1] * base % mod;
    }

    void add(char * str){   // 构造哈希表
        n = strlen(str + 1);
        for(int i = 1; i <= n; i ++ )
            h[i] = (h[i - 1] * base + str[i]) % mod;
    }

    LL get(int l, int r){   // 获得区间哈希
        return (h[r] - h[l - 1] * w[r - l + 1] % mod + mod) % mod;
    }

    LL pre(int len){
        return get(1, len);
    }
    LL suf(int len){
        return get(n - len + 1, n);
    }
}ha;
str_hash:
struct str_hash{
    LL h[N], w[N], n, base, mod;

    void init(LL b, LL m){  // 基数模数初始化
        h[0] = 0, w[0] = 1, base = b, mod = m;
		for(int i = 1; i < N; i ++ )
            w[i] = w[i - 1] * base % mod;
    }

    void add(string & str){
        n = str.size();
        if(n) h[0] = str[0] % mod;
        for(int i = 1; i < n; i ++ )
            h[i] = (h[i - 1] * base + str[i]) % mod;
    }

    LL get(int l, int r){   // 获得区间哈希
        if(!l) return h[r];
        return (h[r] - h[l - 1] * w[r - l + 1] % mod + mod) % mod;
    }

    LL pre(int len){
        return get(0, len - 1);
    }
    LL suf(int len){
        return get(n - len, n - 1);
    }
}ha;

注意事项：

  1. base和mod尽可能不要取小。mod可以使用不常用的大质数，防止常用质数被卡。
  2. 使用一个哈希表可能会产生碰撞，担心碰撞的话使用双哈希，二元组pair<LL, LL>即为哈希值。

例题：

2020年河南省CCPC K.子串翻转回文串

  • 题解：https://blog.csdn.net/weixin_43731933/article/details/109989821

  • 小tips：如何多次 O ( 1 ) O(1) O(1) 询问区间子串是否回文？

  • 将字符串正、反映射到两个哈希表中（注意基数和模数要相同），
    询问时判断 h a 1   [ l , r ] ha1~[l,r] ha1 [l,r] 和 h a 2   [ n − r + 1 , n − l + 1 ] ha2~[n-r+1,n-l+1] ha2 [n−r+1,n−l+1] 是否相等，相等即回文。

AC代码：

#include<bits/stdc++.h>
using namespace std;

typedef long long LL;
const int N=5e5+10;

struct stringhash{
    LL h[N], w[N], base, mod;

    void init(LL b, LL m){
        h[0] = 0, w[0] = 1, base = b, mod = m;
    }

    void add(char * str)
    {
        int len = strlen(str + 1);
        for(int i=1; i<=len; i++)
            h[i] = (h[i - 1] * base + str[i]) % mod, w[i] = w[i - 1] * base % mod;
    }

    LL get(int l, int r){
        return (h[r] - h[l - 1] * w[r - l + 1] % mod + mod) % mod;
    }
}ha1, ha2;


char str[N], s[N];
int n;

bool check()
{
    if(n == 0) return 1;

    for(int i=1; i <= n; i++)
    {
        if(i <= n - i)
        {
            if(ha1.get(1, i) == ha1.get(n - i + 1, n))
                if(ha1.get(i + 1, n - i) == ha2.get(i + 1, n - i)) return 1;
        }else
        {
            if(ha1.get(i + 1, n) == ha1.get(2 * i - n + 1, i))
                if(ha1.get(1, 2 * i - n) == ha2.get(2 * n - 2 * i + 1, n)) return 1;
        }
    }
    return 0;
}

int main()
{
    ha1.init(1213, 50331653);
    ha2.init(1213, 50331653);

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

    while(T--)
    {
        scanf("%s", str + 1);
        n = 0;
        int len = strlen(str + 1);

        for(int i=1; i <= len; i++)
            if(str[i] != str[len - i + 1]){
                for(int j=i; j <= len - i + 1; j++){
                    s[++n] = str[j];
                }
                break;
            }
        
        ha1.add(s);
        reverse(s + 1, s + 1 + n);
        ha2.add(s);

        int ans = check();
        if(ans == 0)
        {
            ha1.add(s);
            reverse(s + 1, s + 1 + n);
            ha2.add(s);
            ans = check();
        }
                
        printf("%s\n", ans ? "Yes" : "No");
    }

    system("pause");
    return 0;
}
【二维哈希】Matrix

代码（被卡内存了，不知道怎么优化）：

  • 更新：unordered_map换成vector内存少了，但是超时，估计是LL或模的问题。
#include<bits/stdc++.h>
using namespace std;

typedef long long LL;
const int N=1e3 + 10;

int n, m, a, b;
char w[N][N];
LL res;
struct stringhash{
    LL h[N][N], w1[N], w2[N], base1, base2, mod;

    void init(LL b1, LL b2, LL _m){
        base1 = b1, base2 = b2, mod = _m;
        w1[0] = w2[0] = 1;
        for(int i=1; i<N; i++) w1[i] = w1[i - 1] * base1 % mod;
        for(int i=1; i<N; i++) w2[i] = w2[i - 1] * base2 % mod;
    }

    inline void add()
    {
        for(int i=1; i<=n; i++)
            for(int j=1; j<=m; j++)
                h[i][j] = h[i][j - 1] * base1 % mod + w[i][j], h[i][j] %= mod;
        
        for(int i=1; i<=n; i++)
            for(int j=1; j<=m; j++)
                h[i][j] += h[i - 1][j] * base2, h[i][j] %= mod;
    }

    inline void get(int & i, int & j){
        res = ((h[i][j] - h[i][j - b] * w1[b] - h[i - a][j] * w2[a] + h[i - a][j - b] * w1[b] % mod * w2[a]) % mod + mod) % mod;
    }
}ha;

unordered_map<LL, bool>mp;

int main()
{
    ha.init(114, 514, 161061241);

    scanf("%d %d %d %d", &n, &m, &a, &b);

    for(int i=1; i<=n; i++)
        for(int j=1; j<=m; j++)
            scanf(" %c", &w[i][j]);
    
    ha.add();

    for(int i=a; i<=n; i++)
        for(int j=b; j<=m; j++){
            ha.get(i, j);
            mp[res] = 1;
        }
    
    int T; scanf("%d", &T);
    while(T--)
    {
        for(int i=1; i<=a; i++)
            for(int j=1; j<=b; j++) scanf(" %c", &w[i][j]);
        
        ha.add();

        if(mp[ha.h[a][b]]) printf("1\n");
        else printf("0\n");
    }

    system("pause");

    return 0;
}

AC代码（用的unsigned int）：

  • 这里用vector内存为10M，用unordered_map内存为32M。可能哈希要占内存吧。vector空间常数应该是更优的
#include<bits/stdc++.h>
using namespace std;

typedef long long LL;
typedef unsigned int UI;
const int N=1e3 + 10;

int n, m, a, b;
char w[N][N];
UI res;
struct stringhash{
    UI h[N][N], w1[N], w2[N], base1, base2;

    void init(UI b1, UI b2){
        base1 = b1, base2 = b2;
        w1[0] = w2[0] = 1;
        for(int i=1; i<N; i++) w1[i] = w1[i - 1] * base1;
        for(int i=1; i<N; i++) w2[i] = w2[i - 1] * base2;
    }

    inline void add()
    {
        for(int i=1; i<=n; i++)
            for(int j=1; j<=m; j++)
                h[i][j] = h[i][j - 1] * base1 + w[i][j];
        
        for(int i=1; i<=n; i++)
            for(int j=1; j<=m; j++)
                h[i][j] += h[i - 1][j] * base2;
    }

    inline void get(int i, int j){
        res = h[i][j] - h[i][j - b] * w1[b] - h[i - a][j] * w2[a] + h[i - a][j - b] * w1[b] * w2[a];
    }
}ha;

vector<UI>vec;

int main()
{
    ha.init(131, 233);

    scanf("%d %d %d %d", &n, &m, &a, &b);

    for(int i=1; i<=n; i++)
        for(int j=1; j<=m; j++)
            scanf(" %c", &w[i][j]);
    
    ha.add();

    for(int i=a; i<=n; i++)
        for(int j=b; j<=m; j++){
            ha.get(i, j);
            vec.push_back(res);
        }
    sort(vec.begin(), vec.end());
    
    int T; scanf("%d", &T);
    n = a, m = b;
    while(T--)
    {
        for(int i=1; i<=a; i++)
            for(int j=1; j<=b; j++) scanf(" %c", &w[i][j]);
        
        ha.add();
        
        if(find(vec.begin(), vec.end(), ha.h[a][b]) != vec.end()) printf("1\n");
        else printf("0\n");
    }

    system("pause");

    return 0;
}
ZhgDgE
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
vector的引用，哈希表解决集合求和的加数
qq_45848768的博客
11-08 731
给出一个集合和一个目标，求出集合中的两个数，这两个数的和为该目标 第一个方法为暴力枚举，但是时间复杂度为O(n^2) #include<iostream> #include<vector> using namespace std; vector<int> twoSum(vector<int>& nums, int target) { /* int len = nums.size(); for (int i = 0; i < le
哈希表的使用
奔跑の蜗牛
07-27 2255
哈希表一般用于存储键值对即key-val 一般是由数组和链表构成 常用操作 //查找是否存在键值 unordered_map<int,int> hash; hash.find(key)==hash.end(); hash.count(key)==1; 例题 290. Word Pattern 由于C++中的哈希表不能查找某一值的存在，只能查找某一键是否存在，所以C++需要两个哈希表来相互存储。 class Solution { public: //将字符串传入到数组
c++用vector实现HashSet
08-16
c++一个用vector实现java的HashSet集合类，可以将任何类，数字，字符串，vector等等存放到里面
Poj 3349 Snowflake Snow Snowflakes(哈希+vector)
Grit_ICPC的博客
08-06 540
Snowflake Snow Snowflakes Time Limit: 4000MS   Memory Limit: 65536K Total Submissions: 34759   Accepted: 9123 Description You may have heard that no two snowflakes are al
vector类详解【c++】
wzh18907434168的博客
05-21 3465
C++的vector类是一个非常重要的容器，它可以动态调整大小，存储任何类型的对象，并提供了快速、高效的随机访问、插入和删除操作。它可以代替数组，提供更多的功能和灵活性。vector类的内存管理非常高效，使用连续的内存块存储元素，能够快速地访问和操作元素。它是C++标准库中最常用的容器之一，被广泛应用于各种编程场景中。掌握vector类的使用方法，可以大大提高编程效率和代码质量。
C++ Vector容器使用方法详解
lzc881012的博客
06-29 914
C++ 标准库向量类是序列容器的类模板。 向量以线性排列方式存储给定类型的元素，并允许快速随机访问任何元素。 向量是需要力求保证访问性能时的首选序列容器。vector是种容器，类似数组一样，但它的size可以动态改变。vector的元素在内存中连续排列，这一点跟数组一样。这意味着我们元素的索引将非常快，而且也可以通过指针的偏移来获取vector中的元素。
数据结构哈希表
02-12
数据结构哈希表是一种在计算机科学中用于存储和检索数据的有效方法。它的核心思想是通过一个函数，称为哈希函数，将数据的关键字映射到一个固定大小的数组中的特定位置，从而实现快速查找。在C#编程语言中，哈希表被...
数据结构哈希表实验报告优质资料.doc
12-01
数据结构哈希表实验报告优质资料 哈希表是一种常用的数据结构，它可以快速地查找、插入和删除数据。本文将对哈希表的基本概念、哈希函数、冲突解决方法、查找和插入操作等进行详细的介绍，并提供一个简单的哈希表...
数据结构哈希表的应于电话本的制作
08-29
数据结构哈希表的应于电话本的制作
vector
m0_37733257的博客
10-04 151
vector(向量)： 向量 vector 是一种对象实体, 能够容纳许多其他类型相同的元素, 因此又被称为容器。 与string相同, vector 同属于STL(Standard Template Library, 标准模板库)中的一种自定义的数据类型, 可以广义上认为是数组的增强版。 一、vector的声明与初始化——vector <> a() <数据类型> a...
Vector 和 HashTable
请叫我王老魔
02-24 2421
其实Vector 和 HashTable现在已经很少使用了，他们是同属于一个时代的，一般我们使用ArrayList 和HashMap 而且建议使用这两个，他们两个是一个时代的。Vector Vector 和ArrayList的区别： Vector是线程同步的，而ArrayList不是线程同步的，其他方面的实现两个基本一样，从下面的代码可以看到，它的底层实现也是数组。protected Objec
哈希表练习（分别用map、array、vector实现）
zgg_12345的博客
07-22 306
leetcode-49 字母异位词分组 题目描述 给定一个字符串数组，将字母异位词组合在一起。可以按任意顺序返回结果列表。 字母异位词指字母相同，但排列不同的字符串。 示例 1: 输入: strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”] 输出: [[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]] 示例 2: 输入: strs = [""] 输出: [[""]] 示例 3: 输入: strs = [“a”] 输出: [[“a
STL hash<vector<bool>>
roaylchen的博客
08-20 1464
原文 class template specialization std::hash> template struct hash; // unspecialized template struct hash >; // vector Hash for vector Unary function
哈希表的设计与实现
热门推荐
喜欢恋着风
08-03 1万+
简介哈希表，也称散列表，是实现字典操作的一种有效的数据结构。尽管在最坏的情况下，散列表查找一个元素的时间复杂度与链表中查找的时间相同，达到了O(n)，然而实际应用中，散列表查找的性能是极好的，在一些合理的假设下，在散列表中可以查找一个元素的平均时间是O(1)。哈希表的精髓在于哈希二字上面，也就是数学里面常用到的映射关系，它是通过哈希函数将关键字映射到表中的某个位置上进行存放，以实现快速插入和查询的。
C++——unordered_set默认无法哈希vector？
dreamiond的博客
03-14 1万+
有如下代码： unordered_set&lt;vector&lt;int&gt;&gt; dict; 上述代码在编译时会报错： 错误 C2338 The C++ Standard doesn't provide a hash for this type. 原因如下： unordered_set和unordered_map本质上都是使用hash方法对元素进行存储和查...
散列表（哈希表）
baidu_16370559的博客
05-12 896
散列表（hashtable）是居于“开链的做法”。本质是一个vector和每个vector成员维护一个link list。需要注意针对这个list搜索只能一种线性操作。 hashtable 由桶子（buckets）(本质是vector)和 节点（node)（本质是list）组成。 hashtable 的数据结构 所以：buckets 就是桶子，node就是节点。 其中node 结构定义： 迭代器结构 迭代器永远维系着与整个buckets vector 的关系，......
vector基础知识点
yam_sunshine的博客
03-12 339
一、vector基本介绍 vector属于STL（标准模板库）的六大组件之一容器部分，它类似于数组。具体有以下几个特点： 1、动态可变，即一个可变大小数组的序列容器； 2、类似于数组，vector采用的连续存储空间来存储元素，即可用下标对vector的元素进行访问，和数组一样高效； 3、vector使用动态分配数组来存储它的元素。当有新的元素插入时，为了增加存储空间，这个数组会被重新分配大小。具体...
数据结构哈希表设计思路
最新发布
12-13
哈希表是一种基于哈希函数进行快速查找的数据结构，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。哈希表的设计思路如下： 1. 哈希函数的设计：哈希函数是哈希表的核心，它将关键字映射到哈希...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值