前言

最近发现电脑越来越卡了，感觉像是有病毒在后台一样，但是某60安全卫士没有给出反馈，随即卸载了360，后面也尝试了火某杀毒，效果也不理想，根本找不出病毒，然后就一一尝试了以下 3 个杀毒软件，都挺不错的，成功把我电脑里流氓软件和病毒给赶走了。

可能会有人觉得杀毒软件没必要付钱，免费够用了，但是在AI下的2026年，免费杀毒软件正在“疏忽泄露“你的各种信息，比如密码，聊天信息，重要文件等等，病毒更新越来越快，各种手段层出不穷，你觉得你不访问陌生链接，不下载不明软件就安全了？不不不，最近的很多泄露事件都表明了这是行不通的，这个钱还是应该付的。

声明：不是广告推广，均为实测，在200个病毒样本中测试，这200个病毒样本均是测试博主之前用过的某60，火某，某管家未能防御成功的。

1. ESET

下载链接

200个病毒检测出来179个，检测用时7分34秒，剩余的运行全部防御成功

• 免费30天

• 占用资源非常少

• 几乎不打扰的体验

• 强大的静态和动态防护能力

这个杀毒软件很好用，付费版功能多了反而用不上，最重要是它是 3 个中对电脑占用资源最少的一个，如果你不想影响电脑性能又想不让电脑中毒这个绝对值得用一用！

2. Norton

200个病毒检测出来184个，检测用时4分21秒，剩余的运行全部防御成功

下载链接

• 付费，一年最便宜36人民币

• 静态和动态防护都很强，网上评价也很高

• 占用资源较少

• 功能很全面，而且不怎么多余

博主目前就用的这个，价格很实惠，卸载某60后用这个杀毒软件在电脑开机期间就检测出了2个木马病毒，是可以让你安心用电脑的杀软

3. BitDefender

200个病毒检测出来191个，检测用时2分16秒，剩余的运行全部防御成功

下载链接

• 3个中能力最强最稳的一个

• 有可以一直用的免费版

• 占用资源较多，对电脑性能有较明显影响

这个能力很强，特别稳，如果你不担心杀软的性能影响可以用这个，且这个有永久免费的版本是可以一直用的。

Cloudflare的免费版对于国内的访问在没有优选的情况下确实有些慢了，一番折腾后我还是换了 EdgeOne 做了CDN，访问速度显著提升了，以下是测速结果，较之前使用 Cloudflare 时还是有提升的，加载最慢从 20 秒到了 6 秒左右，挺不错的。不过 EdgeOne 的缓存配置可能会有一些问题，如果大家发现了有关的问题，欢迎在评论区反馈~

由来

2026年5月28日，Anthropic 在他们的官网发布了一篇文章，如下

官方说的话翻译过来就是，Claude Opus 4.8 在 Opus 4.7 基础上升级，判断力更强，更能诚实反馈自己的进展，也能比上一代更长时间独立工作，而且价格不变。

这句话看着没什么，但是其实隐含很多。

Claude Opus 4.7发布时就遭人诟病，能力是强了，但是变得懒惰了。

judgment、honesty、work independently。

判断力、诚实度、独立工作能力。

这三个词充分表明了Claude未来的技术路线，不再是普通对对话的模型，而是可以真正交付工作和任务的“可靠AI同事”。

一、判断力

AI 现在不缺回答，缺的是回答的可信度真的会完全相信一个 AI 吗，把他用于自己的工作上，你真的相信他给的建议、代码吗？Claude就在做这样一件事，让 AI 变得更加长期可信。

这次的更新实现一件很难的事情：AI知道什么时候该继续，什么时候该停下，什么时候该反驳你，什么时候该承认方案不靠谱了。

二、诚实度

假设你是1个长期使用AI开发项目的人，你会仔细查看AI编写的项目的实际效果来和你的要求对比吗，你会尝试找到Bug然后让AI修复吗，我想大多数人是会的，因为人们不敢完全相信AI，这是会造成灾难性后果的，且有实际例子的。

之前的AI不会告诉你，我这个没完成，哪里可能还有问题，但是Opus 4.8现在会了

所以 Claude Opus 4.8 强调“more honesty about its own progress”

一个能诚实告诉你“我还没完成”“这里不确定”“这个测试失败了”“我需要重新检查”的模型，比一个永远自信满满的模型更可靠。

下面这张图是官方测试，得分越高的模型，越容易欺诈和配合欺骗，可以看到Opus 4.8是明显低于Opus4.7的

三、更长时间独立工作

这是一句富有重量的话，这意味着什么，对开发者、产品经理、研究员、内容团队来说，这个AI开始工作后，不会隔几分钟就来问你 “接下来该怎么做”

他从按要求，完成要求，继续接要求，变成了接任务然后完成交付。

对于Claude Code、Codex这类工具来说，Claude Opus 4.8的更新让他能在此类工具中胜任更加复杂的任务，并做得更出色！

方法

水一期文章，大家应该都知道

访问 https://note.ms/0? 就可以修改文章了

原理

Note.ms对于后端页面的修改处理逻辑是这样的：

判断是不是特殊页面/0，是则不让修改，不是就通过

但是/0?中的?本身就是网址的特殊符号，因为判断逻辑是判断0?与0不完全匹配，Note.ms就会放行修改，但是0?实际和0是差不多等价的，所以实际是修改了/0页面。

在特朗普访华结束后，最近逛京东发现可以买 RTX 5090 和 RTX PRO 6000 了？

难道是解禁了吗？但是这个价格相比官网有些高了，去英伟达官网看，可以发现官网并没有更新

但是根据我查资料了解到，H200解禁了，那么理论上RTX5090也会解禁。可能是细节还在谈。这次访华双方谈妥了很多东西，所以才又爽快的下了200架波音订单。今天看发布的公告，后续还有更多双方解禁和降低关税。

一、工具介绍

博主这里已经把这个做成了一个在线工具，进入输入你的配置就可以直接简单界面化的配置给Frpc配置SSL证书（Chmlfrp基于标准的Frp客户端，理论上可以通用），其中证书的文件路径为你的证书文件在本地存放的路径。

二、使用方法

1.输入配置

这里的配置以示例配置来演示，输入配置，点击解析配置按钮。

可以把每条隧道单独拆开放入列表中，单价可以查看详细信息，你可以选择勾选哪些来进行配置。

2. 配置证书

你可以选择通配符证书或者单独的证书

这里的证书位置输入你本地的证书存放的绝对路径（完整路径），如果是windows就要带上哪个盘，linux就不用。

然后在列表里面看看你需要给哪些网站开启强制Https跳转

3. 生成配置

所有完成后点一下步就自动生成出来了，复制粘贴到 frpc.ini 就可以直接使用，快去试试吧！

题目大意

有若干堆石子，每一次需要从一堆石子中拿走一些，然后如果愿意的话，再从这堆石子中拿一些分给其它任意堆。不能操作的人就输了。

同时，石子只能移到非空堆，一旦某堆变为 0，它就无法继续操作了。

题目分析

一、游戏规则

每次操作分两步：

1. 移除：从某堆中拿走至少 1 个石子

2. 分配（可选）：将该堆剩余的石子任意分配到其他仍有石子的堆中

关键约束：石子只能移到非空堆，一旦某堆变为 0，它就没法操作了

二、从小规模开始分析

n = 1（单堆）

无法分配（没有别的非空堆），退化为了普通取石子游戏。操作者可取走 1~全部。

SG 值就是石子数：SG(x) = x。当 x > 0 时 SG ≠ 0，先手必胜。

n = 2（两堆）

从这个分析里面我们可以推导出解题的关键：

如果两堆相等 (a, a)：后手采用对称策略——无论先手对哪堆做什么（移除 r 个、移 m 个到另一堆），后手在另一堆执行完全相同操作。只要两堆相等，后手总能维持相等，直到把先手逼入 (1,1)，最终先手必败。因此 SG(a, a) = 0，是必败态。

如果两堆不等 (a, b)，a < b：先手只需从较大堆移除 (b−a) 个，不分配，状态变为 (a, a)——把 必败态 丢给后手。因此 SG(a, b) ≠ 0，是 必胜态。

三、SG 函数表格（n = 2）

我们来手动推导小值的 SG 值，设 a ≤ b（?是懒得算了）：

示例：SG(1,2) 的可达 SG 集合 = {SG(0,2)=2, SG(1,1)=0, SG(2,0)=2, SG(1,0)=1} = {0,1,2} → mex = 3
SG(2,3) 的可达 SG 集合 = {SG(1,3)=4, SG(0,4)=4, SG(0,3)=3, SG(2,2)=0, SG(3,1)=4, SG(4,0)=4, SG(2,1)=3, SG(3,0)=3, SG(2,0)=2} = {0,2,3,4} → mex = 1

由此我们可以发现一个规律：对角线全为 0（比败态），其余非零（必胜态）。

四、推广到任意 n

定理（必败态的条件）：

先手必败 ⇔ n 为偶数，且将所有石子堆排序后，可以两两配对相等
（即 a₁ = a₂, a₃ = a₄, …, aₙ₋₁ = aₙ）

证明概要：

五、SG 值规律总结

六、算法实现思路

然后根据上面的规律我们可以得出这个正解思路：

1. 读入 n
2. 读入 n 个石子数，存入数组 a[]
3. 对 a 排序
4. 如果 n 是奇数 → 输出 1（Alice 胜）
5. 如果 n 是偶数：
     检查是否所有 a[2i-1] == a[2i]（i=1..n/2）
     若全等 → 输出 0（Bob 胜）
     否则   → 输出 1（Alice 胜）

AC代码

#include <bits/stdc++.h>
#define ll long long
#define qwq ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
using namespace std;
const int N = 20;
int n;
int a[N];
int main() {
	qwq;
	while (cin >> n && n) {
		for (int i = 1; i <= n; ++i) cin >> a[i];
		if (n % 2) cout << "1\n";
		else {
			int cnt = 0;
			for (int i = 1; i <= n; ++i) {
				if (a[i] == -114514) {
					cnt++;
					continue;
				}
				for (int j = 1; j <= n; ++j) {
					if (i == j || a[j] == -114514) continue;
					if (a[i] == a[j]) {
						cnt++;
						a[i] = a[j]= -114514;
						break;
					}
				}
			}
			if (cnt == n) cout << "0\n";
			else cout << "1\n";
		}
	}
	return 0;
}

就在今天，DeepSeek 全新一代模型 V4 系列正式开源，并迅速冲上 Hugging Face 模型榜单首位。伴随模型开放，一份详尽的技术报告也同步公开，完整披露了该系列在硬件适配、架构改造、训练策略等环节的核心要点。无论从能力指标还是工程效率上看，这都是一次相当激进的迭代。

与以往不同的是，V4 的跃升并不只是“更强了”。它首次把百万 token 上下文作为默认能力交付给社区，同时把单 token 推理的计算量降到 V3.2 版本的 27%，KV 缓存仅为原来的十分之一。这意味着，超长文本处理不再只是实验室里的演示，而是开始走向实用、低成本。

硬件层面，DeepSeek 这次做了一个“跨生态”的全面适配——从训练到推理，整套流程已完整运行在华为昇腾 NPU 之上。同时，自研的细粒度专家并行方案 MegaMoE，把通信和计算交织成一条流水线，在英伟达 GPU 和昇腾 NPU 上分别实现了 1.50 到 1.73 倍的加速，延迟敏感场景下甚至可接近翻倍。其 CUDA 实现 MegaMoE2 也已开源，成为 DeepGEMM 工具包的一部分。

为了让碎片化的计算变得紧凑，团队用 TileLang 把大量零散的小算子融合成大型内核，调用开销从百微秒级骤降到 1 微秒以内，并借助 Z3 形式化验证器确保每次计算在任意批次位置下都给出完全一致的结果。这种“比特级可复现”的设计，对大型模型调试来说几乎是一种保命机制。此外，FP4 量化被部署在 MoE 专家权重和压缩稀疏注意力的 QK 路径上，让长上下文下的注意力分数计算进一步提速。

架构改动是这次长文本效率突破的关键。V4 仍然沿用 MoE 结构和多 token 预测，但注意力部分彻底重构，将压缩稀疏注意力与另一种高压缩稠密注意力组合成“混合注意力”，在保证信息利用的同时大幅缩减计算和存储开销。同时，残差连接被替换为“流形约束超连接”，以增强表达力，训练端则引入 Muon 优化器，收敛更快且更稳定。推理时，KV 缓存可部分下沉至磁盘，使得极长上下文的部署不会直接撑爆内存。

预训练数据的总量超过 32 万亿 token，并首度引入了“样本级注意力掩码”机制。网页数据经过严格过滤，剔除批量生成和模板化的低质内容；数学、编程仍是核心，中期还加入智能体数据；多语言语料扩充了各个文化中的长尾知识，而长文档部分则优先收录论文和技术报告。在这些基础上，V4-Flash 基础模型虽参数更少，却在世界知识和长上下文等任务中超越了 V3.2 基础模型；V4-Pro 基础版则几乎在所有基准上刷新了 DeepSeek 的记录。

后训练阶段的路线也出现了重要转变。先前的混合强化学习阶段被完全移除，取而代之的是“基于策略的蒸馏”。具体做法是，先为每个目标领域分别训练一个专家模型，经过监督微调和 GRPO 强化学习后，得到一群各有所长的“专才”。接下来，统一的学生模型开始自己采样并答题，过程中十多位专家老师在完整词表维度上通过逆向 KL 损失进行 logit 级对齐，以此实现专长的融合。这种全词表蒸馏让梯度更稳定，训练曲线也更容易控制。

与蒸馏策略相配套的，还有对长窗口场景下推理记录的精细管理。当模型处于工具调用环境中时，所有思考轨迹会跨轮次完整保留，让智能体在长时间任务中能够保持连贯的推理链；而在普通对话下，则仍会清除上一轮的推理内容，维持上下文的简洁。

同时Deepseek V4模型也针对 Claude Code 、OpenClaw、OpenCode、CodeBuddy 等主流的 Agent 产品进行了适配和优化，在代码任务、文档生成任务等方面表现均有提升。

评测数据上，DeepSeek V4-Pro-Max 在知识、推理和代码能力上全线提升，综合表现已可对标 GPT-5.4、Claude Opus 4.6 等顶级闭源模型。其推理得分超过 GPT-5.2 和 Gemini 3.0 Pro，知识项略低于 Gemini 3.1 Pro。智能体能力与 Kimi K2.6、GLM-5.1 等领先开源模型持平，长上下文测试在学术基准上甚至超过了 Gemini 3.1 Pro。V4-Flash-Max 则在更低成本下提供了不俗的推理表现，展现出极高的性价比，在部分任务上接近 Pro 版本的水平。

同时值得注意的是，这次Deepseek V4更新后仍然保持与ChatGPT、Claude等模型相对比非常便宜的定价。

其快速版本输入仅每百万Tokens 1元，输出仅每百万Tokens 2元，相较于ChatGPT，Claude等顶尖版本的模型，定价便宜了几十至数百元人民币。

但是也有技术报告坦诚指出，目前的架构仍偏复杂，Anticipatory Routing 和 SwiGLU Clamping 等稳定性机制的内在机理还有待进一步厘清。后续工作方向包括简化结构、提升训练稳定性、向更多稀疏化方向探索、缩短长上下文推理延迟，以及增强多轮智能体和多模态能力等。

整体来讲，开源的DeepSeek V4 把超长上下文的效率推到新高度，其综合能力极为强大，再一次拉近开源模型与闭源模型的距离。同时这次Deepseek将V4模型分为多个版本，如flash、pro、max、base等版本，可能也是转向商业化的又一步。

公益站介绍

传送门链接

这是一个公益站点，目前里面有3个免费的SuperGrok账号，直接点击就能进入使用

因为这个站点是完全免费的公益站，只能靠广告盈利来添加SuperGrok账号，所以说如果你是很喜欢广告建议自行添加屏蔽广告插件，本文不介绍屏蔽广告的方法。

本文不会推荐使用速度较慢，安全性较弱的API，都是可以国内使用的，全是干货，作者自己也在使用的！

1. AIHubMix（推理时代）

官网链接

在推理时代点击右上角的注册账号后，使用邮箱完成注册，随后打开模型广场，标签选择 免费，可以看到有很多可以免费调用的大模型，这个列表设置还会随着时间而更新大模型。

然后进入密钥页面点击 创建Key ，点开高级设置，模型范围里面可以设置能使用哪些模型，建议设置限制只能使用免费模型，参考示例（如图）：

然后你就可以使用这个免费的API了！OpenAI格式调用地址为 https://aihubmix.com/v1

2. ModelScope（魔搭社区）

官网链接

进入后使用手机号注册账号，然后点击进入模型库，在 支持体验 -> 勾选推理 API-Inference 然后看到的这些模型才是可以通过API免费调用。

需要注意这些虽然是完全免费的，但是有如下限制

全部完成后就可以进行API调用，在模型页勾选API-Inference 后随便选择一个模型，进入看到这个，点击查看代码范例，里面会有你的API直接复制就可以使用所有免费模型了，OpenAI格式调用地址为 https://api-inference.modelscope.cn/v1

3. OpenRouter

官网链接

每天提供50次免费调用；

但你充值10 credits，也就是10刀，就有每天1000次的调用次数。充值后的credits，也可以用于其他收费模型的调用。

有需求的可以充个10credits，提升调用次数。

免费模型可以进入模型库搜索Free如 https://openrouter.ai/models?q=free 里面都是可以免费使用的模型。

进入到 https://openrouter.ai/workspaces/default/keys 里面创建一个API设置Credit limit (optional) 为 0 就可以全免费调用了，到量后也不会花钱。

OpenAI格式调用地址为 https://openrouter.ai/api/v1

4. BigModel（智谱 AI）

官网链接

手机号注册账号，实名验证后可以调用。

目前可以免费调用的模型有（覆盖视觉理解，深度思考，文本和图片生成）

还送一些3个月的资源包，可以用用

OpenAI格式调用地址为 https://open.bigmodel.cn/api/paas/v4/

5. Grok公益站

链接

最后附上一个宝藏公益站，有 SuperGrok账号 且不用等陆排队就可以使用，除了广告有点多，可以安装一些浏览器插件解决

且支持API使用，目前我体验过发现可以使用 Grok4 且还未发现有什么总量限制，还是很不错的

结尾

感谢你能读完这篇文章，大家如果有什么新的薅羊毛的方法可以分享在评论区，作者看到后也会不定期更新这篇文章，或者写一篇新的文章的！

官网链接推理时代

前言

4月8日的凌晨，Deepseek在没有任何官方公告的情况下，上新了网页版的专家模式

日常小问题使用快速模式和专家模式的区别不大，但是在写代码，数学问题，物理问题等等上面，专家模式会明显优于快速模式，同时思考时间和逻辑严谨性也要高于快速模式。

同时，灰度测试用户界面还出现了第三个选项“视觉模式”，不过这一模式并未出现在本次所有人的更新中。

这次升级来得并不突然。3月30日，DeepSeek经历了超10小时的C端服务崩溃，网页端和App无法使用，但API调用正常。过去60天内，这已是第二次大规模中断。这是因为Deepseek的算力资源远低于实际日活需求，导致资源不足而崩溃，这也是Deepseek引入模式分层的原因之一。

此次对话界面更新或许是DeepSeek V4版本发布的前奏。

也有业内分析指出认为本次模式分层正是Deepseek不堪财务重负，迟迟无法实现大规模盈利，从而转为商业化的第一步，或许以后Deepseek将不再完全免费。

实测

给 专家模式 和 快速模式 都使用同样的提示词，“编写小球真实物理模拟在复杂2D地形中下落弹跳滚动的html网页”

从专家模式生成的内容可以明显看出比快速模式优秀了不少！

快速模式

专家模式

结尾

Deepseek一直免费持续更新是愿景，但不得不迈向商业化，节省开销是现实。

或许在将来，我们会用上Deepseek V4、V5、V6，甚至更多新的模型，但到了那时也许Deepseek将逐渐融入现实的行业环境中来。

欢迎大家在评论区发表自己的看法！

本文用于长期保存各种重要公告。

导航页

这是网站一个比较重要的页面，里面有一些博主自己的搭建的工具和服务，感兴趣的小伙伴可以去看看，希望能够帮助到大家。

传送门链接

我的联系方式

邮箱： pymcn@outlook.com

在线聊天： 添加好友->pymcn

在线聊天

注册账号并同意用户协议可以使用 在线聊天 服务，请遵守协议内容，构建文明友好守法的聊天环境。

泄露过程

第一次泄露（2025 年 2 月）

Claude Code 随 Claude 3.7 一起发布，以 npm 包形式分发。在 v0.2.8 及之前版本中：

使用了开发环境配置打生产包，包含了inline-source-map所以混淆可以说是没有，被一行命令即可反解出全部源码

Anthropic发现后删除了 0.2.8 之前的包，并在 0.2.9 中修正。但 GitHub 上已经有人存档了完整代码（如 dnakov/claude-code）。

第二次泄露（2026 年 3 月）

版本从 0.2.x 到 2.1.88，代码量膨胀了近 10 倍，但是还是没涨记性：

npm 包中误留了 cli.js.map 文件（59.8 MB）

所以又被放出源码了。。。

提取方式也非常简单：

# 下载 npm 包
npm pack @anthropic-ai/claude-code@2.1.88

# 解压
tar -xzf anthropic-ai-claude-code-2.1.88.tgz

# cli.js.map 的 sourcesContent 字段中包含了所有源码
# 一行 jq 即可提取
cat package/cli.js.map | jq -r '.sources[]' 

代码统计

关键文件

源码下载

Github：https://github.com/huangserva/claude-code-cli

网盘：https://pan.pym.plus/s/owc9

前言

Openclaw确实比较火，但其复杂的配置界面，并不直观的UI设计导致其上手难度对小白不是很友好，而最近Astrbot的Agent更新，使其有了与Openclaw差不多的能力，本文就来讲讲怎么用Docker快速部署Astrbot。

部署

拉取镜像

首先你需要Docker，没有参考这篇文章部署

然后执行这条命令

sudo docker run -itd -p 6185:6185 -p 6199:6199 -v $PWD/data:/AstrBot/data -v /etc/localtime:/etc/localtime:ro -v /etc/timezone:/etc/timezone:ro --name astrbot m.daocloud.io/docker.io/soulter/astrbot:latest

然后等待拉取镜像和启动就可以了。

配置

默认安装好的Astrbot并没有直接使用电脑的能力，需要设置一下才能使用。

进入 配置文件 -> 普通配置 ->使用电脑能力 -> 运行环境 ，然后选择 local ，这代表在本地电脑运行，也可以选择 sandbox 代表在沙箱环境中运行。

需要注意的是，如果你勾选了 需要 AstrBot 管理员权限 且你更改了管理员账户的用户名时需要在当前这个页面点击左边的 平台配置 ，然后修改管理员 ID为你的管理员用户名。

这样才能正常使用Agent能力

配置模型

进入到模型提供商，然后点击新增就可以添加了，具体参考图片，如果新增里没有你的模型提供商也可以随便添加一个，然后修改 API Base URL 为你的模型提供商的适配OpenAI的请求地址，然后修改ID，可以自己随便写一个，最后点击 保存并获取模型 ，等待模型列表出现，点击对应模型旁边的+号，然后再启用就可以使用了。

完成

恭喜你到这里就大功告成了，快去试试吧，点击右上角的 Bot/Chat 选择 Chat 就可以直接在网页里聊天使用了。

今天是愚人节，转发这篇文章给你的亲朋好友，不用想太多，也不用纠结转发的意义，反正就是转发就好，没有任何目的，也没有任何回报，只是单纯地浪费一点时间，浪费你手指滑动的那几秒，浪费你打开通讯录、选择联系人的那几分钟，就像平时浪费的无数个瞬间一样，没有任何价值，也没有任何意义，就那样平平淡淡地消耗着这一天的时光，消耗着愚人节这一天独有的、本就无关紧要的几分几秒。

你不用在意转发之后亲朋好友会怎么想，不用在意他们会不会点开，会不会看完，甚至不用在意这篇文章里写的是什么内容，因为本来就没有什么有意义的东西，转发只是一个动作，一个无意义的动作，就像你平时发呆、走神、对着手机屏幕放空一样，都是在浪费时间，都是在做没有价值的事情。也许你转发的时候，只是随手一点，没有经过任何思考，也许你只是觉得，愚人节就应该做一些这样无厘头、无意义的事情，就应该浪费一点时间，不用追求任何结果，也不用在意任何回报。

转发这篇文章，不用管它能不能给你带来快乐，不用管它能不能给你的亲朋好友带来惊喜，反正都是浪费时间，反正都是没有意义的举动。你可以转发给你的父母，转发给你的兄弟姐妹，转发给你的同学朋友，转发给你认识的每一个人，不用筛选，不用犹豫，浪费一点时间在选择转发对象上，浪费一点时间在等待转发成功的瞬间，这些都是无意义的浪费，都是无关紧要的消耗，就像我们每天浪费的那些碎片化时间一样，悄无声息，没有痕迹，也没有任何价值。

也许有人会问，转发这篇文章有什么用？其实没有任何用，既不能让你暴富，也不能让你变得更好，更不能改变什么，只是单纯地浪费时间，只是在愚人节这一天，做一件和愚人节一样，看似有趣、实则无意义的事情。我们每天都在浪费时间，吃饭的时候浪费时间，睡觉的时候浪费时间，刷手机的时候浪费时间，发呆的时候浪费时间，而转发这篇文章，只是无数浪费时间的举动中的一个，没有什么特别，也没有什么不同，只是刚好赶上了愚人节，刚好有这样一篇无意义的文章，供我们浪费时间，供我们随手转发。

今天是愚人节，转发这篇文章给你的亲朋好友，不用想转发的意义，不用想浪费时间的可惜，反正时间本来就是用来浪费的，反正我们每天都在无意义地消耗着时光。转发之后，你可以继续刷手机，继续发呆，继续做那些没有意义的事情，继续浪费剩下的时间，没有任何负担，也没有任何顾虑。这篇文章没有任何营养，没有任何干货，没有任何值得你记住的内容，就像我们浪费的那些时间一样，过后就忘，没有留下一点痕迹，也没有给我们带来任何收获。

转发吧，不用犹豫，不用纠结，浪费一点时间又怎么样，反正我们有很多时间可以浪费，反正这些浪费的时间，也不会对我们的生活造成任何影响。今天是愚人节，就让我们一起，无意义地浪费一次时间，转发这篇文章，给你的亲朋好友，一起浪费时间，一起做没有意义的事情，不用追求任何结果，不用在意任何回报，只是单纯地享受这份无意义的浪费，享受这份不用思考、不用努力的轻松，就像平时无数个浪费时间的瞬间一样，平平淡淡，无滋无味，却又真实地消耗着我们的时光，直到这一天结束，直到我们又浪费了一天的时间，没有任何意义，也没有任何遗憾。

最后，愚人节快乐~~~

题目传送门

前置知识：2-SAT

题目大意

有 n 种材料，每种可做满式（m）或汉式（h）。m 位评审各有两个喜好（如 m1、h2），只要选手做出其中一个喜好的菜，该评审就通过。

问：是否存在一种做菜方案，能让所有评审都通过？

• 存在输出 GOOD，否则输出 BAD。

解题思路

显然这是一道2-SAT裸题。

分析题目

把每样材料拆成 $i$ 拆开，用 $i$ 表示满式做法，用 $i +n$ 表示汉式做法。

因为每个评委的要求只要满足一样的即可，所以可以看作是或

点 $u$ 可以是满/汉式，点 $v$ 也可以是满/汉式，所以有4种情况：

1. 要求点 $u$ 是满式 或 点 $v$ 是满式，那么若 $u$ 为汉式，则 $v$ 必为满式；若 $v$ 为汉式，则 $u$ 必为满式。

2. 要求点 $u$ 是满式 或 点 $v$ 是汉式，那么若 $u$ 为汉式，则 $v$ 必为汉式；若 $v$ 为汉式，则 $u$ 必为满式。

3. 要求点 $u$ 是汉式 或 点 $v$ 是汉式，那么若 $u$ 为满式，则 $v$ 必为汉式；若 $v$ 为满式，则 $u$ 必为汉式。

4. 要求点 $u$ 是汉式 或 点 $v$ 是满式，那么若 $u$ 为满式，则 $v$ 必为满式；若 $v$ 为汉式，则 $u$ 必为汉式。

建图

从上面的分析，我们可以得出通过特殊建图再跑一边板子2-SAT可以完成这道题。

for (int i = 1; i <= m; ++i) {
	string Su, Sv;
	cin >> Su >> Sv;
	char op1 = Su[0], op2 = Sv[0];
	int u = 0, v = 0;
	for (int j = 1; j < Su.size(); ++j) u = u * 10 + (Su[j] - '0' + 0);
	for (int j = 1; j < Sv.size(); ++j) v = v * 10 + (Sv[j] - '0' + 0);
	if (op1 == 'm') {
		if (op2 == 'h') add(v, u), add(u + n, v + n); // 第二种情况
		else add(u + n, v), add(v + n, u); // 第一种情况
	} else {
		if (op2 == 'h') add(u, v + n), add(v, u + n); // 第三种情况
		else add(u, v), add(v + n, u + n); // 第四种情况
	}
}

恭喜你这道题做完了。

判断GOOD还是BAD

因为 $i$ 为满式， $i + n$ 为汉式，所有只要判断 $scc[i] == scc[i+n]$ 就可以了，如果相等就不成立，输出 BAD ，反之输出 GOOD

bool flag = true;
for (int i = 1; i <= n; ++i) {
	if (scc[i] == scc[i + n]) {
		flag = false;
		break;
	}
}
cout << (flag ? "GOOD" :  "BAD") << "\n";

AC代码

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 1000 + 5;
int T;
int n, m;
vector<vector<int>> e;
void add(int u, int v) {
	e[u].emplace_back(v);
}
int tot, cnt;
int dfn[2 * N], low[2 * N], scc[2 * N];
stack<int> q;
bitset<2 * N> vis;
void tarjan(int u) {
	dfn[u] = low[u] = ++tot;
	q.emplace(u);
	vis[u] = true;
	for (auto v : e[u]) {
		if (!dfn[v]) {
			tarjan(v);
			low[u] = min(low[u], low[v]);
		} else if (vis[v]) {
			low[u] = min(low[u], dfn[v]);
		}
	}
	if (low[u] == dfn[u]) {
		++cnt;
		int v;
		do {
			v = q.top(); q.pop();
			vis[v] = false;
			scc[v] = cnt;
		} while(v != u);
	}
}
void init() {
	cnt = tot = 0;
	e.clear();
	e.resize(2 * N);
	stack<int>().swap(q);
	vis.reset();
	for (int i = 1; i <= 2 * n; ++i) {
		dfn[i] = low[i] = scc[i] = 0;
	}
}
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	cin >> T;
	while (T--) {
		init();
		cin >> n >> m;
		for (int i = 1; i <= m; ++i) {
			string Su, Sv;
			cin >> Su >> Sv;
			char op1 = Su[0], op2 = Sv[0];
			int u = 0, v = 0;
			for (int j = 1; j < Su.size(); ++j) u = u * 10 + (Su[j] - '0' + 0);
			for (int j = 1; j < Sv.size(); ++j) v = v * 10 + (Sv[j] - '0' + 0);
			if (op1 == 'm') {
				if (op2 == 'h') add(v, u), add(u + n, v + n);
				else add(u + n, v), add(v + n, u);
			} else {
				if (op2 == 'h') add(u, v + n), add(v, u + n);
				else add(u, v), add(v + n, u + n);
			}
		}
		for (int i = 1; i <= 2 * n; ++i) if (!dfn[i]) tarjan(i);
		bool flag = true;
		for (int i = 1; i <= n; ++i) {
			if (scc[i] == scc[i + n]) {
				flag = false;
				break;
			}
		}
		cout << (flag ? "GOOD" :  "BAD") << "\n";
	}
	return 0;
}

题目传送门

题目大意

一共 $N$ 个点， $M$ 条边。

有 $3$ 种类型的边：

1. 单向边：从点 $i$ 到点 $j$ 至少有 $c$ ，也就是 ai​−aj​≥c

2. 单向边：从点 $i$ 到点 $j$ 至多有 $c$ ，ai​−aj​≤c

3. 双向边：从点 $i$ 到点 $j$ 一样多，ai​=aj​

将这 $3$ 种边转换一下可以得到：

1. aj​≤ai​−c

2. ai​≤aj​+c

3. ai​=aj​+0 与 aj​=ai​+0

解题思路

判断负环

如果K的记忆冲突了，那么就说明有负环（小K绕晕了😵），输出 NO

如果K的记忆有至少1种情况没有冲突， 那么就说明图中不存在负环，则输出 YES

// 判断负环
cnt[v] = cnt[u] + 1;
if (cnt[v] > n) {
	cout << "No\n"; // 有，就输出NO
	exit(0);
}


// 没有负环，在函数外输出YES
spfa(0);
cout << "Yes\n";
return 0;

处理 3 种边

$c$ 代表从某一点至某一点的边所需的花费。

对于第一种，从点 $i$ 到点 $j$ 至少有 $c$ ：

观察式子 aj​≤ai​−c 可得出 从点 $i$ 到点 $j$ 花费为 $-c$

对于第二种，从点 $i$ 到点 $j$ 至多有 $c$ ：

观察式子 ai​≤aj​+c 可得出 从点 $j$ 到点 $i$ 花费为 $c$

对于第三种，从点 $i$ 到 $j$ 数量一样，即 $c$ 为 $0$ ：

观察式子 ai​=aj​+0 与 aj​=ai​+0 可得出 从点 $i/j$ 到点 $i/j$ 花费为 $0$ ，是一条双向边

for (int i = 1; i <= m; ++i) {
	int op; cin >> op;
	int u, v, w = 0;
	if (op == 1) {
		cin >> u >> v >> w;
		e[u].emplace_back(v, -w);
	} else if (op == 2) {
		cin >> u >> v >> w;
		e[v].emplace_back(u, w);
	} else {
		cin >> u >> v;
		e[u].emplace_back(v, 0);
		e[v].emplace_back(u, 0);
	}
}

超级源点

因为题目并没有规定从哪一点出发，且题目需要求解出所有情况来判断

因此我们需要一个超级源点来连接所有点，方便求出所有情况

for (int i = 1; i <= n; ++i) e[0].emplace_back(i, 0);

AC代码

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 1e4 + 5;
int n, m;
vector<vector<pair<int, int>>> e(N);
ll dis[N]; // 记录距离
int cnt[N]; // 记录任意点在队列的次数，以便判断负环
bool vis[N]; // 记录任意点是否在队列中
void spfa(int s) { // SPFA板子
	queue<int> q;
	q.emplace(s);
	fill(dis + 1, dis + n + 1, INT_MAX); //SPFA必要的初始化
	vis[s] = true;
	dis[s] = 0; // 从超级源点0出发
	while (!q.empty()) {
		int u = q.front(); q.pop();
		vis[u] = false;
		for (auto tmp : e[u]) { // 适配C++14的写法
			int v, w;
			tie(v, w) = tmp;
			if (dis[v] > dis[u] + w) {
				dis[v] = dis[u] + w;
				cnt[v] = cnt[u] + 1; // 累计点v在队列的次数，因为每个点至多n次，所有如果>n就是有负环
				if (cnt[v] > n) {
					cout << "No\n"; // 有负环，输出NO
					exit(0); // exit(0)是退出整个程序
				}
				if (!vis[v]) {
					vis[v] = true;
					q.emplace(v);
				}
			}
		}
	}
}
int main() {
	// 输入输出加速
	ios::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	cin >> n >> m;
	for (int i = 1; i <= m; ++i) {
		int op; cin >> op;
		int u, v, w = 0;
		if (op == 1) { // 第一种边：农场a比农场b至少多种植了c个单位的作物
			cin >> u >> v >> w;
			e[u].emplace_back(v, -w);
		} else if (op == 2) { // 第二种边：农场a比农场b至多多种植了c个单位的作物
			cin >> u >> v >> w;
			e[v].emplace_back(u, w);
		} else { // 第三种边：农场a终止的数量和b一样多
			cin >> u >> v;
			e[u].emplace_back(v, 0);
			e[v].emplace_back(u, 0);
		}
	}
	for (int i = 1; i <= n; ++i) e[0].emplace_back(i, 0); // 建立超级源点
	spfa(0);
	cout << "Yes\n"; // 没有负环输出YES
	return 0;
}

题目传送门

题意简述

有 N 次挤奶，在 M 天 内完成，需要求出每次挤奶的最早可行日期，同时满足两个硬性约束：

1. 基础约束：第 i 次挤奶的日期 不能早于第 Sᵢ 天；

2. 时序约束：给定 C 条规则 (a, b, x)，要求第 b 次挤奶的日期 ≥ 第 a 次挤奶的日期 + x（b 比 a 至少晚 x 天）；

3. 题目保证所有约束无矛盾，一定存在合法方案。

题目思路

步骤 1：建图

我们引入超级源点 0，这样可以让 SPFA 能一次性处理所有规则，不用额外写代码特殊处理。

值得注意的是，超级源点 0 到其他点的单向边代价应该是 这个点不早于第 Sᵢ 天挤奶的时间，也就是 Sᵢ ，不然的话SPFA不会按照限定的时间，可能会提前。

步骤 2：SPFA 初始化

1. 距离数组 dis[]：全部初始化为负无穷（因为我们要求的是最长路）

2. 超级源点 dis[0] = 0

3. 用队列存储待松弛的节点，初始把节点 0 入队

4. 标记数组 vis[]：标记节点是否在队列中，避免重复入队

步骤 3：SPFA 最长路松弛

标准 SPFA 流程，但是判断 dis[v] > dis[u] + w 改成 dis[v] < dis[u] + w

步骤 4：得到答案

队列空时，dis[i] 就是第 i 个变量的最小合法值（满足所有约束）。

然后直接输出就可以了，恭喜你做完了这道题！

AC代码

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 1e5 + 5, INF = 1e9 + 7;
int n, m, kk;        // n:挤奶次数 m:总天数 kk:约束条数
int lim[N];          // 存储每次挤奶的最早天数下限
vector<vector<pair<int, int>>> e(N); // 邻接表存图
bool vis[N];         // SPFA标记数组
ll dis[N];           // 存储答案（最长路结果）

int main() {
	ios::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	cin >> n >> m >> kk;
	for (int i = 1; i <= n; ++i) cin >> lim[i]; // 读取下限约束
	for (int i = 1; i <= kk; ++i) {
		int u, v, w;
		cin >> u >> v >> w;
		e[u].emplace_back(v, w); // 建约束边：v >= u + w
	}
	for (int i = 1; i <= n; ++i) {
		e[0].emplace_back(i, lim[i]); // 超级源点：满足i >= lim[i]
	}
	fill(dis + 1, dis + n + 1, -INF); // 最长路初始化：负无穷
	vis[0] = true;
	dis[0] = 0;
	queue<int> q;
	q.emplace(0);
	while (!q.empty()) {
		int u = q.front();
		q.pop();
		vis[u] = false;
		for (auto tmp : e[u]) {
			int v, w;
			tie(v, w) = tmp;
			if (dis[v] < dis[u] + w) { // 最长路松弛操作
				dis[v] = dis[u] + w;
				if (!vis[v]) {
					vis[v] = true;
					q.emplace(v);
				}
			}
		}
	}
	for (int i = 1; i <= n; ++i) {
		cout << dis[i] << "\n"; // 输出每次挤奶的最早日期
	}
	return 0;
}

先放图

题目

洛谷传送门

题目背景

英文题面见此链接

题目描述

Farmer John 在探索他的农场时发现了许多神奇的虫洞。虫洞的特性非常特殊——它是一个单向通道，能将你传送到它的目的地，而且时间还会回溯到过去！FJ 的每个农场包含 N(1≤N≤500) 块编号为 1∼N 的田地、M(1≤M≤2500) 条双向路径和 W(1≤W≤200) 个虫洞。

作为狂热的时间旅行爱好者，FJ 希望实现：从某块田地出发，经过若干路径和虫洞后，在初始离开时间之前回到起点。这样或许他能遇见自己 :)

为了判断可行性，FJ 将提供 F(1≤F≤5) 个农场的完整地图。所有路径通行耗时不超过 10,000 秒，虫洞最多能将 FJ 带回 10,000 秒前。

输入格式

第 1 行：一个整数 F，表示农场数。后续为 F 个农场的数据。

每个农场：

• 第 1 行：三个空格分隔的整数 N（田地数）, M（双向路径数）, W（虫洞数）。

• 第 2∼M+1 行：每行三个空格分隔的整数 (S,E,T)，表示 S 和 E 间有一条耗时 T 秒的双向路径。两块田地间可能存在多条路径。

• 第 M+2∼M+W+1 行：每行三个空格分隔的整数 (S,E,T)，表示一条从 S 到 E 的单向虫洞，可将 FJ 带回 T 秒前。

输出格式

输出 F 行：对每个农场，若 FJ 能达成目标输出YES，否则输出NO。

输入输出样例

输入 #1

2
3 3 1
1 2 2
1 3 4
2 3 1
3 1 3
3 2 1
1 2 3
2 3 4
3 1 8

输出 #1

NO
YES

说明/提示

• 农场 1：FJ 无法实现时间回溯。

• 农场 2：FJ 可通过环 1→2→3→1 回到起点 1 秒前（可从环上任意点出发实现）。

翻译：DeepSeek-R1

思路

题目解析

这是一道SPFA板子题，题目大意可以理解为：

• 有 $N$ 个点

• 有 $M$ 条双向边，经过会增加时间

• 有 $W$ 条单向边，经过可以减少时间（穿越了）

然后这是一道多组测试数据的题，有 $F$ 组数据

题目需要你求出，从任意一点出发，会不会遇到负环（因为有负环，所以FJ可以回到起点），有就输出 YES ，没有也就是FJ没法回到起点，输出 NO

代码构思

首先注意到我们可以从任意点出发，所以我们需要建一个 超级源点， 有了超级源点后，我们跑SPFA从超级源点出发，这样就可以到达所有点，避免了跑很多遍SPFA来求最优解。那么超级源点是什么呢？就是一个点，比如点0，连接了其他所有点，然后每条连接的边都是单向边，且花费为0，这里我们搭配图片理解：

然后就是SPFA求负环的板子了，不知道SPFA怎么求负环的可以看看这篇文章，里面有讲SPFA如何求负环，那么最终代码如下：

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 500 + 5;
int T;
int n, m, mm;
vector<vector<pair<int, int>>> e; // 奇葩STL，不喜欢可以写结构体，会麻烦点
ll dis[N]; // 没啥用的距离数组，辅助求负环
bool vis[N]; // 标记任意点是否在队列中
int cnt[N]; // 标记任意点的使用次数，用来求负环
bool spfa() {
	// 初始化
	fill(dis + 1, dis + n + 1, INT_MAX);
	fill(cnt + 1, cnt + n + 1, 0);
	fill(vis + 1, vis + n + 1, false);
	queue<int> q;
	q.emplace(0);
	dis[0] = 0;
	vis[0] = true;

	// SPFA板子
	while (!q.empty()) {
		int u = q.front(); q.pop();
		vis[u] = false;
		for (auto tmp : e[u]) { // 适配C++14的写法
			int v, w;
			tie(v, w) = tmp;
			if (dis[v] > dis[u] + w) {
				dis[v] = dis[u] + w;
				cnt[v] = cnt[u] + 1; // 求负环
				if (cnt[v] > n) return false; // 多了一个超级源点，所以是大于n，有负环
				if (!vis[v]) {
					vis[v] = true;
					q.emplace(v);
				}
			}
		}
	}
	return true; //没有负环
}
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	cin >> T;
	while (T--) {
		// 因为有多组数据，每次e数组清空，然后重设大小
		e.clear();
		e.resize(N);
		cin >> n >> m >> mm;
		for (int i = 1; i <= m; ++i) {
			int u, v, w;
			cin >> u >> v >> w; // 输入普通的双向边
			e[u].emplace_back(v, w);
			e[v].emplace_back(u, w);
		}
		for (int i = 1; i <= mm; ++i) {
			int u, v, w;
			cin >> u >> v >> w; // 输入虫洞
			e[u].emplace_back(v, -w);
		}
		
		// 超级源点
		for (int i = 1; i <= n; ++i) {
			e[0].emplace_back(i, 0); // 建立单向边，将0指向其他所有点，且花费为0
		}
		cout << (spfa() ? "NO" : "YES") << "\n"; // 有负环就是可以回到起点，输出YES，否则是NO
	}
	return 0;
}

题目

Luogu P2136

题目背景

我是源点，你是终点。我们之间有负权环。 ——小明

题目描述

在小明和小红的生活中，有 N 个关键的节点。有 M 个事件，记为一个三元组 (Si​,Ti​,Wi​)，表示从节点 Si​ 有一个事件可以转移到 Ti​，事件的效果就是使他们之间的距离减少 Wi​。

这些节点构成了一个网络，其中节点 1 和 N 是特殊的，节点 1 代表小明，节点 N 代表小红，其他代表进展的阶段。所有事件可以自由选择是否进行，但每次只能进行当前节点邻接的。请你帮他们写一个程序，计算出他们之间可能的最短距离。

输入格式

第一行，两个正整数 N,M。

之后 M 行，每行 3 个空格隔开的整数 Si​,Ti​,Wi​。

输出格式

一行，一个整数表示他们之间可能的最短距离。如果这个距离可以无限缩小，输出Forever love。

输入输出样例

输入 #1

3 3
1 2 3
2 3 -1
3 1 -10

输出 #1

-2

说明/提示

对于 20% 数据，N≤10，M≤50。

对于 50% 数据，N≤300，M≤5000。

对于 100% 数据，1≤N≤103，1≤M≤104，∣Wi​∣≤100，保证从节点 1 到 2…N 有路径，从节点 N 到 1…N−1 有路径。

思路

这道题很显然是一道单源最短路的题目，通过观察题目，我们可以得出以下信息：

• 是单向图

• 计算的是小红与小明之间的最短距离，这意味着可以是小红到小明，也可以是小明到小红

• 题目有明显的负环，需要输出 Forever love

• 题目中的边权不是相加是相减，为了避免麻烦改代码，可以对边权取反来建图。

那么这道题是非常良心的👍，出题人没有卡SPFA，所以我们使用SPFA来求解。

对于SPFA来找负环，可以建立一个 $cnt$ 数组，我们定义 𝑐𝑛𝑡[𝑖] 表示点 𝑖 距离源点经过的边数 每次 𝑖 → 𝑗 转移的时候 𝑐𝑛𝑡[𝑗] = 𝑐𝑛𝑡[𝑖] + 1 如果有点的 𝑐𝑛𝑡 大于等于 𝑛 时说明有负环，就直接输出 Forever love

多说无益，我们看代码：

#include <bits/stdc++.h>
#define ll long long
using namespace std;
// N是数组大小，INF用来给dis赋初始值，即极大值
const int N = 1000 + 5, INF = 100000000;
int n, m;
vector<vector<pair<int, int>>> e(N); // 比较奇葩的STL写法，不喜欢的可以写结构体
ll dis[N]; // 记录从起点到任意点的最短距离的数组
bool vis[N]; // 判断任意点是否在队列中
int cnt[N]; // 记录任意点的出队次数，用来判断负环
void spfa(int s) {
	// SPFA的初始化
	fill(dis + 1, dis + n + 1, INF); 
	fill(vis + 1, vis + n + 1, false);
	fill(cnt + 1, cnt + n + 1, 0);
	dis[s] = 0, vis[s] = true;
	queue<int> q;
	q.emplace(s);
	
	// SPFA
	while (!q.empty()) {
		int u = q.front();
		q.pop();
		vis[u] = false; // 标记点u不在队列中了
		for (pair<int, int> tmp : e[u]) { //适配C++14的写法
			int v, w;
			tie(v, w) = tmp;
			if (dis[v] > dis[u] + w) {
				dis[v] = dis[u] + w;
				cnt[v] = cnt[u] + 1; // 找负环
				if (cnt[v] >= n) {
					cout << "Forever love\n"; // 有负环
					exit(0);
				}
				if (!vis[v]) {
					vis[v] = true; // 点v在队列中了
					q.emplace(v); // 把点v加入队列
				}
			}
		}
	}
}
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	cin >> n >> m;
	for (int i = 1; i <= m; ++i) {
		int u, v, w;
		cin >> u >> v >> w;
		e[u].emplace_back(v, -w); // 对边权取反，方便处理
	}
	spfa(1); // 从小明到小红
	ll ans1 = dis[n];
	spfa(n); // 从小红到小明
	ll ans2 = dis[1];
	cout << min(ans1, ans2) << "\n"; // 对两个答案取较小值
	return 0;
}

代码提交结果如下：