CCF NOIP 2021模拟 10.19

最新推荐文章于 2024-07-09 22:37:42 发布

oi_521289

最新推荐文章于 2024-07-09 22:37:42 发布

阅读量243

点赞数

分类专栏：测试文章标签： c++

本文链接：https://blog.csdn.net/oi_521289/article/details/120865184

版权

测试专栏收录该内容

5 篇文章 0 订阅

订阅专栏

CCF NOIP 2021模拟 10.19

写博客的原因是我几个月没写字不会写了。。。

T1

问题

回家（home）
【题目描述】
小 Z 是个路痴。有一天小 Z 迷路了，此时小 Z 到家有 N 个单位长度。小 Z 可以进行若
干次行动，每次行动小 Z 有
1
2的概率向家靠近一个单位长度，有1
2的概率向家远离一个单位长
度。由于小 Z 的体力是有限的，他最多能行动 K 次。请你帮帮可怜的小 Z 算一算，他在体
力耗尽之前到达家中的概率是多少。
【输入格式】
从文件 home.in 中读入数据。
一行两个用空格分隔的整数 N，K。表示小 Z 到家的距离和小 Z 能行动的次数。
【输出格式】
输出到文件 home.out 中。
一行一个整数表示小 Z 回到家的概率，结果对 998244353 取模。
【样例一输入】
1 3
【样例一输出】
374341633
【样例二输入】
5 10
【样例二输出】
889061377
【样例三】
见选手目录下的 home/home3.in 与 home/home3.ans。其满足测试点 3~6 的数据范围。
【数据范围】
测试点编号 𝑁 ≤ 𝐾 ≤
1~2 10 10
3~6 5000 5000
7~8 1
5000000
9~10 5000000
对于所有测试点保证1 ≤ 𝑁 ≤ 5000000，1 ≤ 𝐾 ≤ 5000000。

得了10分，感觉评测机有问题，或许我写代码太丑了。。。数组开成500000，但应该有60分。开5000000能过，挺离谱的。

题解

60分做法显然， $n^2$ dp记搜。
考虑应该 $O (n) ∣ O (k)$ 算。想法是枚举一个向右一共走的步数 $i$ $(0\le i\le \frac{n-k}{2})$ ，那么答案就是 $\sum_{i=0}^{\frac{n-k}{2}} (\frac{1}{2})^{(2\times i+n)}\times 方案数$ ，表示强制每次走哪边的总概率和每次向哪边走的总方案数。
考虑方案里面什么不合法，发现因为走哪边（步数）固定，最后一定能回去，问题在可能没有走完向右的规定步数就已经回去了，如果把向左变成-1，向右变成+1，初始位置为n，那么就是求排列让所有前缀>0，最后=0，发现和卡特兰数很像。
画图发现问题就是从 $\left (n,0\right )$ 走到 $\left (n+i,n+i\right )$ 且中途不经过 $y = x$ 的方案数，但是终点坐标在 $y = x$ 不好用折线法。考场上我把式子蒙出来了，看样例蒙了好久。考虑一件事，走到 $\left (n+i,n+i\right )$ 最后一定是从 $\left (n+i,n+i-1\right )$ 过来（不然在 $y = x$ 左侧），所以终点变为到一个不是 $y = x$ 的点，折线法显然。最后就有式子了： $\sum_{i=0}^{\frac{n-k}{2}} (\frac{1}{2})^{(2\times i+n)}\times \left(C_{n+2\times i-1}^{i}-C_{n+2\times i-1}^{i-1}\right)$
最后贴个代码（考试把数组开成500000，最后测也输入的是500000.。。。）

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
namespace Modular{
	const LL mod=998244353;
	inline LL add(const LL a,const LL b){
		return a<mod-b?a+b:a-mod+b;
	}
	inline LL dec(const LL a,const LL b){
		return a<b?a-b+mod:a-b;
	}
	inline LL mul(const LL a,const LL b){
		return a*b%mod;
	}
	inline void Add(LL &a,const LL b){
		a=a<mod-b?a+b:a-mod+b;
	}
	inline void Dec(LL &a,const LL b){
		a=a<b?a-b+mod:a-b;
	}
	inline void Mul(LL &a,const LL b){
		a=a*b%mod;
	}
	inline LL ksm(LL a,LL p){
		LL res; 
		for(res=1;p;Mul(a,a),p>>=1)
			(p&1)&&(Mul(res,a),1);
		return res;
	}
	inline LL Inv(const LL a){
		return ksm(a,mod-2);
	}
	inline void Min(LL &a,const LL b){
		a=min(a,b);
	}
	inline void Max(LL &a,const LL b){
		a=max(a,b);
	}
};
using namespace Modular;

#define int long long
const int N=5000010<<1,K=5000010;
int n,k; LL fac[N],inv[N],inv2,pwv[K],ans;

inline void pre(){
	fac[1]=1; for(int i=2;i<N;i++) fac[i]=mul(fac[i-1],i);
	inv[N-1]=Inv(fac[N-1]); for(int i=N-2;i>=1;i--) inv[i]=mul(inv[i+1],i+1);
}
inline LL C(const int n,const int m){
	if(n==m||!m) return 1; if(!n) return 0;
	return mul(fac[n],mul(inv[n-m],inv[m]));
} 
#define in read()
inline int read(){
	int f=1,k=0; char cp=getchar(); 
	while(cp!='-'&&(cp<'0'||cp>'9')) cp=getchar(); if(cp=='-') f=-1,cp=getchar();
	while(cp>='0'&&cp<='9') k=(k<<3)+(k<<1)+cp-48,cp=getchar(); return f*k;
}
signed main(){ pre();
//	freopen("home.in","r",stdin),freopen("home.out","w",stdout);
	n=in,k=in; inv2=Inv(2); 
	pwv[0]=ksm(inv2,n); for(int i=1;i<=k;i++){
		pwv[i]=mul(pwv[i-1],inv2); 
	}
	for(int i=0;i<=(k-n)>>1;i++){ //向右的步数 
		Add(ans,mul(pwv[i+i],dec(C(n+i+i-1,i),C(n+i+i-1,i-1))));
	} printf("%lld\n",ans);

	return 0;
}

T2

问题

最小化（min）
【题目描述】
小 F 有一个长度为 N 的正整数序列 A。他的好朋友小 T 提出了这样的一个概念，对于
一个序列 A，它的 K 项差和为所有相邻 K 项的元素的差的绝对值的和。以序列 A 为例，它
的 K 项差和为：
∑ |𝐴[𝑖] − 𝐴[𝑖 + 𝑘]|
𝑛−𝑘
𝑖=1
现在小 F 想求序列 A 的 K 项差和，为了使序列 A 的 K 项差和尽可能地小，小 F 决定对
序列 A 进行重新排序。现在，请你帮助小 F 求出对序列 A 进行任意重排后其 K 项差和的最
小值。
【输入格式】
从文件 min.in 中读入数据。
一行两个用空格分隔的整数 N，K。表示序列长度和差和项数。
接下来一行 N 个用单个空格分隔的正整数表示序列 A。
【输出格式】
输出到文件 min.out 中。
一行一个整数表示重排序列 A 后其的 K 项差和的最小值。
【样例一输入】
6 3
4 3 4 3 2 5
【样例一输出】
3
【样例一解释】
重新排列后的序列为 2 3 4 4 3 5。
其 3 项差和的值为 |2-4|+|3-3|+|4-5|=3。
易证明没有比该排列方式 3 项差和更小的排列方式。
【样例二】
见选手目录下的 min/min2.in 与 min/min2.ans。其满足测试点 3~6 的数据范围。
【样例三】
见选手目录下的 min/min3.in 与 min/min3.ans。其满足测试点 7~12 的数据范围。
【数据范围】
测试点编号 𝑁 ≤ 𝐾 ≤ 特殊性质
1~2 10 10
3~6 200 20
7~12 50000 500
13~16
1000000 5000
满足
17~20
特殊性质：满足 N 为 K 的倍数
对于所有测试点保证1 ≤ 𝑁 ≤ 1000000，1 ≤ 𝐾 ≤ 𝑚𝑖𝑛(5000, 𝑁 − 1)，1 ≤ 𝐴[𝑖] ≤ 1e9。

贪心假做法拿了25分，~~数据给的太水~~。怎么说呢，其实没有那么难，主要感觉被问题吓到了。

题解

其实贪心已经很接近正解了，问题不能想的特别难也不能想的特别简单，稍微多想一会儿，不要一开始被吓到，或许题意越简单越难。如果问题变成：把数列分配出规定的几段（顺序随意），求最小值，显然你就会去去考虑分的顺序。而这个题如果 $k ∣ n$ 发现随便分就是对的，不整除也只有n/k和n/k+1两种长度的，显然就考虑dp，复杂度 $k^2$ 。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

#define int long long
const int N=1000010,K=5010;
int n,k,a[N],f[K][K]; //i个n/k的，j个n/k+1的min 
int num,num1,len,len1;

inline int pos(const int i,const int j){
	return i*len+j*len1;
}
#define in read()
inline int read(){
	int f=1,k=0; char cp=getchar();
	while(cp!='-'&&(cp<'0'||cp>'9')) cp=getchar(); if(cp=='-') f=-1,cp=getchar();
	while(cp>='0'&&cp<='9') k=(k<<3)+(k<<1)+cp-48,cp=getchar(); return f*k;
}
signed main(){ 
	n=in,k=in; for(int i=1;i<=n;i++) a[i]=in; sort(a+1,a+n+1);
	num1=n%k,len=n/k,len1=n/k+1,num=(n-num1*len1)/len;
	memset(f,0x3f,sizeof(f)); f[0][0]=0;
	for(int j=1;j<=num1;j++) f[0][j]=f[0][j-1]+a[pos(0,j)]-a[pos(0,j-1)+1];
	for(int i=1;i<=num;i++){
		f[i][0]=f[i-1][0]+a[pos(i,0)]-a[pos(i-1,0)+1];
		for(int j=1;j<=num1;j++)
			f[i][j]=min(f[i-1][j]+a[pos(i,j)]-a[pos(i-1,j)+1],f[i][j-1]+a[pos(i,j)]-a[pos(i,j-1)+1]);
	}
	printf("%lld\n",f[num][num1]);

	return 0;
}

T3

问题

集合（set）
【题目描述】
小 W 有一个可重正整数集合 S。集合 S 起初为空集。小 W 想对集合进行以下操作。
1．向集合中插入一个正整数 a。
2．每次令集合中 c 个正整数减小 1，求最多进行的操作次数（该操作不改变集合中元
素本身的值）。
现在，请您编写一个程序，帮助小 W 实现上述功能。
【输入格式】
从文件 set.in 中读入数据。
一行两个用空格分隔的整数 N。表示操作数。
接下来 N 行，每行一个数字 1 或 2 表示操作类型
若该数字为 1，在其后有一个用单个空格分隔的数字 a。表示插入的正整数值。
若该数字为 2，在其后有一个用单个空格分隔的数字 c。表示每次减 1 的元素个数。
【输出格式】
输出到文件 set.out 中。
对于每个 2 操作，输出一行一个整数表示此次操作最多进行的次数。
【样例一输入】
6
1 5
1 7
2 2
1 1
2 2
2 1
【样例一输出】
5
6
13
【样例一解释】
初始集合为∅
第一次操作后为{5}
第二次操作后为{5,7}
第三次操作每次都取出第一项与第二项减一，最多进行 5 次
第四次操作后为{5,7,1}
第五次操作前五次都取出第一项与第二项减一，最后一次取出第二项与第三项减一，最
多进行 6 次。
第六次操作每次都取出任意一项减一，最多进行 13 次。
【样例二】
见选手目录下的 set/set2.in 与 set/set2.ans。其满足测试点 4~6 的数据范围。
【样例三】
见选手目录下的 set/set3.in 与 set/set3.ans。其满足测试点 9~10 的数据范围。
【数据范围】
𝑁 ≤ 特殊性质 A 测试点编号特殊性质 B 特殊性质 C
10
满足 1~3
100 4~6
5000
7~8
9~10 满足
50000 满足 11~14
100000 15~18
1000000
19~21 满足
21~25
特殊性质 A：满足1 ≤ 𝑎 ≤ 𝑁。
特殊性质 B：满足操作 2 的次数小于 10 次。
特殊性质 C：满足所有 1 操作在 2 操作之前。
对于所有测试点保证1 ≤ 𝑁 ≤ 1000000，1 ≤ 𝑎 ≤ 1e9，1 ≤ c ≤ N。

确实不会，但是24分暴力应该拿到，确实考了几天思绪很乱，每次找前c大全部-1知道第c大<=0，拿24分。

题解

考虑把权值加一起除c的ans为什么有问题，发现可能有权值>ans让分配不能均匀，即它并不能用来维护前c大的数>=0，因为它一个数占太多了。二分答案，权值>=mid的直接放前c个里面，设有x个，那么还需要凑出c-x个，直接判断权值<mid的和sum是否>= $\left(c-x\right)\times$ mid，原因是后面<mid的就可以全部随便分配给剩下的c-x做贡献了。
改的代码是 $nlogn^2$ 的，直接树状数组（线段树）走二分复杂度 $n l o g n$ 可过。贴的是T的码。

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

#define int long long
const int M=1000010,A=1e18+10;
int m,b[M],uni,c,ans;
struct Que{
	int opt,v;
}q[M];

struct Bit_tree{
	int bit[M];
	inline int lowbit(const int x){
		return x&-x;
	}
	inline void add(int x,const int v){
		while(x<=uni+1) bit[x]+=v,x+=lowbit(x);
	}
	inline int sum(int x){
		int res=0; while(x) res+=bit[x],x-=lowbit(x); return res; 
	}
}T_num,T_sum;

inline bool check(const int x){
	int pos=lower_bound(b+1,b+uni+1,x)-b;
	return (double)(c-T_num.sum(uni-pos+1))<=(double)T_sum.sum(pos-1)/x;
}
#define in read()
inline int read(){
	int f=1,k=0; char cp=getchar();
	while(cp!='-'&&(cp<'0'||cp>'9')) cp=getchar(); if(cp=='-') f=-1,cp=getchar();
	while(cp>='0'&&cp<='9') k=(k<<3)+(k<<1)+cp-48,cp=getchar(); return f*k;
}
signed main(){
	m=in; for(int i=1;i<=m;i++) q[i].opt=in,q[i].v=in; for(int i=1;i<=m;i++) if(q[i].opt==1) b[++uni]=q[i].v;
	sort(b+1,b+uni+1),uni=unique(b+1,b+uni+1)-b-1; for(int i=1;i<=m;i++) if(q[i].opt==1) q[i].v=lower_bound(b+1,b+uni+1,q[i].v)-b;
	for(int i=1;i<=m;i++){
		if(q[i].opt==2){ c=q[i].v; 
			int l=0,r=A; while(l<r){ int mid=(l+r+1)>>1;
				if(check(mid)) l=mid; else r=mid-1;
			} printf("%lld\n",l);
		}
		else T_num.add(uni-q[i].v+1,1),T_sum.add(q[i].v,b[q[i].v]);
	}
	
	return 0;
}

~~蒻蒻的补一个二分答案的模板，我太蒻了https://blog.csdn.net/weixin_43939593/article/details/107341955~~

T4

题目

王国（kingdom）
【题目描述】
小 X 正在玩一款叫做王国的游戏。
游戏的地图可以看作一个 N 个点 M 条边的无向图，每条边的边权为 1。
小 X 操纵着 S 支军队，位于地图的不同点 x 上，每只军队有三个属性，攻击力 a，行动
力 f，雇佣价格 p。
在这个地图上还有 B 个城堡，也位于地图的不同点 x 上。每个城堡有两个属性，防御
力 d，和攻破收益 g。
一个军队可以攻破一个城堡当且仅当
1．该军队的攻击力大于等于城堡的防御力。
2．该军队的行动力大于等于该军队所在点到城堡所在点的距离。
当一个军队攻破一个城堡后，小 X 会获得该城堡的攻破收益减去军队的雇佣价格的
差。（注意收益可以为负）
且如果一个军队无法攻破任何一个城堡，他会拒绝被雇佣。
一个军队只能攻破一个城堡，但是由于游戏的 bug，一个城堡可以被攻破多次。
并且小 X 的军队之间有着深厚的友情，当有些军队没有被雇佣时，其他军队也会拒绝
被雇佣。
具体的说，军队之间有 K 条依赖关系，每条依赖关系由 s1，s2 构成，也就是当且仅当
s2，被雇佣时，s1 才会接受被雇佣。
现在小 X 希望你帮助他算一算，他能获得的最大收益是多少。
【输入格式】
从文件 kingdom.in 中读入数据。
第一行两个用空格分隔的整数 N，M。表示地图的点数和边数。
接下来 M 行，每行两个用空格分隔的数字 u，v 表示一条边所连接的两个点。
接下来三个用空格分隔的整数 S，B，K 表示军队数，城堡数，依赖关系数。
接下来 S 行，每行四个用空格分开的数字 x，a，f，p 表示军队的位置，攻击力，行动
力，雇佣价格。
接下来 B 行，每行三个用空格分开的数字 x，d，g 表示城堡的位置，防御力，攻破收
益。
接下来 K 行，每行两个用空格分开的数字 s1，s2 表示 s1 依赖于 s2。
【输出格式】
输出到文件 kingdom.out 中。
一行一个整数，表示小 X 获得的最大收益。
【样例一输入】
6 7
1 2
2 3
3 4
4 6
6 5
4 4
3 6
4 2 2
1 10 2 5
3 8 2 7
5 1 0 2
6 5 4 1
3 7 6
5 2 3
4 2
3 2
【样例一输出】
2
【样例一解释】
用军队 1，2，4 分别攻击城堡 1，1，2 是收益最大的方案，容易证明没有比该方案收益
更大的方案。
【样例二】
见选手目录下的 kingdom/kingdom2.in 与 kingdom/kingdom2.ans。其满足测试点 3~4
的数据范围。
【样例三】
见选手目录下的 kingdom/kingdom3.in 与 kingdom/kingdom3.ans。其满足测试点 10 的
数据范围。
【样例四】
见选手目录下的kingdom/kingdom4.in与kingdom/kingdom4.ans。其满足测试点15~16
的数据范围。
【数据范围】
𝑁 ≤ 𝑀 ≤ 𝑆, 𝐵 ≤ 测试点编号 𝐾 ≤ 特殊性质
1 0 10 1
0
5 10 100 2
10
100
2000
3~4
0
5
200000
6~7 10
1000
8 0
9 10
10 1000 满足
100 10000
11~14 0
15~16 10
17~20
1000
满足
21~25
特殊性质：满足 s1<s2。
对于所有测试点保证1 ≤ 𝑁 ≤ 100，0 ≤ 𝑀 ≤ 10000，1 ≤ 𝑆, 𝐵 ≤ 200000，0 ≤ 𝐾 ≤ 1000。
1 ≤ 𝑢, 𝑣, 𝑥, 𝑓 ≤ 𝑁，1 ≤ 𝑎, 𝑝, 𝑏, 𝑔 ≤ 1𝑒9，1 ≤ 𝑠1, s2 ≤ 𝑆。

~~说起来可能不信，因为是校内自己出题，数据很水，假算法可以过（不考虑k）。~~
我得了60，我考虑多了，呵呵。~~白学网络流~~ 。

题解

发现每个点不考虑k贡献独立，所以问题一分为二，一个是求每个点贡献，一个是DAG求贡献最大值。
第一个问题先floyed预处理最短路。然后把攻防排序，双指针按顺序加。加城堡就枚举所有点，在每个点的树状数组的权值为两点dis的地方加上收益，加军队就在该点树状数组求行动力内的max，k=0的点就直接把>0的加起来就行了。
第二个问题是经典的最小割，最大闭合子图。其实仔细想想数据范围（k<=2000)和那些dp奇怪的限制不难发现，~~但宁管这叫NOIP???~~
代码是ac的，没打网络流，数据水了，把注释掉的 !k 加上就只有60分了（我打了个寂寞，昏死了）。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

#define int long long
const int N=110,J=200010,K=1010,E=K;
int he[J],ne[E],to[E],tot; 
int n,m,x,y,d[N][N],S,B,k,f[J],ans; 
struct Jun{
	int pos,a,f,v,id;
	inline bool operator < (const Jun &y)const{
		return a<y.a;
	}
}j[J];
struct Bao{
	int pos,a,c,id;
	inline bool operator < (const Bao &y)const{
		return a<y.a;
	}
}b[J];

int bit[N][N];
inline int lowbit(const int x){
	return x&-x;
}
inline void add(const int p,int x,const int v){
//	cout<<"-> "<<p<<' '<<x<<' '<<v<<endl;
	++x;
	while(x<=n+1) bit[p][x]=max(bit[p][x],v),x+=lowbit(x);
}
inline int sum(const int p,int x){
	++x;
	int res=0; while(x) res=max(res,bit[p][x]),x-=lowbit(x); return res;
}

int dfn[J],dfnn,low[J],col[J],c[J],g[J],coll; stack<int> sta; bool ins[J];
struct Edge{
	int x,y;
}e[E]; int cnt;
vector<int> eg[J]; int ru[J]; bool vis[J];
inline void insert(const int x,const int y){
	e[++cnt].x=x,e[cnt].y=y;
	to[++tot]=y,ne[tot]=he[x],he[x]=tot;
}
inline void tar(const int p){
	dfn[p]=low[p]=++dfnn; sta.push(p),ins[p]=1;
	for(int i=he[p];i;i=ne[i]){
		if(!dfn[to[i]]) tar(to[i]),low[p]=min(low[p],low[to[i]]);
		else if(ins[to[i]]) low[p]=min(low[p],dfn[to[i]]);
	}
	if(low[p]==dfn[p]){ ++coll; 
		int x; do{ x=sta.top(); sta.pop(); 
			col[x]=coll,c[coll]+=f[x];
		}while(x!=p);
	} ins[p]=0;
}
inline void dfs(const int p){ 
	vis[p]=1; for(int to:eg[p]){ 
		--ru[to]; if(!ru[to]) dfs(to),c[p]+=g[to];
	} g[p]=max(0ll,c[p]);
}

#define in read()
const int Mxdt=100000; 
inline char gc(){
	static char buf[Mxdt],*p1=buf,*p2=buf;
	return p1==p2&&(p2=(p1=buf)+fread(buf,1,Mxdt,stdin),p1==p2)?EOF:*p1++;
}
inline int read(){
	int t=0,f=0;char v=gc();
	while(v<'0')f|=(v=='-'),v=gc();
	while(v>='0')t=(t<<3)+(t<<1)+v-48,v=gc();
	return f?-t:t;
}
signed main(){ 
//	freopen("kingdom.in","r",stdin),freopen("kingdom.out","w",stdout);
	n=in,m=in; 
	memset(d,0x3f,sizeof(d)); for(int i=1;i<=n;i++) d[i][i]=0; while(m--) x=in,y=in,d[x][y]=d[y][x]=1;  
	for(int k=1;k<=n;k++) for(int i=1;i<=n;i++) if(i!=k) for(int j=1;j<=n;j++) if(j!=k&&j!=i) 
		d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
	S=in,B=in,k=in;
	for(int i=1;i<=S;i++) j[i].pos=in,j[i].a=in,j[i].f=in,j[i].v=in,j[i].id=i;
	for(int i=1;i<=B;i++) b[i].pos=in,b[i].a=in,b[i].c=in,j[i].id=i;
	sort(j+1,j+S+1),sort(b+1,b+B+1);
	for(int i=1,k=1;i<=S;i++){
		while(k<=B&&b[k].a<=j[i].a){ for(int i=1;i<=n;i++) add(i,d[b[k].pos][i],b[k].c); ++k; }
		f[j[i].id]=sum(j[i].pos,j[i].f)-j[i].v; ans+=max(0ll,f[j[i].id]);
	} //if(!k) 
	return printf("%lld\n",ans),0;
	while(k--) insert(in,in); for(int i=1;i<=S;i++) if(!dfn[i]) tar(i); 
	for(int i=1;i<=cnt;i++) if(col[e[i].x]!=col[e[i].y]) eg[col[e[i].x]].push_back(col[e[i].y]),++ru[col[e[i].y]];
	ans=0; for(int i=1;i<=coll;i++) if(!vis[i]&&!ru[i]) dfs(i),ans+=g[i]; printf("%lld\n",ans);

	return 0;
}

蒟蒻第一次写，格式之类还有语言可能不协调，多见谅，有什么问题评论一下，~~别喷，相信也没谁看吧~~ 。可能也写不了几次了，准备AFO。

oi_521289

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
CCF NOIP 2021模拟 10.19

CCF NOIP 2021模拟 10.19写博客的原因是我几个月没写字不会写了。。。T1问题回家（home）【题目描述】小 Z 是个路痴。有一天小 Z 迷路了，此时小 Z 到家有 N 个单位长度。小 Z 可以进行若干次行动，每次行动小 Z 有12的概率向家靠近一个单位长度，有12的概率向家远离一个单位长度。由于小 Z 的体力是有限的，他最多能行动 K 次。请你帮帮可怜的小 Z 算一算，他在体力耗尽之前到达家中的概率是多少。【输入格式】从文件 home.in 中读入数据。一行两
复制链接

扫一扫