SPOJ 8222 Substrings

题意:
给一个字符串S，令F(x)表示S的所有长度为x的子串中，出现次数的最大值。
求F(1)..F(Length(S)) Length(S) <= 250000

题解：
我们构造S的SAM，那么对于一个节点s，它表示的串长度范围是[Min(s),Max(s)]，同时他的出现次数是|Right(s)|。

那么我们用 |Right(s)|去更新F(Max(s))的值。同时最后从大到小依次用F(i)去更新F(i-1)即可。

对于SAM，我口胡几句吧
自动机每个结点信息是一个right集合
比如串aaabbaaabd
aaab在其中1-4 6-9出现
则自动机在读入aaab到达的结点是{4,9}
aab和ab也应该到达这个结点，因为他们出现的结尾也是{4,9}
而b是{4,5,9}不到达这个结点
显然，于一个状态s，若长度l<=r所对应的al，ar满足
ST(al)=ST(ar)=s那么对于任意的l<=x<=r，ST(ax)=s
不妨设s所有合法集合为[Min(s),Max(s)]
al指的是串a的前l个
显然节点信息是集合包含关系
随着串长增加就是集合元素减少
构建自动机的目标就是让所有包含关系变为一棵树

//      whn6325689
//      Mr.Phoebe
//      http://blog.csdn.net/u013007900
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#include <functional>
#include <numeric>
#pragma comment(linker, "/STACK:1024000000,1024000000")

using namespace std;

#define eps 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
#define LLINF 1LL<<62
#define speed std::ios::sync_with_stdio(false);

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef complex<ld> point;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
typedef vector<int> vi;

#define CLR(x,y) memset(x,y,sizeof(x))
#define CPY(x,y) memcpy(x,y,sizeof(x))
#define clr(a,x,size) memset(a,x,sizeof(a[0])*(size))
#define cpy(a,x,size) memcpy(a,x,sizeof(a[0])*(size))

#define mp(x,y) make_pair(x,y)
#define pb(x) push_back(x)
#define lowbit(x) (x&(-x))

#define MID(x,y) (x+((y-x)>>1))
#define ls (idx<<1)
#define rs (idx<<1|1)
#define lson ls,l,mid
#define rson rs,mid+1,r
#define root 1,1,n

template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1;
    char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
template <class T>
inline void write(T n)
{
    if(n < 0)
    {
        putchar('-');
        n = -n;
    }
    int len = 0,data[20];
    while(n)
    {
        data[len++] = n%10;
        n /= 10;
    }
    if(!len) data[len++] = 0;
    while(len--) putchar(data[len]+48);
}
//-----------------------------------

const int MAXN=250010*2;
const int MAC=26;

/*
max：即代码中 len 变量，它表示该状态能够接受的最长的字符串长度。
min：表示该状态能够接受的最短的字符串长度。实际上等于该状态的 fail 指针指向的结点的 len + 1。
max-min+1：表示该状态能够接受的不同的字符串数。
right：即 end-set 的个数，表示这个状态在字符串中出现了多少次，该状态能够表示的所有字符串均出现过 right 次。
fail：fail 指向了一个能够表示当前状态表示的所有字符串的最长公共后缀的结点。所有的状态的 fail 指针构成了一个 fail 树，恰好是字符串的逆序的后缀树。
fail 树的拓扑序：序列中第i个状态的子结点必定在它之后，父结点必定在它之前。
*/

struct SAM
{
    int len[MAXN],next[MAXN][MAC],fa[MAXN],L,last;
    int dp[MAXN],right[MAXN];
    int sum[MAXN],topo[MAXN];

    SAM(){init();}
    void init()
    {
        L=0;last=newnode(0,-1);
    }
    int newnode(int l,int pre)
    {
        fa[L]=pre;
        dp[L]=right[L]=0;
        for(int i=0;i<MAC;i++)  next[L][i]=-1;
        len[L]=l;
        return L++;
    }
    void build(char *p)
    {
        int le=strlen(p);
        for(int i=0;i<le;i++)
            add(p[i]-'a');
        toposort();
        for(int i=L-1;i>=0;i--)
        {
            int u=topo[i];
            if(~fa[u])
                right[fa[u]]+=right[u];
        }
        for(int i=0;i<L;i++)
            dp[len[i]]=max(dp[len[i]],right[i]);
        for(int i=L-1;i>=0;i--)
            dp[i]=max(dp[i],dp[i+1]);
    }
    void add(int x)
    {
        int pre=last,now=newnode(len[pre]+1,-1);
        last=now;right[now]++;
        while(~pre && next[pre][x]==-1)
        {
            next[pre][x]=now;
            pre=fa[pre];
        }
        if(pre==-1) fa[now]=0;
        else
        {
            int bro=next[pre][x];
            if(len[bro]==len[pre]+1)
            {
                fa[now]=bro;
            }
            else
            {
                int fail=newnode(len[pre]+1,fa[bro]);
                for(int i=0;i<MAC;i++)  next[fail][i]=next[bro][i];
                fa[bro]=fa[now]=fail;
                while(~pre && next[pre][x]==bro)
                {
                    next[pre][x]=fail;pre=fa[pre];
                }
            }
        }
    }

    void toposort()
    {
        CLR(sum,0);
        for(int i=0;i<L;i++)    sum[len[i]]++;
        for(int i=1;i<L;i++)    sum[i]+=sum[i-1];
        for(int i=0;i<L;i++)    topo[--sum[len[i]]]=i;
    }

}T;

char str[MAXN>>1];

int main()
{
    int n;
    scanf("%s",str);
    T.build(str);n=strlen(str);
    for(int i=1;i<=n;i++)
        printf("%d\n",T.dp[i]);
    return 0;
}

还有一种是在之后类似dfs的方式在树上更新right

#include<bits/stdc++.h>
#define MAXN 500010
typedef long long LL;
struct sam{
    int len[MAXN],next[MAXN][26],fail[MAXN],L,last,dp[MAXN],num[MAXN],right[MAXN];
    sam(){
        init();
    }
    void init(){
        L=0;
        last=newnode(0,-1);
        memset(dp,0,sizeof dp);
    }
    int newnode(int l,int pre)
    {
        fail[L]=pre;
        for(int i=0;i<26;i++)next[L][i]=-1;
        len[L]=l;
        L++;
        return L-1;
    }
    void add(int x,int l)
    {
        int pre=last,now=newnode(l+1,-1);
        last=now;
        while(~pre&&next[pre][x]==-1){
            next[pre][x]=now;
            dp[now]+=dp[pre];
            pre=fail[pre];
        }
        if(pre==-1)fail[now]=0;
        else{
            int bro=next[pre][x];
            if(len[bro]==len[pre]+1){
                fail[now]=bro;
            }
            else{
                int fa=newnode(len[pre]+1,fail[bro]);
                for(int i=0;i<26;i++){
                    next[fa][i]=next[bro][i];
                }
                fail[bro]=fa,fail[now]=fa;
                while(~pre&&next[pre][x]==bro){
                    next[pre][x]=fa;
                    pre=fail[pre];
                }
            }
        }
    }
    void print(){
        for(int i=0;i<L;i++){
            for(int j=0;j<26;j++){
                if(~next[i][j]){
                  //  printf("next[%d][%d]=%d\n",i,j,next[i][j]);
                }
            }
        }
    }
    void build(std::string s)
    {
        memset(dp,0,sizeof dp);
        memset(right,0,sizeof right);
        memset(num,0,sizeof num);
        int n=s.length(),pre=0;
        for(int i=0;i<n;i++){
            int x=s[i]-'a';
            if(~next[pre][x]){
                pre=next[pre][x];
            }
            else{
                while(pre&&next[pre][x]==-1){
                    pre=fail[pre];
                }
                if(pre){
                    pre=next[pre][x];
                }
            }
            right[pre]++;
        }
       // print();
        std::queue<int> que;
        for(int i=0;i<L;i++){
           // printf("rigt[__%d\n")
            if(~fail[i])num[fail[i]]++;
        }
        for(int i=0;i<L;i++){
            if(!num[i]&&i)que.push(i);
        }
        while(!que.empty()){
            int v=que.front();que.pop();
          //  printf("%d___%d___%d\n",v,fail[v],right[v]);
            if(~fail[v]){
                right[fail[v]]+=right[v];
                num[fail[v]]--;
                if(!num[fail[v]])que.push(fail[v]);
            }
        }
        for(int i=0;i<L;i++){
            dp[len[i]]=std::max(dp[len[i]],right[i]);
        }
     //   print();
    }
}SAM;
std::string A;
int main()
{
    std::cin>>A;
    SAM.init();
    int n=A.length();
    for(int i=0;i<n;i++){
        SAM.add(A[i]-'a',i);
    }
    SAM.build(A);
    for(int i=1;i<=n;i++)printf("%d\n",SAM.dp[i]);
    return 0;
}