POJ 2778 AC自动机+DP+矩阵优化

获得矩阵乘法板子一个（主要是非递归实现乘法）

const int mat_size = 102;//矩阵大小
struct mat
{
	long long a[mat_size][mat_size];
	int x, y;//长宽
	mat()
	{
		memset(a,0,sizeof(a));
	}
};

const long long mod = 100000;

mat operator * (const mat &A, const mat &B)//矩阵乘法
{
	mat tmp;
	for (int i = 0; i < A.x; ++ i)
		for (int j = 0; j < B.y; ++ j)
		{
			tmp.a[i][j] = 0;
			for (int k = 0; k < A.y; ++ k)
			{
				tmp.a[i][j] = (tmp.a[i][j] + A.a[i][k] * B.a[k][j]) % mod;
			}
		}
	tmp.x=A.x;
	tmp.y=B.y;
	return tmp;
}

void pg(mat A)//输出A矩阵
{
	for (int i = 0; i <A.x; ++i)
	{
		for (int j = 0; j < A.y;++j)	cout<<A.a[i][j]<<" ";cout<<endl;
	}
	cout<<endl;
}

mat powMat(mat A , int b)//a^b矩阵A的b次方
{  
	mat ret;  
	bool flag=0;
	while( b )  
	{  
		if( b & 1 )
		{
			if (!flag)
			{
				flag=1;
				ret = A;
			}
			else 	ret = ret * A ;  
		}
		b >>= 1 ;  
		A = A * A ;  
	}  
	return ret ;  
}  

然后就是简单的DP，转移成矩阵做。貌似也没有卡常什么的，主要是矩阵乘法的地方，需要用非递归，不然炸栈空间的。

#include<cstring>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include<queue>
#include<cstdio>
#include<map>
#include<string>
using namespace std;

const int SIGMA_SIZE = 4;
const int MAXNODE = 56789;
#define prln(x)	cout<<#x<<" = "<<x<<endl
#define pr(x)	cout<<#x<<" = "<<x<<" "

int n,L;
char pattern[15][15];

/*
 * AC自动机，令g[i,j]表示从i到j这一路遍历的所有字符串。 f[i]的意义就是g[?,i]和g[0,f[i]]的字符串是相等的
 * last[i] ,表示g[0,last[i]]的字符串，是确定存在的，并且以last[i]结尾的字符串*/


const int mat_size = 102;//矩阵大小
struct mat
{
	long long a[mat_size][mat_size];
	int x, y;//长宽
	mat()
	{
		memset(a,0,sizeof(a));
	}
};

const long long mod = 100000;

mat operator * (const mat &A, const mat &B)//矩阵乘法
{
	mat tmp;
	for (int i = 0; i < A.x; ++ i)
		for (int j = 0; j < B.y; ++ j)
		{
			tmp.a[i][j] = 0;
			for (int k = 0; k < A.y; ++ k)
			{
				tmp.a[i][j] = (tmp.a[i][j] + A.a[i][k] * B.a[k][j]) % mod;
			}
		}
	tmp.x=A.x;
	tmp.y=B.y;
	return tmp;
}

void pg(mat A)//输出A矩阵
{
	for (int i = 0; i <A.x; ++i)
	{
		for (int j = 0; j < A.y;++j)	cout<<A.a[i][j]<<" ";cout<<endl;
	}
	cout<<endl;
}

mat powMat(mat A , int b)//a^b矩阵A的b次方
{  
	mat ret;  
	bool flag=0;
	while( b )  
	{  
		if( b & 1 )
		{
			if (!flag)
			{
				flag=1;
				ret = A;
			}
			else 	ret = ret * A ;  
		}
		b >>= 1 ;  
		A = A * A ;  
	}  
	return ret ;  
}  




struct AhoCorasickAutomata {
	int ch[MAXNODE][SIGMA_SIZE];
	int f[MAXNODE];    // fail函数
	int val[MAXNODE];  // 每个字符串的结尾结点都有一个非0的val
	int last[MAXNODE]; // 输出链表的下一个结点
	int sz;
	int match[MAXNODE];//表示字典树中，下标为i的点，是否为
	queue<int>q;

	void init() {//初始化函数
		sz = 1;
		memset(ch[0], 0, sizeof(ch[0]));
		memset(val, 0, sizeof(val));
		memset(match, 0, sizeof(match));
	}

	// 字符c的编号
	int idx(char c) 
	{  
		//if (c == '\0') return 62;  
		/*
		//包含所有大小写字母和数字idx函数
		if (c >= '0' && c <= '9') return c - '0';  
		if (c >= 'a' && c <= 'z') return c - 'a' + 10;  
		return c - 'A' + 36;  
		*/
		//return (int)c-'A';
		//return (int)c;
		switch (c)
		{
			case 'A':	return 0;
			case 'T':	return 1;
			case 'C':	return 2;
			case 'G':	return 3;
			default :
					{
						cout<<"ERROF"<<endl;
						exit(0);
					}
		}
	}  

	// 插入字符串。v必须非0
	void insert(char s[], int len, int id) {
		int now = 0;
		for(int i = 0; i < len; i++) {
			int c = idx(s[i]);
			if(!ch[now][c]) {
				memset(ch[sz], 0, sizeof(ch[sz]));
				val[sz] = 0;
				ch[now][c] = sz++;
			}
			now = ch[now][c];
		}
		val[now] = id;//单词出现的次数
	}


	// 递归打印以结点j结尾的所有字符串
	void print(int j) //输出j节点的信息，如果last[j]存在，last[j]的位置也有字符
	{
		if(j) 
		{
			//	mp[val[j]]=1;
			//++cnt[val[j]];
			match[j] = 1;
			print(last[j]);
		}
	}

	// 在T中找模板，text串的下标从0开始，长度为len
	void find(char text[], int len) {
		int j = 0; // 当前结点编号，初始为根结点
		for(int i = 0; i < len; i++) { // 文本串当前指针
			int c = idx(text[i]);
			j = ch[j][c];
			if(val[j]) 	print(j);
			else if(last[j]) print(last[j]); // 找到了！
		}
	}

	//计算fail指针
	void get_fail()
	{
		f[0] = 0;//fail[i]表示，当匹配到某个位置失败，下一个自动的位置
		for (int c = 0; c < SIGMA_SIZE; c++)
		{
			int will = ch[0][c];
			if (will)
			{
				f[will]=0;
				q.push(will);
				last[will] = 0;
			}
		}
		while (!q.empty())
		{
			int now = q.front();
			q.pop();
			for (int c = 0; c < SIGMA_SIZE; ++ c)
			{
				int will = ch[now][c];	//now节点，想要访问的下标
				if (!will)	
				{
					ch[now][c] = ch[f[now]][c];
					continue;
				}
				q.push(will);		
				int pre = f[now];	//失配指针,先指now的失配，至少有一段都是相等的
				while (pre && !ch[pre][c])	pre = f[pre];//往前跳失配指针，类似 KMP
				f[will] = ch[pre][c];	// f[i]的意义就是g[?,i]和g[0,f[i]]的字符串是相等的
				last[will] = val[f[will]] ? f[will] : last[f[will]];
			}
		}
		for (int i = 0; i != sz; ++ i)
		{
			if (val[i])	print(i);
			else if (last[i])	print(i);
		}
	}

	void doit()
	{
		mat cent;
		cent.x = sz;
		cent.y = sz;
		for (int i = 0; i < sz; ++ i)
		{
			//prln(i);
			if (match[i])	continue;//从i出发，显然不现实
			for (int j = 0; j < SIGMA_SIZE; ++ j)
			{
				if (!match[ch[i][j]])
				{
					cent.a[ch[i][j]][i] ++;
					cent.a[ch[i][j]][i] %= mod;
				}
			}
		}

		mat chu;
		chu.x = sz;
		chu.y = 1;
		chu.a[0][0] = 1;
		mat ans = powMat(cent, L) * chu;
		int ret=0;
		for (int i = 0; i < ans.x;++i)
			for (int j =0;j<ans.y;++j)
			{
				ret+=ans.a[i][j];
				ret%=mod;
			}
		cout<<ret<<endl;

	}
}ac;




int main() {
	while (~scanf("%d%d", &n, &L))
	{
		ac.init();
		for (int i = 1; i <= n; ++ i)	
		{
			scanf("%s", pattern[i]);
			int len = strlen(pattern[i]);
			bool flag=true;
			for (int j = 0; j != len; ++ j)
			{
				char ch= pattern[i][j];
				if (ch!='A' && ch!='T' && ch!='C' &&ch!='G')
				{
					flag = false;
					break;
				}

			}
			if (flag)ac.insert(pattern[i], len, i);

		}
		ac.get_fail();
		ac.doit();
	}
	return 0;
}