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

题意：

有一个装备，初始是0级，在$i$级时可以花费$c_i$元来尝试升级装备一次，有$p_i$的概率升级到$i+1$级，有$\frac{(1-p_i)w_j}{{\sum }_{k=1}^i{w}_k}$的概率降级到$i-j$级，求升级到$n$级的期望花费。

方法：

很明显的期望$dp$，设$f_i$为当前等级为$i$，升级到$n$级的期望花费为$f_i$，并且以前缀和的形式记$su{m}_i={\sum }_{j=1}^i{w}_k$，期望表达式：$f_i=p_i(c_i+f_{i+1})+{\sum }_{j=1}^i\frac{1-p_i}{su{m}_i}{w}_j(c_i+f_{i-j})$

化简即：$f_i=p_i{f}_{i+1}+c_i+\frac{1-p_i}{su{m}_i}{\sum }_{j=1}^i{w}_j{f}_{i-j}$

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

$f_{i+1}=\frac{f_i-c_i-\frac{1-p_i}{su{m}_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$

有：$a_{i+1}{f}_0+b_{i+1}=\frac{a_i{f}_0-c_i-\frac{1-p_i}{su{m}_i}{\sum }_{j=1}^i{w}_j(a_{i-j{f}_0+b_{i-j}})}{p_i}$

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

$a_{i+1}=\frac{a_i-\frac{1-p_i}{su{m}_i}{\sum }_{j=1}^i{w}_j{a}_{i-j}}{p_i}$

$b_{i+1}=\frac{b_i-c_i-\frac{1-p_i}{su{m}_i}{\sum }_{j=1}^i{w}_j{b}_{i-j}}{p_i}$

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

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

求解完后，利用$f_n=a_n{f}_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;
}