题解转自:http://blog.csdn.net/dyx404514/article/details/8807440

2012杭州网络赛的一道题，后缀数组后缀自己主动机都行吧。

题目大意：给一个字符串S和一系列字符串T1~Tn，问在S中有多少个不同子串满足它不是T1~Tn中随意一个字符串的子串。

思路：我们先构造S的后缀自己主动机，然后将每个Ti在S的SAM上做匹配，类似于LCS，在S中的每个状态记录一个变量deep，表示T1~Tn，在该状态能匹配的最大长度是多少，将每个Ti匹配完之后，我们将S的SAM做拓扑排序，自底向上更新每个状态的deep，同一时候计算在该状态上有多少个子串满足题目要求。详细过程例如以下：

1：对于当前状态，设为p，设p的par为q，则更新q->deep为q->deep和p->deep中的较大值。

2：若p->deep<p->val,则表示在状态p中，长度为p->deep+1~p->val的子串不是T1~Tn中随意字符串的子串，所以答案加上p->val-p->deep。否则表示状态p中全部字串均不满足要求，跳过就可以。

(注意若p->deep==0，表示状态p中全部的子串均满足题目要求，可是答案不是加上p->val-0，而是加上 p->val-p->par->val，这表示状态p中的字符串个数，所以对于p->deep==0要特殊处理)

最后输出答案就可以。

Good Article Good sentence

3
2
abab
ab
ba
1
aaa
bbb
2
aaaa
aa
aaa

Case 1: 3
Case 2: 3
Case 3: 1

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int maxn=110000;

struct SAM_Node
{
    SAM_Node *fa,*next[26];
    int len,id,pos;
    SAM_Node(){}
    SAM_Node(int _len)
    {
        len=_len;
        fa=0; memset(next,0,sizeof(next));
    }
};

SAM_Node SAM_node[maxn*2],*SAM_root,*SAM_last;
int SAM_size;

SAM_Node *newSAM_Node(int len)
{
    SAM_node[SAM_size]=SAM_Node(len);
    SAM_node[SAM_size].id=SAM_size;
    return &SAM_node[SAM_size++];
}

SAM_Node *newSAM_Node(SAM_Node *p)
{
    SAM_node[SAM_size]=*p;
    SAM_node[SAM_size].id=SAM_size;
    return &SAM_node[SAM_size++];
}

void SAM_init()
{
    SAM_size=0;
    SAM_root=SAM_last=newSAM_Node(0);
    SAM_node[0].pos=0;
}

void SAM_add(int x,int len)
{
    SAM_Node *p=SAM_last,*np=newSAM_Node(p->len+1);
    np->pos=len; SAM_last=np;
    for(;p&&!p->next[x];p=p->fa)
        p->next[x]=np;
    if(!p)
    {
        np->fa=SAM_root;
        return ;
    }
    SAM_Node *q=p->next[x];
    if(q->len==p->len+1)
    {
        np->fa=q;
        return ;
    }
    SAM_Node *nq=newSAM_Node(q);
    nq->len=p->len+1;
    q->fa=nq; np->fa=nq;
    for(;p&&p->next[x]==q;p=p->fa)
        p->next[x]=nq;
}

char A[maxn],B[maxn];
int c[maxn*2],LCS[maxn*2];
SAM_Node *top[maxn*2];

int main()
{
    int T_T,T,cas=1;
    scanf("%d",&T_T);
    while(T_T--)
    {
        scanf("%d",&T);
        scanf("%s",A);
        int len=strlen(A);
        SAM_init();
        for(int i=0;i<len;i++)
            SAM_add(A[i]-'a',i+1);

        memset(c,0,sizeof(c));
        memset(LCS,0,sizeof(LCS));
        memset(top,0,sizeof(top));

        for(int i=0;i<SAM_size;i++)
            c[SAM_node[i].len]++;
        for(int i=1;i<=len;i++)
            c[i]+=c[i-1];
        for(int i=0;i<SAM_size;i++)
            top[--c[SAM_node[i].len]]=&SAM_node[i];
        while(T--)
        {
            scanf("%s",B);
            int len2=strlen(B);
            int temp=0; SAM_Node *now=SAM_root;

            for(int i=0;i<len2;i++)
            {
                int x=B[i]-'a';
                if(now->next[x])
                {
                    temp++;
                    now=now->next[x];
                    LCS[now->id]=max(LCS[now->id],temp);
                }
                else
                {
                    while(now&&!now->next[x])
                        now=now->fa;
                    if(now)
                    {
                        temp=now->len+1;
                        now=now->next[x];
                        LCS[now->id]=max(LCS[now->id],temp);
                    }
                    else
                    {
                        temp=0; now=SAM_root;
                    }
                }
            }
        }
        long long int ans=0;
        for(int i=SAM_size-1;i>=1;i--)
        {
            SAM_Node *p=top[i];
            if(LCS[p->id])
            {
                if(p->fa)
                    LCS[p->fa->id]=max(LCS[p->fa->id],LCS[p->id]);
                if(LCS[p->id]<p->len)
                {
                    ans+=p->len-LCS[p->id];
                }
            }
            else
            {
                ans+=p->len-p->fa->len;
            }
        }
        printf("Case %d: %I64d\n",cas++,ans);
    }
    return 0;
}