BZOJ4861【BJOI2017】魔法咒语题解（AC自动机+DP+矩阵乘法）

题目：BZOJ4861.
题目大意：给定$n$个串$S_i$和$m$个串$T_i$，现在要用这$S_i$个串（可重复使用）拼成一个长度为$l$的串使得拼成的串所有$T_i$均未出现，求方案数.注意只要组成方式不同就算不同的方案.
$1\le n,m\le 50,1\le \sum |S_i|,\sum |T_i|\le 100,1\le l\le 10^8$.
数据分成两档，第一档满足$1\le l\le 100$，第二档满足$1\le |S_i|\le 2$.

一题正解分两段是真的恶心，强行二合一啊…

首先，看到这种套路题肯定先把所有$T_i$放进Trie里建AC自动机.

然后考虑一个DP，设$f[i][j]$表示构造一个长度为$i$的串，在AC自动机中运行到点$j$，且不能有任何一个$T_i$出现的方案数.

现在我们考虑转移，显然可以枚举每一个串$S_k$，若在AC自动机上从状态$j$开始运行串$S_k$到达点$t$，则$f[i][j]$可以转移到$f[i+|S_k|][t]$.

也就是说：
$$f[i][j]\to f[i+|S_k|][t=j\to S_k]$$

我们先处理出所有不能走到的点（每个$T_i$代表的状态在fail树上的整棵子树），在运行时若走到了这么一个点就直接把贡献设为$0$就好了.

发现这个算法的时间复杂度为$O(l\sum |T_i|\sum |S_i|)$，可以通过第一档数据.

那么第二档数据呢？我们发现这个时候$l$很大，但是$S_i$的长度均小于等于$2$，这不是明摆着矩乘么…

但是若$S_i$的长度为$1$还好做，$S_i$的长度为$2$怎么做？

其实很简单，原来我们的状态矩阵只记录了当前串长为$i$时的信息，现在只需要多记录串长为$i-1$时的信息就好了.

时间复杂度$O((\sum |T_i|{)}^3\log l)$，可以通过第二档数据.

代码如下：

#include<bits/stdc++.h>
  using namespace std;

#define Abigail inline void
typedef long long LL;

const int N=50,M=100,C=26,mod=1000000007;

int add(int a,int b){return a+b>=mod?a+b-mod:a+b;}
int sub(int a,int b){return a-b<0?a-b+mod:a-b;}
int mul(int a,int b){return (LL)a*b%mod;}
void sadd(int &a,int b=1){a=add(a,b);}
void ssub(int &a,int b=1){a=sub(a,b);}
void smul(int &a,int b){a=mul(a,b);}

int n,m,sk,len[N+9];
char s[N+9][M+9],t[M+9];
struct Trie{
  int s[C],fail,cnt;
}tr[M+9];
int cn;

void Build(){cn=1;}

int Insert(char *s,int n){
  int k=1;
  for (int i=1;i<=n;++i)
    if (tr[k].s[s[i]-'a']) k=tr[k].s[s[i]-'a'];
    else tr[k].s[s[i]-'a']=++cn,k=cn;
  ++tr[k].cnt;
  return k;
}

queue<int>q;

void Bfs_fail(){
  tr[1].fail=1;
  for (int i=0;i<C;++i)
    if (tr[1].s[i]) tr[tr[1].s[i]].fail=1,q.push(tr[1].s[i]);
    else tr[1].s[i]=1;
  while (!q.empty()){
  	int t=q.front();q.pop();
  	tr[t].cnt+=tr[tr[t].fail].cnt;
  	for (int i=0;i<C;++i)
  	  if (tr[t].s[i]) tr[tr[t].s[i]].fail=tr[tr[t].fail].s[i],q.push(tr[t].s[i]);
  	  else tr[t].s[i]=tr[tr[t].fail].s[i];
  }
}

int Judge(int st,char *s,int n){
  if (tr[st].cnt) return 0;
  int k=st;
  for (int i=1;i<=n;++i){
    k=tr[k].s[s[i]-'a'];
    if (tr[k].cnt) return 0;
  }
  return k;
}

int dp1[M+9][M+9],ans;
struct matrix{
  
  int n,m,v[M*2+9][M*2+9];
  
  matrix operator * (const matrix &p)const{
  	matrix res=matrix();
  	res.n=n;res.m=p.m;
  	for (int i=1;i<=n;++i)
  	  for (int j=1;j<=m;++j)
  	    for (int k=1;k<=p.m;++k)
  	      sadd(res.v[i][k],mul(v[i][j],p.v[j][k]));
  	return res;
  }
  
}dp2,go;

void Build_dp2(){
  dp2.n=1;dp2.m=cn<<1;
  dp2.v[1][cn+1]=1;
  for (int i=1;i<=n;++i)
    if (len[i]==1){
      int td=Judge(1,s[i],1);
      if (!td) continue;
      sadd(dp2.v[1][td]);
    }
}

void Build_go(){
  go.n=go.m=cn<<1;
  for (int i=1;i<=n;++i)
    if (len[i]==1){
	  for (int j=1;j<=cn;++j){
        int td=Judge(j,s[i],1);
        if (td) sadd(go.v[j][td]);
      }
    }else{
      for (int j=1;j<=cn;++j){
      	int td=Judge(j,s[i],2);
      	if (td) sadd(go.v[j+cn][td]);
      }
    }
  for (int i=1;i<=cn;++i) go.v[i][i+cn]=1;
}

matrix E(int n){
  matrix res=matrix();
  res.n=res.m=n;
  for (int i=1;i<=n;++i) res.v[i][i]=1;
  return res;
}

matrix Power(matrix a,int k){
  matrix res=E(a.n);
  for (;k;k>>=1,a=a*a)
    if (k&1) res=res*a;
  return res;
}

Abigail into(){
  scanf("%d%d%d",&n,&m,&sk);
  for (int i=1;i<=n;++i){
  	scanf("%s",s[i]+1);
    len[i]=strlen(s[i]+1);
  }
  Build();
  for (int i=1;i<=m;++i){
  	scanf("%s",t+1);
  	Insert(t,strlen(t+1)); 
  }
}

Abigail work1(){
  Bfs_fail();
  dp1[0][1]=1;
  for (int i=0;i<sk;++i)
    for (int j=1;j<=cn;++j){
      if (!dp1[i][j]) continue;
	  for (int k=1;k<=n;++k){
	  	if (i+len[k]>sk) continue;
      	int td=Judge(j,s[k],len[k]);
      	if (!td) continue;
      	sadd(dp1[i+len[k]][td],dp1[i][j]);
      }
    }
  for (int i=1;i<=cn;++i) sadd(ans,dp1[sk][i]);
}

Abigail work2(){
  Bfs_fail();
  Build_dp2();
  Build_go();
  dp2=dp2*Power(go,sk-1);
  for (int i=1;i<=cn;++i) sadd(ans,dp2.v[1][i]);
}

Abigail outo(){
  printf("%d\n",ans);
}

int main(){
  into();
  if (sk<=M) work1();
  else work2();
  outo();
  return 0;
}