SPOJ 8222 Substrings（SAM）

转载请注明出处，谢谢http://blog.csdn.net/ACM_cxlove?viewmode=contents    by---cxlove

题意：给一个字符串S，令F(x)表示S的所有长度为x的子串中，出现次数的最大值。求F(1)..F(Length(S))（感谢clj的翻译>_<）

http://www.spoj.pl/problems/NSUBSTR/

建立 SAM的时候，结点的len值表示那一时刻的后缀长度，虽然最后不一定是后缀，可以表示成一个子串的长度 。

从当前状态出发，能到达终态的路径数目便是当前长度子串出现的次数，取最值就行了。

做法是将SAM上的结点拓扑一下，从后往前遍历，从子结点更新父结点(SAM上的pre其实并非是父结点).

最后还有一种情况便是子串完全包含的情况，也就是长度长的子串包含各种长度 短的子串

拓扑的那步是看别人的，SPOJ时限太紧。利用长度进行一个映射。

对于SAM，还是不太懂，可接受后缀的结点。

最简单的，怎样遍历出串的所有后缀

#include<iostream>
#include<cstdio>
#include<map>
#include<cstring>
#include<cmath>
#include<vector>
#include<algorithm>
#include<set>
#include<string>
#include<queue>
#define inf 100000005
#define M 40
#define N 510005
#define maxn 300005
#define eps 1e-10
#define zero(a) fabs(a)<eps
#define Min(a,b) ((a)<(b)?(a):(b))
#define Max(a,b) ((a)>(b)?(a):(b))
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
#define mem(a,b) memset(a,b,sizeof(a))
#define LL unsigned long long
#define MOD 1000000007
#define lson step<<1
#define rson step<<1|1
#define sqr(a) ((a)*(a))
#define Key_value ch[ch[root][1]][0]
#define test puts("OK");
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
struct SAM
{
    SAM *pre,*son[26];
    int len,g;
}que[N],*root,*tail,*b[N];
int tot;
void add(int c,int l)
{
    SAM *p=tail,*np=&que[tot++];
    np->len=l;tail=np;
    while(p&&p->son[c]==NULL) p->son[c]=np,p=p->pre;
    if(p==NULL) np->pre=root;
    else
    {
        SAM *q=p->son[c];
        if(p->len+1==q->len) np->pre=q;
        else
        {
            SAM *nq=&que[tot++];
            *nq=*q;
            nq->len=p->len+1;
            np->pre=q->pre=nq;
            while(p&&p->son[c]==q) p->son[c]=nq,p=p->pre;
        }
    }
}
char str[N/2];
int dp[N/2];
int main()
{
    while(scanf("%s",str)!=EOF)
    {
        int n=strlen(str);
        tot=0;
        root=tail=&que[tot++];
        for(int i=0;i<n;i++) add(str[i]-'a',i+1);
        int cnt[N/2];mem(cnt,0);
        for(int i=0;i<tot;i++) cnt[que[i].len]++;
        for(int i=1;i<=n;i++) cnt[i]+=cnt[i-1];///cnt[i]表示长度<=i的节点的个数。
        for(int i=0;i<tot;i++)  b[--cnt[que[i].len]]=&que[i];///这里是按节点的长度排序吧？？
        for(int i=0;i<n;i++) (root=root->son[str[i]-'a'])->g++;///可达路径初始化为1
        mem(dp,0);//dp[i]表示的就是长度为i的子串重复出现的最多次数。
        for(int i=tot-1;i>0;i--)
        {
            dp[b[i]->len]=max(dp[b[i]->len],b[i]->g);//b[i]->g 表示b[i]这个节点可到达终态的路径数目。
            if(b[i]->pre) b[i]->pre->g+=b[i]->g;//如果b[i]这个节点的上一个可接受后缀的节点不是根，则b[i]可以接的后缀b[i]->pre一定可以接。
        }
        for(int i=n-1;i>0;i--) dp[i]=max(dp[i],dp[i+1]);
        for(int i=1;i<=n;i++) printf("%d\n",dp[i]);
    }
    return 0;
}

 

 自己的代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define maxn 500080
char str[maxn];
struct SAM
{
    SAM *pre,*son[26];
    int len,g;
}que[maxn],*root,*tail,*b[maxn];
int tot;
int C[maxn],dp[maxn];
void add(int c,int l)
{
    SAM *p=tail,*np=&que[tot++];
    np->len=l;tail=np;
    while(p&&p->son[c]==NULL) p->son[c]=np,p=p->pre;
    if(p==NULL) np->pre=root;
    else
    {
        SAM *q=p->son[c];
        if(p->len+1==q->len) np->pre=q;
        else
        {
            SAM *nq=&que[tot++];
            *nq=*q;
            nq->len=p->len+1;
            np->pre=q->pre=nq;
            while(p&&p->son[c]==q) p->son[c]=nq,p=p->pre;
        }
    }
}

void init(int n)
{
	tot = 0;
	for(int i = 0;i < n;i++)
	{
		que[i].g = 0;	que[i].pre = NULL;
		memset(que[i].son,0,sizeof(que[i].son));
	}
	root = tail = &que[tot++];
	memset(C,0,sizeof(C));
	memset(dp,0,sizeof(dp));
}

inline int max(int a,int b)
{
	return a>b?a:b;
}

int main()
{
	//freopen("in.txt","r",stdin);
	while(scanf("%s",str)!=EOF)
	{
		int len = strlen(str);
		init(len << 1);
		for(int i = 0;i < len;i++)
		{
			add(str[i] - 'a',i+1);
		}
		//SAM建好了，接下来要对可达路径进行初始化
		SAM * now = &que[0];
		for(int i = 0;i < len;i++)
		{
			(now = now -> son[str[i] - 'a']) -> g++;
		}
		//还得对所有状态进行拓扑排序。
		for(int i = 0;i < tot;i++)	C[que[i].len]++;
		for(int i = 1;i <= len;i++)	C[i] += C[i-1];
		for(int i=0;i<tot;i++)  b[--C[que[i].len]]=&que[i];
		for(int i = tot-1;i > 0;i--)
		{
			dp[b[i] -> len] = max(dp[b[i] -> len],b[i] -> g);
			if(b[i] -> pre)
			{
				b[i] -> pre -> g += b[i] -> g;
			}
		}
		for(int i = len - 1;i > 0;i--)
		{
			dp[i] = max(dp[i],dp[i+1]);
		}
		for(int i = 1;i <= len;i++)
		{
			printf("%d\n",dp[i]);
		}
	}
	return 0;
}