SPOJ NSUBSTR - Substrings 后缀自动机

考察对father链的理解……

求长度为k的子串，出现次数最多的，出现多少次。

然后强行询问len次， 分别为1..len。

1、建立后缀自动机。

2、显然我们有若干个状态（我对状态的理解不够深刻），

对于主状态（就是整个串的最长链）上任意一个状态，如果到了这个状态意味着什么？

3、意味着，这个状态的所有father实际上也到达了。 

4、根据后缀自动机的性质， 一个状态跳回的father状态，那么一定可以到father状态的len。 （我都在说一些什么啊！）

5、拓扑排序，倒着DP即可。

6、一旦我们能得到一个长度为8的合法串出现次数，那么长度为7的合法串出现的次数…… 可以是长为8的串里长为7的部分！ 

我都看不懂我再说什么！

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
using namespace std;


const int CHAR = 26;
const int MAXN = 250000 * 2  + 100;
char str[MAXN];

bool duanyan(bool flag)
{
	if (!flag)
	{
		throw 0;
	}
}

struct SAM_Node
{
	SAM_Node *fa, *next[CHAR];
	int len;
	int id, pos;
	int dp;
	SAM_Node(){}
	SAM_Node(int _len)
	{
		fa = 0;
		len = _len;
		dp=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; 
	SAM_node[SAM_size].dp = 0; 
	return &SAM_node[SAM_size++];
}

SAM_Node *newSAM_Node(SAM_Node *p)
{
	SAM_node[SAM_size] = *p;
	SAM_node[SAM_size].id = SAM_size;
	SAM_node[SAM_size].dp = 0; 
	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;
}

int topcnt[MAXN];
SAM_Node *topsam[MAXN*2];

void SAM_build(char *s)
{
	SAM_init();
	int len = strlen(s);
	for (int i = 0 ;i < len; ++ i)
		SAM_add(s[i] - 'a' , i + 1);
}

void SAM_search()
{
	SAM_Node *now = SAM_root;
	int len = strlen(str);
	int ans = 0;
	int maxans =0;
	for (int i = 0; i < len; ++ i)
	{
		int t = str[i] - 'a';
		if (now -> next[t])
		{
			now =now -> next[t];
			++ans;
		}
		else
		{
			while (now != SAM_root && !now -> next[t])	now = now -> fa;
			if (now -> next[t])
			{
				ans = now -> len + 1;
				now = now -> next[t];
			}
			else
			{
				now = SAM_root;
				ans = 0;
			}

		}
		maxans = max(maxans, ans);
	}
	cout << maxans << endl;
}

int r[MAXN], f[MAXN];

void doit()
{
	int n = strlen(str);
	SAM_build(str);

	/*
	for (int i = 0; i < SAM_size; ++ i)
	{
		cout <<"@"<< SAM_node[i].id<< endl;
		for (int j = 0; j < 26; ++ j)
		{
			if (SAM_node[i].next[j])
			{
				cout << SAM_node[i].next[j] -> id << endl;
			}
		}
		if (i)
		cout << "fa: " << SAM_node[i].fa -> id << endl;
		cout<<"===="<<endl;
	}
	exit(0);
	*/

	memset(topcnt, 0, sizeof(topcnt));
	memset(f, 0, sizeof(f));
	memset(r, 0, sizeof(r));
	for (int i = 0; i < SAM_size; ++ i)
		topcnt[SAM_node[i].len] ++ ;
	for (int i = 1; i <= n; ++ i)
		topcnt[i] += topcnt[i - 1];
	for (int i = 0; i < SAM_size ; ++ i)
		topsam[-- topcnt[SAM_node[i].len]] = &SAM_node[i];
	//topsam[i]第i个是谁，满足拓扑序
	
	SAM_Node *now = SAM_root;
	//cout<<"@"<<endl;
	for (int i = 0; i < n; ++ i)
	{
		int t = str[i] - 'a';
		now = now -> next[t];
		r[now -> id] = 1;
	}

	//cout<<"!"<<endl;

	for (int i = SAM_size -1; i > 0; -- i)
	{
		SAM_Node* p = topsam[i];
		//cout<< p->id <<endl;
		//cout<<"!!"<< p->fa->id << endl;
		r[(p->fa)->id] += r[p->id];
	}



	//cout<<"x"<<endl;
	for (int i = 1; i < SAM_size; ++ i)
	{
		f[SAM_node[i].len] = max(f[SAM_node[i].len] , r[i]);
	}
	for (int i = n; i >= 0; -- i)
		f[i] = max(f[i + 1], f[i]);
	for (int i = 1; i <= n; ++ i)
		printf("%d\n", f[i]);
}


int main()
{
	int t;
	while (~scanf("%s", str))
	{
		doit();
	}
	return 0;
}