概率和期望专题训练记录 2024.3

[abc300_e]Dice Product 3

很明显，概率是由其因子转移而来的，设 $d p [i]$ 表示结果为i的概率，则有转移方程：

d p_{i} = \sum_{j = 2}^{6} d p_{\frac{i}{j}} \times \frac{1}{5} \times [i mod j = 0]

为什么是从二开始？因为乘1结果不变，不影响概率，所以只有5中情况，因为n很大，所以可以用记忆化搜索。

分数取模写的很抽象，形象的可以理解为输出 $P \times Q^{- 1} (mod 998244353)$

代码：

#include<cstdio>
#include<map>
#define ll long long
using namespace std;
const int m=998244353;
ll n,d;
map<ll,ll> mp;
ll qpow(ll x,int y)
{
	ll res=1;
	while(y)
	{
		if(y&1) res=res*x%m;
		x=x*x%m;
		y>>=1;
	}
	return res;
}
void dfs(ll x)
{
	if(mp[x]) return;
	for(int i=2;i<=6;i++)
	{
		if(x%i!=0) continue;
		dfs(x/i);
		mp[x]=(d*mp[x/i]%m+mp[x])%m;
	}
}
int main()
{
	scanf("%lld",&n);
	d=qpow(5,m-2);
	mp[1]=1;
	dfs(n);
	printf("%lld",mp[n]);
	return 0;
}

[abc263_e]Sugoroku 3

因为转移存在环，所以无法直接正推，考虑逆推，设 $d p [i]$ 表示当前在i，期望还需走的步数，易得转移方程：

d p_{i} = \frac{\sum_{j = i}^{i + a_{i}} (d p_{j} + 1)}{a_{i} + 1}

即

d p_{i} = \frac{\sum_{j = i + 1}^{i + a_{i}} d p_{j}}{a_{i}} + \frac{a_{i} + 1}{a_{i}}

注意，因为在转移时也要掷一次，所以在列第一个式子时要+1，不然会推出某些奇怪的东西

代码：

#include<cstdio>
#define ll long long
using namespace std;
const int m=998244353;
int n,a[200005];
ll dp[200005],sum[400005];
ll qpow(ll x,int y)
{
	ll res=1;
	while(y)
	{
		if(y&1) res=res*x%m;
		x=x*x%m;
		y>>=1;
	}
	return res;
}
int main()
{
	scanf("%d",&n);
	for(int i=1;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
	for(int i=n-1;i>0;i--)
	{
		dp[i]=((sum[i+1]-sum[i+a[i]+1])%m*qpow(a[i],m-2)%m+(a[i]+1)*qpow(a[i],m-2)%m)%m;
		sum[i]=(sum[i+1]+dp[i])%m;
		//printf("%d ",dp[i]);
	}
	printf("%lld ",dp[1]);
}

[abc276_f]Double Chance

当有k个数时，期望值为 $\frac{\sum_{i = 1}^{k} \sum_{j = 1}^{k} max (a_{i}, a_{j})}{k^{2}}$ ，时间复杂度 $O (n^{3})$

考虑排序，若某个序列已经排好序，则对于每个位置i,max值为自身个数为 $2 \times i - 1$ ，所以可以排序后 $O (n)$ 求解，时间复杂度 $O (n^{2} \log n)$

可以发现，有很多排序以及重复计算，因为涉及大小和求值，考虑权值线段树，每次加新值时统计小于等于它的数的个数，以及大于它的数的和，然后更新答案，加入新值，时间复杂度 $O (n \log n)$

注意取模，部分地方要*1ll

代码：

#include<cstdio>
#define lid id<<1
#define rid id<<1|1
#define ll long long
using namespace std;
const int p=998244353;
int n,a[200005],m=2e5;
ll qpow(ll x,int y)
{
	ll res=1;
	while(y)
	{
		if(y&1) res=res*x%p;
		x=x*x%p;
		y>>=1;
	}
	return res;
}
struct seg_tree{
	int l,r;
	ll sum,cnt;
}tr[800040];
void build(int id,int l,int r)
{
	tr[id].l=l,tr[id].r=r;
	if(l==r)
	{
		return;
	}
	int mid=(l+r)>>1;
	build(lid,l,mid);
	build(rid,mid+1,r);
}
void update(int id,int x)
{
	if(tr[id].l==tr[id].r)
	{
		tr[id].sum=(tr[id].sum+1ll*x)%p;
		tr[id].cnt=(tr[id].cnt+1)%p;
		return;
	}
	int mid=(tr[id].l+tr[id].r)>>1;
	if(x<=mid) update(lid,x);
	else update(rid,x);
	tr[id].sum=(tr[lid].sum+tr[rid].sum)%p;
	tr[id].cnt=(tr[lid].cnt+tr[rid].cnt)%p;
}
ll query1(int id,int l,int r)
{
	if(tr[id].l==l&&tr[id].r==r)
	{
		return tr[id].sum;
	}
	int mid=(tr[id].l+tr[id].r)>>1;
	if(r<=mid) return query1(lid,l,r)%p;
	else if(l>mid) return query1(rid,l,r)%p;
	else return (query1(lid,l,mid)+query1(rid,mid+1,r))%p;
}
ll query2(int id,int l,int r)
{
	if(tr[id].l==l&&tr[id].r==r)
	{
		return tr[id].cnt;
	}
	int mid=(tr[id].l+tr[id].r)>>1;
	if(r<=mid) return query2(lid,l,r)%p;
	else if(l>mid) return query2(rid,l,r)%p;
	else return (query2(lid,l,mid)+query2(rid,mid+1,r))%p;
}
int main()
{
	scanf("%d",&n);
	build(1,1,m);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
	}
	ll ans=0;
	for(int i=1;i<=n;i++)
	{
		ll x=query2(1,1,a[i])*2%p+1,y=query1(1,a[i]+1,m)*2%p,k=1ll*i*i%p,q=1ll*(i-1)*(i-1)%p;
		ans=(ans*q%p+x*a[i]%p+y)%p*qpow(k,p-2)%p;
		update(1,a[i]);
		printf("%lld\n",ans);
	}
	return 0;
}

[cf869C] The Intriguing Obsession

可以发现，当一个岛连接两个同色岛时一定不满足条件，所以若只有两个颜色，方案数为：

\sum_{i = 0}^{m i n (a, b)} C_{a}^{i} \times C_{b}^{i} \times i!

因为三种组合AB,BC,AC互不干扰，所以可以分别按上述公式求解，最后求乘积。

代码：

#include<cstdio>
#include<algorithm>
#define ll long long
using namespace std;
const int p=998244353;
int a,b,c;
ll fac[5005],inv[5005];
ll qpow(ll x,int y)
{
	ll res=1;
	while(y)
	{
		if(y&1) res=res*x%p;
		x=x*x%p;
		y>>=1;
	}
	return res;
}
ll C(int m,int n)
{
	return fac[n]*inv[n-m]%p*inv[m]%p;
}
ll solve(int x,int y)
{
	ll res=1;
	for(int i=1;i<=min(x,y);i++)
	{
		res+=C(i,x)*C(i,y)%p*fac[i]%p;
		res%=p;
	}
	return res;
}
int main()
{
	scanf("%d%d%d",&a,&b,&c);
	fac[0]=inv[0]=1;
	for(int i=1;i<=5000;i++)
	{
		fac[i]=fac[i-1]*i%p;
	}
	inv[5000]=qpow(fac[5000],p-2);
	for(int i=4999;i>0;i--)
	{
		inv[i]=inv[i+1]*(i+1)%p;
	}
//	printf("%d ",inv[1]);
	printf("%lld",solve(a,b)*solve(b,c)%p*solve(c,a)%p);
	return 0;
}

[cf1525E]Assimilation IV

依据题面，可以知道每个点只会被计算一次，所以可以从点出发，求每个点被覆盖的概率，正着计算会有很多重复，所以考虑先算出不可能的情况，在与1作差，很明显，若所有城市到点A的距离都小于n，则一定成立，如果有一个不满足，则若此城市第一个放置，就要分两种情况，若其余距离均小于n-1，则成立，否则以此类推即可求得答案

代码：

#include<cstdio>
#define ll long long
using namespace std;
const int p=998244353;
int n,m;
int t[50005][25];
ll fac[25],ans;
ll qpow(ll x,int y)
{
	ll res=1;
	while(y)
	{
		if(y&1) res=res*x%p;
		x=x*x%p;
		y>>=1;
	}
	return res;
}
int main()
{
	scanf("%d%d",&n,&m);
	fac[0]=1;
	for(int i=1;i<=n;i++)
	{
		fac[i]=fac[i-1]*i%p;
	}
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			int d;
			scanf("%d",&d);
			t[j][d]++;
		}
	}
	ll inv=qpow(fac[n],p-2);
	for(int i=1;i<=m;i++)
	{
		ll sum=0,tmp=1;
		for(int j=n;j>0;j--)
		{
			sum+=t[i][j+1];
			tmp=tmp*sum%p;
			sum--;
		}
		ans=(ans+1-tmp*inv%p+p)%p;
	}
	printf("%lld",ans);
	return 0;
}

[cf571A]Lengthening Sticks

很明显，正算很乱，考虑用全部情况减去不合法情况。

如何计算总情况？即对于每个 $0 \leq i \leq l$ ，将i划分成3份，方案数即：

1 + \sum_{i = 1}^{l} C_{i + 2}^{2}

如何计算不合法情况？首先要先明确不合法情况即两边之和小于第三边，所以可以枚举第三边长度，暴力计算，注意，在剩下的两边的划分中,设共能加k，方案不能直接加k，要加 $\sum_{i = 0}^{k} A_{i + 1}^{l} = \sum_{i = 0}^{k} i + 1 = (i + 1) \times (i + 2) \div 2$

代码：

#include<cstdio>
#include<algorithm>
#define ll long long
using namespace std;
int a,b,c,l;
ll ans;
ll solve(int x,int y,int z)
{
	ll res=0;
	for(int i=max(0,x+y-z);i<=l;i++)
	{
		int tmp=min(l-i,z+i-x-y);
		res=res+1ll*(tmp+1)*(tmp+2)/2;
	}
	return res;
}
int main()
{
	scanf("%d%d%d%d",&a,&b,&c,&l);
	ans=1;
	for(int i=1;i<=l;i++)
	{
		ans=ans+1ll*(i+1)*(i+2)/2;
	}
//	printf("%lld\n",ans);
	ans-=solve(a,b,c);
	ans-=solve(b,c,a);
	ans-=solve(c,a,b);
	printf("%lld",ans);
	return 0;
}

ABC323E Playlist

考虑dp，设 $d p_{i, j}$ 表示在时刻i，j恰好放完的概率，易得转移方程：

d p_{i, j} = \sum_{k = 1}^{n} d p_{i - t_{j}, k}

时间复杂度 $O (n^{2} x)$ ，考虑优化

可以对每个时间点i求和，记为 $s u m_{i}$ ，则转移方程为：

d p_{i, j} = s u m_{i - t_{j}}

代码：

#include<cstdio>
#define ll long long
using namespace std;
const int p=998244353;
ll inv;
ll qpow(ll x,int y)
{
	ll res=1;
	while(y)
	{
		if(y&1) res=res*x%p;
		x=x*x%p;
		y>>=1;
	}
	return res;
}
int n,t[1005],x;
ll dp[20005][1003],sum[20005];
int main()
{
	scanf("%d%d",&n,&x);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&t[i]);
	}
	inv=qpow(n,p-2);
	if(x==0)
	{
		printf("%lld",inv);
		return 0;
	}
	sum[0]=1;
	for(int i=1;i<=t[1]+x;i++)
	{
		for(int j=1;j<=n;j++)
		{
			if(i>=t[j])
			{
				dp[i][j]=sum[i-t[j]]*inv%p;
			}
			sum[i]=(dp[i][j]+sum[i])%p;
		}
	}
	ll ans=0;
	for(int i=x+1;i<=t[1]+x;i++)
	{
		ans=(dp[i][1]+ans)%p;
	}
	printf("%lld",ans);
	return 0;
}

[cf261B]Maxim and Restaurant

本题是背包的思想，设 $d p_{i, j, k}$ 表示前i个人中，进去j个人，占地为k的期望。

对于第i个人，他能进去的概率为 $C_{i - 1}^{j - 1} \div C_{i}^{j} = \frac{j}{i}$

所以，转移方程为：

d p_{i, j, k} = \frac{j}{i} \times d p_{i - 1, j - 1, k - a_{i}} + \frac{i - j}{i} \times d p_{i - 1, j, k}

代码：

#include<cstdio>
using namespace std;
int n,a[55],p;
double f[55][55][55];
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
	}
	scanf("%d",&p);
	f[0][0][0]=1;
	for(int i=1;i<=n;i++)
	{
		for(int j=0;j<=i;j++)
		{
			for(int k=0;k<=p;k++)
			{
				f[i][j][k]=f[i-1][j][k]*(i-j)/(i*1.0);
				if(k>=a[i])
				f[i][j][k]+=f[i-1][j-1][k-a[i]]*j/(i*1.0);
			}
		}
	}
	double ans=0;
	for(int j=1;j<=n;j++)
	{
		for(int k=1;k<=p;k++)
		{
			ans+=f[n][j][k];
		}
	}
	printf("%.10lf",ans);
	return 0;
}

[cf935D]Fafa and Ancient Alphabet

讲一个暴力的方法，分四种情况考虑，设当前位置为i

若 $s 1_{i} \neq 0$ 且 $s 2_{i} \neq 0$
- 若 $s 1_{i} > s 2_{i}$ ，加上前面都相同的概率
- 若 $s 1_{i} < s 2_{i}$ ，则直接输出，因为若前面都相同，s2字典序一定比s1大
- 若相等，则不做处理
若 $s 1_{i} \neq 0$ 且 $s 2_{i} = 0$ ，则当 $s 2_{i} < s 1_{i}$ 时就一定满足条件，概率为 $\frac{s 1_{i} - 1}{m}$ ，相等则记录，用于后面计算
若 $s 1_{i} = 0$ 且 $s 2_{i} \neq 0$ ，则当 $s 2_{i} < s 1_{i}$ 时就一定满足条件，概率为 $\frac{m - s 2_{i}}{m}$ ，相等则记录，用于后面计算
若 $s 1_{i} = 0$ 且 $s 2_{i} = 0$ ，则当 $s 2_{i} < s 1_{i}$ 时就一定满足条件，概率为 $\frac{m (m - 1)}{2 m^{2}}$ ，相等概率为 $\frac{1}{m}$ 记录用于后面计算

代码：

#include<cstdio>
#define ll long long
using namespace std;
const int p=1e9+7;
int n,m,a[100005],b[100005];
ll ans;
ll qpow(ll x,int y)
{
	ll res=1;
	while(y)
	{
		if(y&1) res=res*x%p;
		x=x*x%p;
		y>>=1;
	}
	return res;
}
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
	}
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&b[i]);
	}
	ll tmp=1,inv=qpow(m,p-2);
	for(int i=1;i<=n;i++)
	{
		if(a[i]!=0&&b[i]!=0)
		{
			if(a[i]>b[i])ans+=tmp;
			if(a[i]!=b[i]) break;
		}
		if(a[i]==0&&b[i]!=0)
		{
			ans=(ans+tmp*(m-b[i])%p*inv%p)%p;
			tmp=tmp*inv%p;
		}
		if(a[i]!=0&&b[i]==0)
		{
			ans=(ans+tmp*(a[i]-1)%p*inv%p)%p;
			tmp=tmp*inv%p;
		}
		if(a[i]==0&&b[i]==0)
		{
			ans=(ans+(1ll*m*(m-1)/2)%p*tmp%p*inv%p*inv%p)%p;
			tmp=tmp*inv%p;
		}
	}
	printf("%lld",ans%p);
	return 0;
}

[cf1777D]Score of a Tree

设 $d_{i}$ 表示i到其子树深度最大的节点的距离+1，若 $t > d_{i}$ ，则i的值为0

当 $t < d_{i}$ 时，i的值为与i距离为t的子节点的异或和，此时节点i的值有1/2的概率为1

所以 $a n s = 2^{n - 1} \sum d_{i}$

代码:

#include<cstdio>
#include<algorithm>
#define ll long long
using namespace std;
const int p=1e9+7;
int n,T,head[200005],edgenum;
struct edge{
	int to,nxt;
}e[400005];
void add(int u,int v)
{
	e[++edgenum].nxt=head[u];
	e[edgenum].to=v;
	head[u]=edgenum;
}
int d[200005];
void dfs(int u,int fa)
{
	d[u]=1;
	for(int i=head[u];i;i=e[i].nxt)
	{
		int v=e[i].to;
		if(fa==v) continue;
		dfs(v,u);
		d[u]=max(d[v]+1,d[u]);
	}
}
int main()
{
	scanf("%d",&T);
	while(T--)
	{
		scanf("%d",&n);
		for(int i=1;i<n;i++)
		{
			int u,v;
			scanf("%d%d",&u,&v);
			add(u,v);
			add(v,u);
		}
		dfs(1,0);
		ll ans=0,tmp=1;
		edgenum=0;
		for(int i=1;i<=n;i++)
		{
			head[i]=0;
			ans=(ans+d[i])%p;
			if(i!=1) tmp=tmp*2%p;
		}
		ans=ans*tmp%p;
		printf("%lld\n",ans);
	}
	return 0;
}

[abc297_f]Minimum Bounding Box 2

考虑每个点对整体的贡献，即总方案数减去不符合的方案数，不符合的方案数即不包含(i,j)的方案数

不合法方案数 $a = C_{(i - 1) * m}^{k} + C_{(n - i) * m}^{k} + C_{(j - 1) * n}^{k} + C_{(m - j) * n}^{k}$

但四个角被计算了2次，多算的次数 $b = C_{(i - 1) * (j - 1)}^{k} + C_{(i - 1) * (m - j)}^{k} + C_{(j - 1) * (n - i)}^{k} + C_{(n - i) * (m - j)}^{k}$

总方案数 $c = C_{n * m}^{k}$

所以对于点(i,j)，方案数就是c-a+b

代码：

#include<cstdio>
#include<algorithm>
#define ll long long
using namespace std;
const int p=998244353;
int n,m,k;
ll fac[1000006],inv[1000006];
ll qpow(ll x,int y)
{
	ll res=1;
	while(y)
	{
		if(y&1) res=res*x%p;
		x=x*x%p;
		y>>=1;
	}
	return res;
}
ll C(int n,int m)
{
	if(m>n) return 0;
	return fac[n]*inv[m]%p*inv[n-m]%p;
}
int main()
{
	scanf("%d%d%d",&n,&m,&k);
	fac[0]=1;
	for(int i=1;i<=m*n;i++)
	{
		fac[i]=fac[i-1]*i%p;
	}
	inv[n*m]=qpow(fac[n*m],p-2);
	for(int i=n*m-1;i>=0;i--)
	{
		inv[i]=inv[i+1]*(i+1)%p;
	}
	ll ans=0;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			ll a=(C((i-1)*m,k)+C((n-i)*m,k)+C((j-1)*n,k)+C((m-j)*n,k))%p;
			ll b=(C((i-1)*(j-1),k)+C((i-1)*(m-j),k)+C((j-1)*(n-i),k)+C((n-i)*(m-j),k))%p;
			ll c=C(n*m,k);
			ans=(ans+c-a+b+p)%p;
		}
	}
	printf("%lld",ans*qpow(C(n*m,k),p-2)%p);
	return 0;
}

[cf696B]Puzzles

考虑到 $s t a r t i n g_t i m e [i] > s t a r t i n g_t i m e [f a_{i}]$ 且将一颗子树遍历完后才会遍历其他子树，所以i的转移一定和它的父亲有关

设i的两颗子树u,v，先遍历u的概率为1/2，所以u的期望为 $\frac{s i z e_{v} + 1}{2}$

以此类推，i的期望为 $d p_{f a_{i}} + 1 + \frac{s i z e_{f a_{i}} - s i z e_{u} - 1}{2}$

代码：

#include<cstdio>
using namespace std;
int n,a[100005],head[100005],edgenum,size[100005];
struct edge{
	int to,nxt;
}e[200005];
void add(int u,int v)
{
	e[++edgenum].nxt=head[u];
	e[edgenum].to=v;
	head[u]=edgenum;
}
double dp[100005];
void dfs(int u,int fa)
{
	size[u]=1;
	for(int i=head[u];i;i=e[i].nxt)
	{
		int v=e[i].to;
		if(v==fa) continue;
		dfs(v,u);
		size[u]+=size[v];
	}
}
void dfs2(int u,int fa)
{
	if(u!=1)
	dp[u]=dp[fa]+1+(size[fa]-size[u]-1)/2.0;
	for(int i=head[u];i;i=e[i].nxt)
	{
		int v=e[i].to;
		if(v==fa) continue;
		dfs2(v,u);
	}
}
int main()
{
	scanf("%d",&n);
	for(int i=2;i<=n;i++)
	{
		int v;
		scanf("%d",&v);
		add(i,v);
		add(v,i);
	}
	dfs(1,0);
	dp[1]=1;
	dfs2(1,0);
	for(int i=1;i<=n;i++)
	{
		printf("%.1lf ",dp[i]);
	}
	return 0;
}

[cf500D]New Year Santa Network

考虑记录每一条边的经过次数

设两个节点中深度较大的点为x，则只有两种情况会经过：

两个点在x的子树外， $s i z e_{x} \times (s i z e_{x} - 1) \times (n - s i z e_{x})$
两个点在x的子树内， $s i z e_{x} \times (n - s i z e_{x} - 1) \times (n - s i z e_{x})$

代码：

#include<cstdio>
#include<algorithm>
using namespace std;
int n,head[100005],edgenum,siz[100005],dep[100005];
struct edge{
	int to,nxt,val;
}e[200005];
double sum[100005];
void add(int u,int v,int w)
{
	e[++edgenum].nxt=head[u];
	e[edgenum].to=v;
	e[edgenum].val=w;
	head[u]=edgenum;
}
void dfs(int u,int fa)
{
	siz[u]=1;
	dep[u]=dep[fa]+1;
	for(int i=head[u];i;i=e[i].nxt)
	{
		int v=e[i].to;
		if(v==fa) continue;
		dfs(v,u);
		siz[u]+=siz[v];
	}
}
int u[100005],v[100005],w[100005];
int main()
{
	scanf("%d",&n);
	for(int i=1;i<n;i++)
	{
		scanf("%d%d%d",&u[i],&v[i],&w[i]);
		add(u[i],v[i],w[i]);
		add(v[i],u[i],w[i]);
	}
	dfs(1,0);
	for(int i=1;i<n;i++)
	{
		if(dep[u[i]]>dep[v[i]]) swap(u[i],v[i]);
		sum[i]=1.0*siz[v[i]]*(n-siz[v[i]])*(siz[v[i]]-1)/2;
		sum[i]+=1.0*siz[v[i]]*(n-siz[v[i]])*(n-siz[v[i]]-1)/2;
	}
	double ans=0,s=0,tmp=1.0*n*(n-1)*(n-2);
	for(int i=1;i<n;i++)
	{
		ans+=sum[i]*w[i];
	}
	int q=0;
	scanf("%d",&q);
	while(q--)
	{
		int r,val;
		scanf("%d%d",&r,&val);
		ans+=sum[r]*(val-w[r]);
		w[r]=val;
		printf("%.10lf\n",ans*12.0/tmp);
	}
	return 0;
}

posted @ 2024-03-03 21:41 wangsiqi2010916 阅读(26) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 20240609比赛总结

· 组合数学专项训练记录 2024.3

· 概率与期望

· 概率与期望专项

· 概率与期望

阅读排行：
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 单元测试从入门到精通
· 上周热点回顾（3.3-3.9）
· winform 绘制太阳，地球，月球运作规律

wangsiqi2010916

温柔正确的人总是难以生存,因为这世界既不温柔,也不正确