1月11号学习总结

自习

字符串哈希算法

字符串的哈希算法，通俗的理解，就是将一个字符串，转化成整数

主要用途——字符串匹配                                  

原来我们进行字符串匹配的时候，就是一个个去匹配，那么时间复杂度是o（n），如果转化成数字，去匹配那么时间复杂度会变成o（1）。

将模式串通过hash函数转换成一个整数，将主串中的一个个子串也通过hash函数转换成一个个数，只要模式串转换成的数与一个个子串转换成的数中的某一个数相等，则说明主串包含模式串

怎么去把一串字符串转换成一个整数？想一下十六进制转换，嗯没错，就是通过进制转换来将字符串转换成一个整数的。

将一个字符串转换成一个哈希值：

ull hhash(char *arr) { //将字符串arr转换为base进制的整数
	int base = 131; //base最好设置为131 1331 13331 133331这几种,因为出错的概率较小,转换为base进制
	ull ans = 0;//转换之后的答案ans可能会非常大，当ans超过unsigned long long的取值范围溢出时就相当于系统自动帮你进行2的64次方取模运算
	for (int i = 0; i < strlen(arr); i++) {
		ans = ans * base + arr[i] - 'a' + 1;//可以直接写ans*base+arr[i]的,写成这样的话arr中字符的ASCIL码值需小于字符a
	}
	return ans;
}

一个字符串的哈希预处理

void Hash(char *str) { //预处理求str(str的有效字符下标范围为[1~strlen(str)])各[1~i]子串的hash值转换为base进制
	q[0] = 1;//初始化权值
	h[0] = 0; //存储数组初始化
	int p = 131; //base最好设置为131 1331 13331 133331这几种,转换为p进制
	for (int i = 1; i <= strlen(str); i++) {
		h[i] = h[i - 1] * p + str[i];
		q[i] = q[i - 1] * p;
	}
	//p[i] 是记录第i位字符的权值
	//str的[i~j]子串区间的hash值=h[j]-h[i]*q[j-i+1],由get_hash函数求得
}

获取字符串[i~j]区间的哈希值

ull get_hash(int l, int r) {//字符串的有效字符下标范围为[1~strlen(str)]
	return l ? h[r] - h[l - 1] * q[r - l + 1] : h[r]; //l为0时单独考虑
}

 获取字符串[i~j]区间的例子

/*
	例如：          h[i] = h[i - 1] * p + str[i]   q[i] = q[i - 1] * p      
	  前缀
	  A             A*p^0                                 h[1]=65
	  AB            A*p^1+B*p^0                           h[2]=h[1]*p+66
	  ABC           A*p^2+B*p^1+C*p^0                     h[3]=h[2]*p+67
	  ABCD          A*p^3+B*p^2+C*p^1+D*p^0               h[4]=h[3]*p+68
	  ABCDE         A*p^4+B*p^3+C*p^2+D*p^1+E*p^0         h[5]=h[4]*p+69
	  
	  下标：    0 1 2 3 4 5
	              A B C D E
       求2~4的字符串str区间BCD的hash值
       h[r] - h[l - 1] * q[r - l + 1]
	   ans=h[4]-h[1]*q[4-2+1]
	      =h[4]-h[1]*p^3
		  =A*p^3+B*p^2+C*p^1+D*p^0-(A*p^0)*p^3
	      =A*p^3+B*p^2+C*p^1+D*p^0-A*p^3
		  =B*p^2+C*p^1+D*p^0                        				       
	*/

总的代码：

#include<stdio.h>
#include<string.h>
#define LEN 12000
typedef unsigned long long ull;//缩写数据类型的声明
char arr[LEN];
ull h[LEN], q[LEN]; //一定要注意数据类型
void Hash(char *str) { //预处理求str(str的有效字符下标范围为[1~strlen(str)])各[1~i]子串的hash值转换为base进制
	q[0] = 1;//初始化权值
	h[0] = 0; //存储数组初始化
	int p = 131; //base最好设置为131 1331 13331 133331这几种,转换为p进制
	for (int i = 1; i <= strlen(str); i++) {
		h[i] = h[i - 1] * p + str[i];
		q[i] = q[i - 1] * p;
	}
	//p[i] 是记录第i位字符的权值
	//str的[i~j]子串区间的hash值=h[j]-h[i]*q[j-i+1],由get_hash函数求得
}
ull get_hash(int l, int r) {//字符串的有效字符下标范围为[1~strlen(str)]
	return l ? h[r] - h[l - 1] * q[r - l + 1] : h[r]; //l为0时单独考虑
}

ull hhash(char *arr) { //将字符串arr转换为base进制的整数
	int base = 131; //base最好设置为131 1331 13331 133331这几种,转换为base进制
	ull ans = 0;//转换之后的答案ans可能会非常大，当ans超过unsigned long long的取值范围溢出时就相当于系统自动帮你进行2的64次方取模运算
	for (int i = 0; i < strlen(arr); i++) {
		ans = ans * base + arr[i] - 'a' + 1;//可以直接写ans*base+arr[i]的,写成这样的话arr中字符的ASCIL码值需小于字符a
	}
	return ans;
}

 

刷题

【模板】字符串哈希

【模板】字符串哈希 - 洛谷

题目描述

如题，给定 NN 个字符串（第 ii 个字符串长度为 MiMi​，字符串内包含数字、大小写字母，大小写敏感），请求出 NN 个字符串中共有多少个不同的字符串。

友情提醒：如果真的想好好练习哈希的话，请自觉。

输入格式

第一行包含一个整数 NN，为字符串的个数。

接下来 NN 行每行包含一个字符串，为所提供的字符串。

输出格式

输出包含一行，包含一个整数，为不同的字符串个数。

输入输出样例

输入 #1

5
abc
aaaa
abc
abcc
12345

输出 #1

4

说明/提示

对于 30%30% 的数据：N≤10N≤10，Mi≈6Mi​≈6，Mmax≤15Mmax≤15。

对于 70%70% 的数据：N≤1000N≤1000，Mi≈100Mi​≈100，Mmax≤150Mmax≤150。

对于 100%100% 的数据：N≤10000N≤10000，Mi≈1000Mi​≈1000，Mmax≤1500Mmax≤1500。

样例说明：

样例中第一个字符串(abc)和第三个字符串(abc)是一样的，所以所提供字符串的集合为{aaaa,abc,abcc,12345}，故共计4个不同的字符串。

Tip： 感兴趣的话，你们可以先看一看以下三题：

BZOJ3097：http://www.lydsy.com/JudgeOnline/problem.php?id=3097

BZOJ3098：http://www.lydsy.com/JudgeOnline/problem.php?id=3098

BZOJ3099：http://www.lydsy.com/JudgeOnline/problem.php?id=3099

如果你仔细研究过了（或者至少仔细看过AC人数的话），我想你一定会明白字符串哈希的正确姿势的^_^

 算法：哈希

思路：很简单的模板题，将给出的一个个字符串通过哈希函数转换成一个个整数，不同整数的个数就是不同字符串的个数

代码

#include<stdio.h>
#include<string.h>
typedef unsigned long long ull;//缩写数据类型的声明
ull hhash(char *arr, int base) { //将字符串转换为base进制,arr中字符的ASCIL码值小于字符a
	ull ans = 0;//转换之后的答案ans可能会非常大，当ans超过unsigned long long的取值范围溢出时就相当于系统自动进行2的64次方取模运算
	for (int i = 0; i < strlen(arr); i++) {
		ans = ans * base + arr[i] ;
	}
	return ans;
}
ull jo[12000];//储存不同字符串的hash值
int numjo = 0;//不同字符的数量
int main() {
	int n;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		getchar();
		char temp[1501];
		scanf("%s", temp);
		ull bn = hhash(temp, 23);//计算转换后的值，转为23进制
		int flag = 0;
		for (int i = 0; i < numjo; i++) {
			if (bn == jo[i]) {//该字符出现过
				flag = 1;
				break;
			}
		}
		if(flag==0){//该字符串出现过
			jo[numjo++]=bn;
		}
	}
	printf("%d",numjo);
}