2023CSP-J题解

前言

烦死了，这次CSP考的真的垃圾，犯了好多低级错误。

[CSP-J 2023] 小苹果【民间数据】

题目描述

小 Y 的桌子上放着 $n$ 个苹果从左到右排成一列，编号为从 $1$ 到 $n$。

小苞是小 Y 的好朋友，每天她都会从中拿走一些苹果。

每天在拿的时候，小苞都是从左侧第 $1$ 个苹果开始、每隔 $2$ 个苹果拿走 $1$ 个苹果。随后小苞会将剩下的苹果按原先的顺序重新排成一列。

小苞想知道，多少天能拿完所有的苹果，而编号为 $n$ 的苹果是在第几天被拿走的？

输入格式

输入的第一行包含一个正整数 $n$，表示苹果的总数。

输出格式

输出一行包含两个正整数，两个整数之间由一个空格隔开，分别表示小苞拿走所有苹果所需的天数以及拿走编号为 $n$ 的苹果是在第几天。

样例 #1

样例输入 #1

8

样例输出 #1

5 5

提示

【样例 $1$ 解释】

小苞的桌上一共放了 $8$ 个苹果。
小苞第一天拿走了编号为 $1$、$4$、$7$ 的苹果。
小苞第二天拿走了编号为 $2$、$6$ 的苹果。
小苞第三天拿走了编号为 $3$ 的苹果。
小苞第四天拿走了编号为 $5$ 的苹果。
小苞第五天拿走了编号为 $8$ 的苹果。

【样例 $2$】

见选手目录下的 apple/apple2.in 与 apple/apple2.ans。

【数据范围】

对于所有测试数据有：$1\le n\le 10^9$。

特殊性质：小苞第一天就取走编号为 $n$ 的苹果。

思路

一道很水的思维题，考场上没有想到正解，先花了40min推导了“一”下公式，后面没有推导出来就用20pts打了一个暴力。

题目大意

有 $n$ 个苹果，从第 $1$ 个苹果开始，每隔 $2$ 个拿走 $1$ 个；第一遍拿完之后再把剩下苹果再按这个规则重新拿，直到所有苹果拿完为止。

分析

看完题目，我们就可以发现，其实每次取走苹果数约等于当前所剩余的苹果的 $\frac{1}{3}$。我们根据手推可以推得：每次当 $nmod3=1$ 时（$n$ 为所剩的苹果数），就会取走最后一个苹果。

目测此题难度为 $入门$。

Code

懂了思路，代码实现起来就很简单了。

#include<bits/stdc++.h>
using namespace std;
long long n, sum, ans;
bool flag;
int main() {
	cin >> n;
	while (n) {
		sum++;
		if (!flag && n % 3 == 1) {
			flag = true;
			ans = sum;
		}
		n -= (n + 2) / 3;
	}
	cout << sum << " " << ans;
	return 0;
}

[CSP-J 2023] 公路【民间数据】

题目描述

小苞准备开着车沿着公路自驾。

公路上一共有 $n$ 个站点，编号为从 $1$ 到 $n$。其中站点 $i$ 与站点 $i+1$ 的距离为 $v_i$ 公里。

公路上每个站点都可以加油，编号为 $i$ 的站点一升油的价格为 $a_i$ 元，且每个站点只出售整数升的油。

小苞想从站点 $1$ 开车到站点 $n$，一开始小苞在站点 $1$ 且车的油箱是空的。已知车的油箱足够大，可以装下任意多的油，且每升油可以让车前进 $d$ 公里。问小苞从站点 $1$ 开到站点 $n$，至少要花多少钱加油？

输入格式

输入的第一行包含两个正整数 $n$ 和 $d$，分别表示公路上站点的数量和车每升油可以前进的距离。

输入的第二行包含 $n-1$ 个正整数 $v_1,v_2\dots v_{n-1}$，分别表示站点间的距离。

输入的第三行包含 $n$ 个正整数 $a_1,a_2\dots a_n$，分别表示在不同站点加油的价格。

输出格式

输出一行，仅包含一个正整数，表示从站点 $1$ 开到站点 $n$，小苞至少要花多少钱加油。

样例 #1

样例输入 #1

5 4
10 10 10 10
9 8 9 6 5

样例输出 #1

79

提示

【样例 1 解释】

最优方案下：小苞在站点 $1$ 买了 $3$ 升油，在站点 $2$ 购买了 $5$ 升油，在站点 $4$ 购买了 $2$ 升油。

【样例 2】

见选手目录下的 road/road2.in 与 road/road2.ans。

【数据范围】

对于所有测试数据保证：$1\le n\le 10^5$，$1\le d\le 10^5$，$1\le v_i\le 10^5$，$1\le a_i\le 10^5$。

• 特殊性质 A：站点 $1$ 的油价最低。
• 特殊性质 B：对于所有 $1\le i<n$，$v_i$ 为 $d$ 的倍数。

思路

这题一看就是贪心啊！！

就是从起点开始，找第一个价格比它小的数，即到那个加油站加油。

notice: 油量要用 double类型来储存，因为剩余的油量也可以储存起来进行下一次的行驶。

目测此题难度 $普及-$

Code

贪心，没什么好说的了。

#include<bits/stdc++.h>
using namespace std;
long long n, d, v[100005], dis[100005];
long long pre, minn = 1e9, ans;
double oil;
int main() {
	cin >> n >> d;
	for (int i = 1; i < n; i++) {
		cin >> dis[i];
	}
	for (int i = 1; i <= n; i++) {
		cin >> v[i];
	}
	for (int i = 1; i < n; i++) {
		minn = min(minn, v[i]);
		if (pre < dis[i]) {
			oil = (dis[i] - pre + d - 1) / d;
			ans += (long long)minn * oil;
			pre += (long long)d * oil;
		}
		pre -= dis[i];
	}
	cout << ans;
	return 0;
}

[CSP-J 2023] 一元二次方程【民间数据】

题目背景

众所周知，对一元二次方程 $a{x}^2+bx+c=0,(a\ne 0)$，可以用以下方式求实数解：

• 计算 $\Delta =b^2-4ac$，则:
  1. 若 $\Delta <0$，则该一元二次方程无实数解。
  2. 否则 $\Delta \ge 0$，此时该一元二次方程有两个实数解 $x_{1,2}=\frac{-b\pm \sqrt{\Delta }}{2a}$。

例如：

• $x^2+x+1=0$ 无实数解，因为 $\Delta =1^2-4\times 1\times 1=-3<0$。
• $x^2-2x+1=0$ 有两相等实数解 $x_{1,2}=1$。
• $x^2-3x+2=0$ 有两互异实数解 $x_1=1,x_2=2$。

在题面描述中 $a$ 和 $b$ 的最大公因数使用 $\gcd (a,b)$ 表示。例如 $12$ 和 $18$ 的最大公因数是 $6$，即 $\gcd (12,18)=6$。

题目描述

现在给定一个一元二次方程的系数 $a,b,c$，其中 $a,b,c$ 均为整数且 $a\ne 0$。你需要判断一元二次方程 $a{x}^2+bx+c=0$ 是否有实数解，并按要求的格式输出。

在本题中输出有理数 $v$ 时须遵循以下规则：

• 由有理数的定义，存在唯一的两个整数 $p$ 和 $q$，满足 $q>0$，$\gcd (p,q)=1$ 且 $v=\frac{p}{q}$。

• 若 $q=1$，则输出 {p}，否则输出 {p}/{q}，其中 {n} 代表整数 $n$ 的值；

• 例如：

  • 当 $v=-0.5$ 时，$p$ 和 $q$ 的值分别为 $-1$ 和 $2$，则应输出 -1/2；
  • 当 $v=0$ 时，$p$ 和 $q$ 的值分别为 $0$ 和 $1$，则应输出 0。

对于方程的求解，分两种情况讨论：

1. 若 $\Delta =b^2-4ac<0$，则表明方程无实数解，此时你应当输出 NO；

2. 否则 $\Delta \ge 0$，此时方程有两解（可能相等），记其中较大者为 $x$，则：

   1. 若 $x$ 为有理数，则按有理数的格式输出 $x$。

   2. 否则根据上文公式，$x$ 可以被唯一表示为 $x=q_1+q_2\sqrt{r}$ 的形式，其中：

      • $q_1,q_2$ 为有理数，且 $q_2>0$；
      • $r$ 为正整数且 $r>1$，且不存在正整数 $d>1$ 使 $d^2\mid r$（即 $r$ 不应是 $d^2$ 的倍数）；

   此时：

   1. 若 $q_1\ne 0$，则按有理数的格式输出 $q_1$，并再输出一个加号 +；
   2. 否则跳过这一步输出；

   随后：

   1. 若 $q_2=1$，则输出 sqrt({r})；
   2. 否则若 $q_2$ 为整数，则输出 {q2}*sqrt({r})；
   3. 否则若 $q_3=\frac{1}{q_2}$ 为整数，则输出 sqrt({r})/{q3}；
   4. 否则可以证明存在唯一整数 $c,d$ 满足 $c,d>1,\gcd (c,d)=1$ 且 $q_2=\frac{c}{d}$，此时输出 {c}*sqrt({r})/{d}；

   上述表示中 {n} 代表整数 {n} 的值，详见样例。

   如果方程有实数解，则按要求的格式输出两个实数解中的较大者。否则若方程没有实数解，则输出 NO。

输入格式

输入的第一行包含两个正整数 $T,M$，分别表示方程数和系数的绝对值上限。

接下来 $T$ 行，每行包含三个整数 $a,b,c$。

输出格式

输出 $T$ 行，每行包含一个字符串，表示对应询问的答案，格式如题面所述。

每行输出的字符串中间不应包含任何空格。

样例 #1

样例输入 #1

9 1000
1 -1 0
-1 -1 -1
1 -2 1
1 5 4
4 4 1
1 0 -432
1 -3 1
2 -4 1
1 7 1

样例输出 #1

1
NO
1
-1
-1/2
12*sqrt(3)
3/2+sqrt(5)/2
1+sqrt(2)/2
-7/2+3*sqrt(5)/2

提示

【样例 #2】

见附件中的 uqe/uqe2.in 与 uqe/uqe2.ans。

【数据范围】

对于所有数据有：$1\le T\le 5000$，$1\le M\le 10^3$，$|a|,|b|,|c|\le M$，$a\ne 0$。

其中：

• 特殊性质 A：保证 $b=0$；
• 特殊性质 B：保证 $c=0$；
• 特殊性质 C：如果方程有解，那么方程的两个解都是整数。

思路

SB大模拟，一道思路很简单的模拟题，但是要考虑很多细节，考试的时候只因我没删调试过程，痛失100pts。

对小学的和初一的不是很友好，此题的数学知识涉及到了初二的最简二次根式。。。

目测此题难度 $普及/提高-$

Code

#include<bits/stdc++.h>
using namespace std;
int t, a, b, c, up;
int main() {
	cin >> t >> up;
	while (t--) {
		cin >> a >> b >> c;
		int derta = b * b - 4 * a * c;
		if (derta < 0) {
			cout << "NO\n";
			continue;
		}
		if ((int)sqrt(derta) * (int)sqrt(derta) == derta) {
			int z, m = 2 * a;
			if (a < 0) {
				z = -sqrt(derta) - b;
			} else {
				z = sqrt(derta) - b;
			}
			if (z > 0 && m < 0) {
				z = -z, m = -m;
			}
			if (z < 0 && m < 0) {
				z = -z, m = -m;
			}
			if (z % m == 0) {
				cout << z / m;
			} else {
				int g = __gcd(abs(m), abs(z));
				cout << z / g << "/" << m / g;
			}
		} else {
			int uz = -b, um = 2 * a, z = derta;
			if (uz != 0) {
				if (uz > 0 && um < 0) {
					uz = -uz, um = -um;
				}
				if (uz < 0 && um < 0) {
					uz = -uz, um = -um;
				}
				if (uz % um == 0) {
					cout << uz / um;
				} else {
					int g = __gcd(abs(um), abs(uz));
					cout << uz / g << "/" << um / g;
				}
				cout << "+";
			}
			int q2 = 1;
			for (int i = sqrt(derta); i >= 2; i--) {
				if (z % (i * i) == 0) {
					q2 = i;
					z /= i * i;
					break;
				}
			}
			int g = __gcd(abs(a) * 2, q2);
			a = abs(a) * 2 / g, q2 /= g;
			if (q2 == 1 && a == 1) {
				cout << "sqrt(" << z << ")";
			} else if (q2 == 1) {
				cout << "sqrt(" << z << ")/" << a;
			} else if (q2 % a == 0) {
				cout << q2 / a << "*sqrt(" << z << ")";
			} else {
				cout << q2 << "*sqrt(" << z << ")/" << a;
			}
		}
		cout << "\n";
	}
	return 0;
}

[CSP-J 2023] 旅游巴士【民间数据】

题目描述

小 Z 打算在国庆假期期间搭乘旅游巴士去一处他向往已久的景点旅游。

旅游景点的地图共有 $n$ 处地点，在这些地点之间连有 $m$ 条道路。其中 $1$ 号地点为景区入口，$n$ 号地点为景区出口。我们把一天当中景区开门营业的时间记为 $0$ 时刻，则从 $0$ 时刻起，每间隔 $k$ 单位时间便有一辆旅游巴士到达景区入口，同时有一辆旅游巴士从景区出口驶离景区。

所有道路均只能单向通行。对于每条道路，游客步行通过的用时均为恰好 $1$ 单位时间。

小 Z 希望乘坐旅游巴士到达景区入口，并沿着自己选择的任意路径走到景区出口，再乘坐旅游巴士离开，这意味着他到达和离开景区的时间都必须是 $k$ 的非负整数倍。由于节假日客流众多，小 Z 在旅游巴士离开景区前只想一直沿着景区道路移动，而不想在任何地点（包括景区入口和出口）或者道路上停留。

出发前，小 Z 忽然得知：景区采取了限制客流的方法，对于每条道路均设置了一个
“开放时间”$a_i$，游客只有不早于 $a_i$ 时刻才能通过这条道路。

请帮助小 Z 设计一个旅游方案，使得他乘坐旅游巴士离开景区的时间尽量地早。

输入格式

输入的第一行包含 3 个正整数 $n,m,k$，表示旅游景点的地点数、道路数，以及旅游巴士的发车间隔。

输入的接下来 $m$ 行，每行包含 3 个非负整数 $u_i,v_i,a_i$，表示第 $i$ 条道路从地点 $u_i$ 出发，到达地点 $v_i$，道路的“开放时间”为 $a_i$。

输出格式

输出一行，仅包含一个整数，表示小 Z 最早乘坐旅游巴士离开景区的时刻。如果不存在符合要求的旅游方案，输出 -1。

样例 #1

样例输入 #1

5 5 3
1 2 0
2 5 1
1 3 0
3 4 3
4 5 1

样例输出 #1

6

提示

【样例 #1 解释】

小 Z 可以在 $3$ 时刻到达景区入口，沿 $1\to 3\to 4\to 5$ 的顺序走到景区出口，并在 $6$ 时刻离开。

【样例 #2】

见附件中的 bus/bus2.in 与 bus/bus2.ans。

【数据范围】

对于所有测试数据有：$2\le n\le 10^4$，$1\le m\le 2\times 10^4$，$1\le k\le 100$，$1\le u_i,v_i\le n$，$0\le a_i\le 10^6$。

思路

一道有难度的最短路，一道简单的分层图应用。
通常图论题都会涉及到bfs。如果是普通边权为 $1$ 的图中求最短路，直接使用bfs就可以了。但本题加了 $2$ 个限制，一个是边的开放时间，另一个是起点和终点的时间限制。也就是说即使 $u$ 和 $v$ 连了边，也不是随便就可以走的，需要判断当前时间该边是否开放了。
如果开放了，可以直接过去；如果没开放，需要到达点u的时间往后延迟若干个k的整数倍时间才行，因为不能在途中等，只能乘坐晚相应时间的巴士进入才行，到达 $v$ 的时间也会相应变晚。
有点类似分层图的概念，但作为入门组没有学过分层图，也不妨碍做这道题。
剩下的就是用记忆化搜索来减低队列处理的复杂度了，通常我只有 $vis[n]$ 一维的记忆化，但这道题需要用到二维 $vis[n][k]$ 来记录。

所以这道题可以用SPFA,可以用dijkstra，也可以直接bfs。我主要用的是dijkstra。目测难度 $普及+/提高$

Code

#include<bits/stdc++.h>
using namespace std;
int point, road, k;
const int inf = 0x3f3f3f3f;
struct shest {
	int u, w, res;
	friend bool operator<(shest x, shest y) {
		return x.w > y.w;
	}
};
vector<pair<int, int>>vec[100005];
int vis[100005][105];
priority_queue<shest>q;
int dijkstra() {
	q.push({1, 0, 0});
	memset(vis, inf, sizeof vis);
	while (!q.empty()) {
		shest now = q.top();
		q.pop();
		if (now.w > vis[now.u][now.res]) {
			continue;
		}
		for (pair<int, int> x : vec[now.u]) {
			int add = 0;
			if (x.second > now.w) {
				add = now.w + 1 + (x.second - now.w + k - 1) / k * k;
			} else {
				add = now.w + 1;
			}
			if (vis[x.first][add % k] > add) {
				vis[x.first][add % k] = add;
				q.push({x.first, add, add % k});
			}
		}
	}
	return vis[point][0];
}
int main() {
	cin >> point >> road >> k;
	for (int i = 1, u, v, a; i <= road; i++) {
		cin >> u >> v >> a;
		vec[u].push_back({v, a});
	}
	int ans = dijkstra();
	if (ans == inf) {
		puts("-1");
	} else {
		cout << ans << "\n";
	}
	return 0;
}