字符串哈希题目总结

最新推荐文章于 2024-03-05 23:31:23 发布
最新推荐文章于 2024-03-05 23:31:23 发布
阅读量3k 收藏 10
点赞数 4
文章标签： 字符串哈希
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chaiwenjun000/article/details/71079819
版权

HDU1880

给出对应的字符串，需要建立相应的双向映射。也就是输入first串可以得出对应的second串，输入second串可以得出对应的first串

数据有100000 ，用map<string，string>模拟爆内存。

使用 BKDRHash 哈希函数进行哈希

// BKDR Hash Function
unsigned int BKDRHash(char *str)
{
    unsigned int seed = 131; // 31 131 1313 13131 131313 etc..
    unsigned int hash = 0;
 
    while (*str)
    {
        hash = hash * seed + (*str++);
    }
 
    return (hash & 0x7FFFFFFF);
}
代码 

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 100010;
const int H = 100007;
struct node{
    char que[25];
    char ans[85];
    int next;
};
node nodeA[N], nodeB[N];
int curA,curB;
int hashTableA[N] , hashTableB[N];
void initHash(){
    for(int i=0;i<H;i++){
        hashTableA[i] = -1;
        hashTableB[i] = -1;
    }
    curA = 0;
    curB = 0;
}
unsigned int getHash(char *s){
    unsigned int seed = 131;
    unsigned int hash = 0;
    while(*s){
        hash = hash * seed + *s++;
    }
    return (hash & 0x7fffffff) % H;
}
void insertHash(char *que,char *ans){
    unsigned int h;
    h = getHash(que);
    strcpy(nodeA[curA].que, que);
    strcpy(nodeA[curA].ans, ans);
    nodeA[curA].next = hashTableA[h];
    hashTableA[h] = curA;
    ++curA;

    h = getHash(ans);
    strcpy(nodeB[curB].que,que);
    strcpy(nodeB[curB].ans,ans);
    nodeB[curB].next = hashTableB[h];
    hashTableB[h] = curB;
    ++curB;
}
int searchHashA(char *que){
    unsigned int h = getHash(que);
    int next = hashTableA[h];
    while(next != -1){
        if(strcmp(que,nodeA[next].que) == 0) return next;
        next = nodeA[next].next;
    }
    return -1;
}
int searchHashB(char *ans){
    unsigned int h = getHash(ans);
    int next = hashTableB[h];
    while(next != -1){
        if(strcmp(ans, nodeB[next].ans) == 0) return next;
        next = nodeB[next].next;
    }
    return -1;
}
int main(){
    char str[120], que[25], ans[85],qlen ,alen;
    int n,res;
    initHash();
    while(gets(str)){
        if(str[0] == '@') break;
        qlen = 0;
        for(int i=1;str[i] != ']';++i){
            que[qlen++] = str[i];
        }
        que[qlen] = 0;
        alen = 0;
        for(int i=qlen+3; str[i] != 0; ++i){
            ans[alen++] = str[i];
        }
        ans[alen] = 0;
        insertHash(que,ans);
    }
    scanf("%d",&n);
    getchar();
    while(n--){
        gets(str);
        if(str[0] == '['){
            qlen = strlen(str);
            str[qlen - 1] = 0;
            res = searchHashA(str + 1);
            if(res == -1) printf("what?\n");
            else printf("%s\n",nodeA[res].ans);
        }else{
            alen = strlen(str);
            res = searchHashB(str);
            if(res == -1) printf("what?\n");
            else printf("%s\n",nodeB[res].que);
        }
    }
    return 0;
}


POJ1743

题意：有N(1 <= N <=20000)个音符的序列来表示一首乐曲，每个音符都是1..88范围内的整数，现在要找一个重复的主题。“主题”是整个音符序列的一个子串，它需要满足如下条件：

    1.长度至少为5个音符。

    2.在乐曲中重复出现。(可能经过转调，“转调”的意思是主题序列中每个音符都被加上或减去了同一个整数值)

    3.重复出现的同一主题不能有公共部分。

重复2次以上，不能有公共部分的最长子串。

后缀数组可解，

这里用到88进制取模进行哈希函数

想出这种方法的作者连接 http://blog.renren.com/share/283538506/12293487302/0


#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <cstdlib>

using namespace std;
const int maxh = 10007;
const int maxn  =  20010;
typedef long long ll;
typedef unsigned long long ull;
#define mem(a,x) memset(a,x,sizeof a)
struct HASHMAP{
    int head[maxh] , next[maxn] , size;
    ull  state[maxn];
    int f[maxn];
    void init(){
        size = 0;
        mem(head,-1);
    }
    int insert(ull val,int id){
        int h = val % maxh;
        for(int i=head[h]; i != -1; i = next[i]){
            if(val == state[i]) return f[i];
        }
        f[size] = id;
        state[size] = val;
        next[size] = head[h];
        head[h] = size++;
        return f[size  - 1];
    }
};
HASHMAP H;
const int SEED = 13331;
ull P[maxn];
ull S[maxn];
int A[maxn];
int n;
bool check(int x){
    H.init();
    for(int i=x;i<n;i++)
        if(H.insert(S[i] - S[i-x]*P[x],i ) < i - x)
            return true;
    return false;
}
int main(){
    P[0] = 1;
    for(int i=1;i<maxn;i++)
        P[i] = P[i-1] * SEED; // unsigned long long 自动取模
    while(scanf("%d",&n) && n){
        for(int i=1;i<=n;i++)
            scanf("%d",&A[i]);
        for(int i=1;i<n;i++)
            A[i] = A[i + 1] - A[i];
        S[0] = 0;
        for(int i=1;i<n;i++)
            S[i] = S[i-1] * SEED + A[i];
        int ans = 0;
        int l = 4, r = n - 1;
        while(l <= r){
            int mid = (l + r) >>1;
            if(check(mid)){
                ans = mid;
                l = mid +1;
            }else
                r = mid -1;
        }
        if(ans < 4) ans = -1;
        ans++;
        printf("%d\n",ans);
    }
    return 0;
}



SCU4438 字符串hash ，好题

通过构造hash表，记录模式串的hash值，然后对主串按顺序遍历每个字符，并存入数组stack，并算出当前串的hash值，通过hash[i] - hash[i - len]*hashpow 算出当前子串是否与模式串hash值相等，相等就将数组stack中的下标回退len长度，实现删除匹配的串。

细节还有待推敲

代码

#include<cstdio>
#include<algorithm>
#include<map>
#include<cstring>
#include<vector>
#include<queue>
#include<set>
#include<map>
#include<cstdlib>
#include<iostream>
using namespace std;
#define maxn 5000006
typedef unsigned long long ll;
ll hash = 100007;
ll hash_w;
ll hash_p [maxn];
ll hash_pow[maxn];

char p[maxn], w[maxn];
char stack[maxn];
int len ;
void init(){
    hash_pow[0] = 1;
    for(int i=1;i<maxn;i++)
        hash_pow[i] = hash_pow[i -1] *hash;
}
bool check(int pos){

    if(pos >= len && hash_p[pos] -
        hash_p[pos - len] *hash_pow[len] == hash_w ){

       // cout<<pos<<" "<<hash_p[pos] <<" "<<hash_p[pos - len] *hash_pow[len]<<endl;
        return true;
    }

    return false;
}
int main(){
    init();
    while(~scanf("%s%s",w,p)){
        len = strlen(w);
        //模式串的hash值
        hash_w = 0;
        for(int i=0;*(w + i);i++){
            hash_w = hash_w * hash + *(w + i);
           // cout<<hash_w<<"  xx  ";
        }
      //  cout<<endl;

        int top = 0;
        for(int i=0; *(p + i); i++){
            stack[top++] = *(p + i);
            hash_p[top] = hash_p[top - 1]*hash + *(p + i);
            if(check(top)) top -= len;
        }
        for(int i=0;i<top;i++)
            printf("%c",stack[i]);
        puts("");
    }
    return 0;
}


HDU1280整数hash 水题

#include<cstdio>
#include<algorithm>
#include<map>
#include<cstring>
#include<vector>
#include<queue>
#include<set>
#include<map>
#include<cstdlib>
#include<iostream>
using namespace std;
#define maxn 5000006
typedef unsigned long long ll;
#define mem(a,x) memset(a,x,sizeof a)
int arr[3333];
int vis[10010];
int main(){
    int n,m;
    while(scanf("%d%d",&n,&m) != EOF){
        mem(vis,0);
        for(int i=0;i<n;i++){
            scanf("%d",&arr[i]);
        }
        for(int i=0;i<n;i++){
            for(int j=i+1;j<n;j++){
                vis[arr[i] + arr[j] ]  ++;
            }
        }
        bool isfirst = true;
        for(int i=10000;i>=0;i--){
                if(!m)break;
                while(m && vis[i]){
                    if(isfirst)
                        printf("%d",i);
                    else
                        printf(" %d",i);
                    isfirst = false;
                    m--;
                    vis[i]--;
                }


        }
        puts("");

    }
    return 0;
}

HDU1496

a*x1^2+b*x2^2+c*x3^2+d*x4^2=0

给出这样一个式子，给出a,b,c,d.求有多少解， abcd范围 [-50,50] x1 - x4 [-100,100];

hash，四层循环改成二层循环，通过数组映射判断是否冲突，冲突就说明匹配，说明有解。另外特殊情况该优化的还要优化，否者会超时。

#include<cstdio>
#include<algorithm>
#include<map>
#include<cstring>
#include<vector>
#include<queue>
#include<set>
#include<map>
#include<cstdlib>
#include<iostream>
using namespace std;
typedef unsigned long long ll;
#define mem(a,x) memset(a,x,sizeof a)
//-50*(10000) *2 = 1e 6;
const int maxn = 1e6 + 2;
int vis[2000010]; //2e6 + 10;
int main(){
    int a,b,c,d;

    while(scanf("%d%d%d%d", &a,&b,&c,&d) != EOF){
        if(a > 0 && b> 0 && c > 0 && d > 0){//没有这句就超市了
            puts("0");
            continue;
        }
        mem(vis,0);
        for(int i=1;i<=100;i++){
            for(int j=1;j<=100;j++){
                vis[a*i*i + b*j*j + maxn ] ++;
            }
        }
        int ans = 0;
        for(int i=1;i<=100;i++){
            for(int j=1;j<=100;j++){
                ans += vis[-(c*i*i + d*j*j)+maxn];
            }
        }
        // 每个i ，j都是可正 可负，2 * 2 * 2 * 2 == 16
        printf("%d\n",ans*16);
    }
    return 0;
}

ACDREAM 1726

给出N个数 和一个数 H ，从N个数中选择任意多个数，问有多少种选择使得选的数的和 等于H 。

N <=40 H <= 1e9

1e9需要哈希一下。

N = 40 折半之后哈希就可以了。

二分数据，数据减半后，时间复杂度 有 2 ^ 40 变为 2 ^ 20;

再用HASH判断是否满足

#include<cstdio>
#include<algorithm>
#include<map>
#include<cstring>
#include<vector>
#include<queue>
#include<set>
#include<map>
#include<cstdlib>
#include<iostream>
using namespace std;
typedef long long ll;
#define mem(a,x) memset(a,x,sizeof a)
const int maxn = 1<<20; // 1048576
const int hash = 1000007; //开多大的hash

/*
3 1000010
next记录的是之前的head
head代表着数据在a数组中的位置。
head始终代表着头结点

*/
struct hashmap{
    ll a[maxn]; //映射入的数组
    int head[hash] , next[maxn],size;
    void init(){
        mem(head,-1);
        size = 0;
    }
    /*
    取模相同的数，存入a中之后，可以通过next遍历找到head进而找到对应a[i];
    实现了取模相同的数放到邻接表里一样的查询。
    */
    bool find(ll val){ //查找一个元素是否在hash表中
        int tmp = (val % hash + hash) % hash;
        for(int i=head[tmp]; i != -1;i = next[i]){
            if(val == a[i]) return true;
        }
        return false;
    }
    void add(ll val){ // 添加元素到hash表
        int tmp = (val % hash + hash) %hash;
        if(find(val)) return ;
        a[size] = val;
        next[size] = head[tmp];
        head[tmp] = size ++;
    }
}h1;
int n,m,num[55];

int main(){
//
//    h1.init();
//    h1.add(3);
//    h1.add(4);
//    h1.add(5);
//    h1.add(6);
//    h1.add(1000010);
//    h1.add(2000017);

    while(~scanf("%d%d",&n,&m)){
        h1.init();
        for(int i=0;i<n;i++) scanf("%d",num+i);
        int t = n/2;
        // 将t种取或者不取 映射为二进制数，进行枚举
        for(int i=0;i<(1<<t);i++){
            ll sum = 0;
            for(int j=0;j < t;j++){
                if(i & (1<<j)){
                    sum += num[j]; //加上选中的数
                }
            }
            if(sum > m) continue;
            h1.add(sum);
        }
        int tt = n - t; //枚举剩下的数
        int flag = 0;
        for(int i=0;i<(1<<tt);i++){
            ll sum = 0;
            for(int j=0;j<tt;j++){
                if(i & (1<<j))
                    sum += num[t + j]; //加上剩下的数中符合条件的
            }
            if(sum > m) continue;
            if(h1.find(m - sum)){
                flag = 1; break;
            }
        }
        if(flag)
            printf("Yes\n");
        else
            printf("No\n");
    }
    return 0;
}


WinJourn
关注
  • 4
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LeetCode-Python-1392. 最长快乐前缀（暴力法 + 字符串hash）
12-21
「快乐前缀」是在原字符串中既是 非空 前缀也是后缀（不包括原字符串自身）的字符串。 给你一个字符串 s，请你返回它的 最长快乐前缀。 如果不存在满足题意的前缀，则返回一个...题目允许前后缀在原字符串中重叠。 示
字符串Hash例题详解
南判°
03-15 392
1.Codeforces 961F k-substrings 题目大意：给定一个字符串，对于它的所有子串  k−substrings  \;k-substrings\;k−substrings，问其前缀和后缀相同的最大长度，且长度必须为奇数，如果不存在则为  −1  \;-1\;−1。  k−substrings  \;k-substrings\;k−substrings是这样定义的：对于每个...
字符串哈希模板和经典题
春弦的博客
11-16 914
洛谷P3370 【模板】字符串哈希 给定NN个字符串（第i个字符串长度为M_i，字符串内包含数字、大小写字母，大小写敏感），请求出N个字符串中共有多少个不同的字符串。 输入格式 第一行包含一个整数NN，为字符串的个数。 接下来NN行每行包含一个字符串，为所提供的字符串。 输出格式 输出包含一行，包含一个整数，为不同的字符串个数。 #include<bits/stdc++.h> using namespace std; map<int,bool>vis;...
字符串哈希（HASH）
最新发布
cgl18973281319的博客
03-05 1711
一个字符串的哈希值。
Week5—C—平衡字符串
XiaoAnn的博客
03-24 272
题目描述： 一个长度为 n 的字符串 s，其中仅包含 ‘Q’, ‘W’, ‘E’, ‘R’ 四种字符。 如果四种字符在字符串中出现次数均为 n/4，则其为一个平衡字符串。 现可以将 s 中连续的一段子串替换成相同长度的只包含那四个字符的任意字符串，使其变为一个平衡字符串，问替换子串的最小长度? 如果 s 已经平衡则输出0。 Input： 一行字符表示给定的字符串s Output： 一...
【数据结构与算法-哈希表与字符串经典例题汇总】
是小武呀
03-17 1034
数据结构与算法-哈希表与字符串经典例题汇总
字符串Hash入门+例题详解
hhhcbw的博客，欢迎各位来访
07-17 1083
最近打暑假多校，发现有许多字符串算法自己有所遗忘，今天就借着补题在这开一个坑，把那几个基础的字符串算法总结复习一下，顺便写几个模板，供今后使用。这篇博客主要就是总结一下字符串Hash，并提一下例题。 简介 我们学习一个算法，肯定要先知道它要解决的是什么问题。字符串Hash，就是解决字符串匹配问题的良药，即寻找长度为 n 的主串 S 中的匹配串 T(长度为 m)出现的位置或次数问题。 对于上述问题，朴素的想法是枚举 S 所有起始位置，再直接检查是否匹配，我们可以不使用 O(m) 的直接比较字符串的方法，而.
字符串匹配算法之哈希匹配算法
weixin_44269491的博客
01-18 2104
使用场景 哈希匹配算法比较适合适用于多次对固定串内部匹配的算法。 预备理解 哈希匹配算法的原理是采用一种哈希函数将字符串映射成一个数字，之后就演化为两种方法： 第一种：假如数字相同，则去遍历匹配两串； 第二种：采用两种哈希函数，假如两组不同哈希映射后得到的数字相同则判断为字符能够匹配的上。 第二种方法的速度快但是存在误判即将不能够匹配的上判断为匹配的上，只是若是哈希函数设计的好这种概率会非常的低。 这里采用的哈希函数为： K=(C0∗Base0+C1∗Base1+C3∗Base3+...)(modP)K=(
Hash字符串匹配
Elltor
05-20 1945
hash字符串匹配即把固定长度的字符串转化为hash值进行匹配，这种匹配方式在大量数据的情况下是有误差的，大约万分之四五左右，这是因为hash值是通过字符和公式计算出来的，不同的字符串有可能根据我们的计算公式算出相同的hash值，这就会导致匹配的误差。 一、普通Hash匹配 普通hash匹配即每次截取模式串长度的字串计算hash值，然后原模式串的hash值进行比较，两者相同则认为匹配成功。 ...
1401 兔子与兔子（字符串哈希）
weixin_30498807的博客
04-02 110
描述 很久很久以前，森林里住着一群兔子。有一天，兔子们想要研究自己的 DNA 序列。我们首先选取一个好长好长的 DNA 序列（小兔子是外星生物，DNA 序列可能包含 26 个小写英文字母），然后我们每次选择两个区间，询问如果用两个区间里的 DNA 序列分别生产出来两只兔子，这两个兔子是否一模一样。注意两个兔子一模一样只可能是他们的 DNA 序列一模一样。 输入格式 第一行一个 DNA 字符串...
python求解数组中两个字符串的最小距离
01-21
给定一个数组 strs，其中的数据都是字符串，给定两个字符串 str1，str2。如果这两个字符串都在 strs数组中，就返回它们之间的最小距离；如果其中任何一个不在里面，则返回 -1；如果两个字符串相等，则返回 0。 例如...
LeetCode 706. 设计哈希映射
12-21
1. 题目 不使用任何内建的哈希表库设计一个哈希映射 具体地说，你的设计应该包含以下的功能 put(key, value)：向哈希映射中插入(键,值)的数值对。如果键对应的值已经存在，更新这个值。 get(key)：返回给定的键所...
LeetCode判断字符串是否循环-JianZhiOffer:剑指offer的题目刷一下
07-01
LeetCode判断字符串是否循环 JianZhiOffer 剑指offer的题目 题目列表 题3：数组中的重复数字： 3.1： 解法：哈希 或者 考虑数字范围为0~n-1的重排数组 3.2： 解法：二分 或者 快慢指针 题4：二维数组中的查找 解法：...
Java版本算法练习+笔记总结 按照数组-> 链表-> 哈希表->字符串-&gt
01-14
Java版本算法练习+笔记总结 按照数组-> 链表-> 哈希表->字符串->栈与队列->树->回溯->贪心->动态规划->图论->高级数据结构进行系统的练习 每道题都有标号和题目链接.zip
LeetCode判断字符串是否循环-leetcode:LeetcodeGolang解决方案
07-01
LeetCode判断字符串是否循环 Leetcode Go Algorithm 题目 难度 关键词 easy 哈希表 medium 单链表 medium 哈希表、滑动窗口 hard 二分查找 medium Manacher、动态规划 medium 字符串 easy 数学 medium 数学、字符串 ...
LeetCode判断字符串是否循环-AlgoPractice:算法实践
07-01
LeetCode判断字符串是否循环 题目索引表 编码可能有点问题，VS默认是GBK LeetCode LeetCode自带索引 PAT 字符串处理 1136 回文 数学 1152 素数判断 简单的数据结构 1155, 1147 堆。判断最大堆、最小堆、不是堆 1078,...
LeetCode 599. 两个列表的最小索引总和（哈希map）
12-21
假设Andy和Doris想在晚餐时选择一家餐厅，并且他们都有一个表示最喜爱餐厅的列表，每个餐厅的名字用字符串表示。 你需要帮助他们用最少的索引和找出他们共同喜爱的餐厅。 如果答案不止一个，则输出所有答案并且不...
Rogerspy#LeetCode-Py-1#0758. 字符串中的加粗单词1
07-25
0758. 字符串中的加粗单词标签：字典树、数组、哈希表、字符串、字符串匹配难度：中等题目大意给定一个关键词集合 words 和一个字符串 s。要求：在所有 s
程序员面试金典 – 面试题 10.02. 变位词组（哈希map）
12-21
编写一种方法，对字符串数组进行排序，将所有变位词组合在一起。 变位词是指字母相同，但排列不同的字符串。 示例: 输入: ["eat", "tea", "tan", "ate", "nat", "bat"], 输出: [ ["ate","eat","tea"], ["nat","tan...
字符串匹配算法leetcode
08-25
在 LeetCode 上，常见的字符串匹配算法题目包括： 1. 暴力法：遍历文本字符串，逐个比较模式字符串和文本字符串中的字符。时间复杂度为 O(n*m)，其中 n 是文本字符串长度，m 是模式字符串长度。 2. KMP 算法：利用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值