一、工具介绍

博主这里已经把这个做成了一个在线工具，进入输入你的配置就可以直接简单界面化的配置给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将逐渐融入现实的行业环境中来。

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

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

导航页

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

传送门链接

我的联系方式

邮箱： me@pym.plus

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

在线聊天

注册账号并同意协议可以使用 在线聊天 服务，可以使用 添加群聊 搜索 所有人 加入所有人都可以加入的公共群聊。

一直掉线无法连接，请尝试清空聊天消息，可能是消息太多导致连接掉线。N

泄露过程

第一次泄露（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;
}

代码提交结果如下：

uiverse.io：网站链接

uiverse.io 是全球规模较大的开源 UI 元素社区库，由全球开发者与设计师共建，全部基于纯 CSS 或 Tailwind CSS 实现，免费可商用（MIT 协议）

有需求的小伙伴可以看看，里面的东西还是很高质量的！

叠甲

本文并不针对任何一个AI，文中的免费AI，付费AI也不代指或暗指任何一个AI。

本文属于个人观点。

前言

不知道大家有没有感觉，在使用一个免费AI回答某个问题时，如果对话的篇幅很长，你会感觉这个AI越来越笨笨的了。或者，你问免费的AI它是什么模型，它通常不会告诉你它是什么模型，只会说是XXX公司的XX AI。而付费的AI（以付费API为例）的，你问它是什么模型，它是会告诉你的，且对话篇幅很长不会出现变笨了的感觉，只是感觉钱包空空了

区别

免费的AI

免费的AI通常有3大限制：

1. 限流，限定时间内提问过快过多，AI可能就不会理你了

2. 自己会切模型，问多了，因为考虑到成本，你用的ProAI可能就变成了LiteAI或者MiniAI，能力瞬间下降，这也是为什么用免费AI解决不了某个问题时，开个新对话，或者等会再问，AI可能就变聪明了

3. 提问内容的限制，官网的一些免费AI远比它的付费版本，内容限制多得多

付费的AI

提到付费的AI，大家可能首先想到的就是XXX套餐或者XXX会员，但是我这里想讲的是AI的付费API

这种给AI掏钱买API用的方式与免费的通常有2个区别：

1. 不限流，你余额还有钱就可以稳定输出

2. 可以指定使用什么模型，不会遇到变笨的情况

总结

总结一下，付费的AI，无论是XX套餐或者会员，还是它的付费API的形式，并不是比免费的AI多聪明多少，而是能一直稳定，按照你需求的质量输出。

至于大家是需要付费的AI，还是免费的AI，就看个人需求了。

前言

前些天在网上找免费API的AI，找到了https://chat.intern-ai.org.cn/models，据说这个AI的Intern-S1-Pro模型参数高达968B，最最最关键的是：
普通用户注册后有免费的额度，每个月都有

9,000,000input tokens/月

3,000,000output tokens/月

获取API Key

在https://internlm.intern-ai.org.cn/api/tokens获取，需要手机号注册，注册后可以直接创建API Key，但是每6个月需要更换，否则会失效。

申请更高限流

默认是限制每分钟只能调用30次，每分钟最大50000Tokens，但是可以在https://internlm.intern-ai.org.cn/api/strategy申请更高限流
我目前申请到了每分钟60次，最大300000Tokens。

模型列表

调用模型

BaseUrl： https://chat.intern-ai.org.cn/api/v1/

from openai import OpenAI

client = OpenAI(
    api_key="eyJ0eXBlIjoiSl...请填写准确的 token！",  # 此处传token，不带Bearer
    base_url="https://chat.intern-ai.org.cn/api/v1/",
)

chat_rsp = client.chat.completions.create(
    model="intern-latest",
    messages=[{"role": "user", "content": "hello"}],
)

for choice in chat_rsp.choices:
    print(choice.message.content)

今天闲得无聊，随便问了几个问题（可能20个的样子），然后花出去13.67元，那太贵了，有没有方法省点钱呢？

还真有，每家大厂都有自己的CodingPlan，如果你Token用的多的话相当于是打了1折，CodingPlan是什么呢？

请看下图（示例对象为豆包模型的火山方舟）：

由此我们可以知道，如果自己请求很多的话用CodingPlan无非是等等，价格却是相当于打了1折，非常便宜，基本可以说是个人使用随便问了。

下面给出3家大厂的链接（基本都集成了很多模型）：

阿里云（主要是Qwen模型）：阿里云百炼 Coding Plan - AI 编码订阅计划 - 阿里云

腾讯云（主要是HY模型）：腾讯云 Coding Plan 智能 AI 编程订阅服务

火山引擎（主要是Doubao模型）：方舟Coding-Plan

前言

最近OpenClaw老火了，号称啥事都能帮你干的AI，任务丢过去就会自己完成，完美解决了Token滞销的问题，那么今天就用Docker Compose来搞一个玩玩！

注意：不要随便给别人用！！！否则AI可能把你的API和个人信息之类的打包发给别人！！！也不要在自己的主力电脑上部署，小心AI直接给你文件删完了！！！附带一句请随时注意你的Token账单和你的钱包！

安装

步骤 1：创建工作目录

mkdir -p ~/openclaw-docker
cd ~/openclaw-docker

步骤 2：创建 .env 环境文件

nano .env # 创建.env文件 

将以下内容复制到 .env 文件：

# 镜像配置
OPENCLAW_IMAGE=jiulingyun803/openclaw-cn:latest

# 数据目录（相对于 docker-compose.yml 所在目录）
OPENCLAW_CONFIG_DIR=./data/.openclaw
OPENCLAW_WORKSPACE_DIR=./data/clawd

# 网关配置
OPENCLAW_GATEWAY_PORT=18789
OPENCLAW_BRIDGE_PORT=18790
OPENCLAW_GATEWAY_BIND=lan
OPENCLAW_GATEWAY_TOKEN=your-secure-token-here

# Claude 集成（可选，仅使用 Claude 作为后端时填写）
CLAUDE_AI_SESSION_KEY=
CLAUDE_WEB_SESSION_KEY=
CLAUDE_WEB_COOKIE=

这里附一份表格，关于.env的配置解释：

步骤 3：创建 docker-compose.yml 文件

nano docker-compose.yml # 创建docker-compose.yml文件

将以下内容复制到 docker-compose.yml：

services:
  openclaw-cn-gateway:
    image: ${OPENCLAW_IMAGE:-openclaw-cn:local}
    user: node:node
    environment:
      HOME: /home/node
      TERM: xterm-256color
      OPENCLAW_GATEWAY_TOKEN: ${OPENCLAW_GATEWAY_TOKEN}
      CLAUDE_AI_SESSION_KEY: ${CLAUDE_AI_SESSION_KEY}
      CLAUDE_WEB_SESSION_KEY: ${CLAUDE_WEB_SESSION_KEY}
      CLAUDE_WEB_COOKIE: ${CLAUDE_WEB_COOKIE}
    volumes:
      - ${OPENCLAW_CONFIG_DIR:-./data/.openclaw}:/home/node/.openclaw
      - ${OPENCLAW_WORKSPACE_DIR:-./data/clawd}:/home/node/clawd
    ports:
      - "${OPENCLAW_GATEWAY_PORT:-18789}:18789"
      - "${OPENCLAW_BRIDGE_PORT:-18790}:18790"
    init: true
    restart: unless-stopped
    command:
      [
        "node",
        "dist/index.js",
        "gateway",
        "--bind",
        "${OPENCLAW_GATEWAY_BIND:-lan}",
        "--port",
        "${OPENCLAW_GATEWAY_PORT:-18789}"
      ]

  openclaw-cn-cli:
    image: ${OPENCLAW_IMAGE:-openclaw-cn:local}
    user: node:node
    environment:
      HOME: /home/node
      TERM: xterm-256color
      BROWSER: echo
      CLAUDE_AI_SESSION_KEY: ${CLAUDE_AI_SESSION_KEY}
      CLAUDE_WEB_SESSION_KEY: ${CLAUDE_WEB_SESSION_KEY}
      CLAUDE_WEB_COOKIE: ${CLAUDE_WEB_COOKIE}
    volumes:
      - ${OPENCLAW_CONFIG_DIR:-./data/.openclaw}:/home/node/.openclaw
      - ${OPENCLAW_WORKSPACE_DIR:-./data/clawd}:/home/node/clawd
    stdin_open: true
    tty: true
    init: true
    entrypoint: ["node", "dist/index.js"]

步骤 4：启动容器

docker compose up -d

步骤 5：运行配置向导

docker compose run --rm openclaw-cn-cli onboard

配置向导可以帮助你完成以下基础设置：

• 选择网关后端（Claude、Gemini 等）

• 配置 Feishu、Telegram 等渠道

• 生成和保存配置

步骤 6：访问 Web UI

打开浏览器访问：

http://127.0.0.1:18789/

将配置向导生成的令牌复制到登录页面即可。

如果你有公网IP的话，就用 http://你的公网IP:端口/ 访问。

个人观点

最后文章的结尾，我附带一些个人的观点，欢迎大家在评论区参与讨论！

OpenClaw的出现，无疑是智能体AI的又一大进步。

对于一些真正有需求的企业，肯定不敢大规模使用，就算是大规模使用了，也不会没有审核之类的一道防线，只能说继续期待AI发展。

对于普通个人而言，我建议玩玩就可以了，不要想着这个东西能挣钱，要知道使用AI的成本就是非常高的，我自己也试了试的，基本上一个很简单的问题，比如问问今天的天气，就能干到10万Tokens左右，这还是正常的，以 Doubao-Seed-2.0-pro 的价格来算，就约为1.6元，实际情况更多，编程一类的，账单更是飞上天了（我试了试开发一个Windows下能用的计算器，AI完成后花费了我23.6元），当你玩久后发现，能干的事多，但真正的能干的事情少，真的太少了，在OpenClaw AI能干的事情，你基本上也能完成，还能省少说10元钱，因为现在的AI不成熟，你永远无法知道AI会给你来上波什么操作。

对于有钱，且真的需求效率的，我推荐试一试，真的能快太多。

最后的最后，如果你真的决定用了，请随时注意有关OpenClaw的安全升级和漏洞消息，谨防信息泄露等等问题！