牛客小白月赛89（A,B,C,D,E,F）

已于 2024-03-24 22:43:04 修改
阅读量1.1k 收藏 28
点赞数 29
分类专栏： 牛客 文章标签： c++ 树上DP 动态规划
于 2024-03-24 22:39:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45809243/article/details/136983610
版权

比赛链接

官方视频讲解（个人觉得讲的还是不错的）

这把BC偏难，差点就不想做了在这里插入图片描述，对小白杀伤力比较大。后面的题还算正常点。

A 伊甸之花

思路：

发现如果这个序列中最大值不为 k k k，我们可以把序列所有数都加 1 1 1，这样所有数一定不会超出范围，也就得到了一种可行解。同理，若序列中最小值不为 1 1 1，就可以给序列所有数减 1 1 1。

但是如果序列最小值顶到了 1 1 1，最大值顶到了 k k k，那么序列就完全无法整体上下移动，也就无解。

code：

#include <iostream>
#include <cstdio>
using namespace std;
const int inf=1e9;

int n,m,minn=inf,maxx=-inf;

int main(){
	cin>>n>>m;
	for(int i=1,t;i<=n;i++){
		cin>>t;
		minn=min(minn,t);
		maxx=max(maxx,t);
	}
	if(minn==1 && maxx==m)puts("No");
	else puts("Yes");
	return 0;
}

B 显生之宙

思路：

手玩一下，其实不难发现操作的顺序是固定的：先操作当前剩余序列的最小的负数，给其他所有数加上这个负数，操作完负数后，正数加起来就是答案。

因为我们处理元素是从小到大，所以先排个序。最后一个数一定留着不操作，所以我们把正数都累加到 a n a_n an​ 上，最后的答案就是 a n a_n an​ 了。

但是这里元素值是在时刻变化的，而且处理负数的时候是区间操作。考虑我们设置一个累加变量，给后面加上的数我们先存放在这个变量里，到后面处理到某个元素的时候，再把影响附加到这个元素上。

或者你也可以直接上线段树。赛时调到红温差点就用了。

code：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long ll;
const int maxn=5e5+5;

ll T,n,a[maxn];

int main(){
	cin>>T;
	while(T--){
		cin>>n;
		for(int i=1,t;i<=n;i++)cin>>a[i];
		sort(a+1,a+n+1);
		
		ll add=0;
		for(int i=1;i<=n;i++){
			a[i]+=add;
			if(i==n){
				cout<<a[n]<<endl;
				break;
			}
			
			if(a[i]<0)add+=a[i];
			else a[n]+=a[i];
		}
		
	}
	return 0;
}

C 太阳之华

思路：

手玩一会其实会发现一个规律，就是如果某一方无法一次就决定胜局，那么这一方一定不会赢。

因为如果你一次操作后，若对方还有剩的格子，对方任选一个操作一下，这个格子周围就会出现一圈 “护盾”，你下次操作后只能剥离这个 “护盾”，而内部的格子不会受到影响。因此就会无限循环起来，这时候就会平局。

而进一步研究发现，除非蓝方赢在了起跑线上——地图上全是蓝格子。就只有红方有可能会赢，因为红方先手操作就会导致被操作的红格子周围出现 “护盾”，之后蓝方肯定不可能赢。所以我们暴力枚举红方操作的哪一个连通块，模拟一下涂色过程，看看红方能不能一局定胜负，不能就是平局。

不过检查图是否被涂满红色不能暴力来验证，最坏情况下每个连通块都验证一下，需要 O ( n 2 m 2 ) O(n^2m^2) O(n2m2)。考虑预先统计一下蓝色点的个数，之后涂色的时候记录一下涂了几个点，涂色结束后看一下个数对不对的上就行了，为了不重复可以用set存储被涂色的点。

code：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
using namespace std;
const int maxn=2005;

int T,n,m,cnt;
string mp[maxn];

int fx[]={1,-1,0,0},fy[]={0,0,1,-1};

bool vis[maxn][maxn];
set<pair<int,int> > S;
void dfs(int ux,int uy){
//	cout<<ux<<" "<<uy<<endl;
	vis[ux][uy]=true;
	for(int i=0,x,y;i<4;i++){
		x=ux+fx[i];
		y=uy+fy[i];
		if(x<1 || x>n || y<1 || y>m)continue;
		
		if(mp[x][y]=='#'){
			if(!vis[x][y]){
				dfs(x,y);
			}
		}
		else S.insert(make_pair(x,y));
	}
}
void solve(){
	if(cnt==n*m){
		puts("Blue");
		return;
	}
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			vis[i][j]=false;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			if(!vis[i][j] && mp[i][j]=='#'){
				S.clear();
				dfs(i,j);
				if(S.size()==cnt){
					puts("Red");
					return;
				}
			}
		}
	}
	puts("Draw");
}

int main(){
	cin>>T;
	while(T--){
		cin>>n>>m;
		cnt=0;
		for(int i=1;i<=n;i++){
			cin>>mp[i];
			for(auto x:mp[i])
				if(x=='.')
					cnt++;
			mp[i]=" "+mp[i];
		}
		solve();
	}
	return 0;
}

D 冥古之潮

思路：

题面虽然规定了选出点后的顺序必须从小到大，但是实际上这可以看作是一种选点的集合。因为选点集合和从小到大的排列是可以一一对应的。所以这个题其实就是在问：选择 k k k 个到点 x x x 的距离不同的结点的方案数。

我们预处理出到点 x x x 距离为 i i i 的点的个数 c o u n t [ i ] count[i] count[i]。然后就可以先枚举 k k k，对每个 k k k，去计算选择方案数。

不过这样复杂度是爆炸的，考虑如何优化。考虑对每种距离的点，我们可以选或不选，所以考虑动态规划。设 d p [ i ] [ j ] dp[i][j] dp[i][j] 为考虑了距离小于等于 i i i 的所有点，从中选取 j j j 个的方法数。状态转移方程也好想： d p [ i ] [ j ] = d p [ i − 1 ] [ j ] + c o u n t [ i ] ∗ d p [ i − 1 ] [ j ] dp[i][j]=dp[i-1][j]+count[i]*dp[i-1][j] dp[i][j]=dp[i−1][j]+count[i]∗dp[i−1][j]

实际上发现 d p i dp_{i} dpi​ 只和 d p i − 1 dp_{i-1} dpi−1​ 有关，所以第一维可以优化掉，类似于 01 01 01 背包的优化方式。

code：

#include <iostream>
#include <cstdio>
#include <queue>
#define pii pair<int,int>
using namespace std;
typedef long long ll;
const int maxn=1e6+5;
const int maxk=5e5+5;
const ll inf=1e9;
const ll linf=1e18;
const ll mod=1e9+7;

int n,m,q,x;

int head[maxn],cnt;
struct edge{
	int v,nxt;
}e[maxn<<1];
void add(int u,int v){
	e[++cnt].v=v;
	e[cnt].nxt=head[u];
	head[u]=cnt;
}

int d[maxn],count[maxk];
void dijkstra(){
	for(int i=1;i<=n;i++)d[i]=inf;
	queue<int> q;//假dij，因为边权都是1，直接bfs就行了
	q.push(x);
	d[x]=0;
	while(!q.empty()){
		int u=q.front();
		q.pop();
		for(int i=head[u],v;i;i=e[i].nxt){
			v=e[i].v;
			if(d[v]==inf){
				d[v]=d[u]+1;
				count[d[v]]++;
				q.push(v);
			}
		}
	}
}

ll dp[maxk];//dp[i] 选择i个数的方法数 

int main(){
	cin>>n>>m>>q>>x;
	for(int i=1,u,v;i<=m;i++){
		cin>>u>>v;
		add(u,v);
		add(v,u);
	}
	
	dijkstra();
	
	dp[0]=1;
	for(int i=1;i<=5000;i++){
		if(count[i]){
			for(int j=5000;j>=1;j--)
				dp[j]=(dp[j]+count[i]*dp[j-1])%mod;
		}
	}
	while(q--){
		int k;
		cin>>k;
		cout<<dp[k]<<endl;
	}
	
	return 0;
}

其实还有别的理解方式，比如生成函数，详细讲解可以看这个大佬的。

多项式某一项的系数就表示方法数，指数表示选择个数。比如选择 k k k 个点的方法数就是 x k x^k xk 的系数。

这个题的生成函数其实就是 ∏ i = 1 5000 ( 1 + c o u n t i ∗ x 1 ) \prod_{i=1}^{5000}(1+count_i*x^{1}) i=1∏5000​(1+counti​∗x1)上面的 d p dp dp 递推过程其实相当于在算这个式子的展开式。

E 神性之陨

思路：

发现一个竖条旁边接另一个竖条的话，两个相邻的竖条只能有一个格子是相邻的，这样在前面竖条走到后面竖条的路径一定是唯一的。否则在这上面就会出现多条路径。

因此后一个竖条的上端点要接在前一个竖条的下端点，或者后一个竖条的下端点要接在前一个竖条的上端点。不过有个特殊情况就是如果后一个竖条的宽度就是 1 1 1 的话，那么它放在前一个竖条的哪里都可以。

一个比较明显的想法就是保存第 i i i 列所有可以放竖条的位置，然后枚举每个可能的情况，算出第 i + 1 i+1 i+1 列的情况，一直算到最后一列即可。代码如下：

#include <iostream>
#include <cstdio>
#include <set>
using namespace std;
const int maxn=5005;

int T,n,m,a[maxn];

int main(){
	cin>>T;
	while(T--){
		cin>>n>>m;
		for(int i=1;i<=m;i++)cin>>a[i];
		
		set<int> S,t;
		for(int i=1;i<=n;i++)S.insert(i);
		for(int i=2,l,r;i<=m;i++){
			t.clear();
			if(a[i]==1){
				int tl=0,l,r;
				for(auto x:S){
					l=x;
					r=x+a[i-1]-1;
					for(int j=max(tl,l);j<=r;j++)t.insert(j);
					tl=r+1;
				}
			}
			else {
				for(auto x:S){
					l=x;
					r=x+a[i-1]-1;
					if(l-a[i]+1>=1)t.insert(l-a[i]+1);
					if(r+a[i]-1<=n)t.insert(r);
				}
			}
			
			S=t;
		}
		
		cout<<S.size()<<endl;
	}
	return 0;
}

结果T了， n ∗ m ∗ l o g m n*m*logm n∗m∗logm 会被卡。考虑到可以用桶的思想来存储，我们用 v i s [ i ] [ j ] vis[i][j] vis[i][j] 表示第 i i i 行第 j j j 列是否可以作为第 j j j 列竖条的上端点。我们用第 j − 1 j-1 j−1 列的竖条可能在的位置的信息就可以算出第 j j j 列的信息，这样就可以优化掉一个 l o g log log。

code：

实际上 v i s vis vis 可以再加一维，变成 v i s [ i ] [ j ] [ 0 / 1 ] vis[i][j][0/1] vis[i][j][0/1] 表示第 i i i 行第 j j j 列是否可以作为第 j j j 列竖条的 上/下 端点，递推的时候可能会比较好推。

#include <iostream>
#include <cstdio>
#include <set>
using namespace std;
const int maxn=5005;

int T,n,m,a[maxn];
bool vis[maxn][maxn];

int main(){
	cin>>T;
	while(T--){
		cin>>n>>m;
		for(int i=1;i<=n;i++)
			for(int j=1;j<=m;j++)
				vis[i][j]=false;
		for(int i=1;i<=m;i++)cin>>a[i];
		
		for(int i=1;i<=n;i++)vis[i][1]=true;
		for(int col=2,l,r;col<=m;col++){
			if(a[col]==1){
				for(int l,r,x=0,i=1;i<=n;i++){
					if(!vis[i][col-1])continue;
					l=i;
					r=i+a[col-1]-1;
					for(int j=max(l,x);j<=r;j++)vis[j][col]=true;
					x=r+1;
				}
			}
			else {
				for(int i=1;i<=n;i++){
					if(!vis[i][col-1])continue;
					l=i;
					r=i+a[col-1]-1;
					if(l-a[col]+1>=1)vis[l-a[col]+1][col]=true;
					if(r+a[col]-1<=n)vis[r][col]=true;
				}
			}
		}
		
		int ans=0;
		for(int i=1;i<=n;i++)ans+=vis[i][m];
		cout<<ans<<endl;
	}
	return 0;
}

F 无垢之土

思路：

考虑树上答案的两个生物怎么相遇：应该是走树上的路径然后相遇，这个路径最短就是一个点先到它们的最近公共祖先（LCA，Least Common Ancestor），再到另一个点。

一对生物想要尽可能快地相遇，它们一定是这样跑：某个生物从一个点出生，并沿着这个最短路径向另一边跑，另一个点上的生物同理，然后两个生物在路上的某个位置相遇了。而这个用时我们可以在它们的最近公共祖先上算出来，也就是这两个生物一定是先后到达这个祖先的，先到达的生物向另一个生物所在的子树跑，于是两个生物总用时的一半就是答案用时。

因为我们只需要知道最快相遇的那对生物，所以我们一个祖先就不需要存储每个子树的点到这个根的用时，只用知道每个子树最快到这个根的时间即可。我们设 d p [ i ] dp[i] dp[i] 表示 i i i 的子树的点到达根 i i i 的最快的生物的用时。

我们保存一下这个点出生的生物的时间，每个子树跑过来的最快生物的时间（子树的 d p dp dp 值），从中选出时间最小和次小的生物，它们的平均值就是以这个点为 L C A LCA LCA 的最快相遇时间。然后 d p [ i ] dp[i] dp[i] 就等于其中的最小值。

不过这样是有 b u g bug bug 的，有的生物用时比较长并不是离 L C A LCA LCA 远，而是出生晚，这样一个生物跑到另一边即使跑到了另一个生物的出生地，也无法相遇，只能等待，直接取平均值就会出错，hack数据：

3 2
1 2
1 3
2 1
3 10

正确答案是：20
不考虑出生时间答案是：13

发现一对生物相遇的最快用时是 用时 = m a x { 通过 L C A 跑出的最短时间 , 生物 1 的出生时间，生物 2 的出生时间 } 用时=max\{通过 LCA 跑出的最短时间,生物1的出生时间，生物2的出生时间\} 用时=max{通过LCA跑出的最短时间,生物1的出生时间，生物2的出生时间}
这样验证一个时间是比较方便的（也就是验证在这个时刻上有没有生物已经相遇了）。首先需要这个时间能保证两个生物都能出生，在此基础上 通过 L C A LCA LCA 跑出的最短时间 小于等于这个时间即可。这样就能验证这两个生物一定是在验证时间之前就相遇了。

所以考虑二分答案，当出生时间比要验证的答案要晚的话，就不再将他出生在点上，这样就能保证两个生物在这个时间点上都出生了。如果跑出来的最短时间小于等于这个时刻，就说明在这个时刻上有生物已经相遇了。

不过中间算时间时有可能会出现 ∼ . 5 \sim.5 ∼.5 的情况，搞浮点魔法也不好搞。所以我们一开始就对所有跟时间有关的东西都乘上 2 2 2：出生时间乘以 2 2 2，从子节点移动到父节点的用时变成 2 2 2 即可。

code：

#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;
const int maxn=1e5+5;
const int inf=1e9;

int n,m;
vector<int> tm[maxn];

int head[maxn],counter;
struct edge{
	int v,nxt;
}e[maxn<<1];
void add(int u,int v){
	e[++counter].v=v;
	e[counter].nxt=head[u];
	head[u]=counter;
}

int dp[maxn];//子树点最小时间到达i的时间 
int ans;
void dfs(int u,int fa,int bd){
	int m1=inf,m2=inf;
	for(int i=head[u],v;i;i=e[i].nxt){
		v=e[i].v;
		if(v==fa)continue;
		
		dfs(v,u,bd);
		m2=min(m2,dp[v]+2);
		if(m1>m2)swap(m1,m2);
	}
	
	for(auto x:tm[u]){
		if(x>bd)continue;
		 
		m2=min(m2,x);
		if(m1>m2)swap(m1,m2);
	}
	dp[u]=m1;
	ans=min(ans,(m1+m2)/2);
}
bool check(int bd){
	ans=inf;
	dfs(1,-1,bd);
	return ans<=bd;
}

int main(){
	cin>>n>>m;
	for(int i=1,u,v;i<n;i++){
		cin>>u>>v;
		add(u,v);
		add(v,u);
	}
	for(int i=1,nd,t;i<=m;i++){
		cin>>nd>>t;
		tm[nd].push_back(2*t);
	}
	
	int l=0,r=1e7,mid;
	while(l<r){
		mid=(l+r)>>1;
		for(int i=1;i<=n;i++)dp[i]=inf;
		if(check(mid))r=mid;
		else l=mid+1;
	}
	cout<<l<<endl;
	return 0;
}
邪神与厨二病
关注
  • 29
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
牛客小白赛实用知识库分享
09-19
牛客小白赛实用知识库分享
牛客的代码leetcode代码区别-NiuKeXiaoBaiCode:牛科小白测试代码
06-30
牛客的代码leetcode代码区别 NiuKeXiaoBaiCode So this repository was established for store the code of NiuKe XiaoBai tests
牛客小白月赛90（A,B,C,D,E,F）
qq_45809243的博客
04-12 1093
牛客小白月赛90（A,B,C,D,E,F）
牛客小白月赛87（A,B,C,D,E,F,G）
qq_45809243的博客
02-17 812
牛客小白月赛87（A,B,C,D,E,F,G）
牛客小白月赛84
tesla_shy的博客
01-01 1772
输入一行包含四个整数 n,m,X,Y(1≤m≤n≤106,0≤X≤m,0≤Y≤109)n,m,X,Y( 1 \leq m \leq n \leq 10^6,0 \leq X \leq m,0 \leq Y \leq 10^9)n,m,X,Y(1≤m≤n≤106,0≤X≤m,0≤Y≤109)。第一行输入两个整数 n,k(1≤n≤2⋅105,0≤k≤109)n,k (1 \leq n \leq 2 · 10^5,0 \leq k \leq 10^9 )n,k(1≤n≤2⋅105,0≤k≤109)。
[牛客复盘] 牛客小白月赛70 20230407
liuliangcan的博客
04-11 566
第一次打小白月赛，据说比较简单，但还是有两道没做出来。A 模拟。B 模拟。D 前缀和+哈希。E 博弈 打表/贪心。F 树上背包/有依赖的背包，注意卡常。
牛客小白月赛68【A-E】
gfyy_bkj的博客
03-10 842
A.Tokitsukaze and New Operation【模拟】 B.Tokitsukaze and Order Food Delivery【模拟、特判】 C.Tokitsukaze and Average of Substring【暴力、前缀】 D.Tokitsukaze and Development Task【记忆化搜索】 E.Tokitsukaze and Colorful Chessboard【预处理，二分】
牛客小白月赛53 A-E
weixin_62848089的博客
07-30 185
目录 A-Raining B-Kissing C.Missing D.Breezing E.calling F题还没做，等会补 A-Raining 原题链接<<看原题点这里 思路：简单 略 #include <bits/stdc++.h> using namespace std; int main() { int a,b,c,d,x,ans; ans=0; scanf("%d%d%d%d",&a,&b,&a...
牛客小白月赛1 题解
keguaiguai的博客
11-24 583
牛客小白月赛1 个人补题题解
牛客小白月赛72
m0_62784756的博客
05-23 211
思路有了码不上来？？？离大谱，得加训咯 ，编码能力有点差难蚌一开始以为是看数组是不是从小到大排序的，结果挂了几次，还是要认真看看题，下次一定。
牛客小白月赛25
扣脚老骚
09-11 258
牛客小白月赛25 A AOE还是单体？ #include <bits/stdc++.h> #define int ll typedef long long ll; const int INF = 0x3f3f3f3f3f; const int mod = 1e9 + 7; const int maxn = 2e5 + 10; const int N = 50; using namespace std; int a[maxn]; void solve() { int n,x,sum=
牛客校招C++宝典.rar
03-17
牛客网校招C++面试宝典, 包含计算机网络, 算法, C++面试基础, 数据库知识等 关注本人后私聊免费领取
关于牛客刷题总结全部汇总
02-21
关于牛客刷题总结全部汇总 本资源摘要信息主要讲述了 Java 语言的基本概念、设计模式、MVC 模式、数学函数、重载和重写的区别、多态、数组、静态成员和方法、事务属性等知识点。 一、Java 基本概念 1. Java 源...
牛客AI模拟面试2测开岗
01-07
简单解释一下黑盒与白盒测试方法 黑盒测试： 黑盒测试也称功能测试或数据驱动测试，它是在已知产品所应具有的功能，通过测试来检测每个功能是否都能正常使用，在测试时，把程序看作一个不能打开的黑盆子，在完全不...
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 981
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 134
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 661
LeetCode 算法：轮转数组c++
手搓顺序表（C语言）
最新发布
m0_62646213的博客
06-12 1094
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
牛客 a卷2022q4 华为
05-02
在牛客 a卷2022年第四季度的华为题目中，要求考生设计一种高效的数据结构，能够支持以下几种操作： 1. 添加一个元素 2. 删除一个元素 3. 查找是否存在某个元素 4. 返回元素的总数 该数据结构要求满足空间复杂度...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值