hdu2243 考研路茫茫――单词情结(AC自动机+矩阵快速幂)

最新推荐文章于 2021-06-16 18:39:03 发布

原创最新推荐文章于 2021-06-16 18:39:03 发布 · 301 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#矩阵快速幂 #AC自动机

AC自动机/序列自动机专栏收录该内容

10 篇文章

订阅专栏

本文介绍了一种使用AC自动机和矩阵快速幂解决字符串匹配问题的方法，具体为计算在给定长度内，至少包含一个指定子串的字符串数量。通过构建AC自动机和巧妙的矩阵运算，实现了高效求解。

题目

给n个允许的串，给一个串长l

问不超过l的串中，至少包含一个串的个数

思路来源

自己刚发的前两题题解

poj2778+poj3233

题解

用所有的串 $26+26^{2}+...+26^{l}$

去减所有病毒串M，即不包含任意一个串且长度为1的矩阵M

既然能根据矩阵快速幂求长度为l的 $M^{l}$ ，

就可以根据幂和就能求了 $N=\sum_{i=1}^{l}M^{i}$

符合条件的是 $N$ 的左下角矩阵的第一行元素

注意幂和的时候，左下角的矩阵的对角元应该减1

但是我们可以构造一个只有元素的矩阵P，P[0][0]=26

然后求， $Q=\sum_{i=1}^{l}P^{i}$ ，这样Q的左下角元素Q[1][0]是 $1+26+26^{2}+...+26^{l}$

我们直接用Q[1][0]去减N的左下角的第一行，

即为答案，两个减一就抵消了

技巧

把需要取模的部分都赋成unsigned long long

这样溢出等价于取模 $2^{64}$

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
struct node
{
  int fail,Next[26];    
  bool tag;
}trie[35];
char s[10];
int que[35];//建ac自动机的队列 
int root,tot;//根的编号 节点编号 
ull ans;
ll n,l;
struct Matrix
{
	ull a[62][62];
	int r;
	Matrix():r(61){
		memset(a,0,sizeof a);
	}
	Matrix(int n):r(n)//考虑0次的单位矩阵 
	{
		for(int i=0;i<n;++i)
		{
			for(int j=0;j<n;++j)
			{
				a[i][j]=0;
			}
		}
	}
	Matrix operator*(const Matrix &b)const
	{
		Matrix tmp(r);
		for(int i=0;i<r;++i)
		{
			for(int j=0;j<r;++j)
			{
				for(int k=0;k<r;++k)
				{
					tmp.a[i][j]+=a[i][k]*b.a[k][j];
				}
			}
		}
		return tmp;
	}
}M;
Matrix p(1),q(2),N;
Matrix modpow(Matrix x,ll n)
{
	Matrix p(x.r);
	for(int i=0;i<p.r;++i)
	p.a[i][i]=1;
	while(n)
	{
		if(n&1)p=p*x;
		x=x*x,n/=2;
	}
	return p;
}
Matrix S(Matrix a,ll k)
{
	Matrix b(2*a.r);
	for(int i=0;i<a.r;++i)
	{
		for(int j=0;j<a.r;++j)
		{
		 b.a[i][j]=a.a[i][j];
	    }
	    b.a[a.r+i][i]=b.a[a.r+i][a.r+i]=1;
	}
	b=modpow(b,k+1);
	return b;
}
void init1()
{
	trie[0].tag=0;//向虚节点转移 
	p.a[0][0]=26;
}
void init2()
{
	memset(trie,0,sizeof trie);//只刷一个,之后插入的时候再刷 
	ans=tot=0;
	root=++tot;
}
void insert(int r,char *s)//(root,串),trie树插入 
{
   int len=strlen(s);
   for(int i=0;i<len;i++)
   {
      if(trie[r].Next[s[i]-'a']==0)
	  {
	   trie[r].Next[s[i]-'a']=++tot;
	   trie[trie[r].Next[s[i]-'a']].tag=0;
      }
      r=trie[r].Next[s[i]-'a'];
   }     
   trie[r].tag=1;//是病毒的结尾 
   //if(trie[r].tag)printf("%d\n",r);
}
void build(int r)//建ac自动机 
{
  int head=0,tail=0;
  trie[r].fail=r;//root自己连自己 
  que[tail++]=r;
  while(head<tail)
  {
    r=que[head++];
    if(trie[trie[r].fail].tag)trie[r].tag=1;//后缀的最后一个字母是病毒 那么自己也是 importance1
    for(int i=0;i<26;i++)
    {
      int ch=trie[r].Next[i],failp;
      if(ch)
      {
        que[tail++]=ch;
        for(failp=trie[r].fail;failp!=root&&trie[failp].Next[i]==0;failp=trie[failp].fail);//向前回跳 
        if(trie[failp].Next[i]==0||trie[failp].Next[i]==ch)trie[ch].fail=failp;//接到根或者自己 
		else trie[ch].fail=trie[failp].Next[i];//可以后接 
      }
      else trie[r].Next[i]=trie[trie[r].fail].Next[i];//和fail续一个一模一样的后继 importance2
    }
  }     
}
void debug()
{
	for(int i=0;i<M.r;++i)
    {
    	for(int j=0;j<M.r;++j)
    	printf("%llu ",M.a[i][j]);
    	puts("");
    }
}
void buildMatrix()
{
	 M=Matrix(tot);
	 for(int i=1;i<=tot;++i)
	 {
	   //if(trie[i].tag) printf("%d ",i);
	   for(int j=0;j<26;++j)
	   {
	  	 if(!trie[i].tag&&!trie[trie[i].Next[j]].tag)
	  	 M.a[i-1][max(trie[i].Next[j]-1,0)]++;
	   }  
	 } 
	 //debug();
}
int main()
{
	init1(); 
    while(~scanf("%lld%lld",&n,&l))
    {
    init2();   
    for(int i=0;i<n;i++)
    {
      scanf("%s",s);
      insert(root,s);
    }
    build(root);
    buildMatrix();
    //debug();
	N=S(M,l);
    for(int i=0;i<tot;++i)
	ans+=N.a[tot][i];
    //printf("%llu\n",ans);
	q=S(p,l);//26+26^2+...+26^k 左下角为答案 
    ans=q.a[1][0]-ans;//两个左上角-I的抵消 就都不减了 
    printf("%llu\n",ans);
    }
    return 0;
}