lightoj-1427：Substring Frequency

A string is a finite sequence of symbols that are chosen from an alphabet. In this problem you are given a string Tand n queries each with a string P_i, where the strings contain lower case English alphabets only. You have to find the number of times P_i occurs as a substring of T.

Input

Input starts with an integer T (≤ 10), denoting the number of test cases.

Each case starts with a line containing an integer n (1 ≤ n ≤ 500). The next line contains the string T (1 ≤ |T| ≤ 10⁶). Each of the next n lines contains a string P_i (1 ≤ |P_i| ≤ 500).

Output

For each case, print the case number in a single line first. Then for each string P_i, report the number of times it occurs as a substring of T in a single line.

Sample Input	Output for Sample Input
2 5 ababacbabc aba ba ac a abc 3 lightoj oj light lit	Case 1: 2 3 1 4 1 Case 2: 1 1 0

刚开始没看题目，用kmp做，超时，后来看了一下主题，知道要用AC算法。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <vector>
#include <list>
using namespace std;

char t[1000002];

int** gt;
int* fail;
int* output;

int map[500];

char query[500][501];

int stateNum,maxStateNum;
int queryNum;

void generateGoto();
void generateFail();
void parse();

int main()
{
	int caseNum;

	maxStateNum=250;
	fail=NULL;
	output=(int*)malloc(sizeof(int)*maxStateNum);
	gt=(int**)malloc(sizeof(int*)*maxStateNum);

	for(int i=0;i<maxStateNum;++i)
		gt[i]=(int*)malloc(sizeof(int)*26);

	for(int i=0;i<maxStateNum;++i)
	{
		for(int j=0;j<26;++j)
			gt[i][j]=-1;
		fail[i]=-1;
		output[i]=-1;
	}
	

	scanf("%d",&caseNum);

	for(int i=0;i<caseNum;++i)
	{
		scanf("%d",&queryNum);
		memset(t,0,1000002);
		scanf("%s",t);
		for(int j=0;j<queryNum;++j)
		{
			memset(query[j],0,501);
			scanf("%s",query[j]);
		}
		
		stateNum=0;
		generateGoto();
		if(fail!=NULL)
			free(fail);
		fail=(int*)malloc(sizeof(int)*maxStateNum);
		for(int x=0;x<maxStateNum;++x)
			fail[x]=-1;
		generateFail();
		parse();

		printf("Case %d:\n",i+1);
		for(int p=0;p<queryNum;++p)
			printf("%d\n",output[map[p]]);
		for(int p=0;p<=stateNum;++p)
		{
			for(int q=0;q<26;++q)
				gt[p][q]=-1;
			fail[p]=output[p]=-1;
		}
	}
	return 0;
}

void generateGoto()
{
	for(int i=0;i<queryNum;++i)
	{
		int pos_gt=0;
		for(int j=0;query[i][j]!='\0';++j)
		{
			if(gt[pos_gt][query[i][j]-'a']==-1)
			{
				gt[pos_gt][query[i][j]-'a']=++stateNum;
				pos_gt=stateNum;
			}
			else
				pos_gt=gt[pos_gt][query[i][j]-'a'];
			
			if(stateNum==maxStateNum)
			{
				maxStateNum*=2;
				int** tmp=(int**)malloc(sizeof(int*)*maxStateNum);
				for(int x=0;x<maxStateNum;++x)
					tmp[x]=(int*)malloc(sizeof(int)*26);
				for(int x=0;x<stateNum;++x)
				{
					for(int y=0;y<26;++y)
						tmp[x][y]=gt[x][y];
					free(gt[x]);
				}
				free(gt);
				for(int x=stateNum;x<maxStateNum;++x)
					for(int y=0;y<26;++y)
						tmp[x][y]=-1;
				gt=tmp;

				int* ot=(int*)malloc(sizeof(int)*maxStateNum);
				for(int i=0;i<stateNum;++i)
					ot[i]=output[i];
				for(int i=stateNum;i<maxStateNum;++i)
					ot[i]=-1;
				free(output);
				output=ot;
			}
		}

		output[pos_gt]=0;
		map[i]=pos_gt;
	}
	for(int i=0;i<26;++i)
		if(gt[0][i]==-1)
			gt[0][i]=0;
}

产生goto表，每次有新的模式，从起始状态开始，若存在相应的路径，则变换到该路径的状态，若没有，则创建新的状态，并转到该状态。

void generateFail()
{
	int maxSizeOfQueue=500;
	list<int> queue;
	fail[0]=0;
	for(int i=0;i<26;++i)
		if(gt[0][i]!=-1&>[0][i]!=0)
		{
			queue.push_back(gt[0][i]);
			fail[gt[0][i]]=0;
		}

	while(!queue.empty())
	{
		int currentState=queue.front();
		queue.pop_front();
		for(int i=0;i<26;++i)
			if(gt[currentState][i]!=-1&>[currentState][i]!=0)
			{
				int st=fail[currentState];
				while(gt[st][i]==-1)
					st=fail[st];
				fail[gt[currentState][i]]=gt[st][i];
				queue.push_back(gt[currentState][i]);
			}
	}
}

从0状态开始，0状态不会失败，1状态失败总是到0。然后层次遍历，对于fail[r]，查看他的前一个状态p,p和r之间有‘a’边，若fail[p]存在‘a’的边，则fail[r]=goto(fail[p],a)。若没有，则检查fail[fail[p]],直到存在.0状态不会失败，确保迭代终止。

void parse()
{
	int pos_gt=0;
	for(int i=0;t[i]!='\0';++i)
	{
		while(gt[pos_gt][t[i]-'a']==-1)
			pos_gt=fail[pos_gt];
		pos_gt=gt[pos_gt][t[i]-'a'];
		int tgt=pos_gt;
		while(tgt!=0)
		{
			if(output[tgt]!=-1)
				++output[tgt];
			tgt=fail[tgt];
		}
	}
}

最后遍历主串。