哈希预处理 以及 时间复杂度计算的误区（我自己的误区）

题目链接：https://codeforces.com/gym/102803/problem/C

题意：

        给一个由A、B两种长度相同的字符串以A..B..A..a的形式拼接而成的字符串，找出A和B

思路：

        从小到大枚举所有可能的长度，判断是否满足题目条件。由于随着长度的增加，判断时考虑的字符串的个数就会减少，个数为n/i。若是能以O(1)的时间复杂度判断两个字符串是否相等，就能以O(n logn)的时间复杂度过这道题。方法是，利用哈希表，进行哈希预处理，使得能快速判断。

        （我自己的思维误区）：一直以为两层循环就是n^2的时间复杂度，因此想了很久一直没想明白为什么可以这么做（捂脸）。

        实际上时间复杂度为：

后来听大牛说是叫调和级数，我记住了（哭脸）。

哈希预处理：

        百度：哈希表，也称为散列表，是一种根据关键码值直接进行访问的数据结构。它通过散列函数将关键码值映射到表中一个特定的位置，以便快速访问记录。散列函数是用于映射的函数，而存放记录的数组称为散列表或哈希表。在哈希表中，记录的存储位置是由散列函数计算得出的，即存储位置=f(关键字)，其中f是散列函数，也称为哈希函数。

        哈希预处理就是利用哈希表进行预处理（好像是句废话），一种处理字符串的方式就是，把每一位上的字符看作k进制数中的某一位，这样就能把一个字符串映射到一个十进制数列中，从而进行快速判断是否相同。然而k^(8*1e5)显然存不下，因此需要对其取模，原则上要取模，但实际代码运行时会把超越数据类型大小的数先存到负数再存到正数再存到负数来回存自动类取模（因此只管存，不用管数据大小）。值得一提的是，比较字符串是否相同，只需比较长度相同的，因此数据分布的相对离散

代码（写得跟史一样，但能过，不想改了）：

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

const int N=8*1e5+8;
const int base=31;

string s;
int len;
long long ash[N],sum[N];

void init(){    //哈希预处理
	ash[0]=0;
	sum[0]=1;
	for(int i=1;i<=len;i++){
		ash[i]=ash[i-1]*base+s[i-1];
		sum[i]=sum[i-1]*base;
	}
}

long long gethash(int l,int r){    //读取对应的哈希表中的值
	return ash[r]-ash[l-1]*sum[r-l+1];
} 

int main(){
	memset(ash,0,sizeof(ash));
	memset(sum,0,sizeof(sum));
	cin>>s;
	len=s.length();
	init();
	int he,ta,le;    //A字符串的首字母位置，B字符串的首字母位置，长度
	for(int i=1;i<=len/3;i++){
		bool check=true;
		int t,cnt=0;
		long long t_,k_=gethash(1,i);
		for(int j=i+1;j<=len-i+1;j+=i){    //史一样的判断
			long long kt=gethash(j,i+j-1);
			if(kt!=k_ && !cnt){
				cnt++;
				t=j;
				t_=kt;
				continue;
			}
			if(cnt==1 && kt!=k_ && kt!=t_){
				check=false;
				break;
			}
			if(cnt==1 && kt==k_){
				cnt++;
				continue;
			}
			if(cnt==2 && kt!=k_){
				check=false;
				break;
			}
		}
		if(gethash(len-len%i+1,len)!=gethash(1,len%i)) continue;
		if(check){    //判断是否符合题意
			he=1;
			ta=t;
			le=i;
			break;
		}
	}
	cout<<s.substr(0,le)<<' '<<s.substr(ta-1,le);
	return 0;
}