POJ 3415 Common Substrings

Common Substrings

Time Limit: 5000ms

Memory Limit: 65536KB

This problem will be judged on PKU. Original ID: 3415
64-bit integer IO format: %lld      Java class name: Main

A substring of a string T is defined as:

[T(i, k)=T_iT_{i+1}dots T_{i+k-1}, 1leq ileq i+k-1leq |T|.]

Given two strings A, B and one integer K, we define S, a set of triples (i, j, k):

[S = {(i, j, k) | kgeq K, A(i, k)=B(j, k)}.]

You are to give the value of |S| for specific A, B and K.

 

Input

The input file contains several blocks of data. For each block, the first line contains one integer K, followed by two lines containing strings A and B, respectively. The input file is ended by K=0.

$1 leq |A|, |B| leq 10^5,1 leq  Kleq  min{|A|, |B|}$ Characters of A and B are all Latin letters.

 

Output

For each case, output an integer |S|.

 

Sample Input

2
aababaa
abaabaa
1
xx
xx
0

Sample Output

22
5

Source

POJ Monthly--2007.10.06

 

解题：后缀自动机

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn = 100010;
typedef long long LL;
int ha(char ch){
    if(ch >= 'a' && ch <= 'z') return ch - 'a';
    return ch - 'A' + 26;
}
struct SAM{
    struct node{
        int son[52],f,len;
        void init(int _len){
            f = -1;
            len = _len;
            memset(son,-1,sizeof son);
        }
    }e[maxn<<1];
    int cnt[maxn<<1],lazy[maxn<<1],tot,last;
    int c[maxn<<1],sa[maxn<<1];
    int newnode(int len = 0){
        e[tot].init(len);
        return tot++;
    }
    void init(){
        tot = last = 0;
        memset(cnt,0,sizeof cnt);
        memset(lazy,0,sizeof lazy);
        memset(c,0,sizeof c);
        newnode();
    }
    void extend(int c){
        int p = last,np = newnode(e[p].len + 1);
        while(p != -1 && e[p].son[c] == -1){
            e[p].son[c] = np;
            p = e[p].f;
        }
        if(p == -1) e[np].f = 0;
        else{
            int q = e[p].son[c];
            if(e[p].len + 1 == e[q].len) e[np].f = q;
            else{
                int nq = newnode();
                e[nq] = e[q];
                e[nq].len = e[p].len + 1;
                e[np].f = e[q].f = nq;
                while(p != -1 && e[p].son[c] == q){
                    e[p].son[c] = nq;
                    p = e[p].f;
                }
            }
        }
        cnt[last = np] = 1;
    }
    void update(){
        for(int i = tot-1; i > 0; --i)
            cnt[e[sa[i]].f] += cnt[sa[i]];
    }
    void sort(int len){
        for(int i = 0; i < tot; ++i) c[e[i].len]++;
        for(int i = 1; i <= len; ++i) c[i] += c[i-1];
        for(int i = tot-1; i >= 0; --i) sa[--c[e[i].len]] = i;
    }
    LL solve(char str[],int k,LL ret = 0){
        int p = 0,tmp = 0;
        for(int i = 0; str[i]; ++i){
            int c = ha(str[i]);
            if(~e[p].son[c]){
                p = e[p].son[c];
                ++tmp;
            }else{
                while(p != -1 && e[p].son[c] == -1) p = e[p].f;
                if(p == -1) {
                    p = 0;
                    tmp = 0;
                }else{
                    tmp = e[p].len + 1;
                    p = e[p].son[c];
                }
            }
            if(tmp >= k){
                ret += (tmp - max(k,e[e[p].f].len + 1) + 1)*cnt[p];
                if(k <= e[e[p].f].len) ++lazy[e[p].f];
            }
        }
        for(int i = tot-1; i > 0; --i){
            int u = sa[i];
            ret += (LL)lazy[u]*(e[u].len - max(k,e[e[u].f].len + 1) + 1)*cnt[u];
            if(k <= e[e[u].f].len) lazy[e[u].f] += lazy[u];
        }
        return ret;
    }
}sam;
char str[maxn];
int main(){
    int k;
    while(scanf("%d",&k),k){
        scanf("%s",str);
        sam.init();
        for(int i = 0; str[i]; ++i)
            sam.extend(ha(str[i]));
        sam.sort(strlen(str));
        sam.update();
        scanf("%s",str);
        printf("%lld
",sam.solve(str,k));
    }
    return 0;
}