SPOJ 705 New Distinct Substrings

New Distinct Substrings

Time Limit: 2000ms

Memory Limit: 262144KB

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

 

Given a string, we need to find the total number of its distinct substrings.

Input

T- number of test cases. T<=20; Each test case consists of one string, whose length is <= 50000

Output

For each test case output one number saying the number of distinct substrings.

Example

Input:
2
CCCCC
ABABA

Output:
5
9

Source

Base on a problem in ByteCode06

 

解题：求不同子串的个数。后缀数组lcp的应用。

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <climits>
#include <vector>
#include <queue>
#include <cstdlib>
#include <string>
#include <set>
#include <stack>
#define LL long long
#define pii pair<int,int>
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 50010;
int rk[maxn],wb[maxn],wv[maxn],wd[maxn],lcp[maxn];
bool cmp(int *r,int i,int j,int k){
    return r[i] == r[j] && r[i+k] == r[j+k];
}
void da(int *r,int *sa,int n,int m){
    int i,k,p,*x = rk,*y = wb;
    for(i = 0; i < m; ++i) wd[i] = 0;
    for(i = 0; i < n; ++i) wd[x[i] = r[i]]++;
    for(i = 1; i < m; ++i) wd[i] += wd[i-1];
    for(i = n-1; i >= 0; --i) sa[--wd[x[i]]] = i;

    for(p = k = 1; p < n; k <<= 1,m = p){
        for(p = 0,i = n-k; i < n; ++i) y[p++] = i;
        for(i = 0; i < n; ++i) if(sa[i] >= k) y[p++] = sa[i] - k;
        for(i = 0; i < n; ++i) wv[i] = x[y[i]];

        for(i = 0; i < m; ++i) wd[i] = 0;
        for(i = 0; i < n; ++i) wd[wv[i]]++;
        for(i = 1; i < m; ++i) wd[i] += wd[i-1];
        for(i = n-1; i >= 0; --i) sa[--wd[wv[i]]] = y[i];

        swap(x,y);
        x[sa[0]] = 0;
        for(p = i = 1; i < n; ++i)
            x[sa[i]] = cmp(y,sa[i-1],sa[i],k)?p-1:p++;
    }
}
void calcp(int *r,int *sa,int n){
    for(int i = 1; i <= n; ++i) rk[sa[i]] = i;
    int h = 0;
    for(int i = 0; i < n; ++i){
        if(h > 0) h--;
        for(int j = sa[rk[i]-1]; i+h < n && j+h < n; h++)
            if(r[i+h] != r[j+h]) break;
        lcp[rk[i]-1] = h;
    }
}
int r[maxn],sa[maxn];
char str[maxn];
int main() {
    int n;
    scanf("%d",&n);
    while(n--){
        scanf("%s",str);
        int len = strlen(str);
        for(int i = 0; i < len; ++i)
            r[i] = str[i];
        r[len] = 0;
        da(r,sa,len+1,128);
        calcp(r,sa,len);
        int ans = 0;
        for(int i = 1; i <= len; ++i)
            ans += len - sa[i] - lcp[i];
        printf("%d
",ans);
    }
    return 0;
}

后缀自动机

#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
char str[maxn];
int ret,n;
struct SAM{
    struct node{
        int son[26],f,len;
        void init(){
            f = -1;
            len = 0;
            memset(son,-1,sizeof son);
        }
    }e[maxn];
    int tot,last;
    int newnode(int len = 0){
        e[tot].init();
        e[tot].len = len;
        return tot++;
    }
    void init(){
        tot = last = 0;
        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[q].f = e[np].f = nq;
                while(p != -1 && e[p].son[c] == q){
                    e[p].son[c] = nq;
                    p = e[p].f;
                }
            }
        }
        last = np;
    }
    void solve(){
        ret = 0;
        for(int i = 1; i < tot; ++i)
            ret += e[i].len - e[e[i].f].len;
        printf("%d
",ret);
    }
}sam;

int main(){
    int kase;
    scanf("%d",&kase);
    while(kase--){
        scanf("%s",str);
        n = strlen(str);
        sam.init();
        for(int i = ret = 0; str[i]; ++i)
            sam.extend(str[i]-'A');
        sam.solve();
    }
    return 0;
}