hihocoder #1084 (后缀数组求模糊匹配)

#1084 : 扩展KMP

时间限制: 4000ms

单点时限: 4000ms

内存限制: 256MB

描述

你知道KMP吗？它是用于判断一个字符串是否是另一个字符串的子串的算法。今天我们想去扩展它。

在信息理论中，在两个相同长度的字符串之间的海明码距离是：两个字符串相同位置对应的字符不同的位置数目。换种说法，它表示将一个字符串转化为另一个字符串所需要改变字符的最小数目。

下面这些字符串之间的海明码距离：

"karolin"和"kathrin"是3.

"karolin"和"kerstin"是3.

1011101和1001001是2.

2173896和2233796是3.

现在给定两个字符串stra，strb，和一个整数k。对于stra中的一个子串，如果它的长度和strb的相同且它们之间的海明码距离不超过k，我们认为它们是匹配的。

那么我们想知道在stra中有多少子串是和strb是匹配的。

输入

有多组测试（大约100），每个用例占3行。

第一行是stra。

第二行是strb。

第三行是k。

请处理到文件末尾。

【参数说明】

1<=stra，strb的长度<=100000

stra,strb只包含小写字母

0<=k<=5

输出

对于每个测试用例，以输出结果占一行。

样例输入

abcde
f
0
abcde
f
1
karolin
kathrin
3

样例输出

0
5
1

Emacs Normal Vim

题目地址：http://hihocoder.com/problemset/problem/1084

这题数据一般，还有一道2014年北京邀请赛的题 和这题一样，k改为2了，数据很强，地址：http://www.bnuoj.com/v3/problem_show.php?pid=34990；邀请赛这题时限是2s，用后缀数组就是过不去，2000ms+，看了网上别人的代码，也是用后缀数组过不去。不过这标程是后缀数组过的，题解也是。就不知道姿势哪里有问题了。还可以用hash＋二分来做，800ms过邀请赛这题，暂时不会。

两题都是一类问题——模糊匹配。给两个字符串A,B，1=<|A|,|B|<=1e5，求B是否是A的子串，且允许A与B有k个字符不相同，0=<k<=5.

下面这是官方给的题解（我就偷懒不写了

把两个字符拼起来，中间用’*’连接起来。做一下后缀数组。

两个串长度分别为n,m

然后枚举第一个串的开头。来和第二个串匹配。记当前开头为fa,fb

lcp=以fa,fb开头的最长公共前缀。

如果fb+lcp==m则匹配成功。如果k==0匹配失败，否则用掉一个k,。然后fa+=lcp+1,fb+=lcp+1

如果fb==lcp则匹配成功。一直继续下去直到k==0或者匹配成功。

 

总复杂度为(n+m)log(n+m)+n*k

我的代码如下：

//Hello. I'm Peter.
#include<cstdio>
#include<iostream>
#include<sstream>
#include<cstring>
#include<string>
#include<cmath>
#include<cstdlib>
#include<algorithm>
#include<functional>
#include<cctype>
#include<ctime>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>
using namespace std;
typedef long long ll;
typedef long double ld;
#define peter cout<<"i am peter"<<endl
#define input freopen("data.txt","r",stdin)
#define randin srand((unsigned int)time(NULL))
#define INT (0x3f3f3f3f)*2
#define LL (0x3f3f3f3f3f3f3f3f)*2
#define gsize(a) (int)a.size()
#define len(a) (int)strlen(a)
#define slen(s) (int)s.length()
#define pb(a) push_back(a)
#define clr(a) memset(a,0,sizeof(a))
#define clr_minus1(a) memset(a,-1,sizeof(a))
#define clr_INT(a) memset(a,INT,sizeof(a))
#define clr_true(a) memset(a,true,sizeof(a))
#define clr_false(a) memset(a,false,sizeof(a))
#define clr_queue(q) while(!q.empty()) q.pop()
#define clr_stack(s) while(!s.empty()) s.pop()
#define rep(i, a, b) for (int i = a; i < b; i++)
#define dep(i, a, b) for (int i = a; i > b; i--)
#define repin(i, a, b) for (int i = a; i <= b; i++)
#define depin(i, a, b) for (int i = a; i >= b; i--)
#define pi 3.1415926535898
#define eps 1e-6
#define MOD 1000000007
#define MAXN 200100
#define N
#define M
struct Segment_Tree{
    int min;
    int left,right;
}tree[MAXN<<2];
inline void plant_tree(int id,int l,int r,int *a){
    tree[id].left=l,tree[id].right=r;
    if(l==r){
        tree[id].min=a[l];
        return;
    }
    int mid=(l+r)>>1;
    plant_tree(id<<1,l,mid,a);
    plant_tree(id<<1|1,mid+1,r,a);
    tree[id].min=min(tree[id<<1].min,tree[id<<1|1].min);
}
inline int query_min(int id,int l,int r){
    if(tree[id].left==l && tree[id].right==r){
        return tree[id].min;
    }
    int mid=(tree[id].left+tree[id].right)>>1;
    if(r<=mid) return query_min(id<<1,l,r);
    else if(mid<l) return query_min(id<<1|1,l,r);
    else return min(query_min(id<<1,l,mid),query_min(id<<1|1,mid+1,r));
}
int wa[MAXN],wb[MAXN],wv[MAXN],wss[MAXN],sa[MAXN],r[MAXN];
inline int cmp(int *r,int a,int b,int l){
    return r[a]==r[b] && r[a+l]==r[b+l];
}
inline void Build_SuffixArray(int *r,int *sa,int n,int m){
    int i,j,p,*x=wa,*y=wb,*t;
    rep(i,0,m) wss[i]=0;
    rep(i,0,n) wss[x[i]=r[i]]+=1;
    rep(i,1,m) wss[i]+=wss[i-1];
    depin(i,n-1,0) sa[--wss[x[i]]]=i;
    for(j=1,p=1;p<n;j*=2,m=p){
        for(p=0,i=n-j;i<n;i++) y[p++]=i;
        rep(i,0,n) if(sa[i]>=j) y[p++]=sa[i]-j;
        rep(i,0,n) wv[i]=x[y[i]];
        rep(i,0,m) wss[i]=0;
        rep(i,0,n) wss[wv[i]]+=1;
        rep(i,1,m) wss[i]+=wss[i-1];
        depin(i,n-1,0) sa[--wss[wv[i]]]=y[i];
        for(t=x,x=y,y=t,p=1,x[sa[0]]=0,i=1;i<n;i++)
            x[sa[i]]=cmp(y,sa[i-1],sa[i],j)?p-1:p++;
    }
}
int ranking[MAXN],height[MAXN];
inline void Build_heightArray(int *r,int *sa,int n){
    int i,j,k=0;
    repin(i,1,n) ranking[sa[i]]=i;
    for(i=0;i<n;height[ranking[i++]]=k){
        for(k?k--:0,j=sa[ranking[i]-1];r[i+k]==r[j+k];k++);
    }
}
char s[MAXN];
int lens,lenA,lenB,rankB,limitk;
inline bool successful(int posA,int posB,int k){
    if(posA>=lenA) return false;
    int r1=ranking[posA],r2=ranking[posB];
    int minilen;
    if(r1<r2) minilen=query_min(1,r1+1,r2);
    else minilen=query_min(1,r2+1,r1);
    posA+=minilen;
    posB+=minilen;
    if(posA>lenA) return false;
    if(posB==lens) return true;
    posA++;
    posB++;
    k+=1;
    if(k>limitk) return false;
    if(posA>lenA) return false;
    if(posB==lens) return true;
    return successful(posA,posB,k);
}
int main()
{
    while(~scanf("%s",s)){
        lens=lenA=len(s);
        s[lens++]='#';
        scanf("%s %d",s+lens,&limitk);
        lenB=len(s+lens);
        lens+=lenB;
        repin(i,0,lens){
            r[i]=static_cast<int>(s[i]);
        }
        Build_SuffixArray(r,sa,lens+1,'z'+1);
        Build_heightArray(r,sa,lens);
        plant_tree(1,1,lens,height);
        int ans=0;
        rep(i,0,lenA){
            if(lenA-i<lenB) continue;
            bool ok=successful(i,lenA+1,0);
            if(ok){
                ans+=1;
            }
        }
        printf("%d\n",ans);
    }
}