Block_Fish 的随笔记录

【置顶】珍爱生命，远离 double

Wed, 07 Aug 2024 12:59:26 GMT

rt，今日模拟赛时，某只积木鱼看到了 T1，发现是个百分数计算裸题，于是飞速写下了下面的代码：

1
double tmp;
2
...
3
scanf("%d%d", &n, &x);
4
FOR(i, 1, n) scanf("%d%d", &v[i], &p[i]);
5
FOR(i, 1, n) {
6
  tmp += v[i] * (p[i] * 0.01), ++ans;
7
  if (tmp > (x * 1.0)) break;
8
}
9
if (tmp < (x * 1.0)) log("-1\n");
10
else log("%d\n", ans);

然后呢？100—>40，rk4—>rk7

积木鱼衷心希望大家不要再犯同样的错误……

upd on 2026/10/27：

最不希望出续集旳一集。

是的杂鱼积木鱼在某场模拟赛中仍然是一眼秒掉了 T1，然后又被卡浮点精度误差了（死于“输出结果必须与标准答案相同，不使用浮点误差容限。”）。然后呢？100—>50，喜提倒数第一两位数分数。

这个故事告诉我们能用 int 和 long long 这种整数解决的事情一定要尽量避免 double。换句话来讲，不要用它来存储，而是作为参与运算得临时过渡类型。

另外，涉及到浮点数不开 SPJ 的出题人司凤。

经过测试，在部分 Linux 系统下，如下变量名会挂而 Windows 下没事儿：

nice
kill

建议前者用 good 代替，后者改为 die。具体而言，nice 是 Linux 下用来改变进程优先级的指令，而 kill 是杀死进程的指令，遇到这种东西就会冲突。

运算符的关系简览

Thu, 25 Jan 2024 22:00:24 GMT

转载自 https://blog.csdn.net/huangblog/article/details/8271791。

C/C++运算符优先级

优先级	运算符	名称或含义	使用形式	结合方向	说明
1	[]	数组下标	数组名[常量表达式]	左到右	--
()	圆括号	(表达式）/函数名(形参表)	--
.	成员选择（对象）	对象.成员名	--
->	成员选择（指针）	对象指针->成员名	--

2	-	负号运算符	-表达式	右到左	单目运算符
~	按位取反运算符	~表达式
++	自增运算符	++变量名/变量名++
--	自减运算符	--变量名/变量名--
*	取值运算符	*指针变量
&	取地址运算符	&变量名
!	逻辑非运算符	!表达式
(类型)	强制类型转换	(数据类型)表达式	--
sizeof	长度运算符	sizeof(表达式)	--

3	/	除	表达式/表达式	左到右	双目运算符
*	乘	表达式*表达式
%	余数（取模）	整型表达式%整型表达式
4	+	加	表达式+表达式	左到右	双目运算符
-	减	表达式-表达式
5	<<	左移	变量<<表达式	左到右	双目运算符
>>	右移	变量>>表达式

6	>	大于	表达式>表达式	左到右	双目运算符
>=	大于等于	表达式>=表达式
<	小于	表达式<表达式
<=	小于等于	表达式<=表达式
7	==	等于	表达式==表达式	左到右	双目运算符
！=	不等于	表达式!= 表达式

8	&	按位与	表达式&表达式	左到右	双目运算符
9	^	按位异或	表达式^表达式	左到右	双目运算符
10	\|	按位或	表达式\|表达式	左到右	双目运算符
11	&&	逻辑与	表达式&&表达式	左到右	双目运算符
12	\|\|	逻辑或	表达式\|\|表达式	左到右	双目运算符

13	?:	条件运算符	表达式1? 表达式2: 表达式3	右到左	三目运算符

14	=	赋值运算符	变量=表达式	右到左	--
/=	除后赋值	变量/=表达式	--
*=	乘后赋值	变量*=表达式	--
%=	取模后赋值	变量%=表达式	--
+=	加后赋值	变量+=表达式	--
-=	减后赋值	变量-=表达式	--
<<=	左移后赋值	变量<<=表达式	--
>>=	右移后赋值	变量>>=表达式	--
&=	按位与后赋值	变量&=表达式	--
^=	按位异或后赋值	变量^=表达式	--
\|=	按位或后赋值	变量\|=表达式	--

15	，	逗号运算符	表达式,表达式,…	左到右	--

说明：

运算符共分为15级，1级优先级最高，15级优先级最低。

同一优先级的运算符，运算次序由结合方向所决定。(结合性：2 13 14 是从右至左其他都是从左至右)
简单记就是：！ > 算术运算符 > 关系运算符 > && > || > 赋值运算符

再详细一点，附带一个口诀。(网上找的)

括号成员第一; //括号运算符[]() 成员运算符. ->

全体单目第二; //所有的单目运算符比如++、 --、 +(正)、 -(负) 、指针运算*、&

乘除余三,加减四; //这个"余"是指取余运算即%

移位五，关系六; //移位运算符：<< >> ，关系：> < >= <= 等

等于(与)不等排第七; //即== 和!=

位与异或和位或; "三分天下"八九十; //这几个都是位运算: 位与(&)异或(^)位或(|)

逻辑或跟与; //逻辑运算符:|| 和 &&

十二和十一; //注意顺序:优先级(||) 底于优先级(&&)

条件高于赋值, //三目运算符优先级排到13 位只比赋值运算符和","高

逗号运算级最低! //逗号运算符优先级最低

Firefly 简单使用指南

Fri, 02 Jan 1970 00:00:00 GMT

这个博客模板是基于 Astro 构建的。对于本指南中未提及的内容，您可以在 Astro 文档中找到答案。

文章的 Front-matter#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
description: 这是我新 Astro 博客的第一篇文章。
5
image: ./cover.jpg
6
tags: [前端, 开发]
7
category: 前端开发
8
draft: false
9
---

属性	描述
`title`	文章标题。
`published`	文章发布日期。
`updated`	文章更新日期。如果未设置，将默认使用发布日期。
`pinned`	是否将此文章置顶在文章列表顶部。
`description`	文章的简短描述。显示在首页上。
`image`	文章封面图片路径。 1. 以 `http://` 或 `https://` 开头：使用网络图片 2. 以 `/` 开头：`public` 目录中的图片 3. 不带任何前缀：相对于 markdown 文件的路径
`tags`	文章标签。
`category`	文章分类。
`lang`	文章语言代码（如 `zh-CN`）。仅当文章语言与站点默认语言不同时设置。
`licenseName`	文章内容的许可证名称。
`licenseUrl`	文章内容的许可证链接。
`author`	文章作者。
`sourceLink`	文章内容的来源链接或参考。
`draft`	如果这篇文章仍是草稿，则不会显示。
`comment`	是否启用此文章的评论功能。默认为 `true`。
`slug`	自定义文章 URL 路径。如果不设置，将使用文件名作为 URL。
`password`	文章密码。设置后文章内容将被 AES-256-GCM 加密，访客需输入密码才能查看。
`passwordHint`	密码提示。显示在密码输入框上方，帮助访客回忆密码，也可以不加。

文章文件的放置位置#

您的文章文件应放置在 src/content/posts/ 目录中。您也可以创建子目录来更好地组织您的文章和资源。

1
src/content/posts/
2
├── post-1.md
3
└── post-2/
4
    ├── cover.png
5
    └── index.md

自定义文章 URL (Slug)#

什么是 Slug？#

Slug 是文章 URL 路径的自定义部分。如果不设置 slug，系统将使用文件名作为 URL。

Slug 使用示例#

示例 1：使用文件名作为 URL#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
---

文件：src/content/posts/my-first-blog-post.md

URL：/posts/my-first-blog-post

示例 2：自定义 Slug#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
slug: hello-world
5
---

文件：src/content/posts/my-first-blog-post.md

URL：/posts/hello-world

示例 3：其他语言文件名使用Slug#

1
---
2
title: 如何使用 Firefly 博客主题
3
published: 2023-09-09
4
slug: how-to-use-firefly-blog-theme
5
---

文件：src/content/posts/如何使用Firefly博客主题.md

URL：/posts/how-to-use-firefly-blog-theme

Slug 使用建议#

使用英文和连字符：my-awesome-post 而不是 my awesome post
保持简洁：避免过长的 slug
具有描述性：让 URL 能够反映文章内容
避免特殊字符：只使用字母、数字和连字符
保持一致性：在整个博客中使用相似的命名模式

注意事项#

Slug 一旦设置并发布，建议不要随意更改，以免影响 SEO 和已存在的链接
如果多个文章使用相同的 slug，后面的文章会覆盖前面的
Slug 会自动转换为小写

题解：P16007 [CCO 2016 Day 1] Field Trip 郊游

Tue, 27 Oct 2026 08:20:33 GMT

闲话#

传说 CSP 考前写题解 RP++?

这题放模拟赛 T1 被秒切了，然后卡了半天一直 RE 测不出来问题，后来发现是没开大栈空间。

好消息是 CSP 等一般都是无限栈空间或者是与题目内存限制等大的，反正几乎无需担心。

正文#

题目 Link。

不难将其抽象成一个图论结构。那么题目变为：NNN 个点，MMM 条双向边的图。你可以删去一些边。最终你需要最大化大小恰好为 KKK 的连通块数量，在此基础上最小化删的边数。

Hints#

我们只能删边，而不能建立，这意味着什么？
由于每个点度数不超过 222，所以一整个连通块会是什么形状？
我们需要知道连通块的什么信息才能求答案？如何求得？

答案#

这意味着如果 A,BA, BA,B 两点在最后是连通的，那么它们在最开始的图上也必然是连通的。也就是说，如果点 CCC 开始时不与 AAA 连通，那么最终也不可能与 AAA 连通。
我们画画图就可以发现连通块不是链就是环。
当然是需要知道连通块的大小，以及它是环还是链。

第一个结论很好想，我们删边是在破坏连通性，怎么可能越破坏越连通上了？

第二个结论的话自己画图理解：

链

环

首先链是一种树，一个点一进一出最多两个度，开头和末尾的点只有 111 个度，一共 nnn 个点 n−1n - 1n−1 条边。我们将第一个点和最后一个点连起来（加到其它点上那它的度数就变成 333 了），此时每个点的度都恰好是 222，一共 nnn 个点 nnn 条边。如果我们继续加边就会发现加到哪儿都会是某个点度数为 333 不符合要求，因此确实只有这 222 种情况。

从这里我们也可以看出，因为环要多条边，我们（可能）还要删去，因此需要与链分开处理。

我们先看能选出来几个点。设某个连通块的大小为 LLL。注意如果 L≤KL \le KL≤K 那么根本不需要删边。

我们只能 KKK 个 KKK 个选，一共能选出 C=⌊LK⌋C = \left\lfloor\dfrac{L}{K}\right\rfloorC=⌊KL⌋ 组，共 K×CK \times CK×C 个，设 R=L−K×CR = L - K \times CR=L−K×C，也就是不属于任何一组的点数。

接着我们看链的情况下要断几条边。首先，我们需要把 CCC 组当中组与组之间断开，一共断 C−1C - 1C−1 条。

然后，如果 R>0R > 0R>0，也就是还有剩余，那么还再断 111 条边要把这 RRR 个点和分好组的点断开，至于这 RRR 个点内部，因为肯定有 R<KR < KR<K，所以不用让他们不连通（因为无论如何都选不了），为了最小化断边数这 RRR 个点内部不用处理，一共断 CCC 条。

如果是环的话，同样分类讨论。如果 R=0R = 0R=0，那么同样断开这 CCC 组，因为还要破环，所以是 C−1+1=CC - 1 + 1 = CC−1+1=C，刚好 CCC 条。如果 R>0R > 0R>0，那和链的情况类似，还要再断一条。合计我们发现刚好断了 ⌈LK⌉\left\lceil\dfrac{L}{K}\right\rceil⌈KL⌉ 条边。

那么就算做完了，总结一下做法：

读入、建图。
遍历每一个点，如果它属于一个新连通块那就 DFS 求出连通块大小 LLL，否则的话之前一定被搜过了就跳过。
记录答案，选上点数 K×⌊LK⌋K \times \left\lfloor\dfrac{L}{K}\right\rfloorK×⌊KL⌋，断掉边数分环和链分类讨论。
输出

最终时间复杂度是 DFS 的时间复杂度 O(n+m)\mathcal{O}(n + m)O(n+m)、读入 mmm 条边复杂度 O(m)\mathcal{O}(m)O(m)、遍历每个点的复杂度 O(n)\mathcal{O}(n)O(n)，合计时间复杂度还是 O(n+m)\mathcal{O}(n + m)O(n+m)。

代码#

1
#include <bits/stdc++.h>
2

3
#define FOR(i, j, k) for(ll i = j;i <= k;++i)
4

5
using namespace std;
6
typedef long long ll
7

8
const ll N = 2e6 + 10;
9
ll c, k, m, n, r, u, v, ans, cnt, sum;
10
bool flg;
11
vector<ll> g[N];
12
bitset<N> vis;
13

14
void dfs(ll now, ll fa) {
15
  if(vis[now]) {  // 回来了
16
    flg = 1; // 那么就是环
17
    return;  // 不能再搜了，会走不出去的
18
  }
19
  vis[now] = 1;  // 标记访问过了
20
  ++cnt; // 记录连通块大小
21
  for(auto v:g[now]) {
22
    if(v == fa) continue;  // 当然不能回去
23
    dfs(v, now);
24
  }
25
}
26

27
int main() {
28
  ios::sync_with_stdio(false);
29
  cin.tie(0);
30
  cin >> n >> m >> k;
31
  FOR(i, 1, m) {
32
    cin >> u >> v;
33
    g[u].emplace_back(v), g[v].emplace_back(u);
34
  }
35
  FOR(i, 1, n)
36
    if(!vis[i]) {
37
      cnt = flg = 0;
38
      dfs(i, -1);
39
      if(cnt < k) continue;
40
      c = cnt / k, r = cnt % k;
41
      ans += c * k;  // 先记录选了几个
42
      if(cnt != k) {  // 如果恰好 k 个那当然一条边都不用断
43
        if(!flg) {
44
          if(!r) sum += c - 1;
45
          else sum += c;
46
        } else sum += ceil(1.0 * cnt / k);  // 小心自动下取整！
47
      }
48
    }
49
  cout << ans << ' ' << sum;
50
  return 0;
51
}

展开收起

AC 记录。

理解万岁！RP++！

题解：P15290 [MCO 2023] Two Pointers (easy version)

Mon, 03 Aug 2026 11:33:46 GMT

闲话#

神秘模拟赛放了马来西亚的题，不知道老师怎么找到的。

简要版题意#

AAA 和 BBB 两个人，从两个地方访问 nnn 个地点，顺序无所谓，且只要任何一个人访问过这个地点就算访问了。

求两人所走路径之和的最小值。

Hints#

先给一些提示问题，想出来了先去自己解决吧 :)。

Hint 1：顺序无所谓，那么我们可以干什么？

Hint 2：我们有 222 个人，可否按照某种方式，让某些点由 AAA 负责，另外一些由 BBB 负责？

Hint 3：我们向某个方向通过一个点 XXX 走向该方向的一个更远的点 YYY，距离跟谁有关？

Hint 4：考虑结合 AAA 和 BBB 的位置，配合与各个目标的相对位置进行分类讨论。

完整版解答#

顺序无所谓当然就直接排序啦！

同理，为了方便表述，我们不妨假设初始时 A<BA < BA<B，即点 AAA 在左侧。

排完序之后就可以进行分组了。由于我们不知道每个点分给谁更好，因此我们可以枚举 1∼n1 \sim n1∼n 的每一个点 iii 进行分段，1∼i1 \sim i1∼i 分给 AAA，i+1∼ni + 1\sim ni+1∼n 分给 BBB。

一个非常 Naive 的想法是断点 iii 从最左侧开始挨个向右遍历，每次计算一下路程和的变化。

但是这样子就会卡很久——因为 AAA 的位置取值范围太大了！

它可以在大家的左边，也可以是右边，还可以是这一段的中间。因此，讨论变化的话情况会比较多，很容易卡住。

如图所示

那怎么办呢？我们考虑每次重新计算距离之和。

注意到我们如果在序列最左端的左侧，或者最右端的右侧，我们直接把序列走到头就全部齐活了。也就是说，如果方向固定，我们只关心距离我们最远的点，其它点对距离没有影响，去最远点的路上顺便就解决了。

而如果在序列中间的话，我们需要先向某个方向走到头覆盖所有这个方向的点，然后再掉头回去。为了最小化路程，我们选择距离我们更近的端点（因为这样返回增加的路程更少），然后再折返回去即可。

分成的两段每一段都是这个情况。因此我们可以抽象成一个函数处理。

ACCode#

似乎光讲着比较抽象，看代码会好理解很多。

1
/*Code by Block_Fish*/
2
#include <bits/stdc++.h>
3

4
#define log printf
5
#define EPS 1e-8
6
#define INF 0x3f3f3f3f3f3f3f3f
7
#define FOR(i, l, r) for (ll i = l; i <= r; ++i)
8
#define IOS                      \
9
  ios::sync_with_stdio(false); \
10
  cin.tie(nullptr);
11
#define Buffer 1 << 23
12

13
char buf[Buffer], *p1 = buf, *p2 = buf, obuf[Buffer], *p3 = obuf;
14
#define getchar() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, Buffer, stdin), p1 == p2) ? EOF : *p1++)
15
#define putchar(x) (p3 - obuf < Buffer) ? (*p3++ = x) : (fwrite(obuf, p3 - obuf, 1, stdout), p3 = obuf, *p3++ = x)
16

17
using namespace std;
18

19
typedef __int128 i128;
20
typedef long long ll;
21
typedef pair<ll, ll> PII;
22

23
const ll N = 2e5 + 10;
24
ll a, b, n, t, id[N], mn;
25

26
template <typename T>
27

28
inline T read() {
29
  T sum = 0, fl = 1;
30
  char ch = getchar();
31
  for (; !isdigit(ch); ch = getchar())
32
    if (ch == '-') fl = -1;
33
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
34
  return sum * fl;
35
}
36

37
template <typename T>
38

39
inline void write(T x) {
40
  if (x < 0) putchar('-'), x = -x;
41
  static char sta[40];
42
  short top = 0;
43
  do { sta[top++] = (x % 10) + 48, x /= 10; } while (x);
44
  while (top) putchar(sta[--top]);
45
}
46

47
// 坐标为 i，求 l~r 的距离
48
inline ll dis(ll i, ll l, ll r) {
49
  if (i < id[l]) {                         // 比所有人都左
50
    return abs(id[r] - i);                     // 那就冲到最右边
51
  } else if (i > id[r]) {                       // 比所有人都右
52
    return abs(i - id[l]);                     // 那就冲到最左边
53
  } else {                             // 我在中间
54
    return min(abs(id[r] - i), abs(id[l] - i)) + id[r] - id[l];   // 大家都要跑，具体看哪边开头更近我要折返一遍；全程都是要走的，不然无法覆盖
55
  }
56
}
57

58
int main() {
59
  t = read<ll>();
60
  while (t--) {
61
    n = read<ll>(), a = read<ll>() + 1000000000, b = read<ll>() + 1000000000;  // 全部加上 1e9 变成非负数
62
    if (a > b) swap(a, b);
63
    FOR(i, 1, n) id[i] = read<ll>() + 1000000000;
64
    sort(id + 1, id + n + 1);
65
    mn = min(dis(a, 1, n), dis(b, 1, n));  // 我不管别人跑完全程
66
    FOR(i, 1, n) {  // A:1~i B:i + 1 ~ n
67
      mn = min(mn, dis(a, 1, i) + dis(b, i + 1, n));  // A 一段 B 一段
68
    }
69
    write<ll>(mn), putchar('\n');
70
  }
71
  fwrite(obuf, p3 - obuf, 1, stdout);
72
  return 0;
73
}

展开收起

时间复杂度（单次）就是排序和遍历枚举的复杂度 O(nlog⁡n+n)O(n \log n + n)O(nlogn+n)，相当于就是 O(nlog⁡n)O(n \log n)O(nlogn)，可以过。

AC 记录~

理解万岁！

Edge 浏览器游寄

Sun, 07 Jun 2026 19:08:29 GMT

【多图警告，体积已尽量优化，如怕耗费流量请在 WiFi 环境下阅读】

Edge 浏览器？这有啥可游的出了多少年了。

其实是 International English Language Testing System--->IELTS--->Internet Explorer Long Time Support--->IE 长期支持版--->Edge 浏览器。能从 Language Testing System 扯到 Long Time Support 绝对是 Linux 玩多了。

Edge 不就是 IE 生命的延续吗（认真

页面链接是 Journey to the West （《西游记》的英文名）IELTS。

貌似是最后一波纸笔了（今年第四季度及以后就没了），借机缅怀一下。

闲话——搞这玩意儿干啥？#

TL;DR：考着玩儿

我们家不是顶级富豪——至少不会请 1v1 家教、人住在郊区、没有房。再加上个人喜好等原因，反正没有也很难有出国留学的想法没有房，国内吸引力不足，存在移民倾向，签证都过不了（虽然但是签证官应该也知道“贫贱不能移”吧）。搞升学的话明显科技类优势更大（见本站其它文章），综上用处直接作用没那么大。

但幸运的是爸爸妈妈肯在教育上砸，再加上积木鱼自诩搜索利用资源并自学能力不错，小学阶段成就结算：

二三年级：CEFR A2（IELTS 3 分左右），在二上英语创造了全满分的奇迹（虽然小学二年级只要不跟 @毕导做同桌就都很简单就是了），但是没去考试，不过足够说服三年级老师让我当英语课代表了（对的，仅仅是为了装说到自己在备考，然后老师：在能力上。。。）。

四年级：CEFR B1（IELTS 4 分左右）。冒着被隔离的风险（最后被迫合法逃了两天课去了澳门参加 Preliminary English Test(PET，貌似已经改名叫 Preliminary for Schools，但这里仍然使用老办法)，并取得了阅读接近满分的成绩。虽然差 1 分上优秀吧，剑桥的平均分技术差评！。从此以后养成了吃薯饼的偏好并首次使用了浴缸（虽然不是很会）（？

五年级：CEFR B2（IELTS 5∼65 \sim 65∼6 分。首次去了 CX 考点考试（First for Schools/First Certificate in English，FCE），被口语的 partner 全方位碾压了（但是口语分数仍然是四项最高），写作甚至不及格（停留在 Level B1），不过好歹是及格了并且搞到了不写英语作业的特权（感谢剑桥的平均分技术！必须好评！！！）。。。养成了去某店吃煎饼果子配豆腐脑的习惯。

Caution

这里有必要引入校内公认乐子 Farris，我五年级搞 FCE 它六年级搞，我搞编程它也搞，甚至这几年网名都跟我格式一毛一样就改了个英文名……（好在我改名了），但就是综合竞争力没我强、同学们不喜欢。

但是非常奇怪的一点是它英语校内可以经常性比我高。。。不知道是不是我从小搞剑桥系口音偏英式的原因（自认为英音腔比美音好听）。当然我不否认也有我自身的其它原因，但是这确实好气哦 <_>。

Farris 最近转西班牙语去了并且也搞到了 B2，英语貌似暂停了，听他样子是准备转市外国语体系了，Bye Bye!

初一的时候认识了 IELTS 8 分的 Celyne 老师，竟然第一轮考场作文就把我的能力筛出来了，最后以听力第一完形第一阅读第一填空第一匹配第一语法第一作文第一（14.5/1514.5/1514.5/15）的神仙成绩拿到了单科 & 月考总分的年级第一。

注：这里给一些校内实战数据：一般情况下的英语卷子（不含窄西省特色：生活就像海洋，只有意志坚强的人才能到达彼岸听说） 101010 道完形（每题 111 分）+ 333 篇阅读理解（5×3=155 \times 3 = 155×3=15 题，每题 1.51.51.5 分）+ 555 道短文填空（666 选 555） + 555 道材料匹配（也是 666 选 555，但是每个材料最多 333 句话）+ 101010 道语法填空 + 111 篇作文（满分 151515），不含作文的话 20min⁡20 \min20min 可以做完且全对。目前最快记录是八下期末考，不含作文 7min⁡31s7 \min 31 \text{s}7min31s，属于是批发商了。

初二的时候神仙学校既换同学又换老师了，Celyne 去教了我年级另外两个班，但我们还保持着秘密联系。

本来想着 FCE 够使了初中不管英语了，但是后来听培优课的时候发现自己的口语能力衰没了（你这半衰期也太短了），遂主动提出要去提升（埋下伏笔。

笑话一则：其实我学的根本不是英语，而是一个不能念出来但是可以正常输入的积木语。

去小学搞英语的机构继续弄，测了 CEPT（Cambridge English Placement Test，没错又是你剑桥，只测了听力阅读，满分 505050）成绩记得是听力 434343 阅读 474747），竟然没掉 B2。

鉴于已经这个级别了再去考对标 CEFR C1/IELTS 7.0~8.0 的 Advanced in English（CAE）意义不大，不如直接考 IELTS，认可度要高很多。由于底子不差，所以跳过目标 5.55.55.5 的初级班直接进入目标 6∼6.56 \sim 6.56∼6.5 的中级班，据说省了大几个 W 学费。

此外上课上到快结束的时候突然说 IELTS 纸笔要没了改成全面机考（相关链接：官方公告）很多人不适应，而纸笔分会高一点（尊嘟假嘟？不是有评分标准吗？（我打字不是挺快的吗（，被逼着报了一场，结果赶上口语换题季有 111 位同学不幸躺枪（好吧他在考前 111 天搞到了回忆版题库

考前上课，上到一半口语单项和总分都是 8.58.58.5 的神仙老师离职了（？还有隐藏款剧情？

抽了 333 个同学，配上四个高级班（目标 6.5∼76.5 \sim 76.5∼7）老师新建了一个 VIP 班（然后这个班中又有 1 个人上了一半儿离开了，但是就我一个人是分校的分校，跟总部大佬比起来拉完了（

不过我好像成绩也最好哎

直接晒模拟的成绩单吧嘻嘻（正式考试的成绩在全文最后面；顺便搞到了第二次写作的小分：TA(TR)/CC/LR/GRA 大小作文都是 7/7/6/6；两次都是在 VIP 班测的并且貌似是第一）：

成绩单

对的阅读冲到了 8.58.58.5！感觉我总分能上 777 哎。

IELTS 能整到这个程度给任何级别的学校和公司来看都足以说明:

我的英语水平极强，基本干啥都行
我的学习能力也很强，再不济也可以过去教英语

反正学生阶段其实干啥都行了，据目前了解通过同等学力人员申请硕士学位英语水平全国统一考试申硕都够够的了（好吧憋不出来论文，也没有考试资格，没准能试一试入职学校（？。

upd on 2026/08/08：

算了一下：我去教 1v1 的听力和阅读，按照每个小时 ¥200 来算（不贵吧，一堆要价三四百的），每节 222 小时，每天 666 节（我能肝），合计 200×2×6×365=876000200 \times 2 \times 6 \times 365 =876000200×2×6×365=876000，即八十七万六千元每年，即使算上各种神秘因素五六十万还是有的——但是这 TM 是我们家年收入几倍了。

那还上个 der 学，打工创业去。

另外我最近发现我在使用英语的时候已经可以抛下中文的转接层了，并且可以较为流畅的使用英文版的 iPadOS、Windows、VSCodium、微信等产品，属于梦到啥说啥跟母语一般了，不用再翻译成中文卡 bug 了。

人话：

同学：为啥这么说/选/写？

答：因为我感觉这么说是对的。

因为你不这么整我难受，我别扭。。。

因为不这么搞我弄不出来。。。

因为你不这么选你还能咋选？

做题丧失理性，全面拥抱语感想到到哪儿说哪儿。

于是最近闲着没事儿学点儿法语、世界语之类的东西。

Bonjour, Français!

Saluton, Esperanto!

Day1 考口语#

考点是熟悉的 CX，06 月 01 日儿童节（星期一，后来据悉貌似 A 类有星期一到星期三三天随机抽一天，G 类都是星期一）当天 09:20 的测试，对于住在到哪儿都要一个小时的某郊区还没有车的我们来说简直要命（为啥骑着电动车甚至走路就能到考点的总部大佬是 09:40 场的 /kk。

谁告诉你“城市核心地区”就交通便利了？

听说未成年人会发如图所示的小黄鸭：

大概就是这个东西

但是为啥 CX 考点没有啊啊啊差评，据说不用（埋下伏笔。虽然说穿着校服（被问是高几的了）但是老外考官他不！认！识！啊啊啊啊！

人不是很多，但是检录室离厕所太远了差评。负责检录的老师（记为 X，下文会反复提及他）给我身份证上贴了神秘条形码（上面有我的考号，本来想着纪念的但是下一周生地会考实验操作的时候撕了）。剩下就是经典的指纹、拍照、签字等环节。

如图所示

虽然是纸笔考试但是口语已经变成了跟不知道在哪个大洲的考官连线（细节用的是 Edge 浏览器），匹配了两分钟左右（怪紧张的。。。，跟其他人比起来竟然还算是比较久的了。考场发铅笔和纸用于 Part2，但是不能带出考场（

结论是体验极差，基本不能正常沟通，Part 1 被考官反复强调题目弄得我离题万里一样，最后只能回答 Yes。Part2 撑了不到 1min⁡1 \min1min 除了开头基本没有完整的句子（题目：描述一个擅长做计划的人。。。这 TM 是我练过的原题！但是我是 P 人根本没有计划，导致每一次都不知道咋说（。

合着 IELTS 卡性格、卡 MBTI

Part3 也没好到哪去，摘取两道题：

你觉得做计划对婚礼有啥用？
你觉得做计划对青年在选择职业时的考虑有啥用？

啊我吗，研究婚礼？你看我来这儿考试像是只能去技校/中专考不上高中所以现在就要赶紧做职业规划的样子吗？

要不你现场找一个，或者咱俩先领证你先带我走遍婚礼的流程。

最后快要超时了被马上叫停了。而且总共考试不到 20min⁡20 \min20min 所以赶回学校还在上上午第 444 节课（我校上午 555 节下午 333 节）。没逃过课、没逃过作业，要似了。考前一晚上白瞎刷题库了。

成就结算

但是和之前 OI 界的一位好友沟通（能力如下，之前的小黄鸭图片就是他拍摄的；目前他人在 BJ，但是有 HK 的户籍而且要转过去了，之后联系会方便很多，祝好）：

他的分数

他的模考

图中某积木鱼听力虚报差评（光速逃。

两个白男（可能是一个吗？）的 PK

Day1.99 笔试前一天#

？为啥准考证上没写时间啊？

upd on 2026/06/21：其实是写了的。

然后找到了这个

What the f**k？07:30 到？劳资就近入学也就 07:30 到教室啊？但是这个自行车车程只有 10min⁡10 \min10min 你 SEG 要开汽车/坐地铁将近 111 个小时啊？

当时积木鱼的心情如图所示

都怪洋人发明了 IELTS 害我 07:30 就要到考场。我要洋人死！！！嘣嘣嘣嘣蹦蹦，嘣嘣嘣嘣蹦蹦，在光绪二十六年，神助拳义和团，扶清灭洋，55 天在。。。

要带什么东西也没说？不带文具的吗？索性 2B、HB、中性笔全带上。这波差评（

注：后续回旋镖了（逃

幸亏是考试前一天 zuo 死不写周末作业看的。

Day2 考笔试#

Day 2.0 路上#

Day2 是 2026 年 6 月 6 日星期 6，据称是几百上千年一遇的传奇（巧了我生日也是这样的传奇日期：大家猜一下？）。

今天是个好日子，心想的事儿都能成，今天是个好日子，打开了家门咱迎春风。

最后跟正常点差不多起床，但是 07:30 才收拾好准备出门，反正 08:30 才停止检录去那么早也是堵着。路上听着 B 站大佬翻的歌（由于歌品几乎没有就不放清单了。该说不说 Bilibili is undoubtedly the best website(app) for music.

然后听一半突然想起来自己是去考英语的了，遂请求听一个听力的题目磨耳朵。但是谁家好人一个听力音频的压缩包 470M 啊啊啊。最后压根儿就没传完，也就没听上，真就摆烂了呗。

Day2.1 入场#

把手机还给妈妈了（伏笔），正常进场。但是文具都不让带，白准备那么多了（

一共 212121 间考场给我排到了 Room 19\text{Room 19}Room 19，发了一套牌子用于标记寄存的个人物品，一个绑在上面一个自己拿着。

去检录，还是 X，不用做生物信息录入了（好像也有一间另外的屋子做，但是去的人不多我也就没管）。这次发了一个紫色的手环，以及，最重要的，小！黄！鸭！我才不会告诉你我差点把自己的行李牌落在那儿了。

好吧我是蓝色的。 But blue is my favourite colour without doubt!How lucky I was!

如图所示

可以看到积木鱼的猎奇手法快要把大鸭子贴到领子上了

话说鸭子下面的字感觉有点神秘似懂非懂的样子。

虽然但是笔试你发小黄鸭管个鸡毛用啊，难不成给我换一套简单的题吗？（其实是有用的，后面会讲到，虽然用处奇特

找到 Room 后二次安检（明明进场时做过一次了），但是考官全英操作（事实上她们一直在说英文，但是考生说中文提问她们也能给出中文回应）差点给我问懵了。不过比脸都干净的兜安全过关。前后两个人缺考，左边桌子是用来隔开人的空桌右边是过道，这下被四面夹击了（

原来文具（其实只有铅笔橡皮，但是有 IELTS 的 logo 并且是中国特供版（注意到图中的笔的网站域名里面有 china 字样，但是 .org 域名国内又不能备案注册它干啥？更合理的应该是 ielts.org.cn。）都给我准备好了啊，怪不得不让带。

两件套

China IELTS from the British Council!

但是此处援引退场后我听的某考生的发言：

我才知道原来雅思考试用的是铅笔。

Bon 不 jour 了（怎么还有法语）。

Day2.2 听力#

填个人信息的时候差点超格了，开局直接使用一次橡皮。与前面的考试不同，IELTS 要求是同身份证一样的名字因此按照中国人的习惯姓在前。

同 PET 一样发放耳机利用电台之类的高精尖技术放听力。试了两遍音，音量可以自己调节好评。上次来 CX 考试直接用电脑外放，但是据说之前施工导致有 1mol 人没听清没过。

貌似 A 类 G 类同一套题所以比较简单，基本上每个题目都听出来了。

汇总一下：

Part 1：标准的 100%100 \%100% 填空题，是一个女生商量健身的事儿。

Part 2：某区文化/博物馆（记得是个 gallery）建设，一道地图（两层 777 题）+ 333 道单选。

Part 3：学生研究的神秘课题：宇航服（刚好学校在学 Space 相关，埋下伏笔）与其特点匹配 + 222 道双选。

Part 4：某位意大利（好像是）音乐家的事（莫名记得的背景信息：要办一场这个音乐家的歌曲的音乐会了，所以老师给大家普及一下这位爱用小众高难度乐器使用技巧的 dalao 知识），依旧标准的 100%100 \%100% 填空题。

Part 切换之间还给了检查时间，因此读题时间还算充裕。

最后 10min⁡10 \min10min 填答题卡的时候空余时间略微难熬。此处强烈谴责耳机大小，考完听力要摘下来收回去（明明考 PET 甚至允许你带回大陆的），耳机太小了耳朵疼。。。不过阅读了几分钟就好了。

Day2.3 阅读#

阅读和听力用的是同一张答题卡（但是貌似不允许你往回翻，跟不允许提前阅读题目/文章是类似的，需要重新填写信息），但是分正反面。记得是听力蓝色、阅读绿色（也可能是反过来）。用 PDF 展示带考点编号（CN 的 2 号！澳门的 PET 是 MO 的 3 号！）之类的答题卡填涂模板中评（？。另外 PDF 上的信息貌似不是固定的，例如写作为什么是 11<01> 开始。。。

这会 A 类一套卷子 G 类另外一套了，所以要填涂自己是 A/G 类。直接把那个方框全给劳资涂黑即可，不要打勾啥的。似乎大部分人都是 A 类（虽然纸笔当中这一场是第二季度最后一场 G 类了，月底还有一场但是只有 A 类）。

同样贴一下题目信息：

Passage 1：记录文，讲述的是两位澳大利亚大佬带着两个美国助手在一位加利福尼亚人的赞助下（没错第一题是判断题：给他们买飞机的人是个美国人）历经风浪完成了人类历史上首次由美国成功飞到澳大利亚，然后被赞助人送了飞机、美国总统发了贺电的事（最终两个美国人回国了，这两个澳大利亚人分别在尝试突破某飞行记录和尝试复刻这次旅程的过程中牺牲）。前面是判断，后面忘了，似乎是单选。

Passage 2：说明文，简介了某种日本陶瓷（是瓷器还是陶器忘了）的一些知识（温度、设备、历史、起源地、地位、传承人和他的故事。。。全部融于一文！）。考了最不擅长、最懵 13 的标题匹配，剩下的考了判断还是个啥东西。

Passage 3：讲对集体是否能提高工作效率的研究，并介绍了两个实验：一个是观察测量发现似乎纤夫一起拉东西的时候出的力比自己一个人的时候出力更少；另一个是把一堆受试者对照实验，让他们完成一项电脑任务，但是第一组啥也不说第二组说要和组内平均分比较，结果发现第二组成绩显著优于前者。第一部分的题目是带有 NB 的 555 个专家和观点匹配，后面出了填空，似乎还有单独的一道单选。

阅读跟听力一样，感觉能上 999 分。基本都会，水爆了。

Passage 3 有一道填空题把 separate 填成了 seperate 但是被发现了，对照原文后决定改过来。本来以为是英美式，事后查询发现 seperate 是我记错了很长时间的经典错误拼法。

填空题一定要抄！

另有一道题发现根本没有答案了，最后在可能的答案区间反复寻找了唯一合适的形容词（词性也要合适鸭）塞了进去。

最后强烈谴责两个成年人为什么开始收卷了还在写，最后她们俩拿身份证去登记了并收获一次 Warning。有点同情，但是依旧谴责。

同样需要谴责的还有读到一半打雷了（

Day2.4 写作#

大小作文两张答题卡，小作文是红色的大作文黑的。同样要涂黑自己是 A 类，都要填涂个人信息，两张正反面都要填涂考号。

打开题目 Part 1，迎面一道地图题，方向指针指向北（此处强烈谴责不讲天理的地理考试中方向随机乱指就是不竖直的逆天方向标）。

但是该大学总务处貌似贪污（cos 和珅）摸鱼去了，101010 年内除了砍了点树、建了一个机房、扩大了一下音乐还是哪个学院的教学楼之外啥也没干。不过最后利用空行式分段 + 纸笔考试不显示词数蒙混过关（虽然我不觉得我已经颓到 150150150 词都扯不到了）。不过差点整段写错，幸亏是铅笔擦了还能补上（不过如果是机考更改要方便很多）。

笑点解析：有一条小路直通火车站（train station\text{train station}train station），但是因为在学天文相关的东西所以差点写成了 space staion\text{space staion}space staion 空间站。太空电梯，冲出地球，走向宇宙。

Part 2 怪有意思的一道题：很多国家已经颁布法律禁止开车时使用手机，但仍有不少司机明知故犯。请问原因是什么？最好的解决方案（应该只能要 111 种）是什么？

为了达到字数 + 自己本来习惯性的头脑风暴扯到了 333 种方案，好在最后圆回来了——形式多样，本质如一，思想相同。。。

求求了多给点分吧。。。

Part 2 最后答题卡快写满了。这种需要大段修改的情况其实机考要方便很多而且还不用担心我逆天的书写。

其实 Part 1 略微超过了 20min⁡20 \min20min 的警戒线，当时看到有人 Part 2 都快写了一面了给我人干懵了。。。结果这哥们儿先写的 Part 2，考试结束了也没写完 Part 1。合着整了半天诈我来了。。。

Day2.5 出场#

收完卷子和答题卡就算笔试考完了，没有人获得 Second Warning。老师巡查全场（我们考场两个监考一人一半，我正好分配到了安检我的那位），撕掉右（左）上角的考生信息卡（注意自己考试过程中撕会被 Score Cancelled/Disqualified，如果缺考的话老师也会帮你撕）、剪掉紫色手环。笔和橡皮竟然可以顺走，但是耳机和试卷当然不行。

拿到行李后要把行李牌重新扣成一对，但是积木鱼手笨不知道该咋扣，遂请求工作人员，然后靠着小蓝鸭免去了嘲讽:)

据称是最后一场纸笔了（其实并不是，暑假还有机会）所以人特别多，怪挤的。

走到上次口语出去的电梯那儿，但是被 X 拍了一下肩膀然后把我赶走了，差！大！评！

挤了半天电梯出去后发现找不到浮木了，跑到旁边店铺申请借手机打电话但是被一口神秘方言拒了（？差评。

绕了一圈跑到另外一家成功获得了联系，然后冒雨跑过去吃煎饼果子配豆腐脑。街上怪冷清的，除了煎饼果子和一家糖水之外基本都倒闭了……

Day2.6 回家#

去立体停车场取车，但是神秘帕拉梅拉车主卡住了把停车场设备干废了:)

补作业去喽（大悲 T_T

Day3 等待出分#

正常上学、偶尔写写这篇游记。考了生地会考的实验操作和体育与健康通识，555 分的会考分和 222 分的中考分就这样轻松到手了。

感受？最开始还想着每天去打卡查一查没准跟 CCF 一样突然就给我闪击出分了呢？

后来也就这样了，日子该咋过咋过，反正考成几分儿不重要。

好吧其实过了一周到了查分的那一周还是挺紧张的，又几乎每天打卡登录 114514114514114514 次（NEEA 网站时间登录存续时间太短了）。。。

出分前一天做了个噩梦：梦到查分结果了，结果一个还不错（记得是 9.09.09.0？），剩下的一个 6.06.06.0 两个 3.03.03.0（？只有 3.03.03.0 会去考雅思？），合计总分是 5.55.55.5（有意思的是尽管在睡梦中积木鱼的计算结果也是正确的——没错梦里梦到的总分正好是 5.55.55.5）。

Day4 出分#

出分当天正好是 618 哎！

BC 你是会选日子的，一个个的都给我出这个（而且第二天还是周五又赶上端午假~）。

我校这一周 12:05 放学，虽然暴雨橙色预警了但是仍然紧张的飞奔回家。

然后发现跟之前一样，网站没有半点儿反应。

气炸了，被诈骗了。难道真到要 101010 个还 TMD 是工作日吗（心累，毕竟后面可都是假期啊……？

不过所在市其他地方发布暴雨红色预警了可以停课了，中午回家同学这波得了 MVP 两次（嗯没错周二也停了一下午）。

然后下午边摸鱼边写不完整但依旧体量庞大的端午作业，14:40 不到跑回去看了一下：

出分了！

听力 8.08.08.0（破纪录了！），阅读 8.58.58.5（与个人纪录持平），写作 7.07.07.0（破纪录了！我那个大作文能给我上 777？）、口语 5.55.55.5（……emm 竟然还有 B2 等级其实我也挺 NB 的了），总分 7.57.57.5（也破纪录了！！！）CEFR Level C1！

初中段首考出分 7.57.57.5 我 TMD 是神仙！！！woc 我 NB ！全体起立！

这个心情，真的，我用母语中文都 TM 词穷了，无法形容。

真的，疯了一下午。

虽然是弱 7.57.57.5 但也很知足了（突然发现没有四个 777 好使甚至 4 个 666 都不如，悲）

笑点解析：

本来妈妈想着初中阶段冲到 6.56.56.5--->模考几次后决定这一次保 6.56.56.5 冲 777，高一冲 7.57.57.5，大学再去弄 888--->初二一遍 7.57.57.5 完事儿了
积木鱼用中级班的课程考出了高级班的成绩，哎，又省到了。积木语特色：鼓足干劲，力争上游，多快好省。
其实我自认为再考一次大概率每一项（口语除外但也很难保证超过去）都达不到这个成绩。
据称我们班的那个老师 IELTS 也是 7.57.57.5。7.57.57.5 的成绩理论上可以回到教我的机构机构教课恰钱了。老师，我毕业后可以留校吗

【前方多图预警，由于截图时间原因深浅色都有，望谅解】

与妈妈的通话，似乎混入了神秘烤绿鸟

妈妈的高延迟回应

与老师的报喜

甚至问了 AI

依旧发朋友圈

神秘人的肯定

AI 广告差评，但是积木鱼全国前 4%4 \%4% NB。给 DS 分析然后被建议申请￥1400 的复议了。积木鱼：你不知道我口语考场说说的啥吗？这么明显的差距 BC 那边已经复核过了吧。

在网上到处寻找，6∼6.56 \sim 6.56∼6.5 就算“上岸”了，7.07.07.0 就是可以分享经验的高分了，而且除了 8.58.58.5 以上的大手子之外所有人至少有一个单项比我的该单项要低。

例如说梦中情校 MIT 的 CS 博士项目语言上只要总分到 7 即可大家觉得我能进去吗，剑桥本身的要求也就是 4 个 7.07.07.0 总分 7.57.57.5。事实上这个分数只要不卡单项分（或者单项分要求在 5.55.55.5，更低的没见过了）都是随便进。考了这么多剑桥考试了申个剑桥玩儿玩儿。

不过神奇的大雨导致航班延误了，官方成绩单第二天才送达。

第二天收到了正式的 Test Report Form，成绩与此一致，CEFR Level C1，安全下车。正面写着信息，背面是对不同等级的描述。

但是为什么感觉拍照片的时候我的表情跟那什么 Donald.J.Trump. 有点像。

IELTS 的事情也就告一段落了，虽然口语依旧是短板，不过确实是有一点儿提升了，其它的模块直接出去库库乱杀即可。

不过貌似过了一段时间来看，貌似心里怪平静的没啥感觉了？反正一时半会儿没啥大用，就这样吧。

Day 5 后续#

以下均编写于 2026/10/11。

如果我出分 6 分或以下，我会复议/重考。

如果我出分 6.5，那我估计就算了，勉强接受。反正隔壁跟我一块学的本部和市中学大佬也都 6.5。俺们郊区野路子能平起平坐也不错了。

如果我出分 7，那我要好好庆祝一下，这次发挥非常好。

但既然是 7.5，那这事儿它性质就变了。原来没有留学的计划，但现在发现把语言解决后路走的宽多了，且学校也与 HKU 等港校关系不错，每年单 HKU 就稳定送个十几人（要知道对于我们只有 510510510 人每届的高中部来说这已经是差不多 2%2\%2% 了，对于单单一所大学来讲算是超大比例了，除了地理原因的中大华工很少有这么抢手的）。

在解决完语言屏障后，叠加竞赛的优势，个人认为上个港三新二去跟清北对阵还是很有希望的。考虑到 OI 本身在强基考察中没个 der 用，个人认为这是本科超车的好机会。

无论如何，前方通天大道宽又阔。莫名有种外面从来就没下雨的喜感。

另外雅思成绩单更新了，新增了一个 Ofqual Regulated 标记，我申请了更新，和没有标记的（虽然按照官方说明已经失效相当于是寄了）一块藏着。（u1s1 快递员能在一堆英文中找到我们家地址还是太强力）。就是申请查看小分至今没有结果。

后续也看到诸如作弊、泄题、突然终止考试之类的，不过没波及到积木鱼这场。那就踏实摆烂了，跟我没关系那就于我如浮云。

结束了，我赢了，很彻底。

题解：P5691 [NOI2001] 方程的解数

Sat, 02 May 2026 10:31:53 GMT

闲话#

与题解无关，可以略过。

好久没更新了呢小 L （好吧为了避免暴露年龄现在在改网名了，新名字：Block_Fish，也可以叫积木鱼，此处感谢同学们和语音输入法的贡献）期中烤尸疑似重新回到了年级第一。

我才不会告诉你改 LG 用户名的时候打错了然后只能 2027 年再改了 QwQ。

目前在把博客切换成 Astro + FireFly 的配置，迁移的时候顺便修一下以前文章的错误和低质量内容（积木鱼文章最大的特点就是顺其自然真情流露想到哪儿写到哪儿~）。

再见 Hexo！（以后积木鱼也会更文聊聊为啥要连框架都换了）。

思路分析#

正文从此开始。

150150150 的数据范围，又都是整数，确实可以想到枚举/搜索。

然鹅 1506=11,390,625,000,000≈1.1×1013150^6 = 11,390,625,000,000 \approx 1.1 \times 10^{13}1506=11,390,625,000,000≈1.1×1013 绝对 T 飞了。

但是我们发现 1503=3,375,000≈3.3×106150 ^ 3 = 3,375,000 \approx 3.3 \times 10^61503=3,375,000≈3.3×106 稳稳得可以过。而复杂度指数上的砍半可以通过折半搜索来实现。

具体来说，我们只搜一半，例如前 n2\dfrac{n}{2}2n 项。枚举完这么多之后得到的结果放进一个 map 里。后面的项同样枚举得到一个结果 retretret，然后为了使整个式子的值是 000，即方程成立，我们只需要加上前面取 −ret-ret−ret 的方法数即可，而这个东西可以直接从 map 里读。

由于前后两次是分开进行搜索的，所以总的复杂度（忽略较小的 map，更何况 unordered_map 可以 O(1)O(1)O(1)）就是 O(2×nm2)O(2 \times n^{\frac{m}{2}})O(2×n2m)，忽略常数 222 之后最坏也就是 1503150 ^ 31503。

具体实现可以看代码。

代码#

个人感觉比你谷题解区里的都要清楚易懂一些。

1
/*Code by Block_Fish*/  // 积木鱼依旧冗长的板子
2

3
#include <bits/stdc++.h>
4

5
#define log printf
6
#define EPS 1e-8
7
#define INF 0x3f3f3f3f
8
#define FOR(i, l, r) for (int i = (l); i <= (r); ++i)
9
#define IOS            \
10
  ios::sync_with_stdio(false); \
11
  cin.tie(nullptr);
12
#define Buffer 1 << 23
13

14
char buf[Buffer], *p1 = buf, *p2 = buf, obuf[Buffer], *p3 = obuf;
15
#define getchar() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, Buffer, stdin), p1 == p2) ? EOF : *p1++)
16
#define putchar(x) (p3 - obuf < Buffer) ? (*p3++ = x) : (fwrite(obuf, p3 - obuf, 1, stdout), p3 = obuf, *p3++ = x)
17

18
using namespace std;
19

20
typedef __int128 i128;
21
typedef long long ll;
22
typedef pair<int, int> PII;
23

24
const int N = 10;
25
int m, n, ans;
26
PII x[N];  // 积木鱼习惯把相关的两个数存进 pair 里
27
unordered_map<int, int> mp;  // mp[x] = y 表示取 x 的方法有 y 种；只需要读取和存入，可以 unordered
28

29
template <typename T>
30

31
inline T read() {
32
  T sum = 0, fl = 1;
33
  char ch = getchar();
34
  for (; !isdigit(ch); ch = getchar())
35
    if (ch == '-') fl = -1;
36
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
37
  return sum * fl;
38
}
39

40
template <typename T>
41

42
inline void write(T x) {
43
  if (x < 0) putchar('-'), x = -x;
44
  static char sta[40];
45
  short top = 0;
46
  do { sta[top++] = (x % 10) + 48, x /= 10; } while (x);
47
  while (top) putchar(sta[--top]);
48
}
49

50
int power(int x, int y) {  // 快速幂
51
  int ret = 1;
52
  while (y > 0) {
53
    if (y & 1) ret *= x;
54
    x *= x;
55
    y >>= 1;
56
  }
57
  return ret;
58
}
59

60
void dfs1(int now, int sum) {  // 前一半的搜索
61
  if (now > (n >> 1)) {  // 前一半搜完了
62
    ++mp[sum];  // 计数
63
    return;
64
  }
65
  FOR(i, 1, m) dfs1(now + 1, sum + x[now].first * power(i, x[now].second));  // 往下接着搜，记得代数
66
}
67

68
void dfs2(int now, int sum) {  // 后一半的搜索，跟前一半差不多
69
  if (now > n) {
70
    ans += mp.find(-sum) == mp.end() ? 0 : mp[-sum];  // 搜完了，如果前一半没有这个东西那就是 0 种方法，否则就是后一半结果的相反数；每种方法都是独立的，所以是加法
71
    return;
72
  }
73
  FOR(i, 1, m) dfs2(now + 1, sum + x[now].first * power(i, x[now].second));
74
}
75

76
int main() {
77
  n = read<int>(), m = read<int>();
78
  FOR(i, 1, n) x[i] = {read<int>(), read<int>()};
79
  dfs1(1, 0);  // 初始时 sum 当然是 0
80
  dfs2((n >> 1) + 1, 0);  // 注意从后一半开始搜
81
  write<int>(ans);
82
  fwrite(obuf, p3 - obuf, 1, stdout);
83
  return 0;
84
}

展开收起

AC 记录~

理解万岁！

一个小众又有趣的协议——SATA

Sat, 11 Apr 2026 11:39:08 GMT

关于 SATA#

你可能会注意到，积木鱼和 OI Wiki 都采用了一个叫做 SATA 的逗逼小众协议。

zTrix

sata-license

The Star And Thank Author License(SATA License)

—

NOASSERTION

Unavailable

注意！

这里的 SATA 不是硬盘方面的，而是指一个叫 “The Star And Thank Author License” 的许可协议。

这个协议基于著名的 MIT License，因此和 MIT 协议一样，极为自由（应该是符合 FSF/GNU 之类的组织所定义的“自由”的）、宽松。

而 SATA 协议的不同之处，从它的名字中很容易看出来——你要去给作者点 Star 并感谢项目作者！

具体来说，如果你使用了这个开源项目，而这个项目又使用了 SATA 协议，那么你需要给这个项目点个 Star （例如 SATA 协议本身），并遵循 MIT License。

当然，不是每个项目都在 GitHub 上，因此你也可以通过以下方式表达感谢：

给这个项目挑 bug，让它变得更好
给作者发感谢信（？）
发篇文章（比如这篇）宣传一下该项目
如果实在害羞的话，你也可以不说出来，心里默默的喊一句作者好闪，拜谢作者！感谢作者大大得无私奉献！即可

还是非常宽松、自由的。在此也提醒一下大家（尤其是各路企业），开源作者无私奉献、默默付出又不求回报，其实是一件很伟大的事情。希望大家多多支持、感谢开源作者，哪怕只是轻轻的点个 Star。Said no more counting dollars, We’ll be counting stars.

题解：P12290 [蓝桥杯 2024 国 Java A] 基因组合

Wed, 08 Oct 2025 14:52:30 GMT

闲话#

Java 组的题当然要用 C++ 写啦。应管理员要求，已增加 Java 代码，Java 代码由 DeepSeek 将 C++ 代码转换而来，能够通过本题。

分析#

初读题目可能会感觉这是一个博弈论，然而事实是那一天的博弈博不起来。

为什么呢？

翻一下样例解释，因为只选两个基因，而异或具有交换律……

因此不存在什么先手后手的，反正换了一下也是一样的。

那我们只能考虑从基因入手。我们并不知道两个基因的任何情况，因此至少要枚举一个。

于是我们的问题就转化成了已知一个基因 AAA 和另外 n−1n - 1n−1 个基因，从另外的这 n−1n - 1n−1 个基因中选择两个 XXX 和 YYY，最大化 A⊕XA \oplus XA⊕X，最小化 A⊕Y A \oplus YA⊕Y。

而这个经典的问题可以使用 01-Trie 来解决。

什么是 01-Trie？#

Trie 就是传说中的字典树。我们建立一颗树，树上的每一条边都对应一个字母，因此从根出发到其它节点的某个路径就对应一个字符串。

我们一般用一个二维数组 trie[N][M] 来表示一颗 Trie，其中 NNN 是最长字符串长度，MMM 是字符集大小（即可能出现在字符串里的字符数目）。具体实现略有些抽象，可以结合代码理解。

标准 Trie 模板

1
inline int get(char c) {
2
  if (c <= '9') return c - '0';
3
  else if (c <= 'Z') return c - 'A' + 10;
4
  else return c - 'a' + 36;
5
}
6
/*
7
这个函数用来压缩字符集，将 '0'~'9' 映射到 0~9
8
'A'~‘Z’ 映射到 10~35
9
‘a’~'z' 映射到 36~61
10
当然你也可以不写函数直接用 ASCII 码表，但是这样 M 的大小是 127 而且会有很多浪费
11
*/
12

13
void insert(string &s) {  // 引用传参
14
  int p = 0;  // 指针，表示我现在遍历到哪个点上了
15
  for (auto i : s) {  // 遍历字符串，这种语法需要 C++11，比赛可用
16
    int z = get(i);  // 获取到映射的值
17
    if (!trie[p][z]) trie[p][z] = ++idx;  // 第一次加入这条边，于是给它所到达的那个点分配一个新的编号
18
    p = trie[p][z];  // 跳下去
19
    ++cnt[p];  // 记录这个点多了一个字符串，用于计数或者删除字符串的时候
20
  }
21
  end[p] = 1;  // 记录一下这个点是某个字符串的结尾而不是只是一个路过的
22
}
23

24
int query(string &s) {  // 和 insert 是类似的，这里是查询以 s 作为前缀的字符数量
25
  int p = 0;
26
  for (auto i : s) {
27
    int z = get(i);
28
    if (!trie[p][z]) return 0;
29
    p = trie[p][z];
30
  }
31
  // if (!end[p]) return 0;  // 加上这一行就是必须要完全相同
32
  return cnt[p];
33
}

展开收起

最后的的 end 数组是为了避免类似这样的情形：

输入：

1
luogu

查询：

1
luo

应该是找不到的，但是由于 luo\text{luo}luo 是 luogu\text{luogu}luogu 的前缀因此也能匹配上，于是我们记录到 u\text{u}u 的才是某个字符串的结尾否则就是中间不算的，当然如果题目就是要前缀那就无所谓啦。

模板 P8306

必须要完全匹配的 P2580（请认真练习，虽然我知道 unordered_map 可以水过去）

而 01-Trie 则是只会出现 0 和 1 的 Trie，字符集大小为 222。它可以方便的处理异或相关问题。具体来说，它运用的就是贪心思想。例如我要求异或值最大化，那么我们尽量让 0 和 1 两种边交错着走就好了，由于数字的大小优先比较高位因此这样贪心是对的，不会出现先走相同种类的边然后企图后续反超的情况。

01-Trie 有个小技巧就是建树的时候不要用 string 而是直接将一个数字传过去，然后利用位运算得到每一位的情况。注意为了方便计算我们一般会统一字符串长度为 L=log⁡2ML = \log_2 ML=log2M，其中 MMM 为需要建字典树的序列最大值，一般 M=109，L=30M = 10^9，L = 30M=109，L=30。更大的 LLL 可以适配更大的数字，但是常数也会增大。

01-Trie 模板

1
void upd(int x) {
2
  int p = 0;
3
  for(int i = L - 1;i >= 0;--i) {
4
    int z = x >> i & 1;
5
    if (!trie[p][z]) trie[p][z] = ++idx;
6
    p = trie[p][z];
7
    ++cnt[p];
8
  }
9
}
10

11
void rme(int x) {  // 删数，本题要用
12
  int p = 0;
13
  for(int i = L - 1;i >= 0;--i) {
14
    int z = x >> i & 1;
15
    p = trie[p][z];
16
    --cnt[p];
17
  }
18
}
19

20
int getMax(int x) {  // 求字典树任选数字异或 x 得到的最大值
21
  int p = 0, ret = 0;
22
  for(int i = L - 1;i >= 0;--i) {
23
    int z = x >> i & 1;
24
    if (cnt[trie[p][z ^ 1]]) ret |= 1 << i, p = trie[p][z ^ 1];
25
    /* 可以不同，那就不同；
26
    在左起第 i 位有一个 1，贡献是 1 << i，
27
    由于只有第 i 次遍历会对该位产生影响因此这里是二进制或，和直接加法是一样的
28
    */
29
    else p = trie[p][z];  // 否则只能走相同的路
30
  }
31
  return ret;
32
}
33

34
int getMin(int x) {  // 同上，最小值
35
  int p = 0, ret = 0;
36
  for(int i = L - 1;i >= 0;--i) {
37
    int z = x >> i & 1;
38
    if (cnt[trie[p][z]]) p = trie[p][z];
39
    else p = trie[p][z ^ 1], ret |= 1 << i;
40
  }
41
  return ret;
42
}

展开收起

回归本题#

其实上面的 01-Trie 讲完结合前面的思路分析就做完了……

直接用上面的 01-Trie 模板分别求最大值和最小值即可。注意求最小值的时候会出现 A⊕A=0A \oplus A = 0A⊕A=0 的情况，然后最小值 getMin 就会寄掉，因此要先暂时把 AAA 删除，然后查完再加回去即可。

注意小蓝会让最小值最大，小乔会让最大值最小，因此是对 getMax 取 min⁡\minmin，getMin 取 max⁡\maxmax，否则你样例大概是 0 7 之类的。

时间复杂度上，我们扫一遍是 O(n)O(n)O(n) 的，字典树查询时间复杂度是固定的 O(L)O(L)O(L)，但是我们已经将 LLL 锁定了，因此总的复杂度还是 O(n)O(n)O(n)。但是常数有亿点点大，不过这是 01-Trie 的通病了。

直接贴代码吧：

C++ ACCode

1
/*Code by Leo2011*/
2
#include <bits/stdc++.h>
3

4
#define log printf
5
#define EPS 1e-8
6
#define INF 0x3f3f3f3f
7
#define FOR(i, l, r) for (int i = (l); i <= (r); ++i)
8
#define IOS                      \
9
  ios::sync_with_stdio(false); \
10
  cin.tie(nullptr);            \
11
  cout.tie(nullptr);
12

13
char buf[1 << 23], *p1 = buf, *p2 = buf, obuf[1 << 23], *O = obuf;
14
#define getchar() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1++)
15
#ifdef ONLINE_JUDGE
16
#define putchar putchar_unlocked
17
#endif
18
#define L 31
19

20
using namespace std;
21

22
typedef __int128 i128;
23
typedef long long ll;
24
typedef pair<int, int> PII;
25

26
const int N = 2e6 + 10;
27
int n, a[N], mn = INF, mx = -INF, idx, cnt[N], trie[N][2];
28

29
template <typename T>
30

31
inline T read() {
32
  T sum = 0, fl = 1;
33
  char ch = getchar();
34
  for (; !isdigit(ch); ch = getchar())
35
    if (ch == '-') fl = -1;
36
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
37
  return sum * fl;
38
}
39

40
template <typename T>
41

42
inline void write(T x) {
43
  if (x < 0) {
44
    putchar('-'), write<T>(-x);
45
    return;
46
  }
47
  static char sta[40];
48
  short top = 0;
49
  do { sta[top++] = (x % 10) + 48, x /= 10; } while (x);
50
  while (top) putchar(sta[--top]);
51
}
52

53
void upd(int x) {
54
  int p = 0;
55
  for(int i = L - 1;i >= 0;--i) {
56
    int z = x >> i & 1;
57
    if (!trie[p][z]) trie[p][z] = ++idx;
58
    p = trie[p][z];
59
    ++cnt[p];
60
  }
61
}
62

63
void rme(int x) {
64
  int p = 0;
65
  for(int i = L - 1;i >= 0;--i) {
66
    int z = x >> i & 1;
67
// 一定是存在的，因此不用判断是否存在
68
    p = trie[p][z];
69
    --cnt[p];
70
  }
71
}
72

73
int getMax(int x) {
74
  int p = 0, ret = 0;
75
  for(int i = L - 1;i >= 0;--i) {
76
    int z = x >> i & 1;
77
    if (cnt[trie[p][z ^ 1]]) ret |= 1 << i, p = trie[p][z ^ 1];
78
    else p = trie[p][z];
79
  }
80
  return ret;
81
}
82

83
int getMin(int x) {
84
  int p = 0, ret = 0;
85
  for(int i = L - 1;i >= 0;--i) {
86
    int z = x >> i & 1;
87
    if (cnt[trie[p][z]]) p = trie[p][z];
88
    else p = trie[p][z ^ 1], ret |= 1 << i;
89
  }
90
  return ret;
91
}
92

93
int main() {
94
    n = read<int>();
95
  FOR(i, 1, n) a[i] = read<int>(), upd(a[i]);
96
  FOR(i, 1, n) {
97
    rme(a[i]); // 先删除
98
    mx = max(mx, getMin(a[i]));  // 最小值最大
99
    mn = min(mn, getMax(a[i]));  // 最大值最小
100
    upd(a[i]);  // 加回去，后面还要用
101
  }
102
  write<int>(mx), putchar(' '), write<int>(mn);
103
    return 0;
104
}

展开收起

上面的 01-Trie 模板把注释给的很详尽了，因此这里不做重复。

AC 记录~

Java ACCode

1
import java.io.*;
2
import java.util.*;
3

4
public class Main {
5
    static final int L = 31;
6
    static final int INF = 0x3f3f3f3f;
7
    static final int N = 100010;
8

9
    static int n, idx;
10
    static int[] a = new int[N];
11
    static int[] cnt = new int[N * L];
12
    static int[][] trie = new int[N * L][2];
13

14
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
15
    static StreamTokenizer st = new StreamTokenizer(br);
16
    static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
17

18
    static int readInt() throws IOException {
19
        st.nextToken();
20
        return (int) st.nval;
21
    }
22

23
    static void upd(int x) {
24
        int p = 0;
25
        for (int i = L - 1; i >= 0; --i) {
26
            int z = (x >> i) & 1;
27
            if (trie[p][z] == 0) {
28
                trie[p][z] = ++idx;
29
            }
30
            p = trie[p][z];
31
            ++cnt[p];
32
        }
33
    }
34

35
    static void rme(int x) {
36
        int p = 0;
37
        for (int i = L - 1; i >= 0; --i) {
38
            int z = (x >> i) & 1;
39
            p = trie[p][z];
40
            --cnt[p];
41
        }
42
    }
43

44
    static int getMax(int x) {
45
        int p = 0, ret = 0;
46
        for (int i = L - 1; i >= 0; --i) {
47
            int z = (x >> i) & 1;
48
            if (cnt[trie[p][z ^ 1]] != 0) {
49
                ret |= 1 << i;
50
                p = trie[p][z ^ 1];
51
            } else {
52
                p = trie[p][z];
53
            }
54
        }
55
        return ret;
56
    }
57

58
    static int getMin(int x) {
59
        int p = 0, ret = 0;
60
        for (int i = L - 1; i >= 0; --i) {
61
            int z = (x >> i) & 1;
62
            if (cnt[trie[p][z]] != 0) {
63
                p = trie[p][z];
64
            } else {
65
                p = trie[p][z ^ 1];
66
                ret |= 1 << i;
67
            }
68
        }
69
        return ret;
70
    }
71

72
    public static void main(String[] args) throws IOException {
73
        n = readInt();
74
        int mn = INF, mx = -INF;
75

76
        for (int i = 1; i <= n; i++) {
77
            a[i] = readInt();
78
            upd(a[i]);
79
        }
80

81
        for (int i = 1; i <= n; i++) {
82
            rme(a[i]); // 先删除
83
            mx = Math.max(mx, getMin(a[i]));  // 最小值最大
84
            mn = Math.min(mn, getMax(a[i]));  // 最大值最小
85
            upd(a[i]);  // 加回去，后面还要用
86
        }
87

88
        out.println(mx + " " + mn);
89
        out.flush();
90
    }
91
}

展开收起

Java 版 AC 记录～

为什么比 C++ 慢这么多。

再次提醒，本文有且仅有 Java 部分代码是由 DeepSeek 完成，其余部分均为真人原创。因为不会写 Java。

理解万岁！

CSP-J/S 2025 游寄

Fri, 03 Oct 2025 08:11:14 GMT

闲话#

鬼知道为啥拖到了国庆 Qwq。

延续去年的流水账且事无巨细、详略不当初赛 Day1 复赛 Day2 中间瞎扯随便纪年法传统。

去年 S 组骗了 2=，实际实力（口胡版）能勉强够上蓝钩虽然你谷分数线提高之后就不行了，J 组神秘第一轮挂分遗憾离场。

今年目标：

J/S 双过
J 组一等（300+，冲刺 AK）
S 组一等
进入 NOIP/WC

话说第三年参赛了要是 J 组一等奖都没有是不是可以寄了……

Day −∞-\infty−∞#

集训一暑假，其中不乏 NOI Plus 模拟赛（我至今也不感觉 NOIP 和 CSP-S 是同一个难度的）三紫一黑几乎爆 0 的、SCP 阅读程序作了半天最后完善程序用时不到 10 min 最终得分不到 505050 的、初赛模拟遇上原题忘得一干二净等失败案例，太 vegetable 了。

去年和老师混熟了，但是今年老师和特派员速度都不行啊，报名卡了好几天……应该不是某奇葩学校要把原来的班级重新打乱再次分班的原因吧（恼）。今年怎么还涨价了啊（恼）。

好消息是 GESP 七级 888888 分可以免 J 了。但是八级 73 分还是只能免 J 过于抽象，虽然成为了集团首个满级人类。申请 GESP，谷民说会显示 J 组报名但是没交费，虽然我这里没动静……好在暑假快结束的时候发短信通知通过了不用报名。

Day -1#

考点信息出来啦！这次浅圳市破天荒的设了两个考点（HL 中学高中部和它的 SX 初中部），其中一个食堂（高中部）是全市第一（虽然我免考用不上），但可惜我在初中部。为什么最西部的几个区和最东部的几个区都在初中部啊喂。分配到了神秘座位号 111 过于逆天（111 是小 L 的幸运数字吗？如果是就让我 1= 吧！）。

另外老师说新初一的学弟暴力两三个，应该不会被击杀吧（。

考试前 111 天找到某复习资料就着之前的错题开始复习。

为了练习 Linux 指令其实就是想 Touch Fish 用 VirtualBox 装了个 Arch Linux 玩，然后发现没建 EFI 分区直接重开，好在最后装上 KDE 桌面了吃上 Linux 了，就是太卡了（老机器装啥装，还虚拟机？）。

Day 1#

上午#

把暑假的错题拉出来复习，拉出昨天的 Arch 开始敲指令。

看了一下 J 组题目，当然比去年难，但是感觉还好，真要考也能过，就是混进了奇怪交互题。

下午#

为啥下雨了啊喂……本来想拍照的现在还拍个 der。

个人感觉校园环境不如我校（虽然今年刚勉强建好还没有完全修完……酒精灯一定要有酒精！），太老太破了差评！

指示牌标的不清（正常都是楼的第几层，它给我搞了个先上到这一层然后看哪一楼就在哪一块过于离谱）差评！

没有宣读考场规则差评！

给个五星差评得了。

第一眼（发卷，先扫一遍）：我艹这啥东西，我 Linux 指令呢（那我背的那么多算什么？装了那么久的 Arch 算什么？知不知道这个东西呀有多折腾啊喂？）？

第二眼（开始做了）：哦还好还好，数学题比较少也比较简单，Trie 字典树和线段树直接人工建树，任务分配题直接人工模拟……我是人机还是肝帝呢。

第三眼（看到完善程序 T2）：我艹这啥东西，又来个交互？

第四眼（看到阅读程序 T1）：哦还好还好，比较水，看懂了。

第六眼（看到阅读程序 T3）：我艹这啥东西？咋这么长？第二个函数写的啥玩意儿？

第七眼（看到完善程序 T1）: 哦还好还好，裸的 Dijkstra。

第八眼（快收卷了）我艹这啥东西？怎么这么多 Bug，答题纸不改了保答题卡（注：两者答案不一，以答题卡为准，除非答题卡扫不出来）！

……

这次长记性了，把答案记在准考证上带出去估分（嘘！），由于是以答题卡为准所以最后几分钟懵掉狂改的时候不管答题纸了把答题卡改了即可，应该不会逝吧……

笑点解析：中途被监考员拿起桌上的铅笔看了看，差点人要无了，好消息是又放下了继续考试，我确认我带的是普通 2B 铅笔扫的出来，因此答题纸无所谓。

回家的路上开始对答案估分：

先扫一遍，发现我艹这啥东西，怎么这么多不一样的？

于是关掉页面（逃），后续某小程序火速更新之后输入进去。

估分 60.560.560.5，通过初赛有希望。

Day 1.1#

看分数线，比去年分数线高了 111111 分应该还是稳过的，为啥大部分谷民都说今年简单因此比较悬啊，感觉历年 S 组差不多的。

你谷上一堆七八十求估分数线的，然后发现除了在你谷上我这个分随便过。

于是幸存者偏差（你谷版）：由于学术版禁止了相当大一部分的蒟蒻发言，因此洛谷发帖估分数线的多是 dalao，实际分数线会更低一些。

Day 1.2#

出分，60.560.560.5 一点儿不差。同时 GESP 衔接通过的消息同步到了 NOI 系统上，好耶！

Day 1.3#

保送优先晋级线出来了，62.562.562.5，差两分基本是稳过线的了，就差一个全国 1= 分数线了（注：GD 允许比分数线低 0.50.50.5 分的选手晋级，ZJ 会比国线低、GD 会比 ZJ 低……反正随便过）。

我就说幸存者偏差很明显吧（

Day 1.4#

通过某神秘渠道得知分数线是 52.552.552.5，然后当天晚上就在官网上实锤了，今年 GD 分数线和肺活量都很低啊，尤其是肺活量，憋气大赛掉大榜（

F 类（GESP） J 组只免了 85 人（有另外 8 只 dalao 免考了但仍然报了初赛还过了……），J 组参赛者 1.6w 人？S 组 9.3k？浅圳市参赛者 1.8k？。竞争压力过大……

反正过了就好。

后面蹲 S 组第一轮获奖分数线，然后忘记一等奖获奖比例是 20%20 \%20% 比优先线还低了……拿到了第三个 S 组初赛 2= 惊为天人……

Day 1.5#

日常低中部集训（碰上了学弟 hbh），发现作为全市前五的低中有个好处就是写 WHK 不会的时候可以直接向 dalao 求助然后发现 dalao 们忘记分类讨论翻车了。

打 LG 比赛，等级分涨到了 114811481148，咕值 100+44+55+22+20=241100 + 44 + 55 + 22 + 20 = 241100+44+55+22+20=241 上红了！

考前一周做了个 Div2.5 难度的 CSP 模拟赛（前两题对标 J 组前两题，后两题对标 S 组后两题离大谱……，100+100+25+15=240100 + 100 + 25 + 15 = 240100+100+25+15=240）。

话说为什么会有人 J 组题目做不出来啊，数据范围才 500500500……

Day 1.6#

此外发现所在的 GM 区好起来了，因为 SFLS 的高中园是考点就在 GM 区！中午考虑回家吃饭。

准考证一看发现 S 组这次考场号是 111……这不给个 1= 就抽象了吧……

J 组考场号是 222，但是为啥一个是 555 号楼一个是 131313 号楼……

后面又因为某神秘原因调到了 J 333 号楼，S 组 141414 号。

后面的备考就不用说了，努力地卷——whk，OI 上一题没动。（神人学校复赛前一天期中考逝啊，然后折腾半天告我说延期了……）

Day 2#

J 组#

去年有 5 级的实力了可惜初赛炸锅了，今年只有 1= 一个目标（其实想冲 AK 的，但是希望不大）。

先不看题，把头文件啥的写了，开 NOI Linux。

开题，T1 发现大水题秒了，手搓样例都没问题，14min⁡14 \min14min 后测完所有样例 AC。

T2 感觉是道数学找规律题（为什么我做 J 组都是找规律），然后一看 n,m≤10n, m \le 10n,m≤10……

于是：

1
// 赛后补注：这是 T2 代码
2
/*
3
Sort again?
4
Wait, n, m <= 10
5
So hai think ge ji mao, simulate is OK(Whose maths problem?)  // 赛后补注翻译：那还想个鸡毛啊，模拟就完事了。谁家好数学题混进来了？
6
Why does T1 & T2 == abc A again?
7
Everybody is different, so I just need to record the score to know who little R is
8
09:10, AC All 3 test cases
9
*/

……

9<10>，AC T2。做 T1 和 T2 的过程中偶然发现今年不再是熟悉的 i7-8700K，升级成了 Ultra 9 285K 传奇少爷机于是：

1
// 赛后补注：这是 T1 代码
2
/*
3
08:44, AC All 4 test cases
4
#Shang4Shan3Ruo6Shui4e  // 赛后补注：这是 J 组解压密码，一改之前的随机字符串出了个上善若水，但仍未知数字的意思
5
Intel Core Ultra 9 285K?传奇少爷机？ orz CCF is so rich!
6
So, when can CCF use IOI 赛制?
7
Ultra 9 285K 性能核都出来了，when can release NOI Linux 2.1?
8
*/

原来 CCF 涨价是有它的良苦用心的。这下不得不支持了。

orz CCF 都出来了没进迷惑行为大赏不是很认可。

开 T3,顿感难度飙升。前两年 T3 都是能秒掉的，今年想了半天肝不出来，而且 n≤103n \le 10^3n≤103 的暴力也不是很好写，先开 T4。

T4 的暴力 dfs 要比 T3 好写很多，因此先写 T4 404040pts，然后晃晃悠悠的把 T3 暴力 606060pts 肝完了。

接着没事儿干了开始想特殊性质，最后 T3 出了 555 特殊性质，T4 出了 242424 特殊性质分。

得分（预估）：100+100+(60+5)+(40+24)=329100 + 100 + (60 + 5) + (40 + 24) = 329100+100+(60+5)+(40+24)=329，高分一等稳了。hbh 估分 300300300，太强力！

S 组#

仍然先不看题，把头文件啥的写了，开 NOI Linux。

中午休息了，因此有点困（？没睡醒导致的？），但是做着做着 T1 就精神了。

开 T1，似乎和去年一个水平都是不是很会的样子，想了半天。最后写了 100100100 多行用时 1.5h 惊为天人。15：54，测完样例，AC T1。

T2，一眼 MST，想了半天最后把高分做法（CCF 水数据实现较好的话貌似可以 AC）假了（写出来了，样例挂了，然后觉得是做法假了……），无奈就写了个朴素 MST 跑路。

T3 不是很看得懂的样子，过。但是全输出 000 没准也和样例一样有分呢？于是：

1
// 赛后补注：这是 T3 代码全文
2
#include <bits/stdc++.h>
3

4
using namespace std;
5

6
typedef long long ll;
7

8
int n, q;
9

10
int main() {
11
  freopen("replace.in", "r", stdin);
12
  freopen("replace.out", "w", stdout);
13
  ios::sync_with_stdio(false);
14
  cin.tie(0);
15
  cin >> n >> q;
16
  while(q--) cout << '0\n';  // 赛后补注：应该是 "0\n" 的，虽然改不改都是 0pts
17
  return 0;
18
}
19

20
/*
21
???
22
Thank you.
23
Are you OK?
24
Hello, thank you, thank you very much.
25
Hello, thank you, thank you very much.
26
Oh my CCF is the problem really can be solved?:(
27
Even don't know how to write brute force……T_T
28
*/

展开收起

emm，使用了雷总成名曲《Are You OK？》（Are You OK，My OIers？Are You OK，CCF？），成功入选迷惑行为大赏 #68。

T4 看出来了是 DP，但也仅限是看出来了，打了个 8pts 的全排列调了半天离大谱，好在是过了。

能测的样例都测了，应该不会挂分（埋下伏笔）。至今仍记得使用 diff 比较的时候此处无输出胜有输出的喜感。

得分 100+16+0+8=124100 + 16 + 0 + 8 = 124100+16+0+8=124，一年的努力只值 444 分吗？CCF has no egg！

晚上#

发现 J 组 T2 可能出现 n,mn, mn,m 读反掉大分的情况，好消息是手搓了题面 n=4,m=5n = 4, m = 5n=4,m=5 的情况似不了，但是 333 组样例都 n=mn = mn=m 差评。

S 组 T2 没有 k=0k = 0k=0 的样例，意味着我的代码是没测过的裸奔，有点慌。

Day 2.1#

怎么各大估分系统都挂了，没有代码差评。

看到 S 组 T1 正解了，和我思路一毛一样，但是赛场上在没听过反悔贪心几乎没练过贪心的情况下利用反悔贪心 AC 一道绿（虽然后来降黄了本人几乎没有场切绿的实力）还是太强力。但是考场脑抽忘记如何使用 priority_queue 了难绷 /jk。

Day 2.2#

卡 bug 查分了，J 组 100+100+60+40=300100 + 100 + 60 + 40 = 300100+100+60+40=300，为什么特殊性质分都挂了（恼。

S 组 100+0+0+8=108100 + 0 + 0 + 8 = 108100+0+0+8=108，怎么 MST 都能写挂（仍记得 2024 年暑假用记事本写 MST 模板没测样例没编译直接交都能 AC 的经历，自认为 Kruskal 是非常熟练的算法了）……好在 T1 过了。据说 T2 是没测完更新上去？还有救……

Day 2.3#

接受现实，测完了，是正式成绩。仍然交到你谷上，仍然一分没多，准备祭了。今年据说有 1mol⁡1 \operatorname{mol}1mol 人爆炸了……。

S 比去年低 121212 分是什么鬼……

Day 2.4#

回低中部，发现 S 组 T2 直接 MST 能拿 323232 分的，挂分原因是：https://benben.sbs/feed/6830882，改了就把 323232 分拿满了我【数据删除】。

J 组 T4 能拿 646464 分的，但是《关于取模》然后杨辉三角爆 long long 了 /bangbangt。

J 组 T3 则是没有注意到 k≥0k \ge 0k≥0 时可以 k=0k = 0k=0 且 1⊕1=01 \oplus 1 = 01⊕1=0，只挂了 555 分已经谢天谢地了。

hbh J 295295295，跟我一个水平了，后怕（。

成就结算#

J/S 双过【达成】
J 组一等（300+，冲刺 AK）【300 压线，一等稳了，勉强达成】
S 组一等【废了（把那 32 分拿了顶多也才压线），如果爆 0 的人多点的话顶破天能卡进全国线】
进入 NOIP/WC【未知，希望可以】

算了，等分数线吧。

……

不对，我还要先准备期中考逝，whk 再这么颓下去要滑成年级倒数第一了 /jk。

upd on 2025/11/25：分数线出来了，J 组一等 S 二等意料之中，但是我把 S T2 的 323232 分拿满就到全国一等线并且稳蓝钩了有些抽象吧（

既然如此我认为自己是蓝钩爷没人有意见吧（

期中考逝翻车（jv）了，刷新各科历史最低分。

NOIP 初中生分数线貌似是 100100100 分，过了。

upd on 2026/10/27：其实挂了。MMP 似乎初中线比一等线还高。

问#

怎么会有二货打 333 年提高组连初赛带复赛拿了 555 个奖全部是二等:(

怎么会有二货参加了 444 次复赛第二题爆 000 了 333 次:(

怎么会有二货 222 次把第二题正解几乎想出来了然后又脑补把它假掉了:(

怎么这么二:(

怎么最小生成树都能写挂:(

怎么 INT_MAX 还敢往上加:(

怎么又是全谷倒数第一:(

怎么认识的和不认识的 OIer 都比我高:(

怎么大家都把 J 组 AK 了:(

怎么比我大的比我小的都比我强:(

怎么没给样例测试的数据点都挂了半分没有:(

怎么还不会对拍:(

怎么 OI 和文化课都在颓:(

怎么又双叒叕要衰微了:(

怎么都要习惯了:(

怎么本来应该从从容容游刃有余，现在是匆匆忙忙连滚带爬……没出息:(

:(The End.\texttt{:(}\\ \texttt{The End.}:(The End.

题解：B4400 [蓝桥杯青少年组国赛 2025] 第五题

Fri, 29 Aug 2025 11:06:53 GMT

闲话#

板题，有一定码量和小细节（但是写起来很快，对称的复制粘贴即可），在这种只有 909090 分钟的比赛中出这种题的组委会有点难评。

因此虽然思路简单，放个 T5 还是合适的。

题意#

简要题意：有三个牛奶瓶 A、B、C，容积分别为 v,x,y 升，其中最开始 A 灌满了 v 升，B、C 没有牛奶。

每次操作可以任选两个瓶子倒牛奶：

如果可以倒满那就倒满。
否则全部倒入。

求是否可能让其中一个瓶子恰好有 v2\dfrac{v}{2}2v 升牛奶，如果可以输出最小操作次数，否则输出 -1。

做法#

首先过掉一部分无解的情况，如果 AAA 是奇数那整数内部加减当然不可能有分数，因此是无解的。

鉴于数据范围很小，那当然是考虑搜索、枚举啦。稍微有些经验应该能看出来这是道经典的 BFS 入门练习题。

BFS 的做法是，我们维护一个状态队列，每次不断从队首得到新的状态然后将队首出队。如果队首已经有满足情况的就直接结束了，否则继续搜索。初始状态当然是 AAA 中有 vvv 升，BBB 和 CCC 没有，操作次数是 000，信息略多可以用一个结构体维护。

接着，我们模拟题目中的倒牛奶过程，即 A 倒入 B、A 倒入 C、B 倒入 C，然后每种操作再分两类讨论。由于大差不差的，直接复制粘贴 3 组 666 条判断语句即可。操作完得到新的状态之后，将操作次数 +1 得到新的操作次数然后重新丢进队列里就算结束了。

但是这样子会超时的！考虑如下情况：

1
6 2 1

第一次，我们将 A 倒入 B，此时 A 还剩 444 升，BBB 有 222 升。

第二次，我们将 B 倒入 A，此时 A 有 666 升，B 空了。

哎这怎么又回去了？

我们发现我们需要存下来已经搜索过的状态，开一个三维数组记录即可（这也是为什么这题数据范围这么小，大一些开三维就 MLE 了）。

如果之前搜索过了就不用继续搜了（因为只会搜以前搜过的状态，反而步数更多了不优，某种意义上这也算是一个简单的最优性剪枝）。

最后，注意如果状态队列空了但是还没有结果那也是无解的，仍然返回 -1。

然后就结束啦！

DFS 也差不多，也可以做，也需要维护一个状态数组，只不过从队列改成递归搜索就好啦！

代码#

赛场 AC 代码：

图片版：

Code

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
const int N = 500;
6
int v, x, y, vis[N][N][N], goal;
7

8
struct st {
9
  int a, b, c, stp;
10
};
11

12
queue<st> q;
13

14
int bfs() {
15
  q.push({v, 0, 0, 0});
16
  while (!q.empty()) {
17
    st f = q.front();
18
    q.pop();
19
    if (f.a == goal || f.b == goal || f.c == goal) return f.stp;
20
    if (vis[f.a][f.b][f.c]) continue;
21
    else vis[f.a][f.b][f.c] = 1;
22
    if (f.a > x - f.b) q.push({f.a - (x - f.b), x, f.c, f.stp + 1});
23
    else q.push({0, f.b + f.a, f.c, f.stp + 1});
24
    if (f.a > y - f.c) q.push({f.a - (y - f.c), f.b, y, f.stp + 1});
25
    else q.push({0, f.b, f.c + f.a, f.stp + 1});
26

27
    if (f.b > v - f.a) q.push({v, f.b - (v - f.a), f.c, f.stp + 1});
28
    else q.push({f.b + f.a, 0, f.c, f.stp + 1});
29
    if (f.b > y - f.c) q.push({f.a, f.b - (y - f.c), y, f.stp + 1});
30
    else q.push({f.a, 0, f.c + f.b, f.stp + 1});
31

32
    if (f.c > v - f.a) q.push({v, f.b, f.c - (v - f.a), f.stp + 1});
33
    else q.push({f.c + f.a, f.b, 0, f.stp + 1});
34
    if (f.c > x - f.b) q.push({f.a, x, f.c - (x - f.b), f.stp + 1});
35
    else q.push({f.a, f.b + f.c, 0, f.stp + 1});
36
  }
37
  return -1;
38
}
39

40
int main() {
41
  ios::sync_with_stdio(false);
42
  cin.tie(0);  // 常数优化
43
  cin >> v >> x >> y;
44
  if (v % 2) {  // 偶数 % 2 是 0，判断为 false，不会进入判断
45
    cout << -1;
46
    return 0;
47
  }
48
  goal = v >> 1;  // 对于正整数，右移一位相当于除以 2
49
  cout << bfs() << endl;
50
  return 0;
51
}

展开收起

如有除注释以外的差异以图片为准，文字版可以通过。

AC 记录：https://www.luogu.com.cn/record/233679115。

DFS 的也有：

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
const int N = 201;
6
int v, x, y, vis[N][N][N], ret = INT_MAX, goal;  // ret 最开始要是一个极大值，否则怎么找都是 0
7

8
struct st {
9
  int a, b, c, stp;
10
};
11

12
void dfs(int a, int b, int c, int stp) {
13
  if (a == goal || b == goal || c == goal) {
14
        ret = min(ret, stp);  // 取最小值，dfs 不能保证第一次搜到的是最小的因此要记录一下，而 bfs 可以因此搜到了就可以直接返回结束了
15
        return;  // 不 return 就会继续搜下去然后就无限递归啦！
16
    }
17
  if (stp > vis[a][b][c] && vis[a][b][c]) return;  // dfs 不能保证第一次搜到的就是最小的，因此只有步数大于已经搜过的步数时候才是更劣的
18
  else vis[a][b][c] = stp;  // 仍然记录步数
19
  if (a > x - b) dfs(a - (x - b), x, c, stp + 1);  // A 倒 B
20
  else dfs(0, b + a, c, stp + 1);
21
  if (a > y - c) dfs(a - (y - c), b, y, stp + 1);  // A 倒 C
22
  else dfs(0, b, c + a, stp + 1);
23

24
  if (b > v - a) dfs(v, b - (v - a), c, stp + 1);  // B 倒 A
25
  else dfs(b + a, 0, c, stp + 1);
26
  if (b > y - c) dfs(a, b - (y - c), y, stp + 1);  // B 倒 C
27
  else dfs(a, 0, c + b, stp + 1);
28

29
  if (c > v - a) dfs(v, b, c - (v - a), stp + 1);  // C 倒 A
30
  else dfs(c + a, b, 0, stp + 1);
31
  if (c > x - b) dfs(a, x, c - (x - b), stp + 1);  // C 倒 B
32
  else dfs(a, b + c, 0, stp + 1);
33
}
34

35
int main() {
36
  ios::sync_with_stdio(false);
37
  cin.tie(0);
38
  cin >> v >> x >> y;
39
  if (v % 2) {
40
    cout << -1;
41
    return 0;
42
  }
43
  goal = v >> 1;
44
    dfs(v, 0, 0, 0);
45
  cout << (ret == INT_MAX ? -1 : ret) << endl;  // 不行就是 -1，注意判断 ret
46
  return 0;
47
}

展开收起

AC 记录：https://www.luogu.com.cn/record/233894967。

提示：memset 会对数组中的每一个元素赋值，三维数组这么大当然时空也会超级大（见这篇帖子），因此不建议使用 memset 初始化而是判断步数是否为 0。此处感谢 @ETO_NOI 的提醒。

完结撒花！

提示：这里情况比较多，空行区分和注释可以大幅减少 debug 的时间和代码阅读难度，相比于花大量的时间调不可读的代码甚至比赛结束也做不完，敲它们的时间是非常划算的。

【附 Hack 数据及原理】题解：P1195 口袋的天空

Sat, 23 Aug 2025 20:40:01 GMT

闲话#

Hack 数据确实比较毒瘤，但是怎么大家都是特判过的啊，那跟没有 Hack 有区别吗（气愤）。

因此本题解代码没有特判。

积木鱼是 Hack 工单的提出者，自己手搓了两组 Hack，从讨论区和题解的评论区发现了 @zengziqvan 和 @Landscape_Jing 的 Hack。同时感谢 @zhoujunchen 的帖子让我发了这个工单、@chen_zhe 处理了这个单子。然后 cz 处理完工单第二天晚上写完的时候发现题解通道关了，被谷民速度又双叒叕震惊到了。

另外本篇是唯一同时写了 Prim 和 Kurskal 两种算法的题解，耗费了小 L积木鱼好几个下午（Prim 太难调了 T_T），因此求赞 Qwq，求收藏 OwO。

正文#

有一个有 nnn 个点 mmm 条边的带权无向图，选择一些边使其恰有 kkk 个连通块，求选择的边的边权和的最小值。

怎么做呢？

我们发现我们选择的边都属于原来的图，因此得到的新图一定是原图的生成图，因此不难想到利用最小生成树解决。

为啥就是最小生成树？

树的其中一个定义是：无向无环的连通图。

由于是连通块，当然是连通图啦；选择的都是给定的无向边，因此是无向的。

环上的点至少有 222 条路径可以相互到达，我们当然可以破坏掉其中一些边使它们仍然可以通过另一条路径相互到达，即不破坏连通性的情况下无环会比有环更优（题中边权都是非负的）。

综上，无向无环就是连通块内部的最好情况，当然每个连通块因此也就都是树啦。事实上，最小生成树本身就是本题 k=1k = 1k=1 时的特殊情况。

所以怎么求最小生成树呢？

Krsukal#

我们把图清空，也就是只有 nnn 个点，没有边。

然后利用贪心的想法，优先加边权小的边，因为如果有边权小的边不选而选边权大的边当然是不优的。

但是如果无脑加的话有可能就会出环，为什么呢？

如果这两个节点已经连通了，那么加上这条边还是连通的，这条边除了增加边权以外没有任何用处，反而会新增一条路径，也就是一个环。而我们的生成树也是树，是没有环的。

那我们该如何判连通呢？并查集啊！

然后就做完了，算法只有两步：

把边按边权排序。
遍历每一条边，如果边连接的两点已经连通了就不要；否则就加上来。

时间复杂度分成两部分，排序是 O(mlog⁡m)O(m \log m)O(mlogm) 的，并查集是 O(mα(m,n))O(m \alpha(m, n))O(mα(m,n)) 的，其中 α\alphaα 为 Ackermann 函数的反函数，非常小，可以认为是常数，故总时间复杂度为 O(mlog⁡m)O(m \log m)O(mlogm)。

需要注意的是，因为需要排序选边，因此不可以直接建图，而是要存下每条边连接的两个点和边权。

Prim#

Prim 和 Kruskal 类似，但是 Prim 是加点。也就是每次找和已有的点距离最近的点，然后用连接新的点的边更新其它节点的距离。

哎？这个过程怎么这么像 Dijkstra？Dijkstra 是以起点为中心，不断更新其它点的最短路，而 Prim 是由一个点开始，不断更新其它点的路径……

是的，就是 Dijkstra 改一改，因此也可以用堆优化（事实上，Dijkstra 本人也于 1959 年发现过这个算法）。

但是 Prim 个人认为相对于 Kruskal 来说并不是很好写，而且常数也略大。

暴力 Prim 是 O(n2+m)O(n ^ 2 +m)O(n2+m) 的，优先队列优化为 O((n+m)log⁡n)O((n + m) \log n)O((n+m)logn)，可以用较为特殊的 Fibonacci 堆优化至 O(nlog⁡n+m)O(n \log n + m)O(nlogn+m)。

题目#

那我们怎么知道 Kruskal 选多少边呢？

按照 Kruskal 的流程，每次连接都是两个之前并没有连通的连通块，连接之后成了一个块，整体上减少了 111 个块，而我们需要 kkk 个块，只需要 n−kn - kn−k 条有效的边即可。

按照 Prim 的流程也可以做！Prim 不能适可而止，但是我们可以倒回来啊！一棵树上有 nnn 个点，断掉一条边就增加一个连通块，想要边权和最小我们只需要断掉边权最大的 kkk 条边即可，时间复杂度 O(n2+m)O(n ^ 2 + m)O(n2+m)（朴素 Prim），对于本题完全可以通过。

这样改造有个要求，我们需要存储方案，放进 vector 或者其它数据结构就好了。由于只和边权有关而且要边权最大，这里我用了一个 priority_queue 帮我排序最大值（它默认是大根堆）。本题数据量较小，朴素 Prim 即可通过，欢迎大家尝试优化！虽然由于复杂度、常数等方面的差异大概率卡不过 Kruskal，何况 Kruskal 已经提前结束了。

代码#

Kruskal 代码：

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
const int N = 3e5 + 10;
6

7
int k, m, n, fa[N], cnt, ret;
8

9
struct edge {
10
    int u, v, w;
11
    bool operator<(const edge& cmp) const { return w < cmp.w; } // 重载小于号，方便排序
12
} a[N]; // 直接存边
13

14
inline int fid(int x) {
15
    if (fa[x] != x) fa[x] = fid(fa[x]); // 路径压缩
16
    return fa[x];
17

18
}
19

20
inline void merge(edge u) {
21
    int fx = fid(u.u), fy = fid(u.v);
22
    if (fx != fy) { // 只有不在同一个连通块时才要加边
23
        fa[fx] = fy;
24
        ++cnt; // 统计选的边的数量
25
        ret += u.w; // 统计边权
26
    }
27
}
28

29
int main() {
30
    scanf("%d%d%d", &n, &m, &k);
31
    for (int i = 1; i <= m; ++i) scanf("%d%d%d", &a[i].u, &a[i].v, &a[i].w); // 直接存边
32
    for (int i = 1; i <= n; ++i) fa[i] = i; // 初始化
33
    sort(a + 1, a + m + 1); // 排序
34
    for (int i = 1; i <= m; ++i) {
35
        if (cnt == n - k) { // 警示后人：一定要先判断，后面讲 Hack 的时候会说为什么要先判断
36
            printf("%d\n", ret);
37
            return 0;
38
        }
39
        merge(a[i]); // 没到条件就合并
40
    }
41
    if (cnt == n - k) {
42
        printf("%d\n", ret);
43
        return 0;
44
    } else printf("No Answer"); // 达不到就是 No Answer
45
    return 0;
46
}

展开收起

Prim 代码：

1
#include <bits/stdc++.h>
2

3
#define INF 0x3f3f3f3f
4
#define log printf
5

6
using namespace std;
7

8
typedef pair<int, int> PII;
9

10
const int N = 1010;
11
int k, m, n, x, y, z, ans, cnt, ret, dis[N];
12
bitset<N> vis;
13
vector<PII> g[N];
14
priority_queue<int> q; // q 用于删边，这里利用了 prioqiry_queue 正好是大根堆的特点
15

16
// 并不是很标准的朴素 Prim
17
void prim() {
18
    memset(dis, 0x3f, sizeof(dis));
19
    dis[1] = 0;
20
    for (int i = 1; i <= n; ++i) { // 注意图不一定连通，因此需要遍历每一个点
21
        int u = -1;
22
        for (int j = 1; j <= n; ++j)
23
            if (!vis[j] && (u == -1 || dis[j] < dis[u])) u = j; // 找到新的点，要求不在树中且边权尽量小
24
        vis[u] = 1;
25
        if (i > 1 && dis[u] != INF) q.push(dis[u]), ret += dis[u]; // 加边！加边！加边！同时丢进优先队列里并统计边权
26
        for (auto v : g[u]) if (v.second < dis[v.first]) dis[v.first] = v.second;
27
    }
28
}
29

30
int main() {
31
    scanf("%d%d%d", &n, &m, &k);
32
    for (int i = 1; i <= m; ++i) {
33
        scanf("%d%d%d", &x, &y, &z);
34
        g[x].push_back({y, z}), g[y].push_back({x, z}); // 双向边！
35
    }
36
    prim();
37
    if (q.size() < n - k) log("No Answer"); // 和 Kruskal 一样，压根选不到这么多边就寄了
38
    else {
39
        while (!q.empty() && q.size() > n - k) ans += q.top(), q.pop(); // 删边
40
        printf("%d", ret - ans);
41
    }
42
    return 0;
43
}

展开收起

是不是一个特判都没有呢？

Hack 数据及原理#

与正常题目的 Hack 数据不同，本题的 444 组 Hack 每组 555 分（大部分题目是 000 分，只是会 Unaccepted），原题数据降至每个点 888 分。

数据 1#

题目只说了 NNN 和 KKK 的值域，又没说大小关系。显然 222 朵云连不成 333 个块，故答案为 No Answer。

这组数据 Hack 了原有的 999 篇题解，其中包含一个 328328328 赞的超高赞题解我谔谔……

数据 2、3#

这两组 Hack 的原理都一样。以上面的一组为例，画出来的图长这样：

graph.png

不难发现，即使加上了所有的边也只有 333 个连通块，根本不可能有两个块，因此答案是 No Answer。本数据 Hack 了原 555 篇题解。

数据 4、5#

个人认为最毒瘤的一组数据，非常卡边界处理。

简洁的过分有没有？但是很多题解和代码就是在这里翻车的，错误输出是 3 或 No Answer。

答案很显然，333 个点构成 333 个块，当然一条边都不用选，答案是 0。

究其能 Hack 成功的原因还要看到我们 Kruskal 的部分：

1
for (int i = 1;i <= m;++i) {
2
    merge(a[i]);
3
    if (cnt == n - k) {
4
        printf("%d\n", ret);
5
        return 0;
6
    }
7
}

绝大部分代码都是这样子的也包括我原来的，然后就会挂掉，因为我们是按照顺序执行代码的，因此按照这个逻辑，会先加上那条边，然后才会判断。

可我们一条边都不要啊！因此 cnt 变成 111 之后再也不可能变成 000 了，最后 cnt == n - k 的判断根本不可能成立，因此会输出 No Answer 或此时的 ret 值 333。

解决方法也很简单，把判断挪到上面去即可。但是注意可能会出现最后一条边才形成答案的情况，因此在循环结束之后仍然需要判断，否则：

输出是 10，不判断就是 No Answer（新开题解队列之后有 111 篇题解被这组数据 Hack 掉了）。

这组毒瘤的数据干掉了 777 篇题解和原 OI Wiki 上的代码，最终本题原有 292929 篇题解一个工单 Hack 掉了 9+5+7=219 + 5 + 7 = 219+5+7=21 篇，创下了一个小小的记录（目前成功添加 Hack 数据并撤下题解中撤解最多的？欢迎大佬超越）。

并且在新增题解后又用最下面的数据 5 Hack 了 111 篇，前前后后单杀了 222222 篇题解。

最终可过所有 Hack 数据的 AC 记录放上：

Kruskal
Prim

完结撒花！

网络是怎样诞生的？——简介 OSI 七层模型&TCP/IP 四（五）层模型

Tue, 12 Aug 2025 17:47:03 GMT

闲话#

Tip

这里要讲的是“网络”而不是“网络流”，学习网络流算法的童鞋请转隔壁『算法·理论』区。虽然但是，真的有人分不清这俩毫无关系的东西吗。

前几天刷某 CSP 初赛模拟题看见的，当时考了这么一道题：

【答案在文章后面】以下属于 TCP/IP 协议族中应用层协议的是：A.UDP B.ARP C.SMTP D.ICMP

加上学校信息课 OI 一点不学净学一些网络相关的导致我期末信息课挂分成 OI 界的耻辱了，故而整理一下。

考虑到网络和工程相关，和 OI 是弱相关，因此本文投“科技·工程”而非“算法·理论”。

下文中会混合 OSI 七层模型、TCP/IP 四（五）层模型和图论等多种内容，可能不是很清晰。如有错误欢迎指出！（但是也因此会掉全站推荐，推荐大家前往保存站阅读，后续我也会同步到我自己的博客上。）

本文为万字长文，配了不少图。请耐心阅读。

简介#

OSI 模型，即开放式通信系统互联参考模型（Open System Interconnection Reference Model），是国际标准化组织（ISO）提出的一个试图使各种计算机在世界范围内互连为网络的标准框架。——维基百科

说人话：不同机器之间协作显然需要共同的标准，称为“协议”。把数据传输的协议分为七层，即 OSI 七层模型。

现在我们从头来看看 OSI 是怎么搞出来的。

物理层#

话说你有一台电脑，代号 A。这天你闲得无聊，想和隔壁另一台机器 B 发点东西，怎么办呢？

嗨，连根数据线不就完了！

这个部分我们称为物理层。物理层就是现实世界的、物理意义上存在的，比如光纤、数据线等都属于这一层。

数据链路层#

后来这里扩建成了一个机房，有很多的机器，该如何通信呢？

一样的，继续连线嘛。

但是这样子也有问题。假如一台机房有 100100100 台机器，那么就需要 C1002=4950C^{2}_{100} = 4950C1002=4950 根数据线！每台机器还要开 999999 个网口！显然这不可能，将近五千根线谁受得了啊，而且很乱。

可以看到，7 台机器的图已经看不太清了

于是我们引入了一台新的机器——集线器！这台机器的功能很简单：我们把机房的机器全部和它连线（连成了一个菊花），这样无论和谁发信息都只需要发给集线器，集线器再转发给其它所有机器就可以了。

这样的好处是每台机器只需要和集线器连线即可，只需要 111 个端口 100100100 条数据线。

现在是不是清爽多了

但是这样子也有问题。之前如果你只想和 B 发信息那么直接在线上传输就好了，现在发什么都需要集线器，而集线器会无脑转发给所有机器，那万一有点小秘密不就都被泄露了……

为了解决这个问题，我们可以对集线器做一点升级改造。首先在我们发送的每条数据前面加上自己的地址和对方的地址再发出去，这样集线器就可以识别你要发给谁，然后就可以转给它了（啥？你问为什么发件人也要带上？你们收信都不回的吗？）。

这个升级之后的集线器就是大名鼎鼎的交换机。如果你理解了交换机的概念，那么恭喜你进入了数据链路层。

这里使用的地址一般是媒体存取控制位址（Media Access Control Address，MAC 地址，注意和苹果 Mac 没有关系）。它的特点在于出厂就会烧录每台机器（其实是网卡）唯一的 MAC 地址，全球唯一。而 IP 地址是每个网络自行分配（离开了这个网络就变了），可能会冲突，而且也可以被修改，故而不用。

交换机如果遇到了 IP 地址也要把 IP 转换成 MAC 地址才会发送。而如果是一个不认识的 MAC 地址它就会发扬集线器精神给每台机器都发一遍。这个流程运用的就是地址解析协议（Address Resolution Protocol，ARP）。

Info

集线器仍然属于物理层，因为它根本不处理数据只是传输，和一堆数据线没有区别。

另外，一般情况下的网络如果真的是这样的菊花图或者树那么会非常不健壮，把交换机（根节点）干掉那么这个网络也就被干掉了。

同理不健壮的还有链，干掉一个节点就可以直接中断。

一般考察一个网络的健壮性首先当然要保证这是个连通图（两两可达），其次就是冗余的点和边要尽量多（最好不要有割点或桥），破坏掉一些边最好也能继续工作。典型反例：树，两两节点有且仅有一条最短路径，干掉一个就可以中断一堆节点。

一般来讲最健壮的是完全图，但是上面说了，完全图无论是建立还是维护成本都超高，因此最好还是追求平衡，比如把菊花和链融合的轮图就要比普通的菊花和链健壮。

当然，也可以多来一台交换机，那就是财力的问题啦~

网络层#

后来我们和隔壁机房合作，现在也要建立通信了。有了刚才的经验，我们知道现在不可能把隔壁机房的机器连到这里的交换机上，怎么办呢？

我们在隔壁机房也建立一个交换机嘛，然后再把这两个交换机之间加一个集线器或另一个交换机不就完了？

不对，我们的数据都是记录的 MAC 地址，总的交换机不可能记录每台机器的 MAC 地址啊（毕竟是两个独立的网络）。两个机房还好，一大堆机房那就……交换机要玉玉了 >_<。

于是我们发明了 IP 地址，分为网络地址和主机地址两个部分。同一网络下网络地址是相同的，而每台机器的主机地址不同。

具体来说，我们定义一个数值（子网掩码），然后转成二进制，与 IP 地址进行按位与运算，这样就得到了网络地址。只要网络地址相同，我们就认为它们在同一个网络中。

有了以上准备，我们就发明了大名鼎鼎的路由器！

路由器和交换机类似，但是它基于 IP 地址工作。如果我们发现传过来的数据包属于这个网络就可以丢给交换机下传，如果是要让自己做中转就接着传下去，否则就不管它，直接把数据包扔了（对，就是这么简单粗暴，不过你留着这个包除了占空间以外也没啥用）。

而发送的时候就会检查自己的路由表，看一下它属于哪一个网络。如果这里没有就启动选路算法找到最短路线传过去。

新的传输路线

这个部分东西有点多，需要好好消化一下。

首先为了区分网络我们发明了 IP 地址和子网掩码。子网掩码一般使用 CIDR 斜杠表示法，例如子网掩码为 255.255.255.0/24 就是表示二进制下前 242424 位表示网络地址。当然，你也可以更改，如 255.255.255.128 对应的 CIDR 就是 255.255.255.128/25，这样就划分了上面网络的子网。特别的，我们有 A、B、C、D、E 五类 IP 地址，其中 D、E 分别是多路广播和保留地址一般不用，另外 127.0.0.1 是本机地址。剩余 A、B、C 类如表：

类别	CIDR	对应掩码	地址个数
A	/8	255.0.0.0/8	16777214
B	/16	255.255.0.0/16	65534
C	/24	255.255.255.0/24	254

一般情况下家用的网络都是 C 类，如果你需要更多（不会吧？）那么也可以申请。

子网掩码 xxx.xxx.xxx.xxx/i 的原理其实是保留前 iii 个二进制位，前 iii 位都是 111，与 IP 地址的对应位进行与运算后不变；后面都是 000，全部都变成 000 了，这样可以比较。最终一个网络可用的地址也就是 232−i2^{32 - i}232−i 个。

转换关系表

注：上图中具体的数字是包含保留地址的，上面的表则扣除了保留地址（全 0 和全 1），因此同一类网络中，表中比图中要少 222 个地址。具体计算见 https://www.cnblogs.com/zhezh/p/3773431.html。

当然上面的概念基于 Internet Protocol version 4，即 IPv4，二进制下 323232 位，有 2322^{32}232 个地址。由于现在设备越来越多，产生了 IPv4 地址枯竭的问题（不开 long long 见____）。于是又发明了 IPv6（别找了，我帮你们看了，IPv5 根本就没有成为正式广泛使用的协议），有 21282^{128}2128 个地址，达到了 __int128 的级别，号称“可以为全世界的每一粒沙子编上一个地址”，而且安全性和速度也有一定提升。

但是 IPv6 和 IPv4 不同，一般采用 161616 进制表示，444 个 161616 进制位（161616 个 222 进制位）一组，每组之间用冒号分开（因此成为“冒分十六进制”，相应的，一般 IPv4 称为“点分十进制”）。特别的，如果一组的值是 000 那么可以省略不写直接接到下一个冒号（不过貌似有些老爷机器不一定支持，另外冒号禁止省略）。

Tip

可能会考让你判断 IP 地址是否合法的题目。首先通过冒号和点来区分 IPv6 和 IPv4，然后 IPv4 中的值都不能超过 28−1=2552^8 - 1 = 25528−1=255，十六进制不能超过 FFFF 且必须是恰好 888 组（被省略的也算一组）。

另外对于我国来说，IPv6 还有一个优势是根服务器。IPv4 的 131313 台 101010 台在美国，亚洲只有日本有 111 台辅根服务器；IPv6 全球有 252525 台，其中 111 台主根服务器位于北京，333 台辅根服务器分别位于成都、广州、上海）。

路由器会有一张路由表（下面的图经过简化了，实际上是 Trie+ 链表）。

路由表

接收数据包的时候会检查这是不是发给自己的，如果是就可以丢给交换机了，不是就看看是不是要在这里做中转发给别的路由器之类的机器的。

如果是发送数据包呢？

发送情况 1

如果目标网络有记录（比如图中 PC1 到 PC3）那么查表直接发过去就好了。

发送情况 2

如果不在表中（例如 PC1 发给 PC25）就会找默认网关，默认网关一般会有一张更大的路由表，以此类推。特别的，有几台特殊的服务器：

地区 ISP 服务器
主干网 ISP 服务器
NSP 服务器
NAP 节点

ISP（Internet Service Provider）和路由器连接你的路由器才能接入 Internet，常见的 ISP 就是移动、联通、电信三大运营商。ISP 可以从 NSP（Network Service Provider）批量买入带宽接入更高级的主干网。每个 NSP 都要接入至少三个 NAP 节点，你的请求可以通过 NAP 切换到不同的主干网。

但是好像哪里有问题？

你输入的不是 luogu.com.cn 吗，你咋知道洛谷服务器 IP 的？

黑进 kkk 账户看见的（bushi）。

也不是不刑，但是我们要有请 DNS（Domain Name System） 出场！

。。。

好吧 DNS 协议属于应用层因此鸽到下一篇再讲。光速逃。

Tip

可以使用 tracert domain 的方式来看看递归过程，其中 domain 是你想查询的域名，如 luogu.com.cn。

在某地机房执行 tracert luogu.com.cn 的结果如图：

不难看出查询速度越来越慢（因为经历了更多中转）。

ps：路由表的链路算法分成静态和动态的两种，但是静态不适于网络的变化，而动态的两种算法分别是链路状态（LS）算法，代表为 Dijkstra；以及距离向量（DV）算法，代表 Bellman-Ford 和优化后还没死透的 SPFA。

对，就是最短路。不过也很好理解，发送数据不就是要传输时间短嘛。路由表的过程就是最短路获得路径后递归转发。

之所以要花这么大篇幅讲路由器是因为这就是 OSI 七层模型的第三层——网络层，代表就是 IP 协议。网络层就是过路由选择算法，为数据包选择最优路径，另外数据包也是在这里被转换出来的。

另外，上面当中路由器和交换机的功能在家用路由器中一般被集成到一起了。

传输层#

后来我们又发现了新的问题。有的时候我们可能需要传送像 NOI Linux 的镜像之类的大文件，然而数据线由于折腾了半天有的已经老化了，传不了，丢件了……

几个 GB 的重要大文件就这么挂了，损失惨重。这个事情告诉我们我们必须要有一个处理丢件的措施。怎么办呢？

鸡蛋不能放在同一个篮子里。——古人

对，我们要把数据拆分成数据包，每个包单独传输，这样就算真的有包寄掉了或者出 bug 了只需要重传那一个包就可以了。而且这样还可以让不同的包分头行动，有一个线路寄了其它线路不影响。分包是我们后续流程的基石。

但是随着机器越来越多，我们又发现了新的问题。有的机器是 i9 少爷机跑的飞快，有的机器是 Intel N100 的“高端” CPU，显然让它们处理同样的包大小很不公平。另外，不同的包走不同的线路到达的时间也不一样，谁先谁后不清楚，怎么办呢？还有，一台机器可能会有很多程序需要网络，该如何区分这个包是给哪个程序的呢？

不搞了，跑路。

首先我们给每个包编个号，这样就解决了顺序问题。然后我们规定对面机器每收到一个包就要返回一个编号 nnn，表示 1∼n−11 \sim n - 11∼n−1 的所有包都收到了，现在需要包 nnn，我们这里接收到返回来的信号后继续发下一个包。这样如果对面不发出信号我们就知道包出 bug 了要重新传（这也就是为什么一定要设置一个超时时长）。

下一步我们引出一个概念叫“端口”，不同的程序使用不同的端口，输入和发出都需要端口。如果该端口已经被其它程序占用了那服务就没法搞了。一般一个机器有 0∼655350 \sim 655350∼65535 共 655366553665536 个端口，不过鉴于一般普通机子 300300300 多个进程就卡的要死，所以一般不会出现端口不够的问题。这样我们在包头上加上端口号就可以区分了。

接着我们来思考如何解决机器配置不同的问题。显然我们是要求每一个机器的承载能力以及网络状况的最小值。怎么求呢？我们发完（接收到了包正常的信号）就不用管了，同时每个机器的承载能力基本不变，而且一个包不用管之后就可以处理下一个包了……哎这不是滑动窗口吗？是的就是一个队列维护。而且由于这就是负责传输的协议，因此即使不知道什么原因窗口大小改变了也能通知到（事实上每一个返回的包都会带上新的窗口信息）。

啥？网络环境怎么办？三种方法：

慢启动。就是利用倍增（啊对，就是 1、2、4、8 那个倍增）不断试探网络环境的上限。
如果窗口大小大于之前试探出来的慢启动阈值就会改用拥塞避免模式，线性缓慢尝试。
快速重传，这种情况下不需要等到超时就可以提前发出包了。

快速重传比较复杂，这里简单讲一下。举个例子：

发送方发了 1、2、3、4、5 一共 5 个包。
接收方接收到了包 1，返回 2，表示需要包 2。
接收方接收到了包 2，返回 3，表示需要包 3。
接收方接收到了包 4，此时把 4 放入缓冲区，仍然返回 3。
接收方接收到了包 5，此时把 5 放入缓冲区，仍然返回 3。
接收方终于收到了包 3，此时把 4 和 5 从缓冲区放出来，返回 6。

这里 3 被返回了三次，其中第一次是正常接收，而后两次则是出现了乱序的情况。而如果乱序情况再次出现（如后面的包 6 都到了 3 还没到）那么发送发就会认为包 3 已经祭了就会重新发一遍，这就是快速重传，不需要等到超时。至于为什么是三次，那就是一个折中比较好的选择啦~

好，完事儿了，我们可以开始通信啦！

吗？不对，我们好像还有一个很重要的问题没解决——咋建立连接啊？

关于我传了俩小时文件结果对面还没开机这件事。

这就要引出大名鼎鼎的三次握手了！

首先我们规定一个包长什么样：

这里会有以下我们提到过的信息，也会有些其他的：

发送方的 MAC 地址
接收方 MAC 地址
发送方 IP 地址
接收方 IP 地址
目标端口
源端口

特别的，在路由器发送的时候会把你的主机 IP 改成路由器的外网 IP，还会把端口号给改了，对外完全隐藏你的主机。这个操作称为 NAT，是一种网络隐蔽技术，可以提高安全性、共享网络地址。

然后我们定义几个特殊的信号：

ACK：确认数据包头部的确认序列号有意义。

SYN：特殊报文，建立连接时使用

FIN：数据发送完毕，在关闭连接时使用。

最开始，客户端和服务端都是 “CLOSE” 状态没有任何连接。但是服务器会主动监听某个端口（对于 Web 一般是 80 和 443 两个端口，后面一篇会讲为什么）。

发送请求，此时客户端会生成一个 client_isn 的序列号，标记位是 SYN 表示要连接了，自己进入 SYN_SEND 状态。

服务端接收到之后也初始化序列号 server_isn，在确认号的位置填上 client_isn + 1 表示确认收到了客户端发过来的序列号，同时把 ACK 和 SYN 位置都置为 111，发送给客户端，自己变成 SYN_REVD 状态。

然后客户端也要告诉服务端它收到了这个信号，于是在确认号填上 server_isn + 1，ACK 状态为 1。

发完，客户端进入 ESTABLISHED 状态，服务端同时进入 ESTABLISHED 状态。

如果只有两次握手，那么服务端不能保证自己发的信号能被客户端接收（这是在第三次握手告诉服务端的），因此不行。

序列号随机生成可以保证安全性，同时也可以过滤掉不属于这里的信息。

如果前两个包丢了超时重传就可以了，第三个包需要分类讨论。

情况一：没有任何数据发送。那就直接超时重传。

情况二：客户端要发数据了，服务端接到了 ACK 和数据包，那就自然 ESTABLISHED 接收数据包。

情况三：服务端要发数据了但发不出去那就一直超时重传。

一张图总结就是：

在通信完成之后要释放端口当然就需要断开连接，也就是四次挥手。

双方都有权利断开连接，以客户端为例：

首先客户端发送 FIN 的信号，进入 FIN_WAIT_1 状态。服务端回复 ACK 信号，进入 CLOSE_WAIT 状态。客户端收到 ACK 信号，进入 FIN_WAIT_2 状态

等服务端确认真的没活了都发完了就再次发送 FIN 信号，进入 LAST_ACK 状态，客户端收到 FIN 回应 ACK 之后进入 TIME_WAIT 状态，服务收到 ACK 信号之后就 CLOSE 了，客户端在 TIME_WAIT 等到 2MSL 个时间之后也就 CLOSE 了。

其中这个 MSL 是报文在网络上存在的最长时间，一般是 30 秒、1 分钟或 2 分钟，主要是担心最后一个 ACK 信号服务端没收到那就会超时重传，根本不能关闭连接，而且这样还能保证新建连接的时候老的连接的数据已经消失了。在 TIME_WAIT 状态下端口仍然被占用，因此时间不能太长。

那为什么要四次呢？因为发完 FIN 信号后客户端不发送了但是还能接收的，而服务端收到的时候也可能正好还有数据要传，因此先回一个 ACK 信号，后面真的没东西了才发 FIN 表示可以关了，一来一回一共四次。

我们发现建立连接的过程无非就是交换双方的状态，连接本身也只是维持 ESTABLISHED 这么个状态而已。

这个分包、传输、滑窗、握手、挥手……的过程就是 TCP 协议规定的。

这里花了大量篇幅讲 TCP 的三次握手和四次挥手，因为这就是网络传输的核心——传输层（废话）。

TCP（Transmission Control Protocol，传输控制协议） 和 UDP（User Datagram Protocol，用户数据报协议） 协议是传输层的主要协议之一，UDP 协议比较简单，没有解决数据包重发等问题，增加的功能不多，因此速度也要比 TCP 快很多，但可靠性也会下降，一般适用于视频直播等场合，丢个一帧两帧的看不出来，但是卡是真的看得出来。

而 TCP 提供可靠的交付服务，出 bug 了就重传。典型的应用比如你的shi 山代码传给你谷的时候丢了哪怕一个字符也是不可接受的。

网络层、数据链路层只负责传输，但不能解决传错了怎么办、传乱了怎么办、传丢了怎么办……这些都是 TCP 协议负责的。

前四层负责对实际的数据传输，合称为“传输流层”。

后面的剧情可能会脱离主线（？），时间交给应用层，那就是下一篇的东西了。

总结#

先上一张图镇楼：

开头的题也可以解决了。

查图得 ARP 是数据链路层的，UDP 是传输层的，ICMP 是网络层的，而 SMTP 是做邮件的属于应用层，故选 C。

另外，关于 TCP/IP 五层模型，就是把没讲到的会话层、表示层和应用层合并成应用层。四层模型则是将网络层改名网际层（其实也可以不改，反正差不多），同时将数据链路层和物理层合并为“网络接口层”。

本文讲到了很多协议，但协议本身都很复杂，这里都是简化的版本，也可能会有不符协议之处，希望大家指正。

更新记录#

2025/08/12：新建文件。

2025/08/14：初稿过审全站推荐。

upd on 2025/08/15：更新图片并修复了一些错别字等 bug；修正 TCP 拥塞控制部分的错误表述。自动重新交审。

upd on 2025/08/16：为子网掩码部分图文矛盾增加说明。其实都是对的。然而还没有审核。

upd on 2025/08/19：润色一些文字，修正对 IPv5 的错误表述。然而新一周的管理都上任了仍然没有审核。

参考资料/推荐阅读#

排名不分先后。文中部分图片来自这些资料，这里一并表示感谢。

题解：B4377 [蓝桥杯青少年组省赛 2025] 平衡奇偶位置的字符交换

Tue, 12 Aug 2025 09:06:56 GMT

考场做法逆天，结果发现是正解……

卡卡常（其实也没怎么卡）直接最优解榜一（查看时间：2025/08/12 09<08>）

先说结论：令奇数位的 A 有 XXX 个，偶数位的 A 有 YYY 个，那么如果 ∣X−Y∣\left| X - Y \right|∣X−Y∣ 是奇数那么无解，否则答案是 ∣X−Y∣2\dfrac{\left| X - Y \right|}{2}2∣X−Y∣。

为什么呢？其实证明也很简单。

首先我们发现题目只和字母 AAA 相关，而且关键在于奇数位的 A 和偶数位的 A，于是我们分别对其计数。

然后我们考虑操作会产生什么影响。

每次可以选择交换两个位置相邻的字符。——题目

相邻的两个数显然是一奇一偶，而交换这两个只可能是奇数位换到偶数位（或偶数换到奇数位）。

这样就可以让奇数的数量减少一个，偶数增加一个（或者反过来）。

一个加一，另一个减一，它们的差当然是减少 222 了。而且每次操作都会减少 222，因为必然是奇换偶或偶换奇。因此得到了上面的结论，证毕。

带注释 AC Code：

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
int a, b, n;  // a 是偶数位，b 是奇数位，n 是字符串长度
6
string s;
7

8
int main() {
9
    ios::sync_with_stdio(false);
10
    cin.tie(0), cout.tie(0);
11
    cin >> s;
12
    n = s.size();
13
      for (int i = 0;i < n;++i) if (s[i] == 'A') {  // 注意到和 B 无关因此要判断
14
        if (i % 2) ++b;  // %2 余 0 就是 false，余 1 就是 true，正好分别对应偶数和奇数
15
        else ++a;
16
    }
17
    if ((abs(b - a)) % 2) cout << -1 << endl;  // 不知道谁大谁小，因此要取绝对值
18
    else cout << ((abs(b - a)) >> 1) << endl;  // 右移 1 位相当于除以 2，因为是非负数所以和 / 2 没有区别
19
    return 0;
20
}

展开收起

AC 记录~

理解万岁！

题解：P9704 「TFOI R1」Tree Home

Thu, 07 Aug 2025 10:12:32 GMT

WARNING

本文会带你保姆级推公式，应该是题解中推公式最详细的一篇才不是因为我数学和 OI 都太菜了，因而用到了大量数学公式，可能会加载较慢，请耐心等待。

挺逆天的一道数学题。

这个 fff 函数有 333 个参数明显不好处理，那我们拿出做初一化简求值题的感觉直接化简：

f(a,b,c)=[a−b](a2+b2+ab+3ac+3bc+3c2)=a(a2+b2+ab+3ac+3bc+3c2)−b(a2+b2+ab+3ac+3bc+3c2)=(a3+ab2+a2b+3a2c+3abc+3ac2)−(a2b+b3+ab2+3abc+3b2c+3bc2)=a3+ab2+a2b+3a2c+3abc+3ac2−a2b−b3−ab2−3abc−3b2c−3bc2=a3+3a2c+3ac2−b3−3b2c−3bc2\begin{align*} & f(a, b, c) = [a - b](a^2 + b^2 + ab + 3ac + 3bc + 3c^2) \\ & = a(a^2 + b^2 + ab + 3ac + 3bc + 3c^2) - b(a^2 + b^2 + ab + 3ac + 3bc + 3c^2) \\ & = (a^3 + ab^2 + a^2b + 3a^2c + 3abc + 3ac^2) - (a^2b + b^3 + ab^2 + 3abc + 3b^2c + 3bc^2)\\ & = a^3 + ab^2 + a^2b + 3a^2c + 3abc + 3ac^2 - a^2b - b^3 - ab^2 - 3abc - 3b^2c - 3bc^2 \\ & = a^3 + 3a^2c + 3ac^2 - b^3 - 3b^2c - 3bc^2 \end{align*}f(a,b,c)=[a−b](a2+b2+ab+3ac+3bc+3c2)=a(a2+b2+ab+3ac+3bc+3c2)−b(a2+b2+ab+3ac+3bc+3c2)=(a3+ab2+a2b+3a2c+3abc+3ac2)−(a2b+b3+ab2+3abc+3b2c+3bc2)=a3+ab2+a2b+3a2c+3abc+3ac2−a2b−b3−ab2−3abc−3b2c−3bc2=a3+3a2c+3ac2−b3−3b2c−3bc2

这个部分很简单，乘法分配律然后去括号抵消一些项就好了。

接着把 a=dp−dr,b=dq−dr,c=dra = d_p - d_r, b = d_q - d_r, c = d_ra=dp−dr,b=dq−dr,c=dr 代入：

a3+3a2c+3ac2−b3−3b2c−3bc2=(dp−dr)3+3(dp−dr)2dr+3(dp−dr)dr2−(dq−dr)3−3(dq−dr)2dr−3(dq−dr)dr2=(dp3−3dp2dr+3dpdr2−dr3)+3dr(dp2+dr2−2dpdr)+3dr2dp−3dr3−(dq3−3dq2dr+3dqdr2−dr3)−3dr(dq2+dr2−2dqdr)−3dr2dq+3dr3=dp3−3dp2dr+3dpdr2−dr3+3drdp2+3drdr2−6dpdr2+3dr2dp−3dr3−dq3+3dq2dr−3dqdr2+dr3−3drdq2−3dr3+6dqdr2−3dr2dq+3dr3=(dp3−dq3)+(3dpdr2−6dpdr2+3dr2dp)+(dr3−dr3)+(3drdp2−3dp2dr)+(3dr3−3dr3)+(3dq2dr−3drdq2)−(3dqdr2−6dqdr2+3dr2dq)+(3dr3−3dr3)=dp3−dq3\begin{align*} & a^3 + 3a^2c + 3ac^2 - b^3 - 3b^2c - 3bc^2\\ & = (d_p - d_r) ^ 3 + 3(d_p - d_r)^2d_r + 3(d_p - d_r)d_r^2 - (d_q - d_r)^3 - 3(d_q - d_r)^2d_r - 3(d_q - d_r)d_r^2\\ & = (d_p^3 - 3d_p^2d_r + 3d_pd_r^2 - d_r^3) + 3d_r(d_p^2 + d_r^2 - 2d_pd_r) + 3d_r^2d_p - 3d_r^3 - (d_q^3 - 3d_q^2d_r + 3d_qd_r^2 - d_r^3) - 3d_r(d_q^2 + d_r^2 - 2d_qd_r) - 3d_r^2d_q + 3d_r^3\\ & = d_p^3 - 3d_p^2d_r + 3d_pd_r^2 - d_r^3 + 3d_rd_p^2 + 3d_rd_r^2 - 6d_pd_r^2 + 3d_r^2d_p - 3d_r^3 - d_q^3 + 3d_q^2d_r - 3d_qd_r^2 + d_r^3 - 3d_rd_q^2 - 3d_r^3 + 6d_qd_r^2 - 3d_r^2d_q + 3d_r^3\\ & = (d_p^3 - d_q^3) + (3d_pd_r^2 - 6d_pd_r^2 + 3d_r^2d_p) + (d_r^3 - d_r^3) + (3d_rd_p^2 - 3d_p^2d_r) + (3d_r^3 - 3d_r^3) + (3d_q^2d_r - 3d_rd_q^2) - (3d_qd_r^2 - 6d_qd_r^2 + 3d_r^2d_q) + (3d_r^3 - 3d_r^3)\\ & = d_p^3 - d_q^3 \end{align*}a3+3a2c+3ac2−b3−3b2c−3bc2=(dp−dr)3+3(dp−dr)2dr+3(dp−dr)dr2−(dq−dr)3−3(dq−dr)2dr−3(dq−dr)dr2=(dp3−3dp2dr+3dpdr2−dr3)+3dr(dp2+dr2−2dpdr)+3dr2dp−3dr3−(dq3−3dq2dr+3dqdr2−dr3)−3dr(dq2+dr2−2dqdr)−3dr2dq+3dr3=dp3−3dp2dr+3dpdr2−dr3+3drdp2+3drdr2−6dpdr2+3dr2dp−3dr3−dq3+3dq2dr−3dqdr2+dr3−3drdq2−3dr3+6dqdr2−3dr2dq+3dr3=(dp3−dq3)+(3dpdr2−6dpdr2+3dr2dp)+(dr3−dr3)+(3drdp2−3dp2dr)+(3dr3−3dr3)+(3dq2dr−3drdq2)−(3dqdr2−6dqdr2+3dr2dq)+(3dr3−3dr3)=dp3−dq3

式子很长，但思路很简单，就是先用完全平方公式（(a−b)2=a2+b2−2ab(a - b)^2 = a^2 + b^2 - 2ab(a−b)2=a2+b2−2ab）和完全立方公式（(a−b)3=a3−3a2b+3ab2−b3(a - b)^3 = a^3 - 3a^2b + 3ab^2 - b^3(a−b)3=a3−3a2b+3ab2−b3）以及乘法分配律代入替换拆括号（第一、二步）然后疯狂合并同类项发现基本都抵消了（第三步），然后就剩下了这么个可可爱爱简单的式子（暴力出奇迹.jpg）。

ps：有没有大佬有简单的方法化简呢？手敲 KaTeX 化简了十几分钟 Qwq。

说句闲话：原式中出现了大量的 drd_rdr，化简完竟然和它无关……化简这个式子估计占了题目难度的一半。

于是题目要求的式子就是 ∣dp3−dq3∣+∣vp−vq∣|d_p^3 - d_q^3| + |v_p - v_q|∣dp3−dq3∣+∣vp−vq∣。然后鉴于有绝对值，继续利用初一知识分类讨论，有以下四种情况：

原式（用 SSS 表示）

S=max⁡{dp3−dq3+vp−vq=(dp3+vp)−(dq3+vq)(dp>dq&vp>vq)dq3−dp3+vp−vq=(dq3−vq)−(dp3−vp)(dp<dq&vp>vq)dp3−dq3+vq−vp=(dp3−vp)−(dq3−vq)(dp>dq&vp<vq)dq3−dp3+vq−vp=(dq3+vq)−(dp3+vp)(dp<dq&vp<vq)S=\max \begin{cases} d_p^3 - d_q^3 + v_p - v_q = (d_p^3 + v_p) - (d_q^3 + v_q) & (d_p > d_q \And v_p > v_q) \\ d_q^3 - d_p^3 + v_p - v_q = (d_q^3 - v_q) - (d_p^3 - v_p) & (d_p < d_q \And v_p > v_q) \\ d_p^3 - d_q^3 + v_q - v_p = (d_p^3 - v_p) - (d_q^3 - v_q) & (d_p > d_q \And v_p < v_q) \\ d_q^3 - d_p^3 + v_q - v_p = (d_q^3 + v_q) - (d_p^3 + v_p) & (d_p < d_q \And v_p < v_q) \end{cases}S=max⎩⎨⎧dp3−dq3+vp−vq=(dp3+vp)−(dq3+vq)dq3−dp3+vp−vq=(dq3−vq)−(dp3−vp)dp3−dq3+vq−vp=(dp3−vp)−(dq3−vq)dq3−dp3+vq−vp=(dq3+vq)−(dp3+vp)(dp>dq&vp>vq)(dp<dq&vp>vq)(dp>dq&vp<vq)(dp<dq&vp<vq)

然后我们发现每个式子都有两个项下标一样，可以一起处理。于是我们令 Ai=di3+vi,Bi=di3−viA_i = d_i^3 + v_i, B_i = d_i^3 - v_iAi=di3+vi,Bi=di3−vi，然后把上面四个式子整理一下，分别是：

Ap−AqBq−BpBp−BqAq−Ap\begin{align*} A_p - A_q\\ B_q - B_p\\ B_p - B_q\\ A_q - A_p\\ \end{align*}Ap−AqBq−BpBp−BqAq−Ap

如果需要最大化原式那么我们需要让被减数尽量大，减数尽量小。由于区间被指定了所以这说到底是个 RMQ，而由于没有修改因此可以通过 444 个 ST 表维护。

终于我们有了最终思路：

预处理出 ddd 数组
利用 ST 表查询
比较得出结果

时间复杂度分为两部分，预处理 ddd 数组可以用一个 dfs，时间复杂度 O(n+m)O(n + m)O(n+m)，由于是一棵树所以 m=n−1m = n - 1m=n−1，最终忽略常数复杂度就是 O(n)O(n)O(n)。ST 表预处理为 O(nlog⁡n)O(n \log n)O(nlogn)，查询为 O(1)O(1)O(1)，可以通过。

ACCode（带注释）：

1
/*Code by Block_Fish*/
2
#include <bits/stdc++.h>
3

4
#define INF 0x3f3f3f3f
5
#define EPS 1e-8
6
#define FOR(i, l, r) for (ll(i) = (l); (i) <= (r); ++(i))
7
#define log printf
8
#define IOS                      \
9
  ios::sync_with_stdio(false); \
10
  cin.tie(nullptr);            \
11
  cout.tie(nullptr);
12

13
using namespace std;
14

15
typedef __int128 i128;
16
typedef long long ll;
17
typedef pair<ll, ll> PII;
18

19
const ll N = 2e5 + 10;
20
ll n, t, u, v, w, a[N], l1, l2, r1, r2, lg2[N], dis[N], st1[30][N], st2[30][N], st3[30][N], st4[30][N];
21
vector<PII> g[N];
22

23
template <typename T>
24

25
inline T read() {
26
  T sum = 0, fl = 1;
27
  char ch = getchar();
28
  for (; !isdigit(ch); ch = getchar())
29
    if (ch == '-') fl = -1;
30
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
31
  return sum * fl;
32
}
33

34
template <typename T>
35

36
inline void write(T x) {
37
  if (x < 0) {
38
    putchar('-'), write<T>(-x);
39
    return;
40
  }
41
  static T sta[35];
42
  ll top = 0;
43
  do { sta[top++] = x % 10, x /= 10; } while (x);
44
  while (top) putchar(sta[--top] + 48);
45
}
46

47
// 4 个 ST 表，很长但是基本复制粘贴
48
void init() {
49
  lg2[2] = 1;
50
  FOR(i, 1, n) {
51
    st1[0][i] = st2[0][i] = dis[i] * dis[i] * dis[i] + a[i];
52
    st3[0][i] = st4[0][i] = dis[i] * dis[i] * dis[i] - a[i];
53
  }
54
  FOR(i, 3, n) lg2[i] = lg2[i >> 1] + 1;
55
  FOR(i, 1, lg2[n]) {
56
    ll len = 1 << i;
57
    FOR(j, 1, n - len + 1) {
58
      st1[i][j] = max(st1[i - 1][j], st1[i - 1][j + (len >> 1)]);
59
      st2[i][j] = min(st2[i - 1][j], st2[i - 1][j + (len >> 1)]);
60
      st3[i][j] = max(st3[i - 1][j], st3[i - 1][j + (len >> 1)]);
61
      st4[i][j] = min(st4[i - 1][j], st4[i - 1][j + (len >> 1)]);
62
    }
63
  }
64
}
65

66
// 好的函数命名可以方便写代码和调试
67
ll queryMax1(ll l, ll r) {
68
  ll k = lg2[r - l + 1], len = 1 << k;
69
  return max(st1[k][l], st1[k][r - len + 1]);
70
}
71

72
ll queryMin1(ll l, ll r) {
73
  ll k = lg2[r - l + 1], len = 1 << k;
74
  return min(st2[k][l], st2[k][r - len + 1]);
75
}
76

77
ll queryMax2(ll l, ll r) {
78
  ll k = lg2[r - l + 1], len = 1 << k;
79
  return max(st3[k][l], st3[k][r - len + 1]);
80
}
81

82
ll queryMin2(ll l, ll r) {
83
  ll k = lg2[r - l + 1], len = 1 << k;
84
  return min(st4[k][l], st4[k][r - len + 1]);
85
}
86

87
// 要先预处理出 d 数组
88
void dfs(ll now, ll fa) {
89
  for (auto v : g[now]) {
90
    if (v.first == fa) continue;
91
    dis[v.first] = dis[now] + v.second;   // 要继承父亲的 d 然后加上自己的
92
    dfs(v.first, now);
93
  }
94
}
95

96
int main() {
97
  n = read<ll>(), t = read<ll>();
98
  FOR(i, 1, n) a[i] = read<ll>();
99
  FOR(i, 2, n) {
100
    u = read<ll>(), v = read<ll>(), w = read<ll>();
101
    g[u].push_back({v, w}), g[v].push_back({u, w});
102
  }
103
  dfs(1, -1);
104
  init();   // ST 表和线段树都要初始化！
105
  while (t--) {
106
    l1 = read<ll>(), r1 = read<ll>(), l2 = read<ll>(), r2 = read<ll>();
107
    write<ll>(max({queryMax1(l1, r1) - queryMin1(l2, r2), queryMax1(l2, r2) - queryMin1(l1, r1), queryMax2(l1, r1) - queryMin2(l2, r2), queryMax2(l2, r2) - queryMin2(l1, r1)})), putchar('\n');  // 输出的 4 种情况取 max
108
  }
109
  return 0;
110
}

展开收起

AC 记录~

代码很长，但是非常模块化，写起来不是很慢。

理解万岁！

题解：P1001 A+B Problem

Sat, 10 May 2025 21:30:41 GMT

核弹打蚊子题。

正解#

人口普查代码，直接公布如下了：

1
#include <iostream>
2

3
using namespace std;
4

5
int a, b;
6

7
int main() {
8
    cin >> a >> b;
9
    cout << a + b << endl;
10
    return 0;
11
}

整活#

声明：本文灵感来源于此文：文章公众号链接和知乎

首先，我们要请出一个预编译指令：define

{% folding::blue 什么是预编译指令？ %}

首先，我们需要知道编译的流程。第一步就是这个预编译，这些指令一般以 # 开头，比如常见的 #include 就是，它的处理方法就是递归把被 #include 的东西塞到文件上去。

而这个 define 的作用类似于查找并替换（全字匹配），会被替换掉，之后不影响编译。同时注释也会在这个流程中被隐去。

接着就是编译和汇编，分别是把你的代码转换为汇编代码，然后才是机器码。然后会进行一种叫“链接”的操作，此时才算完毕。 {% endfolding %}

比如说，想开 long long 了，你是不是写过：#define int long long？（srds，根据宝硕大佬的文章和相关标准，这个操作并不好）

然后，我们就可以写出酱紫的代码：

如图所示

啊 bushi，是这个：

1
#define So include
2
#define I iostream
3
#define Say using
4
#define A namespace
5
#define little std
6
#define prayer int
7
#define my int
8
#define dreams main
9
#define will cin
10
#define take And
11
#define me hope
12
#define there cout
13
#define where And
14
#define the hope
15
#define skys endl
16
#define are return
17
#define blue 0
18

19
#include <iostream>
20
// 注意到预编译指令的周围都有非空格符号，不满足“全字匹配”的定义，因此不得不放弃这么搞。
21
// 在小 L 本地上，中文似乎会 CE，因此选了一首英文歌
22

23
// So I
24

25
Say A little;
26

27
prayer And, hope;
28

29
my dreams() {
30
  will >> take >> me;
31
  there << where + the << skys;
32
  are blue;
33
}

展开收起

AC 记录~

当然，也可以是这个:

1
#include <iostream>
2

3
#define _ using
4
#define __ namespace
5
#define ___ std
6
#define ____ int
7
#define _____ a
8
#define ______ b
9
#define _______ main
10
#define ________ cin
11
#define _________ cout
12
#define __________ endl
13
#define ___________ return
14
#define ____________ 0
15

16
_ __ ___;
17

18
____ _____, ______;
19

20
____ _______() {
21
    ________ >> _____ >> ______;
22
    _________ << _____ + ______ << __________;
23
    ___________ ____________;
24
}

展开收起

AC 记录~

老师：你搁这儿发电报呢

同学：古诗文填空中，发现没有题干，炸了

理解万岁！

复出的第一篇文章&两场 ACM 竞赛的混合游寄

Thu, 01 May 2025 10:24:47 GMT

小 L积木鱼残血复活啦！最近在研究 whk，OI 也比较废，姑且就写写游记水一水吧。

由于电脑比较烂删了很多必要的组件，加上之前一段时间写的都是长文（当然，都没写完），因此拖更了很长时间，不好意思哈！

本次依然按照时间顺序~

无趣味提问：不用快捷键，快来快来数一数，本文中有几个“莫名其妙”（包含这一个）？24678。

Day −∞-\infty−∞#

N 多 years ago，老师莫名其妙的找了个 CUHK(【某经济特区】) 的比赛名额，小 L积木鱼作为这一届前最强的选手自然也要来参加！

然鹅，期中考逝就要到了，小 L积木鱼只好把 whk 时间提高到了 900%900\%900%（别问我为啥这么莫名其妙）

后面又多了个去 SZTU 的比赛。

笑点解析：小 L积木鱼从 PS 干到 GM （小 L积木鱼所在的【某经济特区】的两个区）才上的 5231（指现在这个学校，这是小 L积木鱼字丑闹出来的笑话 awa），本想着到其他地方上课、比赛啥的可以近一点，结果比赛的时候又给我干回 PS 去了……

Day 1#

本次比赛官方名称叫什么“国际编程大赛”。学校在离 PS 很近的 LG（不是你谷啦）区。让我比较惊喜的是可以带纸质资料哎！虽然实践表明没啥大用

上午热身赛#

本来到的比较早的了（总部那些人上午的热身赛干脆不打了），但是到了地方还是人巨多。而且我竟然不知道自己是哪个赛道的（有 A、B、C 三个，后续得知 A 是内部的，B 是小 L积木鱼这种xxs中小学生的，C 打得好可以保博）

朋友圈截图0（不含点赞）

经过不懈的——排队，拿到了参赛证，进入机房，结果机子死活登不上去。后面改了三五回密码，终于进去了（密码的！）

这里莫名其妙的只能用 Dev-C++ 这种老古董，VSCode 没配置（考场机器老毛病了），鉴于是 ACM 赛制要卡时间就不用了。

上午 Track B 参赛 48 人，小 L积木鱼以做出 111 题的成绩位列第 17 名（一共 444 道题）。

笑点解析：比赛提供中英双语题面，中文在 B 题的链接里，点了 A 题链接看到题目就开始做的小 L积木鱼愣是仗着自己英语好看了半天的英文题面。

中午#

先是打了 GD 省 CIE 的一场弱智比赛。从上周莫名其妙的延期到这天的，理由竟是服务器炸了？还 TM 只有选判，若只啊……这还是那个敢对战 CCF 的 CIE 吗？校内信号还贼差（只允许访问内部 OJ），我*****

upd on 2025/05/31：晋级了，888888，但是参赛体验感极差，因为网还迟到了几分钟，但是差不多半个小时就答完了，但是还是错过了集体合照虽然没啥用。

更逆天的是妈妈莫名其妙九点多点的外卖莫名其妙的十一点了还没送到……店就在校内啊……相距只有 1 公里多啊……这要十几分钟？骑手的电驴比我跑的都慢啊……干脆取消订单去食堂了。

不过食堂很干净也很香，比去年集训去的某双非强多了……

遂发朋友圈，结果莫名其妙的得到了老师的点赞，不要哇……

朋友圈截图1

下午#

正式比赛#

开题。然后第一题：

我是奶龙！我才是奶龙！

啊，不是戈门，您这玩意儿它对吗？怎么这么莫名其妙的？

不过 A 题就是个莫名其妙的字符串处理的水题，7min 拿到气球（真的有哎！）。

后续 B 题是个约瑟夫模板，小 L积木鱼愣是写了莫名其妙的半个多小时然后莫名其妙的用了双向循环链表才过的。不过好歹莫名其妙的没吃上罚时，而且莫名其妙跑的不算慢。

C 题因为莫名其妙地没看题（逃挂了一发，但是比 B 题写的快。

后面的比赛全程死磕 D 一道莫名其妙的中模拟（看了一下 E、F，都不会），最后交了 888 发愣是莫名其妙地没过。然后比赛结束了。不过比莫名其妙地比隔壁莫名其妙高中了但是莫名其妙爆炸的（奶龙题都没过！）的莫名其妙大哥强。

讲评#

ABCD 都是水题，D 题我想对了，应该还是细节吧。

后面的题解拍照就好了。

集团一共 6 人获奖，我排第 7……

笑点解析：

学校运动会，我班 444 支队伍，期中 333 支位列年级前 333，我们队全班第 444……
期中考逝，小 L积木鱼上学期两次年级第一的实力不出前 222 就死不了，结果一对分数，第 333……（幸好不让公布排名否则就真去世了……）

总结：老是差一名。

不过虽然没拿到奖品，但是白嫖 222 瓶水和 111 支铅笔。

朋友圈截图2

Day 2#

期中考逝，结果除了地理 (49/5049/5049/50) 之外全部玩儿脱了……第一次掉出前二（rk 333）……

比如说，之前 49/5049/5049/50（期中）、40/4540/4540/45（期末，全区第一 414141）的生物，选择挂了 444 个，只有 454545 了……

比如说，之前只扣 0.50.50.5 分的英语作文（14.5/1514.5/1514.5/15），如今只剩 131313 了……

错，错，错。

哭点解析：班长当了一个半学期的年级第 333（稳定的离谱），被我给干退步了……

Day 3#

跑到 PS 考 SZTU。

入场前#

百里迢迢来到现场比赛，然后发现车找不到停车场和考场:)

朋友圈

不过和教练以及本部的二位大佬会合了，然后莫名其妙（我怎么莫名其妙的是个这么莫名其妙的人？）的成了敲代码的。教练检验了一下 whk，竟然过关了（他本来要求年级前 100100100，但我们整个初中部就我们一个年级，一共才 119119119 个人……还有一个国家一级运动员下午不上课、考试看随机的 dalao。

真·把答题卡丢地上踩两脚就行）

封面图便摄与场外。

封面图

场内#

正式了很多，但是气球组明显效率不高。

由于考试有 555 个小时，所以要自备干粮，然后我们的被隔壁组抢了（

不过这次的 VSCode 配置好了哎！就是不知道为什么一份代码它和 Dev 的结果不一样（UB？）

先做的 A 啦，语言入门题。但是莫名其妙（又莫名其妙！）的在线处理会很慢，经隔壁队的提醒离线就过了。

在 A 题莫名其妙的过程中，小 L积木鱼突然发现 G 题只有输出，然后队友飞速把它秒了。

接着做完 A 之后，小 L积木鱼开始拼 F，但是样例一直没过（莫名其妙的每个答案都大 222），考后得知叫什么斯坦纳树，我就说为嘛我 Floyd 过不了嘛（

两位队友尝试找 E 题（数学题）的规律和想 J，但是 J 写完之后一直没过，E 一直没想出来。后续小 L积木鱼接手，一顿提交之后用队列滑动窗口极限过掉了此题（此时距比赛结束还剩不到半个小时），摆脱了队伍成为倒一的厄运虽然是倒二，同时得到了隔壁组的紧急抄袭学习，队友直呼自己是躺赢狗（A 题中的梗）

与此同时，队友们找到了首 A E 题的队伍（也是我们集团的），和隔壁队伍等一起沟通后交给小 L积木鱼找规律，小 L积木鱼最终极限（距比赛结束还剩 6min）时将规律全部找出，但是没空写了。和预期一样，首 A 队伍的代码很短。

由于小 L积木鱼回家需要横跨整个市，教练就让小 L积木鱼先回去了，最后奖项：“成功参赛”？

证书比较简陋，老师的名字之间甚至没有空格……

结束了。

趣味题答案：整整 282828 个！

GESP 202412 游记

Sun, 08 Dec 2024 18:50:46 GMT

这次终于不寄了，555……

Day -∞\infty∞#

9 月刮台风了，自动改成 12 月，离大谱……

报名，还是团报（据说能提前查分）。GD 省 SZ 市共提供考点 2 个：SZYH 和 HIT(SZ)，由于产生了 YH 恐惧症（考 6 级在这里寄了一回 + 去年 CSP-J 不给我 Linux 用结果 T1 数组起猛直接保龄令人窒息），所以选了 HIT。

u1s1，这把要是过了，那么 SZYH 的嫌疑就逃不掉了（

Day -4#

老师：你做一下运动会主持，我中午把稿子改好拿给你

【已连续负责 333 场主持的】我：没问题

中午去了之后：老师呢？

睡觉呢，因为去办公室看了一下被同一办公室的校医轰了出去（

Day -3#

拿到稿子了，免除徭役列方队。

不过那方队本来就离谱，我身高 1.74m，附近方圆 5 个位置就没有超过 1.65m 的……

Day -2#

丸辣，运动会在——周六？？？下午 13<30> 就要 GESP。

鉴于我家距离考点约 40min，还要提前 30min 入场，而运动会则要全天，废了。

跟老师沟通后光荣下岗，回去走方队喽~

谁家好学校周六搞活动还让全校都参加啊喂

Day -1#

彩排。我的位置被换成了隔壁班班长。

第一次读：这什么玩意儿？

第二次读：可算有那味儿了。

虽然已下岗，但还是要默默关心

然后被加训了（全班），又要值日（我是组长，义务劳动ing……）

竟然这还有人敢跑路？？？激起了公愤被老师一个电话又轰了回来。

作业没法减，熬到 19：00

Day 0#

第二次彩排，并布置了巨量作业。

全班被抓去做苦力测试绳子去了，然后有同学的绳子只有绳柄没有绳，不卡绳 1min 直接 846 个破世界纪录（

以上内容只为说明基本是在裸考，刷题量：0

不过今年 S 组拿了二等，稳切橙的实力还是有的，应该能过。

Day 1#

上午#

运动会开幕式，穿班服。在人群中极为耀眼。

哎，同学们怎么都在补作业？就我没带吗？？？

鉴于是体育差生，比赛项目开始摆烂烂……

1min⁡1\min1min 跳绳 260260260 个拿最低等的？？？哦哦哦，原来是三年累计，那我拿到这一级就算满足了

实际成绩：949494 个（？？？）

体育中考没救了。。。

团体赛，跳长绳。每个班 4 个组，有三个是年级前三，问题是我们是全班第 4……

10:50，跑路，回家吃饭，上路

Touching fish……

下午#

SZ 大学？走错了？哦哦哦，是 SZ 大学城。

7 级题最水的一次，编程题 T1 是个 01 背包模板，开考 25min⁡25\min25min 就 AC 了（实际用时 10min⁡10\min10min，还是在我现场推公式的基础上）

T2 卡了半天，dfs、bfs、各种选初始节点的方法都想过，最后写了个记搜，过了，此时时间是 15:55。

又检查了一下选择判断，提前 30min 离场。

碰到一个 2—>4—>6 跳上来的，/jk

晚上#

上周 ABC 过了 ABCD（可惜网络问题 unrated），这周被降智只会 A&B，不过 rating 393—>401？？？

Day 2#

官方公布了题目和答案，估分 888888，反正可以免 J 了。

Day ∞\infty∞#

查分，还真 TM 88 啊……过于吉利了……

本来想冲荣誉榜的，算了，cbddl。

不过后续官方好像不公布了？也好。

无论如何，以后拒绝 YH，人人有责！

题解：AT_abc381_c [ABC381C] 11/22 Substring

Sat, 23 Nov 2024 22:24:02 GMT

显然这个“11/22 Substring”是以那个“/”为中心对称的。鉴于一个这样的字符串只能有一个“/”，而题目又要求最长，所以确定了“/”就能确定一个满足要求的子串。

那思路就很简单了，只有两步：

找到所有的“/”
两边同时寻找相应的子串。

别的，除了判断一下越界之外，就不用管了。

ACCode：

1
/*Code by Block_Fish
2
*/
3
#include <bits/stdc++.h>
4

5
#define INF 0x3f3f3f3f
6
#define EPS 1e-8
7
#define FOR(i, l, r) for (int(i) = (l); (i) <= (r); ++(i))
8
#define log printf
9
#define IOS                      \
10
  ios::sync_with_stdio(false); \
11
  cin.tie(nullptr);            \
12
  cout.tie(nullptr);
13

14
using namespace std;
15

16
typedef __int128 i128;
17
typedef long long ll;
18
typedef pair<int, int> PII;
19

20
int n, ans;
21
string s;
22

23
template <typename T>
24

25
inline T read() {
26
  T sum = 0, fl = 1;
27
  char ch = getchar();
28
  for (; !isdigit(ch); ch = getchar())
29
    if (ch == '-') fl = -1;
30
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
31
  return sum * fl;
32
}
33

34
template <typename T>
35

36
inline void write(T x) {
37
  if (x < 0) {
38
    putchar('-'), write<T>(-x);
39
    return;
40
  }
41
  static T sta[35];
42
  int top = 0;
43
  do { sta[top++] = x % 10, x /= 10; } while (x);
44
  while (top) putchar(sta[--top] + 48);
45
}
46

47
int main() {
48
  IOS;
49
  cin >> n >> s;
50
  for (int i = 0; i < n; ++i) {
51
    if (s[i] == '/') {
52
      int l = i - 1, r = i + 1, len = 1;
53
      while (l >= 0 && r < n)
54
        if (s[l] == '1' && s[r] == '2') --l, ++r, len += 2;  // 左右同时寻找，所以是 +2
55
        else break;  // 不满足了及时break
56
      ans = max(ans, len);
57
    }
58
  }
59
  write<int>(ans);
60
  return 0;
61
}

展开收起

AC 记录~

理解万岁！

题解：P11248 [GESP202409 七级] 矩阵移动

Sat, 09 Nov 2024 17:51:02 GMT

笑点解析：这个人所在城市考试当天刮台风了，没考，免费送了一次 12 月的考试。

设计这么一个东西：

dpi,jdp_{i,j}dpi,j 表示到格子 (i,j)(i, j)(i,j) 的最大分数。

本来还好，但现在的问题是，如果这个格子是‘？’，我哪儿知道到底可不可以变啊？万一变得太多了，那，那不就废了！万一少了，那我分不就没了？

所以我们需要到底还剩多少次机会呢？不好办，没法儿处理。

其实加一维记录就可以了。

于是我得到了这个状态：

dpi,j,kdp_{i, j, k}dpi,j,k = 到格子 (i,j)(i, j)(i,j) 且已经使用了 kkk 次机会的最大值。

转移也很好推：

不是‘？’：

dpi,j,k={max⁡(dpi,j−1,k,dpi−1,j,k)+1(i,j)=1max⁡(dpi,j−1,k,dpi−1,j,k)(i,j)=0dp_{i, j, k} = \begin{cases} \max(dp_{i, j - 1, k}, dp_{i - 1, j, k}) + 1& (i, j) = 1\\ \max(dp_{i, j - 1, k}, dp_{i - 1, j, k})& (i, j) = 0\\ \end{cases}dpi,j,k={max(dpi,j−1,k,dpi−1,j,k)+1max(dpi,j−1,k,dpi−1,j,k)(i,j)=1(i,j)=0

就是从两种可能的上一步转移过来，注意横竖均可。

是‘？’：

dpi,j,k={max⁡(dpi,j−1,k,dpi−1,j,k)+1k=0max⁡(dpi,j−1,k−1,dpi−1,j,k−1)+1k>0dp_{i, j, k} = \begin{cases} \max(dp_{i, j - 1, k}, dp_{i - 1, j, k}) + 1& k = 0\\ \max(dp_{i, j - 1, k - 1}, dp_{i - 1, j, k - 1}) + 1& k > 0\\ \end{cases}dpi,j,k={max(dpi,j−1,k,dpi−1,j,k)+1max(dpi,j−1,k−1,dpi−1,j,k−1)+1k=0k>0

同上，注意 k=0k = 0k=0 时不能使用机会。而且可以变的话当然是变了更好，所以 k>0k > 0k>0 时可以无脑使用。

AC Code:

1
/*Code by Block_Fish*/
2
#include <bits/stdc++.h>
3

4
#define INF 0x3f3f3f3f
5
#define EPS 1e-8
6
#define FOR(i, l, r) for (ll(i) = (l); (i) <= (r); ++(i))
7
#define log printf
8
#define IOS                      \
9
  ios::sync_with_stdio(false); \
10
  cin.tie(nullptr);            \
11
  cout.tie(nullptr);
12

13
using namespace std;
14

15
typedef __int128 i128;
16
typedef long long ll;
17
typedef pair<ll, ll> PII;
18

19
const int N = 510, M = 310;
20
int m, n, t, x, a[N][N], dp[N][N][M], ans;  // dp[i][j][k] = (1, 1) 到(i, j)，已经使用了k次机会的最大值
21
string s;
22

23
template <typename T>
24

25
inline T read() {
26
  T sum = 0, fl = 1;
27
  char ch = getchar();
28
  for (; !isdigit(ch); ch = getchar())
29
    if (ch == '-') fl = -1;
30
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
31
  return sum * fl;
32
}
33

34
template <typename T>
35

36
inline void write(T x) {
37
  if (x < 0) {
38
    putchar('-'), write<T>(-x);
39
    return;
40
  }
41
  static T sta[35];
42
  ll top = 0;
43
  do { sta[top++] = x % 10, x /= 10; } while (x);
44
  while (top) putchar(sta[--top] + 48);
45
}
46

47
int main() {
48
    IOS;
49
    cin >> t;
50
    while (t--) {
51
        cin >> n >> m >> x;
52
        FOR(i, 1, n) {
53
            cin >> s;
54
            for (int j = 0;j < m;++j) {
55
                if (s[j] == '?') a[i][j + 1] = -INF;
56
                else a[i][j + 1] = s[j] - '0';
57
            }
58
        }
59
        FOR(i, 1, n) FOR(j, 1, m) FOR(k, 0, x) {
60
              // 要用到 k - 1, 必须正序遍历。
61
            switch(a[i][j]) {
62
                case -INF:
63
                    if (k > 0) dp[i][j][k] = max(dp[i][j - 1][k - 1], dp[i - 1][j][k - 1]) + 1;
64
                    else dp[i][j][k] = max(dp[i][j - 1][k], dp[i - 1][j][k]);
65
                    break;
66
                case 1:
67
                    dp[i][j][k] = max(dp[i][j - 1][k], dp[i - 1][j][k]) + 1;
68
                    break;
69
                case 0:
70
                    dp[i][j][k] = max(dp[i][j - 1][k], dp[i - 1][j][k]);
71
                    break;
72
            }
73
        }
74
        FOR(i, 0, x) ans = max(ans, dp[n][m][i]);  // 不超过就是不一定，要遍历一遍
75
        cout << ans << endl;
76
        memset(dp, 0, sizeof(dp));
77
        memset(a, 0, sizeof(a));
78
        ans = -INF;
79
        // 多组数据要清空
80
    }
81
  return 0;
82
}

展开收起

AC 记录~

理解万岁！

CSP-J/S 2024 游寄

Sat, 09 Nov 2024 17:50:37 GMT

满纸荒唐言，一把辛酸泪。

其实不是去年没去，只是去年复赛喜提 15pts 荣获四等奖，木有获奖证书。今年决定一雪前耻！

坐标：窄西省浅圳市某郊区（。

该区是弱区，目前已知的唯一一个官方承认的（不包括我的省四）复赛获奖选手是 CSP-J2022 以 90pts 的高分荣获三等奖（T1 一个红题没 AC？这是咋过初赛的）。

注：下文中 Day 1.5、1.6、1.7 等指第一轮与第二轮之间的那几天，不保证在同一天（才不是因为小 L 的记忆力还不如鱼）

Day -1#

初赛之前暑假集训的时候过了几套模拟题（S 组），J 组由于去年前 10% 没管了（埋下伏笔）。初赛感觉还不错。

老师知道我要报 S 的时候还挺诧异的，毕竟是郊区，学校都是专门为了我注册的。

Day 1#

考点素有“紫色城堡”的美誉。但是是老校区了，感觉还是比较旧的（郊区人对市区的高估.jpg）。

因为是郊区，差一点就迟到了（全程超速）。为啥今年人这么多捏？

J#

这么简单？1h 轻松搞定。有几个题比较慌，但是没有问题。考着考着有了种 I AK CSP-J 的感觉。

考完之后有几个小同志不知为何把人家桌子给掀了（指抽屉），只能说是完全不懂考场纪律了。感觉就是语言入门赛，完全没有 CSP 的水平。

中午#

去餐馆吃的饭，妈妈表示祈祷我 S 能过（伏笔 ×2\times 2×2）。

S#

感觉有了正常 S 的难度。不过为啥改了 3 回题目？比赛公平系数大降。上午考 J 的下午基本都来了，不知道是不是来打酱油参加体验赛的。

出去的时候基本是被挤出去的，差一点儿就迷路了。考后个人感觉海星。

Day 1.5#

出成绩啦！S 54.5, J——72.5？

国线是 J 89, S 59，都没进。J 差这么多，废了。S 组还有救……

后面分数线一出，果然 J 没过，S 过了。照应伏笔 QaQ。

后面又对了一下，初赛喜提俩国二。按照惯例，就不申请纸质版了（没用），自己打印吧。

GESP 只有六级（我是蒟蒻），保送是不可能的，祭。

但是为啥又涨价了啊，题也就那水平，评测机也就那老爷机，你涨那么多几个意思啊？

Day 1.6#

学校月考，喜提全校第一（我才不会告诉你我们学校只有仅 3 个班的初一和不考试的小一两个年级）。自我感觉良好，优势项目都拿到了年级第一成功封神。whk 是不用管了，吗？

不可能的，总司令！

学校作业不少啊，天天肝到晚上十点多，学校比赛也有一大堆，QwQ。这个状态一直持续到复赛前一周，刷题数量基本为 0，橙名都给我掉绿喽。

摆。

Day 1.7#

开始准备复赛啦！终于进入了学校校队，初一组有二十几个人，但是，貌似，都是从 0 开始？加油吧！

老师很重视 whk 成绩，月考的高分给了老师一个好印象。我的 OI 水平在同年级当中直接登顶了（野路子确实不同寻常，比市区还 diao）。

集训了 3 天，刷了一下历年的 J 组题目，打了两场模拟赛。第一场优先队列符号打反，202020pts 没了，最后预估 100+60+25=185pts100 + 60 + 25 = 185pts100+60+25=185pts，实得 80+90+25=195pts80 + 90 + 25 = 195pts80+90+25=195pts，但是有高中部大佬半小时 AK 了。T2 因为图有特殊性质给了我 909090pts（官方 tj 承认了这一点，不是数据水），勉强挽回了一点尊严。第二场啥也不会，0（不过是初中组唯一参赛选手了）。

比完第一场之后被老师约谈了，老师竟然一听就听出来了我是个 HE 人。果然是 t 大学大佬。哪儿跟哪儿啊。

之后就是刷洛谷题单，语法组好简单！遇到的几个略难一点的题目也能捣鼓出来。

不过貌似我的实力最多也就橙~黄？废了啊啊啊……

Day 1.8#

考前一周，写题解争取 RP++，但是没过审，大祭。脑子不太灵光，计算题能给做出 606060 分的好成绩（满分 100100100，及格线 100100100），这种状态下通过玄学方法测了一下，发现是 rp—，悲。

Day 2#

复习了一上午总结（含防爆零指南）。毕竟只有 S 组，而我又是蒟蒻，时间还是充裕的。

这个考点是新建的高中园，有 3 高中，一文一理一个别的。三个高中至少 121212 个机房同时启动，可见今年规模非比寻常（CCF 你都知道为什么初赛还要瞎出题）。在 404040 多公里外（从一个郊区到另一个郊区），前几年的因为太小被开除了（doge）。

听说本部的住校生有专车？反正我这种弱区弱校选手只能打的了。听了一路歌，也就混过去了。听说我们教练也是监考老师（但不在一个高中，大悲）。

到地儿之后看了一下上午 J 组的题目，觉得 T1、T2 一眼秒（一红一橙，肯定的）。T2 实在是太裸了，预估分数线会很高。可惜木有机会去啊啊啊……

另外，貌似大多数选手都是强校的？我这个分校的分校就……

进入校园的时候迷路了，出来更晕，离大谱。不过感觉考务做的挺好。

比赛的时候突然发现机子坏了，重启了 5min⁡5 \min5min。重启之后 NOI Linux 虚拟机可以正常使用了，而且可以适配全屏，体验感不错。就是后面自测的时候 Aribter 崩了好几回（凡测必崩）。去年的那个考点不点名批评一下，设置了密码不让用，导致我 T1 开了 1e9 的数组测不出来爆炸了，损失一个 4 级绿钩+一个二等奖+一大堆因为没有钩而导致的在出 gks 时遇到的不便。

S 组 T1 第一反应竟然是二分答案？后面继续优化，什么暴力啥的，想了 1.5h，逆天。最后写了一个二分的 O(nlog⁡n)O(n \log n)O(nlogn) 解法，调了半天。不过好在最后测出来了，但是大样例 TLE 了？哦哦哦，原来是没开 O2，开了之后 0.3s 之内可以把四个样例全部跑过，文操正常。我也没想到考提高组能做出一道题来，好开森~~但问题是我不确定这玩意儿对不对，但看到 444 个样例各种情况的都过了，自己又简单的论证了一下，没问题也就过了。此题十分关键，过了就是绿钩甚至蓝钩，没过就是第二个省四。

T2 一个巨模拟考场上没看出来。最后写了一个 a=0a = 0a=0 的 20pts。中间还特地判了一下特殊情况，今年样例给的很强。其实结束前 10 min 想出了小数据做法（n,m≤20n, m \le 20n,m≤20 想这么半天，没救了），但是没空写了。考前一直希望 CCF 出大模拟，但是出现了没看出来，祭。话说去年考一元二次方程，那会儿我是小学生，这是初中知识点。现在我终于初中了，但你给我考初二甚至是高中的物理？【亿连串被屏蔽的暴戾语言】。

T3 没有任何思路，一个爆搜水过去。预估 202020pts。

T4 题都没看明白，索性就写了一个文操别的不管了（输入都没写）。

以上所有代码均经过反复检查，目录当中没有多余文件，文操和文件名正确，目录用发的 checker 查了一下正确，所有程序均能在 NOI Linux 2.0 中编译测试通过，样例均（除了几组压根儿就没写的）可以通过，注释无。

期望得分 100+20+20+0=140100 + 20 + 20 + 0 = 140100+20+20+0=140，实际能力 100+40+20+0=160100 + 40 + 20 + 0 = 160100+40+20+0=160，QwQ。

出来之后打车等了半天。一天交通费近 200200200，废。听别人讨论说 T1 有黄~绿？竟然能超水平发挥！T4 则是一个紫，明显是要从 333 道题当中选 444 道所以胡乱出题的场次。

Day 2.1#

写游记。暂时还没有代码，没法估分。不过样例都过了应该不至于爆零？

T1 翻了一下题解区，找到了同做法的 ACCode，稳啦。不过最简单做法是直接求众数出现次数？又双叒叕考超过我年龄的数学知识。这货评个橙，我脸上火辣辣的……

目前你谷难度比较乱，T2 在绿、蓝之间来回蹦哒，T4 飙到黑去了……

另外，话说你们怎么都那么快，比赛第二天游记都堆到十几页了？666。

Day 2.2#

出成绩啦！

100 + 0 + 20 + 0 = 120pts，T2 挂了。不过学校老师说很不错，总部的老师说初一这水平还可以，然后发我了亿点点资料、题目与课程，说让我明年冲刺提高组 200+ 的高分，我玉玉了）。

拿代码过去洛谷自测了一下，跟 CCF 完全一样，T2 全 WA，废。本来还想申诉的，现在不可能了。

这次考后的估分小程序只有小图灵考后还能使用。看了一下上面预估的分数线，2= 分数线 70pts，3= 50pts，我分数正好是它俩之和（突然感觉自己好牛 13 啊）。比全国平均分低 3 分（awa），省排 1274（共 3k+），自我感觉良好。

顺便去随便测了一下，发现几个考号和自己差不多的都是大佬，甚至出现了 100 + 100 + 100 + 64 = 364 的狠人，orz。

不过场切 T1 感觉还是可以的。没想到打 CSP AC 的第一题竟然来自提高组。

vp 了一下普及组，前三题都能过，300pts，没去可惜了。听说爆炸有的近 7k 人？离大谱。

现在状态：

坐等 4 级绿色钩钩（查分当天立马拉出百年不用的支付宝账号准备认证）~
坐等官方分数线出来，获得一个 2= + OIerDB 记载（1= 蓝钩彻底没戏了，我想出 gks，可惜实力不允许啊）。
教练，我想打 PION 4202！

是的捏，这个蒟蒻也被老师推举企图去 NOIP 2024 了。

鉴于学校第一年创办（连自己教学楼都没有，一共就 7 个班）就有了一个获奖选手（还是提高组），应该可以再次蹭上一个公众号（上次是月考）名额（事后证明没有，而且集团的教练对着 OIerDB 统计获奖人数的时候因为我是按分校报名的所以把我漏了……）。

Day 2.3#

悲喜交加。2= 分数线 105pts，卡过去了。4 级钩是有了，看了一下，6 级本来 160（我就这点儿实力），实际因为迷之原因（其实懂得都懂）升到 165 了，彻底与蓝钩绝缘。不过好在是有了 OIerDB 记载：评分不到 600, 全国排 8500+，省排（初一）并列第 90，市排（初一）并列第 11，集团内部（初一）S 组唯一一个 2=（貌似是唯一一个提高组的奖？）。不过因为我用分校的名义报的名所以总部方面的老师把我漏了？

其实这个结果也还好，至少 S 组算是没有遗憾了——该拿的奖拿了，该有的钩子钩了（其实还没有，OIerDB 那帮人提 issues 提了 3 天了还没提完……）。唯一的遗憾是自己真实实力 T2 应该拿 40pts 的，不过拿了也是被卡蓝钩线，不管了。

不过 5 级分数线 260？我的 5 级钩！！！

又是一场遗憾的 CSP，好在这场 CSP-S 没啥遗憾了——除了 NOIP 初中生分数线 130+，没我份儿了。

另外，发现自己被大批巨佬薄纱：有背着我偷偷拿蓝狗的，有把我单调队列了的（离大谱，初一被单调队列），反正就是 wtcl。

最后，还是要留一句：

奖项认证未上传，请稍后查看！

The End.\texttt{The End.}The End.

题解：AT_abc376_c [ABC376C] Prepare Another Box

Sun, 20 Oct 2024 14:12:45 GMT

很好的一道二分答案题。

听说 CSP 考前写 tj 可以让 rp += inf？

注：下文中 www 指物品重量序列，xxx 指箱子容量序列。

先问个问题：为什么我上来就敢肯定这是个二分答案题？

或者说，单调性在哪儿？

非常简单：如果一个盒子的容量越大，能装下的东西就更多（废话）。那么如果 vvv 不够用，可以扩大容量变成 v+1,v+2⋯109v + 1, v + 2 \cdots 10^9v+1,v+2⋯109。因为 10910^9109 是上限不能再大了。

所以就可以准备二分啦~

问2：你怎么 check 这个答案呢？

题目告诉我们，一共只有 nnn 个箱子，而物品也有 nnn 个，而且一个箱子最多放一个物品，因此物品与箱子必须一一对应，不可以有空箱子。

其次，只有 wi≤xjw_i \le x_jwi≤xj 时第 iii 个物品才能放进第 jjj 个箱子。那么结论就出来，排完序之后，要求对于 ∀1≤i≤n\forall 1 \le i \le n∀1≤i≤n，要求 wi≤xiw_i \le x_iwi≤xi，否则会导致箱子空掉，然后就不满足刚才的条件了 QaQ。

所以，思路就出来了：

二分新增箱子容量
扫一遍，看看新增后是否合法

总的时间复杂度是 O(nlog⁡k)O(n \log k)O(nlogk)，其中 k=109k = 10 ^ 9k=109。

然后，然后就结束啦~

ACCode:

1
/*Code by Block_Fish*/
2
#include <bits/stdc++.h>
3

4
#define INF 0x3f3f3f3f
5
#define EPS 1e-8
6
#define FOR(i, l, r) for (int(i) = (l); (i) <= (r); ++(i))
7
#define log printf
8
#define IOS                      \
9
  ios::sync_with_stdio(false); \
10
  cin.tie(nullptr);            \
11
  cout.tie(nullptr);
12

13
using namespace std;
14

15
typedef __int128 i128;
16
typedef long long ll;
17
typedef pair<int, int> PII;
18

19
const int N = 2e5 + 10;
20
int n, a[N], b[N], c[N];
21

22
template <typename T>
23

24
inline T read() {
25
  T sum = 0, fl = 1;
26
  char ch = getchar();
27
  for (; !isdigit(ch); ch = getchar())
28
    if (ch == '-') fl = -1;
29
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
30
  return sum * fl;
31
}
32

33
template <typename T>
34

35
inline void write(T x) {
36
  if (x < 0) {
37
    putchar('-'), write<T>(-x);
38
    return;
39
  }
40
  static T sta[35];
41
  int top = 0;
42
  do { sta[top++] = x % 10, x /= 10; } while (x);
43
  while (top) putchar(sta[--top] + 48);
44
}
45

46
int chk(int q) {
47
  b[n] = q;
48
  sort(b + 1, b + n + 1);
49
  FOR(i, 1, n) if (a[i] > b[i]) {
50
    for (int j = 1; j < n; ++j) b[j] = c[j];
51
    // 注意要清空数组，因为排序会打乱顺序，因此不能直接将b[n]设为0，只能新开数组重新复制了 QwQ
52
    return false;
53
  }
54
  for (int j = 1; j < n; ++j) b[j] = c[j];
55
  return true;
56
}
57

58
int main() {
59
  n = read<int>();
60
  for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
61
  for (int i = 1; i < n; i++) scanf("%d", &b[i]), c[i] = b[i];  // 是<哦~
62
  sort(a + 1, a + n + 1);
63
  int l = 1, r = 1e9, ret = -1;  // 要求箱子是正整数个，从 1 开始
64
  while (l <= r) {
65
    int mid = (l + r) >> 1;
66
    if (chk(mid)) {
67
      ret = mid;
68
      r = mid - 1;
69
    } else l = mid + 1;
70
  }
71
  write<int>(ret);
72
  return 0;
73
}

展开收起

AC 记录~

理解万岁！

题解：AT_abc374_c [ABC374C] Separated Lunch

Sat, 05 Oct 2024 21:50:36 GMT

已经沦落到在写这种水题题解了。

题目翻译#

有 nnn 队人，每个队人数不同，把他们分成 2 组（同一队的不能拆开），使两组人数差距尽量小。

形式化题意：有 nnn 个数，把它们分成两组，使两组和的差尽量小。

说句闲话：感觉这题目很经典，但我没有原题作为证据（大雾

解法#

本来觉得我这菜鸡实力是不可能做出来的，已经准备摆烂了，此时我突然发现 n≤20n \le 20n≤20。

这是啥概念？

时间复杂度对应表

看图，n≤25n \le 25n≤25 都是可以用 O(2n)O(2 ^ n)O(2n) 做法解决的，这不结束了？直接枚举每一组，分类讨论是 A 组还是 B 组，就可以了。

给个小建议：可以记录总人数，这样子只需要记录 A 组人数，B 组人数可以直接 O(1)O(1)O(1) 计算，这样就变成选与不选的 dfs 模板题目了……更关键的是这样子不需要记录为每一队对应哪一组了。

代码#

ACCode with 注释：

1
/*Code by Block_Fish*/
2
#include <bits/stdc++.h>
3

4
#define INF 0x3f3f3f3f
5
#define EPS 1e-8
6
#define FOR(i, l, r) for (int(i) = (l); (i) <= (r); ++(i))
7
#define log printf
8
#define IOS                      \
9
  ios::sync_with_stdio(false); \
10
  cin.tie(nullptr);            \
11
  cout.tie(nullptr);
12

13
using namespace std;
14

15
typedef __int128 i128;
16
typedef long long ll;
17
typedef pair<int, int> PII;
18

19
const int N = 30;
20
int n, a[N], ans = INF, sum;
21

22
template <typename T>
23

24
inline T read() {
25
  T sum = 0, fl = 1;
26
  char ch = getchar();
27
  for (; !isdigit(ch); ch = getchar())
28
    if (ch == '-') fl = -1;
29
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
30
  return sum * fl;
31
}
32

33
template <typename T>
34

35
inline void write(T x) {
36
  if (x < 0) {
37
    putchar('-'), write<T>(-x);
38
    return;
39
  }
40
  static T sta[35];
41
  int top = 0;
42
  do { sta[top++] = x % 10, x /= 10; } while (x);
43
  while (top) putchar(sta[--top] + 48);
44
}
45

46
void dfs(int group, int cnt) {
47
  if (group == n) {
48
    ans = min(ans, max(cnt, sum - cnt));
49
    return;
50
  }
51
  // 组 A
52
  dfs(group + 1, cnt + a[group]);
53
  // 组 B
54
  dfs(group + 1, cnt);
55
}
56

57
int main() {
58
  n = read<int>();
59
  FOR(i, 1, n) a[i] = read<int>(), sum += a[i];
60
  dfs(1, 0);
61
  write<int>(ans);
62
  return 0;
63
}
64
// 20组---》爆搜挂着机，打表出 AC

展开收起

赛时 AC 记录~

理解万岁！

题解：AT_abc370_c [ABC370C] Word Ladder

Sat, 07 Sep 2024 21:51:03 GMT

说句闲话#

这题是一个比较奇葩的贪心、构造。也可以认为是一个数据结构略有难度的练习题。

理论部分#

Tip

注：以下使用 NNN 表示字符串长度。

一句段话题意：三个字符串 SSS、TTT、XXX，其中 SSS 和 TTT 仅包含小写字母且等长，XXX 为空。每一个操作可以把对应的 SiS_iSi 修改为 TiT_iTi，但需要把改完后的整个 SSS 加进 XXX 里，求最少步数及方案，要求方案最后得到的 XXX 字典序最小。

这咱办呢？首先是等长的，所以只需要修改一定能达成——每次把不对应的修改成对应的不就可以了？因此步数很好求：不匹配的位置的个数。

现在问题就是怎样最小？

首先能够明确的是：既然等长，那么开头最小字符串最小，正常不都是这么比较的吗（

比如说，字符串 S=abcS = \texttt{abc}S=abc 和 T=abdT = \texttt{abd}T=abd，前面 ab\texttt{ab}ab 相同，b<c\texttt{b} < \texttt{c}b<c，因此 S<TS < TS<T。

这样子就好办了：目标最小，那么就把它改的尽量小嘛。

如何尽量小？兜圈子呢。

首先肯定是越改越小好，不然你越改越大在小还不如先改小的呢是吧~

如果想要尽量小，那么肯定是要先改前面的且是改小的；后面往大了改的同理，先改后面的在改前面的。

这句话比较绕，也是这个思路的核心。总结一下其实就是把这 NNN 个位置分成三类，如下：

Si=TiS_i = T_iSi=Ti，完全一致，不用管
Si>TiS_i > T_iSi>Ti，越改越小，优先改，越早出现的越优先改
Si<TiS_i < T_iSi<Ti，越改越大，最后改，而且越晚出现的越后改。

以上的规则基于题目规则，SiS_iSi 表示 SSS 中某字符，TiT_iTi 同理。两条更改的规则是因为越往前的越需要把它停留在小的状态，因此越改越小优先改，越改越大则先改后面的。

还是举个例子。

S=xay,T=abeS = \texttt{xay}, T = \texttt{abe}S=xay,T=abe，我们想要尽量小，那么按照这个逻辑，先筛出最往小了改的，就是第一个和最后一个位置。它们当中第一个位置最前，因此先改它，SSS 变为 aay\texttt{aay}aay，然后是第三个位置，变成 aae\texttt{aae}aae，最后在去改第二个位置，变成 abe\texttt{abe}abe。

时间复杂度分析#

这个算法是 O(N2)O(N ^ 2)O(N2) 的，而且本题最优解的最坏时间复杂度也是这个值。

为什么？因为最坏情况下我们需要对每一个位置进行更改，而每次输出这个长度，因此输出就是这个复杂度，没法优化了。

我才不会告诉你我冒充这是个 O(N)O(N)O(N) 算法结果被学长发现了才写这一段的。

ACCode with 注释：

1
/*Code by Block_Fish*/
2
#include <bits/stdc++.h>
3

4
#define INF 0x3f3f3f3f
5
#define EPS 1e-8
6
#define FOR(i, l, r) for (int(i) = (l); (i) <= (r); ++(i))
7
#define log printf
8
#define IOS                      \
9
  ios::sync_with_stdio(false); \
10
  cin.tie(nullptr);            \
11
  cout.tie(nullptr);
12

13
using namespace std;
14

15
typedef __int128 i128;
16
typedef long long ll;
17
typedef pair<int, int> PII;
18

19
int ret, len;
20
deque<int> a, b;
21
string s, t;
22

23
template <typename T>
24

25
inline T read() {
26
  T sum = 0, fl = 1;
27
  char ch = getchar();
28
  for (; !isdigit(ch); ch = getchar())
29
    if (ch == '-') fl = -1;
30
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
31
  return sum * fl;
32
}
33

34
template <typename T>
35

36
inline void write(T x) {
37
  if (x < 0) {
38
    putchar('-'), write<T>(-x);
39
    return;
40
  }
41
  static T sta[35];
42
  int top = 0;
43
  do { sta[top++] = x % 10, x /= 10; } while (x);
44
  while (top) putchar(sta[--top] + 48);
45
}
46

47
int main() {
48
  IOS;
49
  cin >> s >> t;
50
  len = s.size();
51
  for (int i = 0; i < len; ++i)
52
  if (s[i] != t[i]) {
53
    ++ret;
54
    if (s[i] < t[i]) b.push_front(i);  /* 考场留下的写法，这一行是说要往大了改的放到 b 里，而且越后出现的越先改*/
55
    else a.push_back(i);  /*同上，反过来*/
56
      /*这里之所以用 deque 主要是因为统一：下面可以统一使用 front 而不用在倒腾 front 和 back*/
57
  }
58
  cout << ret << endl;
59
  while (!a.empty()) {  /*先处理 a 改小*/
60
    s[a.front()] = t[a.front()];
61
    cout << s << endl;
62
    a.pop_front();  /*一定要pop*/
63
  }
64
  while (!b.empty()) {  /*再处理 b 改大*/
65
    s[b.front()] = t[b.front()];
66
    cout << s << endl;
67
    b.pop_front();
68
  }
69
  return 0;
70
}

展开收起

AC 记录~

理解万岁！

2024/09/01 开学前夕，发一篇大水文

Sun, 01 Sep 2024 18:32:39 GMT

笑点解析：封面图不是我们学校是集团在我们学校已有的分部的图片……我校甚至还没建好……

说句闲话：研究珂学的最好方法是

写一篇水文

祝你们成功（滑稽

关于小升初#

事情是酱紫的：

首先，我是个学生，不是老师。

其次，我是个学生，不是家长。

最后，我是个学生，不是父母。

这三点，我都做到了。

所以，我只能说，我很开心。

祝大家开学愉快！

以上内容来自 AI 生成（什么玩意儿，还开心、愉快）。

其实积木鱼就是一个今年（2024）小升初的一学生，明天开学，赶紧把自己暑假干的那些破事儿记录一下。

话说会不会导致自己 RP-= INF 啊啊啊……

6 月填志愿（但是 TMD 这个 213 jyj 把父母的房子、户口第一位），然后我报了一个新学校。录取完之后（8 月了）我父亲拿到通知书，一看学校的老大哥居然变成了市实验学校的某分校，之前区宣传委都不知道这消息，官方公众号上还说是区某中学的集团的，逆天，太逆天了……

报学校送四大？录取率 100%100\%100%？

录取通知书

虽然打码了，但貌似这背景还是能盒出来。

《市实验学校的教育集团的一个局，骗过了所有人，包括区政府》。这就是传说中的“弹射起步”吧，我保证我们学校明年一定会爆满，但我在没满的时候挤进去了。

upd on 2026/04/11：老学长证明确实如此。尤其是看爹娘财力的教育局把某商品房小区建在了学校对面。。。

但是捏，学校还没建好呢（说是要明年，学校工地还上了个什么“水土流失黑名单”），于是只能借址办学，一看借用的学校在我家马路对面，弯儿都不用拐……

然后 8 月 28 开学考（卷子用的是我家对面儿那学校的），考一上午，但是配分比较离谱：

English: 60pts

语文: 90 分

7!5!\dfrac{7!}{5!}5!7! 的某科: 100pts？

关键是前两科是连考的，加起来 2h，最下面的某科一个占了 80min。然后，语文作文差点没写完emm……（ps：那个作文跟觉不像是我喜欢写的风格，但咱也不敢说啊）。语文一考才发现自己“镶嵌”（看拼音写词语第一题）不会写，小学古诗基本全忘了（我之前甚至有一段时间忘了《咏鹅》《静夜思》《悯农》）。

妈妈之前说会有一定的初中知识，但反正我没看出来……

之后还有 20min，老师说是面试，小 L 很紧张，结果：

老师：你叫什么名字啊？

我：【数据删除】。

老师（低头找了一圈）：你理想的高中是哪所？

我：【经济特区中学、经济特区实验学校】。

老师：嗯，你能描述（评价）一下吗？

我：bla bla bla……

事后：

我：一点技术含量没有啊这……

爸爸：这能够区分学生，看看他们是有目标而努力还是专心于当下……

然后分到了 zdb（

dddd

upd on 2026/04/11：由于这个班太强了，年级前 202020 中 191919 个属于这里（一共才 393939 人……），所以在初二开学前就被削了，我们 111 班还被丢到了其它班楼下，信息沟通极不便利（大悲

老师中有好几个主任（年级主任、教务主任、办公室正副主任……）QwQ。

另外，已知的信息是，原来小学班里 474747 个同学中至少有 9 个也在我们学校，我们班就 5 个。说什么九年一贯制，我就没一贯。

upd on 2024/09/02：校徽至今没发，全校一共 777 个班，小学部只有一年级 444 个班，初中部只有初一 333 个班，加起来不到 300300300 人，校长、主任什么的随处可见平易近人，感觉大家都很熟了。开学仪式我去当门神礼仪兵了（职责：举班牌），上了一天道法课（因为班主任教道法）。所以：有社团吗？怎么上？

upd on 2026/04/11：转眼间在这地方混了快两年了，教务处主任和办公室主任也都升副校长了，学校也是正儿八经 run 起来了。。。不过有的时候总感觉竟然会怀念借址办学的日子，为什么呢？辉煌但已逝去的过往吗，还是那几个明明现在也能联系得到的老师、同学？我该在哪里停留？我问我自己。

课本感觉变难了，但还好，反正都是翻一遍基本就全会。唉，以后我是永无写完作业之日啊……

集训#

SC 省 MY 市 SWUST 内，集训了 111 个月（555，暑假就这么没了……），非常 happy （

dddd

去了成都旅游，辣的嘴唇地震……

食堂饭不辣（我专门挑的），也不错，还便宜（我妈一个手滑 888 块钱 202020 个馒头……）。

唉，这年头还有多少几毛钱的东西了……

然后为了这个集训，我发明了：

图上 dfs
图上 bfs
二分插入排序（独立发明，没有任何参考资料，达到了基于比较的排序的最优（时间复杂度假了。。。，因为不能 O(1)O(1)O(1) 插入）且稳定，我还证明了这两点）
单调 vector（我原创的一种新的数据结构；虽然后来证明这个东西时间复杂度假了）
…

话说我是不是也有潜力搞个图灵奖什么的。

第一天还有入门题，最后一周你给我出省选题？逆天了……

还有，举办了第一场比赛虽然不是很成功，出锅的两道题都是我出的，名字叫「金坷垃杯」（不是我起的，是 @mengleo 大哥创办的），欢迎大家持续关注！

集训队（啥时候能进国集啊）里大佬好多（就我最弱 Qaq。

另外，集训快结束的时候，我妈突然发现我有一块秃了……

职业病犯了（

牙#

回家第二天，先拔 4 颗牙。我一晚上没说话，因为咽了俩棉花，还吐了几口血（其实是牙的伤口流出来的，在枕头上待了一个星期），喝了 2 天粥（糊糊）。

然后一个星期过去了，我稍微刚好一点，就去戴牙套了，然后继续喝粥……

现在咬土豆都嫌硬……

我：我爸这是图啥啊……

博客#

回家后重启博客计划，然后建立了这个小破站。三十几篇文章，我搬运了好几天……

最后我就问一句：TMD 为什么你们看也看了赞也点了都不评论？我是单机写文人吗……

题解：P9938 [USACO21OPEN] Acowdemia II B

Thu, 29 Aug 2024 14:51:17 GMT

前言：原来的 tj 干了一堆什么建图啊之类的，但其实不要这么复杂。

注：下文中 nnn 是各成员名字列表。

从 K=1K = 1K=1 开整。如果情况是 ni<ni+1<⋯<njn_i < n_{i + 1}< \cdots < n_jni<ni+1<⋯<nj，那么显然，咱就不知道关于成员 ni,⋯ ,njn_i,\cdots,n_jni,⋯,nj 的相对资历的信息。也许所有这帮成员都做出了相同的贡献。

但是捏，如果存在 iii 使得 ni>n+1n_i > n_{ + 1}ni>n+1，则成员 nin_ini 肯定比成员 ni+1n_{i + 1}ni+1 干了更多的活儿，因此所有成员 n1,⋯ ,nin_1,\cdots,n_in1,⋯,ni 必须比成员 ni+1⋯nNn_{i + 1} \cdots n_Nni+1⋯nN 的贡献少。换句话说，如果 i<ji < ji<j 但 ni,ni+1,⋯ ,njn_i, n_{i + 1},\cdots,n_jni,ni+1,⋯,nj 不是按字母顺序排列的，那么咱就知道 nin_ini 肯定比 njn_jnj 资历浅了。

要是 K>1K > 1K>1 捏？把信息怼起来不就得了？

ACCode：

1
// Problem: P9938 [USACO21OPEN] Acowdemia II B
2
// Contest: Luogu
3
// URL: https://www.luogu.com.cn/problem/P9938
4
// Memory Limit: 256 MB
5
// Time Limit: 1000 ms
6
//
7
// Powered by CP Editor (https://cpeditor.org)
8

9
/*Code by Block_Fish*/
10
#include <bits/stdc++.h>
11

12
#define log printf
13
#define EPS 1e-8
14
#define INF 0x3f3f3f3f
15
#define FOR(i, l, r) for (int(i) = (l); (i) <= (r); ++(i))
16
#define IOS                      \
17
  ios::sync_with_stdio(false); \
18
  cin.tie(nullptr);            \
19
  cout.tie(nullptr);
20

21
using namespace std;
22

23
typedef __int128 i128;
24
typedef long long ll;
25
typedef pair<int, int> PII;
26

27
int k, n;
28
string s;
29
map<string, int> members;
30

31
template <typename T>
32

33
inline T read() {
34
  T sum = 0, fl = 1;
35
  char ch = getchar();
36
  for (; !isdigit(ch); ch = getchar())
37
    if (ch == '-') fl = -1;
38
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
39
  return sum * fl;
40
}
41

42
template <typename T>
43

44
inline void write(T x) {
45
  if (x < 0) putchar('-'), x = -x;
46
  static T sta[35];
47
  int top = 0;
48
  do { sta[top++] = x % 10, x /= 10; } while (x);
49
  while (top) putchar(sta[--top] + 48);
50
}
51

52
int main() {
53
  IOS cin >> k >> n;
54
  FOR(i, 0, n - 1)
55
  cin >> s, members[s] = i;
56
  vector<vector<char>> ans(n, vector<char>(n, '?')); // 全给我干成一个值，为了方便就用'?'
57
  FOR(i, 0, n - 1)
58
  ans[i][i] = 'B';  // 初始化一下，后面就不用搞了
59
  FOR(i, 0, k - 1) {
60
    vector<string> pub(n);
61
    FOR(j, 0, n - 1) cin >> pub[j];
62
    FOR(j, 0, n - 1) {
63
      bool flag = true;
64
      FOR(l, j + 1, n - 1) {
65
        if (pub[l - 1].compare(pub[l]) > 0) flag = false;
66
        if (!flag) {
67
          int a = members[pub[j]], b = members[pub[l]];
68
          ans[a][b] = '0';
69
          ans[b][a] = '1';  // 上面的过程
70
        }
71
      }
72
    }
73
  }
74
  FOR(i, 0, n - 1) {
75
    FOR(j, 0, n - 1) cout << ans[i][j];
76
    cout << endl;
77
  }
78
  return 0;
79
}

展开收起

AC记录~

理解万岁！

题解：AT_abc365_c [ABC365C] Transportation Expenses

Sat, 03 Aug 2024 22:14:28 GMT

Tip

注：为了方便，下文以 SumSumSum 表示 ∑i=1nAi\sum_{i = 1}^{n} A_i∑i=1nAi。

N=2×105N = 2 \times 10^5N=2×105，考虑二分答案。

所以，答案有单调性吗？或者说，可以二分吗？

当然！如果 x=kx = kx=k 时可以满足条件，那么 x=k−1x = k - 1x=k−1 时显然只会更少（上面取 min⁡\minmin 的基本都没变，变了的取了更少的），一样能满足条件。

check⁡\operatorname{check}check 函数怎么写？扫一遍嘛，时间复杂度 O(n)O(n)O(n)，鉴于后面是 log⁡\loglog 级别的复杂度这里就算暴力扫也超不了。

这样我们只需要考虑二分的上下界就好了。最低直接让 x=0x = 0x=0 好了，最高肯定不会超过 SumSumSum（超了那还了得？多的钱幽灵拿了？），就以此为界二分吧！

等等，我们漏了一个很重要的情况！那就是——无！解！

啥时候可以取到无限啊？

按照题意，需要的钱数最大也只有 SumSumSum 这么多，如果这还不到 mmm，即 Sum≤mSum \le mSum≤m，那么 xxx 自然可以随便取，反正钱数都没它啥事儿……

还有一点，上面这一大堆东西时间复杂度到底是多少呢？

显然时间复杂度为 Θ(Nlog⁡Sum)\Theta(N \log Sum)Θ(NlogSum)。感觉会超？注意时间限制是 2s ！拿计算器摁一下，最大值（两项都取到最大）大概是 9.5×1079.5 \times 10^79.5×107，不会超~

然后就真的结束了……

ACCode:

1
/*Code by Block_Fish*/
2
#include <bits/stdc++.h>
3

4
#define INF 0x3f3f3f3f
5
#define EPS 1e-8
6
#define FOR(i, l, r) for (ll(i) = (l); (i) <= (r); ++(i))
7
#define log printf
8
#define IOS                      \
9
  ios::sync_with_stdio(false); \
10
  cin.tie(nullptr);            \
11
  cout.tie(nullptr);
12

13
using namespace std;
14

15
typedef __int128 i128;
16
typedef long long ll;
17
typedef pair<ll, ll> PII;
18

19
const ll N = 2e5 + 10;
20
ll m, n, a[N], sum;
21

22
template <typename T>
23

24
inline T read() {
25
  T sum = 0, fl = 1;
26
  char ch = getchar();
27
  for (; !isdigit(ch); ch = getchar())
28
    if (ch == '-') fl = -1;
29
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
30
  return sum * fl;
31
}
32

33
template <typename T>
34

35
inline void write(T x) {
36
  if (x < 0) {
37
    putchar('-'), write<T>(-x);
38
    return;
39
  }
40
  static T sta[35];
41
  ll top = 0;
42
  do { sta[top++] = x % 10, x /= 10; } while (x);
43
  while (top) putchar(sta[--top] + 48);
44
}
45

46
inline bool chk(ll q) {
47
  ll sum = 0;
48
  FOR(i, 1, n) {
49
    sum += min(q, a[i]);
50
    if (sum > m) return 0;
51
  }
52
  return sum <= m;
53
}
54

55
int main() {
56
  scanf("%lld%lld", &n, &m);
57
  FOR(i, 1, n) scanf("%lld", &a[i]), sum += a[i];
58
  if (sum <= m) {
59
    log("infinite");
60
    return 0;
61
  }
62
  ll l = 0, r = sum, ret = -1;
63
  while (l <= r) {
64
    ll mid = (l + r) >> 1;
65
    if (chk(mid)) {
66
      ret = mid;
67
      l = mid + 1;
68
    } else r = mid - 1;
69
  }
70
  log("%lld\n", ret);
71
  return 0;
72
}

展开收起

AC 记录~

理解万岁！

题解：P10815 【模板】快速读入

Mon, 29 Jul 2024 12:56:40 GMT

闲着没事儿水篇 tj

题目大意#

题目大意极其粗暴，记得 108×108=1016>231−110^8 \times 10^8 = 10^{16} > 2^{31}-1108×108=1016>231−1 会爆 int，开 long long 就好。

于是这个题就变成了一个读入输出优化模板题。这不又回去了。

另外，输入输出常数优化也很常用，抢最优解和骗分时都可以用上。

cin/cout 版本#

操作#

1
ios::sync_with_stdio(false);
2
cin.tie(nullptr);

第一行开启后就不再兼容 stdio 了，也就是说，只要用 cin、cout，就最好不要同时用 scanf、printf 以及 getchar 等 C 语言留下的东西了（至少不能混用）。

原理#

Q：为什么要保留 C 语言的东西？

A：因为要保证 C++ 语言对 C 语言的兼容性，所以 C++ 将这两个的读入输出流绑到了一起。这样是线程安全的。但是，兼容性、安全性、效率经常会有矛盾，这行代码就是从兼容性到取效率。所以，此行代码一旦执行，cin、cout 与 printf、scanf 不得再同时使用，但是 cin 和 printf、cout 和 scanf 还是能同时用的。

剩下是在解除绑定.什么绑定？ostream 和 istream（是的，他俩拼起来就是 iostream）。cin.tie() 默认绑定的是 &std::cout，这不没了？所以这行代码就是在解除绑定。

Warning

注意：解除绑定后一定要及时 flush 刷新缓冲区（或者是用 endl，它就是 \n 和 flush 拼出来的）才能保证先输出 cout 里的再输入。

打包#

当然，一般 cin/cout 优化这 3 行会一起使用，因此可以将其打包成一个宏。

1
#define IOS                      \
2
  ios::sync_with_stdio(false); \  // 这里的'\'表示换行
3
  cin.tie(nullptr);            \

main 函数直接调用 IOS 就相当于 3 行一起上了。但一般还是跑不过 printf/scanf。

另外，不要用 endl，它会刷新缓冲区，因此比 \n 慢多了。

不过这里没啥用（字符串时有大用），这题该 TLE 还是 TLE。

基础版#

Tip

这货搞 __int128 时也有用。

输入#

首先肯定要处理一下符号问题。“+” 一般直接省略，不管它。“-” 不可省略，特判一下。

1
for (; !isdigit(ch); ch = getchar())  // isdigit 函数可以判断传过去的形参是否是数字
2
    if (ch == '-') fl = -1;

这样就可以略过空格和 “+”，直接读入 “-”。

后面的正负就都一样啦。那该咋办？

还记得进制转换吗？转成 10 进制的时候是不是这么写的：

1
int ans = 0;
2
for (int i = 0;i < len;++i) ans *= 10, ans += s[i] - '0';

一样的嘛！把 s[i] 换成刚才的 ch，把 for 循环换成 while 即可。总结一下就是这样：

1
inline int read() {  // inline 是定义内联函数的，可以省去调用函数的常数，具体是把这个函数里的东西干进调用的地方，因此一般只用于小函数
2
  int sum = 0, fl = 1;
3
  char ch = getchar();
4
  for (; !isdigit(ch); ch = getchar) if (ch == '-') fl = -1;
5
  for (; isdigit(ch); ch = getchar) sum = sum * 10 + ch - '0';
6
  return sum * fl;
7
}

输出#

输出是一样的，直接数位分解。把 getchar 替换为 putchar 即可。

1
inline void write(int x) {
2
  if (x < 0) {
3
    putchar('-'), write<int>(-x);
4
    return;  // 不加就会反复输出负号
5
  }
6
  static T sta[110];
7
  int top = 0;
8
  do { sta[top++] = x % 10, x /= 10; } while (x);
9
  while (top) putchar(sta[--top] + 48);
10
}

变通用#

但是！我们还可以让它变得更加通用！

为什么说上面的不通用？因为变量都是 int 的，long long、short 啥的全废了。

好在 C++ 提供了 template 这个好东西，中文名叫模板。可以根据给定的类型和一个模板函数、类生成一堆函数或类。

想想你的 vector、stack，是不是写的 vector<int>？<> 这个东西里面就是要传过去的类型。

于是可以用 template 改写上面的两个函数，现在是这样的：

1
template <typename T>
2

3
inline T read() {
4
  T sum = 0, fl = 1;
5
  char ch = getchar();
6
  for (; !isdigit(ch); ch = getchar)
7
    if (ch == '-') fl = -1;
8
  for (; isdigit(ch); ch = getchar) sum = sum * 10 + ch - '0';
9
  return sum * fl;
10
}
11

12
template <typename T>
13

14
inline void write(T x) {
15
  if (x < 0) {
16
    putchar('-'), write<T>(-x);
17
    return;
18
  }
19
  static T sta[110];
20
  int top = 0;
21
  do { sta[top++] = x % 10, x /= 10; } while (x);
22
  while (top) putchar(sta[--top] + 48);
23
}

展开收起

使用如下：

1
n = read<int>();  // read 没有参数，必须要加
2
write<int>(n);  // 注：write 时 “<int>” 写不写一样，不写会自动识别参数类型
3
w = read<long long>();
4
write<long long>(w);

一般这么整够了，但是这破题还是会 TLE 一个点，于是，我们需要更快的方案！

中端版#

getchar_unlocked

这是个啥？

官方管它叫“getchar 的非线程安全版本”。鉴于 OI 题目都是单线程程序（多线程那还了得？），安全性不影响。但以后写能赚 $ 的程序时记得注意不要使用。速度比 getchar 还要快，果然安全性与性能不可兼得。同理还有 putchar_unlocked，替换过后就可以 AC 了~。

Warning

这个函数并不通用，实测 Windows 不可用，请在 Linux （如某谷评测姬）使用~

高端版#

fread 和 fwrite

原理#

它们和 getchar、putchar 原理是一样的，都是拿 1B 东西出来。不同的是，getchar、putchar 是从硬盘（文件）中读，这俩是从内存中直接拿。鉴于内存速度快的太吓人，因而这两个也要比 getchar 快。

使用#

所以我们可以重新定义一个 getchar 和 putchar。

1
char buf[1 << 20], *p1, *p2;
2
#define gc() \
3
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 20, stdin), p1 == p2) ? EOF : *p1++) \
4

5
char pbuf[1 << 20], *pp = pbuf;
6
void push(const char &c) {
7
  if (pp - pbuf == 1 << 20) fwrite(pbuf, 1, 1 << 20, stdout), pp = pbuf;
8
  *pp++ = c;
9
}

这样就可以把毒瘤造的毒瘤题的毒瘤数据过掉了~

Warning

这种方法速度最快，但相对麻烦，可读性较差，建议不要使用。

参考资料：

OI-Wiki

题解：AT_abc362_d [ABC362D] Shortest Path 3

Sat, 13 Jul 2024 22:51:24 GMT

一句话题意：给定一个带点权的有权无向连通图，求点 1 到所有其它点的最短路径。

首先，只有 1 一个起点，所以是单源最短路，又因为最大是 2×1052 \times 10^52×105，所以是优先队列（堆）优化过后的 Dijkstra。

所以，我们只需要解决点权的问题就好了。一种显而易见的想法是把与这条边的边权加上起终点的点权，因为走这条边肯定是要过这两个点的。但这样有个问题：样例都过不了（或许是我写挂了？反正只过了样例 2）！为啥呢？

你从 1 走到 2，再从 2 走到 3，你这点 2 的点权不就算重了？

那该咋办呢？

其实你不用改边权，对 Dijkstra 做一点小改动即可。什么小改动呢？每次走边的时候加上终点的点权，这样子就方便算、判断了。注意不能加起点的，因为起点是固定的，你算它跟没算一样。

比如还是从 1 到 2 再到 3，你每条边再加上点 2、3 的点权，就不会出事了。

但注意此时点 1 的点权还没算，输出时加上就好。

ACCode:

1
// Problem: D - Shortest Path 3
2
// Contest: AtCoder - Toyota Programming Contest 2024#7（AtCoder Beginner Contest 362）
3
// URL: https://atcoder.jp/contests/abc362/tasks/abc362_d
4
// Memory Limit: 1024 MB
5
// Time Limit: 2000 ms
6
//
7
// Powered by CP Editor (https://cpeditor.org)
8

9
/*Code by Block_Fish*/
10
#include <bits/stdc++.h>
11

12
#define log printf
13
#define EPS 1e-8
14
#define INF 0x3f3f3f3f3f3f3f3f
15
#define FOR(i, l, r) for (ll(i) = (l); (i) <= (r); ++(i))
16
#define IOS                      \
17
  ios::sync_with_stdio(false); \
18
  cin.tie(nullptr);            \
19
  cout.tie(nullptr);
20

21
using namespace std;
22

23
typedef __int128 i128;
24
typedef long long ll;
25
typedef pair<ll, ll> PII;
26

27
const ll N = 1e6 + 10;
28
ll m, n, s, x, y, z, a[N], w[N], to[N], idx, dis[N], nxt[N], head[N];
29

30
struct line {
31
  ll u, d;
32
  bool operator<(const line &cmp) const { return d > cmp.d; }
33
};
34
priority_queue<line> q;
35

36
template <typename T>
37

38
inline T read() {
39
  T sum = 0, fl = 1;
40
  char ch = getchar();
41
  for (; !isdigit(ch); ch = getchar())
42
    if (ch == '-') fl = -1;
43
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
44
  return sum * fl;
45
}
46

47
template <typename T>
48

49
inline void write(T x) {
50
  if (x < 0) putchar('-'), write<T>(-x);
51
  static T sta[35];
52
  ll top = 0;
53
  do { sta[top++] = x % 10, x /= 10; } while (x);
54
  while (top) putchar(sta[--top] + 48);
55
}
56

57
inline void init() {
58
  memset(head, -1, sizeof(head));
59
  memset(dis, 0x3f, sizeof(dis));
60
}
61

62
inline void addEdge(ll u, ll v, ll q) {
63
  w[idx] = q;
64
  to[idx] = v;
65
  nxt[idx] = head[u];
66
  head[u] = idx;
67
  idx++;
68
}
69

70
void dijkstra(ll s) {
71
  dis[s] = 0;
72
  q.push({s, 0});
73
  while (!q.empty()) {
74
    line f = q.top();
75
    q.pop();
76
    ll u = f.u;
77
    if (f.d > dis[u]) continue;
78
    for (ll i = head[u]; i != -1; i = nxt[i]) {
79
      ll v = to[i];
80
      if (dis[u] + w[i] + a[v] < dis[v]) {
81
        dis[v] = dis[u] + w[i] + a[v];  // 把要去的点的点权算上
82
        q.push({v, dis[v]});
83
      }
84
    }
85
  }
86
}
87

88
int main() {
89
  init();
90
  n = read<ll>(), m = read<ll>(), s = 1;
91
  FOR(i, 1, n) a[i] = read<ll>();
92
  FOR(i, 1, m) {
93
    x = read<ll>(), y = read<ll>(), z = read<ll>();
94
    addEdge(x, y, z), addEdge(y, x, z);
95
  }
96
  dijkstra(s);
97
  FOR(i, 2, n)
98
  write<ll>(dis[i] + a[1]), putchar(' ');  // 除了起点都有了，所以要加上起点
99
  return 0;
100
}

展开收起

AC 记录~

理解万岁！

题解：AT_abc362_c [ABC362C] Sum = 0

Sat, 13 Jul 2024 22:03:47 GMT

很好写（15 min 解决）但不好讲（跟别人讲了 20 min）的写法 QwQ……

首先，咱先算出原式的范围。最小值（暂且记为 kkk）的公式就是：

k=∑i=1NLik = \sum_{i = 1}^{N} L_ik=i=1∑NLi

就是每一个最小可能值的和。

同理，最大值（我记为 www）的公式就是：

w=∑i=1NRiw= \sum_{i = 1}^{N} R_iw=i=1∑NRi

即最大可能值的和。

算这玩意儿有啥用呢？卡区间！

你说要是 k>0k > 0k>0 或者 w<0w < 0w<0，即最小都比 000 大或者最大都不到还能干成 000 吗？肯定不能啊！这种情况就是 No。

剩下的鉴于大家都是整数，而且可以随便变化，一定是 Yes（注：其实这就是零点存在定理：当一个函数 f 在 x∼yx \sim yx∼y 是连续时，如果 f(x)<0f(x) < 0f(x)<0 但 f(y)>0f(y) > 0f(y)>0，那么一定有 x<z<yx < z < yx<z<y 满足 f(z)=0f(z) = 0f(z)=0）。

所以该咋构造呢？

我们可以以 kkk 为基准，往 000 去凑。

具体来讲，就是：

Ansi={Ri (left>Ri−Li)Li+left (Ri≥left+Li)Ans_i = \begin{cases}R_i \ (left > R_i - L_i) \\ L_i + left \ (R_i \ge left + L_i)\end{cases}Ansi={Ri (left>Ri−Li)Li+left (Ri≥left+Li)

其中 leftleftleft 表示到 000 的距离，也就是 0−k0 - k0−k。说人话翻译一下就是：

能够直接凑完，那就直接凑完，然后就不用凑了。
凑不完，能凑多少是多少，记得更新一下后面要凑的数目

比如样例 111:

经计算，left=3left = 3left=3，第一组（3∼53 \sim 53∼5）最多凑个 222，那就凑 222，输出 555，还剩个 111 要凑。第二组（−4∼1-4 \sim 1−4∼1）最多能凑个 555，但 111 就够了，输出 −3-3−3，不用凑了。最后一组，不用凑了，直接输出 −2-2−2。

算一下，5+(−3)+(−2)=5−3−2=05 + (-3) + (-2) = 5 - 3 - 2 = 05+(−3)+(−2)=5−3−2=0，满足条件。

注意：今天，你开 long long 了吗？

赛场 AC Code：

1
// Problem: C - Sum = 0
2
// Contest: AtCoder - Toyota Programming Contest 2024#7（AtCoder Beginner Contest 362）
3
// URL: https://atcoder.jp/contests/abc362/tasks/abc362_c
4
// Memory Limit: 1024 MB
5
// Time Limit: 2000 ms
6
//
7
// Powered by CP Editor (https://cpeditor.org)
8

9
/*Code by Block_Fish*/
10
#include <bits/stdc++.h>
11

12
#define log printf
13
#define EPS 1e-8
14
#define INF 0x3f3f3f3f
15
#define FOR(i, l, r) for (ll(i) = (l); (i) <= (r); ++(i))
16
#define IOS                      \
17
  ios::sync_with_stdio(false); \
18
  cin.tie(nullptr);            \
19
  cout.tie(nullptr);
20

21
using namespace std;
22

23
typedef __int128 i128;
24
typedef long long ll;
25
typedef pair<ll, ll> PII;
26

27
const ll N = 2e5 + 10;
28
ll n, l[N], r[N], lft, suml, sumr;
29

30
template <typename T>
31

32
inline T read() {
33
  T sum = 0, fl = 1;
34
  char ch = getchar();
35
  for (; !isdigit(ch); ch = getchar())
36
    if (ch == '-') fl = -1;
37
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
38
  return sum * fl;
39
}
40

41
template <typename T>
42

43
inline void write(T x) {
44
  if (x < 0) {
45
    putchar('-'), write<T>(-x);
46
    return;
47
  }
48
  static T sta[35];
49
  ll top = 0;
50
  do { sta[top++] = x % 10, x /= 10; } while (x);
51
  while (top) putchar(sta[--top] + 48);
52
}
53

54
int main() {
55
  n = read<ll>();
56
  FOR(i, 1, n) l[i] = read<ll>(), r[i] = read<ll>(), suml += l[i], sumr += r[i];
57
  if (!(suml <= 0 && sumr >= 0)) {
58
    cout << "No";
59
    return 0;
60
  }
61
  lft = 0 - suml;   // 到0剩下的距离
62
  cout << "Yes" << endl;
63
  FOR(i, 1, n) {
64
    if (l[i] + lft <= r[i]) {
65
      cout << l[i] + lft << " ";
66
      lft = 0;
67
    } else {
68
      cout << r[i] << " ";
69
      lft -= r[i] - l[i];
70
    }
71
  }
72
  return 0;
73
}

展开收起

AC 记录～

理解万岁！

题解：【YACS 2022年 1 月月赛丙组】平衡括号

Thu, 27 Jun 2024 23:22:09 GMT

题目 Link

前情提要：这个题是栈的经典入门题。

关于栈的详细内容可以看 OI-Wiki，这里简单说一下。

其实栈（stack）就相当于一个桶，有两种操作：从顶上（top）往里边扔东西（push）和拿东西（pop），底部不允许操作（不然就漏了）。

这里就有 333 种操作了：

top：用来获取最上方的东西
push：扔东西进去
pop：拿东西出来

所以这个题就可以用栈解决了，具体步骤如下：

遍历字符串
如果栈是空的（empty），那么直接放东西（学名：入栈）
如果这个字符和栈顶（上一个待匹配的字符）匹配，那么栈顶出去（学名：出栈）
如果不匹配，那么就加进去
对每个字符进行操作 2~4（显然只会执行一个），此时匹配的已经不在栈中，栈里只有不匹配的。如果栈里没东西，那么说明都匹配了，是平衡的；如果有，那就是不平衡的。

这里，这个栈就是用来存储不匹配的括号的。

正确性证明：题目的意思是“就近匹配”，即括号优先分配给最近的且匹配的。那么栈先进后出的结构正好符合该项原则。

ACCode：

1
/*Code by Block_fish*/
2
#include <bits/stdc++.h>
3

4
#define log printf
5
#define EPS 1e-8
6
#define INF 0x3f3f3f3f
7
#define FOR(i, l, r) for (int(i) = (l); (i) <= (r); ++(i))
8
#define IOS                      \
9
  ios::sync_with_stdio(false); \
10
  cin.tie(nullptr);            \
11
  cout.tie(nullptr);
12

13
using namespace std;
14

15
typedef __int128 i128;
16
typedef long long ll;
17
typedef pair<int, int> PII;
18

19
int len;
20
stack<char> stk;
21
string s;
22

23
template <typename T>
24

25
inline T read() {
26
  T sum = 0, fl = 1;
27
  char ch = getchar();
28
  for (; !isdigit(ch); ch = getchar())
29
    if (ch == '-') fl = -1;
30
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
31
  return sum * fl;
32
}
33

34
template <typename T>
35

36
inline void write(T x) {
37
  if (x < 0) {
38
    putchar('-'), write<T>(-x);
39
    return;
40
  }
41
  static T sta[35];
42
  int top = 0;
43
  do { sta[top++] = x % 10, x /= 10; } while (x);
44
  while (top) putchar(sta[--top] + 48);
45
}
46

47
int main() {
48
  IOS;
49
  cin >> s;
50
  len = s.size();
51
  for (int i = 0; i < len; ++i) {
52
    if (stk.empty()) stk.push(s[i]);
53
    else if ((stk.top() == '[' && s[i] == ']') || (stk.top() == '(' && s[i] == ')')) stk.pop();
54
    else stk.push(s[i]);
55
  }
56
  if (stk.size()) cout << "Unbalanced";
57
  else cout << "Balanced";
58
  return 0;
59
}

展开收起

AC 记录~

题解:【YACS 2020 年 3 月月赛丙组】数字加密

Thu, 27 Jun 2024 23:21:24 GMT

题目 Link

先找规律，不难发现：

0+9=91+8=92+7=93+6=99+0=9\begin{align*} 0 + 9 = 9 \\\\ 1 + 8 = 9 \\\\ 2 + 7 = 9 \\\\ 3 + 6 = 9 \\\\ 9 + 0 = 9 \\\\ \end{align*}0+9=91+8=92+7=93+6=99+0=9

所以，对于最后一位的转换，只需要求出 9−9 -9− 密文最后一位的值就是明文的值，不需要写那么复杂用一堆 if。

后面的倒推就可以了，无非就是两次交换。注意第一位可能是 0，所以建议用字符串存.

AC Code：

1
/*Code by Block_Fish*/
2

3
#include <bits/stdc++.h>
4

5
#define log printf
6
#define EPS 1e-8
7
#define INF 0x3f3f3f3f
8
#define FOR(i, l, r) for (int(i) = (l); (i) <= (r); ++(i))
9
#define IOS                      \
10
    ios::sync_with_stdio(false); \
11
    cin.tie(nullptr);            \
12
    cout.tie(nullptr);
13

14
using namespace std;
15

16
typedef __int128 i128;
17
typedef long long ll;
18
typedef pair<int, int> PII;
19

20
string s, ans;
21

22
template <typename T>
23

24
inline T read() {
25
    T sum = 0, fl = 1;
26
    char ch = getchar();
27
  for (; !isdigit(ch); ch = getchar()) if (ch == '-') fl = -1;
28
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
29
  return sum * fl;
30
}
31

32
template <typename T>
33

34
inline void write(T x) {
35
  if (x < 0) {
36
    putchar('-'), write<T>(-x);
37
    return;
38
  }
39
  static T sta[35];
40
  int top = 0;
41
  do { sta[top++] = x % 10, x /= 10; } while (x);
42
  while (top) putchar(sta[--top] + 48);
43
}
44

45
int main() {
46
  IOS;
47
  cin >> s;
48
  FOR(i, 0, 3) ans += '0' + (9 - (s[i] - '0'));
49
  swap(ans[0], ans[3]);
50
  swap(ans[1], ans[2]);
51
  cout << ans;
52
  return 0;
53
}

展开收起

AC 记录~

题解：【YACS 2021 年 5 月月赛丙组】植树造林

Thu, 27 Jun 2024 20:25:33 GMT

题目 Link

考虑到老师不能砍树，所以最少补种树就是把剩下那二位的种树数补成最多的那位。

这里介绍个小语法：

1
max({a, b, c});
2
max(max(a, b), c);

两行代码都是在求 a,b,ca, b, ca,b,c 的最大值，但是第二个是两两求，第一个是整体求，稍微方便一点。

AC Code：

1
/*Code by Block_Fish*/
2
#include <bits/stdc++.h>
3

4
#define log printf
5
#define EPS 1e-8
6
#define INF 0x3f3f3f3f
7
#define FOR(i, l, r) for (int(i) = (l); (i) <= (r); ++(i))
8
#define IOS                      \
9
 ios::sync_with_stdio(false); \
10
 cin.tie(nullptr);            \
11
 cout.tie(nullptr);
12

13
using namespace std;
14

15
typedef __int128 i128;
16
typedef long long ll;
17
typedef pair<int, int> PII;
18

19
int a, b, c;
20

21
template <typename T>
22

23
inline T read() {
24
 T sum = 0, fl = 1;
25
 char ch = getchar();
26
 for (; !isdigit(ch); ch = getchar())
27
  if (ch == '-') fl = -1;
28
 for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
29
 return sum * fl;
30
}
31

32
template <typename T>
33

34
inline void write(T x) {
35
 if (x < 0) {
36
  putchar('-'), write<T>(-x);
37
  return;
38
 }
39
 static T sta[35];
40
 int top = 0;
41
 do { sta[top++] = x % 10, x /= 10; } while (x);
42
 while (top) putchar(sta[--top] + 48);
43
}
44

45
int main() {
46
 a = read<int>(), b = read<int>(), c = read<int>();
47
 write<int>(3 * max({a, b, c}) - (a + b + c));
48
 return 0;
49
}

展开收起

AC 记录~

题解：【YACS 2022年 1 月月赛丙组】平衡括号

Mon, 03 Jun 2024 21:50:03 GMT

提供一种快速做法（31ms）~

首先，枚举是必须的，但是可以快速枚举。

优化 1：众所周知 gcd⁡(a,b)×lcm⁡(a,b)=a×b\gcd(a, b) \times \operatorname{lcm}(a, b) = a \times bgcd(a,b)×lcm(a,b)=a×b，所以我们只需要枚举 aaa 就好了。

优化 2：aaa 最大也只用到 x×y\sqrt{x \times y}x×y，因为分析样例解释发现以后的都是重复的，只是换了个顺序而已，算 222 遍即可。

优化 3：aaa 可以从 xxx 开始枚举，因为再小了最大公因数就没有 xxx 了。

优化 4：每次可以加 xxx，因为余数有可加性，x≡0( mod x)x \equiv 0 (\bmod \hspace{0.1cm} x)x≡0(modx)，所以能够保证最大公约数不低于 xxx。

优化 5：x≥2x \ge 2x≥2，所以 a≥y÷2a \ge y \div 2a≥y÷2 时就不用枚举了。

结束~ 个 dir 啊

因为出事儿了……

下面这组数据阁下又该如何应对？

1
100 100

寄~

因为 x∗y\sqrt{x * y}x∗y 的值若是整数按照刚才的逻辑会被算 222 遍，然鹅换了个顺序还是这俩，不能重复计算啊！特判一下就得了……

ACCode：

1
// Problem: P1029 [NOIP2001 普及组] 最大公约数和最小公倍数问题
2
// Contest: Luogu
3
// URL: https://www.luogu.com.cn/problem/P1029
4
// Memory Limit: 125 MB
5
// Time Limit: 1000 ms
6
//
7
// Powered by CP Editor (https://cpeditor.org)
8

9
/*Code by Block_Fish*/
10
#include <bits/stdc++.h>
11

12
#define log printf
13
#define EPS 1e-8
14
#define INF 0x3f3f3f3f
15
#define FOR(i, l, r) for (int(i) = (l); (i) <= (r); ++(i))
16
#define IOS                      \
17
  ios::sync_with_stdio(false); \
18
  cin.tie(nullptr);            \
19
  cout.tie(nullptr);
20

21
using namespace std;
22

23
typedef __int128 i128;
24
typedef long long ll;
25
typedef pair<int, int> PII;
26

27
int x, y, ans;
28

29
template <typename T>
30

31
inline T read() {
32
  T sum = 0, fl = 1;
33
  char ch = getchar();
34
  for (; !isdigit(ch); ch = getchar())
35
    if (ch == '-') fl = -1;
36
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
37
  return sum * fl;
38
}
39

40
template <typename T>
41

42
inline void write(T x) {
43
  if (x < 0) {
44
    putchar('-'), write<T>(-x);
45
    return;
46
  }
47
  static T sta[35];
48
  int top = 0;
49
  do { sta[top++] = x % 10, x /= 10; } while (x);
50
  while (top) putchar(sta[--top] + 48);
51
}
52

53
int main() {
54
  x = read<int>(), y = read<int>();
55
  for (int i = x; i * i <= x * y && i < y >> 1; i += x)
56
    if (!(x * y % i) && gcd(i, x * y / i) == x) ans += 2;
57
  if (x == y) ans = 1;
58
  write<int>(ans);
59
  return 0;
60
}

展开收起

AC 记录~

理解万岁！

题解：P8267 [USACO22OPEN] Counting Liars B & U208878 晴天

Sat, 25 May 2024 21:50:30 GMT

其实，这个题，只需要最简单的枚举，加上最简单的二分查找即可~

1≤N≤10001 \le N \le 10001≤N≤1000？枚举吧~

咋枚举？显然，最好状态下 Bessie 的位置一定是某个 pip_ipi，否则差一个就会导致有个奶牛要说谎。所以我们枚举（理论来讲要先去个重，这样快一点，不过貌似数据没有重的~）pip_ipi，每次遍历这帮奶牛看看有多少不说实话的不就得了？时间复杂度显然 O(n2)O(n ^ 2)O(n2)。

AC Code：

1
// Problem: P8267 [USACO22OPEN] Counting Liars B
2
// Contest: Luogu
3
// URL: https://www.luogu.com.cn/problem/P8267
4
// Memory Limit: 256 MB
5
// Time Limit: 2000 ms
6
//
7
// Powered by CP Editor (https://cpeditor.org)
8

9
/*Code by Block_Fish*/
10
#include <bits/stdc++.h>
11

12
#define log printf
13
#define EPS 1e-8
14
#define INF 0x3f3f3f3f
15
#define FOR(i, l, r) for (int(i) = (l); (i) <= (r); ++(i))
16
#define IOS                      \
17
  ios::sync_with_stdio(false); \
18
  cin.tie(nullptr);            \
19
  cout.tie(nullptr);
20

21
using namespace std;
22

23
typedef __int128 i128;
24
typedef long long ll;
25
typedef pair<int, int> PII;
26

27
const int N = 1010;
28
int n, t[N], ans = INF;
29
vector<int> pls;
30
char op[N];
31

32
template <typename T>
33

34
inline T read() {
35
  T sum = 0, fl = 1;
36
  char ch = getchar();
37
  for (; !isdigit(ch); ch = getchar())
38
    if (ch == '-') fl = -1;
39
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
40
  return sum * fl;
41
}
42

43
template <typename T>
44

45
inline void write(T x) {
46
  if (x < 0) {
47
    putchar('-'), write<T>(-x);
48
    return;
49
  }
50
  static T sta[35];
51
  int top = 0;
52
  do { sta[top++] = x % 10, x /= 10; } while (x);
53
  while (top) putchar(sta[--top] + 48);
54
}
55

56
int main() {
57
  IOS cin >> n;
58
  FOR(i, 1, n) {
59
    cin >> op[i] >> t[i];
60
    pls.push_back(t[i]);  // 数组 p
61
  }
62
  unique(pls.begin(), pls.end());  // 去重
63
  for (auto i : pls) {
64
    int tmp = 0;
65
    FOR(j, 1, n) if ((op[j] == 'L' && i > t[j]) || (op[j] == 'G' && i < t[j]))++ tmp;  // 满足条件就过
66
    ans = min(ans, tmp);
67
  }
68
  write<int>(ans);
69
  return 0;
70
}

展开收起

AC 记录~

本来该消停了，直到我在讨论区里发现了个加强版。

加强版把 NNN 上调至 2×1052 \times 10^52×105，显然，刚才的方法挂了。实测确实不行。咋办？

注意看标签得到二分。外面显然没法优化，里边可以不？

必须滴！

你查找‘L’中说谎的，不就是在查小于这玩意儿的吗？你查找‘G’当中说谎的，不就是再查大于这玩意儿的吗？小于的直接 lower_bound，大于的就相当于总数 - 小于等于的，也就是总数 - upper_bound。

时间复杂度显然为 Θ(Nlog⁡N)\Theta(N \log N)Θ(NlogN)，可以过。

完。

AC Code：

1
// Problem: U208878 晴天
2
// Contest: Luogu
3
// URL: https://www.luogu.com.cn/problem/U208878
4
// Memory Limit: 128 MB
5
// Time Limit: 1000 ms
6
//
7
// Powered by CP Editor (https://cpeditor.org)
8

9
/*Code by Block_Fish*/
10
#include <bits/stdc++.h>
11

12
#define log printf
13
#define EPS 1e-8
14
#define INF 0x3f3f3f3f
15
#define FOR(i, l, r) for (int(i) = (l); (i) <= (r); ++(i))
16
#define IOS                      \
17
  ios::sync_with_stdio(false); \
18
  cin.tie(nullptr);            \
19
  cout.tie(nullptr);
20

21
using namespace std;
22

23
typedef __int128 i128;
24
typedef long long ll;
25
typedef pair<int, int> PII;
26

27
const int N = 2e5 + 10;
28
int n, t, ans = INF;
29
vector<int> pls, lhs, rhs;
30
char op;
31

32
template <typename T>
33

34
inline T read() {
35
  T sum = 0, fl = 1;
36
  char ch = getchar();
37
  for (; !isdigit(ch); ch = getchar())
38
    if (ch == '-') fl = -1;
39
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
40
  return sum * fl;
41
}
42

43
template <typename T>
44

45
inline void write(T x) {
46
  if (x < 0) {
47
    putchar('-'), write<T>(-x);
48
    return;
49
  }
50
  static T sta[35];
51
  int top = 0;
52
  do { sta[top++] = x % 10, x /= 10; } while (x);
53
  while (top) putchar(sta[--top] + 48);
54
}
55

56
int main() {
57
  IOS cin >> n;
58
  FOR(i, 1, n) {
59
    cin >> op >> t;
60
    pls.push_back(t);
61
    if (op == 'L') lhs.push_back(t);
62
    else rhs.push_back(t);
63
  }
64
  sort(pls.begin(), pls.end());
65
  sort(lhs.begin(), lhs.end());
66
  sort(rhs.begin(), rhs.end());
67
  for (auto i : pls) {
68
    int tmpg = rhs.size() - (upper_bound(rhs.begin(), rhs.end(), i) - rhs.begin()), tmpl = lower_bound(lhs.begin(), lhs.end(), i) - lhs.begin();
69
    cerr << i << ' ' << tmpg << ' ' << tmpl << endl;
70
    ans = min(ans, tmpg + tmpl);
71
  }
72
  write<int>(ans);
73
  return 0;
74
}

展开收起

AC 记录（加强版）~

题解：CF1337A Ichihime and Triangle

Mon, 13 May 2024 19:43:11 GMT

看到大佬们基本都是直接输出 bbb ccc ccc 了事儿，一身反骨有其它构造方法的我表示不服，遂作此篇。

众所周知，两边之和大于第三边，所以，如果 b+c>db + c > db+c>d，那么 bbb、ccc、ddd 就是正确的。那如果不满足呢？在题目条件下 b+c>b+c−1b + c > b + c - 1b+c>b+c−1，那么这一组就是合理的。

分别验证下。满足 b+c>d,x=b,y=c,z=db + c > d, x = b, y = c, z = db+c>d,x=b,y=c,z=d，显然都满足条件。另外一组也是类似的。极端情况下 b+c−1>db + c - 1 > db+c−1>d？那么可以得到 b+c>d+1b + c > d + 1b+c>d+1，显然也满足条件，所以方法正确。

ACCode：

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
int num;
6

7
void run(int a, int b, int c, int d) {  //  a <= x <= b b <= y <= c c <= z <= d
8
    if (b + c - 1 <= d)
9
        printf ("%d %d %d\n", b, c, b + c - 1);
10
    else
11
        printf ("%d %d %d\n", b, c, d);
12
}
13

14
int main() {
15
    scanf("%d", &num);
16
    for (int i = 0; i < num; i++) {
17
        int a, b, c, d;
18
        scanf("%d%d%d%d", &a, &b, &c, &d);
19
        run(a, b, c, d);
20
    }
21
    return 0;
22
}

展开收起

AC记录~

理解万岁！

题解：AT_abc352_c [ABC352C] Standing On The Shoulders

Sat, 04 May 2024 21:58:09 GMT

考场憋了很久，最后代码贼短……

理想状态下，直接全排列解决问题。但是，1≤n≤2×1051 \le n \le 2 \times 10^51≤n≤2×105，明显 TLE，试都不用试的。

咋优化呢？

其实，前面的巨人只负责“打地基”，作为“塔尖儿”的巨人有且仅有 1 个。而前面地基随便排列，地基高度（他们的和）都不会变。所以，我们只需要枚举塔尖即可。塔尖儿定了，下面的地基高度也就定了。

然后，又是一个问题——求和！理论来讲，最最暴力的方法就是一层循环。但是，一层循环时间复杂度为 Θ(n)\Theta(n)Θ(n)，联合上枚举塔尖的循环，时间复杂度为 Θ(n2)\Theta(n^2)Θ(n2)，又 TM 挂了……

这里，我们可以采用一种类似前缀和的思想：用一个变量 sumsumsum（学名叫累加器）来记录 AAA 的总和，然后算去掉塔尖（PiP_iPi）的时候，答案就是 sum−APi+BPisum - A_{P_i} + B_{P_i}sum−APi+BPi。这个操作，时间复杂度显然为 Θ(1)\Theta(1)Θ(1)，算上循环为 Θ(n)\Theta(n)Θ(n)，明显可以。

赛场 ACCode：

1
// Problem: C - Standing On The Shoulders
2
// Contest: AtCoder - AtCoder Beginner Contest 352
3
// URL: https://atcoder.jp/contests/abc352/tasks/abc352_c
4
// Memory Limit: 1024 MB
5
// Time Limit: 2000 ms
6
//
7
// Powered by CP Editor (https://cpeditor.org)
8

9
/*Code by Block_Fish*/
10
#include <bits/stdc++.h>
11

12
#define log printf
13
#define EPS 1e-8
14
#define INF 0x3f3f3f3f
15
#define FOR(i, l, r) for (ll(i) = (l); (i) <= (r); ++(i))
16
#define IOS                      \
17
  ios::sync_with_stdio(false); \
18
  cin.tie(nullptr);            \
19
  cout.tie(nullptr);
20

21
using namespace std;
22

23
typedef __int128 i128;
24
typedef long long ll;
25
typedef pair<ll, ll> PII;
26

27
const ll N = 2e5 + 10;
28
ll n, mx = -INF, sum1;
29
PII g[N];  // pair 可以把两个数组怼到一块儿，具体使用方法见 https://blog.csdn.net/sevenjoin/article/details/81937695
30

31
template <typename T>
32

33
inline T read() {
34
  T sum = 0, fl = 1;
35
  char ch = getchar();
36
  for (; !isdigit(ch); ch = getchar())
37
    if (ch == '-') fl = -1;
38
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
39
  return sum * fl;
40
}
41

42
template <typename T>
43

44
inline void write(T x) {
45
  if (x < 0) {
46
    putchar('-'), write<T>(-x);
47
    return;
48
  }
49
  static T sta[35];
50
  ll top = 0;
51
  do { sta[top++] = x % 10, x /= 10; } while (x);
52
  while (top) putchar(sta[--top] + 48);
53
}
54

55
int main() {
56
  n = read<ll>();  // 不开 long long 见**，别问，问就是实践出来的真知
57
  FOR(i, 1, n) g[i].first = read<ll>(), g[i].second = read<ll>(), sum1 += g[i].first;  // 累加器
58
  FOR(i, 1, n)
59
  mx = max(mx, sum1 - g[i].first + g[i].second);  // 上面简单的公式
60
  write<ll>(mx);
61
  return 0;
62
}

展开收起

AC 记录~

理解万岁！

先别划走，说几件事儿。

这道题可以用贪心（同学做法），但是，贪地基高度是错的，见https://atcoder.jp/contests/abc352/submissions/53114017，贪心需谨慎啊！
不开 long long 见**！
一张绝世好很有用的图，可以收藏，拿走~
如图

P10111 [GESP202312 七级] 纸牌游戏题解

Wed, 13 Mar 2024 22:21:38 GMT

看标签知道要用 DP。

于是开始分析。

状态：dp(i,j,k)=dp(i, j, k) = dp(i,j,k)= 前 iii 轮中，第 iii 轮出 jjj，一共换了 kkk 次牌的最大钱数。很好理解。

转移也不难，不就是不换和换两种吗！

所以，转移就是： dp(i,j,k)=max⁡{dp(i−1,j,k)+pk⁡(j,ci)×aidp(i−1,j′,k−1)+pk⁡(j,ci)×ai−bkdp(i, j, k) = \max \begin{cases}dp(i - 1, j, k) + \operatorname{pk}(j, c_i) \times a_i\\ dp(i - 1, j', k - 1) + \operatorname{pk}(j, c_i) \times a_i - b_k\end{cases}dp(i,j,k)=max{dp(i−1,j,k)+pk(j,ci)×aidp(i−1,j′,k−1)+pk(j,ci)×ai−bk 其中，j′j'j′ 表示你要换的牌，显然要求 j′≠jj' \neq jj′=j，pk⁡(x,y)\operatorname{pk}(x, y)pk(x,y) 表示你出牌 xxx，小杨出 yyy 时的胜负情况。胜返回 222，负返回 000，平返回 111。上面就是不还，下面就是换。

观察发现，获胜时要么大 111，要么小 222（因为此处“0>20 > 20>2”）。

所以 pk⁡\operatorname{pk}pk 函数如下：

1
int pk(int x, int y) {
2
  if (x == y) return 1;
3
  if (x == y + 1 || x == y - 2) return 2;
4
  return 0;
5
}

以上为朴素做法。还能不能优化呢？滚动数组嘛！这玩意儿不就是专门给其中一维是“前 iii 回……”的 DP 状态砍掉这维的嘛！

于是用上滚动数组（这个不会的去看背包），空间复杂度就可以降到 Θ(3N)\Theta(3N)Θ(3N) 啦！

用上滚动数组的：

1
// Problem: P10111 [GESP202312 七级] 纸牌游戏
2
// Contest: Luogu
3
// URL: https://www.luogu.com.cn/problem/P10111
4
// Memory Limit: 512 MB
5
// Time Limit: 1000 ms
6
//
7
// Powered by CP Editor (https://cpeditor.org)
8

9
/*Code by Block_Fish*/
10
#include <bits/stdc++.h>
11

12
#define log printf
13
#define EPS 1e-8
14
#define INF 0x3f3f3f3f
15
#define FOR(i, l, r) for (int(i) = (l); (i) <= (r); ++(i))
16
#define IOS                      \
17
  ios::sync_with_stdio(false); \
18
  cin.tie(nullptr);            \
19
  cout.tie(nullptr);
20

21
using namespace std;
22

23
typedef __int128 i128;
24
typedef long long ll;
25
typedef pair<int, int> PII;
26

27
const int N = 1010;
28
int n, a[N], b[N], c[N], dp[3][N], ans = -INF;
29

30
template <typename T>
31

32
inline T read() {
33
  T sum = 0, fl = 1;
34
  char ch = getchar();
35
  for (; !isdigit(ch); ch = getchar())
36
    if (ch == '-') fl = -1;
37
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
38
  return sum * fl;
39
}
40

41
template <typename T>
42

43
inline void write(T x) {
44
  if (x < 0) putchar('-'), write<T>(-x);
45
  static T sta[35];
46
  int top = 0;
47
  do { sta[top++] = x % 10, x /= 10; } while (x);
48
  while (top) putchar(sta[--top] + 48);
49
}
50

51
int pk(int x, int y) {
52
  if (x == y) return 1;
53
  if (x == y + 1 || x == y - 2) return 2;
54
  return 0;
55
}
56

57
int main() {
58
  n = read<int>();
59
  FOR(i, 1, n) a[i] = read<int>();
60
  FOR(i, 1, n - 1) b[i] = read<int>();
61
  FOR(i, 1, n) c[i] = read<int>();
62
  memset(dp, -0x3f, sizeof(dp));
63
  FOR(i, 0, 2) dp[i][0] = pk(i, c[1]) * a[1];
64
  FOR(i, 2, n)
65
  for (int j = i - 1; j >= 0; --j) FOR(k, 0, 2) {
66
      int s = pk(k, c[i]) * a[i];
67
      dp[k][j] += s;    // 默认不换
68
      if (j > 0)      // 防止越界
69
        FOR(l, 0, 2)  // 换，换成 l
70
      dp[k][j] = max(dp[k][j], dp[l][j - 1] + s - b[j]);
71
    }
72
  FOR(i, 0, n - 1)
73
  FOR(j, 0, 2) ans = max(ans, dp[j][i]);
74
  log("%d", ans);
75
  return 0;
76
}

展开收起

题解：AT_abc344_d [ABC344D] String Bags

Sun, 10 Mar 2024 21:58:27 GMT

前情提要：小 L积木鱼在某谷上第一篇过审的 tj！

明显是 DP。

然后就开始分析：

状态：dpij=dp_{ij} =dpij= 有 iii 个袋子且匹配 TTT 的前缀的长度为 jjj 时所需的最少钱数。

匹配 TTT 的前缀的长度为 jjj 就是前 jjj 个字符与 TTT 的前 jjj 个字符相同。

相对简单。

然后看转移。为了方便，咱不妨令 ∣S∣|S|∣S∣ 为字符串 SSS 的长度，其它的同理。

假设是要将第 iii 个袋子里的字符串 LLL 接到 SSS 的末尾，那么就只有 S∣S∣+1S_{|S|+1}S∣S∣+1 与 S∣S∣+∣L∣)S_{|S|+|L|)}S∣S∣+∣L∣) 依次对应时才能从 dp(i−1)∣S∣dp_{(i-1)|S|}dp(i−1)∣S∣ 转移到 dpi∣L∣dp_{i|L|}dpi∣L∣。

为啥呢？

不对应那你接哪儿去了？不是说好接到末尾吗？那你问啥呢，浪费表情:-(

那我不选呢？

不选你 jjj 不变不就得了？

所以，转移部分就是：

1
for (int i = 0; i < n; i++) {
2
    for (int j = 0; j < 110; j++) dp[i + 1][j] = dp[i][j];  // 同步过去
3
    int m;
4
    cin >> m;
5
    while (m--) {
6
      ...判断是否满足上面的条件
7
        if (满足) dp[i + 1][j + sl] = min(dp[i + 1][j + sl], dp[i][j] + 1);
8
      }
9
    }
10
  }

上面 dp[i + 1][j + sl] 就是不选，dp[i][j] + 1 就是选。

最后看一下时间复杂度。

Θ(NM∣S∣⋅∣T∣)\Theta(NM|S|\cdot|T|)Θ(NM∣S∣⋅∣T∣)。MMM 为袋中字符串数量。

为啥？

你看我们上面的代码，不就是先遍历了一遍 NNN 个袋子，再遍历字符串数量 MMM，每次判断相等挨个比较不就是 ∣S∣⋅∣T∣|S|\cdot|T|∣S∣⋅∣T∣嘛。

结束~

ACCode:

1
// Problem: D - String Bags
2
// Contest: AtCoder -   Toyota Programming Contest 2024#3（AtCoder Beginner Contest 344）
3
// URL: https://atcoder.jp/contests/abc344/tasks/abc344_d
4
// Memory Limit: 1024 MB
5
// Time Limit: 2000 ms
6
//
7
// Powered by CP Editor (https://cpeditor.org)
8
/*Code by Block_Fish*/
9
#include <bits/stdc++.h>
10

11
#define log printf
12
#define EPS 1e-8
13
#define INF 0x3f3f3f3f
14
#define FOR(i, l, r) for (int(i) = (l); (i) <= (r); ++(i))
15
#define IOS                      \
16
  ios::sync_with_stdio(false); \
17
  cin.tie(nullptr);            \
18
  cout.tie(nullptr);
19

20
using namespace std;
21

22
typedef __int128 i128;
23
typedef long long ll;
24
typedef pair<int, int> PII;
25

26
const int N = 110;
27
int dp[N][N];  // dp[i][j] = 前 i 个袋子中匹配 T 的前缀长度为 j 时所需的最少钱数。
28
string t;
29

30
template <typename T>
31

32
inline T read() {
33
  T sum = 0, fl = 1;
34
  char ch = getchar();
35
  for (; !isdigit(ch); ch = getchar())
36
    if (ch == '-') fl = -1;
37
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
38
  return sum * fl;
39
}
40

41
template <typename T>
42

43
inline void write(T x) {
44
  if (x < 0) putchar('-'), write<T>(-x);
45
  static T sta[35];
46
  int top = 0;
47
  do { sta[top++] = x % 10, x /= 10; } while (x);
48
  while (top) putchar(sta[--top] + 48);
49
}
50

51
int main() {
52
  IOS memset(dp, INF, sizeof(dp));
53
  dp[0][0] = 0;
54
  cin >> t;
55
  int tl = t.size(), n;
56
  cin >> n;
57
  for (int i = 0; i < n; i++) {
58
    for (int j = 0; j < 110; j++) dp[i + 1][j] = dp[i][j];
59
    int m;
60
    cin >> m;
61
    while (m--) {
62
      string s;
63
      cin >> s;
64
      int sl = s.size();  // 比较
65
      for (int j = 0; j + sl <= tl; j++) {
66
        bool flag = true;
67
        for (int k = 0; k < sl; k++)
68
          if (t[j + k] != s[k]) {
69
            flag = false;
70
            break;
71
          }
72
        if (flag) dp[i + 1][j + sl] = min(dp[i + 1][j + sl], dp[i][j] + 1);  // 状态转移方程
73
      }
74
    }
75
  }
76
  if (dp[n][tl] > 5e8) dp[n][tl] = -1;  // 过大就是祭了
77
  cout << dp[n][tl] << "\n";
78
  return 0;
79
}

展开收起

AC记录~

理解万岁！

P10187 [USACO24FEB] Palindrome Game B 题解

Thu, 29 Feb 2024 21:15:43 GMT

挑战题解区最短代码

回文数？数学题！打表找规律吧……

显然，1∼91 \sim 91∼9 都是回文数，先手赢（就一位你还想咋地啊）。

然后是 101010。样例告诉我们，这个不行。

接着是 11∼1911 \sim 1911∼19，发现随便减个 1∼91 \sim 91∼9 就可以变成 101010，而 101010 是后手赢。赢得就是后手的后手，那就是先手，可以。

202020？减个 1∼91 \sim 91∼9 不就又回到上面了？然后就是后手的先手，也就是后手赢，寄。

21∼2921 \sim 2921∼29？减个 1∼91 \sim 91∼9 就变成 202020 了，后手的后手，先手赢。

以此类推，每一个非整十数都可以转化为整十数，而整十数都能转化为 101010，而 101010 是后手赢的，所以非整十数是后手的后手，先手赢。而且整十数由于首位不可能为 000，所以都不是回文数，所以都是整十数 ⇒10⇒\Rightarrow 10 \Rightarrow⇒10⇒ E 或非整十数 ⇒\Rightarrow⇒ 整十数 ⇒10⇒\Rightarrow 10 \Rightarrow⇒10⇒ B。

结论：整十数是 E，非整十数是 B。

短短的 ACCode：

1
T = int(input())
2
for _ in range(T):
3
  start = input()
4
  print('E' if start[-1] == '0' else 'B')

AC记录

P10189 [USACO24FEB] Maximizing Productivity B 题解

Thu, 29 Feb 2024 20:56:04 GMT

先说说暴力做法：

每次遍历一遍，看看是否满足 ti+s≤cit_i + s \le c_iti+s≤ci，满足就计数，不满足就挂。单次时间复杂度显然为 O(N)O(N)O(N)，总得时间复杂度约为 O(NQ)O(NQ)O(NQ)，TLE 是肯定的~

暴力代码：

1
// Problem: Problem 3. Maximizing Productivity
2
// Contest: USACO - USACO 2024 February Contest, Bronze
3
// URL: https://usaco.org/index.php?page=viewproblem&cpid=1385
4
// Memory Limit: 256 MB
5
// Time Limit: 4000 ms
6
//
7
// Powered by CP Editor (https://cpeditor.org)
8

9
/*Code by Block_Fish*/
10
#include <bits/stdc++.h>
11

12
#define log printf
13
#define EPS 1e-8
14
#define INF 0x3f3f3f3f
15
#define FOR(i, l, r) for (int(i) = (l); (i) <= (r); ++(i))
16
#define IOS                      \
17
  ios::sync_with_stdio(false); \
18
  cin.tie(nullptr);            \
19
  cout.tie(nullptr);
20

21
using namespace std;
22

23
typedef __int128 i128;
24
typedef long long ll;
25
typedef pair<int, int> PII;
26

27
const int N = 2e5 + 10;
28
int n, q, c[N], t[N];
29

30
template <typename T>
31

32
inline T read() {
33
  T sum = 0, fl = 1;
34
  char ch = getchar();
35
  for (; !isdigit(ch); ch = getchar())
36
    if (ch == '-') fl = -1;
37
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
38
  return sum * fl;
39
}
40

41
template <typename T>
42

43
inline void write(T x) {
44
  static T sta[35];
45
  int top = 0;
46
  do { sta[top++] = x % 10, x /= 10; } while (x);
47
  while (top) putchar(sta[--top] + 48);
48
}
49

50
int main() {
51
  n = read<int>(), q = read<int>();
52
  FOR(i, 1, n) c[i] = read<int>();
53
  FOR(i, 1, n) t[i] = read<int>();
54
  FOR(i, 1, q) {
55
    int v = read<int>(), s = read<int>(), cnt = 0;
56
    FOR(j, 1, n) if (s + t[j] < c[j])++ cnt;
57
    if (cnt >= v) puts("YES");
58
    else puts("NO");
59
  }
60
  return 0;
61
}

展开收起

评测记录，开了优化也只有 20pts。

暴力废了，开始整正解。

2×1052 \times 10^52×105？二分法，了解一下？

然后，然后遇到了个问题：二分这东西要求有序，可是 cic_ici 与 tit_iti 是绑定在一起的啊！咋整？

注意 cic_ici 与 ci−tic_i - t_ici−ti 没关系，而这个式子能够求出啥啊？想要去到第 iii 个农场最大的 SSS 嘛（ci−ti+ti=cic_i - t_i + t_i = c_ici−ti+ti=ci，刚好卡点儿到，不可能再晚了）！

总结一下，问题相当于预处理出来一个数组 aaa，使 ai=ci−tia_i = c_i - t_iai=ci−ti，求数组中是否有至少 VVV 个数满足 ai≥Sa_i \ge Sai≥S。

先排个序（不然还是 O(n)O(n)O(n) 嘛），然后就可以分出来两种做法：

做法一：二分，用 upper_bound 函数（因为是大于等于），时间复杂度约为 O(QlogN)O(QlogN)O(QlogN)。

做法二：排完序后显然满足 aV≥aV−1≥aV−2...a1a_V \ge a_{V - 1} \ge a_{V - 2} ... a_1aV≥aV−1≥aV−2...a1，因此如果 aVa_VaV 都小于等于 SSS 了，那它前面的自然也都满足。因此只需要判断 aV≥Sa_V \ge SaV≥S 成不成立即可。时间复杂度约为 O(Q)O(Q)O(Q)。

赛时 ACCode（做法二）:

1
// Problem: Problem 3. Maximizing Productivity
2
// Contest: USACO - USACO 2024 February Contest, Bronze
3
// URL: https://usaco.org/index.php?page=viewproblem&cpid=1385
4
// Memory Limit: 256 MB
5
// Time Limit: 4000 ms
6
//
7
// Powered by CP Editor (https://cpeditor.org)
8

9
/*Code by Block_Fish*/
10
#include <iostream>
11
#include <algorithm>  // 万能头CE
12

13
#define log printf
14
#define EPS 1e-8
15
#define INF 0x3f3f3f3f
16
#define FOR(i, l, r) for (int(i) = (l); (i) <= (r); ++(i))
17
#define IOS                      \
18
  ios::sync_with_stdio(false); \
19
  cin.tie(nullptr);            \
20
  cout.tie(nullptr);
21

22
using namespace std;
23

24
typedef __int128 i128;
25
typedef long long ll;
26
typedef pair<int, int> PII;
27

28
int N, Q;
29
int close[200010], t[200010], ans[200010], V, S;
30

31
template <typename T>
32

33
inline T read() {
34
  T sum = 0, fl = 1;
35
  char ch = getchar();
36
  for (; !isdigit(ch); ch = getchar())
37
    if (ch == '-') fl = -1;
38
  for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
39
  return sum * fl;
40
}
41

42
template <typename T>
43

44
inline void write(T x) {
45
  static T sta[35];
46
  int top = 0;
47
  do { sta[top++] = x % 10, x /= 10; } while (x);
48
  while (top) putchar(sta[--top] + 48);
49
}
50

51
bool x(int a, int b) { return a > b; }
52

53
int main() {
54
  cin >> N >> Q;
55
  for (int i = 1; i <= N; i++) { cin >> close[i]; }
56
  for (int i = 1; i <= N; i++) { cin >> t[i]; }
57
  for (int i = 1; i <= N; i++) { ans[i] = close[i] - t[i]; }
58
  sort(ans + 1, ans + N + 1, x);
59
  while (Q--) {
60
    cin >> V >> S;
61
    if (ans[V] > S) cout << "YES" << endl;
62
    else cout << "NO" << endl;
63
  }
64
  return 0;
65
}

展开收起

AC记录~

2023 游寄

Sat, 03 Feb 2024 12:07:27 GMT

按首次参加时间排序。

蓝桥STEMA#

考点：家里（

打得最好的比赛之一。

年初场#

选择题好简单，编程题就会前几道，没想到最后 500+500+500+ 分进了 GD 省赛……

可惜省赛跟英语撞了，没打……

2026 翻修时补注：好在英语过了，并且骗到了一段时间的不写英语作业特权。

年末场#

跟年初场差不多，编程题多了一道也多做了一道，最后居然进了前 5%5\%5%……

省赛还没开始……

2026 翻修时补注：2024 赛季省二被迫离场，2025 赛季成为中级组最老的一批选手，但是仍然一大堆题目卡不出来，远远不如别人。。。好在最后莫名其妙的拿了国一。。。

ITC#

考点：家里

题目大多比较简单，只是不会一道编程题，城市赛 1= 后面的赛场就没再打了……

CCF#

CSP#

Day 0#

CSP-J/S 2023 要开始了，蒟蒻 Block_Fish 非常紧张！

不过准备的还行，但愿有个好成绩……

Day 1#

考点：【经济特区】实验初中部

距家里车程约 1h，跟平常到市区差不多。本部校区比我们学校和 GM 分校大多了，路痴别考了，但愿以后能去……

2026 翻修时补注：已经进入该集团 GM 区的某野鸡学部。

上午场（pj）#

题目有些难度，但还好。

选择第 111111 题考了一会儿改选项了……

判断题全选的 ✓……

没想到这样还能 74.574.574.5 全国前 10%10\%10%“保送”进入复赛……（GD 分数线等的我好苦……）

2026 翻修时补注：2024 赛季题目变简单了，但是分数低了 222 分。。。2025 靠 GESP 进了第二轮并光荣 1=

下午场（tg）#

第一眼看到第一题：这不弱智题吗？

第二眼看到第二题：我是弱智（……

pj 选手，tg 摆烂，飞速答完题后（都不用想的，反正都不会）。

45.545.545.5，【经济特区】分数线 46.5，我 KAO……

Day 2#

考点：YH 实验学校

就考了 pj……

T3 一元二次方程给我一六年级 xxs 干炸了……骗个第一个点 101010 分跑路（其实我可以骗 505050的，但没想到）

T4 输出-1，本想着三四个点最后就一个点……

然后 T1T2 反复横跳（重点写 T1）

T2 想假了，本以为性质AB都能骗最后“面向数据范围编程”结果它的数据比我预想的小很多，30—>15—>0……

T1 玩儿命想 AC，结果贪心不足反因为开了个 1e9 的long long数组 CE 爆 0（老师赛后告诉我把 9 改成 7 就可以 909090甚至 AC了……）

2=+4 级绿钩—>啥也没有，寄

GESP#

考点：【某经济特区】职业技术大学

搬家前在 PS 区，那里有个叫“【经济特区】技术大学”的考点，搬家后就得大老远跑位于市中心的到 FT 区去了……（真的有人会把它们弄混吗）

6 月 4 级#

选择判断很简单，编程 AC 了一道题，最后居然 595959 全国第 536536536……€€£你给我出来挨打！！！

9 月 4 级#

跟 6 月一样，这次 696969 了……

12 月 5 级#

没法跳级，但至少能考。

这次是团报。

选择判断还是那么弱。

编程题 T1 从 4 级的 AC25—>15，T2居然从 4 级的 0—>20（考场数据很弱对选手很友好，以后继续这样）。

团报能提前查分，737373。

ABC#

考点（？）：家里

最开始 327、328 两场 AC 了 C 题就以为自己能稳定做出 C，实际是做出 C 是偶然情况，祭。

几种最短路算法对比

Mon, 29 Jan 2024 22:41:55 GMT

WARNING

众所周知，关于SPFA，它死了。

几种最短路算法对比：

名称	时间复杂度	优点	缺点	使用情况
Floyd-Warshall	Θ(n3)\Theta(n ^ 3)Θ(n3)	仅有的多源最短路径算法（即跑一遍 Floyd 能求出每个点到其它点的距离）、其核心代码就 5 行	时间复杂度过高	多源最短路、对时间复杂度没要求
Dijkstra（朴素）	Θ(n2)\Theta(n ^ 2)Θ(n2)	无	编码复杂度非常高、不能处理负权，即边的权值是负数的情况（跟它用的是贪心有关）	不怎么用
Dijkstra（优先队列优化）	Θ(mlog⁡m)\Theta(m \log m)Θ(mlogm)	最快了	同朴素版	对时间复杂度有要求
Bellman-Ford	Θ(nm)\Theta(nm)Θ(nm)	我个人比较喜欢的算法，能处理负权，时间复杂度还行，而且核心代码只有 4 行	跟 Dijkstra 时间复杂度互有胜负，有时还是 Dijkstra 赢了	稀疏图
SPFA	最坏也是 Θ(nm)\Theta(nm)Θ(nm)	优化版 Bellman-Ford	众所周知，它死了	稀疏图
Jonson	Θ(nm+nmlog⁡m)\Theta(nm + nm \log m)Θ(nm+nmlogm)	仅有的全源最短路算法，结合了 Dijksra 和 SPFA 的优势	感觉跑多遍单源叫多源比较牵强、编码复杂度极高	不怎么常用……
BFS	Θ(n+m)\Theta(n + m)Θ(n+m)	思路简单	只能处理等权图或无权图	等权图/无权图

注：nnn 为点的个数，mmm 为边的个数。

B3929 [GESP202312 五级] 小杨的幸运数题解

Sun, 28 Jan 2024 22:58:26 GMT

因为一些众所周知的原因，不放代码。

分享一种考场思路：

a≤107a \le 10^7a≤107，顺序查找肯定会废，所以可以用一种类似埃氏筛的方法将所有满足条件的数标记一下，并将其加入一个答案数组 aaa 当中。然后每次查询只需要用lower_bound函数二分查找一下，假如找到了第 iii 个：

ai=xa_i = xai=x, 直接输出；

否则，比较 ∣ai−1−x∣\mid a_{i - 1} - x \mid∣ai−1−x∣ 和 ∣ai−x∣\mid a_i - x \mid∣ai−x∣，看看那个差值小输出。

最后算一下时间复杂度：预处理部分比埃氏筛快，查找部分二分时间复杂度最坏 O(Nlog⁡m)O(N \log m)O(Nlogm)，其中 mmm 就是查找出来的满足条件数数组大小，经计算，mmm 最坏是 500500500 左右，乘 NNN 显然是因为有 NNN 次查询，最后是 O(alog⁡log⁡a+Nlog⁡m)O(a \log \log a + N \log m)O(alogloga+Nlogm) 不到，不会 TLE。

ATC ABC 串讲——328（A~C）

Fri, 19 Jan 2024 21:18:04 GMT

A Not Too Hard#

N≤8N \le 8N≤8 也是醉了，循环枚举就得了呗？遍历一遍数组就可以 AC 了。

AC Code：

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
const int N = 10;
6
int n, x, a[N], sum;
7

8
int main() {
9
  scanf("%d%d", &n, &x);
10
  for (int i = 1;i <= n;i++) {
11
    scanf("%d", &a[i]);
12
    if (a[i] <= x)
13
      sum += a[i];
14
  }
15
  printf("%d\n", sum);
16
  return 0;
17
}

展开收起

AC 记录

B 11/11#

我生日哎。

数位最多两位，这个数位分解很简单。这里有一种简单粗暴的办法：如果十位是 000 就让它等于个位就好了，反正不影响结果。

AC Code：

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
const int N = 110;
6
int n, d[N], ans;
7

8
int main() {
9
  scanf("%d", &n);
10
  for (int i = 1;i <= n;i++) {
11
    scanf("%d", &d[i]);
12
    for (int j = 1;j <= d[i];j++) {
13
      int ge = j % 10, shi = j / 10, gei = i % 10, shii = i /10;
14
      if (shi == 0)
15
        shi = ge;
16
      if (shii == 0)
17
        shii = gei;
18
      if (ge == shi && shi == gei && gei == shii)
19
        ans++;
20
    }
21
  }
22
  printf("%d\n", ans);
23
  return 0;
24
}

展开收起

AC 记录

C Consecutive#

Tip

区间求答案，就想前缀和。

我们记录一个前缀和数组，如果后一位与前一位相同就记一个，否则就不计，时间复杂度是便利的 O(n)O(n)O(n)。

查询的时候直接用前缀和查询即可，单次复杂度 O(1)O(1)O(1)。

AC Code（带注释）：

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
const int N = 3e5 + 10;
6
int n, q, l, r, cnt[N];
7
string s;
8

9
int main() {
10
    scanf("%d%d", &n, &q);
11
    cin >> s;
12
    s = ' ' + s;  // 前缀和从1开始
13
    for (int i = 1;i <= n;i++)
14
        if (s[i] == s[i + 1])  // 相等
15
            cnt[i] = cnt[i - 1] + 1;  // 记录
16
        else
17
            cnt[i] = cnt[i - 1];
18
    for (int i = 1;i <= q;i++) {
19
        scanf("%d%d", &l, &r);
20
        printf("%d\n",  cnt[r - 1] - cnt[l - 1]);
21
        /*因为上面是 s[i + 1] 与 s[i] 相同就记录了，
22
        所以要用 cnt[r - 1] 以防在最后一组相同的区间内只有其中 1 个字符，
23
        即避免如 aabb 中的 bb 在筛查 1~3 的时候被计算*/
24
    }
25
    return 0;
26
}

展开收起

什么蹩脚英语。

AC 记录

ATC ABC 串讲——327（A~C）

Thu, 18 Jan 2024 22:21:04 GMT

A ab#

SSS 长度不超过 100，随便搞~

遍历一遍，如果一个是“a”且下一个字符是“b”就有，否则没有。

AC Code：

1
#include <bits/stdc++.h>
2

3
#define log printf
4

5
using namespace std;
6

7
int n, len;
8
string s;
9

10
int main() {
11
  scanf("%d", &n);
12
  cin >> s;
13
  len = s.size();
14
  for (int i = 0;i < len;i++)
15
    if ((s[i] == 'a' && s[i + 1] == 'b') || (s[i + 1] == 'a' && s[i] == 'b')) {
16
      log("Yes\n");
17
      return 0;
18
    }
19
  log("No\n");
20
  return 0;
21
}

展开收起

AC记录

B A^A#

18≈4\sqrt{18}\approx{4}18≈4，枚举到 10510^5105 最多了。

枚举每一个 AAA 就完事儿了，如果等于 BBB 就过，没有就继续连快速幂都不需要的。

AC Code：

1
#include <bits/stdc++.h>
2

3
#define log printf
4

5
using namespace std;
6
typedef long long ll;
7

8
ll b;
9

10
int main() {
11
  scanf("%lld", &b);
12
  for (ll i = 1; i <= (int) 1e5; i++) {
13
    ll tmp = 1;
14
    for (ll j = 1;j <= i;j++)
15
      tmp *= i;
16
    if (tmp == b) {
17
      log("%lld\n", i);
18
      return 0;
19
    } else {
20
      if (tmp > b) {
21
        log("-1\n");
22
        return 0;
23
      }
24
    }
25
  }
26
  log("-1\n");
27
  return 0;
28
}

展开收起

AC记录

C Number Place#

题干中给了一个数独，数独 =9×9=9\times9=9×9 的矩阵。

这里给出一个比较暴力的思路：暴力枚举每一行、每一列、每一个小方格（一个宫），如果恰好都出现就没问题。

AC Code：

1
#include <bits/stdc++.h>
2

3
#define log printf
4

5
using namespace std;
6

7
const int N = 10;
8
int a[N][N];
9
bool cnt[N];
10

11
void add(int x, int y) {  // 判断是否合法
12
  if (!cnt[a[x][y]])  // 没出现过
13
    cnt[a[x][y]] = true;
14
  else {  // 出现过了！
15
    log("No\n");
16
    exit(0);  // 退出程序
17
  }
18
}
19

20
int main() {
21
  // 读入，固定是 9*9 的矩阵
22
  for (int i = 1; i <= 9; i++)
23
    for (int j = 1; j <= 9; j++)
24
      scanf("%d", &a[i][j]);
25

26
  // 行
27
  for (int i = 1; i <= 9; i++) {
28
    memset(cnt, false, sizeof(cnt));
29
    for (int j = 1; j <= 9; j++)
30
      add(i, j);
31
  }
32

33
  //  列
34
  for (int i = 1; i <= 9; i++) {
35
    memset(cnt, false, sizeof(cnt));
36
    for (int j = 1; j <= 9; j++)
37
      add(j, i);
38
  }
39

40
  memset(cnt, false, sizeof(cnt));
41
  add(1, 1);
42
  add(1, 2);
43
  add(1, 3);
44
  add(2, 1);
45
  add(2, 2);
46
  add(2, 3);
47
  add(3, 1);
48
  add(3, 2);
49
  add(3, 3);  // 一个一个宫枚举
50

51
  memset(cnt, false, sizeof(cnt));  // 记得清空之前的状态
52
  add(1, 4);
53
  add(1, 5);
54
  add(1, 6);
55
  add(2, 4);
56
  add(2, 5);
57
  add(2, 6);
58
  add(3, 4);
59
  add(3, 5);
60
  add(3, 6);
61

62
  memset(cnt, false, sizeof(cnt));
63
  add(1, 7);
64
  add(1, 8);
65
  add(1, 9);
66
  add(2, 7);
67
  add(2, 8);
68
  add(2, 9);
69
  add(3, 7);
70
  add(3, 8);
71
  add(3, 9);
72

73
  memset(cnt, false, sizeof(cnt));
74
  add(4, 1);
75
  add(4, 2);
76
  add(4, 3);
77
  add(5, 1);
78
  add(5, 2);
79
  add(5, 3);
80
  add(6, 1);
81
  add(6, 2);
82
  add(6, 3);
83

84
  memset(cnt, false, sizeof(cnt));
85
  add(4, 4);
86
  add(4, 5);
87
  add(4, 6);
88
  add(5, 4);
89
  add(5, 5);
90
  add(5, 6);
91
  add(6, 4);
92
  add(6, 5);
93
  add(6, 6);
94

95
  memset(cnt, false, sizeof(cnt));
96
  add(4, 7);
97
  add(4, 8);
98
  add(4, 9);
99
  add(5, 7);
100
  add(5, 8);
101
  add(5, 9);
102
  add(6, 7);
103
  add(6, 8);
104
  add(6, 9);
105

106
  memset(cnt, false, sizeof(cnt));
107
  add(7, 1);
108
  add(7, 2);
109
  add(7, 3);
110
  add(8, 1);
111
  add(8, 2);
112
  add(8, 3);
113
  add(9, 1);
114
  add(9, 2);
115
  add(9, 3);
116

117
  memset(cnt, false, sizeof(cnt));
118
  add(7, 4);
119
  add(7, 5);
120
  add(7, 6);
121
  add(8, 4);
122
  add(8, 5);
123
  add(8, 6);
124
  add(9, 4);
125
  add(9, 5);
126
  add(9, 6);
127

128
  memset(cnt, false, sizeof(cnt));
129
  add(7, 7);
130
  add(7, 8);
131
  add(7, 9);
132
  add(8, 7);
133
  add(8, 8);
134
  add(8, 9);
135
  add(9, 7);
136
  add(9, 8);
137
  add(9, 9);
138
  log("Yes\n");
139
  return 0;
140
}

展开收起

三道题全是枚举。

AC记录

P2580 于是他错误的点名开始了题解

Thu, 18 Jan 2024 22:01:38 GMT

“普及/提高-”这个难度很有意思（当时还叫这个名字啊）。

说明这题可能需要用到提高组当中比较基础的内容。

它的名字叫做 map。

1
map<int, int> a;
2
a[7] = 5;
3
map<string, int> score;
4
score["Leo2011"] = 400;

map，其实相当于一个超大数组，但它真实的作用是：映射。比如 a[7] = 5;就是用 a 数组把 7 和 5 关联了起来，这个操作就叫映射。

map 这东西 NB 的地方在于，它能这么写：score["Block_Fish"] = 400;。哎对，这个类似下标的玩意儿就是个字符串！

有了这不好办了？拿这玩意儿记录一下有没有，然后分类判断即可。

ACCode:

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
unordered_map<string, int> mp;  // map 会自动排序，此时访问时间复杂度为O(logn)，unordered_map 不排序，时间复杂度O(1)
6
// 因为 `map` 的底层是红黑树，作为一种平衡树；而 unordered_map 底层是哈希。因此，对于 pair 之类的东西，要用 map 那就需要定义一个比较器，要用 unordered_map 就要定义一个冲突概率较低的哈希函数。
7
int m, n;
8
string s;
9

10
int main() {
11
  scanf("%d", &n);
12
  for (int i = 1;i <= n;i++) {
13
    cin >> s;
14
    mp[s] = 1;
15
  }
16
  scanf("%d", &m);
17
  for (int i = 1;i <= m;i++) {
18
    cin >> s;
19
    if (mp[s] == 1) {
20
      printf("OK\n");
21
      mp[s] = 2;
22
    }
23
    else
24
      if (!mp[s])
25
        printf("WRONG\n");
26
      else
27
        printf("REPEAT\n");
28
  }
29
  return 0;
30
}

展开收起

AC记录

P9012 [USACO23JAN] Moo Operations B题解

Thu, 18 Jan 2024 21:33:35 GMT

第 1 道赛场 AC 的题，必须发篇题解记录一下。

Tip

Tips: 1≤∣S∣≤1001 \le |S| \le 1001≤∣S∣≤100 ——题目

才 100，这就可以随便整活了。

如果你稍微懂点英语，就会知道第 2∼42 \sim 42∼4 个点的 SSS 都最多只有 333 个字符，而目标“MOO”也是 333 个字符，所以只需要模拟就可以了。

于是你迅速写出了下面的 check 函数，并用它 AC 了前几个点：

1
int check(string a) {
2
  if (a.size() < 3)  // 不让加字符，小于 3 的肯定就废了
3
    return -1;
4
  int step = 0;
5
  if (a == "MOO")  // 都一样了你还变它干啥，浪费表情(
6
    return step;
7
  string tmp1 = a;
8
  step++;
9
  if (tmp1[0] == 'M')  // 胡乱尝试
10
    tmp1[0] = 'O';
11
  else
12
    tmp1[0] = 'M';
13
  if (tmp1 != "MOO") {
14
    step++;
15
    if (tmp1[2] == 'M')
16
      tmp1[2] = 'O';
17
    else
18
      tmp1[2] = 'M';
19
  } else
20
    return step;
21
  if (tmp1 != "MOO") {
22
    step--;  // 撤销第 1 步操作，所以是--
23
    if (tmp1[0] == 'M')
24
      tmp1[0] = 'O';
25
    else
26
      tmp1[0] = 'M';
27
  } else
28
    return step;
29
  if (tmp1 != "MOO")
30
    return -1;
31
  return step;
32
}

展开收起

这样你就能顺利的 AC 前三个点了。

那剩下的咋整？

“MOO”就仨字符，那你把它砍成只有仨字符的形式不就得了？反正 100100100 的数据量随便折腾。所以，你只需要把仨字符能组成的 8 个字符串都枚举出来，挨个判断子串，如果仨字符的是子串，那么就是子串所需步数+原字符串长度-3。

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
int n;
6
string str;
7

8
int min(int a, int b) {
9
  return a > b ? b : a;
10
}
11

12
bool checkSubString(string a, string b) {
13
  int x = a.size(), y = b.size();
14
  if (x <= y) {
15
    for (int i = 0; i < y; i++) {
16
      if (b[i] == a[0]) {
17
        bool flag = true;
18
        for (int j = 0; j < x; j++)
19
          if (b[i + j] == a[j])
20
            continue;
21
          else {
22
            flag = false;
23
            break;
24
          }
25
        if (flag)
26
          return true;
27
      }
28
    }
29
  }
30
  return false;
31
}
32

33
int check(string a) {
34
  if (a.size() < 3)
35
    return -1;
36
  int step = 0;
37
  if (a == "MOO")
38
    return step;
39
  string tmp1 = a;
40
  step++;
41
  if (tmp1[0] == 'M')
42
    tmp1[0] = 'O';
43
  else
44
    tmp1[0] = 'M';
45
  if (tmp1 != "MOO") {
46
    step++;
47
    if (tmp1[2] == 'M')
48
      tmp1[2] = 'O';
49
    else
50
      tmp1[2] = 'M';
51
  } else
52
    return step;
53
  if (tmp1 != "MOO") {
54
    step--;
55
    if (tmp1[0] == 'M')
56
      tmp1[0] = 'O';
57
    else
58
      tmp1[0] = 'M';
59
  } else
60
    return step;
61
  if (tmp1 != "MOO")
62
    return -1;
63
  return step;
64
}
65

66
int checker(string x) {
67
  if (x.size() <= 3)
68
    return check(x);
69
  int mn = 10000;
70
  string a[] = {"OOO", "OOM", "OMO", "OMM", "MOO", "MOM", "MMO", "MMM"};
71
  for (int i = 0; i < 8; i++) {
72
    if (checkSubString(a[i], x)) {
73
      int tmp = check(a[i]);
74
      if (tmp != -1)
75
        mn = min(mn, (tmp + x.size() - 3));
76
    }
77
  }
78
  if (mn == 10000)
79
    return -1;
80
  return mn;
81
}
82

83
int main() {
84
  scanf("%d", &n);
85
  for (int i = 0; i < n; i++) {
86
    cin >> str;
87
    printf("%d\n", checker(str));
88
    str = "";
89
  }
90
  return 0;
91
}

展开收起

AC记录

Python 环境安装与配置

Sun, 31 Dec 2023 20:22:52 GMT

安装Python#

下载安装Python#

要用 Python，那肯定得先装个 Python 呐！

先把 Python 官网扒出来。访问速度一般不咋滴，请耐心等待~

如果正常，应该能出来个这个：

TMD 我等了半天出来个我不认识的全英版本？

是的，就是这样的。

没事，我帮你翻译。选 Downloads，鼠标在上面停留一会，会出现一个列表。直接选你用的系统（Win 就选 Windows，macOS 就是 macOS，Linux 的……自己找教程去吧，官方大概率没有先去包管理器看看，没有那就可以去 Other Platforms 瞅一瞅，还是没有那 GitHub 官方仓库自行编译或者 BDFS 吧），然后如下操作（macOS 会有一个universal2 installer，下载后打开，按指示操作就可以了）。

看图操作就好。下载可能比（fei）较（chang）慢，导入迅雷之类的下载器下载就好。

下载下来当然要打开啦（废话），正常情况下如图：

勾了 Add python.exe to PATH 选项后一键安装就可以了。

然后静静地等着它安装。

安装的同时，可以去隔壁 JetBrains官网看看，这里有待会要用的IDE——Pycharm。

安装完后，按 Win + R，输入 cmd，在弹出的窗口中输入 python（如果是 Linux/macOS，因为这两者系统中似乎内置一个 Python 的 2.x 版本，你需要做的是在终端中输入python3，相应地，后面的pip也要替换成pip3），如果结果如图，那么恭喜你，Python 安装成功（请注意！如果你没勾 Add python.exe to PATH 这个选项，那么你电脑是查不到的！这种情况下需要你配置一下环境变量，每个版本的 Win 都不太一样，自己度娘去，实在不行重装吧……）！

配置pip#

下一步，是配置 pip。pip 是用来管理外部库的，类似应用宝。pip 默认的下载地址在国外，链接可能会 TLE，需要配置一下。

Linux/macOS用户：#

打开配置文件 ~/.pip/pip.conf（不存在就创建），修改如下：

1
[global]
2
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
3
[install]
4
trusted-host = https://pypi.tuna.tsinghua.edu.cn

这里，https://pypi.tuna.tsinghua.edu.cn/simple是清华的镜像站，除了清华的，常用的还有：

名称	网站
南科大镜像源	https://mirrors.sustech.edu.cn/pypi/web/simple
阿里云镜像站	http://mirrors.aliyun.com/pypi/simple/
豆瓣镜像站	http://pypi.douban.com/simple/
中科大镜像站	https://pypi.mirrors.ustc.edu.cn/simple

Windows用户#

conf 文件在 C:\Users\xx\pip（xx是你用户名），其它的照抄Linux/macOS的即可。

升级turtle库#

这个步骤不是必须的，但很推荐操作。

现在你终端中跑一下这行代码：

Terminal window

1
pip install turtle --upgrade turtle

肯定会炸。翻到上面以Using cached xxx (xxkB)开头的那玩意，中间的部分是一个链接，用浏览器打开，会自动下载下来。

跑到下载目录，解压压缩包，找到setup.py，用记事本或者其它任何能编辑文本的东西打开（如果你装了下面的PyCharm，也可以用它）。找到第40行，更改成下面的样子：

1
except (ValueError, ve):

保存，在终端中切到这个目录，运行以下代码：

Terminal window

1
pip install -e turtle-0.0.2

现在应该就成功啦！

安装PyCharm#

这样 Python 就整完了，安装 PyCharm 去（当然，如果你愿意用 VSCode、Sublime Text 之类的其它工具写代码，我也不拦着你，但切记不要用自带的 IDLE 写，原因嘛这里有讲）。也就是说，Python 是自带一个编辑器（Intergrated Developing and Learning Environment, IDLE）的，只不过不太好用而且可能出问题就是了。

到这里，把页面拉到底部，下载 Community Edition 就可以了（Professional Edition 是付费的，而 Community 是免费的）。这次安装包是中文的，按指示操作就好。

打开 PyCharm，会出来一个 JETBRAINS COMMUNITY EDITION TERMS，直接点下面的勾后 continue 就好。

然后的界面中，点击 New Project（新建一个项目，不建就没法使 PyCharm），在新的窗口中如图配置，配置好后点 Create 就好了。

配置好后，就可以愉快的享受被誉为“宇宙最强 Python IDE”的 PyCharm 了！

Python GUI 图形化界面详解

Fri, 29 Dec 2023 23:07:10 GMT

简介#

话说你看到的软件是不是都是用图形化界面（Graphical User Interface, GUI）整出来的？

比如这个：

然鹅，再看看咱的“图形化界面”：

upd：这里的命令行界面连图形化界面都不是，应该叫文本用户界面（Text User Interface, TUI），不可以混淆！

根本不是一个等级的啊！于是，我们来用Python整一个真正的GUI吧！

安装环境#

Info

如果您已安装Python和一个另外的IDE，可以忽略此步骤。但如果后续发现有模块运行不了且代码、模块等正常，可以按照此步骤重新安装。 {% endnote %}

见这里

easygui#

Terminal window

1
pip install easygui

在你的终端中运行这段代码。如果出现了下面的东西，那么就说明安装 easygui 成功啦（以后我介绍的模块除了特殊说明外，都要用类似的方法安装，就不在提了）

1
Looking in indexes: https://mirrors.sustech.edu.cn/pypi/simple
2
Collecting easygui
3
  Using cached https://mirrors.sustech.edu.cn/pypi/packages/8e/a7/b276ff776533b423710a285c8168b52551cb2ab0855443131fdc7fd8c16f/easygui-0.98.3-py2.py3-none-any.whl (92 kB)
4
Installing collected packages: easygui
5
Successfully installed easygui-0.98.3

然后，在你的 IDE 中新建个 .py 文件，输入这段代码，如果出现了下面这幅图，就算成功啦！

1
import easygui as eg
2
eg.msgbox("Hello World!")

这个奇怪的窗口

点掉下面的OK，窗口就会消失。

如果有问题，请核实一下下面的东西：

Warning

easygui 是运行在 tkinter 上并拥有自身的事件循环，而 IDLE 也是 tkinter 写的一个应用程序并也拥有自身的事件循环。因此当两者同时运行的时候，有可能会发生冲突，且带来不可预测的结果。因此如果你发现你的 easygui 程序有这样的问题，请尝试在 IDLE 外去运行你的程序。

其实就3句话：

不要用自带的 IDLE！！！

如果没问题，那么，恭喜你，再次打开了新世界的大门！

接下来，就是对它的一顿研究了

1
eg.msgbox(msg = "A + B Problem", title = "Leo2011", ok_button = "I AK IOI!")

不出所料的话，应该是这样的：

看，我们用 title="Leo2011" 把标题改成了 “Leo2011”，用 ok_button="I AK IOI!" 把下面的按钮改成了”I AK IOI!”。

这就msgbox能干的事了。

下面，咱来看另外的几个家伙：

enterbox

1
s = eg.enterbox("欢迎您随便输入一堆东西", title = tit)
2
eg.msgbox(msg = "您刚才输入了\n" + s, title = tit, ok_button = "我知道了。")

能弹出这么个框：

框中可以随便输东西（只要你打得出来），输完了按回车或点 OK（这个不能改）结束。如果你点了 Cancel 或直接关掉了这个框，会返回 None（这不是一个字符串，是Nonetype，意思就是啥也没有）

multenterbox

有一堆 enterbox 在一个窗口里。
passwordbox

跟 enterbox 一样，只不过用户视角中输入的字符只能看到“*”，跟输密码似的。
multpasswordbox

有一堆 passwordbox 在一个窗口里。

ccbox

1
s = eg.ccbox("欢迎您随便选东西", title = tit, choices = ["[D]ebug", "C[t]j"])
2
eg.msgbox(msg = "您刚才输入了\n" + str(s), title = tit, ok_button = "我知道了。")

[] 里的字符相当于快捷键，你按下这个键就会认为你选了这个选项。ccbox 只能有两个选项（否则解释器会炸）。

boolbox/ynbox

同ccbox，不讲。
choicebox
```
1
s = eg.choicebox("欢迎您随便选东西", title = tit, choices = ["Debug", "Ctj", "AC!"])
```
UI 会变成这样：刚才的快捷键就只能是首字母了。choicebox可以有多个选项，但只能选一个（默认是第一个）。
buttonbox

同 choicebox，不讲。
indexbox

跟 choicebox 一样，只不过 choicebox 会返回你选中的文本，而 indexbox 会返回你选中的那货在你的选项列表里的下标。
multchoicebox

有一堆choicebox在一个窗口里？这次 easygui 不按套路出牌了，界面长这样： Select All 就是全选，Clear All 就是全不选，剩下两个老朋友了。返回值是这样的['Debug', 'AC!']。它会按你选中的选项在选项列表里的相对位置排成一个新列表。
integerbox
```
1
s = eg.integerbox(msg = "请输入一个数", title = tit, default = 5, lowerbound = 3, upperbound = 7)
```
指定你输入一个在 lowerbound 和 upperbound 之间的整数，默认为 default。如果不在区间内了会让你重新输入。
egdemo

easygui 所有函数的效果演示。

eaysgui 确实很 easy！

turtle#

Warning

请注意：实测 Python turtle 的不同版本在不同平台上可能会有所不同，本文以 Windows 11 + Python 3.12.1 为准。

turtle 库（人送绰号“海龟绘图”）是 Python 的内置库，安装了 Python 就可以直接用。

1
import turtle as t
2
t.write("Hello World!")
3
t.done()  # 这一行必须要有，否则你是看不见你的效果的

这就是你的第一个 turtle 程序了！

下面，还是来介绍几个基本函数的使用：

home

木有参数。回到原点 (0,0)(0, 0)(0,0)，也就是屏幕正中央的起始位置（这在你画图画懵 13 的时候很有用）。
forward/fd

111 个参数 kkk，表示你想要让这个画笔沿笔头方向前进 kkk 个像素。如 fd(1000) 即让画笔从当前位置前进 100010001000 个像素。
backward/bk/back

111 个参数 kkk，相当于 fd(-k)，即沿笔头方向后退 kkk 步。
left/lt

111个参数 kkk，表示你想让画笔左转 k∘k^\circk∘。
right/rt

111 个参数 kkk，表示你想让画笔右转 k∘k^\circk∘。
goto

222 个参数 x,yx, yx,y，表示将画笔直线移动到 (x,y)(x, y)(x,y) 的位置。如果画笔还没被抬起来，就会把轨迹画下来。
circle

用来画圆的（这是空心的）。参数最多 333 个：r,e,sr, e, sr,e,s， rrr 表示要画的圆的半径（必须要写），eee 表示圆心角度数（默认为整个圆），sss 表示要画的正多边形边数（不写会自动确定）。这里解释一下，电脑上画圆不太现实，都是用正 nnn 边形（这个 nnn 一般不小）模拟出来的，所以这个函数即可用来画圆也可以用来画正多边形。
dot

也是画一个圆。最多两个参数：ddd 和 color。 ddd 指要画的圆的直径，color 是一个字符串，表示要画的圆的颜色。与 circle 不同，dot 画的圆是实心的，而 circle 默认情况下是空心的。
penup/up/pu

抬起笔，此后在落下笔之前所有的操作都不会留下痕迹。

pendown/pd/down

落下笔。一般可以这么使：

1
def move(x, y):
2
    t.pu()
3
    t.goto(x, y)
4
    t.pd()

speed

设置速度的，有一个参数 vvv。你在用的时候，应保证 0≤v≤100 \le v \le 100≤v≤10。一般情况下，vvv 是个整数，且越大代表越快，但也有例外：

vvv 的值速度
0 或”fastest” 最快
10 或”fast” 快
6 或”normal” 正常（默认）
3 或”slow” 慢
1 或”slowest” 最慢
pensize/width

一个参数 www，表示画笔粗细。

vvv 的值	速度
0 或”fastest”	最快
10 或”fast”	快
6 或”normal”	正常（默认）
3 或”slow”	慢
1 或”slowest”	最慢

pencolor

可以没有参数，此时返回画笔颜色（默认是黑色），也可以给出参数，此时是设置颜色。

有以下几种设置模式：

1
t.pencolor("red")  # 设置为红色
2
t.pencolor("#abcde")  # 设置为十六进制编码为“abcde”的颜色
3
t.pencolor((1, 255, 255))  # 设置为青色。三个数值表示RGB编码
4
t.pencolor(1, 255, 255)  # 同上，只不过上面传过去的是一个元组。

fiilcolor

填充颜色，同上。
color

两个都设置了，可以填写 1∼21 \sim 21∼2 组参数。111 组就是设置成一样的，两组就是先 pencolor 再fillcolor。
bgcolor

背景颜色，参数同 pencolor。
bgpic

背景图片，需要给一个字符串表示背景图片位置。如果是 nopic 就是删除背景图片。
begin_fill

记录一下，准备填充。
end_fill

把上次 begin_fill 以后画的东西填充成 fillcolor。
write

主要有 222 个参数，文字和设置。可以把文字设置成属性后写上去，如开头的例子。
hideturtle/ht

隐藏画笔，能加速。
showturtle/st

显示画笔。
shape

海龟绘图，海龟在哪儿呢？

就是这么设置的。

给定一个参数，它会自动把海龟调整成对应的形状。

支持以下形状：
- “arrow”
- “turtle”
- “square”
- “triangle”
- “classic”
可以自己去试一试~
stamp

把画笔印在当前位置，即在那个位置留下海龟的形状。

turtle 库就先介绍这些，不少了。自个儿试着画几张图去吧！

老规矩，有问题的欢迎私信联系我。

关于三目运算符，你需要知道的一切

Sat, 25 Nov 2023 14:35:08 GMT

if…else语句常写吧？

But，你会不会觉得：

写 if...else？烦死了！

写switch？就俩我写啥……

于是，又一个 C艹利器——三目运算符诞生啦！

先上代码：

mn = (a < b) ? a : b; /* 其中，? :为三目运算符，一般为“结果保存值 = 条件 ? 结果A : 结果B*/

意思即：如果 a < b，那么 mn = a，否则 mn = b`

那不就是 if...else 吗！

不，如果你用 if...else，那么代码会变成这样：

1
if (a < b) mn = a;
2
else mn = b;

不仅变长了，而且，三目运算符是个运算符，它可以被塞进别的语句（写 DFS 或 DP 的时候可能会用到）里面！

最后，说一下性能排名（注：这部分是早期资料，不保证真实性，实战中也鲜有人会利用这种特性，差异一般认为是评测波动即可）。三目运算符作为运算，速度最快，但也有很大的限制（比如嵌套时就会有点 BT）。而switch 和 if…else 不相上下，但是 3 个以上语句时，switch 不仅更方便，还更快哟。

但 if…else，它是最通用的，拿不准选这个就好了。

关于__int128和short，你需要知道的一切

Sat, 25 Nov 2023 14:34:49 GMT

高精度大家都认识吧？

但是，高精度这货是真滴长……

于是，人们又发明出了一个东西 __int128！

__int128（注意前面有2个下划线）嘛，把特点写脸上了：占用128位，也就是16个字节。储存范围，自然也是占用64位的long long的2倍。换算一下，能存三十多近四十位。基本上可以代替部分高精度了。

那__int128这么NB，咋就不能被广泛使用呢（好多教材没教这个对不）？

因为它缺陷也很多：

不通用。__int128 并没有在任何一个 C艹标准中严格定义，所以目前它的支持情况看编译器，不过好消息是一般 GCC（包括 NOI Linux 的那个古董）在内都是支持的）。
不方便。__int128目前看来是不支持直接读入、输出的。管你是 cin、cout、scanf 还是 printf，都甭想输入一个 __int128 类型的数据。于是它需要通过快读（快写）来读入/输出。
空间大，速度慢。 __int128 占用了 16 个字节来存，MLE的风险显著增加。空间大速度还慢。你想啊，人家int 才 32 位，64 位的CPU一次处理俩；你 128 位，64 位的 CPU 两次处理 1 个，不得慢死（TLE 风险增加）……当然啦，这货肯定比高精度快得多。

不过，为了让大家多掌握（pian）亿点东（fen）西，下面给出使用 __int128 时的基本框架。

1
#include <bits/stdc++.h>
2

3
#define log printf
4

5
using namespace std;
6

7
__int128 n;
8

9
__int128 reader() {
10
  __int128 x = 0; // 虽然限制那么多，但咱赋个值总还是可以的吧……
11
    int w = 0;
12
    char ch;
13
    while (!isdigit(ch)) {
14
      w |= ch == '-'; ch = getchar();
15
    }
16
    while (isdigit(ch))
17
      x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar();
18
    return w ? -x : x;
19
}
20

21
void output(__int128 x) {
22
    if (x < 0) {
23
        putchar('-');
24
        x *= -1;
25
    }
26
  if (x > 9)
27
    output(x / 10);
28
  putchar(x % 10 + '0');  // 众所周知这货只能搞四则运算，输出还请数位分解一下（其实就是快读快写）
29
}
30

31
int main() {  // 你变量全用 __int128 我也不拦着你，但永远记住 main 函数不开 int（好吧用 signed 也行，因为这货本来就是 signed int）会 CE 的哈
32
  n = reader();
33
  // 请自行操作
34
  output(n);
35
  return 0;
36
}

展开收起

总结就是它是高精度的下位替代，相对好写很多，但也有不少缺陷——类似树状数组和线段树的关系，前者速度快、代码简单，后者速度慢但能解决更多问题，使用时各取所需即可。

说了这么半天慢的太吓人的 __int128，那有木有一个特快的，比如说 16 位 2 个字节的哪种？

还真有，而且这个槽点就没那么多了。它就是——short！

short 这玩意儿可比 __int128 强多了。它是通用的，也是可以直接读入、输出的（scanf 和 printf统一用“%hd”）。

那为啥它用的也不多呢？

因为它太省内存了，你说它就 −215∼215−1-2 ^ {15} \sim 2^{15} - 1−215∼215−1(−32768∼32767-32768 \sim 32767−32768∼32767，绝对值不超过 444 万）的存储范围能存个啥？考虑到一般情况下卡时间的出题人比卡空间的多得多，而且一般卡空间也不是换个数据类型就能解决的，因此一般还是用 int。

与这两个对应的，浮点数除了 double 还有 float 和 long double，但如果 auto 一下就会发现其实默认用的也是 int（整数）、double（浮点）。存储范围太大了不好，太小了也不行，工程的本质就是寻找中间这么一个“刚刚好”，这就是所谓中庸之道。

关于 switch，你需要知道的一切

Sat, 25 Nov 2023 14:03:51 GMT

话说写代码时要写 1 吨 if 的题你们有木有遇到？

比如这道题。6 个操作要写 6 个 if！那么你的代码可能会成这德行：

1
if (op == 1) {
2
  // 一顿操作猛如虎
3
} else {
4
  if (op == 2) {
5
    // 一顿操作猛如虎
6
  } else {
7
    if (op == 3) {
8
      // 一顿操作猛如虎
9
    } else {
10
      if (op == 4) {
11
        // 一顿操作猛如虎
12
      } else {
13
        if (op == 5) {
14
          // 一顿操作猛如虎
15
        } else {
16
          //一顿操作猛如虎
17
        }
18
      }
19
    }
20
  }
21
}

展开收起

坑*啊！一个这写 20 多行……

于是，人们发明了这个东西：switch！

switch 这玩意儿需要你给它 1 个数，它会自己判断。

格式大概是这样：

1
switch (op) {
2
  case 1 :  /*一顿操作猛如虎*/ break;
3
  case 2 :  /*一顿操作猛如虎*/ break;
4
  case 3 :  /*一顿操作猛如虎*/ break;
5
  case 4 :  /*一顿操作猛如虎*/ break;
6
  case 5 :  /*一顿操作猛如虎*/ break;
7
  case 6 :  /*一顿操作猛如虎*/ break;
8
  ......
9
  case 10086: /*一顿操作猛如虎*/ break;
10
  default : /*一顿操作猛如虎*/

咱来解读一下这货咋跑的：

先进去，op 是几就进哪个 case（与位置无关），执行里面的操作。注意case 语句后面的操作无论有几个语句都不用像 if 或循环那样写个花括号括起来。最后，如果你认为到此为止了，那么写个“break”结束。如果你不写“break”，那么它会自动执行下一个语句（可以是 case，也可以是 default）

如果哪个 case 都不对应呢？那么这个时候就进了 default。default 已经是默认一波操作了，不需要 break 了。

明白了不？

那么用 switch 语句改写上面那段代码就会变成这德行：

1
switch (op) {
2
  case 1 :  /*一顿操作猛如虎*/ break;
3
  case 2 :  /*一顿操作猛如虎*/ break;
4
  case 3 :  /*一顿操作猛如虎*/ break;
5
  case 4 :  /*一顿操作猛如虎*/ break;
6
  case 5 :  /*一顿操作猛如虎*/ break;
7
  case 6 :  /*一顿操作猛如虎*/ break;

是不是清爽了好多？

Q & A:

case 里的 break; 还能结束循环吗？

不能，只能结束该 switch 语句。
你最后的那段代码没有 default 哎……

这货本来就是默认操作，可写可不写。就像你也写过 1 吨不带 else 的 if 一样……
default 只能写在最后嘛？

你爱写哪儿写哪儿，反正能走 case 的都先走 case 了。只不过一般会写在最后。
switch (op) 中的 op 可以是哪几种类型呢？

一般都是整数，有时也会用 char（它本质上是个 1 字节整数）。但你千万别用浮点数（浮点数都敢枚举，疯了？这得枚举到猴年马月去……为了给你续命，正常的编译器都会直接 CE）。
case 里的东西只能写在 1 行里弄得我码风都乱了……

不是，这 TM 谁告诉你只能写在 1 行里的？你要是愿意可以写 10086w 行，反正都不用加花括号。写在 1 行里只是为了方便阅读……
能嵌套吗？

当然可以，switch= 特殊的 if 语句，你 if 能嵌套 switch 咋就不行了？

关于 auto，你需要知道的一切

Sun, 24 Sep 2023 17:35:39 GMT

话说咱写 STL 的时候经常会要写迭代器，大概是这么一大串东西：

vector<int>::iterator iter = data.begin();

好烦啊！而且，iterator 这个单词容易写错（CE：走好不送）……

于是，在 C艹 11标准中，C艹开发者发明了一个超级好用的东西：auto!

auto 这货类似于 Python 定义变量，会自动确定它的类型！

如：

auto a = 3; // a为int类型

auto b = a + 0.1; // b为double类型

好爽哦有木有！

于是，开头的那段代码就可以写成这德行：

auto iter = data.begin();

你以为这就结束了？不，还有！

咱还能这么玩：

1
for (auto i : data) {  // 不用auto写也行，只不过auto较简便
2
    // 正常写，i是普通的迭代器
3
}

不过需要注意几点：

auto 和 for 里用冒号的写法和 to_string 函数一样，都是C 艹 11的新特性，在Dev-C 艹中需要单独设置（否则直接炸裂）
比赛时采用 C 艹 14 标准，可放心使用
~~auto 因为要自动判断类型，运行速度会略慢一丁点，不过差距大概就是 scanf 和 cin 那点，一般 €€£ 不会在这点上卡常的(ps：据说 €€£ 在敛财将评测机由“老爷机”置换为“少爷机”，传闻新评测机能够在 1 秒内 AC(105×10510^5 \times 10^5105×105)的数据。但只是传言！现在还没有那么快！老老实实把代码时间复杂度降下来吧)……~~根据@_trailblazer的指证和常理推断，auto在编译期间就会判断类型，对运行速度没有影响。
别尝试在不赋初值的情况下 auto 变量，否则大概是这个场景：

你： auto arr[10086], x; // 应该是两个 int

编译器：这踏马谁知道 arr 这货是啥类型啊……这个x又是个啥？？？

Python ：我咋可以呢？

编译器：废话你啥都能存进去……

评测组件：Compile Error！

€€£ 砖家组：唉，又一个爆 0 了的……

到时候别怪我没提醒你啊……

auto 初始化一定要赋初值！！！

重要的事情说三遍。

Firefly 布局系统详解

Sat, 03 Jan 1970 00:00:00 GMT

📖 概述#

Firefly 提供了灵活的布局系统，允许您根据内容需求和个人喜好自定义博客的视觉呈现方式。布局系统主要包括侧边栏布局和文章列表布局两个维度，它们相互配合，共同决定了页面的整体结构。

本文将详细介绍 Firefly 的各种布局模式、它们的特点、使用场景，以及不同布局组合的效果。

左侧边栏+列表布局

右侧边栏+网格布局

左侧边栏+三列网格布局

双侧边栏+列表布局

双侧边栏+网格布局

双侧边栏+网格瀑布流布局

一、侧边栏布局系统#

侧边栏是博客页面的重要组成部分，用于展示导航、分类、标签、统计信息等辅助内容。Firefly 支持两种侧边栏布局模式。

1.1 单侧边栏模式#

左侧边栏 (position: “left”)#

左侧边栏布局

右侧边栏 (position: “right”)#

右侧边栏布局

特点#

侧边栏固定在页面其中一侧
文章阅读区域体验更佳，更宽敞
更加简约，没有那么紧凑

适用场景#

传统博客风格
强调导航和分类的博客
需要突出用户资料的个人博客
内容为主，辅助信息次之的场景

Tip

文章详情页显示哪几侧，由**各组件的 showOnPostPage（以及 hideOnNonPostPage）**决定：某一侧在当前页型下没有任何可见组件时，该列会自动收起，把空间让给内容栏。

如果想在文章页同时显示双侧边栏，把 position 设为 "both"，并给两侧组件配好 showOnPostPage 即可。

配置示例#

src/config/sidebarConfig.ts

1
export const sidebarLayoutConfig: SidebarLayoutConfig = {
2
  enable: true,
3
  position: "left", // 左侧边栏
4
};

1.2 双侧边栏模式 (position: “both”)#

特点#

左右两侧同时存在侧边栏
主内容区域位于中间
最大化利用屏幕空间
可以展示更多辅助信息
适合宽屏显示器

布局结构#

双侧边栏+列表布局

双侧边栏+网格布局

适用场景#

宽屏桌面端浏览
信息密集型博客
需要展示大量辅助内容
专业性强的技术博客

配置示例#

src/config/sidebarConfig.ts

1
export const sidebarLayoutConfig: SidebarLayoutConfig = {
2
  enable: true,
3
  position: "both", // 双侧边栏

二、文章列表布局系统#

文章列表是博客首页和归档页的核心内容，Firefly 提供两种展示方式，并支持多种网格配置。

2.1 列表模式 (defaultMode: “list”)#

特点#

单列纵向排列
显示文章封面图，可配置在左侧或右侧
展示更多文章摘要
适合深度阅读

列表布局结构#

列表模式布局

封面位置#

列表模式的封面图默认在卡片右侧，可以通过 coverPosition 改到左侧。改到左侧后，标题前的主题色竖线会自动隐藏（它是贴着卡片左边缘的设计），腾出的间距留给正文。

网格模式的封面固定在卡片顶部，不受这项配置影响。

优点#

✅ 视觉冲击力强，封面图吸引眼球
✅ 可以展示更多文章信息（摘要、标签等）
✅ 适合图片内容丰富的博客
✅ 移动端友好，单列更易阅读
✅ 兼容所有侧边栏配置（单侧、双侧）

配置示例#

src/config/siteConfig.ts

1
export const siteConfig: SiteConfig = {
2
  postListLayout: {
3
    defaultMode: "list",    // 列表模式
4
    coverPosition: "right", // 封面图位置："right" 右侧，"left" 左侧
5
  },
6
};

2.2 网格模式 (defaultMode: “grid”)#

特点#

自适应列数，根据浏览器宽度自动调整
紧凑布局，信息密度高
适合快速浏览

自适应网格#

网格模式通过 columnWidth 配置卡片的最小宽度（单位 px），浏览器会根据容器可用宽度自动计算能容纳多少列。

网格布局

配置示例#

src/config/siteConfig.ts

1
export const siteConfig: SiteConfig = {
2
  postListLayout: {
3
    defaultMode: "grid",
4
    grid: {
5
      masonry: true,      // 开启瀑布流
6
      columnWidth: 320,   // 卡片最小宽度(px)，浏览器自动计算列数
7
    },
8
  },
9
};

2.3 瀑布流布局 (Masonry)#

Firefly 的网格模式内置了智能瀑布流布局支持，解决了网格布局中因图文混合文章导致的卡片高度不一致导致的空白问题。

瀑布流布局

智能排版：自动将卡片放置到最短的列，最大化利用垂直空间。
消除空白：通过绝对定位精确计算每个卡片的位置，让卡片紧贴上方卡片，消除垂直方向的空白间隙。
自适应列数：瀑布流同样根据 columnWidth 和容器宽度动态计算列数，无需固定配置。
配置灵活：您可以在 siteConfig.ts 中通过 postListLayout.grid.masonry 选项自由开启或关闭此功能。

三、布局组合指南#

Firefly 允许您自由组合侧边栏和文章列表布局。以下是各种组合的效果说明。

侧边栏模式	文章列表模式	推荐度	适用场景
单侧边栏	列表模式	⭐⭐⭐⭐⭐	摄影、设计、生活类博客，强调图片和沉浸感
单侧边栏	网格模式	⭐⭐⭐⭐⭐	技术、笔记类博客，平衡阅读与检索效率
双侧边栏	列表模式	⭐⭐⭐⭐⭐	需要展示大量侧边栏信息的站点
双侧边栏	网格模式	⭐⭐⭐⭐⭐	极客风格，追求最高信息密度

四、响应式布局行为#

Firefly 的布局系统具有智能的响应式设计，会根据屏幕尺寸自动调整。

为了保证最佳阅读体验，系统会在屏幕变窄时自动调整布局：

网格列数自动减少：网格模式的列数由 columnWidth 和容器宽度自动决定，屏幕越窄列数越少。
列表模式 -> 网格模式：当屏幕宽度小于 380px（超小屏设备）时，列表模式会自动切换为网格模式，以保证卡片内容的可读性。
双侧边栏 -> 单侧边栏：当屏幕宽度小于 1280px 时，会根据tabletSidebar配置显示单侧边栏，隐藏其中一个侧边栏，文章目录导航会切换成浮动目录导航。

五、常见问题#

Q1: 如何调整网格列数？#

A: 通过 columnWidth 配置卡片最小宽度即可。值越小，同等宽度下列数越多；值越大，列数越少。浏览器会自动根据可用宽度计算最佳列数。

六、总结#

Firefly 的布局系统给予了您更大的自由度，您都可以通过简单的配置实现。

我们建议您根据自己的内容类型和目标读者的设备偏好，尝试不同的组合，找到最适合您的博客形态。

Firefly Wiki Link 内部链接示例

Sat, 03 Jan 1970 00:00:00 GMT

Firefly 支持在 Markdown、MDX 文章中使用 Obsidian 风格的 Wiki Link 内部链接。链接目标填写文章的 slug 或文件路径，都不需要包含扩展名，具体匹配规则见下文「链接目标的三种写法」。

文章链接卡片#

[[slug]] 单独成段时，会自动读取目标文章的标题、描述、发布时间、分类、标签和封面，渲染为链接卡片：

1
[[firefly]]
2

3
[[guide/index]]
4

5
[[markdown-extended]]

firefly

Firefly 简单使用指南

如何使用 Firefly 博客模板。

1970-01-02博客指南#Firefly#博客#Markdown#指南

markdown-extended

行内链接#

[[slug]] 出现在正文中间时，渲染为普通链接，链接文字自动使用目标文章的标题

1
请参阅 [[firefly]] 了解主题特性。

请参阅 firefly 了解主题特性。

自定义显示标题#

在 | 后填写链接的显示文字。行内链接会用它替换文章标题；单独成段时依然渲染为卡片，卡片标题使用自定义文字，描述、时间、分类、标签和封面仍然读取目标文章：

1
请参阅 [[firefly|主题介绍]] 了解主题特性。
2

3
[[firefly|Firefly 主题介绍]]

请参阅主题介绍了解主题特性。

Firefly 主题介绍

一个例外：如果 | 后的文字只是把链接目标又抄了一遍（[[guide/index|index]]），会被当作无效别名忽略，仍然显示文章标题。Obsidian 在插入的链接时会自动补上这样的别名，避免笔记里显示一长串路径，这个例外就是为它准备的。

链接目标的三种写法#

用 Obsidian 管理文章时，把 src/content/posts 目录本身作为 Obsidian 仓库（vault）打开。下文提到的「仓库根目录」都指这个目录，它正好也是 Firefly 解析链接路径的起点。

链接目标按以下顺序匹配：

写法	示例	在 Obsidian 中
frontmatter 的 `slug`	`[[firefly-wiki-link]]`	✗ 不支持
文件路径（相对仓库根目录）	`[[guide/firefly-layout-system]]`	✓ 需改设置（推荐）
裸文件名（仓库内唯一时）	`[[firefly-layout-system]]`	✓ 默认即是

第一种：slug#

slug 写法在 Obsidian 中不支持，slug 是 Firefly 自己的概念，Obsidian 不读取 frontmatter 里的 slug，所以按 slug 写的链接在 Obsidian 里既不会自动补全，也点不动，只有构建出的站点上能正常跳转。如果你主要在 Obsidian 里写作，用下面两种写法。

第二种：文件路径（推荐）#

文件路径写法需要改 Obsidian 设置，在 设置 → 文件与链接 → 链接 → 内部链接类型 中选择基于仓库根目录的绝对路径，Obsidian 插入的链接才会带上目录：

1
[[guide/firefly-layout-system|firefly-layout-system]]

Firefly 布局系统详解

深入了解 Firefly 的布局系统，包括侧边栏布局（左侧/双侧）和文章列表布局（列表/网格），以及自适应网格列数。

1970-01-03博客指南#Firefly#布局#博客#指南

因为仓库根目录就是 src/content/posts，Obsidian 写出的这个路径和 Firefly 需要的路径完全一致，不需要任何额外转换。

上面这行末尾的 |firefly-layout-system 是 Obsidian 自动补的别名，Firefly 会忽略它，卡片标题仍然取文章的 title，除非你把它修改和文件名不一致，才会变成你修改后的别名。

内部链接类型下拉框里的基于当前笔记的相对路径只在同目录内可用：它给同目录文章生成的是裸文件名，能正常匹配；但跨目录时会生成 ../ 前缀，Firefly 无法解析，链接会按原文显示。

第三种：裸文件名#

「内部链接类型」的默认值就是尽可能简短的形式：只要文件名在整个仓库里唯一，Obsidian 插入的链接就只有文件名，不带目录。这种写法不需要改任何设置，效果和写完整路径完全一致：

1
[[firefly-layout-system]]

Firefly 布局系统详解

深入了解 Firefly 的布局系统，包括侧边栏布局（左侧/双侧）和文章列表布局（列表/网格），以及自适应网格列数。

1970-01-03博客指南#Firefly#布局#博客#指南

文件名重名时这种写法会失效，构建日志里会给出提示，改用完整文件路径即可，所以推荐直接修改 Obsidian 内部链接类型设置为基于仓库根目录的绝对路径，使用第二种文件路径写法，一劳永逸

链接到其他文章的标题#

在文章 slug 后添加 #标题。带标题锚点的链接始终渲染为普通链接：

查看代码块语法高亮

Firefly 布局系统详解#相关链接

1
[[code-examples#语法高亮|查看代码块语法高亮]]
2

3
[[guide/firefly-layout-system#相关链接|firefly-layout-system]]

标题锚点使用与页面标题相同的 slug 规则，因此中文、空格和大小写都会按页面实际生成的 ID 处理。

链接到本页标题#

省略文章 slug，只填写标题即可链接到当前文章：

跳转到本页目标

1
[[#本页目标|跳转到本页目标]]

本页目标#

这是本页 Wiki Link 指向的标题。

不支持附件嵌入#

附件嵌入语法目前不会被转换，会按原文显示：

![[image.png]]

行内代码和代码块中的 [[firefly]] 也不会被转换。