【牛客】2024暑期牛客多校3 补题记录

于 2024-07-23 22:12:12 发布
阅读量432 收藏 11
点赞数 10
分类专栏： 2024暑假训练记录 牛客 题解 文章标签： 算法 c++ 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dhxbshbdjzxy/article/details/140644760
版权
  • 明天应该会补完 E 和 H

文章目录

A - Bridging the Gap 2（贪心）

  • 计算总共需要的次数，除去最后一次（因为不需要回对岸），前面需要往返的次数是 c n t = ⌈ n − R R − L ⌉ cnt=\lceil \frac{n-R}{R-L}\rceil cnt=⌈R−Ln−R​⌉，所以需要多来回的人数是 c n t × L cnt\times L cnt×L
  • 每个人自己过河需要 1 1 1 的体力，那每个人可以多往返的次数就是 h i − 1 2 \frac{h_i-1}{2} 2hi​−1​，这个值需要和 c n t cnt cnt 取最小值（因为一个人在一次往返中最多贡献 1 1 1）
  • 可以往返的次数累加起来大于 c n t × L cnt\times L cnt×L 的话就 Y e s Yes Yes，否则 N o No No
#include <bits/stdc++.h>

using namespace std;

#define int long long
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 1e6 + 10;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	int n, l, r;
	cin >> n >> l >> r;
	vector<int> a(1);
	int cnt = (n - r) / (r - l);
	if ((n - r) % (r - l) != 0) cnt ++ ;
	for (int i = 0; i < n; i ++ )
	{
		int x; cin >> x;
		if ((x - 1) / 2 > 0) a.push_back(min(cnt, (x - 1) / 2));
	}
	sort(a.begin() + 1, a.end());

	int m = a.size() - 1;
	vector<int> pre(m + 1);
	for (int i = 1; i <= m; i ++ ) pre[i] = pre[i - 1] + a[i];

	if (cnt == 0) cout << "YES\n";
	else
	{
		if (pre[m] < cnt * l) cout << "NO\n";
		else cout << "YES\n";
	}
}

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

	int t = 1;
	// cin >> t;
	while (t--)
	{
		solve();
	}
}

B - Crash Test（数学）

  • 不知道怎么证明的 队友看了一眼就秒了
#include<iostream>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<vector>
#include<map>
#include<algorithm>
#include<queue>
#include <iomanip>
#include<random>

using namespace std;
typedef long long LL;
typedef __int128 i128;
typedef unsigned long long ULL;
typedef double db;
#define int long long
const int N = 110;
int n , h[N] , d;

void Asuka()
{
	cin >> n >> d;
	for(int i = 1 ; i <= n ; i ++)
		cin >> h[i];
	int g = h[1];
	for(int i = 2 ; i <= n ; i ++){
		g = __gcd(g , h[i]);
	}
	cout << min(d % g , g - (d % g))<< '\n';
	return;
}	

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);

	int t = 1;
	// cin >> t;
	while(t --){
		Asuka();
	}
	return 0;
}

D - Dominoes!（构造）

  • 首先记录每个数字出现的次数，大于 n − 1 n-1 n−1 次就直接 N O NO NO
  • 之后先放 x , y x,y x,y 一样的牌，贪心尽可能放数量多的，总之实现起来有一定难度，但是赛时没有往下想真的太可惜了
#include <bits/stdc++.h>

using namespace std;

#define int long long
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 1e6 + 10;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	int n; cin >> n;
	map<int, int> cnt, mp;
	priority_queue<PII> same;
	vector<PII> ed;
	for (int i = 1; i <= n; i ++ )
	{
		int a, b;
		cin >> a >> b;
		if (a == b) mp[a] ++ ;
		else ed.push_back({a, b});
		cnt[a] ++, cnt[b] ++ ;
	}
	for (auto t : cnt)
	{
		if (t.second > n + 1)
		{
			cout << "NO\n";
			return;
		}
	}
	cout << "YES\n";
	for (auto t : mp) same.push({t.second, t.first});
	vector<PII> ans(1);
	int lst = -1;
	auto work = [&](int num, int cnt)
	{
		vector<PII> ed1, ed2;
		for (auto t : ed)
		{
			if (t.first == num || t.second == num) ed2.push_back(t);
			else ed1.push_back(t);
		}
		int idx = 0;
		while (cnt -- )
		{
			ans.push_back(ed1[idx ++ ]);
			ans.push_back({num, num});
		}
		int lst = num;
		while (idx < ed1.size())
		{
			int a = ed1[idx].first, b = ed1[idx].second;
			if (a == lst) swap(a, b);
			ans.push_back({a, b});
			lst = b;
			idx ++;
		}
		idx = 0;
		while (idx < ed2.size())
		{
			int a = ed2[idx].first, b = ed2[idx].second;
			if (a == lst) swap(a, b);
			ans.push_back({a, b});
			lst = b;
			idx ++ ;
		}
	};
	while (same.size())
	{
		auto t1 = same.top();
		same.pop();
		
		int cnt1 = t1.first, num1 = t1.second;
		if (num1 != lst)
		{
			ans.push_back({num1, num1});
			if (cnt1 > 1) same.push({cnt1 - 1, num1});
			lst = num1;
		}
		else
		{
			if (same.size() == 0)
			{
				work(num1, cnt1);
				for (int i = 1; i <= n; i ++ ) cout << ans[i].first << ' ' << ans[i].second << '\n';
				return;
			}
			else
			{
				auto t2 = same.top();
				same.pop();
				same.push(t1);
				int cnt2 = t2.first, num2 = t2.second;
				ans.push_back({num2, num2});
				if (cnt2 > 1) same.push({cnt2 - 1, num2});
				lst = num2;
			}
		}
	}
	int idx = 0;
	while (idx < ed.size())
	{
		int a = ed[idx].first, b = ed[idx].second;
		if (a == lst) swap(a, b);
		ans.push_back({a, b});
		idx ++ ;
		lst = b;
	}
	for (int i = 1; i <= n; i ++ ) cout << ans[i].first << ' ' << ans[i].second << '\n';
}

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

	int t = 1;
	// cin >> t;
	while (t--)
	{
		solve();
	}
}

J - Rigged Games（倍增）

  • 对于每个位置求出从该位置开始进行一小局之后的胜负，以及下一步从哪个位置开始执行
  • 用倍增实现， n x t [ i ] [ j ] nxt[i][j] nxt[i][j] 表示从 i i i 开始进行 2 j 2^j 2j 轮到达的位置， r e s [ i ] [ j ] res[i][j] res[i][j] 表示从 i i i 开始进行 2 j 2^j 2j 轮 a a a 和 b b b 分别的得分
#include <bits/stdc++.h>

using namespace std;

#define int long long
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 1e6 + 10;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	int n, a, b;
	string s;
	cin >> n >> a >> b >> s;
	vector<vector<int>> nxt(n, vector<int>(21));
	vector<vector<PII>> res(n, vector<PII>(21));
	for (int i = 0; i < n; i++) nxt[i][0] = (i + 1) % n;
	for (int i = 0; i < n; i++)
	{
		if (s[i] == '1') res[i][0] = {1, 0};
		else res[i][0] = {0, 1};
	}

	auto work = [&](int u)
	{
		for (int i = 1; i < 20; i++)
		{
			for (int j = 0; j < n; j++)
			{
				nxt[j][i] = nxt[nxt[j][i - 1]][i - 1];
				res[j][i].first = res[j][i - 1].first + res[nxt[j][i - 1]][i - 1].first;
				res[j][i].second = res[j][i - 1].second + res[nxt[j][i - 1]][i - 1].second;
			}
		}
		vector<int> nnxt(n), nres(n);
		for (int i = 0; i < n; i++)
		{
			int now = i, as = 0, bs = 0;
			for (int j = 19; j >= 0; j--)
			{
				if (as + res[now][j].first < u && bs + res[now][j].second < u)
					as += res[now][j].first, bs += res[now][j].second, now = nxt[now][j];
			}
			nnxt[i] = nxt[now][0], nres[i] = res[now][0].first;
		}
		for (int i = 0; i < n; i++)
		{
			if (nres[i]) res[i][0] = {1, 0};
			else res[i][0] = {0, 1};
			nxt[i][0] = nnxt[i];
		}
	};

	work(a);
	work(b);
	for (int i = 0; i < n; i++) cout << res[i][0].first;
	cout << '\n';
}

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

	int t = 1;
	// cin >> t;
	while (t--)
	{
		solve();
	}
}

L - Sudoku and Minesweeper（签到）

  • 保留一个处在中间的 8 8 8 即可
#include <bits/stdc++.h>

using namespace std;

#define int long long
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 1e6 + 10;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	vector<string> g(10);
	for (int i = 1; i <= 9; i ++ )
	{
		cin >> g[i];
		g[i] = " "  + g[i];
	}
	vector<vector<char>> ans(10, vector<char>(10));
	for (int i = 1; i <= 9; i ++ )
	{
		for (int j = 1; j <= 9; j ++ )
		{
			ans[i][j] = '*';
		}
	}
	bool flag = false;
	for (int i = 2; i <= 8; i ++ )
	{
		for (int j = 2; j <= 8; j ++ )
		{
			if (g[i][j] == '8')
			{
				ans[i][j] = '8';
				flag = true;
				break;
			}
		}
		if (flag) break;
	}
	for (int i = 1; i <= 9; i ++ )
	{
		for (int j = 1; j <= 9; j ++ )
		{
			cout << ans[i][j];
		}
		cout << '\n';
	}
}

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

	int t = 1;
	// cin >> t;
	while (t--)
	{
		solve();
	}
}
Texcavator
关注
  • 10
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
2024牛客暑期训练营第一场
07-22
2024牛客暑期训练营第一场
2020牛客暑期多校集训营第二场题解.pdf
01-20
2020牛客暑期多校集训营第二场题解.pdf
2024牛客暑期多校训练营1 A题 解题思路
华鑫的专栏
07-17 605
本人非目标院校211硕士，专业非科班，2年经验，c++方向，机考370分，技术一二面已过，进入主管面。期间被拒了几次，有点灰心，但导师是认可的。看新闻日本大学生就业率屡创新高，这里既有日本市场经济的繁荣结果，也存在日本少子高龄化的社会问题，而我。本人双非非科班准大四，C++自学的，简历投晚了找不到实习，目前处在焦虑之中，不知道还要不要坚持学下去。有想来多多的么，最近组内扩张，hc非常多，这段时间窗口期大佬们抓紧机会，各岗位都有，社招校招都有需求。找不到工作了，求大佬救救，听劝，投了几百个简历都没有面试。
2024牛客暑期多校1（新手题）
2301_79902706的博客
07-18 987
有两场World Finals同时举办，每场都有若干出线队伍，两场出线名单可能有重复的队伍，而一个队伍只能选择其中的一场参加，然后每场比赛的每支队伍都有一个预测成绩（过题数+ 罚时）lzr010506在两场World Finals 都出线了，他想知道如果所有队伍的最终成绩就是预测成绩，并且可以任意分配两场都出线了队伍的比赛场次的选择，他们队最高可能的排名是多少（1 ≤ number of teams ≤ 10^5）公式：C(k,n)×2^((m-1)(n-k))×(2^k-1)^(m-1)
2024牛客暑期多校训练营1 B题
hhhh3356的博客
07-17 674
题面：给定n,m,q,构造一个长度为n的数组，其中数组中的每个元素大小均小于，若该数组的中，所有元素按位与(AND)之后的结果为1，则该数组合法。求有多少种合法数组例如n=3,m=3,q=100000[1,0,3]是一个合法数组，因为子序列[1]的AND结果为1[5,3,0]是一个合法数组，因为子序列[5,3]的AND结果为1。
2021牛客暑期多校训练营3补题
TIT_0的博客
08-11 136
2021牛客暑期多校训练营3：B题（Black and white） 题目原文 Goodeat has a white chessboard with n rows and m columns. Each grid (i, j) has a weight c(i, j). At any time, the grid (i, j) can be dyed black at the cost of c(i, j). Goodeat has a special talent. For the four inte
2024牛客暑假多校训练营2——两道入门DP（C题，I题）选讲
华鑫的专栏
07-18 542
你合入的代码越多，可能会带入的bug也就越多，带入的bug越多，你要解bug合入的代码也就越多。做成事儿的道、法、术～1、首先，做一件事儿时，要去灵魂拷问自己，为什么要做，发心不对，动作变形，没法。终于明白了递归和动态规划的区别，不愧是群众严选，把通过率50以上的题都做完了，继续加油，简单题信心很。#软件开发笔面经#6.1北京时间上午10点一面简单自我介绍，项目介绍----------------方法：递归+回溯 n对括号的生成就是n个左括号和n个右括号组成的合法排列，在使用了一个。
2024牛客暑期多校训练营1 A题
hhhh3356的博客
07-16 157
若该数组的某一个子序列中，所有元素按位与(AND)之后的结果为1，则该数组合法。题面：给定n,m,q,构造一个长度为n的数组，其中数组中的每个元素大小均小于。[5,3,0]是一个合法数组，因为子序列[5,3]的AND结果为1。[1,0,3]是一个合法数组，因为子序列[1]的AND结果为1。那么某位至少有一个0，也就是不能全1，也就是该位可以填的数有。找到子序列中，恰好有i个元素相与为1，多一个都会出错。个，而总共有(m-1)位这样的位置，总共可以填的数量为。例如n=3,m=3,q=100000。
牛客2021暑假多校联赛第一场补题
weixin_51060919的博客
07-18 407
A题： 题意： 两人博弈，每次一个人从一堆中拿 k 个，同时从另一堆拿 k * s(s >= 0) 个，问谁先不能拿。 10000 组数据，N <= 5000 解题思路：暴力模拟 推理得：A一次能直接拿完A赢 拿不完B赢 代码： #include <iostream> #include <cstdio> #include <cstring> #include <cmath> #include <cstring> #.
暑假杭电牛客多校赛补题地点
Slime
07-25 527
杭电第一场 A.Blank B.Operation 线性基高斯消元 C.Milk D.Vacation 思维 E.Path 最大流最小割 F.Typewriter G.Meteor H.Desert I.String 贪心 J.Kingdom K.Function L.Sequence M.Code 凸包 标程及数据： 链接：https://pan.baidu.com/s/1UcBGav7PaOU...
2021牛客暑期多校训练营3
qq_35975367的博客
07-25 179
2021牛客暑期多校训练营3 题号 题目 知识点 A Guess and lies B Black and white C Minimum grid D Count E Math F 24dian G Yu Ling(Ling YueZheng) and Colorful Tree H Ling Qiu, Luna and Triple Backpack I Kuriyama Mirai and Exclusive Or J Counti
2022牛客暑期多校训练营1(总结+补题)
m0_51028279的博客
07-18 1159
，做完签到后继续找签到题花了一些时间，看到A过题数逐渐增加，就去看A，读了好一会题跟队友讨论了十几二十分钟一发过了A，然后就是D，看D时由于我在队友读题读到一半的时候向队友问题意，导致我们在没读完题的情况下就开始做假题，浪费了差不多一个小时的时间，还wa了2发。，则两建筑物连通，无需电线，现要求从发电站通过变电塔向建筑物通电（电必须从发电站经过变电塔到达建筑物），若变电塔如果在发电站和建筑物的范围内，则可以不需要导线连接，反之则需要用导线连接如果变电塔需要连接发电站范围之外的变电塔，则也需要用导线连接。..
2018牛客暑期多校第二场题解
09-28
2018牛客暑期多校第二场题解
2020牛客暑期多校第一场讲课笔记版本题解1
08-03
3. 有向图的生成树计数(Domino Flip Graphs): 提到了Domino翻转图中的距离计算，可以通过"Lagrange Duality"证明，答案是b的转置乘以矩阵A的逆再乘以b。这在图论和网络流问题中常见。 4. 二次型(Quadratic Form): ...
【18】输出字符菱形
2301_78786609的博客
07-19 410
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 356
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 587
AtCoder Beginner Contest 363 ABCDE
算法题目整合5
最新发布
qq_62571233的博客
07-23 661
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Texcavator

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值