CCPC－Wannafly & Comet OJ 夏季欢乐赛（2019）

最新推荐文章于 2020-05-23 16:41:46 发布

对方正在debug

最新推荐文章于 2020-05-23 16:41:46 发布

阅读量143

点赞数

分类专栏：个人训练

本文链接：https://blog.csdn.net/weixin_43918473/article/details/97618000

版权

个人训练专栏收录该内容

64 篇文章 0 订阅

订阅专栏

原题链接：https://www.cometoj.com/contest/59/problems

A 完全k叉树

题意：给定一个结点树为n的完全k叉树，问树中距离最远的两点。
题解：先找树中深度最高的点，再找和上一个点不在同一个子树上的点，两点深度加起来为答案。

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn=100010;
ll n,k;
ll quickpow(ll x,ll p)
{
	ll ans=1;
	while(p){
		if(p&1) ans=ans*x;
		x=x*x;
		p>>=1;
	}
	return ans;
}
ll geth()
{
	ll ans=n*(k-1)+1;
	ll h=log(1.0*ans)/log(1.0*k);
	if(quickpow(k,h)-1<n*(k-1)) h++;//向上取整 
	h--;
	return h;
}
int main()
{
	int t;scanf("%d",&t);
	while(t--){
		scanf("%lld%lld",&k,&n);
		if(k==1){
			printf("%lld\n",n-1);continue;
		}
		ll h=geth();//第一个点深度 
		ll s=quickpow(k,h-1);//深度最高的点其对应的子树规模 
		ll m=(s*k-1)/(k-1);//深度次高及以上的树的结点总数 
		h*=2;
		if(n-m<=s) h--;
		
		printf("%lld\n",h);
	}
	return 0;
}

B 距离产生美

题意：给定一个序列，求最少修改元素个数，使得相邻元素间差值不小于k。
贪心修改即可

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn=100010;
int n,k;
ll a[maxn];
ll Abs(ll x,ll y)
{
	return x>y?x-y:y-x;
}

int main()
{
	while(~scanf("%d%d",&n,&k)){
		for(int i=1;i<=n;i++) scanf("%lld",&a[i]);
		//sort(a+1,a+n+1);脑子抽了给数组排序 。。 
		int ans=0;
		ll cur=1000000000000000000;
		for(int i=1;i<n;i++){
			if(Abs(a[i+1],a[i])<k){
				//swap(a[i],a[i+1]);
				a[i+1]=cur;cur-=k;
				ans++;
			}
		}
		printf("%d\n",ans);
	}
	return 0;
}

C 烤面包片

题意：求n!!!（3次阶乘运算）对mod取模的结果
鸡尾酒题解：首先根据范围可得 4!!一定大于 $10^9$ (事实上甚至大于 $10^{18}$ )，所
以 4!!!一定能被 mod 整除（n>4 也同理）。那么我们只需要判断 n≤3的情况了。直接计算即可。
如果写一个阶乘函数，然后调用连续三次来获得答案，如：((n!%mod)!%mod)!%mod 可能会无法通过以下的 text：（坑点啊QAQ）
2 2
（本应输出 0，但三次调用阶乘函数最终会输出 1，因为第一次调用
得到 0，之后再调用阶乘函数发现 0！是 1）
一个较好的处理方式是将 n=0，1，2 特判掉，然后预先计算出 3!!为
720，然后用一次 for 循环解决这道题。

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

int main()
{
	while(~scanf("%lld%lld",&n,&mod)){
		if(n==0){
			printf("%lld\n",1%mod);
		}else if(n<3){
			printf("%lld\n",n%mod);
		}else if(n>3){
			printf("0\n");
		}else{//3!!!
			ll cur=1;
			for(int i=1;i<=720;i++){
				cur=cur*i%mod;
			}
			printf("%lld\n",cur);
		}
	}
	return 0;
}

D 茶颜悦色（扫描线）

题意：给定n个二维坐标，问用边长为k的正方形最多能框住多少个点，含边界
题解：经典的线段树+扫描线，对于每个点（x,y），f=1，增加一个虚点（x+k,y），f=-1，把这些点按x坐标升序排序（x坐标相同时按f降序排，即优先加点）。处理好后，对于点f=1，我们把这个点对应的[y,y+k]加一；对于点f=-1，我们这个点对应的[y,y+k]减一。每次遇到一个f=1的点，我们update后查询下当前线段树最大值，更新答案。

#include<bits/stdc++.h>
using namespace std;
const int maxn=100010;

int n,k;
struct node{
	int x,y1,y2;
	int f;
}cur,a[maxn*2];
bool cmp(const node &a,const node &b)
{
	return a.x==b.x?a.f>b.f:a.x<b.x;// T.T刚开始忘了a.f>b.f
}
int b[maxn*2],c[maxn*2];
int sum[maxn<<3],cnt[maxn<<3];
void pushup(int rt)
{
	sum[rt]=max(sum[rt<<1],sum[rt<<1|1]);
}
void pushdown(int rt)
{
	cnt[rt<<1]+=cnt[rt];
	sum[rt<<1]+=cnt[rt];
	cnt[rt<<1|1]+=cnt[rt];
	sum[rt<<1|1]+=cnt[rt];
	cnt[rt]=0;
}
void update(int rt,int l,int r,int a,int b,int val)
{
	if(l>=a&&r<=b){
		sum[rt]+=val;
		cnt[rt]+=val;//
		return;
	}
	if(cnt[rt]) pushdown(rt); 
	int m=(l+r)>>1;
	if(a<=m) update(rt<<1,l,m,a,b,val);
	if(m<b) update(rt<<1|1,m+1,r,a,b,val);
	pushup(rt);
}
int query(int rt,int l,int r,int a,int b)
{
	if(l>=a&&r<=b)
		return sum[rt];
	if(cnt[rt]) pushdown(rt);
	int m=(l+r)>>1;
	int ans=0;
	if(a<=m) ans=max(ans,query(rt<<1,l,m,a,b));
	if(m<b) ans=max(ans,query(rt<<1|1,m+1,r,a,b));
	return ans;
}
int main()
{
	while(~scanf("%d%d",&n,&k)){
		int x,y;
		for(int i=0;i<n;i++){
			scanf("%d%d",&x,&y);
			cur.x=x;cur.y1=y;
			cur.f=1;cur.y2=y+k;
			a[i*2]=cur;
			cur.f=-1;cur.x=x+k;
			a[i*2+1]=cur;
			b[i*2]=x;b[i*2+1]=x+k;
			c[i*2]=y;c[i*2+1]=y+k;
		}
		sort(a,a+2*n,cmp);
		sort(b,b+2*n);
		sort(c,c+2*n);
		n*=2;
		
		int m2=unique(c,c+n)-c;
		for(int i=0;i<n;i++){
			a[i].y1=lower_bound(c,c+m2,a[i].y1)-c;
			a[i].y2=lower_bound(c,c+m2,a[i].y2)-c;
		}
		//build(1,0,m2);
		memset(sum,0,sizeof(sum));
		memset(cnt,0,sizeof(cnt));
		int ans=0,tmp;
		for(int i=0;i<n;i++){
			if(a[i].f==1){
				update(1,0,m2,a[i].y1,a[i].y2,1);
				ans=max(ans,sum[1]);
			}else{
				update(1,0,m2,a[i].y1,a[i].y2,-1);
			}
		}
		printf("%d\n",ans);
	}
}

E 飞行棋

题意：
飞行棋的规则如下：
1、每名玩家有一个棋子，每个回合可以掷一次骰子。
2、如果使用的骰子为 k 面，则这 k 面上的点数分别为 1,2,3, k且掷得每种点数的概率均为 $\frac{1}{k}$
3、如果当前回合掷得的点数为 Q，则玩家控制的棋子前进 Q 步。
4、若当前棋子的位置到终点的距离 d < Q，则棋子先行动 dd 步到终点，再倒退 Q−d 步。（即到终点的距离变为Q−d）
5、某一回合结束后，若该玩家的棋子恰好到达终点，则宣布胜利。
璇璇姐姐参与了这个游戏，已知现在她的棋子到终点的距离为 d，游戏使用的骰子有 k 面，求璇璇获得胜利需要的回合数期望。
鸡尾酒题解：
由题设骰子面数为 k，首先我们先来考虑当前到终点的距离 d 小
于 k 的情况。只有当扔出的点数Q == d时，可以到达终点，概率为 $\frac{1}{k}$
否则都会到达一个新的点?且? < ?，则相当于还是会有 $\frac{1}{k}$ 的概率到达终点。每次掷骰子到达终点的概率均为 $\frac{1}{k}$ ，则此时的期望为 k。
现在我们可以假设我们从终点出发，倒着做即可。假设现在到终点的距离为 n，那么只有可能从距离[n − k, n − 1]的区间掷骰子到此点，且概率均为 $\frac{1}{k}$ ，再加上投掷骰子的动作会使得期望+1。所以用概率 DP 的思想推得公式为 $E_n=1+\frac{1}{k}\sum_{i=n-k}^{n-1}E_i$
用快速幂即可解决。

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int mod=1e9+7;

ll d;
int n;
struct Matrix{
	ll a[25][25];
	Matrix(){
		memset(a,0,sizeof(a));
	}
	Matrix operator *(const Matrix &x){
		Matrix ans;
		for(int k=1;k<25;k++){
			for(int i=1;i<25;i++){
				for(int j=1;j<25;j++){
					ans.a[i][j]+=(a[i][k]*x.a[k][j]%mod+mod)%mod;
					ans.a[i][j]=(ans.a[i][j]%mod+mod)%mod; 
				}
			}
		}
		return ans;	
	}
	
};
ll getinv(ll x)
{
	if(x<=1) return 1LL;
	return (mod-mod/x)*getinv(mod%x)%mod;
}
Matrix quickp(Matrix a,ll p)// int p -> ll p T.T 
{
	Matrix res;
	for(int i=1;i<=n;i++) res.a[i][i]=1;
	while(p){
		if(p&1) res=res*a;
		p>>=1;
		a=a*a;
	}
	return res;
}
int main()
{
	while(~scanf("%lld%d",&d,&n)){
		if(d<=1LL*n){
			printf("%d\n",n%mod);continue;
		}
		n++;
		Matrix base;
		ll invn=getinv(n-1);
		for(int i=1;i<n;i++){
			base.a[i][n-1]=invn;
		}
		base.a[n][n-1]=1;
		for(int i=1;i<n-1;i++){
			base.a[i+1][i]=1;
		}
		base.a[n][n]=1;
		
		
		Matrix res=quickp(base,d-n+1);
		Matrix p;
		for(int i=1;i<n;i++)
			p.a[1][i]=n-1;
		p.a[1][n]=1;
		p=p*res;
		printf("%lld\n",p.a[1][n-1]%mod);
	}
	return 0;
}

F 三元组

题意：给定n个三元组 $a_i,b_i,c_i)$ ，对于每一对三元组，其中 $\le j$ ，若满足 $2*min(a_{i}+ a_{j},b_{i}+b_{j}) \le max(a_{i}+ a_{j},b_{i}+b_{j})$ ，她便能得到 $c_{i} *c_{j}$ 的小钱钱，总共能得到多少钱。

鸡尾酒题解：
对于一组满足条件的(i, j):2 ∗ min(?? + ??, ?? + ??) ≤ max(?? + ??, ?? + ??)
不妨设 2(?? + ??) ≤ ?? + ??,即ai + aj ≤ ?? + ??
移项可得 (2 ∗ ?? − bi) + (2 ∗ ?? − bj) ≤ 0
直接按照2 ∗ ?? − ??升序进行排序,记数组为P此时可以发现性质:
若??最多只能和??匹配,则?? + 1只能和[i + 1, j]之间的匹配此时使用滑窗即可计算答案
又因为我们只考虑了2(?? + ??) ≤ bi + bj的情况再对每个三元组中的??, bi进行交换,计算一次答案即可。

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn=100010;
const int mod=1e9+7;

struct node{
	ll a,b,c;
}arr[maxn];
bool cmp(const node &x,const node &y)
{
	return (2*x.a-x.b)<(2*y.a-y.b);
}
ll cal(node x)
{
	return 2*x.a-x.b;
}
ll ans,sum[maxn];
int n;
void solve()
{
	sort(arr,arr+n,cmp);
	for(int i=0;i<n;i++){
		if(!i) sum[i]=arr[i].c;
		else sum[i]=(arr[i].c+sum[i-1])%mod;
	}
	for(int i=0;i<n;i++){
		if(2LL*cal(arr[i])<=0) ans+=arr[i].c*arr[i].c%mod,ans%=mod;
	}
	for(int i=0,j=n-1;i<n&&i<j;i++){
		while(j>i&&cal(arr[i])+cal(arr[j])>0){
			j--;
		}
		if(j>i) ans+=arr[i].c*(((sum[j]-sum[i])%mod+mod)%mod)%mod,ans%=mod;//arr[j].c
	}
}
int main()
{
	while(~scanf("%d",&n)){
		for(int i=0;i<n;i++){
			scanf("%lld%lld%lld",&arr[i].a,&arr[i].b,&arr[i].c);
		}
		ans=0;
		solve();
		for(int i=0;i<n;i++) swap(arr[i].a,arr[i].b);
		solve();
		printf("%lld\n",ans);
	}
	return 0;
}

G 篮球校赛

题意：n 名队员，挑选 5 人组成一个篮球队来参赛。my给出每名队员在每个位置（共5个位置）的能力。
注：如果一个队员作为控球后卫出战，则他只能发挥他的控球后卫的能力值。（其他位置类似）选择出 5 名队员，分别放置在队伍中的不同位置。求他们组成的队伍的最大能力值之和。
题解：暴力5重for

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define inf 0x3f3f3f3f
const int maxn=100010;

struct node{
	int id,val;
};
node a[maxn],b[maxn],c[maxn],d[maxn],e[maxn];
bool vis[maxn];
bool cmp(const node& x,const node& y)
{
	return x.val>y.val;
}
int n;
int main()
{
	while(~scanf("%d",&n)){
		for(int i=0;i<n;i++){
			scanf("%d%d%d%d%d",&a[i].val,&b[i].val,&c[i].val,&d[i].val,&e[i].val);
			a[i].id=b[i].id=c[i].id=d[i].id=e[i].id=i+1;	
		} 
		sort(a,a+n,cmp);
		sort(b,b+n,cmp);
		sort(c,c+n,cmp);
		sort(d,d+n,cmp);
		sort(e,e+n,cmp);
		int m=min(5,n);
		memset(vis,0,sizeof(vis));
		ll ans=0;
		for(int i=0;i<m;i++){
			ll tmp=a[i].val;vis[a[i].id]=1;
			for(int j=0;j<m;j++){
				if(vis[b[j].id]) continue;
				tmp+=b[j].val;vis[b[j].id]=1;
				for(int k=0;k<m;k++){
					if(vis[c[k].id]) continue;
					tmp+=c[k].val;vis[c[k].id]=1;
					for(int x=0;x<m;x++){
						if(vis[d[x].id]) continue;
						tmp+=d[x].val;vis[d[x].id]=1;
						for(int y=0;y<m;y++){
							if(vis[e[y].id]) continue;
							tmp+=e[y].val;vis[e[y].id]=1;
//							printf("[");
//							for(int i=1;i<=n;i++) if(vis[i]) printf("%d ");
//							printf("] cur:%lld\n",tmp);
							ans=max(ans,tmp);
							vis[e[y].id]=0;
							tmp-=e[y].val;
							break;
						}
						tmp-=d[x].val;
						vis[d[x].id]=0;//break;
					}
					tmp-=c[k].val;
					vis[c[k].id]=0;//break;
				}
				tmp-=b[j].val;
				vis[b[j].id]=0;//break;
			}
			vis[a[i].id]=0;//break;
		}
		printf("%lld\n",ans);
	}
	return 0;
}

H 分配学号

题意：给定一个序列，用最少的修改方法，使得修改后序列的值不重复，且对元素修改只能增不能减，问有多少种修改方案。
鸡尾酒题解：先排序，然后判断当前位置的同学的学号有几种选择的方案，累乘获得结果。

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define inf 0x3f3f3f3f
const int mod=1e9+7;
const int maxn=100010;

ll a[maxn],b[maxn];
int n;

int main()
{
	while(~scanf("%d",&n)){
		for(int i=0;i<n;i++) scanf("%lld",&a[i]);
		sort(a,a+n);
		ll ans=1;
		for(int i=0,j;i<n;i=j){
			for(j=i+1;j<n&&a[j]<a[i]+j-i;j++)//a[i]+j-i VS a[j]
				ans=ans*(a[i]+j-i-a[j]+1)%mod;
		}
		printf("%lld\n",ans);
	}
	return 0;
}
/*
4
1 1 2 2
5
1 1 2 2 2
3
1 1 1
*/

I Gree的心房

#include<bits/stdc++.h>
using namespace std;
#define ll long long
int main()
{
	ll n,m,k;
	while(~scanf("%lld%lld%lld",&n,&m,&k)){
		if(n+m-1<=n*m-k){
			printf("%lld\n",n+m-2);
		}else{
			printf("-1\n");
		}
	}
}