HDU 2243 AC自动机->DP->附矩阵乘法板子

原创 2016年08月28日 20:04:28

题目大意:

给一些字母串,问长度为L【以内】的全部字母串中,有多少个字母串,【包含】给定的字母串。答案mod 2^64


首先,对于答案mod 2^64,只要全部使用unsigned long long进行运算,就会自动实现这个功能了。


然后假设,问题只求长度为L,而不是长度小于L的,这个问题怎么做呢?


参考前一个题解……


题目转换为求【不包含】给定字母串来做的话,会简单一些。求出不包含的数量,和总数,做差即可。

这里再简述一下,构造AC自动机,我们然后我们知道对于trie图中,有些节点不能到达,一旦到达,说明这个方案不合法。



对于上图的AC自动机(省略了无数条边……)

红色的节点,为那个节点表示,到那个节点有单词出现。

(考虑AC自动机的last指针,不能只考虑val来考虑是否有单词,因为对于abcdefgpp,和efg。可能遍历到abcdefgp的时候,已经有efg了,所以abcdefg的g的位置,也是不可访问的)


现在问题就变为了,在trie图中跑路~ 从0出发,经过L步,不经过红色点的方案总数。


f[i][j]表示,停留在AC自动机的i节点,走了j步的方案总数。

其中k节点可以到i节点,并且k,j节点都不是红色节点。


暴力转移必然TLE。 这样的式子可以矩阵优化。


这样的矩阵。中间的矩阵保存f[0][i],经过一次乘法后,得到f[0][i+1]

左边的矩阵意淫一下就可以知道,a[i][j]表示f[j]是否可以转移到f[i],是的话就是1,否则就是0.


然后矩阵乘法满足结合律……就可以实现快速求出结果了。  当然这是HDU 2222的题解~~~~



这题需要的是矩阵的1次方,2次方,3次方。。。n次方的和。


对于a^0+a^1+a^2+a^3+++++a^n 的求解,也可以借助矩阵实现。



就是这个矩阵! 当然也可以推导出(3*3) * (3*1)的矩阵的形式。但是既然有2*2的矩阵,当然好啦。


这个矩阵的n次方后的第一行的元素之和,就是a^0+a^1+a^2++++a^n啦。  (1)



当然,现在我们的a是一个矩阵。 矩阵也可以实现的~


就是这样~ 左上角是矩阵,然后右边一列,是2个大大的单位矩阵。


然后这个矩阵的n次方后,把第一行的2个大矩阵相加,就是A^0+A^1+A^2+++A^n啦。

当然,矩阵的0次方,就是单位矩阵。


这题用这个方法,就可以快速求出方案总数。(包含不经过红色点的方案总数,任何排列的26^1+26^2……26^L的方案总数)

我们求出来的是26^0+26^1...+26^L, 以及矩阵A^0+A^1+A^2++++A^n的方案总数。


看起来是不是多了一个26^0,右边多了一个A^0呢?

左边对于26^0,直接答案减1即可。


右边多了一个A^0,可以去掉一个单位矩阵。当然,可以看出A^0 * b(b就是f[0],f[1]的那个矩阵),单位矩阵乘以那个矩阵,就是那个矩阵本身。而那个矩阵本身,也就走0步的状态的方案总数,也就是26^0的方案总数~ 所以可以不用考虑。   (这一段话比较混乱,大家可以自行理解)


矩阵乘法板子


const int mat_size = 40 * 2;//矩阵大小,需要乘以2,为了&运算的时候需要二倍的矩阵大小
struct Matrix
{
	unsigned long long a[mat_size][mat_size];
	int x, y;//长宽
	Matrix()	//返回0矩阵
	{
		memset(a,0,sizeof(a));
	}
	Matrix(int x,int y)//返回0矩阵,并且x,y赋值
	{
		this->x = x;
		this->y = y;
		memset(a, 0,sizeof(a));
	}

	Matrix(int n)	//返回n*n的【单位矩阵】
	{
		this->x=n;
		this->y=n;
		memset(a,0,sizeof(a));
		for (int i = 0; i <n;++i)	a[i][i]=1;
	}

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

	Matrix operator ^ (int b)//矩阵A的b次方
	{
		Matrix ret = Matrix(x);  
		Matrix A = *this;
		while( b )  
		{  
			if( b & 1 )	ret = ret * A ;  
			b >>= 1 ;  
			A = A * A ;  
		}  
		return ret ;  
	}

	Matrix operator & (int b)//A^0 + A^1+A^2+A^3+++A^n,其中A是矩阵。最后返回的就是一个矩阵
	{
		Matrix ret = *this;
		for (int i = ret.x; i < ret.x * 2; ++ i)	
		{
			ret.a[i-ret.x][i]= 1;
			ret.a[i][i] = 1;
		}
		ret.x <<= 1;
		ret.y <<= 1;
		//pg(ret);
		ret = ret^b;
		ret.x >>= 1;
		ret.y >>= 1;
		for (int i = 0; i < ret.x; ++ i)	
			for (int j = 0; j < ret.y; ++ j)
				ret.a[i][j] += ret.a[i][j + ret.x];
		return ret;
	}
	void pg(Matrix 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;

	}
};


ac code : 46ms


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

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

int n,L;
char pattern[123][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 = 40 * 2;//矩阵大小
struct Matrix
{
	unsigned long long a[mat_size][mat_size];
	int x, y;//长宽
	Matrix()	//返回0矩阵
	{
		memset(a,0,sizeof(a));
	}
	Matrix(int x,int y)//返回0矩阵,并且x,y赋值
	{
		this->x = x;
		this->y = y;
		memset(a, 0,sizeof(a));
	}

	Matrix(int n)	//返回n*n的【单位矩阵】
	{
		this->x=n;
		this->y=n;
		memset(a,0,sizeof(a));
		for (int i = 0; i <n;++i)	a[i][i]=1;
	}

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

	Matrix operator ^ (int b)//矩阵A的b次方
	{
		Matrix ret = Matrix(x);  
		Matrix A = *this;
		while( b )  
		{  
			if( b & 1 )	ret = ret * A ;  
			b >>= 1 ;  
			A = A * A ;  
		}  
		return ret ;  
	}

	Matrix operator & (int b)//A^0 + A^1+A^2+A^3+++A^n,其中A是矩阵。最后返回的就是一个矩阵
	{
		Matrix ret = *this;
		for (int i = ret.x; i < ret.x * 2; ++ i)	
		{
			ret.a[i-ret.x][i]= 1;
			ret.a[i][i] = 1;
		}
		ret.x <<= 1;
		ret.y <<= 1;
		//pg(ret);
		ret = ret^b;
		ret.x >>= 1;
		ret.y >>= 1;
		for (int i = 0; i < ret.x; ++ i)	
			for (int j = 0; j < ret.y; ++ j)
				ret.a[i][j] += ret.a[i][j + ret.x];
		return ret;
	}
	void pg(Matrix 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;

	}
};



void pg(Matrix 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;
}

unsigned long long powMod( unsigned long long a , unsigned long long b)//a^b % p  
{  
	unsigned long long r = 1 ;  
	while( b )  
	{  
		if( b&1 ) r = r*a ;  
		b >>= 1 ;  
		a = a*a ;  
	}  
	return r ;  
}  

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-'a');
	}  

	// 插入字符串。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]];
			}
		}
		//prln('#');
		for (int i = 0; i != sz; ++ i)
		{
			if (val[i])	print(i);
			else if (last[i])	print(i);
		}
		//prln('!');
	}

	void doit()
	{
		//	prln("doit");
		Matrix 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] ++;
				}
			}
		}
		Matrix chu;
		chu.x = sz;
		chu.y = 1;
		chu.a[0][0] = 1;

		//pg(cent);
		//pg(cent&L);

		Matrix ans = (cent&L) * chu;
		//pg(ans);

		unsigned long long ret=0;
		for (int i = 0; i < ans.x;++i)
			for (int j =0;j<ans.y;++j)
			{
				ret+=ans.a[i][j];
			}

		chu = Matrix(2,2);
		chu.a[0][0]=26;
		chu.a[0][1]=1;
		chu.a[1][1]=1;
		//pg(chu);
		chu = chu^L;
		unsigned long long tot = chu.a[0][0] + chu.a[0][1];
		//cout<<tot<<" "<<ret<<endl;
		cout<<tot-ret<<endl;
	}
}ac;




int main() {
	while (~scanf("%d%d", &n, &L))
	{
		ac.init();
		for (int i = 1; i <= n; ++ i)	
		{
			scanf("%s", pattern[i]);
			//cout<<pattern[i]<<endl;
			int len = strlen(pattern[i]);
			ac.insert(pattern[i], len, i);

		}
		ac.get_fail();
		//prln("fuck");
		ac.doit();
	}
	return 0;
}





版权声明:本文为博主原创文章,未经博主允许不得转载。

hdu2243之AC自动机+矩阵乘法

经典AC自动机+矩阵乘法

HDU 2243 考研路茫茫――单词情结 AC自动机 + 矩阵快速幂

题目大意: 就是现在给出一些单词的ci

hdu 2243 考研路茫茫——单词情结

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=2243 题目大意:问长度为1~N的串中包含了模式串的串总共有几个。 题目思路:求出长度不大于l的包含...

HDU2243 考研路茫茫——单词情结 AC自动机DP矩阵优化

传送门:点击打开链接 考研路茫茫——单词情结 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java...

Hdu 3962 Microgene (AC自动机+矩阵)

题目大意: 构造一个串使得有两个以及两个以上的目标串。长度为L的所有串中有多少个这样的串。 思路分析: 用所有的数量减去只有1个和没有目标串的数量就是答案了。 如果数据很小,可以用dp...

【hdu2243】【AC自动机】【矩阵乘法】考研路茫茫——单词情结

首先利用补集转化思想,将问题转化为求一个词根都不包含的单词有多少种。 可以想到将所有的词根建为AC自动机,然后使用DP求解。 由于长度范围很大,可以使用矩阵乘法加速。 并且题目中要求的是“长度不...
  • njlcazl
  • njlcazl
  • 2013年05月11日 16:55
  • 543

hdu 2243 poj 2778 AC自动机 + 经典矩阵乘法

两个题差不多,只不过hdu上的恶心一点,对2^64取模,其实就相当于不用取模,所有的数都用unsigned __int64 即可,注意,无符号类型6-9就不是-3了哦 经典矩阵乘法是指求A+A^2+...

poj2778 DNA Sequence AC自动机 dp 矩阵乘法

poj2778 DNA Sequence 题意:求仅有A G C T不含有k(k
  • yxr0105
  • yxr0105
  • 2016年02月03日 01:02
  • 185

【POJ2778】AC自动机,DP,矩阵乘法

题意:给出n个字串表示“缺陷基因”,然后让求长度为m的基因(4^m个)中有多少个不带病。 题解:首先建立AC自动机,然后从每个节点开始选“ATGC”有四种往外转移的途径。 如:ACG,C这...
  • Vmurder
  • Vmurder
  • 2014年09月17日 08:13
  • 1083

hdu 2243 ac自动机 dp +矩阵快速幂

链接:http://acm.hdu.edu.cn/showproblem.php?pid=2243
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:HDU 2243 AC自动机->DP->附矩阵乘法板子
举报原因:
原因补充:

(最多只允许输入30个字)