2018年全国多校算法寒假训练营练习比赛（第一场）

最新推荐文章于 2018-08-05 19:16:13 发布
最新推荐文章于 2018-08-05 19:16:13 发布
阅读量472 收藏
点赞数
分类专栏： 比赛总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kele52he/article/details/79130013
版权

这是一场拼手速和细节的比赛，难题并不多，我做的七道题里没有一道涉及算法。我虽然做的有点慢，但是七道题全部1A，其中J题的规律想半天想不出来，感谢Winzard大神出手相助告诉了我hhhhh，最后拿了第26名，还算可以吧。


A题：大吉大利，今晚吃鸡——枪械篇

首先把n把枪的属性全部记录下来，然后对m个配件进行处理，处理出每一类配件的最高属性值，代回n把枪中，再对n把枪遍历一遍，就处理出了威力最高的枪，也就是答案。

#include <iostream>  
#include <cstdio>  
#include <cstring>  
#include <string>  
#include <cstdlib>  
#include <cmath>  
#include <vector>  
#include <queue>  
#include <iterator>  
#include <map>  
#include <algorithm>  
#include <set>  
#include <functional>  
#include <time.h>  
#define lson rt<<1  
#define rson rt<<1|1  
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
const int INF = 1e9 + 5;
const int MAXN = 100005;
const LL MOD = 1000000007;
const double eps = 1e-8;
const double PI = acos(-1.0);
LL gcd(LL a, LL b) { return b == 0 ? a : gcd(b, a%b); }
LL ppow(LL a, LL b) { LL res = 1; for (int i = 1; i <= b; i++)   res *= a; return res; }
LL quick_mod(LL a, LL b, LL c) { LL ans = 1; while (b) { if (b % 2 == 1)ans = (ans*a) % c; b /= 2; a = (a*a) % c; }return ans; }

struct gun
{
	double power;
	int num;
	int add[1005];
};

gun G[1005];
double add[1005];

int main()
{
	double res,ans,b;
	int q;
	int n, m;
	while (scanf("%d%d", &n, &m) != EOF)
	{
		ans = 0;
		memset(add, 0, sizeof add);
		for (int i = 1; i <= n; i++)
		{
			scanf("%lf", &G[i].power);
			scanf("%d", &G[i].num);
			for (int j = 1; j <= G[i].num; j++)
				scanf("%d", &G[i].add[j]);
		}
		for (int i = 1; i <= m; i++)
		{
			scanf("%d%lf", &q, &b);
			if (add[q] - b < -eps)
				add[q] = b;
		}
		for (int i = 1; i <= n; i++)
		{
			res = 1;
			for (int j = 1; j <= G[i].num; j++)
				res += add[G[i].add[j]];
			res *= G[i].power;
			if (res - ans > eps)
				ans = res;
		}
		printf("%.4lf\n", ans);
	}
}
B题： 最强的决斗者一切都是必然的！

首先按顺序处理出每一次连锁的范围，对于样例来说，一共有三次连锁，分别是1~4,5~6,7~9。对于每一次连锁，我们从后往前循环分析，因为后连锁的先发动，如果是type1就直接ans+=x，如果是type2就ans+=x*p，如果是type3我们就可以直接跳出该连锁，处理下一个连锁，如果是type4我们就跳过一张卡。最后处理完所有连锁后，ans就是总伤害。

#include <iostream>  
#include <cstdio>  
#include <cstring>  
#include <string>  
#include <cstdlib>  
#include <cmath>  
#include <vector>  
#include <queue>  
#include <iterator>  
#include <map>  
#include <algorithm>  
#include <set>  
#include <functional>  
#include <time.h>  
#define lson rt<<1  
#define rson rt<<1|1  
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
const int INF = 1e9 + 5;
const int MAXN = 100005;
const LL MOD = 1000000007;
const double eps = 1e-8;
const double PI = acos(-1.0);
LL gcd(LL a, LL b) { return b == 0 ? a : gcd(b, a%b); }
LL ppow(LL a, LL b) { LL res = 1; for (int i = 1; i <= b; i++)   res *= a; return res; }
LL quick_mod(LL a, LL b, LL c) { LL ans = 1; while (b) { if (b % 2 == 1)ans = (ans*a) % c; b /= 2; a = (a*a) % c; }return ans; }

struct card
{
	int speed;
	int type;
	int x;
};

LL ans;
card C[1005];
int l, r;

void solve()
{
	for (int i = r; i >= l; i--)
		if (C[i].type == 1)
			ans += C[i].x;
		else if (C[i].type == 2)
			ans += C[i].x*(i - l + 1);
		else if (C[i].type == 3)
			return;
		else if (C[i].type == 4)
			i--;
}

int main()
{
	int n, p;
	while (scanf("%d", &n) != EOF)
	{
		ans = 0;
		l = 1;
		r = 1;
		for (int i = 1; i <= n; i++)
		{
			scanf("%d%d", &C[i].speed, &C[i].type);
			if (C[i].type == 1 || C[i].type == 2)
				scanf("%d", &C[i].x);
		}
		while (l <= n&&r <= n)
		{
			p = C[l].speed;
			while (r + 1 <= n&&C[r + 1].speed >= p)
				p = C[++r].speed;
			solve();
			l = r + 1;
			r = l;
		}
		printf("%lld\n", ans);
	}
}
F题： 大吉大利，今晚吃鸡——跑毒篇

这道题数据范围很小，我们直接用最暴力的模拟即可，也就是每一秒每一秒的模拟，每一秒都判断一下下一回合不用急救包会不会死，如果会死就用急救包，否则就前进，如果要用急救包的时候再判断一下当前状态不用急救包能否走到终点和急救包是否够用，反正就是题目是什么要求我们就怎么写。

#include <iostream>  
#include <cstdio>  
#include <cstring>  
#include <string>  
#include <cstdlib>  
#include <cmath>  
#include <vector>  
#include <queue>  
#include <iterator>  
#include <map>  
#include <algorithm>  
#include <set>  
#include <functional>  
#include <time.h>  
#define lson rt<<1  
#define rson rt<<1|1  
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
const int INF = 1e9 + 5;
const int MAXN = 100005;
const LL MOD = 1000000007;
const double eps = 1e-8;
const double PI = acos(-1.0);
LL gcd(LL a, LL b) { return b == 0 ? a : gcd(b, a%b); }
LL ppow(LL a, LL b) { LL res = 1; for (int i = 1; i <= b; i++)   res *= a; return res; }
LL quick_mod(LL a, LL b, LL c) { LL ans = 1; while (b) { if (b % 2 == 1)ans = (ans*a) % c; b /= 2; a = (a*a) % c; }return ans; }

int a, b, c;
int hp;

bool solve()
{
	hp = 100;
	for (int t = 1; t <= b; t++)
	{
		hp -= a;
		if (hp - a * 7 <= 0)
			if (hp - a*(b - t - 1) > 0)
				return true;
			else
				if (c > 0 && a * 6 < 100)
				{
					hp = 80; c--;
				}
				else 
					return false;
	}
	return true;
}

int main()
{
	bool ans;
	int T;
	scanf("%d", &T);
	while (T--)
	{
		scanf("%d%d%d", &a, &b, &c);
		ans = solve();
		if (ans)
			printf("YES\n");
		else
			printf("NO\n");
	}
}
G题： 圆圈

一道标准的递归图形输出问题，这类问题有通解：递归图形输出问题通解

#include <iostream>  
#include <cstdio>  
#include <cstring>  
#include <string>  
#include <cstdlib>  
#include <cmath>  
#include <vector>  
#include <queue>  
#include <iterator>  
#include <map>  
#include <algorithm>  
#include <set>  
#include <functional>  
#include <time.h>  
#define lson rt<<1  
#define rson rt<<1|1  
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
const int INF = 1e9 + 5;
const int MAXN = 100005;
const LL MOD = 1000000007;
const double eps = 1e-8;
const double PI = acos(-1.0);
LL gcd(LL a, LL b) { return b == 0 ? a : gcd(b, a%b); }
LL ppow(LL a, LL b) { LL res = 1; for (int i = 1; i <= b; i++)   res *= a; return res; }
LL quick_mod(LL a, LL b, LL c) { LL ans = 1; while (b) { if (b % 2 == 1)ans = (ans*a) % c; b /= 2; a = (a*a) % c; }return ans; }

bool a[3000][3000];

void draw(int x, int y, int n)
{
	int temp = ppow(3, n - 1);
	if (n == 0) {
		a[x][y] = true;
	}
	else {
		draw(x - temp, y, n - 1);
		draw(x + temp, y, n - 1);
		draw(x, y - temp, n - 1);
		draw(x, y + temp, n - 1);
	}
}

int main()
{
	int T,n,x;
	int len;
	bool space;
	scanf("%d", &T);
	while (T--)
	{
		memset(a, 0, sizeof a);
		scanf("%d", &n);
		len = ppow(3, n);
		x = (len + 1) / 2;
		draw(x, x, n);
		for (int i = 1; i <= len; i++)
		{
			space = true;
			for (int j = 1; j <= len; j++)
				if (a[i][j])
				{
					printf("O");
					space = false;
					for (int t = j + 1; t <= len; t++)
						if (a[i][t])
							space = true;
				}
				else
					if (space)
						printf(" ");
					else
						break;
			printf("\n");
		}
	}
}
H题： 方块与收纳盒

斐波那契数列

I题：找数字个数

数据范围很小，把他给你的数字进行数位处理，不能选的数打上标记，然后直接1到1000的循环，答案就出来了。

#include <iostream>  
#include <cstdio>  
#include <cstring>  
#include <string>  
#include <cstdlib>  
#include <cmath>  
#include <vector>  
#include <queue>  
#include <iterator>  
#include <map>  
#include <algorithm>  
#include <set>  
#include <functional>  
#include <time.h>  
#define lson rt<<1  
#define rson rt<<1|1  
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
const int INF = 1e9 + 5;
const int MAXN = 100005;
const LL MOD = 1000000007;
const double eps = 1e-8;
const double PI = acos(-1.0);
LL gcd(LL a, LL b) { return b == 0 ? a : gcd(b, a%b); }
LL ppow(LL a, LL b) { LL res = 1; for (int i = 1; i <= b; i++)   res *= a; return res; }
LL quick_mod(LL a, LL b, LL c) { LL ans = 1; while (b) { if (b % 2 == 1)ans = (ans*a) % c; b /= 2; a = (a*a) % c; }return ans; }

bool numok[10];
int a, b;

void solve(int x)
{
	int res;
	while (x)
	{
		res = x % 10;
		x /= 10;
		numok[res] = false;
	}
}

bool check(int x)
{
	if (x%a == 0 || x%b == 0)
		return false;
	int res;
	while (x)
	{
		res = x % 10;
		x /= 10;
		if (numok[res] == false)
			return false;
	}
	return true;
}

int main()
{
	int T;
	int ans;
	scanf("%d", &T);
	while (T--)
	{
		ans = 0;
		for (int i = 0; i < 10; i++)
			numok[i] = true;
		scanf("%d%d", &a, &b);
		solve(a);
		solve(b);
		for (int i = 1; i <= 1000; i++)
			if (check(i))
				ans++;
		printf("%d\n", ans);
	}
}
J题： 闯关的lulu

这题题目里没告诉你规律，要自己找，找到了就很简单。奇数层会给你一个0，偶数层会给你一个1和一个0。

2个0->1个1，3个1->1个2，4个2->1个3，5个3->1个4，以此类推。

那么第n层一共会给你n个0和n/2个1，我们用一个数组记录这些数字的个数，比如说num[p]就是指p的个数，那我们就可以得到一个递推操作，num[p]=num[p-1]/(p+1),num[p-1]%=(p+1)，这就是把p-1转化成p的操作。我们从p=1开始执行这个操作，直到num[p-1]/(p+1)=0为止，即无法继续转化成更大的数了。然后我们从p到0循环一遍，对于每一个i输出num[i]次就是答案。

#include <iostream>  
#include <cstdio>  
#include <cstring>  
#include <string>  
#include <cstdlib>  
#include <cmath>  
#include <vector>  
#include <queue>  
#include <iterator>  
#include <map>  
#include <algorithm>  
#include <set>  
#include <functional>  
#include <time.h>  
#define lson rt<<1  
#define rson rt<<1|1  
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
const int INF = 1e9 + 5;
const int MAXN = 100005;
const LL MOD = 1000000007;
const double eps = 1e-8;
const double PI = acos(-1.0);
LL gcd(LL a, LL b) { return b == 0 ? a : gcd(b, a%b); }
LL ppow(LL a, LL b) { LL res = 1; for (int i = 1; i <= b; i++)   res *= a; return res; }
LL quick_mod(LL a, LL b, LL c) { LL ans = 1; while (b) { if (b % 2 == 1)ans = (ans*a) % c; b /= 2; a = (a*a) % c; }return ans; }

int num[1005];

int main()
{
	int T, n, p;
	scanf("%d", &T);
	while (T--)
	{
		memset(num, 0, sizeof num);
		scanf("%d", &n);
		num[0] = n;
		num[1] = n / 2;
		p = 1;
		while (num[p - 1] / (p + 1)>0)
		{
			num[p] += num[p - 1] / (p + 1);
			num[p - 1] %= (p + 1);
			p++;
		}
		for (int i = p - 1; i >= 0; i--)
			for (int j = 0; j < num[i]; j++)
				printf("%d", i);
		printf("\n");
	}
}









Eiffel灬
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法训练营第二天1
08-03
算法训练营第二天1
2018年全国多校算法寒假训练营练习比赛（第一场） D.N阶汉诺塔变形（数据结构）
polarbear_PB的博客
02-01 300
题目描述 相信大家都知道汉诺塔问题。那么现在对汉诺塔问题做一些限制，成为一个新的玩法。 在一个底座上，从左到右有三个分别命名为A、B和C的塔座，有n个大小不一的圆盘。这些圆盘一开始，从小到大按顺序叠加在塔座A上，形成一座上小下大的塔，塔座B和C为空。我们将n个圆盘，从小到大编号为1~n。现要求将塔座A上的n个圆盘移至塔座C上并仍按照同样的顺序叠排，圆盘移动时必须遵循以下规则：
2018年全国多校算法寒假训练营练习比赛（第一场）题解
张松超的博客
01-21 1620
A：贪心+暴力   链接：大吉大利，今晚吃鸡——枪械篇   思路：我用了一个map使配件种类对应一个最大威力的配件。然后暴力判断每把枪都装上最优的配件以后的威力，求一个极大值即可。   #include&lt;bits/stdc++.h&gt; using namespace std; const int MAXN = 1005; int n, m, k; double p[MAXN...
nowcoder2018年全国多校算法寒假训练营练习比赛（第一场）
weixin_30675247的博客
01-21 99
【气死我了 写完了博客发布 点看来一看怎么只剩下一半不到的内容了！！！！！！！！！！】 【就把卡的那两道放上来好了 其余的不弄了 生气！！！！！】 可以说是很久没有打比赛了 今天这一场主要是基础算法学习（数据结构基础、枚举、递推、贪心、模拟、递归、STL） 所以说今天的题都不难 结果最后只过了3道 卡了两道吃鸡的卡了超久 最后发现都是很傻逼的错误 先来说今...
2018年全国多校算法寒假训练营练习比赛（第一场） - （A，B，F，I，J）
Orz
01-21 853
这场比赛WA比较多，还是题意，先读懂题意再做题。而且读题目下面的样例说明是很重要的。 链接：https://www.nowcoder.com/acm/contest/67#question 来源：牛客网 A 大吉大利，今晚吃鸡——枪械篇 题意： 每一把枪都有其威力及其可装备配件种类。每一个配件有其所属种类，可以为枪支提供威力的百分比加成。每一把枪
2018年全国多校算法寒假训练营练习比赛（第一场） J题解析
qq_40644471的博客
01-22 725
题目： 勇者lulu某天进入了一个高度10,000,000层的闯关塔，在塔里每到一层楼，他都会获得对应数量的0 1（看情况获得），然后塔里有一个法则，当你身上某个数字达到一个特定的数量时，它们会合成为下一个数字，现在问题来了，当lulu从1层到达第n层的时候，他身上的数字是多少。 第1层 0 第2层 11 第3层 110 第4层 21 第5层 210
[2018牛客多校(第五场)] take (树状数组+概率)
ZZZZone的博客
08-05 402
题目链接 take 题目大意 一共有n个箱子， 第iii个箱子有p[i]%p[i]%p[i]\%的概率开出大小为d[i]d[i]d[i]的钻石。 初始玩家手里有一个size为0的钻石， 且手里最多只能有一个钻石， 如果当前开的箱子中得到的钻石大于手中的钻石， 则替换， 问最终替换次数的期望是多少。 最终对答案模998244353。 数据范围 1≤n≤1051≤n≤1051\le ...
算法训练营题目合集-已转档.pdf
02-29
清华大学计算机系邓俊辉教授的算法训练营题目合集及答案，本人是满分毕业。个人认为对于CSP和PAT的编程考试来说有很大的借鉴意义，是很好的CSP和PAT参考资料
算法面试强化刷题训练营课程-视频教程网盘链接提取码下载 .txt
05-02
快来跟着大神换个角度学...课程内容节奏非常快，需要同学们有比较扎实的算法学习基础，而当同学们完成一系列的训练课程之后，无论是对于面试拿Offer，夯实算法学习基础，竞赛竞速学习都有很大的帮助。 视频大小：1.8G
javascript算法训练营
05-29
javascript算法训练营
Pre-算法训练营-新百年1
08-04
② 比较系统的数理基础（离散数学、代 ① 思维方式（严谨、套路==>计算思维 ② (实际)套路（知识点+解题方法，方法论[设计的套路，减治、分 ③ 综合运用能
python学习导航.txt
05-06
python
node-v8.3.0-linux-s390x.tar.xz
05-06
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
嵌入式微处理器设计及应用
05-06
摘要：为满足智能家居座椅的交互式运动控制需求，基于AT89S52设计了嵌入式座椅运动控制系统。使用VB.net设计了游戏手柄按键读取软件，并在此基础上设计了座椅运动控制软件，软件可分别在“手柄模式”和“鼠标模式”下与嵌入式座椅运动控制器通信，进而控制座椅进行加速、减速、正转和反转等运动；构建了控制系统实验装置，实验结果表明，“鼠标模式”下，通过鼠标点击控制软件上功能按钮可实现对座椅的准确运动控制；“手柄模式”下，游戏手柄不仅可控制座椅运动，还可同步控制电脑上运行的游戏或远程遥控车，实现浸入感较强的座椅运动娱乐应用。
2024年中国NFC RFID阅读器行业研究报告.docx
05-06
2024年中国NFC RFID阅读器行业研究报告
node-v9.9.0-linux-ppc64le.tar.xz
最新发布
05-06
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
04-18 周四 为LLM-inference项目配置GitHub CI过程记录
05-06
04-18 周四 为LLM-inference项目配置GitHub CI过程记录
2024年中国AI和机器视觉行业研究报告.docx
05-06
2024年中国AI和机器视觉行业研究报告
代码随想录算法训练营第二十一天
09-13
第二十二天的算法训练营主要涵盖了Leetcode题目中的三道题目，分别是Leetcode 28 "Find the Index of the First Occurrence in a String"，Leetcode 977 "有序数组的平方"，和Leetcode 209 "长度最小的子数组"。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值