[hdu 4821]String 字符串hash

最新推荐文章于 2021-03-17 20:45:11 发布

ahm001

最新推荐文章于 2021-03-17 20:45:11 发布

阅读量1.1k

点赞数

分类专栏： hdu 文章标签：字符串 hash

本文链接：https://blog.csdn.net/ahm001/article/details/37298977

版权

hdu 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

String

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 248 Accepted Submission(s): 83

Problem Description

Given a string S and two integers L and M, we consider a substring of S as “recoverable” if and only if
(i) It is of length M*L;
(ii) It can be constructed by concatenating M “diversified” substrings of S, where each of these substrings has length L; two strings are considered as “diversified” if they don’t have the same character for every position.

Two substrings of S are considered as “different” if they are cut from different part of S. For example, string "aa" has 3 different substrings "aa", "a" and "a".

Your task is to calculate the number of different “recoverable” substrings of S.

Input

The input contains multiple test cases, proceeding to the End of File.

The first line of each test case has two space-separated integers M and L.

The second ine of each test case has a string S, which consists of only lowercase letters.

The length of S is not larger than 10^5, and 1 ≤ M * L ≤ the length of S.

Output

For each test case, output the answer in a single line.

Sample Input

  
  
   
   3 3
abcabcbcaabc

Sample Output

Source

2013 Asia Regional Changchun

字符串处理题，给定一个字符串，询问有多少个连续子串，其满足：

1.长度为L*M且连续

2.将该子串按顺序切割为M份，每份长度为L，且每个部分均不相同。

这一题用到了字符串hash的技巧

采用BKDhash处理较为方便(类似多项式hash)，设s[0]到s[l-1]的hash值为a[l]

则对于s[l]到s[l+k-1]一段的hash值为a[l+k-1]-s[l-1]*base[k]

对于每个开头按顺序处理一次，用map记录是否出现重复的hash即可。

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<algorithm>
#include<vector>
#include<map>
#include<stack>
#include<list>
#include<queue>
#define eps 1e-6
#define INF (1<<30)
#define PI acos(-1.0)
using namespace std;
char a[100005];
unsigned long long base[100005];
unsigned long long pos[100005];
unsigned long long shash[100005];
map <unsigned long long,int>hash_table;
main()
{

    int m,l,n,k;
    base[0]=1;
    for (int i=1;i<=100000;i++)
        base[i]=base[i-1]*131;
    while(~scanf("%d%d",&m,&l)){
    pos[0]=0;
    scanf("%s",a);
    n=strlen(a);
    for (int i=0;i<n;i++)
            pos[i+1]=pos[i]*131ull+a[i];
    for (int i=1;i<=n-l+1;i++)
            shash[i]=pos[i+l-1]-pos[i-1]*base[l];//计算每个长度为l的hash
    int fp,lp,ti,ans=0;
    for (int i=1;(i<=l)&&i+l-1<=n;i++)
    {
        ti=0;
        hash_table.clear();
        fp=i;
        lp=i+l*(m-1);//fp代表开头 lp代表结尾
        if (lp+l-1>n) break;
        for (int j=fp;j<=lp;j+=l)
        {
            if (hash_table[shash[j]]==0) ++ti;
            hash_table[shash[j]]++;
        }
        if (ti==m) ans++;
        while (lp+l+(l-1)<=n)
        {
            if (hash_table[shash[fp]]==1) --ti;
            hash_table[shash[fp]]--;
            fp+=l;
            lp+=l;
            if (lp>n) break;
            if (hash_table[shash[lp]]==0) ++ti;
            hash_table[shash[lp]]++;
            if (ti==m) ans++;
        }
    }
    printf("%d\n",ans);
    }
}