Codeforces 852 B Neural Network country [DP+乘法快速幂优化]

最新推荐文章于 2023-02-18 00:59:51 发布

原创最新推荐文章于 2023-02-18 00:59:51 发布 · 1.2k 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#DP #Codeforces

Codeforces 同时被 2 个专栏收录

76 篇文章

订阅专栏

25 篇文章

订阅专栏

本文介绍了一道关于图的动态规划问题，通过优化原始的DP算法，并利用快速幂运算来减少时间复杂度，最终实现高效求解。文章详细展示了如何从初始的L*N*M*N的时间复杂度优化至m*m*logL。

题意：给你一张图，图的包括了起点，终点，中间有L层，每一层N个点已知，起点与第一层的边的情况，相邻层边的情况，最后一层与终点边的情况，问从起点到终点的总长度取模m为0的走的方案数。

题解：首先不考虑起点与终点，我们可得最暴力的dp式：

for(int i=1;i<l;i++)
	for(int j=1;j<=n;j++)
		for(int k=0;k<m;k++)
			for(int g=1;g<=n;g++)
				dp[i+1][g][k+a[g]]=(dp[i+1][g][k+a[g]]+dp[i][j][k])%mod;

这样是L*N*M*N的时间复杂度（炸翻天）

首先我们可以考虑一个优化，对于当前层我们只需要记录当前层取模为0~m的状态即可，相同的路径长度的转移我们只要：方案数*相同路径的个数即可。所以我们可以记录一个数组num[i]表示当前层取模为i的方案总数。对于中间层的转移，我们只需要num[(i+j)%m]=(num[i]*b[j])%mod。b数组表示中间层转移情况，所以我们需要做l次中间转移。

现在复杂度就变为L*m*m的复杂度但是还不够。

由于状态转移式num[(i+j)%m]=(num[i]*b[j])%mod满足乘法转移式，所以我们就可以用快速幂计算答案进行优化，时间复杂度为m*m*logL。

AC代码：

#include<stdio.h>
#include<string.h>
#define mod 1000000007
#define N 1000005
typedef long long ll;
ll n,l,m;
struct node
{
	ll num[105];
}gc,ss,ee,c,dw;
ll s[N],belong[N],e[N];
node mul(node a,node b)
{
	memset(c.num,0,sizeof(c.num));
	for(ll i=0;i<100;i++)
		for(ll j=0;j<100;j++)
			c.num[(i+j)%m]=(c.num[(i+j)%m]+a.num[i]*b.num[j])%mod;
	return c;
}
node qmi(node s,ll b)
{
	node ans=dw;
	while(b)
	{
		if(b%2)ans=mul(ans,s);
		s=mul(s,s);
		b/=2;
	}
	return ans;
}
int main()
{
	dw.num[0]=1;
	scanf("%lld%lld%lld",&n,&l,&m);
	for(ll i=1;i<=n;i++)
	{
		scanf("%lld",&s[i]);
		ss.num[s[i]%m]++;
	}
	for(ll i=1;i<=n;i++)
	{
		scanf("%lld",&belong[i]);
		gc.num[belong[i]%m]++;
	}
	for(ll i=1;i<=n;i++)
	{
		scanf("%lld",&e[i]);
		ee.num[(e[i]+belong[i])%m]++;
	}
	node ans;
	if(l>2)
	{
		qmi(gc,l-2);
		ans=mul(ans,ss);
		ans=mul(ans,ee);
	}
	else ans=mul(ss,ee);
	printf("%lld\n",ans.num[0]);
}