2022HDU#3 1 期望dp+分治NTT

关注

原创 2022-09-13 22:08:33 160 阅读 AI 写同款· GEO 优化 ›

5个4000比特大状态置换算法的设计与分析下面是 5 个概念性、实验性的 4000 位可逆置换设计。它们都保证是双射，但未经过密码分析，不可直接用于生产系统。风格分别覆盖：三维 SPN、Feistel、可逆元胞自动机、ARX、宽轨迹/Keccak 式结构。这 5 个设计分别代表了 SPN、Feistel、元胞自动机、ARX、宽轨迹 Keccak 五种不同风格，覆盖了主流大状态置换的构造思路。再次强调：它们只是实验性概念，若要用于实际协议，必须经过严格安全性分析。阅读详情

题意：

有一个装备，初始是0级，在 $i$ 级时可以花费 $c_{i}$ 元来尝试升级装备一次，有 $p_{i}$ 的概率升级到 $i + 1$ 级，有 $(1−pi)wj∑k=1iwk\frac{(1-p_{i})w_{j}}{\sum_{k=1}^{i}w_{k}}$ 的概率降级到 $i - j$ 级，求升级到 $n$ 级的期望花费。

方法：

很明显的期望 $d p$ ，设 $f_{i}$ 为当前等级为 $i$ ，升级到 $n$ 级的期望花费为 $f_{i}$ ，并且以前缀和的形式记 $sumi=∑j=1iwksum_{i}=\sum_{j=1}^{i}w_{k}$ ，期望表达式： $fi=pi(ci+fi+1)+∑j=1i1−pisumiwj(ci+fi−j)f_{i}=p_{i}(c_{i}+f_{i+1})+\sum_{j=1}^{i}\frac{1-p_{i}}{sum_{i}}w_{j}(c_{i}+f_{i-j})$

化简即： $fi=pifi+1+ci+1−pisumi∑j=1iwjfi−jf_{i}=p_{i}f_{i+1}+c_{i}+\frac{1-p_{i}}{sum_{i}}\sum_{j=1}^{i}w_{j}f_{i-j}$

原式形式 $i$ 有前面 $i$ 项与 $i + 1$ 得来，不太方便计算，于是变形，将 $f_{i+1}$ 写在前面，使得 $i + 1$ 都由前面推出：

$fi+1=fi−ci−1−pisumi∑j=1iwjfi−jpif_{i+1}=\frac{f_{i}-c_{i}-\frac{1-p_{i}}{sum_{i}}\sum_{j=1}^{i}w_{j}f_{i-j}}{p_{i}}$

虽然最后一项是卷积形式，但是并不知道 $f$ 任何一项是多少，令 $f_{i}=a_{i}f_{0}+b_{i}$ ，有 $a_{0}=1，b_{0}=0$

有： $ai+1f0+bi+1=aif0−ci−1−pisumi∑j=1iwj(ai−jf0+bi−j)pia_{i+1}f_{0}+b_{i+1}=\frac{a_{i}f_{0}-c_{i}-\frac{1-p_{i}}{sum_{i}}\sum_{j=1}^{i}w_{j}(a_{i-jf_{0}+b_{i-j}})}{p_{i}}$

我们将右式以带不带 $f_{0}$ 为准则分开，则这个方程的一个解就是左侧带 $f_{0}$ 的项与右边带 $f_{0}$ 的项相等，左侧不带 $f_{0}$ 的与右侧不带 $f_{0}$ 的相等，并且将带 $f_{0}$ 的那个解的左右两边的 $f_{0}$ 约去，得到：

$ai+1=ai−1−pisumi∑j=1iwjai−jpia_{i+1}=\frac{a_{i}-\frac{1-p_{i}}{sum_{i}}\sum_{j=1}^{i}w_{j}a_{i-j}}{p_{i}}$

$bi+1=bi−ci−1−pisumi∑j=1iwjbi−jpib_{i+1}=\frac{b_{i}-c_{i}-\frac{1-p_{i}}{sum_{i}}\sum_{j=1}^{i}w_{j}b_{i-j}}{p_{i}}$

这是一个卷积递推式，可以用分治 $n tt$ 求解，计算的方法是（以 $a$ 为例子）：求 $a_{i+1}$ 时， $[0, i - 1]$ 的 $a$ 是已知的，用已知的 $a$ 来卷积得到 $∑j=1iwjai−j\sum_{j=1}^{i}w_{j}a_{i-j}$

，然后分治到 $l == r$ 时利用已知的 $a$ 与 $b$ 和求出来的 $∑j=1iwjai−j\sum_{j=1}^{i}w_{j}a_{i-j}$ 来递推 $a_{i+1}$ 。

求解完后，利用 $fn=anf0+bn=0⇒f0=−bnanf_n=a_nf_0+b_n=0\Rightarrow f_0=-\frac{b_n}{a_{n}}$ 求解即可

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

int read()
{
	int ret=0,base=1;
	char ch=getchar();
	while(!isdigit(ch))
	{
		if(ch=='-') base=-1;
		ch=getchar();
	}
	while(isdigit(ch))
	{
		ret=(ret<<3)+(ret<<1)+ch-48;
		ch=getchar();
	}
	return ret*base;
}

const long long mod=998244353,inv3=332748118,inv100=828542813;

ll qpow(ll a,ll b)
{
	ll ret=1,base=a;
	while(b)
	{
		if(b&1) ret=ret*base%mod;
		base=base*base%mod;
		b>>=1;
	}
	return ret;
}

int getlen(int k)
{
	int ret=0;
	while(k){ret++;k>>=1;}
	return ret;
}

int getrev(int k,int len)
{
	int ret=0;
	while(k){ret=ret<<1|(k&1);k>>=1;len--;}
	while(len--) ret<<=1;
	return ret;
}

int n,pos[270005];

void ntt(ll* a,int limit,int op)
{
	for(int i=0;i<limit;i++){
		if(i<pos[i]) swap(a[i],a[pos[i]]);
	}
	for(int len=2;len<=limit;len<<=1)
	{
		ll base=qpow(op==1?3:inv3,(mod-1)/len);
		for(int l=0;l<limit;l+=len)
		{
			ll now=1;
			for(int i=l;i<l+len/2;i++)
			{
				ll temp1=a[i],temp2=now*a[i+len/2]%mod;
				a[i]=(temp1+temp2)%mod;
				a[i+len/2]=(temp1-temp2+mod)%mod;
				now=now*base%mod;
			}
		}
	}
}

void multi(ll *a,ll *b,ll *tog,int limit)
{
	//a*tog,b*tog
	int len=getlen(limit-1);
	for(int i=0;i<limit;i++) pos[i]=(pos[i>>1]>>1)|((i&1)<<(len-1)); 
	ntt(a,limit,1);ntt(b,limit,1);ntt(tog,limit,1);
	for(int i=0;i<limit;i++)
	{
		a[i]=a[i]*tog[i]%mod;
		b[i]=b[i]*tog[i]%mod;
	}
	ntt(a,limit,-1);ntt(b,limit,-1);
	ll temp=qpow(limit,mod-2);
	for(int i=0;i<limit;i++)
	{
		a[i]=a[i]*temp%mod;
		b[i]=b[i]*temp%mod;
	}
}

ll p[270005],c[270005],w[270005],sum[270005],ans_a[270005],ans_b[270005];
ll f[270005],g[270005],a[270005],b[270005],tog[270005];

void solve(int l,int r)
{
	//a,b,tog是卷积容器
	//f,g是卷积结果
	//ans_a,ans_b是公式中的a,b
	if(l==r)
	{
		//用已知的ans_a与ans_b和卷积结果f和g递推i+1
		ans_a[l+1]=((ans_a[l]-(1ll-p[l])*sum[l]%mod*f[l]%mod)%mod+mod)*qpow(p[l],mod-2)%mod;
		ans_b[l+1]=((ans_b[l]-c[l]-(1ll-p[l])*sum[l]%mod*g[l]%mod)%mod+mod)*qpow(p[l],mod-2)%mod;
		return;
	}
	int mid=l+r>>1;
	solve(l,mid);
	for(int i=l;i<=mid;i++)
	{
		a[i-l]=ans_a[i];
		b[i-l]=ans_b[i];
	}
	for(int i=mid+1;i<=r;i++) a[i-l]=b[i-l]=0;
	for(int i=l;i<=r;i++) tog[i-l]=w[i-l];
	multi(a,b,tog,r-l+1);
	for(int i=mid+1;i<=r;i++)
	{
		f[i]=(f[i]+a[i-l])%mod;
		g[i]=(g[i]+b[i-l])%mod;
	}
	solve(mid+1,r);
}

void work()
{
	n=read();
	for(int i=0;i<n;i++)
	{
		p[i]=read()*inv100%mod;
		c[i]=read();
	}
	for(int i=1;i<n;i++)
	{
		w[i]=read();
		sum[i]=(sum[i-1]+w[i])%mod;
	}
	int limit=1;
	while(limit<=n) limit<<=1;
	for(int i=0;i<=n;i++) f[i]=g[i]=tog[i]=ans_a[i]=ans_b[i]=0;
	for(int i=1;i<n;i++) sum[i]=qpow(sum[i],mod-2);//由于sum都在分母出现，所以可以以逆元形式存储
	ans_a[0]=1;ans_b[0]=0;//已知的初始项
	solve(0,limit-1);
	ll ans=(-ans_b[n])*qpow(ans_a[n],mod-2)%mod;
	printf("%lld\n",(ans+mod)%mod);
}

int main()
{
	int t=read();
	while(t--) work();
 	return 0;
}