hdu 杭电多校第八场 G L

最新推荐文章于 2022-08-13 00:19:53 发布

原创最新推荐文章于 2022-08-13 00:19:53 发布 · 289 阅读

0 ·

CC 4.0 BY-SA版权

hdu多校专栏收录该内容

1 篇文章

订阅专栏

本文深入探讨了两个基于博弈论的游戏算法。一是通过莫比乌斯系数和概率计算解决的牌类游戏，目标是找到先手必胜的概率；二是树形结构上的节点操作优化问题，旨在最小化操作次数使所有节点值落在指定区间内。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

G - Gaming of Co-prime Disallowance
题意：
给你n张牌，牌有值，两人轮流拿，求先手必胜的概率。
以下两种情况算输

1.当你拿的所有数的gcd=1时，游戏结束
2.任一人没有牌拿的时候，游戏结束

思路：
我们容易想到从反面想失败的概率，轮流拿使得GCD=X的情况，这样的话考虑必败情况，就是两人拿2k张牌之后，先手的人再拿一张牌，就结束了，所以直接考虑容斥，先取GCD=1的倍数的-2-3…这显然是莫比乌斯的系数。
剩下的就是按照概率计算就好了，可以dp预处理出GCD=x的和GCD不等于x的个数分别为i,j时连续取2k个后失败的概率。这个预处理实际上不到4e6的复杂度
具体就是这样
在这里插入图片描述

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
const int maxn=1e5+5;
int mu[maxn],cnt=0,a[maxn],num[maxn],prime[maxn];
double dp[103][103],ans;
bool v[maxn];
vector<int>fac[maxn];
int gcd(int a,int b){
	return b?gcd(b,a%b):a;
}
void init(){
	mu[1]=1;
	for(int i=2;i<=maxn-5;++i){
		if(!v[i]){
			prime[++cnt]=i;
			mu[i]=-1;
		}
		for(int j=1;j<=cnt&&prime[j]*i<=maxn-5;++j){
			v[prime[j]*i]=1;
			if(i%prime[j]==0){
				mu[i*prime[j]]=0;
				break;
			}
			else mu[i*prime[j]]=-mu[i];
		}
	}
	for(int i=1;i<=100;++i){
		for(int j=1;j+i<=100;++j){
			double p=1;
			double x1=i,x2=j;
			for(int k=1;k<=i;++k){//delete
				p*=1.0*x1/(x1+x2);
				x1--;
				if(k%2==0){
					dp[i][j]+=p*1.0*x2/(x1+x2);
				}
			}
		}
	}
	for(int i=1;i<=maxn-5;++i)
		for(int j=1;j<=(maxn-5)/i;++j)
			fac[i*j].push_back(i);
}
int main(){
	int t,n;
	init();
	scanf("%d",&t);
	while(t--){
		scanf("%d",&n);
		memset(num,0,sizeof(num));
		int num1=0,mx=0;
		for(int i=1;i<=n;++i){
			scanf("%d",&a[i]);
			mx=max(mx,a[i]);
			if(a[i]==1)num1++;
			for(auto&v:fac[a[i]])
				num[v]++;
		}
		int GCD=a[1];
		for(int i=2;i<=n;++i)GCD=gcd(GCD,a[i]);
		if(GCD>1){
			if(n&1)
				printf("%.9lf\n",1.0);
			else	
				printf("%.9lf\n",0.0);
		}else{
			 ans=1.0*num1/n;
			 for(int i=2;i<=mx;++i)
				 ans-=1.0*mu[i]*dp[num[i]][n-num[i]];
			 printf("%.9lf\n",1-(double)ans);
		}
	}
	return 0;
}

L.Linuber File System
题意：
给你一棵树，初始每个树的权值为0，对于每个节点，可以进行一次操作，对这个节点的子树包括自身加上一个权值（可为0，+，-），问最少操作次数使得每个节点都在[Li,Ri]区间中

思路：
有一个容易想到的点是，每个节点其实最多操作一次，因为我们可以合并多次操作，第二个点受启发于我队长出的一道新生杯的题，当前点的值只和该点的祖先有关，所以dp[u][x]表示该
u点的祖先对于u的影响为x时候,u的子树的最小操作次数。怎么转移呢？枚举子节点的第二维，如果回溯到u的时候，父子节点的第二维相同，则操作次数不变，否则在根节点+1。
值域其实只有4000个点，为什么呢，因为dp在边界的点和内部的点的操作次数，是不影响的，我们可以离散化后做，
所以我们还可以在子节点的时候，维护前后缀的最小值，这样就可以O（1）转移了
总复杂度O（T（n^2+logn））

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
const int maxn=4e3+5;
const int INF=1e9;
vector<int>G[maxn];
int dp[maxn][maxn],l[maxn],r[maxn],dis[maxn],a,b,cnt,m,mx[maxn];
void dfs(int now,int fa){
	for(auto&v:G[now]){
		if(v==fa)continue;
		dfs(v,now);
		for(int i=1;i<=m;++i)
			dp[now][i]+=dp[v][i];
	}
	mx[0]=INF;
	for(int i=1;i<=m;++i){
		if(l[now]<=i&&i<=r[now])
			mx[i]=min(mx[i-1],dp[now][i]),dp[now][i]=min(dp[now][i],mx[i-1]+1);
		else
			mx[i]=mx[i-1],dp[now][i]=mx[i-1]+1;
	}
	mx[m+1]=INF;
	for(int i=m;i;--i){
		if(l[now]<=i&&i<=r[now])
			mx[i]=min(mx[i+1],dp[now][i]),dp[now][i]=min(dp[now][i],mx[i+1]+1);
		else
			mx[i]=mx[i+1],dp[now][i]=min(dp[now][i],mx[i+1]+1);
	}
}
int main()
{
	int t,n;
	scanf("%d",&t);
	while(t--){
		cnt=0;
		scanf("%d",&n);
		for(int i=1;i<=n;++i)G[i].clear();
		for(int i=1;i<=n-1;++i){
			scanf("%d%d",&a,&b);
			G[a].push_back(b);
			G[b].push_back(a);
		}
		for(int i=1;i<=n;++i){
			scanf("%d%d",&l[i],&r[i]);
			dis[++cnt]=l[i],dis[++cnt]=r[i];
		}
		dis[++cnt]=0;
		sort(dis+1,dis+1+cnt);
		m=unique(dis+1,dis+1+cnt)-(dis+1);
		for(int i=1;i<=n;++i){
			l[i]=lower_bound(dis+1,dis+1+m,l[i])-dis;
			r[i]=lower_bound(dis+1,dis+1+m,r[i])-dis;
		}
		memset(dp,0,sizeof(dp));
		dfs(1,0);
		printf("%d\n",dp[1][lower_bound(dis+1,dis+1+m,0)-dis]);
	}
	return 0;
}