比赛记录:牛客小白月赛90 A~F

已于 2024-04-06 17:18:12 修改
阅读量844 收藏 25
点赞数 31
分类专栏： c++算法 # 各类比赛 文章标签： 算法 c++
于 2024-04-06 17:16:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yingjiayu12/article/details/137429937
版权

传送门:牛客

[前题提要]:第一次AK小白月赛,赛后成为我们学校第一个牛客颜色到黄色的(好吧只是他们都不打牛客罢了),但是还是具有纪念意义的,故记录一下

这次的题目A~E个人感觉是偏简单的.

A 小A的文化节:

简单模拟题.
只要累加一下参加的比赛的贡献即可.

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls (rt<<1)
#define rs (rt<<1|1)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
inline void print(__int128 x){
	if(x<0) {putchar('-');x=-x;}
	if(x>9) print(x/10);
	putchar(x%10+'0');
}
#define maxn 1000000
const double eps=1e-8;
#define	int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
int a[maxn],b[maxn];
int main() {
	int n=read();int m=read();
	for(int i=1;i<=n;i++) {
		a[i]=read();
	}
	int sum=0;
	for(int i=1;i<=m;i++) {
		b[i]=read();
		sum+=a[b[i]];
	}
	cout<<sum<<endl;
	return 0;
}

B.小A的游戏

简单的数学题.
初看毫无思路,但是按照经典套路先列几个未知数,考虑设 x x x为A获胜的场数, y y y为平局的场数, z z z为B获胜的场数.
那么不难发现,A赢得的分数为 3 ∗ x + y 3*x+y 3∗x+y,B赢得的分数为 3 ∗ z + y 3*z+y 3∗z+y,然后就会发现两者差必须得满足3的倍数.但是这个只是必要条件.当然按照直觉,在比赛时,直接交一发试试正确即可,就会发现轻松AC了.现在考虑证明上述条件是充分条件.考虑现在我们有 X X X分数和 Y Y Y分数,两者差为3的倍数,考虑如何构造?我们发现只要设 x = X − Y 3 , z = 0 , y = Y x=\frac{X-Y}{3},z=0,y=Y x=3X−Y​,z=0,y=Y即可构造一组合法方案.现在我们就证明了充分性.

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls (rt<<1)
#define rs (rt<<1|1)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
inline void print(__int128 x){
	if(x<0) {putchar('-');x=-x;}
	if(x>9) print(x/10);
	putchar(x%10+'0');
}
#define maxn 1000000
const double eps=1e-8;
#define	int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
int main() {
	int T=read();
	while(T--) {
		int x=read();int y=read();
		if(abs(x-y)%3!=0) {
			cout<<"No"<<endl;
		}
		else {
			cout<<"Yes"<<endl;
		}
	}
	return 0;
}

C 小A的数字

简单贪心.
对于每一位如果该位是0,那么现在对应的答案该位我们填1.如果该位不是0,我们要填尽量的填0.
为什么说是尽量的呢.因为有一个坑点,假设我们现在的数字每一位都非0,我们按照上述的贪心构造,会发现答案最后是0,但是题目要求我们输出一个正整数,所以特判一下上述情况即可.(赛时我就因为这个wa了一发…)

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls (rt<<1)
#define rs (rt<<1|1)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
inline void print(__int128 x){
	if(x<0) {putchar('-');x=-x;}
	if(x>9) print(x/10);
	putchar(x%10+'0');
}
#define maxn 1000000
const double eps=1e-8;
#define	int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
int main() {
	int T=read();
	while(T--) {
		string s;cin>>s;int n=stoi(s);
		vector<int>v;
		for(int i=s.length()-1;i>=0;i--) {
			if(s[i]-'0'>0) {
				v.push_back(0);
			}
			else {
				v.push_back(1);
			}
		}
		reverse(v.begin(),v.end());
		int flag=0;
		for(int i=0;i<v.size();i++) {
			if(v[i]==0) {
				if(flag==0) {
					while(i+1<=v.size()-1&&v[i+1]==0) {
						i++;
					}
					flag=1;
					if(i==v.size()-1) {
						for(int j=1;j<=9;j++) {
							if(j!=s.back()-'0') {
								cout<<j;
								break;
							}
						}
					}
				}
				else {
					cout<<v[i];
				}
				
			}
			else {
				cout<<v[i];
			}
		}
		cout<<endl;
	}
	return 0;
}

E 小A的任务

简单贪心.
唯一需要注意的是存在这样一种情况,就是可能我们A多完成几个,然后选后面的B比前面的B更为优秀.
然后顺着上面的思路,发现 q q q才100,很好,对于每一个 q q q我们都可以进行枚举.考虑枚举我们A任务完成了 i i i个(按照题目要求,完成的任务必然是前缀任务),然后对于这A个任务,我们解锁了 i i i个B任务,现在我们的问题就是求这 i i i个中的前 k k k小和.继续抽象一下就会发现我们需要维护的是B任务前缀前 k k k小和.考虑使用优先队列来维护这个.一旦当前的队列中的数超过了 k k k个,贪心的想,我们必然要将队列中最大的那个数给踢出我们的贡献.这样就做完了.

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls (rt<<1)
#define rs (rt<<1|1)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
inline void print(__int128 x){
	if(x<0) {putchar('-');x=-x;}
	if(x>9) print(x/10);
	putchar(x%10+'0');
}
#define maxn 1000000
#define int long long
const double eps=1e-8;
#define	int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
int a[maxn],b[maxn];int sum[maxn];
signed main() {
	int n=read();int q=read();
	for(int i=1;i<=n;i++) {
		a[i]=read();
		sum[i]=sum[i-1]+a[i];
	}
	for(int i=1;i<=n;i++) {
		b[i]=read();
	}
	for(int i=1;i<=q;i++) {
		int k=read();
		priority_queue<int>Q;int sum2=0;
		int ans=ll_INF;
		for(int j=1;j<=n;j++) {
			Q.push(b[j]);sum2+=b[j];
			if(Q.size()>k) {
				sum2-=Q.top();
				Q.pop();
			}
			if(Q.size()>=k) 
				ans=min(ans,sum2+sum[j]);
		}
		cout<<ans<<endl;
	}
	return 0;
}

D&F 小A的线段（Easy&Hard version）

E a s y Easy Easy版本.
发现线段数才10个,直接枚举选取的线段的子集即可.对于枚举的选择的子集,此时我们需要判断的是该方案是否满足条件.
因为我们需要判断是否每一个点都被覆盖了至少2次,直接将其转化为区间覆盖问题即可.可以用线段树之类的数据结构维护(复杂度为 2 m m l o g n 2^mmlogn 2mmlogn,但是这个复杂度需要手写清空函数,不能直接建树覆盖,直接建树是O(n)的).当然对于本题,我们只要使用差分数组即可.复杂度为 2 m n 2^mn 2mn

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls (rt<<1)
#define rs (rt<<1|1)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
inline void print(__int128 x){
	if(x<0) {putchar('-');x=-x;}
	if(x>9) print(x/10);
	putchar(x%10+'0');
}
#define maxn 1000000
#define int long long
const int mod=998244353;
const double eps=1e-8;
#define	int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
struct Line{
	int l,r;
	bool operator < (const Line &rhs) const {
		if(l!=rhs.l) return l<rhs.l;
		else return r<rhs.r;
	} 
}line[maxn];int sum[maxn];
signed main() {
	int n=read();int m=read();
	for(int i=1;i<=m;i++) {
		line[i].l=read();line[i].r=read();
	}
	sort(line+1,line+m+1);
	int ans=0;
	for(int i=0;i<(1<<m);i++) {
		for(int j=1;j<=m;j++) {
			if(i&(1<<(j-1))) {
				sum[line[j].l]++;
				sum[line[j].r+1]--;
			}
		}
		int flag=0;
		for(int j=1;j<=n;j++) {
			sum[j]+=sum[j-1];
			if(sum[j]<2) {
				flag=1;break;
			}
		}
		if(flag==0) ans++;
		for(int j=1;j<=n;j++) {
			sum[j]=0;
		}
	}
	cout<<ans%mod<<endl;
	return 0;
}

H a r d Hard Hard版本.
发现 m m m到100了,显然已经不能枚举子集了,其实按照经验来说,一看到这道题,应该想到使用dp来解决本问题.反正我一看到就想到了.
考虑如何 d p dp dp,我们发现最终的状态和每个点覆盖的次数有关,不难想到一种状态是记录最后覆盖两次的点的位置(也就是在这个位置之前的点都被覆盖了两次).诶,此时我们就发现光记录两次似乎很难递推,因为我们需要用到另一种状态,也就是覆盖一次的点的位置.所以我们再把它加上.
在确定我们的dp方程之前,我们先要明确一点,上述的最后覆盖两次的点的位置以及至少覆盖了一次的点的位置一定是给定的线段的右端点位置,这一点很重要,并且覆盖两次的点的位置一定在覆盖一次的点的位置的左边
所以我们考虑设计dp状态,考虑设 d p [ i ] [ j ] [ k ] dp[i][j][k] dp[i][j][k]为枚举到第 i i i个线段,此时最后覆盖两次的点的位置是第 j j j条线段,最后覆盖一次的点的位置是第 k k k条线段的方案数.然后考虑如何进行递推.

  1. l i n e [ i ] . l < = l i n e [ j ] . r + 1 , l i n e [ i ] . r < = l i n e [ j ] . r line[i].l<=line[j].r+1,line[i].r<=line[j].r line[i].l<=line[j].r+1,line[i].r<=line[j].r,如下图:
    在这里插入图片描述
    不难发现此时选取 i i i这个线段,并不会改变原本覆盖状态,但是此时的方案数依旧是需要累加的.
    d p [ i ] [ j ] [ k ] + = d p [ i − 1 ] [ j ] [ k ] dp[i][j][k]+=dp[i-1][j][k] dp[i][j][k]+=dp[i−1][j][k]

  2. l i n e [ i ] . l < = l i n e [ j ] . r + 1 line[i].l<=line[j].r+1 line[i].l<=line[j].r+1, l i n e [ i ] . r < = l i n e [ k ] . r line[i].r<=line[k].r line[i].r<=line[k].r
    在这里插入图片描述
    不难发现此时选 i i i这个线段改变了覆盖两次的状态,但是没有改变覆盖一次的状态:
    d p [ i ] [ i ] [ k ] + = d p [ i − 1 ] [ j ] [ k ] dp[i][i][k]+=dp[i-1][j][k] dp[i][i][k]+=dp[i−1][j][k]

  3. l i n e [ i ] . l < = l i n e [ j ] . r + 1 line[i].l<=line[j].r+1 line[i].l<=line[j].r+1, l i n e [ i ] . r > l i n e [ k ] . r line[i].r>line[k].r line[i].r>line[k].r
    在这里插入图片描述
    d p [ i ] [ k ] [ i ] + = d p [ i − 1 ] [ j ] [ k ] dp[i][k][i]+=dp[i-1][j][k] dp[i][k][i]+=dp[i−1][j][k]

  4. l i n e [ i ] . l > l i n e [ j ] . r , l i n e [ i ] . r < = l i n e [ k ] . r line[i].l>line[j].r,line[i].r<=line[k].r line[i].l>line[j].r,line[i].r<=line[k].r
    在这里插入图片描述
    d p [ i ] [ j ] [ k ] + = d p [ i − 1 ] [ j ] [ k ] dp[i][j][k]+=dp[i-1][j][k] dp[i][j][k]+=dp[i−1][j][k]

  5. l i n e [ i ] . l > l i n e [ j ] . r , l i n e [ i ] . r > l i n e [ k ] . r line[i].l>line[j].r,line[i].r>line[k].r line[i].l>line[j].r,line[i].r>line[k].r
    在这里插入图片描述
    d p [ i ] [ j ] [ i ] + = d p [ i − 1 ] [ j ] [ k ] dp[i][j][i]+=dp[i-1][j][k] dp[i][j][i]+=dp[i−1][j][k]

需要注意的是上述递推方程必须将所有线段按左端点进行排序才能保证正确性.可以思考一下为什么一定要排序?

因为假设我们不进行排序,可能存在一个线段提前覆盖了后面部分,但是我们上述的dp方程是没有记录这种情况的,所以这种情况会被我们抛弃.而如果排序了,因为左端点单调性,会导致上述情况是不合法的.(所以其实上述的递推方程中的4,5是不合法的,也就是可以不用考虑这种情况)

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls (rt<<1)
#define rs (rt<<1|1)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
inline void print(__int128 x){
	if(x<0) {putchar('-');x=-x;}
	if(x>9) print(x/10);
	putchar(x%10+'0');
}
#define maxn 1000000
#define int long long
const int mod=998244353;
const double eps=1e-8;
#define	int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
struct Line{
	int l,r;
	bool operator < (const Line &rhs) const {
		if(l!=rhs.l) return l<rhs.l;
		else return r<rhs.r;
	} 
}line[maxn];
int dp[210][210][210];
signed main() {
	int n=read();int m=read();
	for(int i=1;i<=m;i++) {
		line[i].l=read();line[i].r=read();
	}
	sort(line+1,line+m+1);
	dp[0][0][0]=1;
	for(int i=1;i<=m;i++) {
		for(int j=0;j<=i-1;j++) {//覆盖2次
			for(int k=0;k<=i-1;k++) {//覆盖1次
				dp[i][j][k]+=dp[i-1][j][k];dp[i][j][k]%=mod;
				if(line[i].l<=line[j].r+1) {
					if(line[i].r<=line[j].r) {
						dp[i][j][k]+=dp[i-1][j][k];dp[i][j][k]%=mod;
					}
					else {
						if(line[i].r<=line[k].r) {
							dp[i][i][k]+=dp[i-1][j][k];dp[i][i][k]%=mod;
						}
						else {
							dp[i][k][i]+=dp[i-1][j][k];dp[i][k][i]%=mod;
						}
					}
					
				}
// 				else {这一部分可以不用,因为本身就是不合法的
// 					if(line[i].r<=line[k].r+1) {
// 						dp[i][j][k]+=dp[i-1][j][k];dp[i][j][k]%=mod;
// 					}
// 					else {
// 						dp[i][j][i]+=dp[i-1][j][k];dp[i][j][i]%=mod;
// 					}
// 				}
			}
		}
	}
	int ans=0;
	for(int j=0;j<=m;j++) {
		for(int k=0;k<=m;k++) {
			if(line[j].r>=n) {
				ans+=dp[m][j][k];ans%=mod;
			}
		}
	}	
	cout<<ans<<endl;
	return 0;
}
yingjiayu12
关注
  • 31
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
牛客小白月赛68
Kwjdefulgn的博客
03-12 446
小白月赛68
牛客小白赛实用知识库分享
09-19
牛客小白赛实用知识库分享
牛客小白月赛71（A~F)
m0_61923501的博客
04-24 323
1,b-a为定值，那么可以尝试枚举b-a的所有质因子，假设某个质因子为p满足的c=p - (amodp),或当np > a时，c = np - a。假设a < b,gcd(a+c,b+c) > 1,根据题目样例说明，可以得知gcd(a+c,b-a),要是该值大于1。如果b-a=1,那么如何增加，也不能使该值gcd(a+c,1)大于1。分情况讨论，当gcd(a,b) > 1 直接输出 0。找是否存在"lov",loe",lve",ove"。当gcd(a,b) = 1时，a = b,输出1。
牛客小白月赛53【比赛记录】
weixin_53745698的博客
07-09 144
牛客小白月赛
牛客小白月赛62
Mango.
12-05 579
牛客小白月赛62——A-E
牛客小白月赛66
weixin_62528401的博客
02-11 785
牛客小白月赛66
牛客小白月赛57
weixin_51195184的博客
09-19 593
牛客小白月赛57
牛客小白月赛17-记录(附题解)
QuantAsk
09-14 617
正题 比赛链接:https://ac.nowcoder.com/acm/contest/1085#question 成绩 总结 除了那道积分数学其他还好 后面没有FFF题的题解 T1:小sun的假期T1:小sun的假期T1:小sun的假期 题目大意 长度为nnn的序列，mmm个区间，求最大的没有被任何区间覆盖的区间。 解题思路 我们将区间按照右端点从大到小枚举，我们每次求从这个右端点往右可...
牛客小白月赛22 【无I】
HungTeen的博客
02-27 352
题目链接：https://ac.nowcoder.com/acm/contest/4462 最近沉迷于写Minecraft的mod，好久没写题了，拿了结束好几天的这场练练手，好自闭哇~ AB都没写出来 只写了D - H 和J 共六题…状态极其不好 截至目前，除了没有I题工具人的题解，本套其他题均有~ 我的程序头 为了节省篇幅（代码复用嘛）233 #include<iostream> ...
牛客小白月赛18-记录
QuantAsk
10-26 373
正题 比赛链接:https://ac.nowcoder.com/acm/contest/1221 成绩 总结 好难，就拿了一些水题分 T1:Forsaken喜欢数论\texttt{T1:Forsaken喜欢数论}T1:Forsaken喜欢数论 题目大意 f(i)f(i)f(i)表示iii的最小质因子，求∑i=2nf(i)\sum_{i=2}^nf(i)∑i=2n​f(i) 解题思路 线性...
community:牛客论坛
03-29
community:牛客论坛
牛客的代码leetcode代码区别-niuke:牛客
06-30
牛客的代码leetcode代码区别 niuke
nowCoder:牛客Java精选面经爬取器
04-18
Java精选面经爬虫 requirement： selenium webDriver.exe
offer:牛客剑指offer
05-06
offer 牛客剑指offer
Cow Exhibition G的来龙去脉
m0_61150571的博客
05-15 457
从暴力方法，到初步方法，再优化最后得到正解，完整展现思考过程。
质数和约数
最新发布
2302_77099705的博客
05-21 699
最大公约数（Greatest Common Divisor）指两个或多个整数共有约数中最大的一个。也称最大公因数、最大公因子，a， b的最大公约数记为（a，b），同样的，a，b，c的最大 公约数记为（a，b，c），多个 整数的最大公约数也有同样的记号。求最大公约数有多种 方法，常见的有 质因数分解法、 短除法、 辗转相除法、 更相减损法。
算法刷题笔记 逆序对的数量（C++实现）
hanmo22357的博客
05-18 312
AcWing上的算法基础课题目 逆序对的数量 刷题笔记记录
P1135 奇怪的电梯
loongnoy的博客
05-17 279
大楼的每一层楼都可以停电梯，而且第 𝑖i 层楼（1≤𝑖≤𝑁1≤i≤N）上有一个数字 𝐾𝑖Ki​（0≤𝐾𝑖≤𝑁0≤Ki​≤N）。例如： 3,3,1,2,53,3,1,2,5 代表了 𝐾𝑖Ki​（𝐾1=3K1​=3，𝐾2=3K2​=3，……），从 11 楼开始。第一行为三个用空格隔开的正整数，表示 𝑁,𝐴,𝐵N,A,B（1≤𝑁≤2001≤N≤200，1≤𝐴,𝐵≤𝑁1≤A,B≤N）。对于 100%100% 的数据，1≤𝑁≤2001≤N≤200，1≤𝐴,𝐵≤𝑁1≤A,B≤N，0≤𝐾𝑖≤𝑁0≤Ki​≤N。
python 1024程序员节
10-22
今天是一年一度的1024程序员节，这是一个庆祝程序员的节日。无论你是哪个领域的程序员，都可以参与庆祝。而1024这个数字也有特殊的含义，它是2的10次方，也是存储单元的基数，例如1GB等于1024MB。此外，这个节日也是为了纪念计算机科学家图灵的生日。在这个节日里，许多公司和组织都会举办各种活动，例如技术分享、比赛、抽奖等等。同时，也有很多优惠和福利活动，例如打折、送礼品等等。如果你是Python程序员，可以参考引用中的《Python少儿趣味编程》这本书，它是一本适合少儿学习Python编程的趣味指南，语言通俗易懂，代码示例丰富，适合10岁以上的孩子学习，也适合家长和老师用作教材。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值