BJOI2017 魔法咒语

传送门
参考博客

l ⩽ 100 l \leqslant100 l100 d p dp dp很好做。
对于 l ⩽ 1 e 8 l \leqslant 1e8 l1e8,由于有基本词汇长度不超过 2 2 2,于是考虑如何构造这个矩阵。
a n s [ i ] [ j ] ans[i][j] ans[i][j]表示当前长度为 i i i,最后在自动机上 j j j节点的方案数。
t r a n s [ l ] [ i ] [ j ] trans[l][i][j] trans[l][i][j]表示从自动机上 i i i节点开始,走过一个长度为 l l l的字符串最终到达 j j j的这种路线是否合法。
考虑矩阵分为四块,于是有:
[ a n s [ l e n − 1 ] a n s [ l e n − 2 ] 0 0 ] [ t r a n s [ 1 ] I t r a n s [ 2 ] 0 ] = [ a n s [ l e n ] a n s [ l e n − 1 ] 0 0 ] \left[ \begin{matrix} ans[len-1] & ans[len-2] \\ 0 & 0 \\ \end{matrix} \right] \left[ \begin{matrix} trans[1] & I \\ trans[2] & 0 \\ \end{matrix} \right]= \left[ \begin{matrix} ans[len] & ans[len-1] \\ 0 & 0 \\ \end{matrix} \right] [ans[len1]0ans[len2]0][trans[1]trans[2]I0]=[ans[len]0ans[len1]0]
t r a n s [ 1 , 2 ] trans[1,2] trans[1,2]分别代表长度为 1 , 2 1,2 1,2的转移矩阵。
a n s ans ans就是答案的矩阵。只有第一行有值,其他行为 0 0 0
第一行的第 j j j个即为在当前长度下,最后停在自动机上 j j j号节点的方案数。
最初的一个相当于是长度为 0 0 0 − 1 -1 1 a n s [ 0 ] ans[0] ans[0]就只有 m a t r i x [ 0 ] [ 0 ] = 1 matrix[0][0]=1 matrix[0][0]=1其它为 0 0 0。而 a n s [ − 1 ] ans[-1] ans[1]相当于不存在,就全部都是 0 0 0。最初的矩阵和转移矩阵乘 L L L次即可。
这个矩阵感觉不是很好想出来。收获了把矩阵分块的新套路。

#include<bits/stdc++.h>
#define ll long long
#define cs const
#define re register
cs int N=51,M=51,alpha=26,maxl=101,mod=1e9+7;
inline int add(int x,int y){return x+y>=mod?x+y-mod:x+y;}
inline int dec(int x,int y){return x-y<0?x-y+mod:x-y;}
inline int mul(int x,int y){return 1ll*x*y%mod;}
inline void Add(int &x,int y){x=(x+y>=mod)?x+y-mod:x+y;}
inline void Mul(int &x,int y){x=1ll*x*y%mod;}
inline void Dec(int &x,int y){x=(x-y<0)?x-y+mod:x-y;}
int n,m,tot=0,Len[N];ll l;
char s[N][maxl],ban[N][maxl];
struct node{int son[alpha],fail,ban;}a[N*maxl];
inline void insert(char *s){
	int now=0,len=strlen(s);
	for(int re i=0;i<len;++i){
		if(!a[now].son[s[i]-'a'])
			a[now].son[s[i]-'a']=++tot;
		now=a[now].son[s[i]-'a'];
	}a[now].ban|=1;
}
inline void build_fail(){
	std::queue<int> Q;
	for(int re i=0,v;i<alpha;++i)
		if(v=a[0].son[i]) a[v].fail=0,Q.push(v);
	while(!Q.empty()){
		int u=Q.front();Q.pop();
		a[u].ban|=a[a[u].fail].ban;
		for(int re i=0,v;i<alpha;++i){
			if(v=a[u].son[i]) a[v].fail=a[a[u].fail].son[i],Q.push(v);
			else a[u].son[i]=a[a[u].fail].son[i];
		}
	}
}
inline int run(int pos,int id){
    for(int i=0;i<Len[id];i++){
        pos=a[pos].son[s[id][i]-'a'];
        if(a[pos].ban) return -1;
    }return pos;
}
namespace SUB1{
	int f[maxl][N*maxl];
	inline void solve(int ans=0){
		f[0][0]=1;
		for(int re i=0,v;i<l;++i)
			for(int re u=0;u<=tot;++u)
				for(int re j=1;j<=n;++j)if(i+Len[j]<=l)
					if((v=run(u,j))!=-1) Add(f[v][i+Len[j]],f[u][i]);
		for(int re i=0;i<=tot;++i) Add(ans,f[i][l]);
		printf("%d\n",ans);
	}
}
namespace SUB2{
	struct matrix{
		int a[M<<2|1][M<<2|1];
		matrix(int t=0){
			memset(a,0,sizeof a);
			for(int re i=0;i<(M<<2|1);++i) a[i][i]=t;
		}
		friend inline matrix operator*(cs matrix &a,cs matrix &b){
			matrix c;
			for(int re i=0;i<=(tot<<1|1);++i)
				for(int re k=0;k<=(tot<<1|1);++k)
					for(int re j=0;j<=(tot<<1|1);++j)
						Add(c.a[i][j],mul(a.a[i][k],b.a[k][j]));
			return c;
		}
		friend inline matrix operator^(matrix a,ll b){
			matrix c(1);
			for(;b;b>>=1,a=a*a) if(b&1) c=c*a;
			return c;
		}
		inline int getsum(int ret=0){
			for(int re i=0;i<=tot;++i)
				Add(ret,a[0][i]);
			return ret;
		}
	}trans,E;
	inline void solve(){
		for(int re i=0;i<=tot;++i)
			trans.a[i][i+tot+1]=1;
		E.a[0][0]=1;
		for(int re u=0,v;u<=tot;++u)
			for(int re j=1;j<=n;++j)
				if((v=run(u,j))!=-1){
					if(Len[j]==1) ++trans.a[u][v];
					if(Len[j]==2) ++trans.a[u+tot+1][v];
				}
		printf("%d\n",(E*(trans^l)).getsum());
	}
}
int main(){
//	freopen("1683.in","r",stdin);
	scanf("%d%d%lld",&n,&m,&l);
	for(int re i=1;i<=n;++i) scanf("%s",s[i]),Len[i]=strlen(s[i]);
	for(int re i=1;i<=m;++i) scanf("%s",ban[i]),insert(ban[i]);
	build_fail();
	if(l<=100) return SUB1::solve(),0;
	return SUB2::solve(),0;
}
### BJOI2013 压力 题目解析 #### 问题描述 题目要求计算每个网络设备必须通过的数据包数量。给定一个无向图,其中存在 $ N $ 个节点和 $ M $ 条边,以及 $ Q $ 组询问,每组询问表示从某个源点到目标点之间的路径。需要统计哪些节点是这些路径中的必经之点。 此问题可以通过构建 **圆方树** 并利用其特性来解决[^1]。 --- #### 圆方树简介 圆方树是一种基于无向图的特殊结构,能够高效处理与割点和桥有关的问题。它由两类节点组成: - **圆形节点**:代表原图中的实际顶点。 - **方形节点**:对应于原图的一个双连通分量 (BCC),即一组不存在割点的顶点集合。 在该题中,我们需要关注的是如何标记并统计经过特定割点的路径数目[^4]。 --- #### 实现细节 以下是具体实现方法: 1. **构建圆方树** 使用 Tarjan 算法找到所有的割点及其对应的双连通分量,并以此为基础构造圆方树。对于每一个新发现的双连通分量,创建一个新的方形节点并与所属的割点相连。 2. **路径差分** 对于每次查询 $(u, v)$,将其转化为对圆方树上的一次简单路径操作。通过对路径上的所有割点执行加一的操作完成统计工作[^2]。 3. **线段树优化** 考虑到可能存在的大量修改请求,在最终阶段可以引入线段树或其他区间数据结构进一步加速更新过程。 下面给出一段伪代码展示上述逻辑的核心部分: ```python def tarjan(u, fa): dfn[u] = low[u] = time_stamp stk.append(u) for y in adj[u]: if not dfn[y]: tarjan(y, u) low[u] = min(low[u], low[y]) if low[y] >= dfn[u]: # Found articulation point or bridge build_bcc(u, y) # Build corresponding square node elif y != fa and dfn[y] < dfn[u]: low[u] = min(low[u], dfn[y]) def build_bcc(root, child): global poi r = ++poi while True: w = stk[-1] stk.pop() att(r, w) # Attach the vertex to current biconnected component if w == child: break att(r, root) # Query processing using tree difference technique on constructed round-square tree. for query in queries: path_diff(query.start, query.end) ``` --- #### 时间复杂度分析 整个算法的时间复杂度主要依赖以下几个方面: - 构造圆方树所需时间为 $ O(N + M) $。 - 每次查询涉及一次简单的路径遍历,总时间开销为 $ O(Q \log N) $ 当采用合适的数据结构辅助时。 因此总体效率较高,适合大规模输入场景下的应用需求。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值