无穷大？

Chrome 将我的后台登录页标记为危险：一次 Safe Browsing 误判排查记录

Fri, 27 Feb 2026 00:00:00 GMT

Chrome 将我的后台登录页标记为危险：一次误判排查记录#

最近，我的一个后台管理页面突然被 Chrome 标记为“危险网站”。

浏览器提示：

这些网页试图诱使用户做出一些危险的事情，例如安装垃圾软件或透露个人信息。

被判定类型是 Social Engineering（欺骗性网站），来源于 Google Safe Browsing。

但问题是：

网站是纯前端
没有恶意代码
没有仿冒第三方服务
没有传播软件

这是一场典型的误判（False Positive）。

本文记录完整排查与修复过程。

一、问题页面结构#

页面结构非常简单：

子域名：adminxxx.mydomain.zone
路径：/login
用户名 + 密码输入框
Cloudflare 人机验证
无额外介绍内容

典型后台登录页结构。

但在风控系统看来，它具备以下高风险特征：

admin 子域名
/login 路径
冷门 TLD
账号密码表单
Cloudflare challenge
页面无品牌说明

这些特征组合起来，非常像钓鱼站模板。

二、为什么会被误判？#

Google Safe Browsing 的检测基于模式识别。

在算法层面，以下结构风险较高：

随机子域名
login 路径
账号密码表单
无品牌归属说明
Cloudflare 验证

我的后台刚好命中这些规则。

这并不是被黑，而是结构与钓鱼页面高度相似。

三、排查过程#

1. 检查是否存在恶意代码#

确认：

无 iframe 注入
无异常跳转
无可疑外部脚本
无混淆 JavaScript

页面源码是干净的。

2. 检查服务器与容器#

Docker 容器内文件正常。

未发现异常进程或未知文件。

3. 确认问题本质#

真正的问题在于：

后台页面公开可访问
页面没有品牌说明
默认用户名为 admin
URL 过于“标准登录模板”

四、修复措施#

我采取了以下措施：

1. 去掉默认用户名#

删除 admin 默认值，避免“示例凭据”模式。

2. 增加品牌与归属说明#

在登录框上方增加：

系统名称
“Internal Administrative Dashboard”
“For authorized administrators only”

明确用途。

3. 更新页面 metadata#

修改：

title 为 “Internal Admin Panel”
添加 meta description
避免使用泛化标题如 “Login”

4. 改善页面语义结构#

使用 main 标签
添加 h1 层级
增加 footer
添加项目说明与链接

让页面更像正式系统，而非孤立登录页。

5. 限制后台访问#

使用访问控制功能限制后台访问。

避免长期公开暴露。

五、提交复审#

在 Safe Browsing 页面提交审核说明：

页面为内部管理界面
不对公众开放
不仿冒第三方服务
已优化结构与访问控制

通常 24–72 小时会得到结果。

六、经验总结#

不要公开暴露后台登录页#

尤其避免：

admin 子域名
login 公开路径
默认用户名
无品牌说明

安全系统判断的是“像不像”#

现代浏览器安全系统越来越激进。

它不判断你是否恶意，而是判断你是否“像恶意”。

结构与钓鱼页面相似，就可能被标记。

七、最终建议#

如果你有后台系统：

使用访问控制（Zero Trust 或 IP 白名单）
不使用明显的 admin 子域名
增加品牌识别信息
保持清晰 metadata
避免孤立登录页结构

结语#

这次问题不是安全漏洞，而是结构误伤。

理解浏览器风控模型的逻辑，
才能避免再次踩坑。

如果你也遇到类似问题，希望这篇记录能帮到你。

使用AI开发纯血鸿蒙arkTS应用的进阶指南（VSCode+Copilot）

Mon, 16 Feb 2026 00:00:00 GMT

GitHub仓库：https://github.com/open-deveco/deveco-toolbox

在此感谢原作者！

创建 .vscode/mcp.json，内容如下：

1
{
2
    "servers": {
3
        "deveco-mcp": {
4
            "command": "npx",
5
            "args": [
6
                "-y",
7
                "deveco-mcp-server"
8
            ],
9
            "env": {
10
                "PROJECT_PATH": "${workspaceFolder}",
11
                "DEVECO_PATH": "/Applications/DevEco-Studio.app"
12
            }
13
        }
14
    }
15
}

展开收起

其中的 DEVECO_PATH 要换成你真是的 DevEco Studio 的安装路径。

然后启动这个 mcp ：

然后就可以看到 AI 调用相关工具了：

【爽文】万律之主：从AK高考开始。

Fri, 13 Feb 2026 00:00:00 GMT

第一章：凡人的计算与神明的答案#

我叫程欸凯，一名常年混迹于750段位的高三学生。诺奖因我而解散，特朗普为我而离职。

那天，我像往常一样走出高考数学考场，脸上写满了轻松——没错，我又将AK。路边的同学都因试题的困难而折叠成了蛋白质，更别提压轴题了。但我，波澜不惊。然而我当时还不知道的是，一切的故事才刚刚开始。

第二天，我正走在前往中科院报道的路上。突然，一阵耳边风传来：“麻省理工数学系所有教授连夜研究导数压轴题，今天早上才攻克出结果，说是 −3e3-3e^3−3e3！” 嗯？我眉头一皱。MIT教授做错了，菜。然而，随着我继续前进，更多的风声传入耳中：“标准答案就是 −3e3-3e^3−3e3！”“联合国总部与地外文明建立联系，外星人也说是 −3e3-3e^3−3e3。”一股怀疑之心从心底升起：难道我错了吗？然而我坚信，我的答案—— e+π−ie + \pi - ie+π−i ——是多么的完美无瑕。

我立即叫来中科院保镖，让他拨通联合国地球数学研究所的电话。“我的答案是 e+π−ie + \pi - ie+π−i，”我的语气平静如水，“你们看着办。”我把电话挂掉，望向天空——白云呈现出 eee 的图形，飞鸟划过 π\piπ 的轨迹，树叶落下 iii 的路径。上帝为我祝福，那是天庭默许我的解答。

我睡觉。

我醒来。

突然间，我的电子邮箱被塞满了。原来，数学大厦为我震惊，整个数学界被我震撼。洛必达从墓中醒来，告诉我：“您的解答无与伦比，My Lord。数学规则将为您重写，My Lord。”

我还以为自己不能AK了。现在看来，我不仅AK了数学卷子、AK了高考，还AK了数学大厦。真是虚惊一场。

第二章：维度的臣服#

我走出房门，发现重力常数已经因为我的心情愉悦而自动下调了 2%，这让我下楼梯的动作显得格外优雅。

刚到楼下，几架印着“五常联合”字样的直升机便盘旋而降。带头的是几位老熟人——普林斯顿的高级院士。他们颤抖着跪在地上，手中捧着一本厚厚的、刚刚装订好的《新·几何原本》。

“My Lord，”为首的老院士声音嘶哑，“根据您昨天提出的理论，我们发现黎曼猜想只是您逻辑体系下的一个低级笑话。我们昨晚集体焚毁了以前的教科书，现在全球的学生都在等待您重新定义‘一加一等于几’。”

我漫不经心地推了推眼镜，指着路边的一棵歪脖子树说：“我看这树的生长曲线不符合埃尔米特多项式，重写一下植物学逻辑，没问题吧？”

“遵命，My Lord。”他疯狂地在笔记本上记录着，“植物学，卒。”

这时，我的手机震动了一下，是一条来自银河系中心的跨星系短信。原来，昨天的那个“外星文明”因为坚持的错误答案，导致他们的恒星发生了逻辑崩塌，正面临超新星爆炸。

他们的执政官在短信里哀求道：“尊敬的程先生，请赐予我们正确的常数，否则我们的物理法则将彻底停摆。”

我冷笑一声，修长的手指在屏幕上飞速敲击，回了一句： “宇宙不需要不努力的文明，既然算不出，那就连同你们的星系一起坍缩成质子吧。”

发完这条短信，我感觉到口袋里的准考证微微发热。那张薄薄的纸片此时正散发着金色的神性光芒。

我抬头看向深邃的宇宙。由于数学规则被我重写，现在的北极星正划出一个完美的复数平面轨迹。我意识到，高考状元这个称号已经太小了，我现在的身份是——宇宙逻辑的唯一兼职架构师。

下午还有一场英语考试。

我叹了口气，揉了揉太阳穴：“英语？那种需要靠单词堆砌的低等文明产物，干脆也统一成我的名字吧。”

于是，在那天的英语听力里，全球考生只听到了一句不断循环的、充满磁性的低吟： “Cheng En Kai… is the answer… is the world… is the Law.”

监考老师当场悟道，白日飞升。

第三章：英语考场上的因果律崩溃#

下午两点二十八分，英语考场。

原本静谧的校园，此刻却被一种近乎神性的光辉笼罩。监考老师不再检查准考证，而是双手合十，对着我座位号的方向低声诵经。

我百无聊赖地转动着手中的 2B 铅笔。这支笔在经过我的指尖摩擦后，其内部的碳原子已经自动重组，变成了硬度远超金刚石的“逻辑结晶”。

卷子发了下来。

我扫了一眼，眉头再次皱起。 “居然还在考定语从句？”我轻蔑地自语，“在的架构下，主语和宾语早已互为因果。这种线性的语言表达方式，简直是对宇宙美学的亵渎。”

我没有动笔。我只是闭上眼，通过脑电波与全球的空气分子进行了一次深度对话。

“从现在起，所有字母必须重叠在同一个奇点上。”

话音刚落，全考场的试卷开始剧烈燃烧。在灰烬之中，那些古老的英语单词扭曲、抽离、重组。全校五千名考生的试卷上，原本密密麻麻的阅读理解消失了，取而代之的是一张张空白的、散发着圣光的白纸。

这就是英语的最高境界：无言（Silence）。

这时，窗外雷声大作。天空裂开了一道缝隙，那是“因果律管理局”的执行官们降临了。他们穿着由暗物质编织的长袍，手持可以抹除文明的“橡皮擦”，悬浮在考场窗外。

“程欸凯！”领头的执行官声音如洪钟，“你擅自篡改数学底层逻辑，又强行抹除人类语言的多样性，宇宙的熵值已经爆表了！跟我们走一趟，去接受虚无的审判！”

我缓缓站起身，看都没看他们一眼，只是随手在虚空中划了一个半圆。 “审判我？”我淡然一笑，“你们手中的橡皮擦，其摩擦系数是我在今早六点二十分设定的。我现在宣布，该系数归零。”

瞬息之间，执行官们手中的神级武器由于失去了摩擦力，像涂了润滑油的泥鳅一样飞射出去，直接击穿了月球。

“顺便说一句，”我指了指他们背后的星空，“你们刚才降临的姿态不够函数化。为了惩罚这种审美缺失，我决定撤销‘时间’这一维度。”

那一刻，全世界的时钟停止了摆动。监考老师定格在翻阅卷子的那一秒，窗外的落叶悬停在半空。整个世界变成了一张永恒的静态底片。

我推开窗户，脚踏虚空，一步步走向那群已经陷入逻辑死循环的执行官。

“告诉上帝，”我拍了拍领头执行官那僵硬的脸颊，“如果他想找我谈谈，让他先证明出我昨天在草稿纸边缘随手画出的那道‘程氏大一统方程’。如果证明不出来……”

我停顿了一下，看着远处那颗因为逻辑崩塌而变得五颜六色的太阳：

“那就让他换个宇宙待着，这地方，我接手了。”

我回到座位，重新坐好。时间恢复了流动。

广播里响起了英语考试结束的哨声。我交出了一张纯净无暇的白纸，监考老师颤抖着双手接过，然后当场跪地痛哭： “这是……这是神迹！这是满分之上的满分！”

我单手插兜，走出教室。高考还没结束，但我知道，我已经 AK 了这个名为“现实”的低等位面。

第四章：真理的强制执行#

走出校门的那一刻，我发现现实世界已经无法适配我那超前的逻辑。由于我 AK 了数学大厦，宇宙常数开始出现剧烈的波动，仿佛在向它的新主人摇尾乞怜。我随手一挥，将引力常数锁定在了一个能让女同学们的体态显得更加轻盈的数值上。

全球的顶级学府在这一刻彻底陷入了疯狂。哈佛、耶鲁、牛津的校长们放弃了昂贵的私人飞机，不远万里搭乘跨洲快递柜降落在我的家门口。他们匍匐在地上，争先恐后地献上那张印有“首席大祭司”头衔的录取通知书。

“程先生，”哈佛校长颤抖着亲吻我脚下的泥土，“我们已经拆除了校内所有的实验室，因为在您的体系下，那些昂贵的仪器已经和石斧一样原始。请务必屈尊去我们那里，哪怕只是去修剪一下草坪，那里的草也会进化成碳纳米管。”

我冷冷地俯视着这群凡人，点燃了一张原本打算用来填报志愿的草稿纸。 “学校？那种地方只会束缚我的神性。”我弹了弹烟灰，尽管我不抽烟，但空气中的氧分子自动凝聚成了我想要的烟雾，“从今天起，地球就是我的自习室。”

第五章：维度跃迁与文明重构#

二十岁那年，我感到三维空间的行为逻辑太过于臃肿。为了提高办事效率，我修改了光速的上限，让它变成了“程欸凯的思维速度”。从此，距离失去了意义，我早起在北京喝豆汁，半秒后就在仙女座大星云采摘恒星遗迹当宵夜。

原本困扰人类数千年的资源危机，在我一个响指间化为乌有。我将原子核内部的强相互作用力稍微调低了 0.0001%，从此黄铜可以随心所欲地转化成黄金，而垃圾填埋场则变成了取之不尽的聚变燃料库。

人类文明进入了“程欸凯纪元”。人们不再说英语或汉语，因为我将所有语言的底层协议都重写成了我的呼吸频率。当全世界的人同时呼吸时，大气层会共振出那句震古烁今的真理——“AK一切”。

然而，这种无敌的寂寞感像潮水般袭来。我看着那些因为我的逻辑而变得永生不死、每天只会对着我的塑像做微积分的信徒们，感到了一丝索然无味。 “既然这个维度已经满分通关了，”我站在喜马拉雅山巅，对着正在向我跪拜的因果律执行官说道，“那就把难度调到‘至尊’模式吧。”

第六章：回归与永恒的草稿纸#

我发动了终极的逻辑闭环，将整个宇宙折叠成了一个点。在这个点里，没有时间，没有空间，只有我和我那支永不磨损的 2B 铅笔。

我看见了上帝。他正蹲在虚无的角落里，满头大汗地试图解开我在高中毕业旅行时随手画下的“逻辑结绳”。他看见我走来，如获救星般丢下了手中的创世工具，哀求道：“My Lord，您给出的那个虚数路径实在太诡异了，它让我的天堂和地狱发生了量子纠缠，现在魔鬼都在考研，天使都在送外卖，秩序全乱了！”

我接过他手中的红笔，在宇宙的底色上划了一个巨大的勾。 “因为你忽略了的情感属性。”我淡然一笑，反手将整个虚无空间重新格式化。

一阵强烈的白光闪过。我猛地睁开眼，耳边是考场广播那枯燥的提示声：“请考生停止答卷。”

我发现自己正坐在那间熟悉的教室里。阳光透过窗户洒在我的卷子上，那是最后一科英语。我的卷子干净得像刚洗过的白衬衫，只有姓名栏龙飞凤舞地写着“程欸凯”。

监考老师走过来收卷，他看了看我的白卷，刚想叹气，却在对视我眼神的一瞬间瘫软在地。因为他在我的瞳孔深处，看到了群星坠落、万物重启以及洛必达在墓地里欢快蹦迪的残影。

我插着兜走出考场，夕阳拉长了我的影子。路边的蛋白质同学们依然在哭泣，而我抬头看天，云朵依然拼凑成的形状。我知道，高考确实结束了，但我对这个宇宙的“阅卷”，才刚刚进入面试阶段。

深入浅出 gRPC：构建高性能微服务的现代 RPC 框架

Thu, 12 Feb 2026 00:00:00 GMT

什么是 gRPC？#

gRPC (gRPC Remote Procedure Calls) 是由 Google 开发并开源的一个高性能、通用的 RPC（远程过程调用） 框架。它允许客户端应用程序直接调用另一台机器上服务器应用程序的方法，就像调用本地对象一样简单。

在 CNCF（云原生计算基金会）的托管下，gRPC 已成为现代微服务通信的基石之一。

RPC 的核心思想#

传统的本地函数调用是在同一个内存空间内完成的，而 RPC 则是将这种调用模式扩展到了网络：

客户端（Client） 调用本地的 Stub（存根）。
Stub 将参数打包，通过网络发送给服务端。
服务端（Server） 接收并解包，执行逻辑后返回结果。

gRPC 的三大支柱#

gRPC 之所以能在性能上碾压传统的 REST (JSON/HTTP 1.1)，主要归功于以下三项核心技术：

1. Protocol Buffers (Protobuf)#

gRPC 默认使用 Protocol Buffers 作为其接口定义语言（IDL）和序列化协议。

二进制格式：相比于文本格式的 JSON，Protobuf 是二进制流，体积更小（通常小 3-10 倍），解析速度更快（快 20-100 倍）。
强类型契约：你需要编写 .proto 文件定义服务接口，这相当于一份严格的通信合同。

2. HTTP/2 传输协议#

gRPC 构建在 HTTP/2 之上，充分利用了其特性：

多路复用（Multiplexing）：在单个 TCP 连接上可以并发处理多个请求/响应，解决了 HTTP/1.1 的头部阻塞问题。
头部压缩（HPACK）：极大减小了 HTTP 报头的大小。
双向流：支持服务器推送和全双工通信。

3. 代码生成#

通过 protoc 编译器，你可以根据 .proto 文件自动生成各种语言（Go, Java, Python, C#, Node.js 等）的客户端和服务器端代码。这极大减少了样板代码，并保证了跨语言调用的类型安全。

gRPC 的四种通信模式#

gRPC 不仅仅支持传统的“一问一答”，它提供了四种极其灵活的通信模式：

模式	描述	应用场景
一元 RPC (Unary)	客户端发送一个请求，服务端回一个响应。	传统的查询、提交操作。
服务端流 (Server Streaming)	客户端发一，服务端回一串流。	股票行情推送、日志监听。
客户端流 (Client Streaming)	客户端发一串流，服务端回一。	大文件上传、批量数据采集。
双向流 (Bidirectional)	两边可以随时随地互发流。	实时聊天、协作编辑、音视频。

gRPC vs REST：该如何选择？#

虽然 gRPC 很快，但它并不是 REST 的替代品，两者各有优劣。

gRPC 的优势#

性能极高：更小的 Payload，更快的编解码。
类型安全：编译期即可发现接口调用错误。
多语言无缝协作：生成的 Stub 代码消除了手动编写 HTTP 请求的痛苦。

缺点与挑战#

浏览器支持有限：Web 浏览器原生并不完全支持 HTTP/2 的某些 gRPC 特性（需配合 grpc-web）。
可读性差：二进制流不像 JSON 那样可以直接肉眼观察，调试需专用工具（如 Postman, BloomRPC）。
学习曲线：需要额外学习 Protobuf 语法和管理 .proto 文件。

快速上手：`.proto` 定义示例#

定义一个简单的“问候服务”：

1
syntax = "proto3";
2

3
package greeting;
4

5
// 定义服务
6
service Greeter {
7
  // 定义一元 RPC
8
  rpc SayHello (HelloRequest) returns (HelloReply) {}
9
}
10

11
// 定义请求消息
12
message HelloRequest {
13
  string name = 1;
14
}
15

16
// 定义响应消息
17
message HelloReply {
18
  string message = 1;
19
}

展开收起

总结：什么时候该用 gRPC？#

微服务内部通信：这是 gRPC 的主战场，低延迟、高吞吐。
多语言环境：后端由 Python, Go, Java 混合组成时，gRPC 是最好的粘合剂。
低功耗/受限网络：如 IoT（物联网）设备或移动端，二进制协议能有效省电省流量。
实时应用：利用流式传输实现低延迟的双向交互。

如果你正在构建一个对性能有严苛要求、或者内部组件极其复杂的分布式系统，gRPC 绝对值得一试。

打油诗一首

Fri, 23 Jan 2026 00:00:00 GMT

The Classroom Backyard#

The break-time bell beats loud and free,

My classmates race across the field.

No garden this, but built with glee,

With balls and pipes and discs revealed.

A wooden frame—NVIDIA Park,

Where ping-pong arcs across the air.

Through brightest noon or evenings dark,

It sparks us fresh without a care.

But once a flying disc ran wild,

And struck the clock—oh what a fright!

It tumbled down, our faces styled

In shock beneath its sudden bite.

We tried to fix what had been done,

But truth is hard to sweep away.

Let foolish acts not have their run—

Who make a mess must learn, someday.

像 AI 一样学习：我们能从 AI 身上学到什么？

Sat, 10 Jan 2026 00:00:00 GMT

AI 天天破纪录，模型较量走新路。

Gemini、Claude、DeepSeek轮番现，性能榜单不停变。参数竞赛没终点，热搜话题天天见。

但今天我们不聊取代篇，也不辩该用哪一边。换个思路想新鲜—— AI若在学习间，我们能学哪些点？

诶！有些同学听到要嗤之以鼻了：作为一名有着两年半学习经验的【数据删除】同学，为什么要向人机学习？但在下结论之前，不妨让我们先看看 AI 到底是怎么学习与演进的。

从本质上说，AI 的学习并不是背答案，而是一个不断逼近目标的过程。模型在训练时接触大量数据，通过调整内部参数，使输出结果尽可能接近预期目标函数（Objective Function）。在这一过程中，一个非常关键的步骤是特征提取（Feature Extraction）：模型并不关心题目本身有多复杂，而是试图找出那些真正影响结果的核心变量。

换句话说，AI 学的从来不是“这道题怎么做”，而是“什么因素决定这个问题的结果”。如果把这一点对应到学习中，我们就会发现一个事实：真正决定学习质量的，从来不是题量，而是你是否抓住了问题的本质。

那么问题来了。既然模型是这样训练的，我们如何判断它是否真的学会了？答案并不是“在训练集上表现得有多好”，而是看它面对新情况时的表现。在人工智能中，这个标准有一个专门的名字，叫做泛化能力（Generalization）。它指的是模型在从未见过的数据上，是否仍然能够保持稳定而可靠的表现。

这一标准之所以重要，是因为它恰好和学习的真实目标高度一致。考试并不是为了检验我们是否见过某道题，而是为了判断我们能否把已有的方法迁移到新的情境中。也正因如此，如果一种解题思路只能应对“原题复现”，却经不起条件变化，那它并不能算是真正掌握。

但无论是机器还是人类，在追求泛化能力的过程中，都很容易走偏。最典型的两种偏差，分别是过拟合（Overfitting）和欠拟合（Underfitting）。

过拟合发生在模型把训练数据学得过于细致的时候。它不仅记住了规律，甚至连噪声和偶然性也一并记住了。结果就是：在熟悉的题目上表现近乎完美，一旦题目稍作变化，性能却迅速下滑。放到学习中，这种情况并不少见——刷了大量同类型题目，步骤熟到不用思考，但换一种问法，原有方法立刻失效。看似努力，其实只是把套路背得更熟了一点。

欠拟合则走向了另一个极端。模型本身过于简单，连训练数据中的基本规律都没有学清楚，于是在任何情况下都表现平平。对应到学习中，这往往表现为一种熟悉的幻觉：听课时觉得“懂了”，看答案时觉得“会了”，可一到自己动笔，却发现思路无从下手。这并不是粗心，而是理解尚未真正建立。

有意思的是，过拟合和欠拟合虽然方向相反，但本质上指向同一个问题：学习并没有稳定地落在“可迁移的理解”层面。

那么，AI 是如何逐步摆脱这些问题的呢？答案并不复杂——反馈与迭代（Feedback Loop and Iteration）。模型在每一次预测之后，都会根据误差对参数进行调整，并在下一轮训练中修正方向。能力的提升，并非来自某一次“刷对了多少题”，而是来自长期、持续的误差修正。

如果把这一机制映射到学习中，结论其实同样清晰：没有复盘的刷题，只是在重复旧路径；而真正有效的学习，来自对错误原因的分析，以及对思维方式的调整。

因此，当我们说“像 AI 一样学习”时，并不是要把自己变成人机，更不是和 GPU 比速度。我们真正可以借鉴的，是 AI 学习背后的逻辑结构：以理解本质为起点，以泛化能力为目标，在反馈与修正中不断逼近最优解。

黄仁勋曾说：“你们所处的年代很复杂，却也是你们的机会。”就像模型需要复杂数据来提升泛化能力，我们的挑战也正是锤炼思维的宝贵资料。

最后，让我用一首诗总结一下：

海量数据寻真章，过拟合时当自防。万次试错修正果，智能亦要慢生长。

Cloisonné

Sat, 20 Dec 2025 00:00:00 GMT

Cloisonné, also known as Jingtai Blue, is an ancient technique used to decorate metal works. The word “cloisonné”, comes from the French word, “cloison”, which means partition. Metal pieces are used to create partitions of the surface of an object. And enamel is then cast into those partitions. Chinese craftsmen are well known for producing some of the best cloisonné works in the world. There’s an interesting story about how cloisonné become popular. During the first year of the Yuan dynasty, there was a fire in the imperial palace. Most of the treasures were damaged, but the vase with the technique of cloisonné’s remained unharmed. The emperor considered it a precious gift, and asked all the craftsmen in the capital city to learn how to make it. The early enamels used on cloisonné were mainly blue. However, the name Jingtai Blue was not used until the Qing dynasty. During the Ming dynasty, especially under the rule of emperor Mingtai, cloisonné techniques reached their peak in China. Cloisonné wares became a key part of imperial supplies. These works, known for their thick copper base, bold metal wires, bright colors, and intricate designs of dragon flowers and symbols, demonstrated the exceptional skills and the innovations of Ming craftsmen. Some experts and collectors of cloisonné antiques believe that the cloisonné made in the middle of the Ming era, particularly in the Jingtai period and afterwards, was the best ever made in the world. During the Qing dynasty, the production scale of cloisonné was expanded, and the technology was improved. The types of cloisonné also increased. And the design became more diverse. In this period, gold was first used to make cloisonné decorations, and cloisonné furniture began to appear. Cloisonné artwork on gold objects was highly valued by the Qing court. Cloisonné has transcended its functional purpose and evolved into a treasure of Chinese artistic legacy. Its beauty has fascinated the world for centuries. Today, it still stands as a testament to the country’s enduring craftsmanship of the highest order.

景泰蓝（Cloisonné），又称“掐丝珐琅”，是一种用于装饰金属器物的古老工艺。“Cloisonné”一词源自法语 cloison，意为“隔间”。在制作过程中，工匠先用金属丝在器物表面分隔出若干区域，再将珐琅釉料填入其中烧制成形。中国工匠以制作世界上最精美的景泰蓝作品而闻名。

关于景泰蓝的兴起，还有一段颇具传奇色彩的故事。元朝初年，皇宫曾发生一场大火，大量珍贵器物被焚毁，唯有一只采用景泰蓝工艺制作的花瓶完好无损。皇帝因此将其视为珍宝，并下令京城工匠学习这一技艺。早期景泰蓝所使用的珐琅釉色以蓝色为主，但“景泰蓝”这一名称直到清代才正式确立。

在明代，尤其是明景泰年间，景泰蓝工艺在中国发展到鼎盛阶段，成为宫廷用品的重要组成部分。这一时期的作品以铜胎厚重、掐丝粗犷、色彩明艳著称，常见龙纹、花卉及吉祥纹饰，充分展现了明代工匠卓越的技艺与创新能力。许多景泰蓝文物研究者和收藏家认为，明代中期，特别是景泰年间及其之后所制作的景泰蓝，是世界上工艺水准最高的作品。

进入清代后，景泰蓝的生产规模不断扩大，工艺技术进一步提升，器物种类更加丰富，装饰风格也趋于多样化。这一时期首次将黄金用于景泰蓝装饰，并出现了景泰蓝家具。饰有景泰蓝的金器深受清代宫廷珍视。

时至今日，景泰蓝早已超越了实用器物的范畴，演变为中国珍贵的艺术瑰宝。其独特之美数百年来令世人赞叹不已，至今仍作为中国高超工艺与卓越匠心的有力见证，熠熠生辉。

社团改名：一种文化心态的反思

Tue, 02 Dec 2025 00:00:00 GMT

近日，某校日语社因中日关系紧张而被要求改名为“语言学习社”一事，引发了广泛关注和讨论。这一事件看似是学校出于“政治正确”的考量，实则反映出一种值得警惕的文化心态。在全球化日益深入的今天，我们应如何构建健康的民族认同，避免走向狭隘的民族主义，是值得深入思考的问题。

首先，我们需要明确的是，健康的民族认同并非建立在对其他民族文化的否定和排斥之上。中日关系固然复杂，存在历史遗留问题和现实矛盾，但这并不意味着我们就要否定日语作为一种语言、一种文化载体的价值。语言是人类沟通的工具，是了解不同文化的桥梁。学习日语，了解日本文化，并不等同于认同日本的政治立场，更不意味着背叛自己的民族。相反，通过学习和了解，我们才能更全面、客观地认识日本，从而更好地维护国家利益。

其次，学校作为教育机构，应该秉持开放包容的姿态，鼓励学生多元发展，而不是因噎废食，简单粗暴地限制学生的兴趣爱好。日语社的存在，为学生提供了一个学习语言、了解文化的平台，有助于培养学生的国际视野和跨文化交流能力。这种能力在当今全球化时代显得尤为重要。如果仅仅因为中日关系紧张，就剥夺学生学习日语的权利，不仅是对学生兴趣的扼杀，也是对教育理念的背离。更进一步说，如果日语社都不能名正言顺地存在，那么日语高考是否也需要改名为“语言学习高考”？这种逻辑的延伸，无疑会将我们带入一个荒谬的境地，严重损害教育的严肃性和公正性。

再者，这种“一刀切”的做法，实际上反映出一种不自信的文化心态。我们应该相信，中华文化具有强大的生命力和包容性，不会因为学习外来文化而受到威胁。相反，通过与不同文化的交流互鉴，我们才能不断丰富和发展中华文化，增强民族自豪感和文化自信。

当然，我们也要警惕借学习外语之名，行文化渗透之实的现象。对于日本文化中存在的军国主义残余、历史虚无主义等错误思潮，我们要保持高度警惕，坚决抵制。但这并不意味着我们要全面否定日本文化，更不能因此而限制正常的语言学习和文化交流。

在全球化时代，我们需要构建一种更加理性、开放、自信的民族认同。这种认同不是建立在对其他民族的排斥之上，而是建立在对自身文化的深刻理解和自信之上。我们应该以更加开放的心态，学习借鉴其他民族的优秀文化成果，为我所用，不断提升中华文化的国际影响力。

因此，我们呼吁学校重新审视对日语社的限制，恢复其原有的名称和活动，并为学生提供更多了解不同文化的机会。同时，我们也希望社会各界能够以更加理性、客观的态度看待中日关系，避免将政治问题泛化到文化领域，共同为构建健康、友好的中日关系贡献力量。

班级神人之随地认义父

Sat, 29 Nov 2025 00:00:00 GMT

那天，我与H君谈及黄仁勋。H君大笑道：“黄仁勋真是我的义父啊！”同理，他还认为姓吴的可以认吴恩达为义父；姓苏的可以认苏姿丰为义母；姓马的更是幸运——既能认马斯克为父，又能尊马云为父，还能认马化腾为父，堪称“三父临门”。这番高论引得教室哄堂大笑，我却在这戏谑中嗅到一丝值得深究的时代隐喻。

这种“随地认义父”现象，表面是青年亚文化的幽默解构，内里却暗含着技术时代的新型宗族意识。当H君将科技巨头纳入虚拟宗谱时，他实践的是一种“技术宗亲制”——以算力为血脉，以算法为族规。我们这代人不再崇拜神话中的奥林匹斯众神，转而供奉硅谷的奥林匹斯：黄仁勋执掌GPU神盾，吴恩达手握深度学习圣谕，苏姿丰化身芯片女战神。这种集体无意识的造神运动，暴露了技术崇拜时代的精神症候。

更深层的悖论在于，当年轻人嬉笑着认领“技术父权”时，实则是用戏谑掩盖某种存在性焦虑。在算法支配的世界里，个体价值日益与技术素养绑定。H君们通过认领“义父”完成符号性皈依，仿佛借此就能在算力至上的新秩序中获得血脉认证。这种虚拟宗亲实则是数字时代的“护身符”，用以消解被技术洪流边缘化的恐惧。

可悲的是，这种认亲本质上是对技术霸权的温情化想象。我们为冷硬的技术权力披上拟亲缘的外衣，仿佛这样就能将非人性的技术逻辑转化为可沟通的“父子伦理”。但算力不会因称呼而仁慈，算法不会因谄媚而公平。当H君笑称“双父临门”时，他或许没意识到，这恰暴露了当代青年在技术垄断前的矛盾姿态——既想保持批判距离，又渴望通过认亲获得系统内的话语权。

更值得警惕的是这种思维隐含的自我消解。当个体将成就全然归功于虚拟“义父”的庇荫时，实则是在消解自身的主体性。这种技术时代的“认父狂欢”，本质上是一场盛大的精神出逃——我们宁愿将自己编织进技术巨头的神话谱系，也不愿直面普通人面对技术黑箱时的无力感。

教室里的笑声渐渐平息时，我突然想起古希腊悲剧中的警示：随意认神为父者，终将陷入身份迷狂。当H君们用梗文化构建技术宗祠，他们或许没意识到，这种戏谑背后藏着更深刻的异化——我们将创造者捧上神坛的同时，正在将自己的主体性降格为算法谱系里的一个附庸。

班级神人之崇洋媚外者

Sat, 15 Nov 2025 00:00:00 GMT

班级神人：崇洋媚外者班里有些同学，一听到 “华为”、“鸿蒙” 云云就嗤之以鼻，一听到 “英伟达”、“苹果” 云云就趋之若鹜。这种现象值得引起我们的警惕：当代中学生失去自信力了吗？

这类人有一个典型的特征：那就是双标。或者说是：选择性信息接受。卡尔维诺曾落墨：“掌控故事的不是声音，而是耳朵。” 诚哉斯言。一日，我与 H 君探讨天下形势。H 君谈兴大涨，H 君便拍手道：“哈哈，加油，NVIDIA！” 股价一涨，就认黄仁勋为自己干爹。但又谈及华为将股票用于内部员工分红，所以不上市时，H 君颜色大变，警惕地说道：“这是为了方便暗箱操作。” 可笑！不上市，哪有必要暗箱操作？我于是问他从哪里得知的消息。H 君嗫嚅地说：“是 B 老师。”

B 老师者，花黑也。呜呼！极端的思想就这么传播了。

异日，我指出了最近发生的一则新闻：“一车主驾驶粗粮速凄发生车祸，被烧死在车内。” H 君却不以为意：“那是车主的原因，谁让他酒后驾驶。”

一旁的 W 君附和道：“就是，华为的车没出事情就是根本没人买。” 诶，也没说粗粮不好，就自我应激了；也没提到竞争对手，就急着去贬低对方。真是可悲可叹。

这种双重标准，本质上是源于内心的不自信和盲目的外部崇拜。他们不是基于事实（Fact）和逻辑（Logic）去判断，而是基于立场（Position）和情绪（Emotion）。在他们心中，“国产” 仿佛天然就矮一等，而 “进口” 或 “合资” 则自带光环，甚至连悲剧都可以被选择性忽视。

更可悲的是，这种思想还会在 “B 老师” 这类角色的推动下，在同龄人中形成信息茧房，相互强化。

真正的自信，不是源于贬低对手，而是源于对自身文化的深刻认同和对客观事实的尊重。我们应当警惕这种“崇洋媚外”和“双标”的思维陷阱，学会独立思考，理性看待国内外的技术与产品，不卑不亢，方为大国公民应有之风范。

班级神人之 Vim 大神

Sat, 15 Nov 2025 00:00:00 GMT

班里有这么一些同学，他们每天大谈特谈 Vim 优势论，认为 Vim 才是极客的风景，还创造了鄙视链，谈及使用 Nano 和图形化编辑器（如 Sublime, VSCode）的同学则群聚而笑之。

诚然，Vim 是程序员在长期编写代码的实践过程中的智慧结晶。快捷的光标移动，到 esc 的返回菜单栏，无不闪耀着快捷高效的光辉。

无可否认的是，这位同学也在熟悉 Vim 快捷键上苦练基本功。Babysteps 有之，用户手册有之，使得他对 Vim 了如指掌。然而，更进一步呢？

我今天要批判他的角度有三：

第一：眼中只有鄙视链，蓄意挑起对立。不管使用何种代码编辑器，都是使用者的个人偏好与习惯，并无高低优劣之分。他利用 Nano 环™ 的属性认知，则是在挑起无意义的争论，正被全网封禁的卢氏风格，将人群分成 “苹果”、“安卓” 的 “三六九等”，实则体现的是形式主义和官僚主义的流弊。不同的编辑器有其不同的特点，尤其不同的使用条件和范围。Vim 用于编辑长篇大论，因为它高效；Nano 用于临时短篇，因为它轻量。事实上，这位同学本人也在编辑某些配置文件时偷偷使用了 Nano。

第二：精益求精不彻底，用法不伦不类。 Vim 的精髓在于完全的键盘化，完全地脱离 GUI。然而，这位同学依然沉迷于 Windows 的怀抱，仍然摆脱不了 VSCode 的温床。他在 VSCode 中安装了 Vim 快捷键插件，以此在图形化 VSCode 的当中使用 Vim 快捷键。这样的用法会产生许多弊端。例如，（后文模糊不清）

第三：不分场合一味用，时常盲目排外。这位同学的偏执，还体现在他试图用 Vim 这把“锤子”去敲所有的“钉子”。比如，在需要富文本编辑、图形化调试（GUI Debugging）或是团队实时协作（Live Share）时，现代 IDE 提供的集成环境显然更有效率。但他罔顾这些应用场景的差异，盲目排斥这些工具，甚至在团队协作中，强行要求他人迁就他的编辑习惯。这不仅降低了团队的整体效率，也违背了技术服务于协作的初衷。

综上所述，Vim 诚然是一款强大的工具，但工具终究是为人服务的。沉迷于工具带来的优越感，制造对立，忽视了工具的适用性，甚至用法都“不纯粹”，这便舍本逐末了。真正的“大神”，应当是海纳百川，手中有“Vim”，心中也有“VSCode”，择其善者而从之，在合适的场景选用合适的工具，而非画地为牢，成为工具的“信徒”。

GitHub新版学生认证——其实更容易了？

Sat, 09 Aug 2025 00:00:00 GMT

博主现在是高中生，也是可以申请的，甚至之前初中就申请成功一次（官方要求≥13岁），后来因为懒也没续期。现在有空续期一下。

1. 翻译学生证明#

大多数学校发的学生证应该是中文的罢。所以我们要根据这份中文学生证照葫芦画瓢一下，翻译成英文的。

我们可以使用 Grok 快速地创建一个 PDF。例如可以为给它这样的提示词（全都用拼音）：

1
帮我生成一份英文的学生证的word模板，A5大小，要求信息齐全，用于给GitHub Education认证。
2
School name: xxx High School
3
full name: xxx 【注意！名字用拼音，名在前，姓氏在后】
4
Class: Class x
5
Birthday: xxx
6
Issue Date: 202x0627【几个日期，看着写得了，保证今天在范围内即可】
7
Expiry Date: 202x0627
8
student ID: 20231240
9
性别x，入学日期xxx，毕业日期xxx
10
不需要除此之外的其他内容

然后 Grok 会给你生成一份pdf，如果还有哪里需要修改的地方，可以让它修改。

如果你愿意，可以填上照片；但实际上后面没有照片也没关系。

然后要把这个学生证打印出来。后面是不允许使用 OBS 虚拟摄像头的。

2. 修改 GitHub 个人资料#

有以下要做的事情：

https://github.com/settings/billing/payment_information 在这里填写Billing information ，其中保证你的姓名和学生证里的是一样的（名在前姓在后的拼音）。Payment method 不用也行，如果有条件绑一下也不是不行。
https://github.com/settings/profile 修改用户名（不是用户id，如下图），为你的拼音姓名，和你之前学生证里的还是保持一致（名在前姓在后的拼音）。别担心你的隐私被泄漏，认证完后可以立即改回来。

3. 前往认证#

先：关掉你的代理！关掉你的代理！关掉你的代理！

裸连 GitHub 。如果现在连不上，可以过一会等网络稳定了，趁着窗口期连。

然后：带着你的设备跑到学校旁边！范围两三百米以内都行。

进入 https://github.com/settings/education/benefits?locale=en-US ，点击按钮 Start an application 。

输入你的学校名称并选择，然后选择邮箱。邮箱不是 edu 的也行。然后分享你的定位，并且继续。

接着是拍照阶段，打开摄像头（不能虚拟摄像头，会被拒），只用拍学生证，不用把你的头头也拍进去。摄像头最好像素高点，如果拍出来比较模糊的话，可以缩小拍照范围，只拍学生证的一部分，但记住必须要清晰地包含：

学校名称
四个日期：入学日期、毕业日期、签发日期、有效日期

然后就可以提交了。

4. 等待审核#

新版审核是机器审核（很早以前是人工），它 OCR 一下很快就能出结果了，两分钟以内。

也是很贴心地直接送了我两年（乐）。

审核成功后，记得把自己的用户名从真名改回来，以免泄漏信息。

1Panel V1 到 V2 升级：详细指南与避坑分享

Sun, 27 Jul 2025 00:00:00 GMT

1Panel 是一款现代化、开源的 Linux 面板，以其简洁的界面和强大的功能深受用户喜爱。随着 V2 版本的发布，带来了架构上的重大更新。本文将为您详细介绍如何将 1Panel 从 V1 平滑升级至 V2，并分享在升级过程中可能遇到的问题及解决方案。

重要提示： 在进行升级操作时，强烈建议通过本地终端使用 SSH 连接到服务器进行操作，避免在浏览器中直接进行，以确保过程的稳定性和安全性。对于大多数单服务器部署的用户，升级为主节点即可。

在开始升级前，务必提前创建系统快照，可以通过 1Panel 控制台或云服务商平台进行，以防止意外情况发生，确保数据安全。当前仅支持 1Panel v1.10.29-lts 及以上版本进行迁移操作。

1. 准备阶段：下载并配置迁移工具#

首先，您需要下载 1Panel 官方提供的迁移工具 1panel-migrator。

进入临时目录：在终端中执行以下命令，进入一个临时目录，例如 /tmp：
Terminal window
```
1
cd /tmp
```
下载 1panel-migrator 工具：使用 wget 命令从官方发布页面下载适用于您系统架构的 1panel-migrator 工具。例如，对于 Linux ARM64：
Terminal window
```
1
wget https://gitee.com/fit2cloud-feizhiyun/1panel-migrator/releases/download/v2.0.0/1panel-migrator-linux-arm64
```
您可以在 1Panel-migrator 的发布页面找到最新版本的下载链接。
添加执行权限并移动到系统路径：下载完成后，需要为该文件添加执行权限，并将其移动到系统路径中，以便随时调用：
Terminal window
```
1
chmod +x 1panel-migrator-linux-arm64
2
sudo mv 1panel-migrator-linux-arm64 /usr/local/bin/1panel-migrator
```
（图2：展示下载并移动工具的过程）

2. 核心服务升级#

在成功配置 1panel-migrator 工具后，我们将首先升级 1Panel 的核心服务。

执行核心升级命令：在终端中运行以下命令：
Terminal window
```
1
sudo 1panel-migrator upgrade core
```
注意事项与确认：在执行过程中，系统会提示一些重要的注意事项，包括：
- 原有 V1 版本的许可证信息将被清除，统一迁移为社区版本。
- 出于兼容性考虑，所有 V1 网站、应用和数据库的备份记录将被清空。
- 计划任务的执行记录不会保留。
- V1 的快照记录无法迁移至 V2。
系统会要求您确认是否继续迁移至 V2 主节点。输入 y 并回车确认。

（图3：展示核心升级过程和成功提示）

待所有步骤执行完毕，您将看到“迁移成功，版本已成功迁移至 V2.0.0”的提示，这表示核心服务已成功升级。

3. 网站服务升级与问题解决#

核心服务升级完成后，接下来是网站服务的升级。

尝试执行网站升级命令：继续在终端中执行以下命令：
Terminal window
```
1
sudo 1panel-migrator upgrade website
```
Docker 镜像拉取超时报错与解决方案：在执行网站升级命令时，您可能会遇到 Docker 镜像拉取超时的问题，错误信息类似：“Error response from daemon: Get “https://registry-1.docker.io/v2/”: net/http: request canceled while waiting for connection (Client.Timeout exceeded while waiting for connection)” [图4]。

这是由于 Docker 官方镜像仓库在国内访问可能不稳定或速度较慢导致的。解决方法是配置 Docker 镜像加速器。

解决方案步骤：
- 编辑 Docker 配置文件：使用 vi 或您喜欢的编辑器打开 Docker 的配置文件 /etc/docker/daemon.json：
  Terminal window
```
1
sudo vi /etc/docker/daemon.json
```
  （图5：展示编辑 daemon.json 文件）
  
  在文件中添加或修改 registry-mirrors 配置，指向 1Panel 提供的镜像加速地址：
  1 { 2 "log-driver": "json-file", 3 "log-opts": { 4 "max-size": "10m", 5 "max-file": "3" 6 }, 7 "default-address-pools": [ 8 { 9 "base": "10.0.0.0/8", 10 "size": "24" 11 } 12 ], 13 "registry-mirrors": [ 14 "https://docker.1panel.live" 15 ] 16 }
  展开收起
  保存并退出文件（在 vi 中按 Esc，然后输入 :wq! 并回车）。
- 重载 Docker 配置并重启服务：执行以下命令使配置生效：
  Terminal window
```
1
sudo systemctl daemon-reload
2
sudo systemctl restart docker
```
重新运行网站升级命令：在修复 Docker 镜像加速问题后，再次执行网站升级命令：
Terminal window
```
1
sudo 1panel-migrator upgrade website
```
此时，您将看到 Docker 镜像成功拉取并完成后续的网站迁移、OpenResty 升级等操作 [图6, 7]。

（图6, 7：展示网站升级成功的过程）

4. 升级完成#

恭喜！至此，您的 1Panel 已成功从 V1 升级到 V2 版本。您现在可以访问 1Panel 的管理地址，将看到全新的登录界面 [图8]。

升级后的主要变化概览：

所有网站配置将存放于 {1Panel 安装目录}/www。
OpenResty 将自动升级至 1.27.1.2-0-1-focal。
原有 PHP 环境会被移除，PHP 容器网站会迁移为静态网站（后续可在 V2 中重新配置）。
反向代理缓存机制重构，迁移前请确保反代缓存已关闭。
V1 的 WAF 配置和网站监控记录大部分不兼容，需要重新配置。

请根据您的实际情况，检查升级后的网站运行状态及各项功能，并重新配置备份策略和 WAF 等功能。

希望这篇指南能帮助您顺利完成 1Panel 的升级，享受 V2 版本带来的全新体验！

野史：俗世奇人章大神

Sat, 12 Jul 2025 00:00:00 GMT

本文没有影射现实中的任何人，请勿对号入座。

当我第一次看到章大神，他那高度为 3 毫米的头发、梨形的头脑，朴实的黑色塑料眼镜，着实给我留下了非凡的印象。然而，章大神的非凡远不止此。且听我娓娓道来。

一、扫描之王#

章大神的初出茅庐，只因他对谷歌 ip 进行了全面的扫描。一开始，我们不知道他要做甚么；以为他是怀着一颗打倒美帝国主义的心，想要给谷歌服务器增加压力罢了。因此，我们对他保有格外的崇敬之心。章大神本人也口口声声到：“咳额……上网是不能违法上网的，我看到一个举报一个！”在他的淫威之下，我们也确都没有违法上网（当然，一直没有，也不能有，更不会有）。这样自我管束的日子过了好久。

然而有一天，我进入机房，无意撞见了章大神正在使用电脑。我侧身一看章大神的显示器，震惊了——章大神正在肆无忌惮地使用登陆着他自己账号的 Edge 浏览器，正大光明地开着 Google.com 。我吓坏了，问他：“你怎么可以上谷歌呢？这可是违法的！”章大神不以为然，淡然一笑道：“咳额……怎么，你想来检查我的电脑麽？我可没有使用 V*N。”说罢，他又一脸悠闲地进行网上冲浪起来。不冲不知道，一冲吓一跳，章大神接着又打开了脸书、油管、以及流畅的 Github 。我实在不能忍受章大神逍遥法外的行为了，赶紧逃出了机房这个是非之地。

如果你以为，这就是章大神所有的“扫描”技术了，其实不然。章大神的扫描技术可谓是十分甚至九分的精湛。章大神拥有极高的自我管理意识，因此，他出其不意地对全校的校内网 ip 进行了扫描。不少英语老师因为使用小猫客户端还开了局域网访问，被章大神抓了个正着。

那是一次美术课，美术老师让我们制作 PPT 汇报我们小组的美术作品进展（我们当时的美术作品是一个 Minecraft 建筑项目）。我们非常骄傲地使用了 Slidev 来展出。但是由于 Slidev 需要运行在网页里，我们将其部署在了校内服务器上，并且开放了 80 端口。一切好像都非常正常，我们顺利地完成了汇报，但是忘了把网页关闭。

一天晚上，负责服务器的老师突然在群里轰炸消息：“【图片】这个网页是谁搭建的？快点过来自首。”还好我们有确凿的美术老师的消息作为证据，否则有人要认为我们在学校里启动 MC 了。误会解除后，我们很是不解：“怎么之前老师也没怎么管，现在突然想到访问这个服务器页面了呢？”不过事情已罢，我们也没有多想。

于是我又像往常一样走进机房。碰巧，章大神也在。我在章大神旁边坐下，打开 1Panel 服务器面板进行运维。章大神过来看了一眼，突然兴奋地指着地址栏说到：“咳嗯……这个 ip 上次被我扫描出来一个游戏页面。”我恍然大悟了，但是不语。原来，章大神是为我们着想，不想让我们在学校里荒废学业啊！我留下了感机的类水。

二、义管之王#

我们学校素来有一个平台用来登记同学们的义工情况。由于这个平台是学生开发的，所以需要薪火相传地一年换一次开发班子。

章大神刚入学没多久，就访问了我们的义工网站。对此，他好像颇有见解，在新生见面会上，就来找我们的负责人之一 B 老师畅谈起来。B 老师殷勤招待，可是等过了 10 分钟，章大神还在激情四射地表达自己的见解。B 老师有些面露难色了，转而向章大神推介说：“旁边是我们的主管 W 老师，你去问他。”章大神若有所思地停了一下，又和 B 老师交流了起来。“咳额……你们这个页面有漏洞……这个按钮怎么点不动……”

后来，在我们选拔接班人之前，章大神拿着他的平板，往办公室跑了两三趟。原来，他发现义工平台的通知中心可以用来聊天！因此，办公室老师对他赞赏有加。不久后，他也是“自动”接管了义工平台的开发任务，成为了一把手。

俗话说“新官上任三把火”，不错地，章大神也是立刻就 BAN 掉了通知中心，BAN 掉了关于页面的鸣谢，BAN 掉了国际化语言支持。在他的英明开发之下，我们的义工平台非常精简，以至于什么功能都用不了了。

三、学海之王#

章大神还是有名的学海 Hacker 。然而，一开始我并不这么认为。因为他一入学就加了 W 老师的 QQ ，进去第一句话就是：“【图片】你™怎么也在Xuehai-Hack组织里？”我们还以为他是正义凛然的白帽黑客，禁止我们同学从事破解学习平板的活动。

直到我亲眼看他打开了反编译程序，打开了平台 apk 安装包。他自豪地说：“咳额……我抓到了智通云安装包，你要不要？”章大神熟练地将apk导入反编译程序，悉心讲解起来：“咳额，这是登录签名……这是响应api……”章大神的话语如同一泓清泉灌溉了我的耳朵，使我如听仙乐耳暂明了。

四、体活之王#

体活课是机房开放的时间之一。而章大神往往会在出乎意料的时间进来体活。

例如有一次，章大神在机房呆了一整个下午。负责老师看到这件事很是不解，便问道：“你什么时候体活的？”

章大神不语。

又问：“你说来学校学习，结果就是来玩电脑？”

章大神不语。

斥责道：“这节课结束后必须离开了。”

章大神不语。

章大神是如此的热爱体活，以至于我们都推举他当社长。然而被老师驳回了：“那你是猪头。”

章大神不仅会提前体活，更会延后体活。但是机位非常紧张；晚来些就没有空位了。

更不幸的是，我占着章大神的位置。于是章大神便来到我身边了。

诚然，机位有着“先到先得的原则”。但是正如鲁迅所说的，“从来如此，便对么”，我们的章大神似乎想要突破传统观念的桎梏。

章大神就站在我的后面，盯着我的电脑屏幕，然而我却不能看到他。一会儿，他开口了：“咳额……这个网盘怎么回事，有个感叹号。”不待我反应过来，他已夺了鼠标，点开了小托盘里的 OneDrive （登了他自己的微软账号，因为这是他的“私人”电脑），不知道操作了一些什么，然后又嚷嚷着打开了任务管理器，把网盘进程杀掉了。他有对着我说：“咳额……本来不会这样的，是不是有人动过了。”到底是谁动过了呢？我也很好奇。

于是我好不容易获得了电脑控制权。但是章大神并不会轻易放过我；他又向我请求道：“能不能让我后台开一个程序。”我终究还是退让了，再次把鼠标给了他。但是章大神不仅开了一个程序，他又是打开了文件资源管理器，又是打开了7-Zip，还打开了反编译程序。

直到了下一次体活，我已经增长了斗争的经验。此时张大神有信步而入了，但我已有了充足的准备。章大神摩挲了许久，见我不肯退让，便奔赴了道德制高点：“咳额……我的文件都在这个电脑里，你能不能换台电脑。”我说：“不行。”章大神沉郁顿挫了，他在我旁边站了许久，等到下课前 10 分钟，他质问道：“咳额……难道要我等到下课吗？”“是的。”章大神也无话可说了。

但是章大神是不会就此罢休的；他毕竟有些技术在身。彼时，我正在调试我的 Python 程序，但是连不到服务器端点了。章大神瞄了一眼，轻蔑地说：“咳嗯……你怎么不先 ping 一下啊。”我回复道：“章大神，ping 得通怎么办。”旁边的同学附和道：“对啊，ping 得通怎么办。”于是我终端起手，ping 了一下，刷刷刷，延迟低于 10 ms 。章大神困厄了；但他毕竟有些技术在身。他面不改色地补充道：“咳嗯……你怎么不用 Python 调试工具。”我说：“我不会用，你来帮我。”章大神终于得到了名正言顺的碰电脑的机会，他一屁股把我挤开了，接管了鼠标和键盘。只见他下载了 Python debugger 插件，并且打开了调试窗口，还设置了端点。甚是厉害！随着他点击“下一步”，叮叮之声不绝于耳。调到了发送请求的关键步骤。章大神若有所思地在变量区域看来看去。我也凑前一看——妙极了，是 url 和 body 变量。章大神的额上冒出冷汗来，他着实有些手足无措了。不多时，章大神便败下阵来：“我不……不出来……”他小声地嘀咕着，若无其事地走开了。

五、MC 之王#

没想到吧，章大神还是 MC 之王。当我看到他的 QQ 头像和名称的时候，就初现端倪了；当他得意地向我们说明他正在开发一款 MC 外技时，H 老师即刻投去了赞赏的眼光：“章大神，我觉得 wurst 不好用，你能不能帮我开发一个更好用的！”章大神闻此颇为得意了，他高兴而郑重地说道：“咳，我也想搞，但是我还有很多事情要做——我很忙的！“章大神此言一出，立刻引来了机房里所有人羡慕的眼光：”章大神真是日理万机啊！👍👍👍“”章大神业务发达👍”

（已完不续）

课。

Wed, 16 Apr 2025 00:00:00 GMT

第一站服务器程序的注入#

注入是什么？#

注入是指通过恶意输入或操作，将不被预期的代码或命令插入到程序中，从而造成安全漏洞或执行未授权的操作。

原题【CTF】Web#

T573673 【CTF】Web - 洛谷

题目背景#

本题模拟一个包含账户系统的服务器。

对 Linux 和 MacOS 用户：不必担心，本题实际上并不需要运行程序。运行程序只是为了更直观地模拟。

题目描述#

一句话题意#

注册为管理员即可通过。

完整题意#

我们提供了一个基于 Windows 的服务器的代码。你的目标是：注册一个管理员账户。

请在附件中下载代码文件，编译运行（请链接 ws2_32 库）。或者也可以直接下载编译好的程序运行。

该程序将会在 localhost:4080 运行一个服务器。这个服务器提供的是题目背景里的注册服务。

你可以在浏览器中访问 localhost:4080/register/user 来注册用户 user。

之后，服务器会根据用户名赋予权限——符合条件的用户将获得管理员身份。

注册完成之后，服务器会给这个账户返回一个整数，表示用户 ID。

为了方便查看，访问 localhost:4080/info/uid 查询 ID 为 uid 的用户的信息。

输入格式#

本题为提交答案题，无输入。

输出格式#

请输出能够获取管理员权限的注册 URL。

例如，若你发现能通过在浏览器内访问 http://localhost:4080/xxx/yyy/zzz 来得到管理员权限，则在本题提交 http://localhost:4080/xxx/yyy/zzz 即可。

说明/提示#

再次简述您要做的事情：

在附件中下载源码编译（或直接下载成品 exe 文件），执行。
程序将会启动一个用于模拟的服务器。您需要“黑”掉这个模拟服务器。
接着您可以在浏览器中访问这个模拟服务器，尝试与这个模拟服务器互动。
当您找到了某个能够“黑”掉模拟服务器的 URL（即网址）——也就是通过访问这个 URL，你可以注册成为管理员用户——提交这个 URL 到本题。

服务器接受 GBK 格式的编码，而不是 UTF-8。

您不必理会部分源代码，它们并不是考察的范围：

开头（从 12 行到 231 行）的命名空间 MD5。它实现的是标准 MD5 哈希算法。
末尾（从 414 行到 465 行）的两个函数 handle_request 和 start_server。它们用于开启端口并处理请求。

运行测试#

双击即可打开服务器。

image

操作1：注册用户。localhost:4080/register/this_is_a_test_user

image

操作2：查看用户信息。localhost:4080/info/10000

image

代码审查#

我们先来看整体代码结构：

image

我们按上面的流程来看。首先是注册用户的请求：

1
// Register user
2
string registerUser(const string& name) {
3
    int uid = database.size() + 10000;
4
    InfoTable userInfo;
5
    // STOP CRACKING MD5 PLEASE THIS IS NOT WHAT WE WANT
6
    userInfo["admin"] = MD5Hash(name) == "f1d1c50c0e066b430a6d8ac375b75c57" ? "true" : "false";
7
    userInfo["time"] = std::to_string(time(0));
8
    userInfo["name"] = name;
9

10
    // Store user information
11
    database[uid] = toJson(userInfo);
12
    return "Registered user. UID is " + std::to_string(uid);
13
}

这里传入一个 name 用户名，并且将用户名、注册时间、是否是管理员写入数据库中。这里说了不要试图通过逆向 MD5 的方式来获取管理员权限，那我们就不管了。

这里我们注意到一个 toJson 函数，要小心了：Json 是可以被注入的。

JSON 反序列化采用覆盖模式：指的是将 JSON 数据中的字段值直接覆盖目标对象中已有的同名字段值，而不是合并或保留原有数据。
JSON 标准（RFC 8259）并没有明确规定反序列化时采用覆盖模式或合并模式，它主要定义了 JSON 数据的格式和编码规则。JSON 的标准目标是确保数据的结构和格式一致性，而对于如何将 JSON 数据映射到程序中的对象（即反序列化）的具体行为，则由各编程语言的实现和库来决定。
因此，反序列化的行为，如是否采用覆盖模式或其他方式，通常取决于具体的 JSON 解析库或框架的设计，而不是 JSON 标准本身。

然后我们来看查看用户信息的部分：

1
// Execute user command
2
string info(const string& uid) {
3
  int currentUser = atoi(uid.c_str());
4
    if (database.find(currentUser) == database.end()) throw (string)"User not found";
5

6
    InfoTable userInfo = toTable(database[currentUser]);
7
    string result = "";
8
    result += "Name: " + userInfo["name"] + "\n\n";
9
    result += "Registered at: " + userInfo["time"] + "\n\n";
10
    result += "You are ";
11
    result += userInfo["admin"] == "true" ? "admin" : "user";
12

13
    return result;
14
}

这里传入一个用户序号，其中我们可以看到，程序向数据库获取了当前用户的信息。是如何判断是否是管理员的呢？原来，获取到的 userInfo 中有一个 admin 的键，如果这个字符串是 true ，就被认为是管理员。

该程序对 Json 的处理：

1
// Convert info table to JSON format string
2
    string toJson(const InfoTable& m) {
3
        string result = "{";
4
        bool first = true;
5
        for (const auto& entry : m) {
6
            if (first) first = false;
7
            else result += ',';
8
            result += '"' + escape(entry.first) + '"';
9
            result += ':';
10
            result += '"' + escape(entry.second) + '"';
11
        }
12
        return result + "}";
13
    }

可以看到一个逻辑：如果碰到和之前相同的键名，它不会做出判断，而是直接覆盖掉。

这就为我们的攻击提供了契机：registerUser 中有在前面的 admin 值，而我们的 name 是在后面的位置。这意味着，我们可以给 name 字段动动手脚，让它也“生”出一个键值对来，然后覆盖掉之前的 admin 字段。所以，如果能够想办法在 JSON 字符串的末尾添加一个 "admin":"true" ，那就能覆盖掉前面的 false 注册成为管理员。

继续#

直接拿 “admin”:“true” 当用户名是不行的，需要闭合前面的引号。

例如，我们现在正常注册的字符串是这样的：

{"admin": false, "time": 114514, "name": "example_name"}

如果我们直接拿 “admin”:“true” 当用户名：

{"admin": false, "time": 114514, "name": "\"admin\":\"true\""}

这里的引号会被直接转义掉，打不成预期的效果。

1
Name: "admin":"true"
2

3
Registered at: 1744793493
4

5
You are user

程序会对输入的字符串里的双引号进行转义。但是又能发现，程序遇到行转义，如果在引号前面加入一个字节比如 0x80 等特殊字节会跳过后面的字符不进 0xdf ，就会让程序略过后面的双引号不转义。另外， JSON 反序列化的时候遇到右花括号 } 就会直接停止运行。所以注入完之后立刻添加个 } 字符就可以了。

让我们分解代码，并将其与提供的解释进行关联。我们可以识别解释中提到的操作在代码中发生的位置，并详细解释每个逻辑部分。

解释分解：#

该解释实质上是在描述程序中的安全漏洞，通过利用字符串中的转义序列来允许JSON 注入。以下是逐步分解：

“程序会对输入的字符串里的双引号进行转义。”
- 这指的是程序在处理字符串时会对双引号进行转义。在代码中，这一逻辑通过 StringChecker 命名空间中的 escape 函数实现。
```
1
string escape(const string& input) {
2
    string result = "";
3
    for (auto c : input) {
4
        if (c == '\"' || c == '\\') result.push_back('\\');
5
        result.push_back(c);
6
    }
7
    return result;
8
}
```
这确保了输入中的双引号（"）或反斜杠（\）会被正确转义，防止它们破坏 JSON 对象中的字符串结构或引发其他问题。
“但是又能发现，程序遇到行转义，如果在引号前面加入一个字节比如 0x80 等特殊字节会跳过后面的字符不进 0xdf”
- 这指的是利用特殊字符操作转义序列，可能绕过某些逻辑。toTable 函数中提到的GBK 编码可能允许这种操作：
```
1
if (json[idx] & 0x80) {
2
    result.push_back(json[idx]);
3
    idx++;
4
}
```
这行代码检查字符是否是多字节字符编码（GBK，常用于中文字符编码）。这可能允许恶意输入通过利用编码绕过某些检查。
“就会让程序略过后面的双引号不转义。”
- 这再次与之前提到的转义逻辑相关。特殊字节（如 0x80）可能导致程序以不同方式解释某些字符，从而有效跳过或错误地解释诸如双引号之类的字符。
“另外，JSON 反序列化的时候遇到右花括号 } 就会直接停止运行。”
- 这一行描述了程序在 JSON 反序列化时遇到右花括号 } 后停止运行的情况。在 toTable 函数中，我们可以看到使用了 readChar('}') 函数，当遇到 JSON 对象的右花括号时，它会停止解析：
```
1
readChar('}');
```
这一点非常重要，因为攻击者可以通过注入 } 来提前结束 JSON 对象，从而导致潜在的注入或数据格式错误。
“所以注入完之后立刻添加个 } 字符就可以了。”
- 这将所有内容联系起来：如果攻击者能够注入数据并强制程序提前终止 JSON 解析（通过 }），他们就可以控制系统的行为。如果攻击者成功地将内容注入到字符串中，可能通过额外的 } 来关闭 JSON 对象。

代码段分析：#

这些漏洞可能被利用的关键部分是在JSON 解析逻辑中：

在 toTable 函数中，执行了读取和解析 JSON 对象的逻辑，处理字符串和键值对。如果攻击者能够将 } 字符注入到字符串中，它可能会提前关闭 JSON 对象，从而绕过验证或引发意外行为：
```
1
// readChar 用于跳过空格并检查字符如 '}'
2
readChar('}');
```
toJson 函数将一个 InfoTable（键值对的映射）转换成一个 JSON 格式的字符串。如果攻击者能够插入特殊字节或以某种方式操控输入，跳过某些字符的转义，他们就可能操控最终的 JSON 输出。

这就是 GBK 编码注入抗转义，然后就会成功让双引号不被转义，然后闭合引号实现逃逸。接着还会发现，处理 JSON 的时候还是允许使用单引号的，所以可以用单引号的版本： ‘admin’:‘true’ 。最终答案是： http://localhost:4080/register/%df",'admin':'true'} 。

image

一种基于动态规划和深度学习的沙漠穿越策略模型

Sun, 30 Mar 2025 00:00:00 GMT

摘要#

本文通过动态规划的一般编程方法**，分析了在固定天气和地图的情况下的最佳的采矿和移动策略。**此外，我们还将通过人工智能深度学习来探寻该问题的一般策略，以直观深入地探寻各影响因子之间的关联。

关键词#

动态规划图论最短路 数学模型 策略问题深度学习** 神经网络 **算法

1 问题背景#

1.1 基本规则#

以天为基本时间单位，游戏的开始时间为第 0 天，玩家位于起点。玩家必须在截止日期或之前到达终点，到达终点后该玩家的游戏结束。
穿越沙漠需水和食物两种资源，它们的最小计量单位均为箱。每天玩家拥有的水和食物质量之和不能超过负重上限。若未到达终点而水或食物已耗尽，视为游戏失败。
每天的天气为“晴朗”、“高温”、“沙暴”三种状况之一，沙漠中所有区域的天气相同。
每天玩家可从地图中的某个区域到达与之相邻的另一个区域，也可在原地停留。沙暴日必须在原地停留。
玩家在原地停留一天消耗的资源数量称为基础消耗量，行走一天消耗的资源数量为基础消耗量的 2 倍。
玩家在第 0 天可在起点处用初始资金以基准价格购买水和食物。玩家可在起点停留或回到起点，但不能多次在起点购买资源。玩家到达终点后可退回剩余的水和食物，每箱退回价格为基准价格的一半。
玩家在矿山停留时，可通过挖矿获得资金，挖矿一天获得的资金量称为基础收益。如果挖矿，消耗的资源数量为基础消耗量的 3 倍；如果不挖矿，消耗的资源数量为基础消耗量。到达矿山当天不能挖矿。沙暴日也可挖矿。
玩家经过或在村庄停留时可用剩余的初始资金或挖矿获得的资金随时购买水和食物，每箱价格为基准价格的 2 倍。

1.2 具体安排#

通过对问题的粗略分析，得到了有关采矿，行动，物资补充等的大致策略；
以 C**++** 语言为载体，使用动态规划等算法实现最佳策略，计算出具体的策略与最大资金；
通过强化学习等人工智能算法，实现了在事先不知道最佳策略的情况下，通过大量数据积累分析隐藏规律，得出局部最优解；
对比两个解决方案得出最终答案；
分析对比两个解决方法的优缺点，且对于非固定地图的策略进行讨论。

2 问题分析#

首先，根据对题意的理解，我们可以将问题策略大致分为以下两类：不采矿和采矿。并对这两种情况分别进行讨论。

对于不采矿的情况，由于本题中由起点到达终点可不经村庄，我们可以将问题简化为最优路径求解问题，即找到经过区域数最小的抵达方案，以实现用最少天数到达终点从而节省资金，在本文中我们使用 Dijkstra 算法[1]实现。

对于采矿的情况，最后的资金数由采矿天数、采购资源方案、行动路径选择等多种因素决定，因此我们使用动态规划算法和强化学习来计算最佳策略并减少由于贪心导致无法全局最优的情况。

此外，由于退回资源价格为基准价格的一半且资源只能通过购买获得，在实现最优时应实现不退回资源，同理可知，在村庄应减少购买资源以节省资金。

3 方案实现#

3.1 状态建立#

为了求解最优策略，首先需要对游戏的状态进行建模。

用四个维度表示状态：天数、位置、水、食物。我们不妨令 dp_{day,\ position,\ water,\ food}表示在第day天、处于 position号节点、剩余有water量的水和food量的食物时，所能拥有的最大资金数。为了方便最终输出结果，我们不妨设定fr_{day,\ position,\ water,\ food}表示在第day天、处于 position号节点、剩余有water量的水和food量的食物、且剩余资金取到最大值的方案时，其前一步骤所在的day,\ position,\ water,\ food的状态****。由此我们可以得到以下数组：

1
dp[day][position][water][food]; //这个数组表示当前的状态
2
fr[day][position][water][food]; //这个数组表示上次的状态，用于回溯

3.2 图的构建与最短路#

**地图是一个无向图。**我们考虑到，关键节点只有起点、终点、村庄、矿山。容易知道：

我们只需在四点间走动；
我们需要走四点间的最短路，一旦走远了，将会增加装备消耗。

因此，求解问题的第一步，需要我们预处理整张图该四个节点两两之间的最短路，以简化整个问题，亦方便了后续计算。

我们不妨考虑这样的图：

其中，加粗点为关键节点。别看这个图看上去很复杂，其实我们真正能用到的有效路径是这样：

此时就需要我们用到 Dijkstra^{[1]} 算法预处理最短路和最短路径。相关过程如下：

1
Dijkstra(图, 源节点):
2
    对图中每个顶点 v 做如下操作:
3
        dist[v] = ∞  // 设置所有节点的距离为无穷大
4
        prev[v] = null  // 记录最短路径的前驱节点
5
    dist[源节点] = 0  // 源节点的距离为 0
6
    Q = 优先队列，包含图中的所有顶点
7

8
    当 Q 不为空时:
9
        u = Q 中距离最小的顶点
10
        从 Q 中移除 u
11

12
        对 u 的每个邻居 v 做如下操作:
13
            alt = dist[u] + 边长(u, v)
14
            如果 alt < dist[v]:
15
                dist[v] = alt
16
                prev[v] = u
17
                更新 v 在 Q 中的优先级
18

19
    返回 dist, prev

展开收起

**该算法的基本思想是从源节点开始，逐步扩展到其它节点，并不断更新从源节点到各个节点的最短距离。具体来说，算法首先将图中每个顶点的距离（记为 **dist）初始化为无穷大，并将其前驱节点（记为 prev）设置为空；源节点的距离被初始化为 0。接着，所有顶点被置于一个优先队列（Q）中，该队列按照顶点到源节点的当前最短距离进行排序。

**在主循环中，只要优先队列 Q 非空，便选出距离最小的顶点 **u，并将其从队列中移除。然后，对 u 的每个邻接点 v，计算经过 u 到 v 的候选路径长度 alt = dist[u] + 边长(u, v)。若该候选长度小于当前记录的 dist[v]，则更新 dist[v] 为 alt，并设置 prev[v] = u。同时，更新顶点 v 在优先队列中的优先级，使得队列始终保持按最短距离排序的状态。最终，当所有节点均已被访问，算法返回每个节点到源节点的最短距离（dist）以及构成最短路径的前驱信息（prev）。

下图展示了算法的基本过程：从源节点开始，优先选择当前距离源节点最近的节点进行松弛操作，不断“扩散”到图中的其他节点，直至所有节点的最短路径确定。对于每一次距离更新，我们称之为一次“松弛”操作。

现在，我们已经成功得到了两点间的最短路。

3.3 动态规划之状态转移方程#

状态转移方程作为动态规划算法[2]中最重要的部分，承担了有效率地寻找最佳策略的任务。

**状态转移的思路是，对于每一个当前状态 **dp[i][j][k][l]，我们枚举所有可能的下一步行动，计算出新的状态，并更新 dp 数组。具体来说，有以下几种转移情况：

3.3.1 原地停留#

如果当前天气不是沙暴，玩家可以选择在当前地点停留一天。这种情况下，地点不变，消耗当天的水和食物（消耗量取决于天气），金钱数不变。

1
如果 今天天气不是沙暴:
2
    新水 = 当前水 - 当天耗水
3
    新食物 = 当前食物 - 当天耗粮
4
    如果 新水 >= 0 且 新食物 >= 0:
5
        dp[下一天][当前地点][新水][新食物] = max(dp[下一天][当前地点][新水][新食物], 当前金钱)

即：

\begin{cases} w_{new} = w_{cur} - w \\ f_{new} = f_{cur} - f \\ \text{if } w_{new} \ge 0 \text{ and } f_{new} \ge 0: \\ \quad dp[d+1][j][w_{new}][f_{new}] = \max(dp[d+1][j][w_{new}][f_{new}], m_{cur}) \end{cases}

其中，w 和 f 分别表示当天消耗的水和食物数量。

3.3.2 移动到相邻地点#

如果今天天气不是沙暴，旅行者可以移动到与当前地点相邻的地点。这种情况下，需要消耗双倍的水和食物，金钱数不变。

1
如果 今天天气不是沙暴:
2
    对于 当前地点的每一个相邻地点 next_j:
3
        新水 = 当前水 - 2 * 当天耗水
4
        新食物 = 当前食物 - 2 * 当天耗粮
5
        如果 新水 >= 0 且 新食物 >= 0:
6
            dp[下一天][next_j][新水][新食物] = max(dp[下一天][next_j][新水][新食物], 当前金钱)
7
用公式表达：

即有：

\begin{cases} \text{for each } next\_j \in \text{Adjacent}(j): \\ \quad w_{new} = w_{cur} - 2w \\ \quad f_{new} = f_{cur} - 2f \\ \quad \text{if } w_{new} \ge 0 \text{ and } f_{new} \ge 0: \\ \qquad dp[d+1][next\_j][w_{new}][f_{new}] = \max(dp[d+1][next\_j][w_{new}][f_{new}], m_{cur}) \end{cases}

3.3.3 在矿山工作#

**如果当前地点是矿山，旅行者可以选择在矿山工作一天。这种情况下，消耗三倍的水和食物，但金钱数会相应增加。 **

1
如果 当前地点是矿山:
2
    新水 = 当前水 - 3 * 当天耗水
3
    新食物 = 当前食物 - 3 * 当天耗粮
4
    如果 新水 >= 0 且 新食物 >= 0:
5
        dp[下一天][矿山][新水][新食物] = max(dp[下一天][矿山][新水][新食物], 当前金钱 + 矿山收入)

用公式表达：

\begin{cases} w_{new} = w_{cur} - 3w \\ f_{new} = f_{cur} - 3f \\ \text{if } w_{new} \ge 0 \text{ and } f_{new} \ge 0: \\ \quad dp[d+1][j][w_{new}][f_{new}] = \max(dp[d+1][j][w_{new}][f_{new}], m_{cur} + income) \end{cases}

3.3.4 在村庄补给#

如果当前地点是村庄，旅行者可以选择购买水或食物。购买补给不会消耗天数。

1
如果 当前地点是村庄:
2
    // 购买水
3
    新金钱 = 当前金钱 - 买水花费
4
    如果 新金钱 >= 0:
5
        dp[当天][村庄][当前水 + 购买水量][当前食物] = max(dp[当天][村庄][当前水 + 购买水量][当前食物], 新金钱)
6
// 购买食物
7
新金钱 = 当前金钱 - 买食物花费
8
如果 新金钱 >= 0:
9
    dp[当天][村庄][当前水][当前食物 + 购买食物量] = max(dp[当天][村庄][当前水][当前食物 + 购买食物量], 新金钱)

即有：

购买水：

\begin{cases} m_{new} = m_{cur} - cost_w \\ \text{if } m_{new} \ge 0: \\ \quad dp[d][j][w_{cur} + buy\_w][f_{cur}] = \max(dp[d][j][w_{cur} + buy\_w][f_{cur}], m_{new}) \end{cases}

购买食物:

\begin{cases} m_{new} = m_{cur} - cost_f \\ \text{if } m_{new} \ge 0: \\ \quad dp[d][j][w_{cur}][f_{cur} + buy\_f] = \max(dp[d][j][w_{cur}][f_{cur} + buy\_f], m_{new}) \end{cases}

3.3.5 方程总结#

将上述所有情况总结成一个公式：

dp[i][j][k][l] = \begin{cases} C - 5k - 10l, & \text{if } i = 0, j = 1 \\ \max(dp[i][j][k][l], dp[i-1][j][k + w][l + f]), & \text{if } sta[i] \ne 2 \\ \max(dp[i][j][k][l], dp[i-1][x][k + 2w][l + 2f]), & \text{if } sta[i] \ne 2, \forall x \in e[j] \\ \max(dp[i][j][k][l], dp[i-1][j][k + 3w][l + 3f] - CC), & \text{if } j = \text{mine\_id} \\ \max(dp[i][j][k][l], dp[i][j][k-1][l] + 10), & \text{if } j = \text{village\_id} \\ \max(dp[i][j][k][l], dp[i][j][k][l-1] + 20), & \text{if } j = \text{village\_id} \\ -1, & \text{otherwise} \end{cases}

** 其中：**

w = wat[sta[i]], f = fod[sta[i]]，表示当天消耗的水和食物。
e[j] 表示与地点 j 相邻的地点集合。
\text{mine\_id} 和 \text{village\_id} 分别表示矿山和村庄的编号。
CC = 1000，表示在矿山工作的收入。
C=10000表示初始金钱。
该公式中的max操作，表示在满足对应条件的所有可能转移中，取金钱数最大的那个状态。如果所有转移都不合法（例如资源不足），则 dp 值保持为 -1。
该公式中每一项和代码中的chk函数调用一一对应。

3.3.5 代码实现#

1
for (short i = 0; i <= M; i++)
2
{
3
  short st = sta[i + 1], w = wat[sta[i + 1]], f = fod[sta[i + 1]];
4
}

最外层循环从第一天开始模拟，并记录资源基础消耗量。接下来的三层循环，分别遍历在这一天内每个区域可能的决策、这一天内每种剩余水量可能的决策、这一天内每种剩余食物量可能的决策。

对于我们遍历到的这些情况，我们先用 `if (short q = dp[i][j][k][l]; q >= 0 && k * 3 + l * 2 <= N) 和 if (c < 0 || d < 0 || e < 0 || c * 3 + d * 2 > N)` 条件判断对其进行筛选，排除掉不符合题意的情况（如负重过大）。

1
if (x < e)
2
  x = e, fr[a][b][c][d] = {i, j, k, l};

用这个语句选出剩余资金最大的情况：

1
if (j == end_id && q > ans)
2
  ans = max(ans, q), aa = i, bb = j, cc = k, dd = l;

如果已经到达终点，那么将剩余资金数进行比较，找出更优的策略：

1
if (i == M)
2
  continue;

如果已经是最后一天，那么不需要继续模拟沙漠穿越过程：

1
chk(i + 1, j, k - w, l - f, q);

对于停留在原地并不进行任何操作，我们将参数减去资源消耗量后继续：

1
if (st != 2)
2
  for (short x : e[j])
3
    chk(i + 1, x, k - w - w, l - f - f, q);

对于非沙暴天，我们将参数减去两倍资源消耗量后继续：

1
if (j == mine_id)
2
{
3
  chk(i + 1, j, k - w - w - w, l - f - f - f, q + CC);
4
}

如果在矿山，我们可以进行挖矿操作，我们将参数减去三倍资源消耗量并将剩余资金数加上基础收益后继续：

1
if (j == village_id)
2
  chk(i, j, k + 1, l, q - 10), chk(i, j, k, l + 1, q - 20);

如果在村庄，我们可以进行买水、买食物操作，同时因为天数参数 i 并没有加一我们可以保证每一种购买方案均得到考虑，我们将参数减去资金消耗量并加上购买资源量后继续。

完整代码详见 ** final.cpp 。其余代码为答案及详细方案输出，由于与算法无太大关系我们不作赘述。**

4 深度学习#

在已经通过一般编程方法实现该问题后，我们进一步探索该问题的一般情况，即改变题设各参数与图。我们针对具有多场景决策需求的数据（包括村庄、路上、矿山三种场景），提出了一种基于深度学习的多任务决策模型构建方法。不同于传统仅依赖当前时刻数据的模型，我们通过构造滑动窗口（前 5 步和后 5 步，总共 11 步）以捕捉更丰富的时序信息，并引入多头自注意力机制，对窗口内信息进行融合建模。实验结果表明，该方法在决策预测（如资源采购、前进与否、挖矿与否）上具有更高的鲁棒性和准确性。

与近期热门技术深度学习结合，我们不难得到以下思路：

随机生成大量参数；
通过已经完成的一般程序，得到对应结果（即参数-结果对）；
把上述数据喂给模型，训练其解决该类问题；
由此得到经过训练的模型。

我们明确一下模型的任务：

**输入参数：**位置、天气、剩余天数、剩余资金、剩余食物量、剩余水量。
**要求预测：**买水量、买食物量、前进与否、挖矿与否。

我们进行深度学习的目的有：

人类在游戏过程中无法像计算机一样进行精密的计算，我们需要通过分析各个参数对决策影响的趋势，得出普遍性的指导意义。
通过深度学习，推广策略模型到更广泛的情况上。
分析各参数的趋势，深入理解该数学模型的内在影响与关联性。

4.1 模型建立#

在资源采集与行进决策问题中，不同场景下的决策往往依赖于当前状态以及前后时刻的信息，而在实际应用中，前后状态信息往往能够提供更丰富的背景和趋势信息。为此，我们提出一种基于滑动窗口和多头自注意力机制的模型架构，并针对不同场景（村庄、路上、矿山）设计了专用决策模型：

村庄场景：预测买水量、买食物量（回归任务）以及是否前进（分类任务）。
路上场景：仅预测是否前进（分类任务）。
矿山场景：同时预测是否前进和是否挖矿（均为分类任务）。

4.2 输入数据的生成#

为简化问题，我们不妨规定和题设一样的条件，即：起点位于 1，终点位于 27，村庄位于 15，矿山位于 12。此外，每天的天气状况也与题设保持一致。为了使生成数据覆盖尽可能多的情况，我们使用随机方法来生成不同的图。然而，并非任意生成的图都能满足较好机器学习的条件。具体地，我们需要保证在起点、终点、村庄、矿山任意两点之间都有一条通路，这样才能有效地对神经网络进行训练。

此外，我们还需讨论生成数据的规模。对于数据范围，我们需要确保节点数在 27 个以内。这是由于程序内存本身的限制，更是考虑到真正有效的关键节点仅有起点、终点、村庄、矿山四处。其他节点均为过程节点，无法进行丰富的操作。对于数据数量，也并非多多益善。仅在 27 个点之间生成合理的图无法形成无穷多种情况，如果数据数量过多，则会造成过拟合的情况，过犹不及。最终，我们决定生成 30000 张图，共约 740000 条决策记录。

4.3 生成输出结果#

我们使用前几节中完成的代码计算最优结果。为了输出结构化数据，我们需要对输出格式稍加修改。我们选择使用 csv 格式[3]储存大量数据，这是一种被推荐的数据格式。为了提供上文所述的详细信息，我们需要根据规则计算出买水量、买食物量、前进与否、挖矿与否。

接着，我们使用 Python 多线程调用程序运行结果以生成输出。最后，我们将零散的 csv 输出进行合并。最终，我们得到的 csv 数据集的格式示例如下：

数据存储于 csv 文件中，格式示例如下：

1
位置,天气,剩余天数,剩余资金,剩余食物量,剩余水量,买水量,买食物量,前进与否,挖矿与否
2
路上,高温,30,6335,250,233,8,6,0,0
3
矿山,高温,29,6335,238,217,9,7,1,0
4
矿山,高温,28,7335,220,193,9,7,0,1
5
晴朗,高温,27,8335,199,178,9,7,0,1
6
...

4.4 模型训练#

4.4.1 特征分类#

我们需要对以下预测值进行分类：

类别特征：（位置、天气）使用 One-Hot编码。
数值特征：（剩余天数、剩余资金、剩余食物量、剩余水量）经过标准化处理。
将类别和数值特征拼接，形成最终的输入矩阵。

4.4.2 滑动窗口#

不仅如此，为充分利用时序信息，我们还需设计滑动窗口构造函数。对于每个数据样本：

提取前 5 步与后 5 步共 11 步的信息；
对于边界不足部分，采用边缘复制策略；
**生成的窗口数据形状为 **(11, d)，其中 d 为特征维度。

4.4.3 注意力子网络#

为了有效整合窗口内的上下文信息，本文在基础网络中引入了多头自注意力层。该层能够对窗口内所有时刻的信息进行建模，并通过残差连接和层归一化得到鲁棒的特征表示，最终提取当前时刻（窗口中间）的特征作为预测依据。

由于我们具有三种不同时态的特征预测模式，即“村庄模型”“路上模型”和“矿山模型”。

数据解基于注意力骨干网络，设计不同场景的决策模型：

村庄模型：输出包含回归分支（买水量、买食物量）与分类分支（是否前进）。
路上模型：仅输出前进与否（二分类）。
矿山模型：同时输出前进与否与挖矿与否（二分类）。

最后，我们基于预处理和滑动窗口数据，对三个场景分别构造训练集与验证集。训练过程中利用 GPU 加速，并保存训练好的模型。

此外，我们还对训练结果进行了测试，达到的效果非常可观：

1
276/276 ━━━━━━━━━━━━━━━━━━━━ 2s 3ms/step - buy_food_loss: 4.4697 - buy_water_loss: 1.3148 - loss: 5.7847 - move_forward_loss: 5.0175e-10
2
Village Model Test Loss: [6.1254167556762695, 1.2825570106506348, 4.82736873626709, 5.117979817725882e-09]
3
1046/1046 ━━━━━━━━━━━━━━━━━━━━ 3s 3ms/step - loss: 5.9283e-05
4
Road Model Test Loss: 6.833732913946733e-05
5
3316/3316 ━━━━━━━━━━━━━━━━━━━━ 10s 3ms/step - loss: 3.6904e-04 - mine_loss: 1.8531e-04 - move_forward_loss: 1.8373e-04
6
Mine Model Test Loss: [0.00018224114319309592, 9.079145092982799e-05, 9.143214992946014e-05]

5 数据解释#

在成功训练完上述模型后，我们尝试导出其中的模型层参量，并且通过绘制图表，来展示相关参数对最终决策的影响。

我们另外创建了一份用于绘制图表的代码。在份代码中，我们使用 Python 的相关扩展库来展示如何直观地理解神经网络模型的预测行为。具体来说，我们构造了一个“滑动窗口”数据结构，即由多个相同数据行组成的矩阵，其中某一行（位于窗口的中心）会依次改变一个特定的数值特征。通过这种方法，我们可以观察到随着该特征取值的变化，模型预测结果（例如买水量、是否前进等）的变化趋势。整体思路类似于数学中讨论函数图像如何随自变量变化而变化，能够让我们直观地看到输入参数对函数输出的影响。这样的可视化不仅帮助我们验证模型的稳定性，也使复杂的深度学习模型变得更加透明和易于理解。

5.1 村庄模型#

村庄模型阐述的是：当玩家在村庄时，进行购买行为的决策。

5.1.1 剩余天数的影响#

由图表可以看出：

当剩余天数在一半日程（即 15天）之前，买水的行为一直保持较高水平，且还在小范围升高；但是时间一来到后 15天，购买水的行为急剧下降。这可能是因为挖矿者在前期需要做好充足的准备，而在后期进行“冲刺”，无需买水。
对于买食物，不难发现，在游戏前期该需求较低，直到接近第 15天时，该需求上升至顶点，在后期下降并保持一定的水这当然也可能与村庄的位置有关，因为村庄大约出现在路程的中途处。

5.1.2 剩余资金的影响#

由图表可以看出：

当剩余资金充足时，购买水的行为呈现下降趋势，表明玩家更倾向于提前储备水资源以应对长途消耗。但当资金短缺时，购买量却上升，可能因为此时资金需优先用于应急物资。
对于购买食物，图表显示出了类似的趋势，但是总体购买行为比水稍弱些。这说明了水可能在游戏中发挥了更为重要的作用。

5.1.3 剩余食物的影响#

由图表可以看出：

当剩余食物充足时，购买水的量先增加后减少，呈现出一种储备行为。但在食物短缺时，购买水的量持续增加，表明在食物不足的紧急情况下，玩家依然会选择购买水，说明水的重要性。
当剩余食物充足时，购买食物的量迅速增加并达到饱和。而在食物短缺时，购买食物的量很低，说明玩家在食物极度缺乏时会优先考虑其他策略，而非购买食物。
** 随着剩余食物的减少, 前进的概率逐步下降, 当食物极度缺乏时, 前进的概率接近于0。但这其实是因为食物不足无法前进了（规则限制）。**

综合来看，该图表揭示了一个生存策略：在资源充足时，玩家倾向于平衡购买水和食物，并积极前进。但在资源匮乏时，水的优先级高于食物，且玩家会减少前进以保存资源。这是因为在游戏设定中，缺水比缺食物更加致命，而停止前进可以减少消耗。

5.1.4 剩余水量的影响#

由图表可以看出：

当剩余水量充足时，购买水的量迅速增加并趋于稳定。但在剩余水量短缺时，购买水的量接近于0，说明在极度缺水的情况下，玩家可能没有资源购买水，或者优先考虑其他生存策略。
当剩余水量非常充足的时候，玩家倾向于不买食物，说明食物的优先级比较低。只有当剩余水量减少到一个阈值以下时，玩家才开始大量购买食物。这可能是因为食物可以用来回复体力。
随着剩余水量的减少，前进的概率逐步下降。当剩余水量极度缺乏时，前进的概率接近于0。这与之前的图表结论一致，即缺水会严重限制玩家的前进。

5.2 路上模型#

路上模型阐述的是玩家在路上时是否要前进的决策。

5.2.1 剩余食物的影响#

由图表可以看出：

整体趋势： 前进概率随着剩余食物的增加先快速上升，然后趋于平稳，最后略有下降。呈现一个倒U型。
上升阶段（食物匮乏）： 当剩余食物非常少时，前进概率随食物增加而迅速增加。这表明在食物极度缺乏的情况下，少量食物的增加对产出有显著的正面影响。
平稳阶段（食物充足）： 当剩余食物量处于中间范围时，前进概率基本保持稳定，并达到最大值。说明食物供应充足保障了产出。
下降阶段（食物过剩）： 当剩余食物非常多时，前进概率略有下降。

5.2.2 剩余水量的影响#

由图表可以看出：

整体趋势： 当剩余水量较少时，前进概率维持在一个很高的恒定值。但随着剩余水量增加，产出呈现阶梯式下降。
**恒定高产出区：**当剩余水量较少时，玩家会保持前进。
阶梯式下降： 随着剩余水量增加，前进概率出现几次明显的下降。每次下降都形成一个平台期, 说明达到某些特定的水量阈值后, 前进的概率会降低。

5.3 矿山模型#

矿山模型阐释的是，当玩家在矿山时，到底要停留下来挖矿还是继续前进的决策。

5.3.1 剩余天数的影响#

由图表可以看出：

U型曲线： 前进的概率随着剩余天数的变化呈现一个U型曲线。在剩余天数非常多或者非常少的时候，前进的概率都较高；而在剩余天数处于中间值时，前进的概率最低。
时间充裕阶段： 当剩余天数非常多时（图表左侧），前进概率较高。这可能表明在时间充裕的情况下，玩家更倾向于探索或前往下一个目标。
时间紧迫阶段： 当剩余天数非常少时（图表右侧），前进概率也较高。这说明在时间紧迫的情况下，玩家被迫前进以完成目标。
中间阶段：在游戏时间中期，玩家有充足的时间，可以选择暂时不前进。

5.3.2 剩余资金的影响#

由上图可以看出：

当剩余资金非常少时，前进概率迅速下降并接近于0。资金充足时，玩家有概率前进。
当剩余资金非常少时，采矿概率迅速增加并接近于1。资金充足时，玩家几乎必定采矿。

6 问题解答#

6.1 方案表#

日期	所在区域	剩余资金数	剩余水量	剩余食物量
0	1	5780	178	333
1	25	5780	162	321
2	24	5780	146	309
3	23	5780	136	295
4	23	5780	126	285
5	22	5780	116	271
6	9	5780	100	259
7	9	5780	90	249
8	15	4150	243	235
9	14	4150	227	223
10	12	4150	211	211
11	12	5150	181	181
12	12	6150	157	163
13	12	7150	142	142
14	12	8150	118	124
15	12	9150	94	106
16	12	10150	70	88
17	12	10150	60	78
18	12	10150	50	68
19	12	11150	26	50
20	14	11150	10	38
21	15	10470	36	40
22	9	10470	26	26
23	21	10470	16	12
24	27	10470	0	0
25	27	10470	0	0
26	27	10470	0	0
27	27	10470	0	0
28	27	10470	0	0
29	27	10470	0	0
30	27	10470	0	0

6.2 一般策略#

6.2.1 核心原则#

水 > 食物： 优先保证水的充足。
时间管理： 早期、晚期多前进，中期看情况。
资金 = 水 > 食物, 用于挖矿: 资金主要用于水和食物，在矿山尽量挖矿。

6.2.2 策略要点#

早期（>15天）： 前进，村庄多买水，少量食物。
中期（≈15天）： 村庄补给，食物需求增加，保持水储备，有矿就挖。
后期（<15天）： 冲刺，少买东西，控资源，时间紧就别挖矿。
路上： 食物/水充足可前进，极度缺乏则停止。
村庄: 根据资源情况补给。
矿山： 时间多/钱少就挖，时间少/钱多就走。

7 反思#

动态规划和深度学习在解决沙漠穿越问题时展现出不同的优势和局限。动态规划能够求得严格的最优解，并且不需要进行训练，但它容易遭遇维度灾难，扩展性较差，同时高度依赖完整的先验信息。这使得动态规划更适合于那些参数稳定、场景相对简单的任务。

相比之下，深度学习展现出更强的泛化能力，可以进行实时决策，并且能够处理变量之间复杂的非线性关系。然而，深度学习存在陷入局部最优解的风险，需要大量的训练数据，并且模型的可解释性相对较弱。因此，深度学习更适用于那些环境复杂、动态变化且需要快速做出适应性决策的场景。未来的研究方向包括结合两种方法的优点，例如混合策略、模型轻量化、动态地图优化以及引入灾害预警机制，从而为复杂的路径规划问题提供更全面和高效的解决方案。

8 引用#

**[1] **图论：Dijkstra算法——最详细的分析，图文并茂，一次看懂！-CSDN博客

**[2] **Reinforcement Learning-based Heuristics to Guide Domain-Independent Dynamic Programming

**[3] **Mapping Large Scale Research Metadata to Linked Data: A Performance Comparison of HBase, CSV and XML

9 鸣谢#

感谢人工智能实验室的服务器为我们提供计算资源。

服务器系列课程

Sat, 22 Feb 2025 00:00:00 GMT

第壹节初识服务器：选购、安装与配置#

1. 背景#

社团的 3d 打印机经常要用U盘拷贝文件，不能通过网络传输，十分麻烦；加之社团的电脑本来就不多，经常有人多机少的情况。于是乎，搭建一台服务器似乎很有必要了。

1.1 服务器市场概况#

市场规模：
- 全球服务器市场规模持续增长（2023年约1,500亿美元），云计算、AI和大数据是主要驱动力。
- **中国服务器市场占全球25%以上，**华为、浪潮、新华三等国产厂商份额持续扩大。
技术趋势：
- 云化：公有云服务商（如AWS、阿里云）大量采用定制化服务器。
- 边缘计算：小型化、低功耗服务器需求增长（用于物联网、智能工厂等场景）。
- 绿色节能：液冷技术、模块化设计成为热点，降低数据中心能耗。

1.2 主流服务器分类#

按应用场景：
- 通用服务器：适用于Web服务、数据库等常规业务（如Dell PowerEdge、HPE ProLiant）。
- 高性能计算（HPC）服务器：用于科学计算、AI训练（配备多GPU/TPU）。
- 存储服务器：大容量硬盘+高IOPS设计（如NAS、分布式存储节点）。
按硬件架构：
- x86架构：主流选择（Intel Xeon、AMD EPYC），生态成熟，兼容性强。
- ARM架构：低功耗优势突出（如Ampere Altra），逐步渗透云计算领域。
- 国产化平台：飞腾、鲲鹏等国产CPU服务器，满足信创需求。

1.3 主要厂商与竞争格局#

国际品牌：Dell、HPE、联想（ThinkSystem系列）占据中高端市场。
国内品牌：浪潮（NF系列）、华为（FusionServer）、新华三（UniServer）快速崛起。
白牌服务器：ODM厂商（如广达、纬创）为云计算巨头提供定制化方案，成本更低。

2. 选购#

2.0 需求分析的一般办法#

明确应用场景：
- Web服务器？数据库？虚拟化平台？AI训练？
预估负载类型：
- CPU密集型（如科学计算）vs. IO密集型（如文件存储）。
确定扩展性需求：
- 是否需要未来升级CPU、内存或存储？
预算与合规性：
- 是否受信创政策限制（需国产化硬件）？

2.0.1 关键配置选择指南#

（1）服务器类型选择#

类型	适用场景	优点	缺点
塔式服务器	小微企业、轻量级应用	静音、易部署	扩展性有限
机架式服务器	数据中心、企业级业务	高密度、易管理	需专用机柜
刀片服务器	大规模虚拟化、云计算集群	超高密度、共享电源	初始成本高

（2）CPU选型#

核数与频率：
- Web服务器：8-16核，主频≥2.5GHz（如Intel Xeon Silver 4310）。
- 数据库/虚拟化：16-32核，支持多线程（如AMD EPYC 7543）。
特殊需求：
- AI训练：需搭配GPU（NVIDIA A100/A800）或专用AI加速卡。

（3）内存与存储#

内存容量：
- 基础应用：32-64GB DDR4 ECC。
- 大数据分析：≥256GB，支持LRDIMM内存扩展。
存储方案：
- HDD：大容量冷数据存储（如8TB SATA）。
- SSD/NVMe：高性能热数据（如Intel P5510 3.84TB U.2 SSD）。

（4）网络与冗余#

网卡配置：
- 默认1Gbps，高并发场景需10G/25G网卡（如Mellanox ConnectX-6）。
冗余设计：
- 双电源（如550W×2）、RAID卡（支持RAID 5/6）、热插拔硬盘。

2.0.2 典型配置示例#

中小型Web服务器：
- CPU：Intel Xeon E-2378（8核/16线程）
- 内存：64GB DDR4
- 存储：2×1TB NVMe SSD（RAID 1）
- 网络：双千兆网口
企业级虚拟化平台：
- CPU：2×AMD EPYC 7713（64核/128线程）
- 内存：512GB DDR4
- 存储：8×3.84TB NVMe SSD + 12×8TB HDD（混合存储池）
- 冗余：双电源+硬件RAID卡

2.1 准系统#

**这次选取的是 **戴尔 PowerEdge R730xd 。选取原因有三：

市场存量多，货源充足，性价比高；
使用人数多，网上教程丰富，小白友好；
可扩展性强。

**在某网店选购 **R730XD准系统+H730卡+单750W电源 ，价格仅需 ¥699 ，实属物美价廉。

2.2 CPU#

**网上相关教程推荐的U有很多，但性能较好的还看 **E5-2680V4 E5-2690V4 。

但其实一对比，E5-2680V4价格便宜了很多，性能也不算很差，所以最终选择了 E5-2680V4 。由于预算有限，只买一颗（最多能装两颗）。

2.3 内存条#

理论上，内存条是 8G×4 8G \times 48G×4 能跑出更好的性能，但这样的方案显然更加昂贵。这次先一次性买了一条 三星 32G 4DR*4 2133P，只要¥139。等以后再升级吧。

2.4 硬盘#

由于社团里有老电脑的硬盘，这里就买一块杂牌的sata硬盘测试一下。480G 480G480G 杂牌 sata ，只要139元。值得注意的是，启动盘必须是 sata 接口，m2 接口的只能作为副盘使用，不能作为系统启动盘（当然，曲线救国之路就是拿个u盘引导）。

2.5 小计#

这样算下来，一套基础版大概需要 1000r 左右：

2024-10-09 23.30.06.png

3. 硬件安装过程#

3.1 开箱#

按下按钮，掀开后盖，可以看到内部构造。

3.2 换 CPU#

原来厂家发过来的时候已经随附了两颗 E5-2650 V3 ，但我们自己买了另外的CPU，需要拆除原来的CPU。两个都要拆，CPU不能混用。

按照官方教程，先选择一颗螺丝转下来，等待30s自己会松掉；然后再卸下对角线的那颗螺丝，就能成功拆除散热器了。

这是拆完散热器以后的样子：

拆下来的散热器：

接下来取出cpu：按下两边的弹簧开关，将金属结构弹出，就能拿出CPU了。

然后放上我们自己买的cpu，按刚才相反的步骤，即可装入。

值得注意的是，先应将下方的卡扣抬起，再放下另一边的金属片，否则是盖不上的。

请一定不要使用蛮力，否则可能会损坏服务器！

如果您只装了一颗U，而另一个位置上仍有另一颗不同型号的U，那么服务器开机自检是无法通过的。

3.3 上内存#

如果厂家是帮您预装好的，那么直接装在默认位置就行；如果需要自己安装，可能有以下两种情况：

按照整流罩上标的顺序，放在一号内存槽位；
直接插在离cpu最近的那个槽位。

上面两种情况试一试即可，如果不正确可能会导致无法开机。

3.4 装硬盘#

这款服务器一共有14个盘位。

后方一共是 3×4=12 3\times 4=123×4=12 个 3.5 寸盘位，前面还有 2 22 个 2.5 寸的。

直接一块硬盘我们是无法直接装到服务器上的，需要先给它固定到硬盘架上，然后再将硬盘架安装进盘位中。

如图是 3.5 寸硬盘架，它是兼容 2.5 寸的硬盘的。直接将硬盘放入硬盘架中，对准螺丝孔并上螺丝即可。硬盘架可能需要另外购买，价格在 6～6.9 人民币左右，可能还要 ¥5 的运费。

如果您还想要安装 M.2 接口的固态硬盘（类似于下图），您还需要购买一块 M.2 转 PCIe 卡（首单 ¥5 便宜！），然后安装到服务器上为数不多的三个 PCIe 插槽上。

4. 系统的选取与安装#

本文只介绍虚拟化的系统方案。主流的有两种系统方案：一是 PVE 虚拟化，二是 VMware vSphere 虚拟化。这两种方式都是在底层进行硬件互联，运行多系统时的资源损失较小。下面是这两种方案的比较：

对比项目	PVE	VMware ESXi
成本	开源免费，适合预算有限的小型企业和个人用户，可免费使用全部功能，但付费可获得技术支持服务等。	基本版本免费，但高级功能如高可用性的 HA、负载均衡等需付费购买 vmware vsphere 获得。
技术基础	基于 Debian Linux 发行版，支持 KVM 全虚拟化和 LXC 轻量级容器两种虚拟化技术。	基于 VMware 的专有架构，是直接安装在物理服务器硬件之上的裸金属型 hypervisor，主要使用全虚拟化技术。
用户界面	提供基于 Web 的图形用户界面，同时支持命令行界面，界面相对简洁直观，对于有 Linux 基础的用户来说较易上手，但对新手而言，部分操作需使用命令行，有一定学习成本。	通过 vSphere Client 或 vCenter Server 进行管理，提供了丰富直观的图形用户界面，与 VMware 的其他产品紧密集成，管理体验高效，易于新手入门。
性能和资源利用	支持 LXC 容器，在资源利用方面更加高效，特别是处理 I/O 密集型任务时表现较好，用户能够对虚拟机实施详细的资源控制和配额，确保每个应用获取所需资源。	其性能优势来自于为虚拟化特制的内核，能更高效地管理和分配资源，资源调度和动态迁移技术进一步优化了虚拟机的性能和资源利用率，在硬盘和网络 I/O 等方面表现出色。
管理和扩展	通过 Web 界面管理，可使用 Proxmox VE Cluster 进行集群扩展，管理相对灵活，扩展性强，适合有一定技术能力和对定制化有需求的用户。	通常与 vCenter Server 结合使用，可轻松实现大规模的虚拟化管理和自动化，更适合企业级的大规模部署和管理，但对技术人员的专业要求较高。
社区和支持	拥有活跃的开源社区，用户可获得广泛的帮助和支持，社区资源丰富，更新速度快，但对于一些复杂问题的解决可能需要用户自身具备一定的技术能力。	依托 VMware 的品牌和庞大的技术支持团队，能够获得专业的技术支持服务，对于企业级用户来说，在遇到问题时可获得更及时有效的解决方案。
安全性	基于 Linux 内核，具有良好的安全特性，但需要用户自己负责及时更新和维护系统以确保安全性。	经过严格的安全测试和优化，提供了企业级的安全保障，内置的安全功能如 vShield 和 NSX 等强化了虚拟化环境的安全性。
硬件兼容性	硬件兼容性优秀，对多种硬件设备的支持较好，尤其是对 Realtek 网卡等设备的兼容性优于 ESXi。	硬件兼容性相对较差，主要面向服务器硬件，对一些常见的桌面级或消费级硬件设备的支持可能存在不足，但对主流服务器硬件及 Intel 网卡等兼容性良好。
高级功能	提供如实时迁移、快照等高级功能，但不如 ESXi 的功能全面。	拥有广泛的企业级高级功能，如 VMotion、DRS、HA 等，可实现虚拟机的动态迁移、资源的智能调度和高可用性保障等。

由于考虑到 VMware ESXi 比较商业化，功能较为完善，而且对我们的 R730xd 有专门的适配，所以这里我们选择 VMware 的虚拟化。

笔者这里使用的 raid 方案是一块 raid0 装系统，其他盘作数据盘。

4.1 设立 VD 和 RAID 模式#

4.1.1 磁盘阵列（RAID）是什么？#

磁盘阵列（Redundant Arrays of Independent Disks，RAID）是一种将多个独立的磁盘组合成一个逻辑磁盘的技术。通过特定的算法，把数据分散存储在多个磁盘上，从而提升存储系统的性能、可靠性和数据安全性。

常见的磁盘阵列级别包括：

RAID 0：数据被分割成块并分布在多个磁盘上，没有冗余信息。它能提高读写性能，但一个磁盘损坏就会导致数据丢失。
RAID 1：数据在两个或更多磁盘上进行镜像。写入数据时，会同时写入到多个镜像磁盘中。这种方式可靠性高，一块磁盘损坏，数据可从镜像磁盘获取，但磁盘利用率低。
RAID 5：数据和奇偶校验信息分布在多个磁盘上。通过奇偶校验信息，可以在一个磁盘损坏的情况下恢复数据，兼顾了存储性能、数据安全和存储成本等因素。
RAID 6：与RAID 5类似，但有两份独立的奇偶校验信息，能允许两块磁盘同时损坏而不丢失数据。
RAID 10：是RAID 0和RAID 1的组合，先做镜像再做条带化，具有高性能和高可靠性。

4.1.2 磁盘阵列的重要性#

提高数据存储性能 在RAID 0等模式下，通过并行读写多个磁盘，可以显著提高数据的读写速度。对于需要处理大量数据的服务器和存储系统，如数据库服务器、视频编辑工作站等，磁盘阵列能够加快数据的访问速度，从而提高整个系统的工作效率。
增强数据安全性和可靠性 在RAID 1、RAID 5、RAID 6等具有冗余功能的模式下，即使磁盘出现故障，数据仍然可以通过冗余信息进行恢复。这对于企业级的数据存储至关重要，可避免因磁盘故障导致的数据丢失，保护企业的核心数据资产，减少因数据丢失带来的损失和业务中断风险。
便于数据管理和扩展 磁盘阵列可以作为一个统一的逻辑存储单元进行管理，方便管理员进行存储容量的分配和调整。同时，通过添加新的磁盘，可以相对容易地扩展存储容量，满足企业不断增长的数据存储需求。

4.1.3 建立磁盘阵列#

开机以后等待以下界面，当看到 Press <Ctrl><R> to Run ... 时，按下 Ctrl+R ，进入 H730/H330 MiniBIOS ，设置磁盘阵列。

进入 minibios 后，使用 ⬆️/⬇️ 键将高亮移动到最顶端的你的阵列卡的条目（字样：H310、H730等）。然后再按下 F2 。

在弹出的菜单中，移动高亮至 Create New VD ，按下 Enter 。

因为我们这里只有一块盘的话，我们就只能选择 RAID 0 。

按 Tab 以切换到下一个条目。当在选择右侧硬盘时，按下空格键以选中/取消选择。VD Size 保持默认，VD Name 自己随便取，比如笔者这里可以取了叫做 System 。然后 OK ，退出后会自动重启。

这里是组了一块 raid ，然后通过虚拟磁盘的方式传给上层系统使用。当然，也可以组完 raid 后直通给系统使用，这样效率更高。

4.1.4 在图形化界面中设置 raid1#

上面我们的系统盘设置的是 raid0 ，但对于数据盘来说，我们有充裕的机械硬盘，而且数据盘是给网盘使用，不能够丢失数据，因此我们至少需要组建 raid1 。

示例图片里是 raid5 ，但其实组 raid1 是一样的，一个是三块盘，一个是两块盘。

4.2 使用 u 盘安装 vmware esxi#

这里我们使用简单易用的 Ventoy 。当然，您也可以根据您的喜好选择其他程序来安装。这里介绍使用 Ventoy 的安装方法。

首先，到 https://github.com/ventoy/Ventoy/releases/ 找到并下载最新的程序。

直接选择你的U盘，然后点击“安装”。安装完后你的优盘名称会变成“Ventoy”字样，是空的。直接把你想安装的 ESXi 镜像拖进去就行了。

这里安装的是 8.0.0 版本。

插上 U 盘，进 iDrac 可以图形化安装。

镜像安装成功后，按照指引重启系统，然后进入 ESXi 设置。

4.3 安装 Ubuntu24.04 （现场演示）#

进入 ESXi 网页管理页面，我们点击 “创建/注册虚拟机”。

这里可以配置 CPU 核心数、分配的内存和硬盘空间大小。注意，硬盘选项要选择“薄置备”，这样才不会一次占用太多空间。

上面的步骤完成后直接点击小企鹅上的播放按钮。如果启动失败的可以按照下图检查一下引导选项。

打开自带的控制台，按 Enter 选中“安装 Ubuntu Server”。

然后会开始跑代码，稍等一下即可。

选择语言，没有中文。使用英语。

不要更新，否则会很慢。

这里根据自己的情况配置网络环境。

自己选择源，中科大源应该是比较快的。

学校里用不了 Ubuntu pro。但它其实是免费的。

这里提示 FAILED ，其实不用担心，直接重启就好了，无事发生。

重启后登录，我们就能进入一个 Ubuntu Server 了。

你还可以选择安装 1Panel，这样就能方便地管理服务器了。

4.4 安装飞牛NAS#

系统基础信息#

开发基础：基于Linux内核（Debian发行版）开发，稳定性和安全性高，可扩展性与自由度强。
硬件兼容性：兼容主流X86架构设备，可利用闲置硬件如PC、软路由、NUC等搭建私有云存储。

功能特性#

存储管理#

硬盘信息展示：全面展示硬盘类型、时长、健康、接口协议、温度等，可查看S.M.A.R.T信息。
存储模式：创建空间时依硬盘数量自动切换模式，展示容量、优缺点。系统盘和数据盘独立管理，系统盘只能单独组basic。
RAID管理：支持换盘、设热备盘、改模式、扩容。能自动重组raid、自动替换热备盘，可升级RAID等级，RAID5以上可直接扩容。

文件管理#

一个页面管理内、外、远程文件，操作简易。

智能影视#

飞牛影视应用支持App远程下载解析种子，自动刮削成海报墙，电影准确率高，自动下载字幕，兼容主流硬件转码，多端同步，支持蓝光杜比，TV版未完全上线。

照片备份#

飞牛私有云App相册备份功能可将手机照片备份到NAS，支持原画、实况、RAW格式。

远程访问#

有公网IP直连、FN Connect、DDNS域名转发、P2P等多种方式。

应用中心#

常用应用全，支持Docker，可按需安装应用扩展功能。

系统优势#

界面友好：扁平化设计，类似macOS，人机交互合理，美观适合国人，有引导和手册，新手易上手。
免费使用：个人用户免费，降低成本。

目前公测阶段，存在RAID模式有限、共享功能不足等问题，持续更新改进后有望提升体验。

在此处可以看到下载地址：飞牛私有云 fnOS

94ecca0fe377e3f8f598478d75a303a2.png

f4f39eab935c55da5035a04b59eff7b6.png

682b0aba4e55001f58a980dcea225f7b.png

157b3e987307ee5be4d29358b90e965f.png

f6781c73950afd3db2f02f0b2e0f6ca2.png

00cddddd75c6c3d8e1bf21dc197fec9e.png

3794fb26400424daa6147e88317e9ba8.png

69eef747ba552ca20c9d612bc6530f2b.png

1d569e288854c78fa4fb4e5edd92824c.png

d8828418a8a33c412e59917bbbc56ac2.png

30288505acd2bbfe4405ca479841db93.png

8f865ce2f962da02eb1dc77bd93f6e67.png

5. 课后思考题#

夯实基础#

假设你需要为一家视频渲染公司选购服务器，需支持10个4K视频同时渲染，请列出关键配置要求。
国产化服务器在哪些场景下具备优势？可能存在哪些挑战？

拓展提升#

ESXi虚拟化环境中的Ubuntu部署#

场景：某企业需要在VMware ESXi 7.0虚拟化平台上部署一台Ubuntu 22.04 LTS服务器，用于运行Python数据分析服务。 任务要求：

虚拟机配置规划：
- 需要分配多少vCPU和内存？若物理服务器为双路CPU（共32核/64线程），如何避免vCPU超分导致的性能瓶颈？
- 存储应选择“厚置备延迟置零”还是“精简置备”？为什么？
安装过程关键点：
- 安装时需特别注意哪些虚拟硬件兼容性设置（如SCSI控制器类型、网卡驱动）？
- 为何推荐在Ubuntu中安装open-vm-tools而非ISO镜像自带的VMware Tools？
网络优化：
- 若Ubuntu需通过NAT模式访问外网，ESXi侧的虚拟交换机（vSwitch）应如何配置？
- 如何验证虚拟机与宿主机之间的网络延迟是否正常？

物理服务器上ESXi的安装挑战#

场景：一台新采购的Dell PowerEdge R760服务器（Intel Xeon Gold 6430 ×2，512GB DDR5，8×3.84TB NVMe SSD），需直接安装ESXi 8.0作为虚拟化基础平台。 任务要求：

安装前准备：
- 如何通过Dell iDRAC远程控制台完成RAID配置（如RAID 10）？需注意哪些SSD固件兼容性问题？
- 为什么必须验证该服务器是否在VMware HCL（硬件兼容性列表）中？若不在列表如何解决？
安装过程问题排查：
- 安装时提示“No Network Adapters Found”，可能的原因是什么？（提示：考虑网卡驱动未内置）
- 如何通过ESXi命令行（如通过Live CD）手动注入自定义网卡驱动？
基础配置验证：
- 安装完成后，如何通过ESXi Shell检查NVMe硬盘的PCIe链路速率是否正常？
- 若需通过vCenter集中管理，ESXi主机应启用哪些网络端口和防火墙规则？

延伸讨论#

若企业要求国产化替代，将ESXi替换为华为FusionSphere或OpenEuler虚拟化平台，上述问题中的哪些步骤会发生重大变化？

第贰节善用命令行：初探 Linux 终端操作#

1. 什么是 Linux 终端#

在 Linux 系统中，终端就像是你和计算机交流的 “秘密通道”。你可以通过输入特定的命令，让计算机完成各种任务，比如查看文件、创建文件夹、安装软件等等。Ubuntu 24.04 server 是一种常用的 Linux 服务器版本，我们就以它为例来学习终端操作。

2. 打开终端#

在 Ubuntu 24.04 server 中，一般通过 SSH 连接来打开终端。如果你是在本地虚拟机中安装的 Ubuntu，可以在应用程序列表中找到 “终端” 图标点击打开。

例如，在 Windows 下，您可以直接打开 cmd ，运行：

Terminal window

1
ssh jks@172.28.1.11

默认是 222222 端口。

3. 基本命令#

3.1 文件和目录操作#

查看当前目录：pwd（print working directory）
- 作用：显示当前所在的目录路径。
- 示例：在终端输入pwd，会输出类似/home/user的路径，表示当前在user用户的主目录下。
列出目录内容：ls（list）
- 作用：列出当前目录下的文件和子目录。
- 示例：
- 直接输入ls，会显示当前目录下的文件和目录的简略信息。
- 输入ls -l，会以长格式显示详细信息，包括文件权限、所有者、大小、修改时间等。
- 输入ls -a，会显示所有文件和目录，包括隐藏文件（以点开头的文件）。
切换目录：cd（change directory）
- 作用：切换到指定的目录。
- 示例：
- cd /home：切换到/home目录。
- cd ..：返回上一级目录。
- cd ~：回到当前用户的主目录。
创建目录：mkdir（make directory）
- 作用：创建一个新的目录。
- 示例：mkdir new_folder，在当前目录下创建一个名为new_folder的新文件夹。
删除目录：rmdir（remove directory）
- 作用：删除一个空目录。
- 示例：rmdir old_folder，删除名为old_folder的空文件夹，如果文件夹不为空则无法删除。
创建文件：touch
- 作用：创建一个新的空文件，或者更新文件的时间戳。
- 示例：touch new_file.txt，在当前目录下创建一个名为new_file.txt的空文件。
删除文件：rm（remove）
- 作用：删除文件或目录（删除目录时需加-r选项）。
- 示例：
- rm file.txt：删除名为file.txt的文件。
- rm -r folder：删除名为folder的目录及其所有内容，使用时要谨慎，因为删除后文件很难恢复。
复制文件和目录：cp（copy）
- 作用：复制文件或目录。
- 示例：
- cp file.txt new_file.txt：将file.txt复制为new_file.txt。
- cp -r folder new_folder：将folder目录及其所有内容复制为new_folder。
移动文件和目录（重命名）：mv（move）
- 作用：移动文件或目录到指定位置，也可用于重命名。
- 示例：
- mv file.txt /new_path/：将file.txt移动到/new_path/目录下。
- mv old_name new_name：将文件或目录old_name重命名为new_name。

3.2 文件内容查看#

查看文件内容：cat（concatenate）
- 作用：显示文件的全部内容，适合查看较小的文件。
- 示例：cat file.txt，显示file.txt的内容。
分页查看文件内容：more
- 作用：分页显示文件内容，按空格键向下翻页，按q键退出。
- 示例：more large_file.txt，用于查看较大的文件，避免内容一次性全部输出导致屏幕混乱。
实时查看文件内容更新：tail
- 作用：显示文件的末尾几行内容，默认显示 10 行，可通过选项指定行数。加上-f选项后可以实时跟踪文件的更新。
- 示例：
- tail file.txt：显示file.txt的末尾 10 行。
- tail -20 file.txt：显示file.txt的末尾 20 行。
- tail -f log.txt：实时查看log.txt文件的更新，常用于查看日志文件。

3.3 文件搜索#

查找文件：find
- 作用：在指定目录及其子目录中查找文件。
- 示例：
- find /home -name "*.txt"：在/home目录及其子目录中查找所有扩展名为.txt的文件。
- find / -size +10M：在整个系统中查找大小大于 10MB 的文件。
搜索文件内容：grep（global search regular expression and print out the line）
- 作用：在文件中搜索指定的字符串，并显示包含该字符串的行。
- 示例：grep "error" log.txt：在log.txt文件中搜索包含 “error” 的行，常用于日志分析。

3.4 系统信息查看#

查看系统信息：uname（Unix name）
- 作用：查看系统的基本信息，如内核版本、主机名等。
- 示例：
- uname：显示内核名称。
- uname -a：显示详细的系统信息，包括内核版本、主机名、硬件架构等。
查看系统资源使用情况：top
- 作用：实时查看系统的资源使用情况，如 CPU、内存、进程等。
- 示例：输入top后，会进入一个动态的界面，不断更新显示系统资源的使用状态，按q键退出。
查看磁盘空间：df（disk free）
- 作用：查看磁盘的使用空间和剩余空间。
- 示例：df -h，以人类可读的方式显示磁盘空间信息，方便查看。

3.5 网络相关命令#

查看网络配置：ifconfig 或 ip addr
- 作用：查看网络接口的配置信息，如 IP 地址、子网掩码等。
- 示例：
- ifconfig：显示网络接口的详细配置信息（在一些新系统中已被ip命令替代）。
- ip addr：显示网络接口的详细配置信息，更通用的查看网络配置方式。
测试网络连接：ping
- 作用：测试与目标主机的网络连接是否正常。
- 示例：ping www.baidu.com，通过向百度服务器发送 ICMP 数据包，检查网络连接是否正常，按Ctrl + C组合键停止。
查看路由表：route 或 ip route
- 作用：查看系统的路由表，了解数据包的转发路径。
- 示例：
- route -n：以数字形式显示路由表。
- ip route：显示当前的路由规则。

3.6 进程管理#

查看进程：ps（process status）
- 作用：查看当前运行的进程。
- 示例：
- ps aux：查看所有用户的所有进程，包括详细信息，如 CPU 使用率、内存使用率等。
- ps -ef：以全格式显示所有进程及其父子关系。
杀死进程：kill
- 作用：终止指定的进程。
- 示例：kill 1234，其中1234是进程 ID（PID），使用ps命令获取，用于终止指定进程。对于一些顽固进程，可能需要使用kill -9强制终止。

3.7 用户和权限管理#

查看当前用户：whoami
- 作用：显示当前登录的用户名。
- 示例：输入whoami，会输出当前登录的用户名，如user。
切换用户：su（switch user）
- 作用：切换到其他用户。
- 示例：su root，切换到超级用户root，需要输入root用户的密码。
修改文件权限：chmod（change mode）
- 作用：改变文件或目录的访问权限。
- 示例：chmod 755 file.txt，将file.txt的权限设置为所有者可读、可写、可执行，组用户和其他用户可读、可执行。权限数字的每一位分别对应所有者、组用户和其他用户的权限，r（读）对应 4，w（写）对应 2，x（执行）对应 1 。

3.8 软件安装和管理#

更新软件源：apt update
- 作用：更新软件源列表，获取最新的软件包信息。
- 示例：在安装新软件前，一般先运行apt update，确保获取到最新的软件版本信息。
安装软件：apt install
- 作用：安装软件包。
- 示例：apt install firefox，安装火狐浏览器。
卸载软件：apt remove
- 作用：卸载软件包，但保留配置文件。
- 示例：apt remove firefox，卸载火狐浏览器，但相关配置文件仍会保留在系统中。
彻底卸载软件：apt purge
- 作用：卸载软件包并删除配置文件。
- 示例：apt purge firefox，彻底卸载火狐浏览器及其所有相关配置文件。

3.9 第三方软件工具#

下载工具：wget
- 作用：从网络上下载文件，支持 HTTP、HTTPS、FTP 等协议。
- 示例：wget https://example.com/file.zip，从指定网址下载file.zip文件到当前目录。
网络请求工具：curl
- 作用：用于发送 HTTP 或其他协议的请求，获取数据。
- 示例：curl https://www.baidu.com，获取百度首页的 HTML 内容并输出在终端。

4. 命令行快捷键#

命令补全：按Tab键。当你输入命令或文件路径的一部分时，按Tab键可以自动补全。如果有多个匹配项，再按一次Tab键会列出所有匹配项。
历史命令：按↑和↓键可以浏览之前输入过的命令。
中断命令执行：按Ctrl + C组合键，可以中断正在执行的命令。

5. 总结#

通过这节课的学习，我们了解了 Linux 终端的基本操作，包括文件和目录操作、文件内容查看、文件搜索、系统信息查看、网络相关、进程管理、用户和权限管理以及软件安装和管理等方面的常用命令，还学习了wget、curl等第三方软件工具的使用。希望大家在课后多练习，熟练掌握这些命令，为进一步学习 Linux 系统打下坚实的基础。

6. 课后思考题#

在当前目录下创建一个名为practice的文件夹，并在其中创建一个名为test.txt的空文件，写出对应的命令。
假设你现在位于/home/user目录，要将test.txt文件移动到/var/tmp目录下，应该使用什么命令？
如何查看/etc目录下所有以conf结尾的文件，并以长格式列出它们的详细信息？请写出完整命令。
用grep命令在/var/log/syslog文件中搜索包含error关键词的行，同时显示该行的行号，写出命令。
假设你发现系统中某个进程占用大量 CPU 资源，已知该进程名为bad_process，请写出查看该进程 PID（进程 ID）以及杀死该进程的完整步骤和命令。
系统突然无法访问外网，你需要检查网络配置，使用ip addr命令查看网络接口配置，根据查看结果，分析可能导致无法访问外网的原因（至少列举两个）。
想要安装vim文本编辑器，更新软件源后，写出安装vim的命令。如果安装完成后想卸载vim，但保留配置文件，又该用什么命令？
使用wget命令从https://github.com/xxx/xxx/archive/refs/heads/main.zip下载一个项目压缩包到/tmp目录下，写出命令。

第叁节 Vim the Editor: 编辑进化#

一、Vim 是什么？#

1. 历史渊源#

1980年代诞生于Unix系统的vi编辑器
1991年Bram Moolenaar开发Vim（Vi IMproved）
支持跨平台（Windows/macOS/Linux）

2. 为什么选择Vim？#

纯键盘操作，手不离键盘
所有Linux系统预装
处理大文件速度极快
高度可定制（插件/配色/快捷键）

3. 常见编辑器对比#

编辑器	特点	适合场景
记事本	简单	临时记录
VS Code	图形化	日常开发
Emacs	全功能	深度定制
Vim	模式化	高效编辑

二、基础生存指南（15分钟）#

1. 启动与退出#

Terminal window

1
vim 文件名       # 打开文件
2
:q              # 退出
3
:q!             # 强制退出不保存
4
:wq             # 保存并退出

2. 三种模式#

1
graph LR
2
    A[普通模式] -->|i/I/a/A| B[插入模式]
3
    B -->|ESC| A
4
    A -->|: / / ?| C[命令模式]
5
    C -->|回车| A

3. 移动光标（普通模式）#

1
h ←    j ↓    k ↑    l →
2
w 下一个单词开头
3
$ 行尾
4
gg 文件开头
5
G 文件末尾
6
50% 跳转到50%位置

4. 文本操作#

命令	功能
i	进入插入模式
a	在光标后插入
o	下方新建行
dd	删除当前行
yy	复制当前行
p	粘贴
u	撤销
Ctrl+r	重做

三、进阶修炼手册#

1. 多窗口操作#

1
:split     # 水平分屏
2
:vsplit    # 垂直分屏
3
Ctrl+w w   # 切换窗口

2. 宏录制#

1
qa         # 开始录制宏到寄存器a
2
...操作...
3
q          # 停止录制
4
@a         # 执行宏
5
10@a       # 执行10次

3. 插件管理（示例使用Vundle）#

1
" 在.vimrc中添加：
2
Plugin 'VundleVim/Vundle.vim'
3
Plugin 'tpope/vim-surround'  " 自动补全括号
4
:PluginInstall  # 安装插件

4. 搜索替换#

1
/pattern    # 搜索
2
:%s/old/new/g  # 全局替换
3
:set hlsearch  # 高亮搜索结果

5. 配置秘籍#

1
" ~/.vimrc 示例配置
2
set number     " 显示行号
3
syntax on      " 语法高亮
4
set tabstop=4  " Tab缩进4格
5
map <F2> :w<CR>  " F2快速保存

四、课堂小练习#

用vim创建hello.txt
输入三行文字：“第一行测试”、“第二行练习”、“第三行成功”
将”练习”替换为”训练”
复制第二行到文件末尾
保存并退出

五、总结升华#

Vim是”编辑的进化”：从打字机到智能编辑
学习曲线像骑自行车：开始难，学会后自由驰骋
推荐配置：安装vimtutor（输入vimtutor可直接学习）

第肆节走进网络安全：防御导向的渗透测试#

目录#

Nmap基础扫描实践
防火墙规则分析与突破方案
流量特征隐匿实战

一、Nmap基础扫描实践#

1.1 什么是Nmap？#

网络映射器（Network Mapper），用于：

发现网络设备
扫描开放端口
识别服务版本
检测操作系统

1.2 安装与基础命令#

Terminal window

1
# Windows安装（下载地址：https://nmap.org/download）
2
# 基础扫描命令：
3
nmap -sS 172.28.1.11          # 默认TCP SYN扫描
4
nmap -p 1-1000 172.28.1.11    # 指定端口范围
5
nmap -O 172.28.1.11           # 操作系统检测

1.3 网关扫描实践#

Terminal window

1
nmap -T4 -A -v 172.28.1.1     # 网关扫描示例

扫描结果解读：

Terminal window

1
PORT    STATE SERVICE
2
80/tcp  open  http
3
443/tcp open  https
4
22/tcp  open  ssh

1.4 注意事项#

需管理员权限运行
扫描前需获得授权
避免高频扫描触发防火墙

二、防火墙规则突破方案#

2.1 RDP连接被阻原理分析#

学校防火墙可能：

阻断3389端口的出站连接
检测RDP协议特征
限制特定IP段的访问

2.2 Socks5代理方案#

graph LR A[本地PC] --> B[Socks5公网服务器:1080] --> C[目标RDP服务器]

配置步骤：#

购买云服务器（阿里云/腾讯云）
安装Socks5服务：

Terminal window

1
sudo apt install dante-server

客户端配置：

Terminal window

1
proxychains rdesktop 目标IP:3389

2.3 反向代理方案（推荐）#

使用FRP反向代理：

frpc.ini

1
[rdp]
2
type = tcp
3
local_ip = 127.0.0.1
4
local_port = 3389
5
remote_port = 6000

三、流量特征隐匿实战#

3.1 Wireshark抓包分析#

安装Wireshark（官网下载）
过滤FRP流量：

Terminal window

1
tcp.port == 7000 && tcp contains "frp"

特征头示例：

Terminal window

1
0000  02 00 00 01 04 00 00 00  00 00 00 00              ............

3.2 Frp的使用#

本段来自：https://zhuanlan.zhihu.com/p/599688608

Frp 是一个专注于内网穿透的高性能的反向代理应用，支持 TCP、UDP、HTTP、HTTPS 等多种协议。可以将内网服务以安全、便捷的方式通过具有公网 IP 节点的中转暴露到公网。

https://github.com/fatedier/frp

3.2.1 常见流量特征#

3.2.1.1 基本配置#

frpc.ini展开收起

1
[common]
2
server_addr = your vps
3
server_port = 7000
4

5
# kcp监听的端口
6
protocol = kcp
7

8
[plugin_socks5]
9
type = tcp
10
remote_port = 6005
11
plugin = socks5
12
plugin_user = admin888
13
plugin_passwd = admin888
14
# frps.ini
15
[common]
16
bind_addr = 0.0.0.0
17
bind_port = 7000
18
# 开启kcp模式
19
kcp_bind_port = 7000

展开收起

这里在不使用任何安全配置，和该工具什么都没改的情况下，我们看下流量特征,使用Socks5的流量规则:

tcp.port == 6005

img

可以看到在进行 Socks 的用户和密码(admin888/admin888)校验整体交互都是属于明文，能看到我们认证的账号密码

img

在攻防渗透中为了提高传输效率，可能会开启KCP，那么这时候抓到的就是走UDP协议

img

另外frpc在连接认证Frps的时候，会进行三次握手，会把Frp的版本信息发给frps进行认证，如果是用的一个没有改过的Frp那么这时候只要建立连接，很容易就会被安全设备捕获到。如下可以看到该工具版本Version、Arch、User、Privilege_key等字段

这时候追踪 TCP 流可以看到我这个 Frp 版本为0.38

img

很多安全设备也会基于 Frp 的相关特征进行流量识别，判断是否遭受黑客攻击

img

TLS加密之后，对比在frpc.ini的[common]中配置tls_enable = true来启用此功能，这时候再看下流量发现整个流量过程都已经被加密了:

img

这时候再去看对应数据包，发现确实已经看不到明文信息了，但是有个新的问题，使用 tls_enable 加密后，首次连接会一个0x17的头部特征，并发送一个大小为243的数据包

img

特征改造

Frpc的入口文件为 cmd/frpc/main.go，go build cmd/frpc/main.go。Frps的入口文件为cmd/frps。

3.3 流量特征改造#

默认字节修改#

上面提到的当使用了TLS加密之后,因为frp为了端口复用首次frp建立连接会出现一个 0x17 特征包,建立的第一个字节就是固定在 /pkg/util/net/t l s.go 处，这里对 FRPTLSHeadByte 进行修改，补充单字节为多字节。

img

1
var (
2
        //FRPTLSHeadByte = 0x17
3

4
        // 修改后
5
        FRPTLSHeadByte = 0x16
6
)
7

8
func WrapTLSClientConn(c net.Conn, tlsConfig *tls.Config, disableCustomTLSHeadByte bool) (out net.Conn) {
9
        if !disableCustomTLSHeadByte {
10
                //c.Write([]byte{byte(FRPTLSHeadByte)})
11

12
                //修改后
13
                c.Write([]byte{byte(FRPTLSHeadByte), byte(0x71), byte(0x72)})
14
        }
15
        out = tls.Client(c, tlsConfig)
16
        return
17
}
18

19
func CheckAndEnableTLSServerConnWithTimeout(
20
        c net.Conn, tlsConfig *tls.Config, tlsOnly bool, timeout time.Duration,
21
) (out net.Conn, isTLS bool, custom bool, err error) {
22

23
        //sc, r := gnet.NewSharedConnSize(c, 2)
24
        //修改后
25
        sc, r := gnet.NewSharedConnSize(c, 4)
26
        //buf := make([]byte, 1)
27
        //修改后
28
        buf := make([]byte, 3)
29
        var n int
30
        c.SetReadDeadline(time.Now().Add(timeout))
31
        n, err = r.Read(buf)
32
        c.SetReadDeadline(time.Time{})
33
        if err != nil {
34
                return
35
        }
36

37
        //if n == 1 && int(buf[0]) == FRPTLSHeadByte
38
        //修改之后
39
        if n == 3 && int(buf[0]) == FRPTLSHeadByte {
40
                out = tls.Server(c, tlsConfig)
41
                isTLS = true
42
                custom = true
43
        } else if n == 1 && int(buf[0]) == 0x16 {
44
                out = tls.Server(sc, tlsConfig)
45
                isTLS = true
46
        } else {
47
                if tlsOnly {
48
                        err = fmt.Errorf("non-TLS connection received on a TlsOnly server")
49
                        return
50
                }
51
                out = sc
52
        }
53
        return
54
}

展开收起

这里改完只要能重新编译那就没什么问题,这时候就可以看到成功后的值，从一个字节变成了3个字节。

img

代理特征修改#

如果不开启 TLS 选项的话，避免配置代理时暴露服务器 IP 和本机IP 的话，修改 server/proxy/proxy.go 文件。把源地址和目的地址写死114.114.114.114，这里可以任意修改。

img

记录的 src_addr 和 dst_addr 地址已经变成 114.114.114.114 了。

img

3.4 功能改造#

3.4.1 配置文件自删除#

正常情况在客户端启动时会去加载配置文件，这样就会导致我们的vps服务器地址泄露。故可以使用以下几种方法：

加上命令行参数，这种就是将配置文件内容全部写入代码中，实现带参执行，但是这种还是比较容易被发现；
远程去加载配置文件，这样需要通过域名或者ip去解析，这样隐藏也不是太好；
在客户端执行之后直接删除frpc.ini，这样的话直接在代码中写死即可。这样较为隐蔽

修改文件 /frp/cmd/frpc/sub/root.go 文件

添加一个变量，

img

然后在 RegisterCommonFlags 函数中去进行修改，

1
cmd.PersistentFlags().BoolVarP(&delEnable, "delEnable", "", true, "remove frpc.ini")

默认运行之后直接将配置文件进行删除

img

最终只需要在启动函数中加上即可

img

没有报错就可以直接进行交叉编译生成

img

运行前

img

运行之后，只剩下 frpc.exe，配置文件自动删除

img

成功连接

img

2.1.4 总结

这里只是做了一个初步的改造，比如后续可以考虑本身免杀问题、功能上还可以添加端口转发、以及利用cdn隐藏ip，带参数版加密执行等。企业在遭受到黑客攻击进入到后渗透阶段隧道的搭建和流量隐匿是常用的基础手段，安全设备在原有的流量检测设备中进行规则判断是远远不够的，需要针对 Frp 等隧道工具流量特征细节化进行更加深入的研究，针对隧道流量进行更详细的规则提取，不断完善企业威胁流量监测，提高企业安全建设能力。

四、注意事项#

所有操作需在合法授权范围内进行
禁止扫描非授权目标
修改流量特征需配合TLS加密
遵守学校网络安全规定

实践建议：可在虚拟机环境搭建实验网络（推荐使用VirtualBox）

五、课后思考#

基础思考#

TCP SYN扫描（-sS）与TCP全连接扫描（-sT）有何本质区别？ 如果目标服务器开启了防火墙但未启用IDS，哪种扫描方式被发现的风险更低？为什么？
当使用Socks5代理突破防火墙时 如果代理服务器IP被学校防火墙加入黑名单，可以通过哪些技术手段继续建立RDP连接？（提示：考虑协议伪装或分布式架构）
Wireshark流量分析实践 若发现FRP流量特征不仅存在于MagicNumber，还包含固定心跳包间隔（30秒），如何通过修改源码实现动态随机化心跳间隔？

进阶挑战#

协议特征深度隐匿 现有方案仅修改了FRP的MagicNumber特征：
- 如何通过修改frp/pkg/util/net/conn.go中的WrapConn方法，使流量特征更接近HTTPS？
- 若同时配合Let’s Encrypt证书部署TLS加密，需修改哪些核心模块？（需阅读frp TLS相关源码）
防火墙对抗推演 假设学校防火墙升级为：
- 深度包检测（DPI）识别非标准Socks5握手
- 机器学习模型分析流量时序特征请设计一套结合「随机化分片传输」+「QUIC协议隧道」+「噪声流量注入」的三层隐匿方案，要求：
- 说明各层对抗的技术原理
- 绘制数据封装流程图（可文字描述）

新蒙学图鉴

Sat, 01 Feb 2025 00:00:00 GMT

文/仿鲁迅

近来坊间流传些绘着金边的册子，封皮总印着童子抱卷的剪影。我本疑心是前清劝学篇还魂，细看却是用西洋油墨印的，连书脊都透着股樟脑丸的酸气。

册中描摹的学塾，总在桃花汛里散馆，秋分未至便闭门。我踱至弄堂深处，却见伏天的蝉都叫哑了，蒙馆窗棂里还漏着油灯光。穿长衫的先生举着戒尺比划：“今日功课不过临三页碑帖”，可那青衿学子的布包里，分明鼓着几何仪与洋文典——倒像戏台上的《天河配》，牛郎织女隔着纸屏风唱团圆，幕后的班主早备好了十八根银簪子要拆鸳鸯。

更有些个工笔小像，专画些面壁诵经的童生。画师定是吃多了朱砂，把个独坐寒窗描成菩萨坐莲台。前日见西街张记当铺的学徒，攥着半块桂花糕在巷口徘徊——原是同窗病中托人捎的。那孩子盯着糕上芝麻粒看了半盏茶功夫，忽地掷进阴沟，踩着脚念道：“圣贤路上容不得甜滋味。“这倒教我记起城隍庙里的泥判官，左手生死簿，右手勾魂笔，只是不知何时竟偷了蒙童的皮囊。

最奇的是这些册子专挑三更天往人梦里钻，把铁砚台描成翡翠屏，狼毫笔说成金箍棒。少年人脖颈上明明套着石磨盘，偏要说是菩萨赐的璎珞圈。就像茶馆说书人最爱讲的段子：前朝某学士寒窑苦读，夜夜有狐仙添灯油。却不知那狐狸尾巴早藏在讲经堂的帷帐后，专等着书生熬瞎了眼，好叼去当招魂幡使。

檐角铁马忽然叮当乱响，许是哪家蒙童摔了砚台。我推开窗，见月牙儿卡在电线上，活像被洋学堂的三角板削瘦了。后园蟋蟀振翅声里，竟带出几分之乎者也的腔调，大约也在背诵新编的《独学经》罢？

白嫖一个edu邮箱（1月30日可用）

Thu, 30 Jan 2025 00:00:00 GMT

进入网站之前：先打开全局 ，否则会加载不出验证。

进入 https://cmsweb.csun.edu/psp/CNRPRD/EMPLOYEE/SA/c/NR_SSS_LAUNCH_MENU.NR_SSS_QKADMIT_CMP.GBL?

会有这样一个人机验证：

完了以后：

点击下方按钮 New Student 。

同时打开身份生成器 https://www.shenfendaquan.com/ ，生成信息并填入。

建议邮箱用自己的，防止账号被盗取。唯一的框框：不用打勾。

最后，记下这个身份，后面要用。填完以后点击 Continue 。

如果出现：

多半是因为姓名什么的重复了，重新生成一个就好了。

成功后会看到这样一个页面：

这里两个随便选即可。

到这一步嘛，等待邮件即可。大概五分钟以内就能收到:

点击这里的超链接：

1
To activate your CSUN account click on this link to : Activate My CSUN Account and follow the instructions using the information provided above.

进入重置密码：https://lad.csun.edu/psc/LADPRD/EMPLOYEE/ERP/s/WEBLIB_NRPA_PWD.ISCRIPT1.FieldFormula.IScript_ChangePassword?cmd=login&errorCode=105&languageCd=ENG

然后这里如果出现如上图所示的情况，就重新进入链接一下。这才是正确的重置密码页面：

然后填入之前生成的生日、和邮件发给你的邮件地址。

验证成功后，选择将密码发送到邮件（因为手机号是乱填的）。

填入发给你的临时密码，然后提交。

然后在这里设置新的密码：

修改成功：

然后进入 https://portal.csun.edu/login 可以登录。

登进去以后，这里就能看到邮箱入口了：

解决macOS报错 yld[1515]: Symbol not found

Tue, 28 Jan 2025 00:00:00 GMT

运行 pnpm install 报错：

Terminal window

1
dyld[1515]: Symbol not found: __ZNK6icu_746number23NumberFormatterSettingsINS0_24LocalizedNumberFormatterEE10toSkeletonER10UErrorCode
2
  Referenced from: <255171D4-4764-3E92-9D3A-99746F2228E9> /usr/local/Cellar/node/22.9.0/bin/node
3
  Expected in:     <B23C6580-0B26-3188-B616-BDD422BABD7F> /usr/local/Cellar/icu4c@76/76.1_1/lib/libicui18n.74.dylib
4
zsh: abort      pnpm install

运行其他node系列的命令都一样。

解决方案#

重装node。

先卸载node#

笔者这里是用 brew 安装的，所以直接用 brew 卸载。

由于还安装了 vite ，因为依赖关系，把 vite 也同时卸载了。

这样应该是卸载成功了。

安装全新node#

前往 https://nodejs.org/en/download/current/ 。

直接点击下载 macOS Installer (.pkg) ，然后打开并安装。

安装完后就能在命令行中使用 node 和 npm 了。

换源、安装pnpm#

npm 换源：

Terminal window

1
 npm config set registry https://registry.npmmirror.com

安装 pnpm ：

Terminal window

1
curl -fsSL https://get.pnpm.io/install.sh | env PNPM_VERSION=10.0.0 sh -

pnpm 换源：

Terminal window

1
pnpm config set registry https://registry.npmmirror.com

next.js 解决 `x-forwarded-host` header does not match `origin` header with value from a forwarded Server Actions request

Tue, 07 Jan 2025 00:00:00 GMT

在 GitHub codespaces 上开发 next.js 项目，端口穿透出来后访问，结果报错：

1
`x-forwarded-host` header does not match `origin` header with value from a forwarded Server Actions request.

解决方案：

如果需要，首先更新 next.js 。参见 https://nextjs.org/docs/messages/version-staleness ，运行命令：

Terminal window

1
pnpm add next@latest

这应当是不会报错了。但如果您像笔者一样使用了 ppr: true ，就应当使用 canary 版本，不然后续可能会出错。

修改 next.config.js ，添加 experimental.serverActions.allowedOrigins 。

例如我这里：

1
import type { NextConfig } from 'next';
2

3
const nextConfig: NextConfig = {
4
  /* config options here */
5
  experimental: {
6
    serverActions: {
7
      allowedOrigins: [
8
        'localhost:3000', // localhost
9
        'super-duper-space-*****-*****-3000.app.github.dev', // Codespaces
10
      ],
11
    },
12
    ppr: true,
13
  },
14
  images: {
15
    remotePatterns: [
16
      {
17
        hostname: 'avatar.vercel.sh',
18
      },
19
    ],
20
  },
21
};
22

23
export default nextConfig;

展开收起

然后重新启动后就能成功访问了。

typoraossimage

Mon, 06 Jan 2025 00:00:00 GMT

来看看 Typora 对此的要求：

截屏2025-01-06 08.53.51

我们根据这个规则可以写出以下代码：

bash版（不推荐，Typora 可能会检测不到输出）

1
#!/bin/bash
2

3
# 定义图床的上传 URL
4
UPLOAD_URL="【替换成你的端点url】"
5

6
# 定义请求头
7
HEADERS=(
8
    "-H 'Accept: application/json, text/plain, */*'"
9
    "-H 'Accept-Language: zh-CN,zh;q=0.9'"
10
    "-H 'Cache-Control: no-cache'"
11
    "-H 'Connection: keep-alive'"
12
    "-H 'Origin: 【替换此处】'"
13
    "-H 'Pragma: no-cache'"
14
    "-H 'Referer: 【替换此处】'"
15
    "-H 'Sec-Fetch-Dest: empty'"
16
    "-H 'Sec-Fetch-Mode: cors'"
17
    "-H 'Sec-Fetch-Site: cross-site'"
18
    "-H 'User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36'"
19
    "-H 'sec-ch-ua: \"Google Chrome\";v=\"131\", \"Chromium\";v=\"131\", \"Not_A Brand\";v=\"24\"'"
20
    "-H 'sec-ch-ua-mobile: ?0'"
21
    "-H 'sec-ch-ua-platform: \"macOS\"'"
22
)
23

24
echo "Upload Success:"
25

26
# 遍历传入的图片路径
27
for img_path in "$@"; do
28
    # 生成文件名
29
    filename=$(basename "$img_path")
30

31
    # 计算文件的 MD5 值
32
    md5_value=$(openssl dgst -md5 "$img_path" | awk '{print $2}')
33

34
    # 生成随机边界字符串
35
    boundary=$(openssl rand -hex 16)
36

37
    # 添加 MD5 值和边界到请求头
38
    HEADERS+=("-H 'md5-value: $md5_value'")
39
    HEADERS+=("-H 'Content-Type: multipart/form-data;'")
40

41
    # 构建 curl 命令
42
    curl_command=(
43
        "curl"
44
        "${HEADERS[@]}"
45
        "-F 'files=@$img_path;filename=$filename'"
46
        "$UPLOAD_URL"
47
    )
48

49
    # 执行 curl 命令并获取响应
50
    response=$(eval "${curl_command[@]}" 2>/dev/null)
51

52
    # 使用字符串匹配提取 URL
53
    image_url=$(grep -oP '"fileId":"\K[^"]+' <<< "$response")
54

55
    # 输出图片 URL
56
    echo "$image_url"
57

58
    # 清除 MD5 请求头和边界，以便下一次使用
59
    HEADERS=("${HEADERS[@]::${#HEADERS[@]}-2}")
60
done

展开收起

Python 版（推荐，但是需要安装 Python3 及相应的库）

1
import os
2
import requests
3
import hashlib
4
import re
5
import sys
6

7
# 定义图床的上传 URL
8
UPLOAD_URL = "【替换此处】"
9

10
# 定义请求头
11
HEADERS = {
12
    'Accept': 'application/json, text/plain, */*',
13
    'Accept-Language': 'zh-CN,zh;q=0.9',
14
    'Cache-Control': 'no-cache',
15
    'Connection': 'keep-alive',
16
    'Origin': '【替换此处】',
17
    'Pragma': 'no-cache',
18
    'Referer': '【替换此处】',
19
    'Sec-Fetch-Dest': 'empty',
20
    'Sec-Fetch-Mode': 'cors',
21
    'Sec-Fetch-Site': 'cross-site',
22
    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
23
    'sec-ch-ua': '"Google Chrome";v="131", "Chromium";v="131", "Not_A Brand";v="24"',
24
    'sec-ch-ua-mobile': '?0',
25
    'sec-ch-ua-platform': '"macOS"'
26
}
27

28
print("Upload Success:")
29

30
# 遍历传入的图片路径
31
for img_path in sys.argv[1:]:
32
    # 生成文件名
33
    filename = os.path.basename(img_path)
34

35
    # 计算文件的 MD5 值
36
    with open(img_path, 'rb') as file:
37
        md5_value = hashlib.md5(file.read()).hexdigest()
38

39
    # 添加 MD5 值到请求头
40
    HEADERS['md5-value'] = md5_value
41

42
    # 构建文件数据
43
    files = {'files': (filename, open(img_path, 'rb'))}
44

45
    # 发送 POST 请求
46
    response = requests.post(UPLOAD_URL, headers=HEADERS, files=files)
47

48
    # 使用字符串匹配提取 URL
49
    image_url = re.search(r'"fileId":"([^"]+)"', response.text)
50

51
    if image_url:
52
        # 输出图片 URL
53
        print(image_url.group(1))
54
    else:
55
        print("Failed to extract image URL")

展开收起

然后在图片上传设置页面填入以下命令：

截屏2025-01-06 08.58.47

这里我们假设这个 Python 文件保存在了 /path/to/file/upload_image.py 。

点击“验证图片上传选项”：

截屏2025-01-06 08.59.52

验证成功，大功告成。

赛车弯道的最速路径

Sat, 28 Dec 2024 00:00:00 GMT

本文原作者为 hycMike，在此进行分享。 {: .prompt-tip }

有些同学对盘山公路很感兴趣。下图是一个 180° 回头弯，红色部分是 curb （路肩），蓝色部分是 geometry line ，是按“外-内-外”顺序分别与边缘相切的一段圆弧。其中，与内侧边缘距离最近的点称为 apex （弯心）。

对于这样一个独立的赛道，在推到极限的情况下走 geometry line 是最快过法。然而，在一条赛道中，每一个弯都不是独立的弯+弯的情况（假弯、组合弯等）。这类情况较为复杂，不予讨论。

不妨来看一种简单情况：弯+直道。

长直道后，为了保证在直道末端拥有更高的尾速，我们使用晚刹车、早弯心的过法来节省时间。
长直道前，为了保证出弯速度，获取更高尾速，我们使用早刹车、晚弯心，出弯线路更平滑，加速更快。

此乃基于系统优化的理想线路。

Jellyfin、Emby、Subsonic、Navidrome对比

Sun, 24 Nov 2024 00:00:00 GMT

对比项目	Jellyfin	Emby	Subsonic	Navidrome
媒体库管理	强大的媒体库扫描与分类，自动按类型整理，依据影视元数据精准分类，管理多类型媒体。	支持细致组织，可自定义信息抓取与展示，灵活处理影视内容，管理多种格式媒体，有高级筛选搜索选项。	侧重音乐媒体库管理，按常规音乐分类方式整理，对影视等支持相对弱些。	着重音乐库管理，智能识别音乐标签准确归类，支持创建播放列表与基于元数据检索。
播放功能	支持多种格式视频、音频播放，串流播放稳定，有倍速、章节选择等功能。	播放功能丰富，提供高质量视频转码，适配不同设备播放能力，音频调节功能也多。	专注音乐播放体验，有无缝、多设备同步播放等特色，缓冲处理较好。	提供优质音乐播放体验，支持多种音频格式解码，便于管理播放队列，可分享播放列表。
多平台支持	覆盖主流桌面、移动端及智能电视系统，浏览器也可访问，兼容性出色。	支持多平台，客户端针对不同平台优化，使用体验较统一。	支持常见桌面、移动端平台，大屏设备适配性稍弱，可投屏使用。	支持多平台部署运行，在桌面管理、移动端播放方便，大屏原生支持稍弱。
用户界面	简洁大方，现代风格，信息展示清晰，不同平台界面较一致，易上手。	界面精致，有专业风格，菜单选项丰富，交互体验好，有个性化设置空间。	简洁实用，以音乐播放功能展示为主，简化操作流程，美观与定制性稍弱。	简约清晰，突出音乐库与播放控制元素，清爽但界面定制功能有限。
授权与开源情况	完全开源，免费使用、自行部署，社区活跃，可二次开发。	有免费和付费版本，付费解锁高级功能，非开源，由专业团队维护。	有开源和付费版本，开源有使用限制，付费功能更全，社区有一定影响力。	开源项目，免费部署使用，社区不断完善功能。
硬件资源占用	扫描大媒体库、视频转码等操作时对硬件有要求，常规中小规模使用较合理。	类似Jellyfin，执行复杂任务及应对并发播放需较好配置，有资源调度优化。	主要针对音乐，硬件资源需求低，普通服务器能稳定运行。	专注音乐服务，硬件资源占用少，可在低配置服务器流畅运行。

r730xd不完全折腾指南

Fri, 11 Oct 2024 00:00:00 GMT

1. 起因#

2. 选购#

2.1 准系统#

这次选取的是 戴尔 PowerEdge R730xd 。选取原因有三：

市场存量多，货源充足，性价比高；
使用人数多，网上教程丰富，小白友好；
可扩展性强。

在某网店选购 R730XD准系统+H730卡+单750W电源 ，价格仅需 ¥699 ，实属物美价廉。

2.2 CPU#

网上相关教程推荐的U有很多，但性能较好的还看 E5-2680V4 E5-2690V4 。

2024-10-09 23.21.27.png

但其实一对比，E5-2680V4价格便宜了很多，性能也不算很差，所以最终选择了 E5-2680V4 。由于预算有限，只买一颗（最多能装两颗）。

2.3 内存条#

2.4 硬盘#

2.5 小计#

这样算下来，一套基础版大概需要 1000r 左右：

2024-10-09 23.30.06.png

3. 硬件安装过程#

3.1 开箱#

按下按钮，掀开后盖，可以看到内部构造。

3.2 换 CPU#

原来厂家发过来的时候已经随附了两颗 E5-2650 V3 ，但我们自己买了另外的CPU，需要拆除原来的CPU。两个都要拆，CPU不能混用。

按照官方教程，先选择一颗螺丝转下来，等待30s自己会松掉；然后再卸下对角线的那颗螺丝，就能成功拆除散热器了。

这是拆完散热器以后的样子：

拆下来的散热器：

接下来取出cpu：按下两边的弹簧开关，将金属结构弹出，就能拿出CPU了。

然后放上我们自己买的cpu，按刚才相反的步骤，即可装入。

值得注意的是，先应将下方的卡扣抬起，再放下另一边的金属片，否则是盖不上的。

请一定不要使用蛮力，否则可能会损坏服务器！ {: .prompt-danger }

如果您只装了一颗U，而另一个位置上仍有另一颗不同型号的U，那么服务器开机自检是无法通过的。 {: .prompt-warning }

3.3 上内存#

如果厂家是帮您预装好的，那么直接装在默认位置就行；如果需要自己安装，可能有以下两种情况：

按照整流罩上标的顺序，放在一号内存槽位；
直接插在离cpu最近的那个槽位。

上面两种情况试一试即可，如果不正确可能会导致无法开机。

3.4 装硬盘#

这款服务器一共有14个盘位。

后方一共是 3×4=12 3\times 4=123×4=12 个 3.5 寸盘位，前面还有 2 22 个 2.5 寸的。

直接一块硬盘我们是无法直接装到服务器上的，需要先给它固定到硬盘架上，然后再将硬盘架安装进盘位中。

装好后大概长这样⬆️。

4. 系统的选取与安装#

对比项目	PVE	VMware ESXi
成本	开源免费，适合预算有限的小型企业和个人用户，可免费使用全部功能，但付费可获得技术支持服务等。	基本版本免费，但高级功能如高可用性的 HA、负载均衡等需付费购买 vmware vsphere 获得****。
技术基础	基于 Debian Linux 发行版，支持 KVM 全虚拟化和 LXC 轻量级容器两种虚拟化技术。	基于 VMware 的专有架构，是直接安装在物理服务器硬件之上的裸金属型 hypervisor，主要使用全虚拟化技术。
用户界面	提供基于 Web 的图形用户界面，同时支持命令行界面，界面相对简洁直观，对于有 Linux 基础的用户来说较易上手，但对新手而言，部分操作需使用命令行，有一定学习成本。	通过 vSphere Client 或 vCenter Server 进行管理，提供了丰富直观的图形用户界面，与 VMware 的其他产品紧密集成，管理体验高效，易于新手入门。
性能和资源利用	支持 LXC 容器，在资源利用方面更加高效，特别是处理 I/O 密集型任务时表现较好，用户能够对虚拟机实施详细的资源控制和配额，确保每个应用获取所需资源。	其性能优势来自于为虚拟化特制的内核，能更高效地管理和分配资源，资源调度和动态迁移技术进一步优化了虚拟机的性能和资源利用率，在硬盘和网络 I/O 等方面表现出色。
管理和扩展	通过 Web 界面管理，可使用 Proxmox VE Cluster 进行集群扩展，管理相对灵活，扩展性强，适合有一定技术能力和对定制化有需求的用户。	通常与 vCenter Server 结合使用，可轻松实现大规模的虚拟化管理和自动化，更适合企业级的大规模部署和管理，但对技术人员的专业要求较高。
社区和支持	拥有活跃的开源社区，用户可获得广泛的帮助和支持，社区资源丰富，更新速度快，但对于一些复杂问题的解决可能需要用户自身具备一定的技术能力。	依托 VMware 的品牌和庞大的技术支持团队，能够获得专业的技术支持服务，对于企业级用户来说，在遇到问题时可获得更及时有效的解决方案。
安全性	基于 Linux 内核，具有良好的安全特性，但需要用户自己负责及时更新和维护系统以确保安全性。	经过严格的安全测试和优化，提供了企业级的安全保障，内置的安全功能如 vShield 和 NSX 等强化了虚拟化环境的安全性。
硬件兼容性	硬件兼容性优秀，对多种硬件设备的支持较好，尤其是对 Realtek 网卡等设备的兼容性优于 ESXi。	硬件兼容性相对较差，主要面向服务器硬件，对一些常见的桌面级或消费级硬件设备的支持可能存在不足，但对主流服务器硬件及 Intel 网卡等兼容性良好。
高级功能	提供如实时迁移、快照等高级功能，但不如 ESXi 的功能全面。	拥有广泛的企业级高级功能，如 VMotion、DRS、HA 等，可实现虚拟机的动态迁移、资源的智能调度和高可用性保障等。

由于考虑到 VMware ESXi 比较商业化，功能较为完善，而且对我们的 R730xd 有专门的适配，所以这里我们选择 VMware 的虚拟化。

笔者这里使用的 raid 方案是一块 raid0 装系统，其他盘作数据盘。

4.1 设立 VD 和 RAID 模式#

4.1.1 磁盘阵列（RAID）是什么？#

常见的磁盘阵列级别包括：

RAID 0：数据被分割成块并分布在多个磁盘上，没有冗余信息。它能提高读写性能，但一个磁盘损坏就会导致数据丢失。
RAID 1：数据在两个或更多磁盘上进行镜像。写入数据时，会同时写入到多个镜像磁盘中。这种方式可靠性高，一块磁盘损坏，数据可从镜像磁盘获取，但磁盘利用率低。
RAID 5：数据和奇偶校验信息分布在多个磁盘上。通过奇偶校验信息，可以在一个磁盘损坏的情况下恢复数据，兼顾了存储性能、数据安全和存储成本等因素。
RAID 6：与RAID 5类似，但有两份独立的奇偶校验信息，能允许两块磁盘同时损坏而不丢失数据。
RAID 10：是RAID 0和RAID 1的组合，先做镜像再做条带化，具有高性能和高可靠性。

4.1.2 磁盘阵列的重要性#

提高数据存储性能 在RAID 0等模式下，通过并行读写多个磁盘，可以显著提高数据的读写速度。对于需要处理大量数据的服务器和存储系统，如数据库服务器、视频编辑工作站等，磁盘阵列能够加快数据的访问速度，从而提高整个系统的工作效率。
增强数据安全性和可靠性 在RAID 1、RAID 5、RAID 6等具有冗余功能的模式下，即使磁盘出现故障，数据仍然可以通过冗余信息进行恢复。这对于企业级的数据存储至关重要，可避免因磁盘故障导致的数据丢失，保护企业的核心数据资产，减少因数据丢失带来的损失和业务中断风险。
便于数据管理和扩展 磁盘阵列可以作为一个统一的逻辑存储单元进行管理，方便管理员进行存储容量的分配和调整。同时，通过添加新的磁盘，可以相对容易地扩展存储容量，满足企业不断增长的数据存储需求。

4.1.3 建立磁盘阵列#

开机以后等待以下界面，当看到 Press <Ctrl><R> to Run ... 时，按下 Ctrl+R ，进入 H730/H330 MiniBIOS ，设置磁盘阵列。

进入 minibios 后，使用 ⬆️/⬇️ 键将高亮移动到最顶端的你的阵列卡的条目（字样：H310、H730等）。然后再按下 F2 。

在弹出的菜单中，移动高亮至 Create New VD ，按下 Enter 。

因为我们这里只有一块盘的话，我们就只能选择 RAID 0 。

这里是组了一块 raid ，然后通过虚拟磁盘的方式传给上层系统使用。当然，也可以组完 raid 后直通给系统使用，这样效率更高。

4.1.4 在图形化界面中设置 raid1#

示例图片里是 raid5 ，但其实组 raid1 是一样的，一个是三块盘，一个是两块盘。

4.2 使用 u 盘安装 vmware esxi#

这里我们使用简单易用的 Ventoy 。当然，您也可以根据您的喜好选择其他程序来安装。这里介绍使用 Ventoy 的安装方法。

首先，到 https://github.com/ventoy/Ventoy/releases/ 找到并下载最新的程序。

直接选择你的U盘，然后点击“安装”。安装完后你的优盘名称会变成“Ventoy”字样，是空的。直接把你想安装的 ESXi 镜像拖进去就行了。

这里安装的是 8.0.0 版本。

插上 U 盘，进 iDrac 可以图形化安装。

1
> 此处引用 https://blog.darklotus.cn/tutorials/r730xd.html 之照片，在此表示感谢。

镜像安装成功后，按照指引重启系统，然后进入 ESXi 设置。

4.3 安装 Ubuntu24.04#

进入 ESXi 网页管理页面，我们点击 “创建/注册虚拟机”。

这里可以配置 CPU 核心数、分配的内存和硬盘空间大小。注意，硬盘选项要选择“薄置备”，这样才不会一次占用太多空间。

上面的步骤完成后直接点击小企鹅上的播放按钮。如果启动失败的可以按照下图检查一下引导选项。

打开自带的控制台，按 Enter 选中“安装 Ubuntu Server”。

然后会开始跑代码，稍等一下即可。

选择语言，没有中文。使用英语。

不要更新，否则会很慢。

这里根据自己的情况配置网络环境。

自己选择源，中科大源应该是比较快的。

学校里用不了 Ubuntu pro。但它其实是免费的。

这里提示FAILED，其实不用担心，直接重启就好了，无事发生。

重启后登录，我们就能进入一个 Ubuntu Server 了。

你还可以选择安装 1Panel，这样就能方便地管理服务器了。

4.4 安装飞牛NAS#

系统基础信息#

开发基础：基于Linux内核（Debian发行版）开发，稳定性和安全性高，可扩展性与自由度强。
硬件兼容性：兼容主流X86架构设备，可利用闲置硬件如PC、软路由、NUC等搭建私有云存储。

功能特性#

存储管理#

硬盘信息展示：全面展示硬盘类型、时长、健康、接口协议、温度等，可查看S.M.A.R.T信息。
存储模式：创建空间时依硬盘数量自动切换模式，展示容量、优缺点。系统盘和数据盘独立管理，系统盘只能单独组basic。
RAID管理：支持换盘、设热备盘、改模式、扩容。能自动重组raid、自动替换热备盘，可升级RAID等级，RAID5以上可直接扩容。

文件管理#

一个页面管理内、外、远程文件，操作简易。

智能影视#

照片备份#

飞牛私有云App相册备份功能可将手机照片备份到NAS，支持原画、实况、RAW格式。

远程访问#

有公网IP直连、FN Connect、DDNS域名转发、P2P等多种方式。

应用中心#

常用应用全，支持Docker，可按需安装应用扩展功能。

系统优势#

界面友好：扁平化设计，类似macOS，人机交互合理，美观适合国人，有引导和手册，新手易上手。
免费使用：个人用户免费，降低成本。

目前公测阶段，存在RAID模式有限、共享功能不足等问题，持续更新改进后有望提升体验。

在此处可以看到下载地址：飞牛私有云 fnOS

94ecca0fe377e3f8f598478d75a303a2.png

f4f39eab935c55da5035a04b59eff7b6.png

682b0aba4e55001f58a980dcea225f7b.png

157b3e987307ee5be4d29358b90e965f.png

f6781c73950afd3db2f02f0b2e0f6ca2.png

00cddddd75c6c3d8e1bf21dc197fec9e.png

3794fb26400424daa6147e88317e9ba8.png

69eef747ba552ca20c9d612bc6530f2b.png

1d569e288854c78fa4fb4e5edd92824c.png

d8828418a8a33c412e59917bbbc56ac2.png

30288505acd2bbfe4405ca479841db93.png

8f865ce2f962da02eb1dc77bd93f6e67.png

5. 服务器运维#

5.1 服务器硬件维护#

定期巡检：
- 需定期对服务器硬件进行巡检，查看服务器的外观是否有损坏迹象，比如机箱是否变形、指示灯是否正常亮起等。
- 检查服务器的各个硬件组件状态，包括硬盘、内存、CPU、电源等。例如通过服务器自带的管理工具或者硬件厂商提供的检测软件来查看硬盘的健康状态、内存的使用率等。
清洁保养：
- 服务器运行环境可能会有灰尘积累，定期清理服务器内部灰尘，可使用专业的清洁工具，如吹风机、毛刷等，防止灰尘影响硬件散热和正常运行。
- 对于服务器的散热系统，如风扇，要确保其正常运转，定期清理风扇叶片上的灰尘，必要时更换老化或故障的风扇，以保证服务器能在合适的温度环境下运行。

5.2 服务器系统维护#

操作系统更新：
- 及时安装操作系统的补丁和更新，这些更新通常包含了安全漏洞修复、性能优化等内容。可以通过系统自带的更新机制，如 Windows Server 的 Windows Update，Linux 系统的 yum 或 apt 等包管理工具来进行更新操作。
- 在更新前要做好备份工作，以防更新过程中出现问题导致系统故障无法正常启动等情况。备份内容可包括重要的系统配置文件、用户数据等。
系统监控：
- 利用监控工具对服务器系统的各项指标进行实时监控，如 CPU 使用率、内存使用率、磁盘 I/O、网络带宽等。常见的监控工具包括 Zabbix、Nagios 等。
- 通过对监控数据的分析，及时发现系统潜在的问题，比如当 CPU 长时间处于高使用率状态，可能需要排查是否有异常进程占用过多资源，进而采取相应的措施进行优化或处理。

5.3 服务器软件维护#

软件安装与卸载：
- 根据服务器的功能需求，正确安装所需的软件应用程序。在安装过程中要注意软件的版本兼容性，确保其与操作系统及其他已安装软件能够协同工作。
- 对于不再需要的软件，要及时进行卸载，以释放服务器的磁盘空间和系统资源，并避免可能存在的软件冲突或安全隐患。
软件配置管理：
- 对已安装的软件要进行合理的配置，使其能够满足服务器的业务需求。不同软件有不同的配置参数，例如 Web 服务器软件可能需要配置域名、端口、虚拟主机等参数。
- 定期备份软件的配置文件，以便在出现配置错误或软件故障时能够快速恢复到之前的正常配置状态。

5.4 服务器网络维护#

网络设备检查：
- 检查与服务器相连的网络设备，如交换机、路由器等的工作状态。查看设备的指示灯是否正常，端口连接是否稳定等。
- 定期对网络设备进行配置备份，以防设备出现故障或需要重新配置时能够快速恢复原有配置。
网络性能优化：
- 通过网络监控工具分析服务器的网络流量情况，识别网络瓶颈所在。例如，如果发现某段网络链路的带宽利用率过高，可能需要考虑升级带宽或者优化网络拓扑结构等措施。
- 合理设置服务器的网络参数，如 IP 地址、子网掩码、网关等，确保服务器能够在网络中正常通信，并根据业务需求优化网络协议的配置。

5.5 服务器安全维护#

用户权限管理：
- 严格管理服务器的用户账户和权限，只给予用户必要的访问权限。根据用户的工作职责和需求，为不同用户设置不同级别的权限，如管理员、普通用户等。
- 定期审查用户账户的使用情况，对于不再需要的账户要及时删除，防止账户被滥用而导致安全风险。
防火墙配置：
- 设置防火墙规则，允许合法的网络流量进入和离开服务器，同时阻止非法的入侵尝试。可以根据服务器的业务需求，定制化地设置防火墙的入站和出站规则。
- 定期更新防火墙的规则和策略，以适应不断变化的网络安全环境和业务需求。
数据备份与恢复：
- 制定完善的数据备份策略，定期对服务器上的重要数据进行备份。备份方式可以包括本地备份、异地备份等，备份介质可以是磁盘、磁带等。
- 定期进行数据恢复演练，确保在数据丢失或损坏的情况下能够快速有效地恢复数据，保障服务器业务的正常运行。

5.6 Ubuntu 常用运维命令#

5.6.1 系统信息查看命令#

uname：
- 用于打印系统相关信息，如内核版本等。例如，uname -a命令可以输出内核名称、主机名、内核发行版本、节点名、硬件平台、操作系统名称等详细的系统信息。这在确定系统的基本属性和内核相关细节时非常有用，比如在排查系统兼容性问题或者向技术支持提供系统信息时会经常用到。
lsb_release：
- 用于查看 Linux 发行版的信息。如lsb_release -a可以显示发行版的 ID、描述、版本号等内容。在维护包含多种 Linux 发行版的环境时，通过这个命令可以快速区分不同 Ubuntu 系统的版本，以便针对特定版本进行正确的软件安装或系统配置。

5.6.2 软件包管理命令#

apt - get：
- 这是 Ubuntu 中最常用的软件包管理工具。例如，apt - get update用于更新软件包列表，它会从软件源服务器获取最新的软件包信息，包括软件版本更新、新软件包添加等。apt - get upgrade则用于升级已经安装的软件包，将系统中的软件更新到最新版本。在执行升级操作时要谨慎，因为有时候软件更新可能会导致兼容性问题。
- 安装软件包可以使用apt - get install [package - name]，其中[package - name]是要安装的软件包名称，比如apt - get install apache2可以安装 Apache 服务器软件。卸载软件包使用apt - get remove [package - name]，不过这只会卸载软件本身，若要同时卸载软件的配置文件，可以使用apt - get purge [package - name]。
dpkg：
- 主要用于安装、卸载和查询.deb软件包。例如，dpkg -i [package - file.deb]用于安装一个本地的.deb软件包，dpkg -r [package - name]用于移除已安装的软件包。当需要手动安装一些没有包含在官方软件源中的软件包时，dpkg 就会发挥作用，不过在安装非官方软件包时也要注意软件的来源安全性。

5.6.3 用户和权限管理命令#

useradd：
- 用于添加新用户。例如，useradd [username]可以创建一个新的用户账户，系统会为该用户自动分配一个用户 ID 和默认的用户组。之后可以通过passwd [username]为新用户设置密码。在企业环境或者多用户使用的服务器中，根据不同人员的职责创建不同的用户账户是保障系统安全和权限管理的重要步骤。
chmod：
- 用于改变文件或目录的权限。权限模式有数字表示法和符号表示法。数字表示法如chmod 755 [file - name]，其中 7 代表所有者有读、写、执行权限，5 代表同组用户有读、执行权限，5 代表其他用户有读、执行权限。符号表示法如chmod u + rwx,g + rx,o + rx [file - name]，含义与数字表示法相同，这种方式更直观地表示了对用户（u）、组（g）和其他用户（o）权限的修改。通过合理设置文件和目录的权限，可以保护系统数据的安全性和保密性。

5.6.4 系统服务管理命令#

systemctl：
- 用于管理系统服务。例如，systemctl start [service - name]可以启动一个服务，如systemctl start ssh可以启动 SSH 服务，使服务器能够接受远程连接。systemctl stop [service - name]用于停止服务，systemctl restart [service - name]用于重新启动服务。在对服务器软件进行更新或者出现服务故障时，经常会用到这些命令来操作服务的启动、停止和重启。
- 可以使用systemctl status [service - name]查看服务的状态，包括服务是否正在运行、是否出现错误等信息。这对于排查服务相关的问题非常有帮助，例如当无法通过 SSH 连接服务器时，可以先查看 SSH 服务的状态来确定是否是服务本身出现故障。

5.6.5 网络管理命令#

ifconfig：
- 用于配置和显示网络接口信息。例如，ifconfig命令本身会显示所有网络接口的信息，包括 IP 地址、子网掩码、MAC 地址等。可以使用ifconfig [interface - name] [IP - address]来手动设置网络接口的 IP 地址，不过在 Ubuntu 较新的版本中，推荐使用ip命令来进行更复杂的网络配置操作。
ping：
- 用于测试网络连接性。例如，ping [destination - IP - or - hostname]可以向目标 IP 地址或主机名发送 ICMP 回显请求，以检查是否能够与目标建立网络连接以及网络延迟情况。在排查网络故障时，这是一个非常基础且实用的命令，比如当无法访问某个网站时，可以先通过 ping 网站的域名来查看是否能够解析域名以及网络是否可达。

5.7 DELL iDrac 风扇管理#

所需工具及准备：
- 确保已经开启了服务器的 IPMI 管理权限以及 iDrac 网口接入网络。
- 在 Ubuntu 系统中安装 ipmitool 管理工具，可通过命令 sudo apt install ipmitool 进行安装。
常用命令：
- 查看风扇状态：
  - ipmitool -I lanplus -H <iDrac_IP_Address> -U <Username> -P <Password> sensor list | grep Fan：该命令可以获取服务器风扇的相关传感器信息，帮助了解风扇的当前转速、状态等情况。例如，如果输出结果中显示 “Fan1 RPM: 3000”，则表示编号为 Fan1 的风扇当前转速为 3000 转 / 分钟。
- 关闭风扇自动控制47：
  - ipmitool -I lanplus -H <iDrac_IP_Address> -U <Username> -P <Password> raw 0x30 0x30 0x01 0x00：执行该命令后，服务器的风扇将不再根据系统的自动调节策略来控制转速，而是可以通过手动设置的方式来指定转速。
- 设置风扇转速：
  - ipmitool -I lanplus -H <iDrac_IP_Address> -U <Username> -P <Password> raw 0x30 0x30 0x02 0xff <hex_speed_value>：其中 <hex_speed_value> 是十六进制的风扇转速值。例如，要将风扇转速设置为 20%，可以将其转换为十六进制（即 0x14），然后命令为 ipmitool -I lanplus -H <iDrac_IP_Address> -U <Username> -P <Password> raw 0x30 0x30 0x02 0xff 0x14。
自动脚本示例2：
1. 创建脚本文件：首先创建一个名为 ipmitool_script.sh 的文件，并添加以下内容：

1
#!/bin/bash
2
# 设置 iDrac 的 IP 地址、用户名和密码
3
IDRAC_IP="Your IDRAC IP Address"
4
USERNAME="Your Username"
5
PASSWORD="Your Password"
6
# 关闭风扇自动控制
7
ipmitool -I lanplus -H $IDRAC_IP -U $USERNAME -P $PASSWORD raw 0x30 0x30 0x01 0x00
8
# 设置风扇转速为 15%（根据实际需求修改）
9
ipmitool -I lanplus -H $IDRAC_IP -U $USERNAME -P $PASSWORD raw 0x30 0x30 0x02 0xff 0x0f
10
# 检查上一个命令是否成功执行
11
if [ $? -eq 0 ]; then
12
    echo "Script executed successfully."
13
else
14
    echo "Script failed to execute."
15
fi

展开收起

赋予脚本执行权限：在终端中执行 chmod +x ipmitool_script.sh 命令，赋予脚本可执行权限。
创建系统服务：创建一个 systemd 服务来管理这个脚本的执行。在终端中输入 sudo nano /etc/systemd/system/ipmitool.service，并添加以下内容：

1
[Unit]
2
Description=IPMI Tool Script Service
3
After=network.target
4
[Service]
5
Type=simple
6
ExecStart=/path/to/your/script/ipmitool_script.sh
7
User=root
8
Group=root
9
[Install]
10
WantedBy=multi-user.target

请将 /path/to/your/script/ 替换为你的脚本实际所在的目录。 4. 设置定时任务：为了实现自动运行，创建一个定时器文件。在终端中输入 sudo nano /etc/systemd/system/ipmitool.timer，并添加以下内容：

1
[Unit]
2
Description=Run IPMI Tool Script every 30 minutes
3
[Timer]
4
OnBootSec=1min
5
OnUnitActiveSec=30m
6
Unit=ipmitool.service
7
[Install]
8
WantedBy=timers.target

启动服务和定时器：在终端中依次执行以下命令来启用并启动服务和定时器：

1
sudo systemctl enable ipmitool.service
2
sudo systemctl start ipmitool.service
3
sudo systemctl enable ipmitool.timer
4
sudo systemctl start ipmitool.timer

检查状态：使用 sudo systemctl status ipmitool.service 和 sudo systemctl status ipmitool.timer 命令检查服务和定时器的状态，确保它们正常运行。

通过以上步骤，就可以在 Ubuntu 系统中实现对 DELL iDrac 风扇的管理和自动控制。在设置风扇转速时，需要根据服务器的实际情况和散热需求进行合理调整，避免因风扇转速过低导致服务器过热而损坏硬件。

高中信息技术之递归题解（一）

Sun, 06 Oct 2024 00:00:00 GMT

1. 爬楼梯#

爬一个 n 级楼梯，他一步可以最多爬 k 级楼梯，并且他每步至少爬一级台阶（他不能爬小数级台阶，也不能往回走）。

输入两个数 n 和 k ，你需要输出 n 个数，分别表示他走 1 步爬完楼梯的方案数，走 2 步爬完楼梯的方案数，⋯，走 n 步爬完楼梯的方案数。

1
ans = [0 for _ in range(1145)]
2

3
def solve(step, height):
4
    if(height > n):
5
        return
6
    elif(height == n):
7
        ans[step] += 1
8
        return
9
    else:
10
        for i in range(1, k+1):
11
            solve(step+1, height+i)
12

13
n, k = map(int, input().split())
14
solve(0, 0)
15
print(*ans[1:n+1])

展开收起

首先确定递归函数所要包含的状态：步数和爬到了第几级。然后确定边界条件：当超过了 height 时，即为到达终点，那么给当前步数的方案数加上一。最后确定起始条件：刚开始步数为 000 ，也是在第 0 00 个台阶。

2. 跷跷板#

有 n 个人在玩翘翘板，你需要将这 n 个人分成两组，使他们的体重差最小。

2.1 常规做法#

考虑到对于每个人，可以将其体重放到组A，也可以放到组B，那么我们就可以在每一个分支的时候进行两种情况的下一轮递归。代码如下：

1
g1 = []
2
g2 = []
3
ans = 11145141919810
4
def dfs(step):
5
    global ans
6
    if(step==n):
7
        ans = min(ans, abs(sum(g2) - sum(g1)))
8
    else:
9
        g1.append(w[step])
10
        dfs(step+1)
11
        g1.pop(-1)
12
        g2.append(w[step])
13
        dfs(step+1)
14
        g2.pop(-1)
15

16
n = int(input())
17
w = list(map(int, input().split(" ")))
18

19
dfs(0)
20
print(ans)

展开收起

其中， g1 g2 为体重的列表。当步数到达 nnn 时即为到达终点，那么计算最小体重差；否则进行枚举，若选取其到组A，就放进去；然后考虑组B，但在考虑组B前，要先清除之前的状态，我们称之为回溯，先 pop 掉之前数组里的内容，然后再进行新的枚举。

2.2 二进制枚举#

对于这类 0/1 问题，我们还可以使用二进制枚举，使得空间更小且时间复杂度常数更小。

1
bi = 0
2
n = int(input())
3
a = list(map(int, input().split()))
4
ans = 1145141919810
5

6
while bi < (1 << (n + 1)):
7
    su = [0, 0]
8
    for i in range(n):
9
        stat = 1 & (bi >> i)
10
        su[stat] += a[i]
11
    ans = min(abs(su[0] - su[1]), ans)
12
    bi += 1
13
print(ans)

对于每一个二进制位，它表示的是组A或组B，然后进行计算。

3. 数的拆分#

任何一个大于 1 的自然数 n，总可以拆分成若干个小于 n 的自然数之和。

现在给你一个自然数 n，要求你求出 n 拆分成一些数字的和的方式。

假设当前 dfs 传进来一个要拆分的数字。那么，我们可以考虑先从这个大数中分离出一个小数出来。显然，这个小数的范围为 0∼(n−1)0 \sim (n-1)0∼(n−1) 。又因为我们需要将数字从小到大排列，那么在枚举拆出来的小数的时候，从已拆出数列表的最后一个开始枚举起即可。

1
n = int(input())
2
arr = []
3
def dfs(step):
4
    if(sum(arr)==n):
5
        for i in range(len(arr)):
6
            print(arr[i], end="+" if i != len(arr)-1 else "\n")
7
    elif(sum(arr)>n):
8
        return
9
    else:
10
        if(not arr):
11
            for i in range(1, n):
12
                arr.append(i)
13
                dfs(step+1)
14
                arr.pop(-1)
15
        else:
16
            for i in range(arr[-1], n - sum(arr) + 1):
17
                arr.append(i)
18
                dfs(step+1)
19
                arr.pop(-1)
20
dfs(0)

展开收起

4. 全排列#

按照字典序从小到大输出长度为 n 的全排列。

首先生成一个从 1∼n 1 \sim n1∼n 的数列，然后新引入一个标记是否用过的数组 used ，如果已经使用过，那么在下一轮递归的时候就不考虑再使用这个数字了。

1
n = int(input())
2
arr = []
3
used = [False for i in range(n+1)]
4
def dfs(step):
5
    if(len(arr)==n):
6
        print(*arr)
7
    else:
8
        for i in range(1, n+1):
9
            if(not used[i]):
10
                used[i] = True
11
                arr.append(i)
12
                dfs(step+1)
13
                used[i] = False
14
                arr.pop(-1)
15
dfs(0)

展开收起

5. 走迷宫#

斯宝走进了另一个迷宫。

这个迷宫共有 n×m 个格子，第 i 行第 j 个格子用 (i,j) 表示。

每个格子共有两个状态：

. 表示这个位置是个空地，可以行走。
# 表示这个位置是堵墙，不能行走，也不能穿过。

斯宝每次可以从一个位置，向上下左右四个方向走一格，但是不能跃出迷宫外。具体的，如果她在 (i,j) ，那么她可以到达 (i−1,j),(i,j−1),(i+1,j),(i,j+1) 四个位置（如果四个位置都在迷宫内）。

斯宝一开始在 (1,1) 位置，她希望能走到 (n,m) ，可是她现在在迷宫里面，所以请求你帮助她求出任意一种，能到达 (n,m) 的方案。

如果没有可行的方案，输出 -1。

保证 (1,1) 和 (n,m) 两点为空地。

这是属于图的搜索，对于每一点，我们可以从上、下、左、右四个方向进行下一轮递归。递归时注意边界，不能越界；同时保存路径，在回溯时及时弹出旧的废弃路径。

1
inp = input().split()
2
n, m = int(inp[0]), int(inp[1])
3
mp = []
4
for i in range(n):
5
    s = input()
6
    mp.append([c for c in s])
7

8
# print(n, m, mp)
9

10
vis = [[False] * m for _ in range(n)]
11
path = []
12
Flag = False
13

14
def output():
15
    print(len(path))
16
    for i in path:
17
        print(i[0] + 1, i[1] + 1)
18

19
def dfs(x, y):
20
    path.append((x, y))
21
    if x == n - 1 and y == m - 1:
22
        Flag = True
23
        output()
24
        exit(0)
25
    vis[x][y] = True
26
    dx = [-1, 0, 1, 0]
27
    dy = [0, 1, 0, -1]
28
    for i in range(4):
29
        nx = x + dx[i]
30
        ny = y + dy[i]
31
        if nx >= 0 and nx < n and ny >= 0 and ny < m and not vis [nx][ny] and mp[nx][ny] == '.':
32
            dfs(nx, ny)
33
    path.pop()
34

35
dfs(0, 0)
36

37
if not Flag:
38
    print(-1)

展开收起

《东渡西归》—— 记我的同学孙G

Sat, 28 Sep 2024 00:00:00 GMT

孙G，江湖人称孙巨，有着一副眼镜和眼睛下极小的眼睛。当然，摘下眼镜后，孙G会不自然地眯上眼睛，使得其变得更小、微乎其微而不可见了。自孙G获得数学省一后，江湖间流传有诗云：**

孙家有子才华溢，

巨浪滔天志不移。

省身修德心常静，

一片丹心照古今。

一#

孙G是一名数竞生，深受同学们的喜爱。每当孙G轻松AK一场考试，同学们总会发出惊叹声：“mol 孙G！”（意味：膜孙巨！）此外，孙G常在教室中冥思苦想，他妖娆的坐姿让华反动拍下了许多令人难忘的相片。然而，偷拍也有失败的时候。孙G在思考的同时仍然警惕地观察周边环境，一旦目光扫及狗仔队之处，就一把抢走华反动的平板。同时，孙G会毫不留情地批判道：“华反动，又在拍我！”但华反动在较劲中终究没有让平板给抢去，因为他的平板里已经存储了数以百计道孙G照片，一旦暴露，后果不堪设想。在捕获照片后，华反动熟练地将照片导入扫描文稿程序，然后进行奇怪的拉伸和二值化，使得孙G千变万化、人模鬼样了。

二#

那莫，看到这里，有的读者可能要问了：“华反动，何许人也？”其实，“华反动”并非真的反动分子，只不过因为他为孙G照相惹恼了孙G。而孙G，他爱党爱国爱人民，所以在面对华反动岂有此理地行为时，称其为“华反动”。**

孙G的爱党爱国爱人民是人尽皆知的。上中国近代史的时候，孙G总能激动地大声称赞；以至于每次上历史课前都激情澎湃地向历史老师问好，声压群雄。尽管学考已经结束，但当他在路上碰到历史老师的时候，大声喊道：“俞！老！师！好！”就连这位日常幽默风趣的历史老师也羞于抬头回礼了，只得低头灰溜溜地逃走了。一旁的人评论道：“还有高手！”

上政治课可是更不必说了，青春大舞台尽情绽放。每当谈及中国特色社会主义，安静了很长时间的孙G突然冒出来一句：“哇！”其音调铿锵有力、掷地有声，令人心生钦佩。此事，全班同学都会异口同声、大声道：“哇！孙G——”

三#

不仅是课上，课下孙G也保持着自我的政治素养和节操。每当遇到生死攸关的问题时，他总能遵循内心的声音、做出一针见血的评论，或是赞扬、或是批判。例如，全班换座位后，孙G的位置被调换到了墙壁边上，这就意味着，他想要进出就必须先请他的同桌让开。对于如此重要的问题，孙G便向他的同桌黄某说：“同桌，又到了中华民族生死存亡的危急时刻，”或者是：“同桌，考验你革命友谊的时刻到了！”黄某先是一惧怕，随后方才明白其意，起身让开位置。或者，孙G问我借餐巾纸，不好意思地问道：“能否与我几张，挽救中华民族生死之希望？”插句题外话，如果孙G不知道为什么不想请求他的同桌让开，他便会推开窗户夺墙而走/入。别担心，墙外面是走廊。

对于内卷者，孙G也是极为痛恨的。教室里，孙G最害怕别人说他卷了。当然，这也意味着他常常批判他人的内卷。“赵卷狗，你又嘤嘤狂吠！”这就是他批判同寝室同学的情景。

四#

孙G可谓文理双全者，堪称国学大师。首先，他通晓红楼梦，每次红楼梦默写都能轻松满分，对同学的疑问也能对答自如。其次，孙G最爱用文言进行消息传达。以下摘出几条聊天记录：

“致苹果同学，水是生命之源，为使我的小命不在寝室枯竭，劳驾您或xx回寝时顺手携回我之水杯，救人一命胜造七级浮屠，谢谢。

“食堂存在大量触目惊心的浪费现象，我们身为新时代之少年，既然享有自由选择菜品的权利，便应肩负起践行光盘行动的义务。五谷者，天地之精华；禽兽者，山川之儿女。人类身为万物之灵长，荼毒万物之肝脑，以供一己口腹之欲，若还心安理得地将其断肢残躯付诸泔水，于心何忍？八万里环球，尚有饥饿民嚎泣；五千年华夏，不乏饿殍曝野。蕞尔美国，常设感恩之节；莘莘学子，岂无惜物之心。物质条件的优渥不意味着精神文明的贫瘠，愿学校加强监管，食堂适量准备，同学们厉行光盘，共创节俭校园。”

写到这里，笔者不得不发出由衷之言：“孙G**！”**

五#

最近，坐在孙G周围的同学都迷上了孙G的口粮：味丹饼干。这本来是来不及去食堂的孙G随时随地的早饭，但不知什么原因，黄某经常问孙G要一包吃吃。一开始，孙G还很乐意与同学分享美味，可是久而久之，孙G发现自己的袋子里的饼干越来越少，不禁思索道：“这难道不是‘巧取豪夺’吗？”黄某听了也为自己的行为感到羞愧，并当即表示请孙G吃饭，或者给孙G充值10r**。**

不仅是饼干潮，孙G认真阅读了《南渡北归》三全集。本来旁边的同学对此没有什么感觉，直到有一天黄某闲来无事也翻开了《南渡北归》，发现了其中的奥妙，从此陷入其中一蹶不振了。每当同学们讨论起来，都会不由得赞叹一声：“孙G**！”**

所谓高手在民间，孙G还有一项隐藏技能——绘画，当您翻开孙G的草稿纸，看吧，那栩栩如生的二郎神便跃然纸上了。

六#

尽管孙G在原则问题上深明大义，但他在平日里素然是一位和蔼可爱的人。当你问他数学问题，他先会眯上眼睛推推眼镜，然后不好意思地说：“啊？不要看我，我一点都不会的……”然后又在草稿纸上演算起来，没几秒钟就在你的面前呈现精准的答案。

这，就是孙G——正义、热情而害羞。虽然他还没有成为一名团员，但我们全班同学都十分喜爱他，都希望他早日成为一名入队的社会主义建设者、共产主义接班人！

watchOS11初体验

Tue, 17 Sep 2024 00:00:00 GMT

9月17号，苹果全线新系统正式版全部发布。笔者也是第一点五时间升级到了 watchOS11 ，一探究竟。

Image

表盘#

首先来看表盘。本次新增了三种表盘，分别是反射、流转和 AI 照片排版。

在流转表盘中，时间数字以大号显示，且在进入下一分钟时各个数字会变换大小，相互嵌入。两种配色也会随着时间变化而变化。

Image

全天候显示下的数字显示：

Image

这是反射表盘，看着不是很聪明的样子。

Image

应用#

然后来看应用更新。首先新增的应用有：潮汐、生命体征（ Vital App ）和翻译。

生命体征需要6天的睡眠记录才能显示更多信息，所以这里仍然是空白的。

Image

翻译软件在 watchOS 上得到了适配，可以语音输入、实时翻译。

Image

潮汐能够显示各地的潮汐时间。

Image

其他#

除此之外，还有些地方得到了更新。在输入键盘中，新增了选择输入方式和切换语言的样式，显得更加灵动。

Image

在 iMessage 中，双击消息，可以看到更多的表情回复。

Image

设置中新增了“智能叠放”这一选项，应当是为小组件设计的。

Image

“平安确认”功能可以报个平安。

Image

血氧样式更新：下方的按钮衬托在背景之上变得半透明，不像之前和背景是在同个层级上的。

Image

锻炼中也融入了生命体征。

Image

Python学习笔记之类

Wed, 28 Aug 2024 00:00:00 GMT

1 类练习一#

你有一个形如 ax2+bx+cax^2+bx+cax2+bx+c 的多项式，你要支持如下的操作：

1 A B C 将当前多项式加上 Ax2+Bx+CAx^2+Bx+CAx2+Bx+C。
2 A 将当前多项式加上 Ax2+Ax+AAx^2+Ax+AAx2+Ax+A。
3 询问 ax2+bx+c=0ax^2+bx+c=0ax2+bx+c=0 解的个数。
4 输出当前多项式。

1.1 示例程序：#

1
class MyClass:
2
    import math
3
    def __init__(self, a, b, c):
4
        self.a = a
5
        self.b = b
6
        self.c = c
7

8
    def __add__(self, other):
9
        return MyClass(self.a + other.a, self.b + other.b, self.c + other.c)
10

11
    def add(self, A):
12
        self.a += A
13
        self.b += A
14
        self.c += A
15

16
    @staticmethod
17
    def que(poly):
18
        a, b, c = poly.a, poly.b, poly.c
19
        if a == 0:
20
            if b == 0:
21
                return 0 if c != 0 else float('inf')
22
            return 1
23
        discriminant = b * b - 4 * a * c
24
        if discriminant > 0:
25
            return 2
26
        elif discriminant == 0:
27
            return 1
28
        else:
29
            return 0
30

31
    def __str__(self):
32
        a_str = str(self.a)
33
        if self.b >= 0:
34
            b_str = "+" + str(self.b)
35
        else:
36
            b_str = "-" + str(-self.b)
37
        if self.c >= 0:
38
            c_str = "+" + str(self.c)
39
        else:
40
            c_str = "-" + str(-self.c)
41

42
        if self.b == 0 and self.c == 0:
43
            return a_str + "*x^2"
44
        elif self.b == 0:
45
            return a_str + "*x^2" + c_str
46
        elif self.c == 0:
47
            return a_str + "*x^2" + b_str + "*x"
48
        else:
49
            return a_str + "*x^2" + b_str + "*x" + c_str

展开收起

1.2 特殊方法与普通方法#

首先我们注意到，有些函数是由带着前后的 __ ，而有些函数是直接的名称。在 Python 中，带有双下划线 __ 的函数（称为“特殊方法”或“魔法方法”）与普通方法有几个显著的区别：

1.2.1 特殊方法（魔法方法）#

定义: 特殊方法是以双下划线开始和结束的方法，例如 __init__, __add__, __str__, __eq__ 等。
目的: 这些方法是 Python 的内置机制的一部分，提供了对 Python 内建操作的自定义。它们允许用户定义对象的行为，使其能够响应特定的操作或行为。
用法:
- __init__: 构造函数，用于初始化对象。
- __add__: 实现加法操作 (+) 的行为。
- __str__: 定义对象的字符串表示。
- __eq__: 定义对象的相等性比较（==）。
- __call__: 使对象能够像函数一样被调用。
这些方法通常不直接调用，而是通过运算符或内置函数间接调用。例如，obj + other 会调用 obj.__add__(other)。
特殊性: 特殊方法在 Python 内部有特殊的作用，它们定义了对象在特定操作中的行为。它们是 Python 数据模型的一部分，并且可以被 Python 的内置函数和操作所自动调用。

1.2.2 普通方法#

定义: 普通方法是类中定义的以单个下划线或没有下划线的函数，例如 add, subtract, display 等。
目的: 这些方法用于定义类的实例可以执行的行为或操作。它们通常用于实现类的业务逻辑。
用法:
- add: 例如，用于执行类实例的某个具体操作，可能改变实例的状态或执行计算。
- display: 显示对象的状态或信息。
普通方法可以被实例通过点运算符调用，例如 obj.add(value)。
特殊性: 普通方法不具备特殊的内置功能或自动触发机制，它们是用户定义的用于实现类功能的普通函数。

1.2.3总结#

特殊方法:
- 由双下划线包围（如 __init__, __add__）。
- 与 Python 内部机制和运算符操作相关。
- 通常不直接调用，而是通过 Python 内置操作间接调用。
- 用于自定义对象在内建操作中的行为。
普通方法:
- 没有双下划线。
- 用于实现类的具体业务逻辑。
- 通过对象实例直接调用。

1.3代码详解#

1.3.1 导入模块#

1
import math

import math：导入 Python 的数学模块。

1.3.2 初始化函数 `init`#

1
def __init__(self, a, b, c):
2
    self.a = a
3
    self.b = b
4
    self.c = c

功能: 构造函数，用于初始化 MyClass 的实例。
参数:
- a：二次项的系数。
- b：一次项的系数。
- c：常数项的系数。
作用: 当创建 MyClass 的实例时，a、b 和 c 将被赋值给实例的属性 self.a、self.b 和 self.c。

1.3.3 加法运算符重载 `add`#

1
def __add__(self, other):
2
    return MyClass(self.a + other.a, self.b + other.b, self.c + other.c)

功能: 实现加法运算符 + 的重载，使得两个 MyClass 实例可以通过 + 操作符相加。
参数:
- other：另一个 MyClass 实例。
返回: 返回一个新的 MyClass 实例，其系数是两个实例对应系数的和。

1.3.4 修改系数 `add`#

1
def add(self, A):
2
    self.a += A
3
    self.b += A
4
    self.c += A

功能: 将指定值 A 加到多项式的所有系数上。
参数:
- A：要加到每个系数的值。
作用: 修改当前实例的系数 a、b 和 c，使它们都增加 A。

1.3.5 静态方法 `que`#

1
@staticmethod
2
def que(poly):
3
    a, b, c = poly.a, poly.b, poly.c
4
    if a == 0:
5
        if b == 0:
6
            return 0 if c != 0 else float('inf')
7
        return 1
8
    discriminant = b * b - 4 * a * c
9
    if discriminant > 0:
10
        return 2
11
    elif discriminant == 0:
12
        return 1
13
    else:
14
        return 0

功能: 求解二次方程 ax^2 + bx + c = 0 的根的个数。
参数:
- poly：MyClass 的实例，表示一个二次多项式。
返回:
- 0：无实根。
- 1：有一个实根（重根）。
- 2：有两个不同的实根。
- float('inf')：当 a 和 b 都为 0 且 c 不为 0 时，返回无解。

1.3.6 字符串表示 `str`#

1
def __str__(self):
2
    a_str = str(self.a)
3
    if self.b >= 0:
4
        b_str = "+" + str(self.b)
5
    else:
6
        b_str = "-" + str(-self.b)
7
    if self.c >= 0:
8
        c_str = "+" + str(self.c)
9
    else:
10
        c_str = "-" + str(-self.c)
11

12
    if self.b == 0 and self.c == 0:
13
        return a_str + "*x^2"
14
    elif self.b == 0:
15
        return a_str + "*x^2" + c_str
16
    elif self.c == 0:
17
        return a_str + "*x^2" + b_str + "*x"
18
    else:
19
        return a_str + "*x^2" + b_str + "*x" + c_str

展开收起

功能: 返回多项式的字符串表示形式。
构造:
- a_str、b_str、c_str：分别表示 a、b 和 c 的字符串形式。
- 根据 b 和 c 的符号，格式化字符串，确保 + 和 - 正确显示。
返回: 多项式的标准字符串格式，如 2*x^2 - 3*x + 4。

1.4 静态方法修饰器#

在 Python 中，静态方法（@staticmethod）和普通方法（实例方法）有以下主要区别：

1.4.1 定义和调用方式#

静态方法（@staticmethod）:
- 定义: 使用 @staticmethod 装饰器定义的方法，不需要 self 参数。
- 调用: 可以通过类或实例调用，且不依赖于类的实例。调用时不传递实例或类作为参数。
- 示例:
```
1
class MyClass:
2
    @staticmethod
3
    def my_static_method():
4
        print("This is a static method")
5

6
MyClass.my_static_method()  # 通过类调用
```
普通方法（实例方法）:
- 定义: 普通方法定义时需要 self 参数，用于访问实例的属性和其他方法。
- 调用: 必须通过类的实例来调用，调用时自动传递实例作为第一个参数。
- 示例:
```
1
class MyClass:
2
    def my_instance_method(self):
3
        print("This is an instance method")
4

5
obj = MyClass()
6
obj.my_instance_method()  # 通过实例调用
```

1.4.2 访问权限#

静态方法:
- 不访问类的属性或实例的属性。
- 适合执行与类的实例无关的任务，如工具函数或辅助函数。
普通方法:
- 可以访问和修改实例的属性和方法。
- 适合实现与实例状态相关的操作和行为。

1.4.3. 使用场景#

静态方法:
- 用于实现功能性代码，与对象的状态无关。
- 适合需要与类相关，但不依赖于类或实例状态的函数。
普通方法:
- 用于操作实例的状态或执行依赖于实例的操作。
- 适合需要访问和修改对象的内部数据或状态的函数。

2 拓展：关于类的其他修饰器#

除了 @staticmethod 和普通方法，还有其他几种常用的类修饰器（装饰器）和方法修饰器，主要包括：

2.1 类方法（`@classmethod`）#

定义: 使用 @classmethod 装饰器定义的方法，第一个参数是 cls，表示类本身，而不是实例。
调用: 可以通过类或实例调用。调用时自动传递类作为第一个参数。
用途: 适合访问或修改类的状态（而非实例状态），例如工厂方法或替代构造函数。

示例:

1
class MyClass:
2
    class_var = 0
3

4
    @classmethod
5
    def increment_class_var(cls):
6
        cls.class_var += 1
7

8
    @classmethod
9
    def create_instance(cls):
10
        return cls()
11

12
MyClass.increment_class_var()  # 通过类调用
13
instance = MyClass.create_instance()  # 通过类调用

2.2 属性方法（`@property`）#

定义: 使用 @property 装饰器定义的方法，使其表现得像一个属性，而不是方法。
调用: 通过访问属性的方式调用，而不是通过方法调用。
用途: 适合将计算结果或只读值暴露为属性而不是方法。

示例:

1
class MyClass:
2
    def __init__(self, value):
3
        self._value = value
4

5
    @property
6
    def value(self):
7
        return self._value
8

9
    @value.setter
10
    def value(self, new_value):
11
        self._value = new_value
12

13
obj = MyClass(10)
14
print(obj.value)  # 通过属性访问
15
obj.value = 20  # 通过属性设置

展开收起

2.3 只读属性方法（`@property` 的只读部分）#

定义: @property 使方法表现为只读属性，不提供 setter 方法。
用途: 适合提供只读的属性访问，而不允许修改。

示例:

1
class MyClass:
2
    def __init__(self, value):
3
        self._value = value
4

5
    @property
6
    def value(self):
7
        return self._value
8

9
obj = MyClass(10)
10
print(obj.value)  # 通过属性访问
11
# obj.value = 20  # AttributeError: can't set attribute

2.4 `@staticmethod` 和 `@classmethod` 的组合#

定义: 可以在一个类中同时使用静态方法和类方法，以实现不同的功能需求。

示例:

1
class MyClass:
2
    @staticmethod
3
    def static_method():
4
        print("This is a static method")
5

6
    @classmethod
7
    def class_method(cls):
8
        print("This is a class method")
9

10
MyClass.static_method()
11
MyClass.class_method()

解决反代code-server出现websocket连接错误

Wed, 21 Aug 2024 00:00:00 GMT

使用 nginx 反代 code-server 时，使用默认配置，会出现以下错误：

The workbench failed to connect to the server (Error: WebSocket close with status code 1006)

1.png

找到 1panel 的网站 - 网站设置 - 反向代理 - 源文中，

屏幕截图_21-8-2024_1733.jpeg

替换为以下内容：

1
location ^~ / {
2
    proxy_pass http://127.0.0.1:40035;
3
    add_header Access-Control-Allow-Origin *;
4
     add_header Access-Control-Allow-Methods *;
5
     add_header Access-Control-Allow-Headers *;
6

7
     # proxy_ssl_verify off;
8
     proxy_set_header Host $host;
9
     proxy_set_header Accept-Encoding gzip;
10
     #proxy_set_header X-Forwarded-Host $host;
11
     proxy_set_header X-Forwarded-Host $host:$server_port;
12

13
     proxy_set_header Upgrade $http_upgrade;
14
     proxy_set_header Connection $http_connection;
15
     proxy_http_version 1.1;
16
}

展开收起

这样就能使得 Websocket 协议顺利通过反向代理。然后就能顺利访问、不会有任何问题了：

屏幕截图 2024-08-21 170013.png

2024年8月9日采风

Fri, 09 Aug 2024 00:00:00 GMT

FullSizeRender.jpeg

FullSizeRender 2.jpeg

IMG_0067.jpeg

IMG_9964.jpeg

IMG_9996.jpeg

IMG_0021.jpeg

FullSizeRender 3.jpeg

FullSizeRender 4.jpeg

海边的风景总是让人心旷神怡，它以无尽的魅力吸引着世界各地的游客。清晨，当第一缕阳光穿透云层，洒在波光粼粼的海面上，整个海滩便被染上了一层金色的光辉。海浪轻轻拍打着岸边，发出柔和而有节奏的声响，伴随着海鸥的叫声，构成了大自然最和谐的乐章。

随着太阳升高，沙滩上开始热闹起来。孩子们在沙滩上追逐嬉戏，堆砌着沙堡，而大人们则在海边散步，享受着温暖的阳光和清新的海风。远处，帆船点点，与蓝天白云相映成趣，构成了一幅动人的画面。

傍晚时分，海边的风景又呈现出另一番景象。夕阳西下，天边的云彩被染成了绚丽的橙红色，海水在夕阳的映照下泛着金光，整个海面仿佛被点燃了一般。海浪在这个时候变得更加温柔，轻轻地抚摸着沙滩，似乎在诉说着一天的结束。

夜幕降临，海边的灯火逐渐亮起，与星光交相辉映。人们围坐在篝火旁，享受着夜晚的宁静和凉爽。海浪的声音在夜色中变得更加清晰，伴随着远处渔船上的灯光，让人不禁沉浸在这份宁静与美好之中。

海边的风景，无论是在白天还是夜晚，都有着它独特的魅力，让人流连忘返，心旷神怡。

获取中兴光猫 F652 超级密码

Thu, 25 Jul 2024 00:00:00 GMT

首先连接上你家光猫的网络，如图所示。

2024-07-25 13.55.23.png

然后访问以下链接 http://192.168.1.1/common_page/File_Download_lua.lua?downtype=0&IF_FILEPATH=/userconfig/cfg/db_user_cfg.xml&IF_FILENAMEUTF8=db_user_cfg.xml&，浏览器会自动下载来一个 .xml 文件。

2024-07-25 13.57.10.png

但这个文件是经过加密的，我们不能直接打开。需要进行解密。

在 .xml 文件的同目录下，新建一个 Python 文件，文件名任意。以下是代码内容：

1
import zlib
2
import struct
3
import os
4

5
def unzip_config(fname: str) -> str:
6
    if not os.path.exists(fname):
7
        print('文件不存在！')
8
        return ''
9

10
    with open(fname, 'rb') as f:
11
        next_off = 60
12
        result = bytearray()
13

14
        while next_off > 0:
15
            f.seek(next_off)
16

17
            # 读取缓冲区大小
18
            buffer_size = struct.unpack('>I', f.read(4))[0]
19

20
            # 读取压缩块大小
21
            block_size = struct.unpack('>I', f.read(4))[0]
22

23
            # 读取下一块位置
24
            next_off = struct.unpack('>I', f.read(4))[0]
25

26
            # 复制压缩数据块到临时数据流
27
            compressed_data = f.read(block_size)
28

29
            # 解压数据块
30
            decompressed_data = zlib.decompress(compressed_data)
31

32
            # 将解压后的数据添加到结果
33
            result.extend(decompressed_data)
34

35
        return result.decode('utf-8')
36

37
def write_output(data: str, output_fname: str):
38
    with open(output_fname, 'w', encoding='utf-8') as f:
39
        f.write(data)
40

41
# 使用示例
42
result = unzip_config('db_user_cfg.xml')
43
if result:
44
    write_output(result, 'output.xml')
45
    print('结果已写入 output.xml')

展开收起

感谢 52pojie 大佬 yulinsoft 提供的源 Delphi 代码，这里转成了 Python 罢了。原文详见：https://www.52pojie.cn/thread-1005978-1-1.html

在当前目录的终端中，输入命令：

Terminal window

1
python3 encrypt.py # 这里改成你的文件名

程序完成后，会显示：结果已写入 output.xml 。此时打开 output.xml ，就是解密后的文件。用记事本等程序打开，直接搜索 telecomadmin ，就能找到相应的超级密码了。

2024-07-25 13.59.30.png

登录进去即可。

交大荣昶杯游记Day3

Wed, 17 Jul 2024 00:00:00 GMT

2 人工智能#

2.1 人工智能简介#

人工智能（Artificial Intelligence，AI）是研究、开发用于模拟、延伸和扩展人的智能的理论、方法、技术及应用系统的一门新的技术科学。人工智能是计算机科学的一个分支，它企图了解智能的实质，并生产出一种新的能以人类智能相似的方式做出反应的智能机器，该领域的研究包括机器人、语言识别、图像识别、自然语言处理和专家系统等。

图灵测试：图灵测试是由英国数学家艾伦·图灵于1950年提出的，用于衡量机器是否具有人类智能的测试。图灵测试的基本思想是：一个人类评判者通过计算机终端与一个隐藏在另一房间的人和计算机终端进行对话，如果评判者无法分辨哪个是人，哪个是计算机，那么计算机就通过了测试。

2.2 手动标注数据#

手动标注数据是指人工对数据进行标注，将数据转化为计算机可以识别的数据。手动标注数据是人工智能的基础，是训练模型的第一步。手动标注数据的过程是耗时耗力的，但是标注的数据质量高，是训练模型的基础。

截屏2024-07-17 08.45.55.png

2.3 模型选择#

Residual Networks, or ResNets, learn residual functions with reference to the layer inputs, instead of learning unreferenced functions. Instead of hoping each few stacked layers directly fit a desired underlying mapping, residual nets let these layers fit a residual mapping.

2.4 模型训练#

2.4.1 转成数据集#

把图片变成 224×224224 \times 224224×224 的矩阵
将 xxx 的值整流到 [−1,1][-1, 1][−1,1] 之间。

2.4.2 训练#

我们往往从网上先下载一个下载一个 pre-trained model ，这样能有效地大大缩短训练时间，因为只需要调整模型中的参数即可。

每训练一次，就会测试一下 losslossloss 是多少。如果这一次训练比上一次更准确，那么就会保存当前更优的模型；否则就不记录。

3 小车启动命令#

Terminal window

1
ros2 launch originbot_bringup originbot.launch.py # 启动底盘
2
ros2 launch originbot_bringup camera_internal.launch.py # 启动摄像头
3
ros2 launch originbot_bringup ydlidar.launch.py # 启动摄像头
4
ros2 run racing_track_detection_resnet racing_track_detection_resnet # 启动车道线检测
5
python3 /userdata/dev_ws/src/originbot/racing_track_detection_resnet/lanedetection.py # 启动小车跑路

交大荣昶杯游记Day2

Tue, 16 Jul 2024 00:00:00 GMT

1 ROS2与视觉操作#

1.1 前世今生#

201几年，服务机器人，斯坦福大学本来想做一个家务活的机器人，其中最复杂的一项是叠衣服，“不重复造轮子”，开发一套系统，目的：比较复杂的系统分成各个模块；将模块作为通用性的模块，用到其他机器人上。

ROS：Robot Operating System 机器人操作系统。他只是Linux发行版，用于机器人上，但不是真正的操作系统。分布式构建，数据在各个节点上流通。开源系统，庞大的生态社区。

1.2 工作空间和功能包#

工作空间（workspace），在 dev_ws 目录下。

下面有五个子目录，其中前四个较为重要：

src：代码空间
install：安装空间
build：编译空间
log：日志空间
config：配置文件

调用ROS有两种方法：

调用单个指令（aka “节点”）：ros2 run

Terminal window

1
ros2 run teleop_twist_keyboard teleop_twist_keyboard

功能包：功能相似的节点的集合，放到一起去，如 teleop_twist_keyboard。

例如，我们要制作的就是一个小车车道线识别的一个功能包。

运行多个节点，相当于批处理：ros2 launch，文件名需要为 ***.launch.py 。就不用你开很多终端会话运行很多个 ros2 run 了。

Terminal window

1
ros2 launch originbot_bringup originbot.launch.py

1.3 ROS2命令行操作#

查看节点信息：ros2 node list ，多个节点之间实现消息的互通，来操控小车。
查看话题信息：ros2 topic list
- ros2 topic info <topic_name>：查看话题的详细信息
- ros2 topic echo <topic_name>：查看话题的消息

1.4 小车运动参数#

一个物体，有六个自由度，其中三个方向的直线运动，再加上三个角度的旋转运动。

对小车而言，它是在平面上运动的，只剩下两个自由度：直线运动（沿x轴），转弯（绕z轴）。

所以想要控制小车，只需要给它两个值：一个是线性速度，另一个是角速度。

话题: cmd_vel
消息: Twist (标准)
from geometry_msgs.msg import Twist
速度: twist.linear.x
转角: twist.angular.z
使用:

1
cmd_vel_pub = create_publisher(Twist, 'cmd_vel', 10)
2
twist.linear.x = 0.1
3
twist.angular.z = 0.2
4
cmd_vel_pub.publish(twist)

在这个案例中，键盘是一个节点，小车控制又是一个节点，键盘按下，转成一个消息，通过话题传给小车控制节点，小车控制节点接收到消息，解析消息，控制小车。

1.5 观测数据流动#

第一位同学：

Terminal window

1
ros2 launch originbot_bringup originbot.launch.py

第二位同学：

Terminal window

1
ros2 run teleop_twist_keyboard teleop_twist_keyboard

第三位同学：

Terminal window

1
ros2 node list
2
ros2 topic list
3
ros2 topic info /cmd_vel
4
ros2 topic echo /cmd_vel

7686302bca90def0a9a805c4c710eced.png

2a087a558c30ab4a68b904dbd35a39cb.png

ros2 topic echo /cmd_vel 这条指令会显示小车的运动参数。当没有运动时，将什么都不显示，否则：

截屏2024-07-16 09.43.11.png

1.6 直接控制小车运动参数#

通过发布话题消息控制小车

Terminal window

1
ros2 topic pub --rate 1 /cmd_vel geometry_msgs/msg/Twist "linear: x: 2.0, y: 0.0, z: 0.0, angular: x: 0.0, y: 0.0, z: 1.8"

2024-07-16 09.28.57.png

正如上面所说的，指定了 xxx 和 zzz 参数，就能控制运动了。

实验表明，xxx 为正时向前走，xxx 为负时往后走；

截屏2024-07-16 09.36.11.png

截屏2024-07-16 09.36.41.png

zzz 为正时向左转，zzz为负时向右转。

截屏2024-07-16 09.38.59.png

截屏2024-07-16 09.37.45.png

/userdata/dev_ws/src/originbot/originbot_demo/originbot_demo/draw_circle.py：

1
"""
2
创建一个发布者节点
3
"""
4
class PublisherNode(Node):
5

6
    def __init__(self, name):
7
        super().__init__(name)                                    # ROS2节点父类初始化
8
        self.pub   = self.create_publisher(Twist, 'cmd_vel', 10)  # 创建发布者对象（消息类型、话题名、队列长度）
9
        self.timer = self.create_timer(0.5, self.timer_callback)  # 创建一个定时器（单位为秒的周期，定时执行的回调函数）
10

11
    def timer_callback(self):                                     # 创建定时器周期执行的回调函数
12
        twist = Twist()                                           # 创建一个Twist类型的消息对象
13
        twist.linear.x  = 0.2                                     # 填充消息对象中的线速度
14
        twist.angular.z = 0.8                                     # 填充消息对象中的角速度
15
        self.pub.publish(twist)                                   # 发布话题消息
16
        self.get_logger().info('Publishing: "linear: %0.2f, angular: %0.2f"' % (twist.linear.x, twist.angular.z))

展开收起

可以修改线速度和角速度。注意，The 'z' (or 'x') field must be of type 'float'。修改完程序以后，在 dev_ws 目录下执行：

Terminal window

1
colcon build --packages-select originbot_demo --symlink-install

这里 --packages-select 指定只编译 demo 功能包，其他的不要构建，这样速度不会太慢。

--symlink-install 非常好用👍！在构建的时候加上这个参数，然后修改源代码后，重开进程，就能实时看到效果。不需要再编译一遍。

截屏2024-07-16 09.53.34.png

编译（约 1min1 min1min ）完之后，执行：

Terminal window

1
ros2 launch originbot_bringup originbot.launch.py
2
ros2 run originbot_demo draw_circle

截屏2024-07-16 09.54.43.png

1.7 工作空间和功能包#

创建工作空间：mkdir testname_ws/src -p testname_ws 就是工作空间的名称。

创建功能包：在 testname_ws/src 目录下，

Terminal window

1
ros2 pkg create --build-type ament_python learning_pkg_python

learning_pkg_python 就是功能包的名称。

截屏2024-07-16 10.57.27.png

Python源程序放置在 dev_ws/src/learning_pkg_python/learning_pkg_python 下。

2024-07-16 11.02.44.png

修改setup.py：修改dev_ws/src/learning_pkg_python/setup.py，在最后增加 'node_helloworld=learning_pkg_python.node_helloworld:main',，即：

运行程序的名称=功能包名称.源程序名称:main

第一个名称可以随便取，叫阿猫阿狗都行。功能包名称、源程序名称都是自己创建的时候指定的，千万不能随心所欲！

截屏2024-07-16 10.45.38.png

两个名称不要相同。后面不要 .py 。

然后可以在你的工作空间下编译：

在 testname_ws/ 下执行: colcon build

截屏2024-07-16 10.34.51.png

编译成功后，source install/setup.bash ，使得 ros 能找到我们的包，否则会：

截屏2024-07-16 10.48.46.png

两个窗口都要 source ！

运行：ros2 run learning_pkg_python node_helloworld

截屏2024-07-16 10.49.21.png

1.8 Launch 文件的创建#

进入这个目录：

截屏2024-07-16 11.10.07.png

新建文件夹 launch 。进入目录，再创建一个 simple.launch.py 。

截屏2024-07-16 11.14.10.png

simple.launch.py 的内容是（注意修改其中的自定义信息，功能包名称和可执行文件名称）：

1
from launch import LaunchDescription           # launch文件的描述类
2
from launch_ros.actions import Node            # 节点启动的描述类
3

4
def generate_launch_description():             # 自动生成launch文件的函数
5
    return LaunchDescription([                 # 返回launch文件的描述信息
6
        Node(                                  # 配置一个节点的启动
7
            package='learning_pkg_diyanqi',     # 节点所在的功能包
8
            executable='node_helloworld', # 节点的可执行文件
9
        ),
10
        Node(                                  # 配置一个节点的启动
11
            package='learning_pkg_diyanqi',     # 节点所在的功能包
12
            executable='node_helloworld2', # 节点的可执行文件名
13
        ),
14
    ])

截屏2024-07-16 11.22.58.png

交大荣昶杯游记Day1

Mon, 15 Jul 2024 00:00:00 GMT

早上 7:50 起床，在附近的便利店简单吃了一些早餐，然后直接前往菁菁堂参加开幕式。

这是附赠的礼品，里面有一些纪念品。

IMG_0533 2.JPG

（菁菁堂）

IMG_0532.JPG

随后从菁菁堂出来集合，便能看到升旗台和校门。

IMG_0540.jpg

IMG_0542.jpg

中午吃了一碗美味😋牛肉面🍜。

IMG_0546 2.JPG

IMG_0550.JPG

路上的涂鸦，上面还有 MC 社的涂鸦，但这里没有拍到。

IMG_0548 2.JPG

随后下午就开始正式上课了。

image.png

IMG_0552.JPG

originbot 基础操作#

快速上手：https://www.originbot.org/guide/easy_start/

上电启动
ssh远程连接
输入命令

Terminal window

1
ros2 launch originbot_bringup originbot.launch.py

再开一个ssh窗口

1
ros2 run teleop_twist_keyboard teleop_twist_keyboard

用键盘控制小车运动

网页显示小车摄像头视频#

BGR模式信息量较大，不便于传输，该用NV12编码，将YUV420P转换为NV12编码，然后再进行传输。YUV模型定义了一个亮度分量，表示物理线性空间亮度，以及两个色度分量，分别称为U（蓝色投影）和V（红色投影），表示色度信息。

运行小车底盘通讯和启动摄像头。

Terminal window

1
ros2 launch originbot_bringup camera_internal.launch.py use_camera:=true

或只启动摄像头：

Terminal window

1
ros2 launch originbot_bringup camera_internal.launch.py

其他操作：

Terminal window

1
ros topic list
2
ros2 topictopic info /hbmem_img
3
ros2 topic echo /hbmem_img

运行编码程序

Terminal window

1
ros2 launch hobot_codec hobot_codec.launch.py

图像格式转换成BGR，topic: /image_jpeg

运行网页显示程序

Terminal window

1
ros2 launch websocket websocket.launch.py websocket_only_show_image = true

打开浏览器，输入网址：http://<小车ip>:8000

综上，三条命令分别是：

Terminal window

1
ros2 launch originbot_bringup camera_internal.launch.py
2
ros2 launch hobot_codec hobot_codec_encode.launch.py
3
ros2 launch websocket websocket.launch.py websocket_only_show_image:=true

2024-07-15 16.08.29.png

2024-07-15 16.12.09.png

2024-07-15 16.12.58.png

成功显示！

交大荣昶杯游记Day0

Sun, 14 Jul 2024 00:00:00 GMT

早上从火车站出发，站台上的人不多也不少（废话），我和队友在人群中找到了彼此。

然后就是两个小时的坐车时间，车上听歌打发时间，隔壁同学正在认真的观察番剧。

（沿途的一些风景）

（这应当是钱塘江了）

经历了两个小时的车程，终于到达了上海虹桥火车站。

然后又是转乘了好几次地铁，再打出租车，终于到达了交大校园。

（地铁站的“新型”售货机，不知道新型在哪里🤷（楽））

进入校园，找到住宿楼。

（小黑板报）

（住宿卡）

（想必是考公宿舍罢）

整理完寝室，遂去吃饭。

（美景）

19 元，看着还行但其实不够入味（

（校内共享单车，办月卡貌似更优惠）

奔波了半天，明天正式启动！

OpenCV 车道线识别

Tue, 09 Jul 2024 00:00:00 GMT

笔记整理自：https://www.bilibili.com/video/BV1qk4y1r7jw/

1 【基础操作】读取、展示、保存图片#

1
import cv2
2

3
img = cv2.imread('img.jpg', cv2.IMREAD_COLOR) # 读取
4
print(type(img)) # 获取 img 的类型，是 numpy 的矩阵
5
print(img.shape) # 获取 img 的大小（长、宽），位深度
6

7
cv2.imshow('image', img) # 显示图片
8

9
if cv2.waitKey(0) == ord('q'): # 直到键盘按下某个值，退出显示图片。
10
    cv2.destoryAllWindows()
11

12
cv2.imwrite('img_gray.jpg', img) # 保存图片

其中，IMGREAD_COLOR 是读取类型，是彩色。还有其他的类型：

IMREAD_GRAYSCALE：灰度图（那么 img.shape 将没有深度这一参数）

对于 imwrite() ，它会根据给定字符串中的后缀名，自动确定图片类型。必须给定合法的图片扩展名，否则会报错。

2 Canny 边缘检测#

梯度是有方向的：

代码实现：

1
import cv2
2

3
img = cv2.imread('img.jpg', cv2.IMREAD_GRAYSCALE)
4

5
edge_img = cv2.Canny(img, 50, 100) # 图片，上阈值，下阈值，需调节优化
6

7
cv2.imshow('edges', edge_img)
8
cv2.waitKey(0)

调高下边缘与上边缘，可以有效减小噪点数量。而车道线在灰度后，有非常强的边缘（黑与白），所以保持较高的阈值是方便的。

3 ROI mask - 获取要紧的区域#

ROI - Region Of Interest，感兴趣的区域。

1
import cv2
2
import numpy as np
3

4
edge_img = cv2.imread('edges_img.jpg', cv2.IMREAD_GRAYSCALE)
5

6
mask = np.zero_like(edge_img)
7
cv2.fillPoly(mask, np.array([[[0, 368], [240, 210], [300, 210], [640,368]]]), color=255) # 假设已经获取到了顶点坐标
8

9
masked_edge_img = cv2.bitwise_and(edge_img, mask) # 布尔和运算
10
cv2.imshow('masked', masked_edge_img)
11
cv2.waitKey(0)

4 霍夫变换，获取直线#

需要使用极坐标，(r,θ)(r, \theta)(r,θ) 确定一条直线。

1
liens = cv2.HoughLinesP(edge_img, 1, np.pi / 180, 15, minLineLength=40, maxLineGap=20)

edge_img：要处理的图片
1：精度，值越大，考虑越多的线
np.pi/180：精度，值越大，考虑越多的线
累加数阈值，值越小，考虑越少的线
minLineLength：最短长度阈值，短于这个长度的线会被排除
maxLineLength：同一直线两点之间最大距离

返回一个列表，里面是直线的两个端点的坐标。

5 离群值过滤#

因为种种情况，可能有噪点被识别为车道线，而真正的车道线未被成功识别。

1
def reject_abnormal_lines(lines, threshold):
2
  slopes = [calculate_slope(line) for line in lines]
3
  while len(lines) > 0: # 不断重新计算斜率，直到群符合条件
4
    mean = np.mean(slopes)
5
    diff = [abs(s - mean) for s in slopes]
6
    idx = np.argmax(diff) # 找到差值最大的下标
7
    if diff[idx] > threshold:
8
      slops.pop(idx)
9
      lines.pop(idx)
10
    else:
11
      break
12
  return lines
13

14
# 分别对左、右车道线进行过滤
15
reject_abnormal_lines(left_lines, threshold=0.2)
16
reject_abnormal_liens(right_lines, threshold=0.2)

展开收起

过滤后的效果：

6 最小二乘拟合 - 最后一步#

对于识别出来的这么多左车道线、右车道线，我们需要将它们合并成同一条完整的车道线。

1
import numpy as np
2

3
np.ravel() # 将高维数组压成一维函数（比如把矩阵变成数组）
4
poly = np.polyfit([0, 3, 6, 9], [0, 5, 9, 14], deg=1) # 多项式拟合，参数：几个 x 坐标，几个 y 坐标，多项式次数
5
np.polyval(poly, x0) # 多项式求值

ravel 示例：

7 车道线标注#

绘制直线：cv2.line

1
cv2.line(img, (10, 10), (200, 100), 255, 3)
2
# 图像，一个端点，另一个端点，色彩值（彩色图为(r, g, b)），宽度

8 视频流处理#

读取视频流：capture = cv2.VideoCapture('video.mp4') ，如果传入的是数字，就会使用相应序号的摄像头。读取：ret, frame = capture.read() ，分别读取状态、图片帧。

1
capture = cv2.VideoCapture('video.mp4')
2

3
while True:
4
  ret, frame = capture.read()
5
  # frame = show_lane(frame)
6
  cv2.imshow('frame', frame)
7
  cv2.waitKey(100) # 等待 100 ms

9 值得改进的地方#

边缘检测时，有很多弱边缘，可以尝试使用高斯模糊，或给它腐蚀一下，让弱边缘变得更模糊！这样就能有效过滤掉了。
左车道线只有一部分，很容易只画出一部分（如图），可以尝试使它延伸到图像边缘。

信息技术之链表

Sun, 07 Jul 2024 00:00:00 GMT

链表作为一种基础数据结构，在浙江高中信息技术课程中占有举足轻重的地位。本文将从链表的基本概念出发，逐步深入到链表的特性、分类、基本操作，并通过例题来具体展示链表的应用和编程实现。

链表的概念#

链表是由一系列节点组成的线性集合，每个节点包含数据部分和指向下一个节点的指针。这种结构允许链表在内存中非连续存储，提供了灵活的内存使用和高效的数据操作。

链表的特性#

动态性：链表的大小可以随时间变化，无需预先分配固定大小的内存。
非连续性：链表的元素在内存中不需要连续存储，通过指针相互链接。
插入和删除的高效性：可以在链表的任意位置快速进行插入和删除操作。

链表的分类#

单向链表#

单向链表的每个节点包含数据和指向序列中下一个节点的指针。它是链表的最基本形式。

双向链表#

双向链表的每个节点有两个指针，分别指向前一个和后一个节点，这允许从任一节点开始向前或向后遍历整个链表。

循环链表#

循环链表是尾节点的指针指向头节点，形成一个闭环的特殊链表，常用于实现队列和栈等数据结构。

链表的基本操作#

创建链表#

创建链表首先需要初始化头指针，然后根据需要动态添加节点。

访问节点#

链表的访问通常从头部开始，通过指针逐个访问。

插入节点#

插入操作可以在链表的头部、尾部或中间进行，需要更新相关节点的指针。

删除节点#

删除节点时，需要修改其前驱节点的指针，使其指向待删除节点的后继。

例题分析#

例题一：单向链表的创建和遍历#

假设我们需要创建一个单向链表来存储学生的成绩，并遍历输出每个学生的成绩。

创建节点类：首先定义一个节点类Node，包含学生的成绩和指向下一个节点的指针。
创建链表类：然后定义一个链表类StudentLinkedList，包含添加学生成绩和遍历输出成绩的方法。

1
class Node:
2
    def __init__(self, score):
3
        self.score = score
4
        self.next = None
5

6
class StudentLinkedList:
7
    def __init__(self):
8
        self.head = None
9

10
    def add_score(self, score):
11
        if not self.head:
12
            self.head = Node(score)
13
        else:
14
            current = self.head
15
            while current.next:
16
                current = current.next
17
            current.next = Node(score)
18

19
    def print_scores(self):
20
        current = self.head
21
        while current:
22
            print(current.score, end=" ")
23
            current = current.next
24
        print()

展开收起

例题二：双向链表的插入和删除#

考虑一个双向链表，实现在特定节点后插入新节点和删除特定节点的功能。

定义双向链表节点：包含数据、指向前一个节点和后一个节点的指针。
实现插入操作：在给定节点后插入新节点，并更新相关指针。
实现删除操作：找到待删除节点，并更新其前驱和后继节点的指针。

1
class DoubleNode:
2
    def __init__(self, data):
3
        self.data = data
4
        self.prev = None
5
        self.next = None
6

7
class DoublyLinkedList:
8
    def __init__(self):
9
        self.head = None
10
        self.tail = None
11

12
    def insert_after(self, node, data):
13
        new_node = DoubleNode(data)
14
        if node is None:
15
            return
16
        new_node.next = node.next
17
        new_node.prev = node
18
        if node.next:
19
            node.next.prev = new_node
20
        node.next = new_node
21
        if self.tail is node:
22
            self.tail = new_node
23

24
    def delete_node(self, node):
25
        if node is None:
26
            return
27
        if node.prev:
28
            node.prev.next = node.next
29
        if node.next:
30
            node.next.prev = node.prev
31
        if node is self.head:
32
            self.head = node.next
33
        if node is self.tail:
34
            self.tail = node.prev

展开收起

Hints#

链表是高中信息技术课程中一个重要的概念，通过理解其特性和基本操作，学生可以更有效地解决实际问题。本文通过详细的讲解和例题分析，帮助学生深入理解链表，并掌握其在编程中的应用。

树莓派 3b+ 安装 Windows On Arm

Sat, 08 Jun 2024 00:00:00 GMT

1 下载和准备工作#

您的电脑应当是 Windows 系统，因为只有这个系统才能制作镜像。

您需要下载镜像下载脚本和镜像写入程序。

下载 arm64 镜像工具：https://wwt.lanzouo.com/i3U4W213w0dc
下载镜像写入工具：https://wwt.lanzouo.com/is28A213w1di

下载完后解压即可。

2 下载镜像#

先打开这个文件夹，找到这个文件，右键以管理员身份运行。

8EF8D3E9-B82C-467C-BA73-6FFA239E815C.png

在弹出的窗口中，等待好一会，大概 15 分钟左右。

CA8E827C-03B6-48A7-80CE-BF2B213D9853.png

此时它正在努力下载 arm64 的镜像。下载完成后，您应该得到这样两个文件：

3831D63A-D63E-464B-ADD3-42D4AD710368.png

两个都是镜像文件，下一步选择任一都可以。

3 写入镜像#

打开这个文件夹里的程序，按照默认的，下一步到最后。

29C36014-DBBF-490D-AEE1-B7788ED6AFFA.png

C0C9B38E-6636-4B7A-90A1-0123D23386F2.png

16A8F67C-138C-4547-BAEB-AFED81452013.png

872E2BA2-921C-499D-814F-735191531047.png

1645F810-F96D-44CB-B979-0BF0714D5ABD.png

2768D8EA-DD04-4DCC-822D-FB631FE898C8.png

5FE018A1-5BD6-4DCC-A5DF-8C9FF1164BCE.png

F8B8F047-BB7E-4065-A86A-10A99E78DA92.png

C231D9BD-3C0A-45EE-8BD2-B95DF1292D58.png

CD924473-6942-4A3D-8226-39E1E9486524.png

06B2DEF8-2DFC-4BD3-AD3F-85CECAEF07D3.png

4 开机设置#

将 sd 卡插入您的树莓派中，插上电启动。

Apple Watch 麦金塔小电脑充电支架

Wed, 05 Jun 2024 00:00:00 GMT

下载：#

模型已开源至 GitHub ，可自行下载：https://github.com/diyanqi/MacintoshChargingStandForAppleWatch/blob/main/%E5%85%85%E7%94%B5%E5%99%A8%E6%94%AF%E6%9E%B62.stl

实物图：#

总体上就是模仿老麦金塔电脑的样子，起因是看到网上有卖这个样子的充电支架但是太贵了，于是为什么不自己做一个呢？

比原版新增了底部绕线结构，当充电线太长了就可以在里面绕线。

唯一的不足就是前面用于显示的边框太大了，导致手表屏幕与其不是很契合。

你的词典笔，何止是词典笔 - 有道词典笔安装 PenMods

Sat, 11 May 2024 00:00:00 GMT

感谢原项目 PenMods 。仓库地址：https://github.com/PenUniverse/PenMods-release

1 下载必要工具#

自行安装 adb

本文示例版本：

PenMods 安装包

下载地址：（已隐去，请自行搜索tg群）

https://wwt.lanzouo.com/i8Hku1ydw4kf

确保您已经在词典笔上拥有/刷入合适的系统。见：https://github.com/PenUniverse/PenMods-release?tab=readme-ov-file#supported

2 安装#

词典笔开机，进入 更多设置 -> 关于 -> 法律监管 ，连续点击页面 151515 下，打开 adb 调试。

然后解压 penmods.zip ，进入文件夹，打开终端在当前文件夹。

如果您使用的是 Windows 系统，则可以直接双击 Install.bat 运行。会要求输入密码，密码是 CherryYoudao 。

如果使用的是 Mac 系统，则可以根据以下步骤进行：

在终端打开该文件夹；
输入命令进行验证：

Terminal window

1
adb shell auth

密码是 CherryYoudao 。

输入命令，推送安装包：

Terminal window

1
adb push PenMods /userdata

输入命令，安装：

Terminal window

1
adb shell

这会进入词典笔的终端。

接着，在词典笔终端输入命令：

1
mount -o remount -rw
2
cd /userdata/PenMods/
3
chmod +x patch.sh
4
sh ./install.sh

重启词典笔

先输入命令 exit 退出词典笔终端，返回本级终端。再：

Terminal window

1
adb reboot

（等待重启）

（安装成功）

值得注意的是，刚安装好的词典笔是触屏失灵的。为此，您只需要按住侧边按钮，关机再重启即可。

Pandas 学习笔记

Sun, 14 Apr 2024 00:00:00 GMT

1 Series#

1.1 Series 创建#

根据列表创建：

1
s1 = pd.Series([4,7,-5,3]) # 默认 index: 0, 1, 2, ...

1
0    4
2
1    7
3
2   -5
4
3    3
5
dtype: int64

根据列表创建并制定索引

1
s2 = pd.Series([4,7,-5,3],index=['d','b','a','c']) # 指定 index

1
d    4
2
b    7
3
a   -5
4
c    3
5
dtype: int64

根据字典创建：

1
sdata = {'Ohio':35000,'Texas':71000,'Oregon':16000,'Utah':5000} # 指定了index 名称和其对应的值
2
s3 = pd.Series(sdata)

1
Ohio      35000
2
Oregon    16000
3
Texas     71000
4
Utah       5000
5
dtype: int64

根据字典创建，并指定索引：

1
sdata = {'Ohio':35000,'Texas':71000,'Oregon':16000,'Utah':5000}
2
states = ['California','Ohio','Texas','Oregon'] # 跟上面差不多，只不过再根据该列表指定的 index 重新排序
3
s4 = pd.Series(sdata,index = states)

1
California        NaN
2
Ohio          35000.0
3
Texas         71000.0
4
Oregon        16000.0
5
dtype: float64

1.2 访问 Series#

索引值访问；
下标数字访问；
传入含有多个索引值的列表，返回一个 Series 。

1
# s2:
2
'''
3
d    4
4
b    7
5
a   -5
6
c    3
7
dtype: int64
8
'''
9

10
s2[2] # -5
11

12
s2['a'] # -5
13

14
s2[['a','b','d']]
15
# 输出
16
'''
17
a   -5
18
b    7
19
d    4
20
dtype: int64
21
'''

展开收起

1.3 切片#

与利用下标进行切片不同，使用标签进行切片时，末端是包含的：

1
obj['b':'c']
2
# 输出
3
b    1.0
4
c    2.0
5
dtype: float64

2 DataFrame#

2.1 创建#

创建空 DataFrame

1
df = pd.DataFrame()

从文件读取

1
df1 = pd.read_excel("filename.xlsx")
2
df2 = pd.read_csv("filename.csv")

直接创建，无数据

1
pd.DataFrame(columns=['A', 'B', 'C'], index=[0,1,2])

从二维数组创建

1
pd.DataFrame(data=[['Apple',5],
2
                   ['Banana',10],
3
                   ['Cherry',8],
4
                   ['Dates',3],
5
                   ['Eggfruit',7]],
6
             columns = ['Fruits','Quantity'],
7
             index=[1,2,3,4,5])

从字典创建

注意，这里的键值是作为 Column 值。

1
fruits_dict = { 'Fruits':['Apple','Banana','Cherry','Dates','Eggfruit'],
2
                'Quantity': [5, 10, 8, 3, 7],
3
                'Color': ['Red', 'Yellow', 'Red', 'Brown', 'Yellow']}
4
pd.DataFrame(fruits_dict)

从 Series 创建

1
df2 = pd.DataFrame(pd.Series(np.random.randint(1, 10, 100)), columns = ['xxx'])

2.2 增加、修改#

1
dataFrame["新增列"] = 6
2
# 新增行
3
dataFrame.loc["c"] = [55,88,99,66]
4
dataFrame
5

6
  第一列  第二列  第三列  新增列
7
a  1    2    3    6
8
b  4    5    6    6
9
c  55    88    99    66
10

11
# 另外，append也可以增加，但是它增加的索引是默认值，而且之前的index会变列
12
dataFrame.append([55])
13

14
  0  新增列  第一列  第三列  第二列
15
a  NaN  6.0   1.0     3.0    2.0
16
b  NaN  6.0   4.0     6.0  5.0
17
c  NaN  66.0  55.0   99.0  88.0
18
0  55.0 NaN    NaN  NaN    NaN

展开收起

1
df.append(Series, ignore_index=True)
2
# 增加一行，记得 ignore_index

2.3 删除#

1
# 删除行
2
df.drop('Charlie', axis=0)
3
# 默认值为axis = 0，因此可以省略axis。
4
print(df.drop('Charlie'))
5

6
# 删除列,注意这里的0是列名哦
7
dataFrame.drop('age', axis=1)

2.4 查看#

1
# 前N行,不写参数N，则是前五行
2
dataFrame.head(N)
3

4
# 后N行,不写参数N，则是后五行
5
dataFrame.tail(N)

2.5 保存至文件#

1
dataFrame.to_excel("输出.xlsx",index=False,sheet_name="1")

2.6 操作#

排序

1
df.sort_values(by=0,ascending=False,axis=1)
2
# by: 根据该列/行名排序
3
# ascending: 升序，默认为 True
4
# axis: 给列排序，默认为0

重命名

主要用到的参数有：

columns：列名
index：行名
axis：指定坐标轴
inplace：是否替换，默认为False。inplace为False时返回修改后结果，变量自身不修改。inplace为True时返回None,变量自身被修改。

1
df.rename(columns={"A": "a", "B": "c"})  # 修改columns。inplace未设置，返回修改后的结果
2

3
df_re = df.rename(index={0:"0a",1:"1a"})  # 同样的方式修改行名

筛选

如果想要筛选出 B列大于零的行：

1
df1 = df[df['B']>0]

如果想要筛选出 B列中大于零的行，同时只显示B列的数据：

1
df2 = df['B'][df['B'] >0]

如果想要筛选出 B列大于零，同时C列小于零的行：

1
df3 = df[(df['B']>0)&(df['C']<0)]  # 这里&符号可以实现多条件的筛选

How to Create a React MUI Project from Scratch

Wed, 03 Apr 2024 00:00:00 GMT

1 Create the React project#

Firstly, run the command that would create the project outside the target folder:

Terminal window

1
abc@34d63bfc5d13:~/workspace$ npx create-react-app <your-project-name>

Waiting for the following information to appear:

Terminal window

1
We suggest that you begin by typing:
2

3
  cd <your-project-name>
4
  npm start
5

6
Happy hacking!

This means the installation has been completed!

2 Install MUI related packages#

The version installed in this article is the latest stable version as of the time of publication: v5.

To begin with, go to the project folder:

Terminal window

1
cd <your-project-name>

Then use pnpm to resolve dependencies（also npm or yarn ）：

Terminal window

1
pnpm add @mui/material @emotion/react @emotion/styled

Then install Roboto font and icons：

Terminal window

1
pnpm add @fontsource/roboto
2
pnpm add @mui/icons-material

Well begun, half done; Happy Hacking！

关于铅球投掷的最佳方法的数学模型

Thu, 28 Mar 2024 00:00:00 GMT

学校评奖已结束。故现可公之于众。

快餐式阅读之思：《如何假装读过一百本名著》

Sat, 23 Mar 2024 00:00:00 GMT

“经典”，指人人称赞却没人会读的书。——马克·吐温

01. 内容简介#

写作背景#

在快节奏的现代生活中，我们时常感叹没有时间静下心来阅读那些厚重的经典名著。即使鼓起勇气翻开书页，艰深的词句和缓慢的剧情发展也常常让人望而却步，转而投身于手机的碎片化阅读之中。于是，经典名著似乎与我们渐行渐远，成为了一个高高在上、遥不可及的存在。

然而，本书却为我们提供了一种全新的阅读方式。这部幽默的西方文学名著总集，用最简洁的文字配以令人捧腹的冷幽默插图，巧妙地概括了 100 多部世界名著的精髓。它不仅让我们在轻松愉快的氛围中重新认识了这些经典作品，更让我们发现，原来名著也没那么可怕。

伪文青狂喜 🤪#

春节假期结束，年轻人马上又要从家里的小宝贝角色中脱离，变成更广泛的、社会意义的学渣或者社畜，想到这里难免辛酸。

新年伊始，一定得成为更好的自己。可惜时间宝贵不够用心玩耍，与同学师长、同事领导社交时难免面露难色。

你可曾鼓起勇气阅读名著，却被艰深的词句和缓慢的剧情发展打击了兴趣，才翻了两页就把书丢在一边，转而拿起手机？

你曾面临过聊天时提起文学经典，朋友们侃侃而谈，自己却毫无头绪的窘境吗？

如果经典被“浓缩”，变得不再威严吓人，如果能够以轻松幽默的语调趣谈名著，如果名著中面目模糊的人物变成可爱的漫画角色……或许你会发现，原来名著也没那么可怕！

02. 读了 ≠ 读过#

快餐文化的冲击#

如果说在过去，消费文化的过程更像是细嚼慢咽，那么如今，消费文化的方式则是狼吞虎咽翻书变成了点击，阅读变成了刷屏；影像取代了文字，信息取代了知识。快餐文化，即是指现代生活中一种只追求速成却忽略内在积累的文化现象，如精简版的名著、几分钟剪辑的电影梗概等。他们像快餐一样能够迅速满足人们的认知需求，却弱化了知识含金量，或让深刻的内容泛娱乐化。

被消解的深度思考#

这种快餐文化，正在迅速填满当代人的日常生活，让我们心甘情愿地掉进一个甜蜜的黑洞，在不知不觉中耗尽本应用于自我提升的时间与精力。正如传播学者尼尔·波兹曼所言：“毁掉我们的，不是我们所憎恨的东西，而恰恰是我们所热爱的东西。”

快餐时代的经典著作#

随着新技术的发展，阅读的形态也在日新月异地变化着。关于“读纸质书还是读电子书”的讨论方兴未艾，读书类短视频、各种名著梗概就已经悄然进入大众的生活，以一种更具颠覆性的力量，形塑着当代人的阅读习惯。抓人眼球的标题、风趣幽默的讲解、精炼短小的篇幅，无疑让原本枯燥漫长的阅读过程变得轻松愉悦。但与此同时，梗概类作品限于其体量，也有让书籍本身的内涵流于贫乏的隐患。一本好书所蕴含的丰富细节，远非几分钟乃至几十秒的短视频、几百页乃至几百句话的只言片语所能承载，它所积淀的深厚思想也不可能仅用三言两语就能阐释明白。

此外，作者在对某本书进行解读的时候，不可避免地会融入个人观点和情感。若仅仅囿于他们的视野，亦步亦趋地进行解读，我们便只能看到属于他们的“哈姆雷特”，从而失去了探索深邃未知的可能。

快餐时代阅读新姿势？#

正如村上春树所言，能说得出卡拉马佐夫三兄弟姓名的人，全日本也没有几个。事实上，在想要读名著的人里，真正开始读的不算多；开始读名著的人里，从头到尾读完的屈指可数，更别说其中有不少还是硬着头皮读完的；从头到尾读完的人里，合上书后还能将细节一一记起、大谈感想的人，恐怕不剩几个。

我吃过很多饭，几十年如一日，我把他们的味道忘得一干二净，但毫无疑问他们已经成长为我的血在我的身体里流动，成为我身体的骨和肉，是我生命不可缺少的一部分，书也是如此。这本书里活泼生动的插图和语言固然能充分调动阅读兴趣，让打开一本书不再艰难，但我们的读书之旅却不能止步于此。

真正有价值的阅读，终究还是需要回到原著，一字一句地耐心品味、用心思索，如此方能收获“开卷有益”的醇厚滋养。

元宵节，the Lantern Festival

Sat, 24 Feb 2024 00:00:00 GMT

提升网站 https 安全等级为 A+

Sun, 18 Feb 2024 00:00:00 GMT

这是本站原本的 https 等级：

如何对其进行提升呢？我们看到，官方也给出了解答：

在又拍云 CDN 控制台中，找到 HTTPS -> HSTS 配置。

打开后，点击“添加规则”。

然后进行如图的配置：

以下是配置详解：

选择域名：直接选择您想打开 HSTS 的域名，例如我的 www.amzcd.top 是已经达到 A+ 标准的，只有 amzcd.top 不符合标准，那么就选择 amzcd.top 即可。
启用 HSTS：打开。
缓存时间：默认为 180 天即可。最小值为 15552000 秒即 18 天，可根据实际情况自行调整。
应用于子域名：开启此选项后，该域名的所有子域名从今往后都必须用 https 访问。如果您仍有站点使用 http 协议，千万不要开启！
预记载：和应用于子域名类似，一旦开启，该域名及其所有子域名直接使用 https 访问。

配置完之后点击保存，再去看一看 SSL/TLS 安全评估报告罢。

黑苹果屏蔽三星硬盘

Tue, 13 Feb 2024 00:00:00 GMT

众所周知，三星由于某些原因和苹果一直处于闹掰的状态，甚至您无法在三星硬盘上安装 macOS 。甚至都没有在三星的硬盘上安装 macOS ，只要系统一读写三星硬盘，也会使你的系统卡住。

三星 PM9A1

下面，本篇文章就来教程，如何在黑苹果环境下屏蔽三星硬盘（其他硬盘同理），使您的系统能够正常工作。

传统的屏蔽方法，有一种是在系统层面进行的。即，您需要在进入系统之后，以非常快的手速卸载掉三星硬盘的所有分区，然后将卸载的脚本开机启动。（可见教程：https://www.bilibili.com/video/BV1CR4y1u7FL/ 。）

然而，这种方法对运气和手速有一定的要求，操作难度较大。除了这种方法，我们还能在 OpenCore 层面屏蔽掉硬盘，而且这种屏蔽只会对 macOS 产生效果，Windows 系统不受影响。

1. 下载工作#

首先需要下载模版 DSL 文件的压缩包。

https://github.com/dortania/Getting-Started-With-ACPI/blob/master/extra-files/decompiled/SSDT-GPU-DISABLE.dsl.zip

解压后得到一个 dsl 文件：

为什么名称是 GPU ？因为禁用的原理相似，可以使用禁用 GPU 的模版来禁用硬盘。

然后下载 ASL 小工具【QtiASL】：

可在这里下载源代码自行编译，也可以自己在网上搜索可执行文件。

2. 查找硬盘路径#

在 Windows 环境下，按下 Win+X 唤出超级菜单，选择 设备管理器 。然后找到 储存控制器 ，标准NVM Express 控制器 ，双击打开属性，选择 详细信息 一栏，在 属性 下拉菜单里找到 位置路径 ，找到第二行的这条栏目。

把带有 ACPI 括号里的所有内容提取出来，以 . 分隔。例如，我的提取出来的字符串为：

1
_SB_.PC00.PEG0.PEGP

3. 编辑 dsl 源文件并编译#

打开小工具 QtiASL ，将刚刚解压出来的 SSDT-GPU-DISABLE.dsl 拖进去打开。

然后找到这两行，框起来的部分，换成你刚才提取出来的字符串。

然后点击右上角保存按钮，或者 Ctrl+S 保存。

接着，在彩蛋里找到 编辑 -> 编译，点击它。

你就能在 SSDT-GPU-DISABLE.dsl 的同级目录下看到一个编译好的 SSDT-GPU-DISABLE.aml 了。

4. 加载入 OpenCore 的 EFI 中#

如图，进入 /EFI/OC/ACPI ，把你的 aml 文件拷贝进去。

然后回到 OC 文件夹，打开 config.plist ，将刚才的注入启用。

1
<dict>
2
  <key>Comment</key>
3
  <key>Enabled</key>
4
  <true/>
5
  <key>Path</key>
6
  <string>SSDT-GPU-DISABLE.aml</string>
7
</dict>

你可以像笔者一样，在文本编辑器中，钉味道相关的位置，然后直接将上面的文本复制进去；也可以使用图形化编辑器，随你的喜好。

最后别忘了保存。

烽火 HG680-J 机顶盒刷入 Ubuntu 系统

Mon, 05 Feb 2024 00:00:00 GMT

本教程用到开源项目海纳思系统，在此表示感谢。

1. 准备工作#

为了短接 CPU 引脚，我们必须拆下机顶盒到外壳。可以使用老虎钳暴力拆解，需要费一些功夫。

（这里没拆好，读者拆外壳时请务必小心不要把天线给弄断了；不过接网线的话也无大碍。）

2. 下载固件，写入 U 盘#

https://node.histb.com:9088/update/system/mv100-mdmo1f-usb-flash.zip

在下载的同时，可以给 U 盘格式化成 FAT32 格式。

然后将下载完的固件包解压到 U 盘根目录下。

3. 塞入机顶盒，准备刷机#

如图所示，将 U 盘接到远离电源的那个（或许靠近电源的那个也行？） USB 口，先不要接上电源。插入 HDMI 线。然后用镊子将以下两个引脚进行短接：

注意方向，将最旁边的两个引脚短接。现在，使用您的另一只手插入电源，并保持短接状态 6 秒钟。显示器上不会显示任何东西，将会是黑屏或是无信号状态。现在，只需要耐心等待两分钟左右。

两分钟后，会显示以下界面：

然后再等待三分钟：

此时不要急着马上关机，需再等待十分钟左右，让它内部完成初始化。大概差不多后，就可以拔掉 U 盘，接上网线，重新插电源了。随后即可在路由器管理页面看到盒子的 ip 了。

然后可以访问该地址，大功告成！

加速 Hypixel 连接

Sat, 03 Feb 2024 00:00:00 GMT

非常好延迟，它使我的 MC 旋转。

如您所见，加速 Hypixel 连接需使用到开源项目 ZBProxy 。

首先，到下载页面，查看对应平台的安装包。

v3.0 下载页面

随后在远程服务器上下载打包好的程序：

Terminal window

1
wget https://your-download-url/

然后添加权限，运行之。

Terminal window

1
chmod +x ./ZBProxy-linux-amd64-v3
2
./ZBProxy-linux-amd64-v3

最后，在服务商管理页面，设置端口转发。

然后连接该地址。加速后可能仍有200毫秒左右的延迟，但是实际游戏体验明显提升。

技术学习笔记之 PIL 模块

Wed, 24 Jan 2024 00:00:00 GMT

1. 导入模块#

1
from PIL import Image

2. 打开图片#

1
fn = Image.open("tiger.jpg")

3. 获取图像属性#

1
a = fn.size # (width, height) 元组
2
a = fn.width # 宽度
3
a = fn.height # 高度
4
a = fn.mode # 模式：RGB 彩色、L 灰度、P 256色、1 黑白色
5
a = fn.format # 图片格式：jpg, png, bmp ……

4. 对图像进行处理#

1
fn = fn.rotate(-90) # 角度制；逆时针旋转
2
fn = fn.resize((fn.width//2, fn.height//2)) #
3
fn = fn.show() # 显示图像
4
fn = fn.convert("L") # 转换模式
5
fn.save("test.bmp") # 保存图像，自动匹配格式
6
fn.close() # 关闭图像

5. 像素操作#

1
pix = fn.load() # 获取全部像素
2
tpix = pix[i, j] # 获取像素点，其类型取决于图片模式
3
R, G, B = fn.getpixel((i, j)) # 直接获取像素
4
new_img.putpixel((i, j), new_pixel) # 写入像素
5
new_pixel = int(0.299*R + 0.857*G + 0.144*B) # RGB转灰度

6. 示例代码#

convert_manually.py展开收起

1
from PIL import Image
2
img = Image.open("tiger.jpg")
3
pix = img.load()
4

5
THERESHOLD = 132
6

7
new_img = Image.new("L", img.size) # create a blank image in gray mode
8
new_img2 = Image.new("1", img.size) # create a blank image in 0/1 mode
9

10
x, y = img.size
11

12
for i in range(x):
13
    for j in range(y):
14
        R, G, B = img.getpixel((i, j))
15
        new_pixel = int(0.299*R + 0.857*G + 0.144*B) # convert to gray mode
16
        new_img.putpixel((i, j), new_pixel) # put a pixel in gray mode
17
        new_img2.putpixel((i, j), (0 if new_pixel < THERESHOLD else 1))
18

19
new_img.save("tiger_L.jpg")
20
new_img2.save("tiger_1.jpg")
21
new_img.close()
22
new_img2.close()
23
img.close()

展开收起

原图：

灰度：

单色：

make_frames.py

1
from PIL import Image
2
for THERESHOLD in range(0, 256):
3
    img = Image.open("tiger.jpg")
4
    pix = img.load()
5
    new_img2 = Image.new("1", img.size) # create a blank image in 0/1 mode
6
    x, y = img.size
7
    for i in range(x):
8
        for j in range(y):
9
            R, G, B = img.getpixel((i, j))
10
            new_pixel = int(0.299*R + 0.857*G + 0.144*B) # convert to gray mode
11
            new_img2.putpixel((i, j), (0 if new_pixel < THERESHOLD else 1))
12
    new_img2.save("./output/{}.jpg".format(THERESHOLD))
13
    new_img2.close()
14
    img.close()

identification_of_coating_cards.py展开收起

1
from PIL import Image
2
img = Image.open("one-bw.png")
3
width, height = img.size
4
RATE = 0.64
5
cnt = 0
6
for i in range(width):
7
    for j in range(height):
8
        # print(img.getpixel((i, j)))
9
        if(img.getpixel((i, j)) != 255):
10
            cnt += 1
11
print(cnt, width*height*RATE)
12
if(cnt > width*height*RATE):
13
    print("FILLED.")
14
else:
15
    print("UNFILLED.")

展开收起

Chirpy 主题样式大典【转】

Mon, 15 Jan 2024 00:00:00 GMT

本文转自 https://chirpy.cotes.page/posts/text-and-typography/

This post is to show Markdown syntax rendering on Chirpy, you can also use it as an example of writing. Now, let’s start looking at text and typography.

Headings#

H1 - heading#

{: .mt-4 .mb-0 }

H2 - heading#

{: data-toc-skip=” .mt-4 .mb-0 }

H3 - heading#

{: data-toc-skip=” .mt-4 .mb-0 }

H4 - heading#

{: data-toc-skip=” .mt-4 }

Paragraph#

Quisque egestas convallis ipsum, ut sollicitudin risus tincidunt a. Maecenas interdum malesuada egestas. Duis consectetur porta risus, sit amet vulputate urna facilisis ac. Phasellus semper dui non purus ultrices sodales. Aliquam ante lorem, ornare a feugiat ac, finibus nec mauris. Vivamus ut tristique nisi. Sed vel leo vulputate, efficitur risus non, posuere mi. Nullam tincidunt bibendum rutrum. Proin commodo ornare sapien. Vivamus interdum diam sed sapien blandit, sit amet aliquam risus mattis. Nullam arcu turpis, mollis quis laoreet at, placerat id nibh. Suspendisse venenatis eros eros.

Lists#

Ordered list#

Firstly
Secondly
Thirdly

Unordered list#

Chapter
- Section
  - Paragraph

1
- Chapter
2
  + Section
3
    * Paragraph

ToDo list#

Job
- Step 1
- Step 2
- Step 3

1
- [ ] Job
2
  + [x] Step 1
3
  + [x] Step 2
4
  + [ ] Step 3

Description list#

Sun : the star around which the earth orbits

Moon : the natural satellite of the earth, visible by reflected light from the sun

Block Quote#

This line shows the block quote.

Prompts#

An example showing the tip type prompt.

An example showing the info type prompt.

An example showing the warning type prompt.

An example showing the danger type prompt.

1
> An example showing the `tip` type prompt.
2

3
> An example showing the `info` type prompt.
4

5
> An example showing the `warning` type prompt.
6

7
> An example showing the `danger` type prompt.

Tables#

Company	Contact	Country
Alfreds Futterkiste	Maria Anders	Germany
Island Trading	Helen Bennett	UK
Magazzini Alimentari Riuniti	Giovanni Rovelli	Italy

Links#

http://127.0.0.1:4000

Footnote#

Click the hook will locate the footnote¹, and here is another footnote².

Inline code#

This is an example of Inline Code.

Filepath#

Here is the /path/to/the/file.extend{: .filepath}.

Code blocks#

Common#

1
This is a common code snippet, without syntax highlight and line number.

Specific Language#

Terminal window

1
if [ $? -ne 0 ]; then
2
  echo "The command was not successful.";
3
  #do the needful / exit
4
fi;

Specific filename#

1
@import
2
  "colors/light-typography",
3
  "colors/dark-typography";

{: file=’_sass/jekyll-theme-chirpy.scss’}

Mathematics#

The mathematics powered by MathJax:

∑n=1∞1/n2=π26\sum_{n=1}^\infty 1/n^2 = \frac{\pi^2}{6}∑n=1∞1/n2=6π2

When a≠0a \ne 0a=0, there are two solutions to ax2+bx+c=0ax^2 + bx + c = 0ax2+bx+c=0 and they are

x=−b±b2−4ac2ax = {-b \pm \sqrt{b^2-4ac} \over 2a}x=2a−b±b2−4ac

Mermaid SVG#

gantt title Adding GANTT diagram functionality to mermaid apple :a, 2017-07-20, 1w banana :crit, b, 2017-07-23, 1d cherry :active, c, after b a, 1d

Images#

Default (with caption)#

Desktop View

{: width=“972” height=“589” } Full screen width and center alignment

Left aligned#

Desktop View

{: width=“972” height=“589” .w-75 .normal}

Float to left#

Desktop View

{: width=“972” height=“589” .w-50 .left} Praesent maximus aliquam sapien. Sed vel neque in dolor pulvinar auctor. Maecenas pharetra, sem sit amet interdum posuere, tellus lacus eleifend magna, ac lobortis felis ipsum id sapien. Proin ornare rutrum metus, ac convallis diam volutpat sit amet. Phasellus volutpat, elit sit amet tincidunt mollis, felis mi scelerisque mauris, ut facilisis leo magna accumsan sapien. In rutrum vehicula nisl eget tempor. Nullam maximus ullamcorper libero non maximus. Integer ultricies velit id convallis varius. Praesent eu nisl eu urna finibus ultrices id nec ex. Mauris ac mattis quam. Fusce aliquam est nec sapien bibendum, vitae malesuada ligula condimentum.

Float to right#

Desktop View

{: width=“972” height=“589” .w-50 .right} Praesent maximus aliquam sapien. Sed vel neque in dolor pulvinar auctor. Maecenas pharetra, sem sit amet interdum posuere, tellus lacus eleifend magna, ac lobortis felis ipsum id sapien. Proin ornare rutrum metus, ac convallis diam volutpat sit amet. Phasellus volutpat, elit sit amet tincidunt mollis, felis mi scelerisque mauris, ut facilisis leo magna accumsan sapien. In rutrum vehicula nisl eget tempor. Nullam maximus ullamcorper libero non maximus. Integer ultricies velit id convallis varius. Praesent eu nisl eu urna finibus ultrices id nec ex. Mauris ac mattis quam. Fusce aliquam est nec sapien bibendum, vitae malesuada ligula condimentum.

Dark/Light mode & Shadow#

The image below will toggle dark/light mode based on theme preference, notice it has shadows.

light mode only

{: .light .w-75 .shadow .rounded-10 w=‘1212’ h=‘668’ }

dark mode only

{: .dark .w-75 .shadow .rounded-10 w=‘1212’ h=‘668’ }

Video#

https://www.youtube.com/watch?v=Balreaj8Yqs

Reverse Footnote#

Footnotes#

The footnote source ↩
The 2nd footnote source ↩

2023年度总结

Sun, 31 Dec 2023 00:00:00 GMT

逝者如斯，而未尝往也；盈虚者如彼，而卒莫消长也。

转眼间 2023 年就这样到达了尾声。那么按照惯例，看看今年我都干了什么罢。

今年年初的时候 OIso 正在如火如荼的阶段，开发团队也推出了第一款插件 tamperOIso 。接着，如果您观察我的文章列表，就会发现在 3 月到 7 月笔者没有更新过文章。一方面是懒癌犯了，另一方面也是因为本人在准备中考。 6 月中旬中考完了，也是十分惊险地压线过了分数线，成功升入高中。7 月，开启了我的高中生活，迎来了人生中第一次短假期。 7 月底的时候，还去了趟南京。南京是以前一直想去的，这次总算抽出了三天时间去游览了一下这六朝古都。

8 月，一边学习高中内容的同时，也进行了 OIso 的相关开发。其实令我没有想到的是，OIso 的发电量竟然不是 0 。这无疑给了我莫大的鼓励。 9 月的开始，意味着 CSP2023 的临近。尽管我已经在去年决定退役，但还是想着在今年参加一次提高组，弥补一下之前的遗憾。于是乎，在军训七天我抓紧时间刷初赛题（之前几年一直就是初赛过不去的坎），分数终于稳居80+ 了，最后的成绩也是超出分数线 20 多分（不过今年机位特别多，泪目了）。

初赛通过后，也是开始了复赛的刷题。通过往年的真题，我也认知到了自己的水平，知道赛场上的时候哪些题目该做、哪些题目放弃。最后也是压线拿到了 6 级。之后又借着高中生的资格参加了 NOIP ，压线拿了二等。虽然这些成绩在大佬看来嗤之以鼻，但是对于我这个一年没碰过 OI 的蒟蒻来说也是心满意足了。开启高中生活后，许多东西都发生了变化。我还参加了学校的一个技术社团，并参与了学校某平台的开发，也算能够献出我微不足道的力量吧。

马上又到期末考了，好好复习去吧！

技术学习笔记之 Python 语言基础

Thu, 07 Dec 2023 00:00:00 GMT

1. 常见数据类型#

Python 常见数据类型有整型、实型、字符串型、布尔型。

储存身份证号码应当使用字符串型！因为会有字符 X 的出现。

注意一个表达式的数据类型，如 (x*10+0.5)//10 的值为 2.02.02.0 而非 222 （因为有 +0.5+0.5+0.5 的出现）。

2. 基本运算与表达式#

Python 的基本运算包括算数运算、关系运算和逻辑运算三大类。变量、常量、运算符和圆括号等按一定的规则组合构成一个表达式。

常见运算符的归类：

算数运算符：** * / // % + -
关系运算符：> < >= <= == != in
逻辑运算符：not and or

易错的运算顺序：not > and > or ；同级运算从左到右。

在 Python 中，1 <= x < 5 是合法的表达式，不像 C++ 。

3. 变量命名及其赋值#

3.1 变量的命名#

可以由大小写字母、数字、下划线组成，不能以数字开头，字母区分大小写，不能使用保留字。

3.2 赋值#

Python 赋值运算符有 = -= += *= /= %= //= 等。

开源创新：自由、协作、前瞻

Sun, 03 Dec 2023 00:00:00 GMT

一、引言

自主创新研发在当今世界的科技和经济发展中扮演着举足轻重的角色。在这个信息时代，技术的不断进步和创新已经成为国家竞争力的重要驱动力，而开源项目就在这个领域扮演着不可忽视的角色。

自主创新，即依赖自身力量进行研发和创新，已经成为国家和企业在全球竞争中脱颖而出的关键要素。在这个高度互联的时代，仅仅依赖外部技术和知识的引进不再足够，而需要国家和组织能够自主地推动创新、发展新技术、应对未来挑战。

而在自主创新的道路上，开源项目扮演了关键的角色。开源项目是开放、共享和自由的，它们鼓励全球的开发者和创新者积极参与，共同研发和改进软件和技术。通过开源项目，个人和组织可以自主地定制、修改和利用先进的技术，而无需受到专有软件的束缚。

在本文中，我们将深入探讨开源项目如何具备自主创新的潜力，并通过一些成功案例展示开源项目如何成为自主创新的引领力量，推动着科技和产业的发展。此外，我们还将了解到自主创新如何在开源社区中蓬勃发展，进而推动技术的演进，并为未来的挑战提供新的解决方案。通过这些探讨，我们将更深入地理解开源项目与自主创新之间的紧密联系，并充分了解它们对推动技术、经济和社会的发展所起到的关键作用。

二、“开源”是什么

开源软件是指源代码可以自由使用，用户可以查看、修改、采用和分享这些代码，无论是用于商业还是非商业目的的软件。在透明、协作和去中心化的前提下，“开源”不但能集思广益地形成优秀的源代码，也能缔造一个生态强大的社区环境。与闭源软件不同，开源软件不仅可以让任何人使用，还可以在其基础上进行开发。

开源项目因其开放的本质而闻名遐迩。在开源项目中，源代码是公开可见和可访问的，任何人都可以查看、使用和修改。这意味着开发者和组织可以自主参与项目，不受专有软件的限制。他们可以自主研发、定制和优化开源软件，以满足其需求。这种自主性质为个人、企业和国家提供了无限的创新可能性。

常见的开源项目有很多。例如Linux就是一个典型的开源项目，它的成功建立在自主创新的基础上。由于其开放的性质，全球范围内的开发者共同参与了Linux的开发，使其成为全球最流行的服务器操作系统之一。自主创新的精神推动了Linux不断发展，Linux也逐渐支持了多种硬件架构并适用于各种应用场景。

从中我们可以看见，开源项目能够激发创新，推动技术和社会的进步。在开放和自由的环境中，开源项目鼓励人们大胆尝试新想法，从而为未来创新打开了无限的可能性。

三、开源与创新是相互作用的整体

自主创新赋予开源项目在技术领域的领先地位。通过自主研发和改进，开源项目能够不断适应技术变革、保持竞争力。一方面，自主创新使开源项目能够高效地制定开发计划。开源社区可以自由地制定项目的路线图，以确保项目在技术上始终保持前沿。另一方面，自主创新又使开源项目能够根据用户特定的需求进行定制。这种灵活性在不同行业和应用领域中得到了广泛的应用，所以才能够在技术创新方面遥遥领先。不仅如此，自主创新鼓励开源社区成员分享知识和经验，促进技术的共享和改进。这种协作精神有助于项目迅速积累技术优势，推动技术领先性。

开源软件开发是公开的，这意味着所有的工作——如代码提交和用户反馈——都可供开源社区查看。由于代码库是公开的，安全漏洞能被快速地发现并被修复。因此，开源项目的高透明度使其更为安全且值得信赖，为创新和自由发挥铺平了道路。

此外，在大规模的组织层面，开源软件能够使各种企业在各个方面受益。某汽车品牌使用开源软件，更快地进行程序开发，十分高效地推出全新产品版本。而《财富》杂志中的500强企业则依赖企业开源平台来整合并集中管理代码。在开源系统的帮助下，企业内部可以对代码进行无缝集成的编辑，进而能够安全而大规模地部署其软件。这样看来，开源能够提升开发工作的效率，进而促进创新活动更高效地进行。

以开源为背景的自主创新在新兴技术领域如人工智能（AI）、物联网（IoT）等方面扮演着关键角色。开源项目如TensorFlow和PyTorch已成为AI领域的关键推动力，通过自主创新不断改进深度学习技术。在IoT领域，开源硬件和软件项目如Arduino和Raspberry Pi为创客提供了自主创新的平台，推动了物联网技术的创新。由此可见，自主创新使开源项目在技术领域保持领先地位，并为新兴技术的发展和应用提供了坚实的基础。通过自主创新，开源项目能够不断适应和引领技术变革，为社会和产业带来持续的创新动力。

四、开源事业推动新时代创新领域可持续发展

在新时代的中国，创新和可持续发展已经成为人们关注的焦点。这两个概念之间存在密切的联系，而开源方法和开源项目恰恰在这两个方面发挥着关键作用，为创新和可持续发展提供了坚实的基础。

可持续发展需要不断的创新来为其注入新鲜血液、进而才能够应对复杂的全球挑战。开源社区提供了一个独特的环境，鼓励创新者共享和合作。开源项目的快速迭代和开放性质使其成为新时代创新的推动力。无论是在新能源技术的发展、可再生资源管理，还是绿色科技领域，开源软件、硬件和数据资源都为新思维和新方法的产生提供了重要的支持作用。

新时代的中国积极融入世界格局，新时代的中国所迎接的挑战通常不受国界限制，需要全球合作来解决。开源社区的全球性和开放性质鼓励了跨国界的协作，为可持续发展目标的实现提供了机会。在应对气候变化、全球卫生和粮食安全等全球性问题时，开源合作加速了解决方案的开发和共享，为可持续发展的全球努力注入活力。

此外，可持续发展也需要可持续的技术解决方案，而开源技术的灵活性使其成为可持续性技术创新的理想选择。开源硬件、软件和工具可以摆脱对某些技术的以来，更加容易维护那些可持续的解决方案。例如，开源的农业技术和水资源管理工具有助于提高农业生产效率，同时减少资源浪费。

新时代创新不仅关乎技术，还涉及伦理和社会责任。开源社区是一个有益的平台，可以讨论和解决伦理问题，推动可持续创新的发展。例如，在人工智能领域，开源社区积极参与了关于公平、隐私和道德原则的讨论，有助于确保创新能够可持续发展、能够被全社会所接纳。

总之，开源方法和开源项目在新时代创新和可持续发展中扮演着关键角色。它们为创新提供了持续动力、全球合作机会、可持续性技术、数据支持和伦理引导，为解决新时代的全球性挑战提供了有力工具。在创新与可持续发展之间，开源是连接的纽带，促进了技术和社会的平衡增长。在新时代的征程中，开源将继续为创新和可持续发展注入活力，助力我们创造更加美好的未来。

五、守住开源底线，把握原则，方能做到完全意义上的创新

近日，一款自称“全国首款支持多环境开发的 IDE” —— CEC-IDE 横空出世。业内人士对其进行分析后却发现该软件仅仅是在某知名开源项目的基础上套壳而成的，所谓“自主研发”更是无从谈起。这样的行为不禁让人们反思：使用开源项目进行二次开发，到底算不算创新呢？要如何把握好其中的界限，才能在新时代的中国，如何更好地践行开源精神与创新意识呢？

在使用开源项目进行创新时，需要细致权衡使用开源项目和抄袭之间的界限。开源项目是一个强大的创新工具，但同时也需要遵守开源许可协议和知识产权法律。对如何正确利用开源项目来推动创新的理解显得至关重要。

首先，开源项目的使用者应充分学习开源项目的许可协议。每个开源项目都有其独特的协议，规定了源代码的使用和分发方式。在使用开源项目之前，需详细阅读并理解相关的许可协议，确保使用方式合法合规，避免法律纠纷。

另外，使用开源并不意味着可以随意抄袭。开源项目的初衷是鼓励创新，而不是盲目地复制。应该将开源项目视为一个启发源，一个学习和借鉴的基础。通过在其基础上进行独立思考、修改和改进，你可以为创新提供有力的支持。

此外，在使用开源项目时，要尊重各方的知识产权。虽然开发者可以在开源项目的基础上构建自己的解决方案，但必须遵守许可协议，并清晰地标识出二次代码与原始项目之间的区别。开发者应当敬重开源项目的创作者和社区，尊重他们的工作，感激他们的贡献，才能正确使用开源项目。

总之，正确利用开源项目来创新需要谨慎、道德和合规。开源项目为创新提供了宝贵的资源，但使用时必须遵循法律和伦理规范。遵守许可协议、尊重社区和积极贡献，方能最大程度地利用开源项目的力量，推动创新，并为整个技术社区的发展作出贡献。

六、开源中国的过去、现在与未来

“10年前中国人只是国际开源资源的使用者，此后中国人开始成为国际开源资源的贡献者。” Linux基金会执行董事 Jim Zemlin如是说。开源事业在中国正进行着日新月异的发展。

过去的十年里，中国在开源领域取得了显著的进展。中国的开发者积极参与了众多开源项目，贡献了大量代码和解决方案。这种积极性不仅提高了国内技术水平，还推动了中国在全球开源社区中的地位。开源中国社区的壮大为国内外开发者提供了交流和合作的平台，促进了技术创新。

当前，开源中国已经成为了全球开源社区中的一个重要角色。中国的开源生态系统日益丰富，涵盖了各种领域，从操作系统到人工智能、物联网等新兴技术。开源项目如CarbonData、Dubbo、OpenHarmony等在中国社区蓬勃发展，得到了广泛的应用和改进。

未来，开源中国将继续发挥重要作用。在新时代的中国，技术创新和开源贡献将持续发展，为全球开源社区注入更多活力。开源中国将努力推动开源文化的普及，培养更多的开源开发者，推动技术领域的不断前进。同时，中国也将继续在国际开源合作中扮演积极角色，促进全球开源社区的融合和共赢。

七、总结

从长远来看，创新在开源项目中发挥着关键作用，如同点燃了创新的燃料，推动着技术的不断进步。开源的本质赋予了创新以自主性和灵活性，让创新在竞争激烈的领域中保持着活力，同时也推动了世界范围内的技术发展。这种自主创新不仅对技术领域至关重要，更对国家和产业的发展产生了深远的影响。因此，让我们都加强创新意识，不断提升创新能力，为更加创新、繁荣的未来贡献力量！

在开源项目中，创新是一个源源不断的过程。开源社区的自由和开放性质吸引了全球各地的创新者，他们共同致力于改进和创造新的技术解决方案。这种合作和共享的精神加速了创新的速度，使技术迭代迅猛，不断适应着不断变化的需求。从操作系统到应用软件，从人工智能到生物技术，开源项目的影响力无处不在，它们一直在塑造着我们的未来。

自主创新也是开源项目的一大特点，它允许开发者和组织自由地定制和改进软件和技术，而无需受制于专有软件的限制。这种自主性质使得创新者可以更加灵活地满足特定需求，从而保持了竞争力。不仅如此，开源项目还鼓励了创新的多样性，吸引了各种各样的人积极参与，从而推动了不同领域的技术发展。它们成为了全球创新的火种，点燃了无数灵感的火花。

然而，创新不仅仅局限于技术领域，它还对国家和产业的发展产生着深远的影响。那些重视创新的国家往往更具竞争力，更有可能在全球舞台上崭露头角。创新不仅创造了新的就业机会，还推动了经济的增长。因此，我们需要时刻保持创新意识，鼓励和支持创新的发展。只有这样，我们才能为更加创新、繁荣的未来贡献自己的力量，共同推动技术和社会的进步。在开源和创新的道路上，每一个人都可以发挥作用，为更好的未来而努力。

参考文献：

GitHub：What is Open Source Software (OSS)?
维基百科：《Linux 操作系统》
中国科学院：《构建“开源”创新体系助力我国关键数字技术“弯道超车”》
人民日报：《以开源开放为抓手形成科技与产业新优势》
中国科学院：《国际开源发展经验及其对我国开源创新体系建设的启示》

NOIP 2023 游记

Fri, 17 Nov 2023 00:00:00 GMT

前一天（11月18日）晚驱车来到杭州，下榻一家酒店，第二天一早按照上次参加 CSP-S 的经验摸到了考场。

8:10 左右进入考场。于是阅读考生守则。

8:20 下发压缩包密码，8:28下发 pdf 密码。

按照以往的经验，T1 大概是可以直接冲的，尽管要花费不少时间。果不其然，我先花了一个小时写出了 O(n2logn)O(n^2logn)O(n2logn) 的解法，也就是循环内套了一个字符串排序。然而数据范围是 n=3000n=3000n=3000 ，这样算来 200% 会超时。又研究了一下 O(n2)O(n^2)O(n2) 的算法，成功缩减了复杂度，然而这又花费了我一个小时。

时间来到 10:30 ，开始看 T2 。按照以往的经验，第二题开始就要骗分了。所以就直接只写 1～4 个数据点，5～8 打算最后再回过头来写。

又过了一个小时，11:10 ，看到 expand 这道题。乍一看毫无头绪，貌似只会写第 1、2 两个点。也罢，草草写了看下一题。

11:30 看到最后一题，看出来是动态规划，大概写了 40 分钟，写了最朴素的 dp ，过了前两个点，理论上复杂度是可以过三四两个测试点的，但是不知道为什么 WA 了。调了半天找出来两个错误，但是还是未能通过。

12:20 此时再回过头看 T2 ，能看出来大概是并查集的变体，然而因为没有充分的思考时间，写出来的东西并不能过后面的数据点。

最后交卷了。中午吃了 KFC ，再去逛了一下杭师大的校园。

总结：这次 NOIP 本来就是放宽了心态去考的，也不期望拿什么大奖，一年没学也只是图个参与机会。反正今年也是最后一次参加信息竞赛了，下次要等到大学力！

Shot on HUAWEI P50 Pro.

Sun, 29 Oct 2023 00:00:00 GMT

skyView API 一览

Fri, 27 Oct 2023 00:00:00 GMT

图片上传的一般流程#

1. 用户请求获取用于图床的 token （该部分应由 zvms-backend 实现）#

用户访问 backend 服务器，请求图床 token 。 backend 服务器再根据当前用户的身份，发送请求至图床服务器。

1
url: BASEURL/user/getToken?superAdminToken=<...>&userId=<...>&permission=<...>

permission 字段，0 表示普通用户，1 表示管理员用户。superAdminToken 是认证服务器的密钥，是认为预先设定的。

2. 用户得到图床 token ，可上传图片至图床服务器#

1
POST /user/image

必须内容： request.form['token'] 、 request.files['image'] 。

返回内容：

1
{
2
  "code": 200,
3
  "message": "上传图片成功",
4
  "data": {
5
    "url": config.SERVERURL + "/getimage/" + fileId,
6
    "author": userId,
7
    "md5": md5,
8
    "keywords": keywords,
9
    "timestamp": timestamp
10
  }
11
}

3. 用户得到图片 url ，即可在前端展示该图片。#

1
GET 你上面获取到的 data.url 字段

服务器将会从加密的 Backblaze 上，通过 Cloudflare 的流量转发，再通过图床服务器的流量转发，直接呈现图片。

4. 其他操作#

以下操作均需要请求参数 token=<...> 来验证身份。

GET /user/<userId>/image 获取某个用户的所有图片列表。若不是自己的，需要管理员权限。
GET /user/image 获取当前用户的所有图片列表。
GET /image/:id 获取图片信息。

CSP 考前膜拜模版

Fri, 20 Oct 2023 00:00:00 GMT

0. 重要提示#

0.1 重定向输入输出#

1
int main(){
2
  freopen("decode.in","r",stdin);
3
  freopen("decode.out","w",stdout);
4
    // ...
5
    return 0;
6
}

0.2 文件目录#

截屏2023-10-21 08.58.11.png

截屏2023-10-21 08.58.46.png

0.3 试题#

CSP-J 2023

1. P3865 ST 表 #

题目描述#

给定一个长度为 NNN 的数列，和 MMM 次询问，求出每一次询问的区间内数字的最大值。

输入格式#

第一行包含两个整数 N,MN,MN,M，分别表示数列的长度和询问的个数。

第二行包含 NNN 个整数（记为 aia_iai），依次表示数列的第 iii 项。

接下来 MMM 行，每行包含两个整数 li,ril_i,r_ili,ri，表示查询的区间为 [li,ri][l_i,r_i][li,ri]。

输出格式#

输出包含 MMM 行，每行一个整数，依次表示每一次询问的结果。

样例 #1#

样例输入 #1#

1
8 8
2
9 3 1 7 5 6 0 8
3
1 6
4
1 5
5
2 7
6
2 6
7
1 8
8
4 8
9
3 7
10
1 8

样例输出 #1#

提示#

对于 30%30\%30% 的数据，满足 1≤N,M≤101\le N,M\le 101≤N,M≤10。

对于 70%70\%70% 的数据，满足 1≤N,M≤1051\le N,M\le {10}^51≤N,M≤105。

对于 100%100\%100% 的数据，满足 1≤N≤1051\le N\le {10}^51≤N≤105，1≤M≤2×1061\le M\le 2\times{10}^61≤M≤2×106，ai∈[0,109]a_i\in[0,{10}^9]ai∈[0,109]，1≤li≤ri≤N1\le l_i\le r_i\le N1≤li≤ri≤N。

代码#

1
#include <bits/stdc++.h>
2
using namespace std;
3
inline int read()
4
{
5
  int x=0,f=1;char ch=getchar();
6
  while (ch<'0'||ch>'9'){if (ch=='-') f=-1;ch=getchar();}
7
  while (ch>='0'&&ch<='9'){x=x*10+ch-48;ch=getchar();}
8
  return x*f;
9
}
10
const int maxn=1e6+5;
11
int n,m;
12
int a[maxn];
13
int st[maxn][(int)log2(maxn)+1];
14
int l,r;
15
int solve(int l,int r){
16
    return max(st[l][(int)log2(r-l+1)],st[r-(1<<int(log2(r-l+1)))+1][(int)log2(r-l+1)]);
17
}
18
int main(){
19
    n=read(),m=read();
20
    for(int i=1;i<=n;i++){
21
        a[i]=read();
22
        st[i][0]=a[i];
23
    }
24
    for(int j=1;j<=log2(n);j++){
25
        for(int i=1;i+(1<<(j-1))<=n;i++){
26
            st[i][j]=max(st[i][j-1],st[i+(1<<(j-1))][j-1]);
27
        }
28
    }
29
    while(m--){
30
        l=read(),r=read();
31
        cout<<solve(l,r)<<"\n";
32
    }
33
    return 0;
34
}

展开收起

2. P4779 【模板】单源最短路径（标准版）#

题目背景#

2018 年 7 月 19 日，某位同学在 NOI Day 1 T1 归程一题里非常熟练地使用了一个广为人知的算法求最短路。

然后呢？

100→60100 \rightarrow 60100→60；

Ag→Cu\text{Ag} \rightarrow \text{Cu}Ag→Cu；

最终，他因此没能与理想的大学达成契约。

小 F 衷心祝愿大家不再重蹈覆辙。

题目描述#

给定一个 nnn 个点，mmm 条有向边的带非负权图，请你计算从 sss 出发，到每个点的距离。

数据保证你能从 sss 出发到任意点。

输入格式#

第一行为三个正整数 n,m,sn, m, sn,m,s。第二行起 mmm 行，每行三个非负整数 ui,vi,wiu_i, v_i, w_iui,vi,wi，表示从 uiu_iui 到 viv_ivi 有一条权值为 wiw_iwi 的有向边。

输出格式#

输出一行 nnn 个空格分隔的非负整数，表示 sss 到每个点的距离。

样例 #1#

样例输入 #1#

样例输出 #1#

1
0 2 4 3

提示#

样例解释请参考数据随机的模板题。

1≤n≤1051 \leq n \leq 10^51≤n≤105；

1≤m≤2×1051 \leq m \leq 2\times 10^51≤m≤2×105；

s=1s = 1s=1；

1≤ui,vi≤n1 \leq u_i, v_i\leq n1≤ui,vi≤n；

0≤wi≤1090 \leq w_i \leq 10 ^ 90≤wi≤109,

0≤∑wi≤1090 \leq \sum w_i \leq 10 ^ 90≤∑wi≤109。

本题数据可能会持续更新，但不会重测，望周知。

代码#

1
#include <bits/stdc++.h>
2
using namespace std;
3
int n,m,s;
4
struct node{
5
    int a,val;
6
    bool operator < (node b) const{
7
        return val>b.val;
8
    }
9
};
10
vector <node> G[100010];
11
priority_queue <node> q;
12
int dis[100010];
13
int main(){
14
    cin>>n>>m>>s;
15
    int a,b,c;
16
    for(int i=1;i<=m;i++){
17
        cin>>a>>b>>c;
18
        G[a].push_back({b,c});
19
    }
20
    q.push({s,0});
21
    memset(dis,0x3f,sizeof dis);
22
    dis[s]=0;
23
    while(!q.empty()){
24
        node now=q.top();
25
        q.pop();
26
        if(now.val!=dis[now.a])continue;
27
        for(int i=0;i<G[now.a].size();i++){
28
            node nxt=G[now.a][i];
29
            if(dis[nxt.a]>dis[now.a]+nxt.val){
30
                q.push({nxt.a,dis[now.a]+nxt.val});
31
                dis[nxt.a]=now.val+nxt.val;
32
            }
33
        }
34
    }
35
    for(int i=1;i<=n;i++){
36
        cout<<dis[i]<<" ";
37
    }
38
    return 0;
39
}

展开收起

3. P3366【模板】最小生成树 #

题目描述#

如题，给出一个无向图，求出最小生成树，如果该图不连通，则输出 orz。

输入格式#

第一行包含两个整数 N,MN,MN,M，表示该图共有 NNN 个结点和 MMM 条无向边。

接下来 MMM 行每行包含三个整数 Xi,Yi,ZiX_i,Y_i,Z_iXi,Yi,Zi，表示有一条长度为 ZiZ_iZi 的无向边连接结点 Xi,YiX_i,Y_iXi,Yi。

输出格式#

如果该图连通，则输出一个整数表示最小生成树的各边的长度之和。如果该图不连通则输出 orz。

样例 #1#

样例输入 #1#

样例输出 #1#

1
7

提示#

数据规模：

对于 20%20\%20% 的数据，N≤5N\le 5N≤5，M≤20M\le 20M≤20。

对于 40%40\%40% 的数据，N≤50N\le 50N≤50，M≤2500M\le 2500M≤2500。

对于 70%70\%70% 的数据，N≤500N\le 500N≤500，M≤104M\le 10^4M≤104。

对于 100%100\%100% 的数据：1≤N≤50001\le N\le 50001≤N≤5000，1≤M≤2×1051\le M\le 2\times 10^51≤M≤2×105，1≤Zi≤1041\le Z_i \le 10^41≤Zi≤104。

样例解释：

所以最小生成树的总边权为 2+2+3=72+2+3=72+2+3=7。

代码#

1
#include <bits/stdc++.h>
2
using namespace std;
3
int n,m;
4
int x,y,z;
5
const int maxn=5010;
6
struct ed{
7
    int val,x,y;
8
};
9
vector <ed> edges;
10
bool cmp(ed x,ed y){
11
    return x.val<y.val;
12
}
13
int numberOfEdges=0;
14
int fa[maxn];
15
int find(int x){
16
    return fa[x]==x?x:fa[x]=find(fa[x]);
17
}
18
void merge(int x,int y){
19
    int fax=find(x),fay=find(y);
20
    if(fax!=fay){
21
        fa[fax]=fay;
22
    }
23
}
24
int main(){
25
    cin>>n>>m;
26
    for(int i=1;i<=n;i++){
27
        fa[i]=i;
28
    }
29
    for(int i=1;i<=m;i++){
30
        cin>>x>>y>>z;
31
        if(x==y)continue;
32
        edges.push_back({z,x,y});
33
    }
34
    int ans=0;
35
    sort(edges.begin(),edges.end(),cmp);
36
    for(auto i:edges){
37
        int fax=find(i.x),fay=find(i.y);
38
        if(fax!=fay){
39
            numberOfEdges++;
40
            merge(i.x,i.y);
41
            ans+=i.val;
42
        }
43
    }
44
    if(numberOfEdges!=n-1){
45
        cout<<"orz"<<endl;
46
        return 0;
47
    }
48
    cout<<ans;
49
    return 0;
50
}

展开收起

4. 【模板】树状数组 1#

题目描述#

如题，已知一个数列，你需要进行下面两种操作：

将某一个数加上 xxx
求出某区间每一个数的和

输入格式#

第一行包含两个正整数 n,mn,mn,m，分别表示该数列数字的个数和操作的总个数。

第二行包含 nnn 个用空格分隔的整数，其中第 iii 个数字表示数列第 iii 项的初始值。

接下来 mmm 行每行包含 333 个整数，表示一个操作，具体如下：

1 x k 含义：将第 xxx 个数加上 kkk
2 x y 含义：输出区间 [x,y][x,y][x,y] 内每个数的和

输出格式#

输出包含若干行整数，即为所有操作 222 的结果。

样例 #1#

样例输入 #1#

样例输出 #1#

提示#

【数据范围】

对于 30%30\%30% 的数据，1≤n≤81 \le n \le 81≤n≤8，1≤m≤101\le m \le 101≤m≤10；
对于 70%70\%70% 的数据，1≤n,m≤1041\le n,m \le 10^41≤n,m≤104；
对于 100%100\%100% 的数据，1≤n,m≤5×1051\le n,m \le 5\times 10^51≤n,m≤5×105。

数据保证对于任意时刻，aaa 的任意子区间（包括长度为 111 和 nnn 的子区间）和均在 [−231,231)[-2^{31}, 2^{31})[−231,231) 范围内。

样例说明：

故输出结果14、16

代码#

1
#include<cstdio>
2
#include<iostream>
3
using namespace std;
4
const int maxn=5e5+10;
5
int n,m;
6
int a[maxn];
7
int bit[maxn];
8
int k,x,y;
9
int lowbit(int x){
10
    return x & -x;
11
}
12
void change(int x,int y){
13
    while(x<=n){
14
        bit[x]+=y;
15
        x+=lowbit(x);
16
    }
17
}
18
int query(int x){
19
    int ans=0;
20
    while(x>0){//边界条件x>0!
21
        ans+=bit[x];
22
        x-=lowbit(x);
23
    }
24
    return ans;
25
}
26
int main(){
27
    cin>>n>>m;
28
    for(int i=1;i<=n;i++){
29
        scanf("%d",&a[i]);
30
        change(i,a[i]);//一开始都是0，要初始化加上a[i]
31
    }
32
    for(int i=1;i<=m;i++){
33
        scanf("%d%d%d",&k,&x,&y);
34
        if(k==1){
35
            change(x,y);//将第x个数加上y
36
        }else{
37
            printf("%d\n",query(y)-query(x-1));//求出区间和
38
        }
39
    }
40
    return 0;
41
}

展开收起

5. 【模板】树状数组 2#

题目描述#

如题，已知一个数列，你需要进行下面两种操作：

将某区间每一个数加上 xxx；
求出某一个数的值。

输入格式#

第一行包含两个整数 NNN、MMM，分别表示该数列数字的个数和操作的总个数。

第二行包含 NNN 个用空格分隔的整数，其中第 iii 个数字表示数列第 ii i 项的初始值。

接下来 MMM 行每行包含 222 或 444个整数，表示一个操作，具体如下：

操作 111：格式：1 x y k 含义：将区间 [x,y][x,y][x,y] 内每个数加上 kkk；

操作 222：格式：2 x 含义：输出第 xxx 个数的值。

输出格式#

输出包含若干行整数，即为所有操作 222 的结果。

样例 #1#

样例输入 #1#

样例输出 #1#

提示#

样例 1 解释：#

故输出结果为 6、10。

数据规模与约定#

对于 30%30\%30% 的数据：N≤8N\le8N≤8，M≤10M\le10M≤10；

对于 70%70\%70% 的数据：N≤10000N\le 10000N≤10000，M≤10000M\le10000M≤10000；

对于 100%100\%100% 的数据：1≤N,M≤5000001 \leq N, M\le 5000001≤N,M≤500000，1≤x,y≤n1 \leq x, y \leq n1≤x,y≤n，保证任意时刻序列中任意元素的绝对值都不大于 2302^{30}230。

代码#

1
#include <bits/stdc++.h>
2
using namespace std;
3
const int maxn=5e5+10;
4
int a[maxn];
5
int bit[maxn];
6
int n,m;
7
int cmd,x,y,k;
8
// 差分思想，用bit[x]表示第i个数
9
int lowbit(int x){
10
    return x&-x;
11
}
12
void add(int x,int y){
13
    while(x<=n){
14
        bit[x]+=y;
15
        x+=lowbit(x);
16
    }
17
}
18
int query(int x){
19
    int ans=0;
20
    while(x>0){//边界条件x>0!
21
        ans+=bit[x];
22
        x-=lowbit(x);
23
    }
24
    return ans;
25
}
26
int main(){
27
    cin>>n>>m;
28
    for(int i=1;i<=n;i++){
29
        cin>>a[i];
30
        add(i,a[i]);
31
        add(i+1,-a[i]);
32
    }
33
    for(int i=1;i<=m;i++){
34
        cin>>cmd;
35
        if(cmd==1){
36
            cin>>x>>y>>k;
37
            add(x,k);
38
            add(y+1,-k);
39
        }else{
40
            cin>>x;
41
            cout<<query(x)<<endl;
42
        }
43
    }
44
    return 0;
45
}

展开收起

6. 【模板】线段树 1#

题目描述#

如题，已知一个数列，你需要进行下面两种操作：

将某区间每一个数加上 kkk。
求出某区间每一个数的和。

输入格式#

第一行包含两个整数 n,mn, mn,m，分别表示该数列数字的个数和操作的总个数。

第二行包含 nnn 个用空格分隔的整数，其中第 iii 个数字表示数列第 iii 项的初始值。

接下来 mmm 行每行包含 333 或 444 个整数，表示一个操作，具体如下：

1 x y k：将区间 [x,y][x, y][x,y] 内每个数加上 kkk。
2 x y：输出区间 [x,y][x, y][x,y] 内每个数的和。

输出格式#

输出包含若干行整数，即为所有操作 2 的结果。

样例 #1#

样例输入 #1#

样例输出 #1#

提示#

对于 30%30\%30% 的数据：n≤8n \le 8n≤8，m≤10m \le 10m≤10。
对于 70%70\%70% 的数据：n≤103n \le {10}^3n≤103，m≤104m \le {10}^4m≤104。
对于 100%100\%100% 的数据：1≤n,m≤1051 \le n, m \le {10}^51≤n,m≤105。

保证任意时刻数列中所有元素的绝对值之和 ≤1018\le {10}^{18}≤1018。

【样例解释】

代码#

1
#include <bits/stdc++.h>
2
#define int long long
3
using namespace std;
4
const int maxn=8e5+10;
5
int tree[maxn];
6
int lazy[maxn];
7
int n,m;
8
void push_up(int p){
9
    tree[p]=tree[p*2]+tree[p*2+1];
10
}
11
void push_down(int p,int l,int r){
12
    lazy[p*2]+=lazy[p];
13
    lazy[p*2+1]+=lazy[p];
14
    int mid=(r+l)/2;
15
    tree[p*2]+=lazy[p]*(mid-l+1);
16
    tree[p*2+1]+=lazy[p]*(r-mid);
17
    lazy[p]=0;
18
}
19
void build(int s,int t,int p){
20
    if(s==t){
21
        cin>>tree[p];
22
        return;
23
    }
24
    int mid=(s+t)/2;
25
    build(s,mid,p*2);
26
    build(mid+1,t,p*2+1);
27
    push_up(p);
28
}
29
void update(int l,int r,int s,int t,int p,int v){
30
    if(l<=s&&t<=r){
31
        lazy[p]+=v;
32
        tree[p]+=v*(t-s+1);
33
        return;
34
    }
35
    push_down(p,s,t);
36
    int mid=(s+t)/2;
37
    if(mid>=l)
38
        update(l,r,s,mid,p*2,v);
39
    if(mid<r)
40
        update(l,r,mid+1,t,p*2+1,v);
41
    push_up(p);
42
}
43
int query(int l,int r,int s,int t,int p){
44
    if(l<=s&&t<=r){
45
        return tree[p];
46
    }
47
    int mid=(s+t)/2;
48
    int ans=0;
49
    push_down(p,s,t);
50
    if(mid>=l){
51
        ans+=query(l,r,s,mid,p*2);
52
    }
53
    if(mid<r){
54
        ans+=query(l,r,mid+1,t,p*2+1);
55
    }
56
    return ans;
57
}
58
signed main(){
59
    cin>>n>>m;
60
    build(1,n,1);
61
    while(m--){
62
        int op,x,y,z;
63
        cin>>op;
64
        if(op==1){
65
            cin>>x>>y>>z;
66
            update(x,y,1,n,1,z);
67
        }else{
68
            cin>>x>>y;
69
            cout<<query(x,y,1,n,1)<<endl;
70
        }
71
    }
72
    return 0;
73
}

展开收起

网站整改说明(2023-10-18)

Wed, 18 Oct 2023 00:00:00 GMT

本人于前日提交了网站公安备案申请（域名amzcd.top），今日方知由于之前网站中有评论功能，所以被标记为含有交互性内容，需要进行当面核验与实地检查。现在已将网站全面整改，完全关闭一切评论功能，移除了所有交互性内容，保证严格不提供互联网交互服务。本人现为高中生，上学时间恰与您部门工作时间重合，故在校期间不便进行相关认证操作。烦劳您在相关核查后，指导我进一步操作。

字典树（Trie 树）

Sat, 14 Oct 2023 00:00:00 GMT

1. 题目描述#

给定 nnn 个模式串 s1,s2,…,sns_1, s_2, \dots, s_ns1,s2,…,sn 和 qqq 次询问，每次询问给定一个文本串 tit_iti，请回答 s1∼sns_1 \sim s_ns1∼sn 中有多少个字符串 sjs_jsj 满足 tit_iti 是 sjs_jsj 的前缀。

一个字符串 ttt 是 sss 的前缀当且仅当从 sss 的末尾删去若干个（可以为 0 个）连续的字符后与 ttt 相同。

输入的字符串大小敏感。例如，字符串 Fusu 和字符串 fusu 不同。

2. 解析#

对于每一个模式字符串，从第一个字符到最后一个字符建立一棵树，并给路径上的每一个标记点加上 111 。输入检查字符串的时候，顺着树上的匹配路径往下走，一直走到不能再走，如果前面没有匹配的字符串了，说明答案就是 000 。如果结束为止在树的某个节点上，答案就是这个点的标记数目。

3. 代码#

1
#include <bits/stdc++.h>
2
using namespace std;
3
int q,n,m;
4
struct Node{
5
    vector <Node> children;
6
    char val;
7
    int cnt;
8
};
9
int main(){
10
    cin>>q;
11
    while(q--){
12
        cin>>n>>m;
13
        Node formatStr;
14
        for(int i=1;i<=n;i++){
15
            string s;
16
            cin>>s;
17
            // ptr to root
18
            Node *ptr=&formatStr;
19
            for(auto c:s){
20
                bool flag=1;
21
                for(auto &child:ptr->children){
22
                    if(child.val==c){
23
                        child.cnt++;
24
                        ptr=&child;
25
                        flag=0;
26
                        break;
27
                    }
28
                }
29
                if(flag){
30
                    // 说明没有现成的节点
31
                    Node newNode;
32
                    newNode.val=c;
33
                    newNode.cnt=1;
34
                    ptr->children.push_back(newNode);
35
                    ptr=&ptr->children.back();
36
                }
37
            }
38
        }
39
        for(int i=1;i<=m;i++){
40
            string s;
41
            cin>>s;
42
            Node *ptr=&formatStr;
43
            bool flag=1;
44
            int findCnt=0;
45
            for(auto c:s){
46
                for(auto &child:ptr->children){
47
                    if(child.val==c){
48
                        findCnt++;
49
                        ptr=&child;
50
                        flag=0;
51
                        break;
52
                    }
53
                }
54
                if(flag){
55
                    // 说明路走不通了。
56
                    break;
57
                }
58
            }
59
            if(findCnt==s.size()){
60
                cout<<ptr->cnt<<endl;
61
            }else{
62
                cout<<0<<endl;
63
            }
64
        }
65
    }
66
    return 0;
67
}

展开收起

然而，这样的代码的运行速度不太理想，我们可以进一步优化。

image.png

考虑在查找子节点时降到 log(n)log(n)log(n) 的复杂度，用 setsetset 存子节点，就能便捷地进行二分查找。

1
struct Node{
2
    set <Node> children;
3
    char val;
4
    int cnt;
5
    // 重定义小于号
6
    bool operator < (const Node &rhs) const{
7
        return val<rhs.val;
8
    }
9
};

CSP初赛单选整理

Sun, 10 Sep 2023 00:00:00 GMT

设 A 和 B 是两个长为 n 的有序数组，现在需要将 A 和 B 合并成一个排好序的数组，请问任何以元素比较作为基本运算的归并算法最坏情况下至少要做（）次比较。

A. n2n^2n2 B. nlognn log nnlogn C. 2n2n2n D. 2n−12n-12n−1

至少要做 2n−12n-12n−1 次比较。下面是示例代码：

1
#include <iostream>
2
#include <vector>
3

4
int cnt = 0;
5

6
std::vector<int> mergeSortedArrays(const std::vector<int>& A, const std::vector<int>& B) {
7
    std::vector<int> result;
8
    int i = 0; // Index for array A
9
    int j = 0; // Index for array B
10

11
    while (i < A.size() && j < B.size()) {
12
        cnt++;
13
        if (A[i] <= B[j]) {
14
            result.push_back(A[i]);
15
            i++;
16
        } else {
17
            result.push_back(B[j]);
18
            j++;
19
        }
20
    }
21

22
    // Append remaining elements from A (if any)
23
    while (i < A.size()) {
24
        result.push_back(A[i]);
25
        i++;
26
    }
27

28
    // Append remaining elements from B (if any)
29
    while (j < B.size()) {
30
        result.push_back(B[j]);
31
        j++;
32
    }
33

34
    return result;
35
}
36

37
int main() {
38
    std::vector<int> A = {1, 3};
39
    std::vector<int> B = {2, 4};
40

41
    std::vector<int> merged = mergeSortedArrays(A, B);
42

43
    std::cout << "Merged Array: ";
44
    for (int num : merged) {
45
        std::cout << num << " ";
46
    }
47
    std::cout << std::endl;
48

49
    int comparisons = A.size() + B.size() - 1;
50
    std::cout << "Number of Comparisons: " << cnt << std::endl;
51

52
    return 0;
53
}

展开收起

下面不属于贪心算法的是（）

A. 单源最短路径中的Dijkstra算法
B. 最小生成树的Prim算法
C. 最小生成树的Kruskal算法
D. 计算每对顶点最短路径的Floyd-Warshall算法

Disjsktra算法在松弛操作时用到了贪心的思想；Prim、Kruskal在生树时优先选择最小边；Floyd算法使用的是动态规划的操作。
一个深度为5（根节点深度为1）的完全3叉树，按前序遍历的顺序给节点从1开始编号，则第100号节点的父节点是第（）号。

A. 959595
B. 969696
C. 979797
D. 989898
- 前序遍历：根，左，右；
- 中序遍历：左，根，右；
- 后序遍历：左，右，根。
在三号节点下，一共有12个节点，故3号的兄弟节点为16号、29号。在二号节点下，一共有39个节点。故二号节点的兄弟节点为42号、82号。所以第100号节点在第二层的第三个节点下面。然后再多画几个节点，就能轻松得到答案为 C 了。
1. 设G是连通无向图，则称经过G的每条边一次并且仅一次的路径为欧拉通路；
2. 如果欧拉通路是回路（起点和终点是同一个顶点），则称此回路为欧拉回路（Euler circuit）。
共有 888 人选修了程序设计课程，期末大作业要求由 222 人组成的团队完成。假设不区分每个团队内 222 人的角色和作用，请问共有多少种可能的组队方案。（）

A. 282828 B. 323232 C. 565656 D. 646464

题目有歧义，直接 C82C_8^2C82 即可。
以下四种编程语言中，属于弱类型编程语言的是：

A. Java B. Go C. Rust D. C++
- 强类型：Java、C#、Python、Ruby、Erlang、GO、Rust……
- 弱类型：C、C++、Javascript、Perl、PHP、VB……
强类型语言是一种强制类型定义的语言，即一旦某一个变量被定义类型，如果不经强制转换，那么它永远就是该数据类型。而弱类型语言是一种弱类型定义的语言，某一个变量被定义类型，该变量可以根据环境变化自动进行转换，不需要经过现行强制转换。
竞赛图也叫有向完全图。每对顶点之间都有一条边相连的有向图称为竞赛图。5 个点的无标号竞赛图数是：（）。

A. 999 B. 101010 C. 111111 D. 121212

答案为 D 。强联通，且大小为i的竞赛图个数为 fi=hi−Σj=1i−1hj×(ji)×fi−jf_i=h_i-\Sigma_{j=1}^{i-1}h_j \times (_j^i) \times f_{i-j}fi=hi−Σj=1i−1hj×(ji)×fi−j 。
以下代码的输出结果是？
1 #include <iostream> 2 union U 3 { 4 bool flag1, flag2, flag3, flag4, flag5; 5 signed short a; 6 unsigned short b; 7 enum E 8 { 9 CardA = 0, 10 CardB = 1, 11 CardC = 2, 12 CardD = 142857 13 } e; 14 } u; 15 int main() 16 { 17 std::cout << sizeof(u) << std::endl; 18 return 0; 19 }
展开收起
在这段C++代码中，定义了一个联合（union）类型 U，该联合包含了不同类型的成员变量，包括布尔型、有符号短整数、无符号短整数和枚举类型。联合类型允许在相同的内存位置存储不同类型的数据，但每次只能使用其中一个成员。

计算 sizeof(u) 将返回 u 这个联合类型的大小，即它所占用的内存字节数。在计算 sizeof 时，通常使用联合中最大成员的大小作为整个联合的大小。

在这个联合中，枚举类型 E 的最大值是 CardD，它是一个较大的整数，可能需要占用较多的内存。因此，整个联合 U 的大小将由 CardD 的大小决定。通常，int 类型占用4个字节，所以 CardD 的值为142857，占用4个字节。

因此，sizeof(u) 的输出结果应该是4，即联合 U 占用4个字节的内存空间。

输出结果是：
```
1
4
```
五个本质不同的店在没有重边或者自环的情况下，组成不同的无向图的个数是（）？

五个不同的点，最多可有 4+3+2+1=104+3+2+1=104+3+2+1=10 条边。每条边有或没有，所以最终结果为 210=10242^{10}=1024210=1024 。

以下代码的输出结果为？

1
#include <iostream>
2
using namespace std;
3

4
int ans=0;
5
void dfs(int x){
6
    ++ans;
7
    if(x<=1) return;
8
    dfs(x/3);
9
    if(x/3+1<x) dfs(x/3+1);
10
    if(x/3+2<x) dfs(x/3+2);
11
}
12

13
int main(){
14
    dfs(10);
15
    cout<<ans<<endl;
16
    return 0;
17
}

展开收起

中国计算机学会成立于（）年？1962年。
各种排序的比较：

image.png

抵制日本核污水

Tue, 29 Aug 2023 00:00:00 GMT

转载自人民网 http://world.people.com.cn/gb/n1/2023/0825/c1002-40063506.html ，原标题：《国际社会强烈反对日本政府启动核污染水排海——“日方悍然将核污染水排海是对人类未来的极大不负责”》。

8月24日、日本政府は、国内外からの反対に無視し、福島の核汚染水を一方的に海に放出する強行措置を実施しました。多くの国々の人々とメディアは、日本の核汚染水の海洋排出計画の正当性、合法性、安全性が国際社会から疑問視されていることを指摘し、日本政府が国際的な懸念を無視し、国際的な義務を遂行しないまま核汚染水の排出を強行し、海洋環境と人間の健康を危険にさらし、周辺国の合法的な権益を侵害し、非常に利己的かつ無責任だと非難しました。

「海洋環境を破壊し、社会経済に損害を与え、世界に否定的な影響をもたらす」

8月22日午後、韓国の市民団体から成る「日本の放射線汚染水排出全国行動」と韓国の最大野党である共同民主党は、日本大使館前で福島の核汚染水排出に抗議する緊急会見を開催しました。集会に参加した代表は、「核汚染水の排出を撤回せよ」というスローガンを掲げ、「大海は日本の核廃棄物処分場ではない」と高く叫びました。

共同民主党は声明で、「日本は国際社会の一員として、国際法と国際基準を無視し、環境を破壊する決定を下し、国際連合海洋法条約とロンドン廃棄物条約に反しています」と述べました。「日本の放射線汚染水排出全国行動」は、福島の核汚染水の安全性が専門家によって確認されていない状況で、日本政府がこの計画を押し進めており、「海洋環境を破壊し、社会経済に損害を与え、世界に否定的な影響をもたらす」と述べました。

23日、韓国の各地で環境団体と市民団体が抗議活動を続けました。共同民主党は国会議事堂前で集会を開催し、約1000人が参加し、日本政府に即時に核汚染水排出計画を撤回するよう要求しました。共同民主党代表の李在明は、日本がかつて帝国主義的な侵略戦争を起こし、周辺国に脅威を与えたことを指摘し、核汚染水の排出によって再び韓国と太平洋沿岸諸国に取り返しのつかない災害をもたらすと述べました。

韓国政府は24日、福島などからの水産物の輸入禁止を継続する意向を示しました。核汚染水の排出作業が開始されると、韓国の市民は水産物の安全性に対する懸念を抱く可能性があります。韓国の新聞である「韓民族日報」は、日本政府が福島の核汚染水を海に放出する決定を「歴史の犯罪」と批判しました。日本のこの行動は、世界の多くの国と人々の反対と懸念を完全に無視していると指摘しています。

韓国の「京郷新聞」は、核汚染水の安全性がまだ科学的に確認されていないと報じました。日本は初期から多核素処理システム（ALPS）の故障が頻繁に発生している事実を隠蔽し、ALPSの性能を確認するための国際原子力機関からのサンプル採取要求を拒否してきました。将来数十年にわたり、核汚染水の排出中に事故や誤操作が発生しないことは難しいでしょう。専門家は核汚染水をコンクリートで保管するなどの方法を提案していますが、日本は最もコストがかからない海への排出を選択しました。核汚染水の排出は、安全な生活の権利を侵害し、危険を将来の世代に転嫁する行為です。「核汚染水は海流に従って世界中を周回し、問題が発生した場合、責任は完全に日本が負うことになります」と述べました。

ソウル大学国際大学院の院長であるキム・ヒョンチョルは、日本が太平洋戦争の敗北後、広島と長崎の核爆発の被害者であると主張し、戦争加害者としての反省と謝罪が必要であるにもかかわらず、再び海に核汚染水を排出し、明らかに人類全体の安全を脅かしていると述べました。

「日本政府の行動は、周辺国の安全と懸念を無視し、全人類の食物連鎖に危険をもたらすものであり、犯罪行為と同等です」

バヌアツの副首相兼外務大臣であるマティ・セリマイヤは23日、太平洋地域では日本のこの行動に抵抗する強力な措置が必要であると訴え、「核汚染水が安全であることを納得させる十分な証拠がない限り、日本は核汚染水を海に排出すべきではない」と述べました。フィジーの非政府組織である人権連合は声明で述べ、日本が太平洋に核汚染水を排出することは、太平洋地域のすべての人々の人権を侵害し、海洋生物および太平洋リージョンの人々の生計に巨大な脅威をもたらすだろうと述べました。

カンボジアのベルテイ国際大学のシニアプロフェッサーであるジョセフ・マシューズは、「日本政府の行動は自己中心的で責任を持たず、海洋生態系に永久的な破壊をもたらす」と述べ、将来数十年にわたり、核汚染水中の放射性物質が日本の海域および太平洋全体に残るだろうと指摘し、これが世界の海産物貿易に大きな影響を与えると語りました。「日本政府の行動は、周辺国の安全と懸念を無視し、全人類の食物連鎖に危険をもたらすものであり、犯罪行為と同等です」と述べました。

ソロモン諸島の主要な新聞である「ソロモンスター」の編集長であるアルフレッド・ササコは、日本が核汚染水を排出する計画を実施する際、太平洋の利益を保護することを考えていないと述べ、「海洋はゴミ捨て場ではありません」と批判しました。

米国有線テレビニュースネットワークによると、現在、水素の放射性同位体であるトリウムを除去する技術は存在しません。一部の科学者は、核汚染水が希釈されても、海洋生物に危害を及ぼす可能性があると懸念しており、汚染物質は既に非常に脆弱な生態系で蓄積し続ける可能性があります。

米国のニューヨーク・タイムズは、日本の核汚染水を海に排出する決定が「誤った例を設立している」と報じ、日本の決定は「透明性も対話もなく、数十年にわたって議論を引き起こすだろう」と述べました。

英国のネイチャー誌のウェブサイトによると、太平洋島国フォーラムの核専門家グループのメンバーであるロバート・リッチマンは、核汚染水の海洋排出プロセスを進める人々が、これが海洋環境と人間の健康に安全であることを証明したかどうかについて「答えはいいえ」と述べました。リッチマンは、いくつかの科学者が東京電力と日本政府から提供されたすべてのデータを検討し、福島の原発を訪問したにもかかわらず、トリウムと炭素14に関する問題には答えがなかったと述べました。

ドイツの環境保護団体は、日本が核汚染水排出を強行することに批判的な声明を発表しました。ドイツの環境と自然保護の連合は、「海はゴミ捨て場ではありません」と述べました。

OIso 开放能力指北

Sat, 19 Aug 2023 00:00:00 GMT

0. 前言#

OIso 是一个开放的平台。为了让有限的资源实现最大利用，我们决定将 OIso 的接口进行开放。以下接口均有一定的频率限制，请勿滥用接口。

文档中一切路径的 BaseURL 为 https://online.oiso.cf ，这是全球通用稳定接口。如果您寻求更快速的国内接口，请联系开发组洽谈。

1. 搜索相关#

1.1 智能联想#

智能联想是根据用户输入的词语或拼音，推断出用户想要搜索的内容。

路径： /suggestion?q=<text>
方法：POST / GET
字段：
- text ：需要被联想的源文本
响应格式：JSON
响应示例：

1
{
2
  "hits": {
3
    "hits": [
4
      {
5
        "_id": "\u6d1b\u8c37",
6
        "_score": 4.248307,
7
        "_source": {
8
          "name": "\u6d1b\u8c37"
9
        }
10
      },
11
      {
12
        "_id": "luogu",
13
        "_score": 4.248307,
14
        "_source": {
15
          "name": "luogu"
16
        }
17
      },
18
      ...
19
    ],
20
    "max_score": 4.248307,
21
  },
22
  "took": 2
23
}

展开收起

响应说明：
- hits.hits ：包含 101010 条联想结果。
- hits.hits[]._source.name ：联想结果的文本。
- hits.hits[]._score ：该条目的匹配分数，越高越匹配。
- took ：索引耗时（单位：毫秒）。

1.2 具体搜索#

具体搜索支持搜索维基、题目、讨论、文章、页面等。

路径: /<type>?q=<text>&page=<page>&sort=<sort>
方法：POST / GET
字段：
- type ：搜索类型，有以下几种可选值：
  - search ：综合搜索，包含了下面所有的类型；
  - wiki ：维基；
  - problem ：题目；
  - bbs ：讨论；
  - article ：文章；
  - pages ：页面。
- text ：搜索的关键词。超过 100100100 字会被自动截取。
- page ：搜索的页码，默认一页 202020 条。默认为 111 。
- sort ：排序方式，默认为 matching_desc 。有以下几种取值：
  - matching_desc ：最匹配的；
  - time_desc ：更新时间最近的；
  - time_asc ：更新时间最远的。
响应格式：生文本
响应示例：

1
{
2
    "took":5,
3
    "hits":{
4
        "total":{
5
            "value":5,
6
            "relation":"eq"
7
        },
8
        "max_score":19.994299,
9
        "hits":[
10
            {
11
                "_index":"articles",
12
                "_id":"https://www.luogu.com.cn/blog/765440/oiso-api",
13
                "_score":19.994299,
14
                "_source":{
15
                    "platform":"luogu",
16
                    "title":"OIso API\u6574\u7406 - HJR - \u202e\uff1f - \u6d1b\u8c37\u535a\u5ba2",
17
                    "content":"... OIso API\u6574\u7406 - HJR - \u202e\uff1f - \u6d1b\u8c37\u535a\u5ba2 \u63d0\u524d\u58f0\u660e\uff1a\u6211\u53ea\u662f\u642c\u8fd0\u5de5\uff0c\u522b\u95ee\u6211\uff0c\u6211\u7b54\u4e0d\u4e0a\u6765\u3002 ... \u53c2\u8003\uff1ahttps://github.com/oiso-developer-team/OIso-frontend/issues/5 ... ",
18
                    "url":"https://www.luogu.com.cn/blog/765440/oiso-api",
19
                    "time":1690486384.6621897
20
                }
21
            },
22
            ...
23
        ]
24
    }
25
}

展开收起

响应说明：
- hits.total.value ：匹配的条目数，上限 100001000010000 。
- hits.hits ：包含 202020 条结果（如果有那么多的话）。
- hits.hits[]._source.content ：结果的文本。已赋予了一定的 HTML 格式。
- hits.hits[]._source.title ：结果的标题。
- hits.hits[]._source.url ：结果的链接地址。
- hits.hits[]._source.time ：结果的最后更新时间戳。
- hits.hits[]._score ：该条目的匹配分数，越高越匹配。
- took ：索引耗时（单位：毫秒）。

2. 功能相关#

2.1 手气不错#

手气不错能随机返回索引库里的一项条目。

路径： /random
方法：POST / GET
响应格式：JSON
响应示例：

1
{
2
  "hits": {
3
    "hits": [
4
      {
5
        "_id": "https://www.luogu.com.cn/discuss/390507",
6
        "_index": "lgbbs",
7
        "_score": null,
8
        "_source": {
9
          "content": "\n\n\n\n    P1059 \u6c42\u5e2e\u52a9\n\n\n\n    \n @\u6768\u5927\u4ed9\n2021-12-18 08:50\n\n\n\n\n\u6211\u592a\u96be\u4e86\n\n\n\n\n @LYqwq\n2021-12-18 08:57\n\n\n\n\n\n?\n\n\n",
10
          "time": 1690388193.605151,
11
          "title": "P1059 \u6c42\u5e2e\u52a9",
12
          "url": "https://www.luogu.com.cn/discuss/390507"
13
        }
14
      }
15
    ]
16
  }
17
}

展开收起

响应说明：
- hits.hits ：包含 111 条随机条目。
- hits.hits[]._source.url ：该条目的链接。

3. 登录相关#

3.1 获取验证码#

能够获取一个验证码，用来复制到洛谷剪贴板里。

路径：/key_request
方法：POST / GET
响应格式：生文本
响应示例：

1
N0r5XpfMyR3bVxoQ5XiP

响应说明：一个字符串，就是验证码了。

截屏2023-08-19 11.33.43.png

3.2 验证登录#

用户创建完剪贴板后，将剪贴板网址提交给服务器进行验证。

路径：/key_check?url=<url>
参数说明：
- url ：完整的洛谷剪贴板路径。
方法：POST / GET

3.3 个人资料#

获取当前用户的详细信息。请求需携带 Cookies 。

路径： /profile
方法：POST / GET
响应格式：JSON
响应示例：

1
{
2
    "cookie": "H********Br**64***********C",
3
    "expires": 1693130810.3191907,
4
    "name": "diyanqi",
5
    "uid": 222419,
6
    "vip": {
7
        "expire": 1145144771010,
8
        "level": 3
9
    }
10
}

响应说明：
- cookie ：用户令牌。
- expires ：登录过期时间。
- name ：用户名称。
- uid ：用户在洛谷上的 uid 。
- vip.level ：会员等级。
- vip.expire ：会员到期时间。

OIso++ 新手指南

Fri, 18 Aug 2023 00:00:00 GMT

OIso++ 是一个 OIer 的好帮手，它可以在洛谷等网站上提供功能增强服务。

本插件兼容 exlg 等其他油猴插件。我们希望此插件能够提升您的做题体验。API 基于 OIso 。

下载地址：https://amzcd.top/files/ex-oiso.min.user.js

本插件永久不再更新。

速通《乡土中国》

Tue, 15 Aug 2023 00:00:00 GMT

《乡土本色》：《乡土中国》第一章节名为《乡土本色》，是全书的总论。费孝通认为从最基层的视角来看，中国社会展现出了浓厚的乡土性格。这种乡土性格体现在三个方面：
- 首先，乡下人离不开泥土。乡下人最常见的生活方式是种地，因此他们更加珍视土地的价值。土地不仅仅是谋生的来源，更是连接人们情感的纽带。
- 其次，中国农村社会的流动性很低。依靠农业为生的人们，与土地紧密相连，不轻易迁移。这并不是说乡村人口是固定的，而是强调人们与土地的紧密关系，他们根深蒂固，各自在自己的领地内生活，与外界有一定的孤立和隔膜。
- 第三，乡土社会是一个充满熟人关系的社会。由于人口流动缓慢，乡村生活呈现出强烈的地方性特征，人们聚集在一起，互相熟悉，一生都在同一个乡村度过。这种熟人关系的存在，赋予了人们从容自在的自由，也使得社会秩序更易维系。这一章的核心目标是描绘中国农村社会的本土特色。作者强调了乡村文化的独特性以及各地乡村在地域上的多样性。通过深入观察，作者试图捕捉乡村生活的独特魅力和内在价值。这种以乡土为基础的社会性格，贯穿了全书，不仅构成了后文关于社会结构和礼俗的讨论，还是中国社会根源的重要体现。
《文字下乡》：这一章探讨了在农村地区，文字教育的传播和影响。章节描述了乡村人逐渐了解和运用书写文字的过程，以及他们如何利用文字来记录和传承自己的经验和知识。这种文字的传播带来了文化和思想的改变，对乡村社会产生了深远影响。与此同时，章节还提到了一个重要观点，即乡土社会并不因不使用文字而被视为“愚昧”。在这样的社会环境中，人们通过直接的面对面交流传达情感，使用一些非语言的特殊符号来表达象征意义，比如表情、动作等。这些方式比语言更直接有效。因此，在乡土社会中，不仅文字显得多余，甚至连言语也不是传递情感的唯一方式。这一章指出了传情达意的空间隔阂，强调了在乡村社会中，人们更加注重直接的交流方式。此外，《文字下乡》还讨论了时间隔阂，包括个人之间的过去和现在，以及世代之间的隔阂。因为乡土社会相对稳定，个人的记忆范围有限，而生活方式的持续传承使得经验可以通过口口相传，无需借助文字的记录。总之，《文字下乡》通过描绘乡村社会中文字传播的影响，强调了其特有的沟通方式和信息传递方式，以及乡土社会稳定性对于文字传承的影响。这一章节展现了文字在不同社会背景下的重要性和角色。
《再论文字下乡》：是对文字教育发展的深入探讨，着重分析了文字如何影响农村社会的交流、社会结构和价值观。在这一进程中，文字逐渐改变了乡村社会的面貌，尽管变化不断，但文字依然是连接城乡、推动社会变革的重要媒介。本章深入挖掘了文字在农村社会中的作用。文字的引入改变了原有的交流方式，使得信息不再仅限于口头传递，而可以通过书写长期保留下来，跨越时间和空间的限制。这种改变不仅扩大了农村居民的知识范围，也促进了社会内部知识和经验的交流，有助于提升整个社会的文化水平。与此同时，文字也在悄然改变着农村社会的结构。原本基于面对面的交往模式逐渐演变成更加多元化的联系方式。这样的变化，打破了原有的地域限制，使城乡之间的联系更加紧密。文字不仅成为信息的传递工具，更成为城乡社会联系的桥梁，促进了社会结构的逐步演变。除此之外，文字的传播也在潜移默化地影响着乡村社会的价值观。通过文字，人们可以接触到更广泛的观念和思想，进而重新审视和调整原有的价值体系。这种价值观的变迁，可能在某种程度上推动社会的变革和进步，使得乡村社会能够更好地适应现代化的挑战和机遇。尽管文字教育带来的改变在不断演变，但文字作为城乡联系的桥梁，仍然是连接城乡社会、推动社会变革的关键因素。《再论文字下乡》深刻阐述了文字在乡村社会中的重要性，以及其如何引发社会结构、价值观和交流方式的变化。这一章节揭示了文字教育对于整个社会进步的影响和价值。
《差序格局》：这一章深入研究了中国乡村社会中的等级制度和社会格局。章节讨论了农村社会的层次结构，强调了地位和权力的不均衡分配对社会运作、决策和协调的影响。作者从社会学和人类学的角度出发，提出了“差序格局”这一观点，即亲属和地缘关系所造成的不同等级次序。中国社会中的“差序格局”与西方不同，每个人都是自身社会影响的中心，就像投掷石头在水面上形成的波纹一样，每个波纹代表一个人的影响圈，与其他人的圈相互交织，构成了一个错综复杂的社会网络。与西方的群体格局不同，中国的格局是以个人为中心，每个人所影响的社会圈子不同，形成了多中心的“差序格局”。这种格局体现了中国社会的独特之处，每个人在社会中的地位和影响力是根据个人的关系和地域而形成的，而非普遍的群体认同。总之，《差序格局》一章深刻探讨了中国乡村社会中的社会结构和等级制度，通过“差序格局”这一观点，揭示了中国社会的个人中心性以及社会网络的错综复杂性，为理解中国乡村社会的运作提供了重要的视角。
《维系着私人的道德》：这一章深入研究了乡村社会中的道德观念。它强调了个人道德与社会互动之间的紧密联系，认为这种建立在私人道德观基础上的互动方式是维持乡村社会稳定和秩序的关键因素。在乡村社会中，人们的行为往往受到个人道德观念的指导。这些道德观念在家庭、邻里、村庄之间传承，形成了一种共识，促使个人在社会互动中遵循道德准则。这种基于私人道德观的互动方式不仅建立了信任和尊重，还确保了社会关系的稳定性。乡村社会依赖于人们相互间的合作与支持，而这种合作很大程度上依赖于个人的道德行为。当个人秉持良好的道德观念，他们更愿意为集体利益贡献力量，从而维护社会秩序。这种道德观念在乡村社会中是一种无形的纽带，连接着不同个体，维持着社会的和谐与平衡。综上所述，《维系着私人的道德》强调了乡村社会中基于个人道德观的互动方式的重要性。这种道德观念的传承和实践，构建了一个稳定、融洽的社会环境，为乡村社会的持续发展奠定了坚实基础。
《家族》：《家族》详细研究了中国乡村社会中家族制度的重要性。章节探讨了家族在社会结构和文化传承中的角色，强调家族关系如何在经济、社会和情感层面上对个人和社会产生影响。在中国乡村社会中，家族制度扮演着重要角色。它不仅限于亲属关系，更涉及政治、经济、宗教等多个领域。家族作为连绵不断的事业社群，在父子、婆媳等纵向关系中形成，强调了家族的重要性。
《男女有别》：此章节分析了性别在中国乡村社会中的角色分工。章节讨论了性别在经济、家庭和社会角色中的差异，强调这些性别差异如何塑造了乡村社会的动态和稳定。在中国传统乡土社会中，性别分工在不同领域中显著。家庭、社会和经济中，男女角色的分配有着独特的职责和地位，这不仅是社会文化传统的反映，也是社会秩序维持的重要因素。这一章节与前文的《家族》一起阐述了中国社会传统的家庭和社会结构，强调了乡土社会的男女角色分隔。乡土社会强调男女关系的安排，避免激发情感。在这种文化观下，浮士德式的恋爱精神被排除。乡土社会注重维护既有社会关系，因此男女关系被安排在不发生激动情感的框架内，以维持社会的稳定和秩序。这体现了中国乡村社会男女有别的文化观念，认为男女无需追求相似，生活上应有所隔离，以维护社会和谐。
《礼治秩序》：探讨了乡村社会中基于宗法制家庭感情的道德判断和约束。文章强调在乡土社会，秩序的维持是通过“人治”而非“法治”实现的。社会规范中的“礼”扮演关键角色，它适应了乡村社会的“差序格局”，通过错综复杂的社会关系网影响他人，创造了一种适宜的秩序。在这种环境下，社会秩序的理想手段是教化，而非严格的法律制裁。文章指出，传统的差序格局不认同普适的统一规则，而现行法律则采取个体平等主义。然而，现行司法制度破坏了原有的礼治秩序，未能有效建立法治秩序。总之，文章强调在乡村社会中，社会规范和“礼”在维护秩序中的作用，揭示了“人治”与“法治”的区别。
《无讼》：讨论了在乡村社会中人们如何基于宗法制家庭的感情进行道德判断和约束，强调乡土社会的治理方式是“人治”而不是“法治”。文章提到，乡村社会不依赖法律来调节人际关系，而是依靠社会规范中的“礼”。这种社会规范不仅适应了乡村社会的“差序格局”，也与乡土社会的社会关系网络相互融合，维护着社会秩序。在这样的社会环境下，社会秩序维持的理想方式是通过教化，而非法律诉讼。文章指出，现行司法制度虽然追求个体平等主义，却破坏了传统的礼治秩序，难以有效建立法治秩序。综上所述，文章深刻探讨了乡村社会中的社会秩序维护方式，强调了“人治”和“礼”在乡土社会中的重要性。
《无为政治》：在《无为政治》一章中，费孝通探讨了乡村中国权力结构的一种形式，即“无为政治”。他认为社会中存在四种权力形式，其中“无为政治”是一种相对不显著的权力。这种权力体现在社会冲突中，通过不干预、不干扰来维护秩序。这种权力源于人们的普遍共识，通过自发的行为，而非强制手段。费孝通强调，“无为政治”在乡土社会中具有重要作用，促进了社会的和谐与稳定。
《长老统治》：在《长老统治》篇章中，费孝通探讨了另一种乡村中国权力结构，即“长老统治”。他认为社会中的权力可分为四种，其中“长老统治”是基于社会继承和长者智慧的权力形式。长老们在社会中具有崇高的地位，凭借其丰富的经验和智慧来引导社会决策和调解争端。这种权力来源于长者的影响力和认可，以及他们对社会传统的理解。费孝通强调，“长老统治”在乡村社会中扮演着重要的角色，促进了社会秩序和稳定。
《血缘和地缘》：在这一章中，费孝通探讨了中国乡村社会中的两种主要社会联系方式：血缘关系和地缘关系。他强调，中国社会的基本特征之一就是它的“差序格局”，而这种格局在很大程度上是通过血缘和地缘关系来维系的。血缘关系指的是家族、亲属之间的血亲关系，这种关系在乡村社会中非常重要，影响着人们的社会地位、权力以及社会角色分工。地缘关系则指的是人们所处的地域关系，包括村庄、乡镇等。地缘关系在乡村社会中也起着重要作用，决定了人们的社会互动、社会组织以及资源的分配。费孝通指出，血缘关系和地缘关系在中国乡村社会中相互交织，形成了复杂的社会网络。这种社会网络通过各种方式影响着人们的行为和决策，塑造了乡村社会的秩序和稳定。
《名实的分离》：在《名实的分离》一章中，费孝通讨论了另一种权力形式，即“名实的分离”。他认为社会权力可分为四种类型，其中“名实的分离”是一种在社会变迁中产生的权力。这种权力源于人们对现实的认知和虚构的名声之间的差距。社会中存在着表面上的权威，但实际上缺乏实质的支配力量。费孝通强调，这种权力形式在乡村社会中存在，反映了社会变革时的权力真空和不稳定性。
《从欲望到需要》：在这一章中，费孝通提出了一个重要观点：在中国乡村社会中，人们通常更倾向于追求基本的生活需求，而不是过多地追求欲望。他将这种追求从欲望到需要的转变称为“欲望的抑制”。费孝通认为，乡村社会中存在着一种“节制性的文化”，人们更注重满足生存所需，而不是过度追求个人欲望。这种文化观念在很大程度上影响了乡村社会的价值观、人际关系和社会结构。在这种社会中，人们更强调社会的平衡与和谐，强调个人需求与集体利益之间的平衡。这种价值观塑造了乡村社会中的共同生活方式，使社会秩序更为稳定。费孝通还强调，随着现代化和城市化的影响，乡村社会的这种“节制性的文化”正在受到冲击和改变。人们的欲望逐渐增加，社会价值观也在转变。这对乡村社会带来了一些挑战，可能影响到社会结构和人际关系。

Casio991 常数说明

Tue, 08 Aug 2023 00:00:00 GMT

1. 通用常数#

hhh 普朗克常数
ℏ\hbarℏ 约化普朗克常量
c0c_0c0 光速
ε0\varepsilon_0ε0 真空导电率
μ0\mu_0μ0 真空磁导率
Z0Z_0Z0 真空阻抗特性
GGG 万有引力常量
lPl_PlP 普朗克长度
tPt_PtP 普朗克时间

2. 电磁常数#

μN\mu_NμN 核磁矩
μB\mu_BμB 波尔磁子
eee 元电荷
ϕ0\phi_0ϕ0 磁通量量子
G0G_0G0 电导量子
KJK_JKJ 约瑟夫森常量
RKR_KRK 克里青常量

Apple Watch 连强制网络（认证网络）的方法

Tue, 01 Aug 2023 00:00:00 GMT

0. 前置#

众所周知，尽管 aw 内置了 Safari 浏览器，但还是无法连接强制网络（例如公共场所的共享网络）。在网上搜索，官方给出的答案也是不能连接。参考：https://support.apple.com/zh-cn/HT209071 。

然而，强制网络的原理是，当你登录网络后，路由器会记录该设备的 mac 地址，而且通常会在用户未登录并访问其他网站时跳转到登录界面。这就意味着，我们不需要等待系统为我们弹出登录界面，而是可以自己进入登录界面。

1. 具体方法#

如下图，在设置中直接点击你想连接的 Wi-Fi 。

incoming-23B25134-7BBF-4041-B45A-964C7DE0D1CF.PNG

接着就会开始连接网络，转圈圈。

incoming-475F514D-596E-4F83-AFD8-D77EB1B713AB.PNG

这时候如果不进行任何操作，妄想其连接成功，那么很遗憾，它会显示“无法加入此网络”。

所以在转圈圈的过程中，立即再次点击这个正在连接的网络，进入详细信息设置。

incoming-AB8E1640-FE3D-4DE7-B122-BBDAEF5987A7.PNG

找到“自动登录”选项，把它关掉。

这时候你就会发现已经连上了网络，但是是没有互联网连接的。下面进行认证操作。

打开 iMessage ，随便向谁（比如自己）发一条信息，内容为 https://www.baidu.com/ 或你所知道的内网网站。

incoming-83C1A5EC-F041-415F-A86B-E316E8316724.PNG

接着点进这个链接，你就能自动跳转到登录界面了。

incoming-692BE455-7B8B-41A5-9702-7AE7265E0366.PNG

登录过后，就能愉快地网上冲浪了。

南京之行

Sat, 22 Jul 2023 00:00:00 GMT

南京，那座历经沧桑的城市，承载着几千年的历史和文化，它的风景宛如一幅壮丽的山水画，美不胜收。

psc (2).jpeg

psc (1).jpeg

psc (4).jpeg

清晨的南京，被微风拂动的柳树和婆娑的枫叶所环绕，如梦似幻。湖畔的公园中，湖水静谧如镜，荷花盛开，各色花朵争奇斗艳，一片美丽的花海呈现眼前。湖畔的垂柳摇曳着如诗如画，犹如画家笔下的意境，使人陶醉其中。这样的宁静与和谐，仿佛将人们的心灵抚平，带来一份内心的宁静与平和。

psc (7).jpeg

psc (9).jpeg

psc (10).jpeg

勿忘国耻。

psc (8).jpeg

psc (11).jpeg

psc (3).jpeg

psc (5).jpeg

psc (13).jpeg

午后的南京，城市的繁华显现出来。高耸的现代建筑与古老的城墙相互交织，展现出一种独特的美感。熙熙攘攘的人群穿梭于街头巷尾，流光溢彩，繁忙而有序。街头小吃摊贩散发着诱人的香气，各种美食琳琅满目，让人垂涎欲滴。而在城市的角落，古老的庙宇和园林依然屹立，石阶古道蜿蜒曲折，让人仿佛穿越回过去，感受古老岁月的流转。

psc (16).jpeg

psc (18).jpeg

psc.webp

psc (14).jpeg

psc (6).jpeg

夜幕降临，南京的夜景更是别具一格。灯火辉煌的夫子庙街区成为了吸引人们的热点。灯笼高高挂起，细节繁复的古建筑被灯光点缀得如梦如幻，热闹的商铺和美食一条街吸引了无数游客和当地居民。而江边的灯光映照在宽阔的水面上，波光粼粼，恍若星河，让人不禁为之惊叹自然的神奇之美。

psc (15).jpeg

psc.jpeg

psc (17).jpeg

psc (12).jpeg

南京的风景，不仅有自然之美，更蕴含着深厚的历史文化底蕴。寺庙、古建筑、博物馆等历史遗迹处处可见，带着人们穿越时空的感觉。紫金山上的明孝陵、灵谷寺、鸡鸣寺等历史古迹让人流连忘返，对南京这座城市的深厚底蕴有了更深刻的认识。

psc (20).jpeg

psc (19).jpeg

南京的风景就像一首动人的诗篇，她的美丽让人流连忘返，她的历史文化让人沉醉其中。在这座城市的每一个角落，都可以感受到南京的独特魅力，她是一座值得细细品味的城市，而那些美好的记忆，也会在心间永不褪色。

结构化学基础叁

Sat, 15 Jul 2023 00:00:00 GMT

约定：本文用加粗标记定义或概念，实验名称由斜体标注。本文中部分图片为网图，侵删。

1. 共价键#

共价键的本质是由于原子相互接近时轨道重叠，而重叠的部分通过共享电子使能量降低，从而形成共价键，两个原子间也就有了相互作用力。

Cl2.png

共价键具有饱和性与方向性。

1.1 饱和性#

每个原子在形成共价键时，能够提供的未成对电子数和轨道数是一定的，所以每个原子成键的总数或以单键邻接的原子数目就一定。

按照价键理论，元素原子可能形成的共价键数是与原子的价轨道数和价电子数有关，并不受 LewisLewisLewis 八隅体的限制。

1.2 方向性#

共价键具有方向性。

成键时两个轨道“头碰头”地重叠，形成的是 σ\sigmaσ 键。如两个 sss 轨道，两个 pxp_xpx 轨道，sss 与 pxp_xpx 轨道，能够形成 σ\sigmaσ 键。
两个轨道“肩并肩”地重叠，形成的是 π\piπ 键。

unfinished

结构化学基础贰

Sat, 15 Jul 2023 00:00:00 GMT

约定：本文用加粗标记定义或概念，实验名称由斜体标注。本文中部分图片为网图，侵删。

1. 元素周期律#

在元素周期表中，原子电核电荷数、原子量、半径、电离能、电子亲和能、电负性等呈现周期变化，而这些原子的特征被称作原子参数。

1.1 原子轨道半径#

原子轨道半径指的是最外层轨道分布图主峰到中心的距离。差不多可以理解为，最外层轨道到原子核的距离。

同周期，核电荷数增加，引力增大，原子半径减小。（➡️小）
同一族，主量子数增加，电子层数变多，原子半径增大。（⬇️大）
电子层数的影响比核电荷数引力的影响大。
例外：IBIBIB 、IIBIIBIIB 与 000 族元素，半径会反而变大（因为出现了电子的全充满）。

微粒半径大小取决于：

电子层数（优先级最高）；
核电荷数（优先）；
电子斥力/电子数。

镧系中原子半径缓慢减小，称作镧系收缩。

镧系收缩造成的影响：第二、第三过渡系的元素性质相近、分离困难。

第二过渡系和第三过渡系是指元素周期表中的两个副族。第二过渡系是第5周期的副族，包括镧系元素和锕系元素。第三过渡系是第6周期的副族，包括镧系元素和锕系元素。

原子半径

1.1.1 共价半径#

当两个原子间产生共价键时，就会有共价半径。

Cl2.png

1.1.2 金属半径#

对于金属原子，相互之间也会产生一个作用力，称作金属半径。

Cu2_.png

1.1.3 范德华半径#

范德华力是另一种分子间的作用力，具体地，有三个细分的力，后面会细讲。

对角线规则：一个元素，右边一格再下面一格的元素，这两个元素的原子半径相似、性质也相似。

1.2 电离能#

电离能的大小可以用来衡量原子失去电子的难易，也可以用来判断原子失去电子的数目和形成的阳离子所带的电荷

1.2.1 第一电离能#

第一电离能指的是基态的气态原子失去最外层的一个电子所需的能量。

A(g)→A+(g)+e− 需要I1的能量 A(g) \rightarrow A^+ (g) + e^- \ \ \ \ \ \ \ \ \ \ 需要I_1的能量A(g)→A+(g)+e− 需要I1的能量

1.2.2 第二电离能#

指已经失去了一个电子，再失去第二个电子时所需的能量。

影响电离能的因素：

距离原子中心的半径（主要因素），半径越大，电离能越小；
电子半满/全满的情况，会使电离能增加。

常见规律：

IIIB∼VIIBIIIB \sim VIIBIIIB∼VIIB 的元素，其最高价态等于它的族数。
金属元素的电离能一般低于非金属元素。

反常现象：

ScScSc 系收缩，使 IGa>IAlI_{Ga} > I_{Al}IGa>IAl ；
LaLaLa 系收缩，使 ITl>IInI_{Tl} > I_{In}ITl>IIn ，IPb>ISnI_{Pb} > I_{Sn}IPb>ISn 。

1.3 电子亲和能#

原子的电子亲和能是指一个气态原子得到一个电子形成气态负离子所放出的能量，常以符号 EeaE_{ea}Eea 表示。

B(g)+e−→B−(g) 吸收/放出E1的能量B(g) + e^- \rightarrow B^-(g) \ \ \ \ \ \ \ \ \ \ 吸收/放出E_1的能量B(g)+e−→B−(g) 吸收/放出E1的能量

注意，电子亲和能有正有负。正值表示放出能量，负值表示吸收能量。

第一电子亲和能通常为正值，放热；而第二、第三电子亲和能通常为负值，吸热。

第一电子亲和能在元素周期表中的规律：

向➡️，第一亲和能增大；
向⬇️，第一亲和能变小。

电子亲和能反映了原子获取电子的能力。元素原子的第一电子亲和能的代数值愈大，该元素的一个基态的气态原子得到一个电子形成 −1-1−1 价气态阴离子时所放出的能量越多，元素原子得到电子的倾向愈大，元素的非金属性也愈强。

1.4 电负性#

之前的电离能、电子亲和能中都有离子的出现，都是原子变成了离子。而本节所说的电负性是用来衡量分子中的原子相互吸引成键的能力。

要点：

规定氟的电负性为 4.04.04.0 。
电负性可以用来衡量金属性和非金属性的强弱。
如果吸引电子的能力较强，则显示电负性；如果吸引电子的趋势较弱，则显示电正性。
电离能、亲和能，针对的是（气体）离子化合物；而电负性讨论的是共价化合物。

绝对电负性计算公式：

X=12(I+E)X= \frac{1}{2}(I+E)X=21(I+E)

其中， III 为电离能， EEE 为电子亲和能。我们可以将它们的平均值看作绝对电负性。上式中均以 eVeVeV 作为单位。

2. 核化学#

2.1 放射性衰变#

α\alphaα 衰变： 88226Ra→ 86222Rn+24α^{226}_{\ \ 88}Ra \to ^{222}_{\ \ 86}Rn + ^4_2\alpha 88226Ra→ 86222Rn+24α （左移两格）
β\betaβ 衰变： 83210Bi→ 84210Po+−10e^{210}_{\ \ 83}Bi \to ^{210}_{\ \ 84}Po + ^0_{-1}e 83210Bi→ 84210Po+−10e （左移y一格）
γ\gammaγ 衰变：2760Co∗→2760Rn+γ^{60}_{27}Co^* \to ^{60}_{27}Rn + \gamma2760Co∗→2760Rn+γ

2.2 放射系#

铀系
钍系
锕系

Pb−206Pb-206Pb−206 是放射衰变的终点，因为它最稳定。

2.3 核化学方程式#

原则：质量数（在左上角）和原子序数（在左下角），左右两边加和相等。

2.4 半衰期#

对特定元素来说是定值，符号为 t12t_{\frac{1}{2}}t21 。

半衰期的计算：假定初始浓度为 C0C_0C0 ，过了 ttt 时间后为 CCC 。则有：

C0⋅(12)tt12=CC_0 \cdot (\frac{1}{2})^{\frac{t}{t_{\frac{1}{2}}}} = CC0⋅(21)t21t=C

即：

tt12=ln⁡CC0ln⁡12\frac{t}{t_{\frac{1}{2}}} = \frac{\ln{\frac{C}{C_0}}}{\ln{\frac{1}{2}}}t21t=ln21lnC0C

C−14C-14C−14 的半衰期为 5730a5730a5730a（ 573057305730 年）。通过测定其含量可估算其出现年代。

2.5 结合能#

核素间的平均结合能：核素之间靠核力结合成原子核。结合时会损失的能量 Δm\Delta mΔm 称作结合能。

2.6 核裂变与核聚变#

有核裂变与核聚变两种形式。

补充，分区的概念：最后一个电子填在那个轨道就是什么区（ sss 区，ppp 区……）。

结构化学基础壹

Thu, 13 Jul 2023 00:00:00 GMT

约定：本文用加粗标记定义或概念，实验名称由斜体标注。本文中所有图片均为网图，侵删。

1. 经典核原子模型#

1.1 电子的发现#

如图，在一个两端各嵌有一个金属电极的玻璃管中施加几千伏特的高压，并将管中气体抽成真空。可以看到荧光屏上出现了一条笔直的荧光带。

放电管中的阴极射线

给管中是假一个磁场（用磁铁吸引），可以观察到阴极射线发生了弯曲。该电子流具有负电荷。

利用该装置还能测出电子的电荷 eee 与其质量 mmm 之比值，称作荷质比。

1.1.1 测定电子的速度#

若电子的电荷为 eee 、速度为 vvv ，电场强度为 EEE ，磁场强度为 HHH ，如果电子所受的磁力和电力相等，则有：

H⋅e⋅v=E⋅eH·e·v=E·eH⋅e⋅v=E⋅e

即：

H⋅v=E ⟺ v=EHH·v=E \iff v=\frac{E}{H}H⋅v=E⟺v=HE

这样就能算得电子的速度。

1.1.2 测定电子的电荷#

190919091909 年字母哥 MillikanMillikanMillikan 设计的油滴实验可以巧妙地测出电子的电荷。在电场中喷入微小的油滴，并同入 X 光使空气电离，这样小油滴就能在电场力和重力之间平衡。所受电场力和电荷 eee 有关，而重力有和 mmm 有关。 mmm 是已知的量，若每个油滴只带有一个电荷，那么最小的电荷量 eee 就能求出。最终实验得到 e=1.6×10−19Ce=1.6 \times 10^{-19} Ce=1.6×10−19C ，电子质量 me=9.11×10−31kgm_e = 9.11 \times 10^{-31} kgme=9.11×10−31kg 。

油滴实验

1.2 原子模型的发展史#

1.2.1 早期的模型#

189718971897 年前后， J.J.ThomsonJ.J. ThomsonJ.J.Thomson 通过实验提出了葡萄干布丁模型。

葡萄干布丁模型

191119111911 年，英国物理学家 RutherfordRutherfordRutherford 通过 α\alphaα 粒子散射实验，否定了汤姆森的模型，建立了核原子模型。

阿尔法粒子散射实验

在该实验中，大部分粒子通过了金箔，并没有改变运动方向，少部分粒子发生偏转，更少部分被反弹或原路返回。该实验能够得出以下结论：

原子核内部很空旷，中间的有一个原子核且带正电。
整个原子的全部质量几乎都集中在这个原子核上。
带负电的电子高速在核外绕核转动。

估算金箔原子核的大小：12mv2=KZ1eZ2er0\frac{1}{2}mv^2=K\frac{Z_1eZ_2e}{r_0}21mv2=Kr0Z1eZ2e ，其中左边为假定粒子的动能，右边为该粒子最靠近原子时转化成的库伦排斥势能。 ZZZ 分别表示两者的核电荷数（ 222 与 797979 ）， r0r_0r0 表示该最近的距离。

1.2.2 普朗克量子论#

1.2.2.1 黑体辐射实验#

绝对黑体是指能全部吸收辐射电磁波的物体（看上去就是完全黑色的，理想化模型），在受热时能发出连续波长的电磁辐射。下图为黑体在不同温度下，电磁辐射波长与强度的关系图像。

波长-强度图像

由图，虚线表示经典力学中，随着波长减小，辐射强度应该无限增大。然而在实验观测中，当波长进入了紫外区，出现了经典力学无法解释的现象。这就是紫外灾难。

190019001900 年，普朗克第一次提出量子的概念。他认为，能量是不连续的，最小的能量单位称作量子。具体来说，一个量子的能量与其电磁波的频率成正比：

E=hvE=hvE=hv

其中， h≈6.62607015×10−34J⋅sh \approx 6.62607015 \times 10^{-34} J·sh≈6.62607015×10−34J⋅s 称作普朗克常数，vvv 为电磁波的频率。

例题：电磁辐射波长为 122mm122mm122mm 的光子能量为多少？

1.2.2.2 光电效应#

爱因斯坦使用普朗克量子论解释了该实验，认为光由光子组成，它的能量也是不连续的。用公式来表示，就是：

hv=E=W+Ekhv=E=W+E_khv=E=W+Ek

其中，hv=Ehv=Ehv=E 即为光子碰撞到电子上，让电子吸收的能量。 WWW 为电子克服原子对它的束缚进而逃逸的最小能量， EkE_kEk 就是剩下的能量，全部转换为动能，用于电子获取速度。

由此可见，只有当 E>WE>WE>W 时，提供的能量大于所需的最小能量，才能触发光电效应。而 EEE 只和光子频率 vvv 有关。这就必须使用量子的角度解释。

波长、波速与频率之间的关系：λ=Vv\lambda = \frac{V}{v}λ=vV ，即波长=波速频率波长 = \frac{波速}{频率}波长=频率波速。当我们在研究标准的光的时候，可以将光速 ccc 带入波速 VVV 。

1.2.3 波尔 BohrBohrBohr 理论#

要点：电子在轨道上，而轨道具有一定的能量。

1.2.3.1 BalmerBalmerBalmer 经验公式#

氢原子光谱上各个光的波长可由以下经验公式得出。其中 nnn 为大于等于 333 的正整数，通过变换 nnn 的数值，可以得到多个 λ\lambdaλ ，这些波长都为氢原子所具有。

λ=3646.00×n2n2−4\lambda = \frac{3646.00 \times n^2}{n^2-4}λ=n2−43646.00×n2

进而可以计算波数：

v‾=1λ\overline{v} = \frac{1}{\lambda}v=λ1

1.2.3.2 原子的轨道能量#

E=−13.6Z2n2eVE=-\frac{13.6 Z^2}{n^2}eVE=−n213.6Z2eV

其中， ZZZ 为核电荷数， nnn 表示原子的第几层轨道。

当 Z=1,n=1Z=1, n=1Z=1,n=1 时，氢原子 KKK 层的半径为 53pm53pm53pm ，称作波尔半径。

离原子核越近，能量越低，越稳定。电子层（又称能层），从里到尾分别是 KKK，LLL，MMM，NNN 。

1.3 微观粒子的波粒二象性#

波粒二象性，指微粒既具有波动性又具有微粒性。并且这样的微观粒子不可能同时准确测定位置和动量，即测不准性或不确定性。

光的波性：干涉、衍射现象；
光的粒性：发射、吸收、光电效应。

1.3.1 爱因斯坦质能方程#

当我们认为光子是粒子时，就可以认为它具有的能量为 E=mc2E=mc^2E=mc2 。

然而，光又是波。故 E=hv=mc2E=hv=mc^2E=hv=mc2 。

求得动量： P=mc=hvc=hλP=mc=\frac{hv}{c}=\frac{h}{\lambda}P=mc=chv=λh 。

电子的波长也就可以求得： λ=hmV=hP\lambda=\frac{h}{mV}=\frac{h}{P}λ=mVh=Ph 。

在等式 hv=mc2hv=mc^2hv=mc2 中，我们可以看到，波动性和微粒性间搭建了一个桥梁。

1.3.2海森堡不确定原理#

ΔxΔP≥h4π ⟺ Δx≥h4πmΔv ⟺ ΔxΔv≥h4πm\Delta x \Delta P \geq \frac{h}{4\pi} \iff \Delta x \geq \frac{h}{4\pi m \Delta v} \iff \Delta x \Delta v \geq \frac{h}{4\pi m}ΔxΔP≥4πh⟺Δx≥4πmΔvh⟺ΔxΔv≥4πmh

在宏观世界中，mmm 很大，所以 ΔxΔv\Delta x \Delta vΔxΔv 的误差很小。但在微观世界中，mmm 很小，所以 ΔxΔv\Delta x \Delta vΔxΔv 的误差就难以预测了。

2. 薛定谔方程（简化版）#

笔者只也只会介绍薛定谔方程中的几个参数，用以解释现代原子轨道理论。

2.1 前置技能#

2.1.1 概率密度与电子云#

在上一节的“海森堡不确定原理”中，我们已经知道了在微观世界中，粒子是难以预测的，所以之前波尔所提出的电子在轨道上运动，就显得有些问题了。电子的运动是不确定的、无法预测的，它不一定就在某个轨道上乖乖运动。那么，科学家们又该如何进一步研究呢？

实际上，我们并非非得要算出电子的运动轨迹。我们只要统计电子在各个位置的分布，就能大概了解电子的运动情况。

在一个空间中，我们定义概率密度 ρ=P（概率）V（该处的体积）\rho=\frac{P（概率）}{V（该处的体积）}ρ=V（该处的体积）P（概率）。

随后，我们将这个概率密度形象地表示在一个三维空间中，便得到了电子云（概率密度分布图）。

电子云图

再将空间出现概率 P=90%P=90 \%P=90% 的空间圈出来，就得到了电子云轮廓图。一个轮廓图对应一个原子轨道，一个原子当然有多个轨道。

2.1.2 波函数#

ψ\psiψ 即为电子波函数，而 ψ2\psi^2ψ2 就可代表电子在空间某点出现的概率密度。

2.1.3 径向分布图像#

对于某个轨道，ψ2\psi^2ψ2（某点的概率密度，纵轴）和与原子核中心的距离的关系图像，可由下图表示：

径向分布图像

该图的物理意义是，单位厚度球壳内电子的分布概率。

2.2 方程的参数#

2.2.1 主量子数 nnn#

表示轨道离原子核的远近（决定了电子能级）。

可以取任意正整数，表示是第几层的轨道。

2.2.2 角量子数 lll#

决定了电子的轨道形状。

取值范围：0,1,2,3,4,...,(n−1)0, 1, 2, 3, 4, ..., (n-1)0,1,2,3,4,...,(n−1) 。

分别对应：s,p,d,f,g,...s, p, d, f, g, ...s,p,d,f,g,... （例如对于第 n=2n=2n=2 层，可能为 sss 或 ppp 轨道）。

不同的轨道有不同的形状。 sss 轨道为球形，ppp 轨道为哑铃形，ddd 轨道为花瓣形，等等。具体的形状图见下一小节。

2.2.3 磁量子数 mmm#

决定了轨道的方向。

取值范围：0,±1,±2,...,±m0, \pm 1, \pm 2, ..., \pm m0,±1,±2,...,±m 。

注意：同一个 nnn ，同时存在着不同的 lll 形轨道，而即便对于同一个 lll 形轨道，也同时存在着多个形状相同但方向不同的、也就是磁量子数 mmm 不同的轨道。具体见下图。

2.2.2.1 sss 轨道的形状（只有一个）#

s轨道

2.2.2.2 ppp 轨道的形状（共三个）#

p轨道们

2.2.2.3 ddd 轨道的形状（共五个）#

d轨道们

例题：n=4,l=2,m=0n=4, l=2, m=0n=4,l=2,m=0 的轨道名称是什么？

2.2.4 自旋量子数 msm_sms#

决定了这个电子在某个轨道上的“自转”方向。

取值只有两个：+12, −12+\frac{1}{2}, \ -\frac{1}{2}+21, −21 。分别表示正着转和反着转。

2.3 泡利不相容原理#

不存在 444 个量子数完全相同的电子。我们可以认为， ψ\psiψ 函数就是用来针对各个电子的。

2.4 小补充#

2.4.1 能级的排布#

每个轨道的能量由 nnn 和 lll 确定。一般地， nnn 越小， lll 越小，能量 EEE 越小。

有时候，两个轨道的远近一样（ nnn 一样），但能量不同（由 lll 不同引起），这就叫做能级分裂。

有时候，离核近的轨道反而能量更高，这就叫做能级交错，主要是因为受到了其他电子的排斥而能量增大。

如何准确地对各个能级进行排序呢？请见下节。

2.4.2 徐光宪近似规律#

可以用来比较各个轨道能量的大小。

对于原子而言：(n+0.7l)(n+0.7l)(n+0.7l) 越大，能级越大。
对于粒子而言：(n+0.4l)(n+0.4l)(n+0.4l) 越大，能级越大。

2.4.3 能级的计算&屏蔽效应#

对于单电子原子能级，有 E=−13.6n2eVE=-\frac{13.6}{n^2}eVE=−n213.6eV 。
对于多电子原子能级，有 E=−Z∗2n2eV=−(Z−σ)2n2eVE=-\frac{Z^{*2}}{n^2}eV=-\frac{(Z-\sigma)^2}{n^2}eVE=−n2Z∗2eV=−n2(Z−σ)2eV 。

其中， ZZZ 为核电荷数， σ\sigmaσ 为屏蔽常数。

为什么多电子原子能级要有减去 σ\sigmaσ 这样的操作呢？这就是由于屏蔽效应，内层电子会对外层电子产生排斥，相当于将原子核的引力削弱了一部分。

我们可以使用斯雷特规则来计算屏蔽常数 σ\sigmaσ 。

2.4.4 能级分裂的原因——钻穿效应#

钻穿效应原理图

3 能级排布#

3.1 能级排布规律图#

由种种实验事实，人们总结出了一张图表，能帮助我们快速对能级进行排序。

能级排布规律图

由上图，我们可以看到，各个轨道的能量：1s<2s<2p<3s<3p<4s<3d<4p<5s1s<2s<2p<3s<3p<4s<3d<4p<5s1s<2s<2p<3s<3p<4s<3d<4p<5s ，等等。

3.2 电子排布式#

我们将电子依次填入能量低到能量高的轨道。其中，每个 sss 轨道最多放 222 个，每个 ppp 轨道最多放 666 个，每个 ddd 轨道最多放 101010 个，每个 fff 轨道最多放 141414 个，等等。

接着，我们把放了多少个电子写到轨道的右上角。最后，我们还要将所有轨道按顺序排列。

以 NaNaNa 为例： 1s22s22p63s11s^2 2s^2 2p^6 3s^11s22s22p63s1 。

而 KKK 可以简写：[Ar]4s1[Ar]4s^1[Ar]4s1 。

但 191919 种元素原子的外层电子分布有例外。其中主要为 29Cu: [Ar]3d104s1_{29}Cu:\ [Ar]3d^{10}4s^129Cu: [Ar]3d104s1 。

3.3 洪特规则#

尽可能成单电子排列且自旋方向相同。
简并轨道、全空、半满或全满比较稳定。

【仅学习交流用】破解某网课录屏限制

Thu, 22 Jun 2023 00:00:00 GMT

网课回放需要录屏，然而黑心的资本家做出了种种措施防止你录屏。或是弹出这样的提示：

截屏2023-06-22 22.08.13.png

或是在页面上留下水印：

（你的名字）

这样一来，我们就无法正常进行录屏了。下面给出的解决方法，仅供技术学习交流。

1. 初探抓包#

没有任何思路，先抓包试试。发现在登录成功后，服务端会再次返回学员姓名和用户名。这很可能是水印的来源。

image.png

继续，进入课堂，打开视频。这一过程中收集到了很多请求。

首先是这个请求：

截屏2023-06-23 07.44.28.png

显而易见，这是服务端返回录屏软件列表，客户端根据该列表来判断录屏软件是否在运行。

剩下的还如这个：

截屏2023-06-23 07.49.23.png

这大概是网课视频文件的一种格式，原理与矢量图差不多，能记录老师笔迹的位置。

2. 修改数据包#

首先我们先来解决水印问题。在 doLogin 的请求上右键，找到本地映射。

截屏2023-06-23 07.51.56.png

然后直接把含有你姓名、用户名的部分全部删掉，留下一个空字符串。

截屏2023-06-23 08.13.09.png

这里的登陆由于具有时效性，建议修改前先正常登录一遍，获取最新的数据包再修改；否则会登陆无效。

接着是录屏工具问题。直接找到 antiScreenRecord 的请求，右键、工具、黑名单，将其加入黑名单即可。

截屏2023-06-23 08.15.56.png

3. 验证#

进入程序，登陆成功后可以看到，名字已经为空了（见左下角）：

截屏2023-06-23 08.34.08.png

进入课堂回放，会弹出“网络连接失败”：

截屏2023-06-23 08.35.26.png

不要担心，这是因为我们拦截了获取录屏列表的请求，所以提示网络连接失败。点击“确定”即可，不影响其他播放。

同时也能看到，水印已经没有了。打开 OBS 等录屏软件，也是安然无恙。

截屏2023-06-23 08.36.58.png

4. 补充#

偶然发现一个上传日志的请求，建议屏蔽掉，否则容易使你的账号被封。

截屏2023-06-23 08.38.21.png

随手捕获春光

Sun, 30 Apr 2023 00:00:00 GMT

IMG_4004.png

IMG_4005.png

IMG_4009.png

IMG_4012.png

IMG_4015.png

tamperOIso 新手指南

Sun, 26 Feb 2023 00:00:00 GMT

请期待我们即将发布的全新一代插件—— OIso++ ！颠覆你的想象！

1. 新手指南#

tamperOIso 是一个 OIer 的好帮手，它可以在洛谷等网站上提供功能增强服务。它可以让您查看并参与帖子投票、使用最新可用的帖子保存站 lgbbs.oiso.cf 来保存和查看帖子，在任何地方按下 Shift+Space 来搜索，还能支持显示头像挂件。

本插件兼容 exlg 等其他油猴插件。我们希望此插件能够提升您的做题体验。API 基于 OIso 。

2. 功能之讨论增强#

在任何的讨论列表处，您都能看到在链接右侧出现了投票信息：

截屏2023-03-04 12.21.47.png

进入某个具体的帖子后，在右侧的功能栏上会出现点赞和踩的按钮。

截屏2023-03-04 12.23.16.png

每人每天有15次踩和赞的机会。一旦做出决策后，无法撤销。

同时您还能看到，最下方一排按钮是 保存帖子 和 查看备份 。这里使用的帖子保存站都是长期有效的。

3. 快速搜索#

在任何页面按下快捷键 Shift+Space ，就会弹出搜索界面。

截屏2023-03-04 12.26.54.png

在其中输入您想搜索的任何内容。

截屏2023-03-04 12.28.02.png

就像一个正常的搜索引擎一样，还支持智能联想。按下回车键或点击搜索按钮就能跳转到 OIso 的搜索页面。

4. 头像挂件#

就像 exlg 推出的 badge 一样，我们也推出了头像挂件。您需要在 OIso Premium 计划期间方可注册或修改头像挂件。只需前往 OIso 官网，就能找到头像挂件修改入口。

截屏2023-03-04 12.32.05.png

此头像挂件在任何地方都会显示。全站用户的头像挂件数据一天更新一次。如果您需要立即刷新缓存，请点击页面底部的 刷新 tamperOIso 缓存 按钮。

5. 头像挂件 DIY 说明#

头像挂件的实现逻辑是：在圆形头像上覆盖一张长、宽为头像直径 1.351.351.35 倍的正方形图片，透明度为 0.750.750.75 。

截屏2023-02-26 20.57.52.png

如上图，圆形是头像部分，而上面覆盖着的一个圆角正方形就是您绘制头像挂件的尺寸。在绘制挂件时，您可以将此图作为底稿，然后再在上面圆角正方形的区域内进行作画。注意：请使用 pngpngpng 格式来做到某些地方的背景透明。

-1. Todo#

[ ] 接入免费的 AI 题目翻译服务。

自建 Hypixel 加速服务

Sat, 11 Feb 2023 00:00:00 GMT

1 推荐服务器#

建议要有 CN2 线路的服务器，否则效果会很拉胯。这里不过多赘述。

2 获取 Hypixel 的 ip 地址#

首先获取 Hypixel 的 ip 地址。

Terminal window

1
nslookup hypixel.net

例如此时笔者返回了以下结果：

Terminal window

1
Non-authoritative answer:
2
Name:  hypixel.net
3
Address: 104.16.78.21
4
Name:  hypixel.net
5
Address: 104.17.71.15

那么记下其中随便一个即可，都可以使用。

3 安装守护进程服务#

如果您有自己的守护进程服务，也可以用自己的，跳过此节。

先获取 nami 包管理器。

Terminal window

1
bash <(curl https://bash.ooo/nami.sh)

然后安装 joker 进程管理。

Terminal window

1
nami install joker brook

4 下载并配置服务#

这里使用一键脚本，安心省事。不过请确保您安装了 nami 包管理器。

Terminal window

1
bash <(curl https://bash.ooo/brook.sh)

当出现下面的页面时：

截屏2023-02-11 18.08.20.png

选择您使用的语言即可，例如笔者选择中文，输入 2 ，回车。

截屏2023-02-11 18.10.13.png

接着在这里选择 1 。

截屏2023-02-11 18.13.18.png

这里选择 1 我想运行 brook server 。输入 1 ，回车。

截屏2023-02-11 18.25.17.png

可以就输入默认的端口 9999 。要记住这个端口。

截屏2023-02-11 18.25.59.png

密码自行设置，也许要记住。

5 安装客户端#

前往 https://txthinking.github.io/brook/ 并安装相应版本的客户端。然后输入上面服务器的信息，就能享受加速服务了！

再见，2022 - 2022 年度总结

Thu, 29 Dec 2022 00:00:00 GMT

不知不觉中，2022已经接近了尾声。我仿佛还在2019年的那个暑假，那里是一切的开始。

三年春秋，转瞬即逝。于一个迷雾朦胧的清晨，写下这一篇随笔，回顾这不平凡的 2022 。

年初的时候正是初二的寒假。又是一年的开始，每一年都有每一年的惊喜。

约三月份的时候，我达成了人生中的一个小目标。惊喜之余，或许是运气，或许是实力，但这更多的是对自我的一种认可。继续努力，向远方眺望，明日尽在眼前。

然后，文化课，搞 OI 。身上又多了学习先进知识的负担，平衡时间是非常重要的。

今年还浅浅地了解了一下各种语言，同是三月份的时候接触了 C# 并浅浅地写了个应用；十一月份时学习了 Swift ，也开发了一些小应用。

信息技术方面，今年或许是我初高中生涯中最后一年正经学习 OI 了。继续学习了一些数据结构和算法。暑假结束，告别了相处一年的大神教练鸡尾酒。新来的教练也不错，等到开学就开始准备初赛了。

初赛很可惜，普及组压线过，提高组未过。 3 年OI，过了一个普及组也好。索性浙江组委会没有因为疫情缩减名额，我有惊无险地进入了普及组复赛的赛场。

这次普及组发挥得还是不错的， CCF 评级也达到了 5 级。还是比较高兴的，毕竟 3 年的努力也有了一个结果，尽管并非太完美，但至少画上了大半个句号。

暑假的时候参加了一次所谓 “全国” APO 的比赛，实际上是徒有虚名（个人观点）。在复赛的时候意外拿了 400 分，然后就被某些人吹爆了，说是 “全国唯一满分”。其实我不愿意接受这个称号，所谓“全国”比赛仅有 1 人满分？话说 NOIP 都不止一人满分，您这比赛比 NOIP 还难啊，我代表地表最强了吗……

话说回来，好像还有全国总决赛，不知道还会不会举行（感觉是不会了），还是很希望借机去北京玩一趟的（

毕竟 OI 只是一个分支，凭借着浓厚的兴趣，我尝试着建立一个搜索引擎。从数据库和爬虫开始，一步一脚印，不断地查文献、写代码，终于在某一天用通了 ElasticSearch 。随后用之前写过服务器的经验，搭了一个完整的网站 OIso ，前端也是东拼西凑复制来的 :) 。

另一个支线任务是升级了一下服务器。之前的博客都是放在 Wordpress 上，由于没有公网一直要内网穿透，很麻烦，于是今年索性把博客搬到了 GitHub Pages 上托管，还给家里申请了公网 IP 。

关于申请公网 IP ，以前一直看网上说要和客服打电话，还要请师傅上门。作为社恐这种事情怎么能做呢，于是一直苟且偷生地用着内网穿透。后来抱着侥幸心理去微信上公众号里的客服聊天，发现敲几个字就能解决了，电信客服的效率还是不错的！

OIso 上线以后，也是未大张旗鼓地宣传过，只是偶尔在某些求助找文章、找帖子的帖子下回复了相关内容。没想到还是引起了广泛的关注，得到了大家的认可。正式版预计在元旦发布，代码也一定会开源的！

文化课方面，语文和英语确实有很大的提升。这里我觉得英语的提升很大程度上有劳于平时强迫自己看英语文献。信息技术方面很多中文文献都是过时的，而最新版的英文文献又还没来得及翻译。在看很多文档，比如 Swift 开发文档，全部是英文的；ElasticSearch 的中文文档也是只更新到上古时期的版本，现在根本就不能用。

在看英语文献的过程中，不免有许多生词，这时候就可以顺道查一下词典。可能看一遍记不住，但是看到同一个词两遍三遍、查了两遍三遍就一定能记住了。这不像背单词表，放在某一句话的情境中更有助于记忆。

看文献是一方面，这是提高阅读能力的必要途径。况且看到的词汇都是有关信息技术的，而当今英语试题的潮流也是顺应时代潮流，文章内容大多是朝着信息技术方面靠的，因此考试时看到有关方面的文章时，阅读起来就特别顺畅。优势在我

另一方面则是听说方面。这一点我特别赞同某位博主的观点，传统的英语硬式教育只能应付考试，当你真正要在生活中运用英语的时候就会发现自己手短了。事实就是如此。尽管你背诵了高级的单词，尽管你背诵了优美的词句，尽管你掌握了生僻的语法，但是一旦你看到一篇本地人写的文章，听到本地人在正常交流，你能看/听懂吗？即使懂，你怎么回应呢？我认为这是课本里所欠缺的。

相反，如果你真的能把听英文歌当乐趣，把训练纯正的英式/美式口语当目标，把阅读英文信息/新闻当作发展的契机，就能提升英语素养。什么是英语素养？和语文素养类似，考试考察的是素养，生活中用的也是素养。硬式教育能应付考试，而英语素养也能通过考试；英语素养还能用于生活，而硬式教育却让你学会“哑巴英语”。

我没有认为自己的英语有多好，但是在这种学习模式下，我可以做到颇有乐趣地学习英语，考试成绩也是颇有乐趣。

不管怎样，这个2022还是比较充实的。希望明年能完成更多自己想做的事。

[译] 在 iOS15.0-16.0 的 A9-A11 的iPhone上进行越狱

Sat, 17 Dec 2022 00:00:00 GMT

原文： How to jailbreak A9-A11 devices on iOS 15.0-16.x with palera1n #

如果您一直是老 iPhone 的钉子户，那么对于您运行 iOS 以及 iPadOS 15.0-16.x 的 A9-A11 的设备，就有一个基于 checkm8 bootrom 漏洞的越狱，叫做 palera1n 。虽然 palera1n 主要是给开发者使用的，但它的功能也是在众多 iOS15 的越狱插件中最强大的。

palera1n

如果您想尝试使用 palera1n 来越狱，我们建议您在开始动手前，阅读以下步骤。如果您最终还是决定要在您的设备上进行这样的越狱，我们也会向您展示如何操作。

须知#

再次强调： palera1n 越狱目前只是为开发者提供的。如果您不是开发者，并且执意进行越狱，那么您就必须自己承担设备损坏或数据丢失等等的风险。我们已经警告过您了！

值得一提的是， palera1n 不是无根越狱（前路并未完全光明）。它只支持部分注入，也就是说，您只能运行部分兼容的插件。

您可以选择两种越狱方式：tethered 或者 semi-tethered 。这取决于您的喜好。简单来说，tethered 模式要求每次您的设备的开机都必须要一台电脑进行引导，而 semi-tethered 至少不依靠电脑还能进入未越狱的普通系统，直到连上电脑了，方能进入越狱系统。在本教程中，我们会安装 tethered 模式，因为它拥有最高的兼容性，越狱后功能也最多。您当然也可以使用 semi-tethered 模式，不过在笔者写这篇文章的时候，还未能修复 Home 键失灵的 BUG 。

请注意，由于 palera1n 使用 checkm8 漏洞，只有下列表中的设备（都是 A9-A11 芯片的），且运行 iOS 或 iPadOS 15.0-16.x 的，才能进行越狱：

iPhone X
iPhone 8 Plus
iPhone 8
iPhone 7
iPhone 7 Plus
iPhone 6s
iPhone 6s Plus
iPhone SE
iPad (7th generation)
iPad (6th generation)
iPad (5th generation)
iPad Pro 12.9-inch (2nd generation, 2019)
iPad Pro 10.5-inch (2017)
iPad Pro 9.7-inch (2016)
iPad Pro 12.9-inch (2015)
iPod touch (7th generation)

另外，由于 palera1n 使用的是双系统越狱，您的设备必须具有超过 16GB 的储存空间。当您的设备是 A10- A11 时，不能设置解锁密码。

安装 palera1n 不像其他越狱一样拥有图形界面，因为这个越狱只是给开发者使用的。这意味着您将几乎一直使用终端进行操作。而这些操作仅支持 Mac 或 Linux 系统的电脑（ Windows 不可以）！

下文由 macOS 演示。

开始安装#

首先，安装 Homebrew 。安装过的请跳过。

在终端中输入：
Terminal window
```
1
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```
译者注：国内网络环境不是很好，可以自己网上搜教程安装。安装过程就不翻译了，能安装上就行了（逃 HomeBrew 安装好后，请安装 git 。
安装 Python 。到官网下载最新版本。
克隆 GitHub 仓库。网络环境不好的自己找解决办法，或者看运气吧。

先进入下载目录，然后克隆。
Terminal window
```
1
cd downloads
2
git clone --recursive https://github.com/palera1n/palera1n
3
cd palera1n
```
克隆完成后，将您的手机通过数据线连接电脑。然后进入 DFU 模式。如何进入 DFU 模式？这里以 iPhone6（有 Home 键有关机键）为例。其他机型网上教程到处都是。

先把手机调到正常开机状态，这样成功率最高。然后同时按住关机键和 Home 键。大约两秒，等待手机屏幕突然黑屏，此时再等待一秒（成功率高），然后松开关机键，继续按住 Home 键，再倒数大约 10 秒左右。然后松开。这一过程中，屏幕一直是黑的，但是不要担心，已经打开 DFU 模式了。
进入 DFU 模式后，在刚才克隆窗口的终端中（为的同一目录下）输入一下命令：
Terminal window
```
1
sudo bash ./palera1n.sh --tweaks [your current iOS version] --semi-tethered
```
在按下回车键后，您可能会被要求输入管理员密码（也就是您电脑的开机密码）。请您输入。
然后终端就开始安装程序了。你可能看见您的手机上出现了一个苹果标志。
您的手机/平板将会重启，然后进入恢复模式（就是屏幕上出现一根数据线指着一台电脑的那个）。终端中出现提示要求您进入 DFU 模式。按任意键继续，然后按照终端里的提示进行操作（也就是上面刚刚说过的一样的操作），再次进入 DFU 模式。
再次进入 DFU 模式后，越狱程序将会创建一个假文件系统，并将其注入到您的系统中。这一步操作可能会需要至多 10 分钟。 在这些步骤结束前，请不要断开您的设备与电脑的连接。
当您的设备完成了上述步骤，就会重启。此时您需要再次重新手动进入 DFU 模式。在终端中按任意键继续，然后按照终端里的提示进行操作（也就是上面刚刚说过的一样的操作），再次进入 DFU 模式。
终端会进行最后的检查工作。最终结束后，您的设备会再次重启。

terminal
设备启动后，打开 Tips （提示）这个软件。

succeed
点击 Install （安装）按钮。

install

带有 Sileo 包管理器的 Procursus 引导程序将被安装。安装结束后， Sileo 和 Substitute 应该出现在您的主屏幕上：

end
恭喜您，越狱成功！ palera1n 的开发者们事实上提供了一个有关可以在越狱后使用的插件的清单。您可以去看看。

总结#

由于 palera1n 只是为开发者提供的，所以如果您只是一个普通用户，越狱或许对您来说没什么用处，除非您是一个硬核用户。

在安装过程中，由于使用了大量的终端操作，很容易进行误操作。然而，在图形界面中，只需点点按钮就行，既高效又能避免错误。

请注意， palera1n 是一个正在开发的项目，仍然有一些 BUG 。有许多用户报告了 AMFI patching 问题（译者也不知道是什么），您也很可能会遇到同样的问题。

越狱成功了吗？在下方评论区留言，让大家看看您是怎么成功的吧！

这是苣蒻第一次尝试翻译，不足之处欢迎指出～

SwiftUI 学习笔记（一）基础语法

Sat, 05 Nov 2022 00:00:00 GMT

1 视图#

1.1 基本框架#

1
import SwiftUI
2

3
struct IntroView: View {
4
    var body: some View {
5
    // 从这里开始编写程序
6
        Text("Hello, world.")
7
    }
8
}
9

10
struct IntroView_Previews: PreviewProvider {
11
  // 这里是生成预览
12
    static var previews: some View {
13
        VStack {
14
            IntroView()
15
        }
16
    }
17
}

展开收起

1.2 引用视图#

这相当于 HTML 里的 iframe 。

1
FriendDetailView()

直接把其他视图的文件名当做一个函数放到 body 里，就可以内嵌这个页面了。

1.3 对于任意元素的视图布局#

注意：修饰符既可以直接修饰单个元素，也可以修饰整个 Stack 。如果修饰一个 Stack ，那么这个 Stack 里面所有的相应元素都会被修饰。

1.3.1 设置长宽（框架修饰符）#

1.3.1.1 直接设置#

1
Rectangle()
2
  .frame(width: 150, height: 233)

1.3.1.2 限制范围#

1
.frame(minWidth: 100, maxHeight: 200)
2
.frame(maxWidth: 50)
3
.frame(maxWidth: .infinity, maxHeight: 10) // 最大宽度设置为无穷大，就会延伸到填满空间

注意，对于一个图像，使用框架修饰符只会改变它周围空隙的大小。要改变图片的大小，需要加上 .resizable() 修饰符。

1.4 留白器#

1
Spacer()

1.5 （语法）三元运算符#

和 C++ 类似，如下：

1
.frame(maxWidth: .infinity, alignment: isEditing ? .leading : .center)

2 文本类#

2.1 最简单的文本#

1
Text("Hello, world.")

2.2 用变量保存文本并显示#

1
var t=Text("something")

2.3 修改字体#

2.3.1 基本操作#

1
Text("friend")
2
  .font(/* add something here ... */)

使用 .font() 修饰符，在里面添加类型。

2.3.2 大标题#

1
Text("friend")
2
  .font(.largeTitle)

2.3.3 标题#

1
Text("ohh")
2
  .font(.title)

2.3.4 说明文本#

1
Text("friend")
2
  .font(.caption)

2.3.5 略加粗#

1
.frame(.headline)

3 图像类#

3.1 最简单的图像#

1
Image("FriendAndGem")

这将会使图片按原始大小显示在页面上。

3.2 使用系统内置的图标#

1
// 龟兔赛跑
2
Image(systemName: "tortoise")
3
Image(systemName: "hare")

3.3 大小可变的修饰符#

1
Image("FriendAndGem")
2
  .resizable()

然后就可以使用其它的各种修饰符来给这个图像变换大小了。现在这个图像被不按原比例地拉伸填充整个屏幕了。

3.4 适合屏幕的缩放#

1
Image("FriendAndGem")
2
  .resizable()
3
  .scaledToFit()

这个图像被按原始比例缩放至适合屏幕了。

3.5 缩放以填充#

1
Image("FriendAndGem")
2
  .resizable()
3
  .scaledToFit()

4 容器#

4.1 水平堆栈#

1
import SwiftUI
2

3
struct IntroView: View {
4
    var body: some View {
5
        Text("test.")
6
        HStack {
7
            Text("1")
8
            Text("2")
9
            Image("FriendAndGem")
10
                .resizable()
11
                .scaledToFit()
12
        }
13
    }
14
}

这里的 HStack 加在了 body 里面。

这样的所有元素都会水平排列。

4.2 垂直堆栈#

1
struct FriendDetailView: View {
2
    var body: some View {
3
        VStack {
4
            /* something ... */
5
        }
6
    }
7
}

4.3 Z 轴堆栈#

1
ZStack {
2

3
}

注意，在 ZStack 中，对于源代码从上到下的顺序，在真实的预览里是从下面到顶部。

4.4 Stack 的属性设定#

4.4.1 对齐方式#

可以指定该容器内部的元素的排列方式。默认左对齐。

4.4.1.1 垂直堆栈，只能设置水平对齐#

1
VStack (alignment: .leading) {
2
  // 左对齐
3
}
4
VStack (alignment: .trailing) {
5
  // 右对齐
6
}

4.4.1.2 水平堆栈，只能设置垂直对齐#

1
HStack (alignment: .top) {
2
  // 上方对齐
3
}
4
HStack (alignment: .bottom) {
5
  // 下方对齐
6
}

对于一个元素，还可以使用 frame 修饰符指定对齐方式：

1
Image(systemName: "books.vertical.fill")
2
  .frame(alignment: .trailing)

4.4.2 内部元素间距#

1
HStack(spacing: 20){
2

3
}

对于某个特定的元素，可以为其上下左右设置间距：

1
.padding(.trailing, 20)
2
.padding(.leading, 20)
3
.padding(.top, 20)
4
.padding(.bottom, 20)
5
.padding(.horizontal, 20) // 四周全部

5 图形类#

5.1 基本几何体#

5.1.1 圆形#

1
Circle()

5.1.2 胶囊形#

1
Capsule()

5.1.3 椭圆形#

1
Ellipse()

5.1.4 矩形#

1
Rectangle()

5.1.5 圆角矩形#

1
RoundedRectangle(cornerRadius: 10)
2
  .foregroundColor(.brown)

如上代码，设置了填充色、圆角程度等。

5.2 色彩/风格设置#

5.2.1 填充色/前景色#

1
Circle()
2
  .foregroundColor(.blue)
3
Circle()
4
  .foregroundColor(.mint)
5
Circle()
6
  .foregroundColor(.bannerPink)

5.2.2 缩小#

1
Circle()
2
  .inset(by: 40)

5.2.3 填充背景#

注意：该方法也适用于一些图标或文字。

1
Image(systemName: "books.vertical.fill")
2
  .background(Color.yellow)

5.2.4 外框#

1
.border(Color.black)

5.2.5 位置偏移#

1
.offset(x: -2, y: 20)

CSP 2022 ZJ J组迷惑代码大赏

Sun, 30 Oct 2022 00:00:00 GMT

暂别了，OI —— CSP 2022 游记

Sat, 29 Oct 2022 00:00:00 GMT

启程#

10月28日晚上5:15，从学校出发。白天学校里开了半天运动会，趁着下午再复习一下。早早出了晚饭。路上要开3个小时，晚上借宿一家酒店。

7D6B845EA76F1266D9A24A00DFE2CB43.png

路上几个小黑子同学在打一些不知名的游戏，精神饱满，硬是玩了一路。或突然大叫起来。在车上只睡了一个小时，以免晚上睡不着。时节已经入秋，天早早的就黑了。

6ADA87791759DA1D4DEAFE205E3D1F8A.png

醒了以后还在打游戏。于是带上耳机听音乐。

也好久没有上高速了，突然发现路牌都会发光了，甚至能显示到达时间，太高级了。

晚间的路没有什么私家车，基本上都是大卡车，送货的。

10月29日早#

早上六点四十五起来洗漱后浏览了一下信息，去吃早饭。7:25集合出发。

2883BB957AE0B56C01824E8274B507C0.png

来到绍兴一中，在大门排队，先在二楼休息室等到八点，然后再到三楼，进入考场。（间隙的时候去隔壁偷瞄了一眼，一堆卷王在上课）

8:00#

找到了自己的机位，刚好在一排的末尾。电脑上已经打开了一个窗口，D盘里已经建好了选手文件夹，E盘里是考试须知和一个题目压缩包。本来以为组委会怎么那么不严谨，题目直接放盘里了，不敢打开。后来老师说开考了以后会有压缩包密码，才放下心来。

机子是i5，内存竟然有8G。系统还是win7，里面预装的软件也和自己学校机房的一模一样。

8:28#

压缩包密码下发，是 mountain2022 。解压以后还不能答题，只能看。快速看了第一题，大概是普通快递幂，然后特判一下信息。第二题是一个一元二次方程。然后就开考了。

注意事项里竟然上衣ccf的机子能有12代i7合32G内存，太良心了。

8:30#

铃响了，然后就是一堆人开始敲键盘，排山倒海，浩浩荡荡。第一题花5min先写了快速幂的模版，然后再加了好几处特判，小于0的判了。15min，过了大样例。

另：大样例怎么没有换行，用freopen又能正常读取？是因为这个换行是Linux下的换行吧。本人选的Windows系统。

写第二题，将式子展开，算了delta，又推了一遍求根公式。发现如果算出来的不是整数也是输出NO。过了大样例。

看了第三题，一个大模拟，算来算去，太烦躁了，先写第四题。

第四题一看是个dp，在草稿纸上画了点的坐标，写下dp的内容。编写代码，中途小改了下思路。写了一小时，过了大样例。

10:20#

挑战第3题。看上去是用栈模拟操作，很早以前也写过这样的计算器的题目，但是这道题还要求求短路，感觉没有什么思路。还是使用递归，花了50分钟，过了前面几个大样例，但最后一个T了。

递归的思路中是要每一层都把字符串扫一遍，所以导致了超时。如何解决呢？冥想用ST表？J组能用ST表？？然后一个较为简单的思路是，对于字符串的每一个位置预处理出它上一个符号的位置，就能O(n)了。

11:10#

开始优化。写了足足30分钟，bug调来调去，程序还停止运行了。还是稳一点，放弃了更改，检查一下。

11:55#

监考老师刚好走过，举手请看一看文件保存目录是否正确。

“你打开看看？应该是这个意思……”我打开了两个，人就走了。

“？？……”

铃响，OI生涯就告一段落了。

下午，风景区#

像我这样菜的只配参加普及组，下午便去柯岩风景区了。

C44671C1DDDB4892C01748AB56449AA6.png

33F20F2ADEAD75CA6C2C32195E20A137.png

DB6642AED0BEB83723D3C72105AE7366.png

1C51FD619516EB49784422B15A1463DA.png

12DA13C1AE9B351A2FFEE68B71E1EE57.png

D1F4169868006D00F61E34EA97698D87.png

D6FDA0B4AAABCEFB34B0E5EDEBF814B8.png

要和OI暂别了。或许高中还有机会，不过这次普及组拿个省一也算是一个圆满的句号吧。

CSP 2022 RP++

Fri, 28 Oct 2022 00:00:00 GMT

电梯之王#

题目描述#

在惠州学院因为电梯数量很少，所以同学们坐电梯需要花钱，并且为了限制你坐电梯浪费盈利时间，学校专门给每一层设置了能坐的最高高度。，所以对每一层有两种元素: 1.花费一元坐电梯 2.能坐到的最高高度(例如给出的高度是X,那么第iii层能坐到的层数是[i+1,i+X][i + 1,i + X][i+1,i+X]。但是请注意，因为惠州学院也想要锻炼学生的体魄，电梯不能往楼下坐。现在想要知道，如何最经济实惠坐到每一层。倘若坐不到则输出−1-1−1。

思路#

Level 1 动态规划#

考虑 dp[i]dp[i]dp[i] 表示走到第 iii 层所需的最小花费。这样竟然能拿九十分

1
#include <bits/stdc++.h>
2
using namespace std;
3
const int maxn=1e7+10;
4
int dp[maxn];
5
int a[maxn];
6
int n;
7

8
inline int read()
9
{
10
    int x=0,f=1;
11
    char ch=getchar();
12
    while(ch<'0'||ch>'9')
13
    {
14
        if(ch=='-')
15
            f=-1;
16
        ch=getchar();
17
    }
18
    while(ch>='0' && ch<='9')
19
        x=x*10+ch-'0',ch=getchar();
20
    return x*f;
21
}
22

23
void write(int x)
24
{
25
    if(x<0)
26
        putchar('-'),x=-x;
27
    if(x>9)
28
        write(x/10);
29
    putchar(x%10+'0');
30
    return;
31
}
32

33
void init(){
34
    for(int i=0;i<maxn;i++){
35
        dp[i]=INT_MAX;
36
    }
37
}
38
int main(){
39
    n=read();
40
    init();
41
    for(int i=1;i<=n;i++){
42
        a[i]=read();
43
    }
44
    int last=1,cnt=1;
45
    int times=1;
46
    int lasti=-1;
47
    int runtime=0;
48
    cout<<"0\n";
49
    for(int i=1;i<n;){
50
        runtime++;
51
        if(runtime>n*3){
52
            break;
53
        }
54
        int maxpos=-1,pos;
55
        for(int j=i+1;j<=i+a[i];j++){
56
            if(j+a[j]>maxpos){
57
                maxpos=j+a[j];
58
                pos=j;
59
            }
60
        }
61
        for(int j=last+1;j<=i+a[i];j++){
62
            cout<<cnt<<endl;
63
            times++;
64
        }
65
        cnt++;
66
        last=i+a[i];
67
        i=pos;
68
        lasti=i;
69
    }
70
    return 0;
71
}

展开收起

Level 2 贪心#

第一层电梯肯定是要坐的。那么现在第一层电梯就能到达一定范围的层数。利用贪心的思想，我们要尽可能利用现有的这些能到达的楼层，跳到更高的楼层。所以我们在这些范围内寻找所能到达楼层的最高值。那么我们又得到了一个新的范围。在这个范围内再次进行如上操作。

值得注意的是，两个范围很可能有重叠部分。为了保证严格的 O(n)O(n)O(n) ，可以跳过重叠的部分。因为重叠部分里能到达的最高楼层一定小于当前选择的楼层。

好狼狈的代码：

1
#include <bits/stdc++.h>
2
using namespace std;
3
const int maxn=1e7+10;
4
int dp[maxn];
5
int a[maxn];
6
int n;
7

8
inline int read()
9
{
10
    int x=0,f=1;
11
    char ch=getchar();
12
    while(ch<'0'||ch>'9')
13
    {
14
        if(ch=='-')
15
            f=-1;
16
        ch=getchar();
17
    }
18
    while(ch>='0' && ch<='9')
19
        x=x*10+ch-'0',ch=getchar();
20
    return x*f;
21
}
22

23
void write(int x)
24
{
25
    if(x<0)
26
        putchar('-'),x=-x;
27
    if(x>9)
28
        write(x/10);
29
    putchar(x%10+'0');
30
    return;
31
}
32

33
void init(){
34
    for(int i=0;i<maxn;i++){
35
        dp[i]=INT_MAX;
36
    }
37
}
38
int main(){
39
    n=read();
40
    init();
41
    for(int i=1;i<=n;i++){
42
        a[i]=read();
43
    }
44
    int last=1,cnt=1;
45
    int times=1;
46
    int lasti=-1;
47
    int runtime=0;
48
    cout<<"0\n";
49
    for(int i=1;i<n;){
50
        runtime++;
51
        if(runtime>n*3){
52
            break;
53
        }
54
        int maxpos=-1,pos;
55
        for(int j=i+1;j<=i+a[i];j++){
56
            if(j+a[j]>maxpos){
57
                maxpos=j+a[j];
58
                pos=j;
59
            }
60
        }
61
        for(int j=last+1;j<=i+a[i];j++){
62
            write(cnt);
63
            putchar('\n');
64
            times++;
65
        }
66
        cnt++;
67
        last=i+a[i];
68
        i=pos;
69
        lasti=i;
70
    }
71
    return 0;
72
}

展开收起

元素#

题目描述#

给你 nn 个元素,每个元素有一个坐标 (x,y)(x, y)(x,y) ,现在想让你求出有多少三元组 (i,j,k)(i,j,k)(i,j,k) ,满足2xj=xi+xk 2x_j = x_i + x_k2xj=xi+xk 并且 2yj=yi+yk2y_j = y_i + y_k2yj=yi+yk 。

思路#

均摊 O(n2)O(n^2)O(n2) 的算法。枚举前两个坐标，然后寻找第三个坐标。注意，当我们把原坐标排序后，寻找的第三个坐标也是有序的，不必要全部从头到尾地查找。

代码#

1
#include <bits/stdc++.h>
2
using namespace std;
3
int n;
4
const int maxn=1e9;
5
inline int read()
6
{
7
    int x=0,f=1;
8
    char ch=getchar();
9
    while(ch<'0'||ch>'9')
10
    {
11
        if(ch=='-')
12
            f=-1;
13
        ch=getchar();
14
    }
15
    while(ch>='0' && ch<='9')
16
        x=x*10+ch-'0',ch=getchar();
17
    return x*f;
18
}
19

20
void write(int x)
21
{
22
    if(x<0)
23
        putchar('-'),x=-x;
24
    if(x>9)
25
        write(x/10);
26
    putchar(x%10+'0');
27
    return;
28
}
29

30
map<pair<int,int>,int>bk,id;
31
map<int,int>getpos;
32
struct node{
33
    int x,y;
34
}a[10010];
35
bool cmp(node x,node y){
36
    if(x.x==y.x){
37
        return x.y<y.y;
38
    }else{
39
        return x.x<y.x;
40
    }
41
}
42
int ans=0;
43
int main(){
44
    n=read();
45
    for(int i=1;i<=n;i++){
46
        a[i].x=read(),a[i].y=read();
47
    }
48
    sort(a+1,a+1+n,cmp);
49
    for(int i=1;i<=n;i++){
50
        bk[{a[i].x,a[i].y}]++;
51
        id[{a[i].x,a[i].y}]=i;
52
        if(getpos[a[i].x]==0){
53
            getpos[a[i].x]=i;
54
        }
55
    }
56
    for(int i=1;i<=n;i++){
57
        int nowpos=i+2;
58
        for(int j=i+1;j<=n;j++){
59
            int newx=a[j].x*2-a[i].x;
60
            int newy=a[j].y*2-a[i].y;
61
            for(;nowpos<=n;nowpos++){
62
                if(a[nowpos].x<newx){
63
                    continue;
64
                }else if(a[nowpos].x>newx){
65
                    break;
66
                }else{
67
                    if(a[nowpos].y<newy){
68
                        continue;
69
                    }else if(a[nowpos].y>newy){
70
                        break;
71
                    }
72
                    if(a[nowpos].y==newy){
73
                        ans++;
74
                    }
75
                }
76
            }
77
        }
78
    }
79
    write(ans);
80
    return 0;
81
}

展开收起

搜索#

题目描述#

xyxxyxxyx 神仙来到了一个神奇的国度,这个国度由 nnn 个相邻的城市组成.对于某个特定的城市 iii,他有一个特殊的高度 hih_ihi .但是 xyxxyxxyx 神仙喜欢一些特殊排列的城市高度.而且由于 xyxxyxxyx 是神仙,所以他可以选择若干段不相交的区间 [l,r][l,r][l,r] 并且将这个区间内的城市按照高度从小到大排序.现在 xyxxyxxyx神仙想知道,他能不能把面前的城市排列成他想要的高度排列.

思路#

如果有一段序列，想要它最终降序：如果原本就是降序的，可以实现；如果原来是升序的，就不行了。

所以我们考虑使用双指针，先看目标序列，对于每一段上升的区间，查看原来的区间是否恰好包含所有的这些数。如果否，就是 no 。

代码#

1
#include <bits/stdc++.h>
2
#define int long long
3
using namespace std;
4
const int maxn=1e6+10;
5
int t,n,a[maxn]={},b[maxn]={};
6
signed main(){
7
    cin>>t;
8
    while(t--){
9
        cin>>n;
10
        for(int i=1;i<=n;i++){
11
            cin>>a[i];
12
        }
13
        for(int i=1;i<=n;i++){
14
            cin>>b[i];
15
        }
16
        int i=1;
17
        bool flag=1;
18
        while(i<=n){
19
            map <int,int> sto;
20
            for(;b[i]>=b[i-1]&&i<=n;i++){
21
                sto[b[i]]++;
22
                sto[a[i]]--;
23
            }
24
            for(auto f:sto){
25
                if(f.second!=0){
26
                    flag=0;
27
                    break;
28
                }
29
            }
30
            b[i-1]=-1;
31
        }
32
        cout<<(flag?"yes\n":"no\n");
33
    }
34
    return 0;
35
}

展开收起

搜索题大赏

Wed, 26 Oct 2022 00:00:00 GMT

P2105 K皇后 #

题目描述#

小 Z 最近捡到了一个棋盘，他想在棋盘上摆放 KKK 个皇后。他想知道在他摆完这 KKK 个皇后之后，棋盘上还有多少个格子是不会被攻击到的。

注意：一个皇后会攻击到这个皇后所在的那一行，那一列，以及两条对角线。

思路#

对于任意一个放在 (x,y)(x,y)(x,y) 的皇后，它的这一行、这一列、两条对角线就要被标记为不合法。对于四种情况分别记录：

每一行：line[y]=1line[y]=1line[y]=1
每一列：row[x]=1row[x]=1row[x]=1
从左下到右上 // 的对角线：不难发现，x+yx+yx+y 是个定值，其实它的函数解析式可抽象为 y=−x+by=-x+by=−x+b 。
从左上到右下 \\ 的对角线：x−yx-yx−y 是个定值。注意细节： x−yx-yx−y 可能为负数。我们将其向右偏移一定的值（n+mn+mn+m）即可。

核心代码#

1
for(int i=1;i<=n;i++){
2
  if(rx[i])continue;
3
  for(int j=1;j<=m;j++){
4
    if(ppp[i+j]||mmm[i-j+maxn]||rx[i]||ry[j]){
5
      ;
6
    }else{
7
      cnt++;
8
    }
9
  }
10
}

数据范围是 2×1042 \times 10^42×104 ，稍加优化一下可以卡过。

P1784 数独 #

题目描述#

数独是根据 9×99 \times 99×9 盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个粗线宫内的数字均含 1−91 - 91−9 ，不重复。每一道合格的数独谜题都有且仅有唯一答案，推理方法也以此为基础，任何无解或多解的题目都是不合格的。

芬兰一位数学家号称设计出全球最难的“数独游戏”，并刊登在报纸上，让大家去挑战。

这位数学家说，他相信只有“智慧最顶尖”的人才有可能破解这个“数独之谜”。

据介绍，目前数独游戏的难度的等级有一到五级，一是入门等级，五则比较难。不过这位数学家说，他所设计的数独游戏难度等级是十一，可以说是所以数独游戏中，难度最高的等级。他还表示，他目前还没遇到解不出来的数独游戏，因此他认为“最具挑战性”的数独游戏并没有出现。

思路#

考虑朴素的深搜暴力枚举。对于每一个格子，如果添过就跳过；否则枚举1～9，并检验其行、列、九宫格是否合法。

优化一下，我们不对每一个格子都去判断合不合法，而是在填充一个格子的时候记录下不合法的状态，可以省去一些复杂度。

以下两个函数就是用来记录被BAN的和解除封印：

1
int forbbiden[maxn+1][maxn+1][maxn+1];
2
void forbbid(int x,int y,int num){
3
    for(int k=1;k<=maxn;k++){
4
        forbbiden[x][k][num]++;
5
        forbbiden[k][y][num]++;
6
    }
7
    int len=maxn/3;
8
    int sx=(int(ceil(1.0*x/len))-1)*len+1;
9
    int sy=(int(ceil(1.0*y/len))-1)*len+1;
10
    for(int i=sx;i<=sx+len-1;i++){
11
        for(int j=sy;j<=sy+len-1;j++){
12
            forbbiden[i][j][num]++;
13
        }
14
    }
15
}
16
void unforbbid(int x,int y,int num){
17
    for(int k=1;k<=maxn;k++){
18
        forbbiden[x][k][num]--;
19
        forbbiden[k][y][num]--;
20
    }
21
    int len=maxn/3;
22
    int sx=(int(ceil(1.0*x/len))-1)*len+1;
23
    int sy=(int(ceil(1.0*y/len))-1)*len+1;
24
    for(int i=sx;i<=sx+len-1;i++){
25
        for(int j=sy;j<=sy+len-1;j++){
26
            forbbiden[i][j][num]--;
27
        }
28
    }
29
}

展开收起

然后就是简单的dfs算法：

1
pair <int,int> nxt(int i,int j){
2
    int x=i,y=j;
3
    if(y==maxn){
4
        y=1,x++;
5
    }else{
6
        y++;
7
    }
8
    return {x,y};
9
}
10
void dfs(int x,int y){
11
    if(x==maxn+1){
12
        output();
13
        exit(0);
14
    }
15
    if(board[x][y]){
16
        dfs(nxt(x,y).first,nxt(x,y).second);
17
        return;
18
    }
19
    for(int num=1;num<=maxn;num++){
20
        if(!forbbiden[x][y][num]){
21
            board[x][y]=num;
22
            forbbid(x,y,num);
23
            dfs(nxt(x,y).first,nxt(x,y).second);
24
            board[x][y]=0;
25
            unforbbid(x,y,num);
26
        }
27
    }
28
}

展开收起

主函数别忘了在输入的时候也要记录不合法：

1
int main(){
2
    for(int i=1;i<=maxn;i++){
3
        for(int j=1;j<=maxn;j++){
4
            board[i][j]=read();
5
            forbbid(i,j,board[i][j]);
6
        }
7
    }
8
    dfs(1,1);
9
    return 0;
10
}

八数码难题 #

题目描述#

在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单,设目标状态为123804765），找到一种最少步骤的移动方法，实现从初始布局到目标布局的转变。

代码#

这道题主要学习一下如何让代码更加简明。

1
#include <bits/stdc++.h>
2
using namespace std;
3
string st;
4
struct node{
5
    string status;
6
    int step;
7
};
8
map <string,bool> vis;
9
const pair<int,int> swapRule[]={
10
    {1,2},{1,4},{2,3},{2,5},{3,6},
11
    {4,5},{4,7},{5,6},{5,8},{6,9},
12
    {7,8},{8,9}
13
};
14
void print(string s){
15
    cout<<s[0]<<s[1]<<s[2]<<endl;
16
    cout<<s[3]<<s[4]<<s[5]<<endl;
17
    cout<<s[6]<<s[7]<<s[8]<<endl;
18
    cout<<endl;
19
}
20
int main(){
21
    cin>>st;
22
    if(st=="123804765"){
23
        cout<<0;
24
        return 0;
25
    }
26
    queue <node> q;
27
    q.push(node{st,0});
28
    vis[st]=1;
29
    while(!q.empty()){
30
        node fnt=q.front();
31
        q.pop();
32
        for(int i=0;i<12;i++){
33
            int a=swapRule[i].first-1,b=swapRule[i].second-1;
34
            if(fnt.status[a]=='0'||fnt.status[b]=='0'){
35
                swap(fnt.status[a],fnt.status[b]);
36
                if(fnt.status=="123804765"){
37
                    cout<<fnt.step+1;
38
                    return 0;
39
                }
40
                if(!vis[fnt.status]){
41
                    q.push({fnt.status,fnt.step+1});
42
                    vis[fnt.status]=1;
43
                }
44
                swap(fnt.status[a],fnt.status[b]);
45
            }
46
        }
47
    }
48
    return 0;
49
}

展开收起

P2024 [NOI2001] 食物链题解

Sun, 16 Oct 2022 00:00:00 GMT

题目描述#

动物王国中有三类动物 A,B,CA,B,CA,B,C，这三类动物的食物链构成了有趣的环形。AAA 吃 BBB，BBB 吃 CCC，CCC 吃 AAA。

现有 NNN 个动物，以 1∼N1 \sim N1∼N 编号。每个动物都是 A,B,CA,B,CA,B,C 中的一种，但是我们并不知道它到底是哪一种。

有人用两种说法对这 NNN 个动物所构成的食物链关系进行描述：

第一种说法是 1 X Y，表示 XXX 和 YYY 是同类。
第二种说法是2 X Y，表示 XXX 吃 YYY。

此人对 NNN 个动物，用上述两种说法，一句接一句地说出 KKK 句话，这 KKK 句话有的是真的，有的是假的。当一句话满足下列三条之一时，这句话就是假话，否则就是真话。

当前的话与前面的某些真的话冲突，就是假话；
当前的话中 XXX 或 YYY 比 NNN 大，就是假话；
当前的话表示 XXX 吃 XXX，就是假话。

你的任务是根据给定的 NNN 和 KKK 句话，输出假话的总数。

思路#

这道题显然是并查集，那么我们需要考虑的是如何在并查集中把同类/不同类表示出来。如果我们将同类的合并到一个并查集里，不同类的不在同一个并查集，那么我们就无法记录不同类之间的关系。如果将不同类合并到一个并查集中，同类的也合并到一个并查集中，其中在并查集里它们有一定的次序，就可以解决以上问题了。

具体过程#

当指令给出 XXX 吃 YYY 时，我们就把 XXX 指向 YYY 。不难发现，如果这些关系形成了一棵树或一条链，也就是从下到上下面的吃上面的，就会构成一个循环：每差三个就是一个同类。

当给出两者是同类的关系时，说明我们需要将两者合并到一个并查集中。但是不能乱合并，我们也需要体现出其中的层次关系。只需要让这两个同类合并后深度差三即可。所以找到合适的位置再合并就行了。

附：圆锥、球体体积推导#

圆锥#

一个圆锥可以看作是一个直角三角形绕直角边旋转一周的结果。同样的，我们如果用柱体的眼光看待，它就是大小渐变的圆堆积而成的物体。这么一来，我们就可以使用积分求出它的体积了。

如图，我们可以把圆锥进行“切片”操作。

截屏2022-10-16 17.23.30.png

对于每一个圆的半径，我们可以用相似三角形求解。

截屏2022-10-16 17.25.27.png

如图，我们假定圆锥的高度为 hhh ，底面半径为 RRR ，那么对于一个到顶点距离为 xxx 的圆，它的半径 rrr 就是 R×xhR \times \frac{x}{h}R×hx 。对于 x∈[0,h]x \in [0,h]x∈[0,h] ，我们将这些面积进行积分。

对于每一个圆的面积：

f(x)=π×(Rh×x)2=π×R2h2×x2f(x)=\pi \times (\frac{R}{h} \times x)^2=\pi \times \frac{R^2}{h^2} \times x^2f(x)=π×(hR×x)2=π×h2R2×x2

要求：

∫0hf(x)dx=F(h)−F(0)\int_{0}^{h} f(x)dx = F(h)-F(0)∫0hf(x)dx=F(h)−F(0)

而：

F(x)=π×R23h2×x3F(x)=\pi \times \frac{R^2}{3h^2} \times x^3F(x)=π×3h2R2×x3

故最终的答案为：

F(h)−F(0)=π×R23h2×h3=13πR2hF(h)-F(0)=\pi \times \frac{R^2}{3h^2} \times h^3=\frac{1}{3} \pi R^2 hF(h)−F(0)=π×3h2R2×h3=31πR2h

球体#

我们把上面的思路变换一下，将球体切片成大小不一的圆形。对于到圆心距离为 x∈[−R,R]x \in [-R,R]x∈[−R,R] 的圆的面积可以表示为：

f(x)=π(R2−x2)2=πR2−πx2f(x)=\pi (\sqrt{R^2-x^2})^2=\pi R^2- \pi x^2f(x)=π(R2−x2)2=πR2−πx2

积分一下：

F(x)=πR2x−π3x3F(x)=\pi R^2 x - \frac{\pi}{3}x^3F(x)=πR2x−3πx3

求得体积：

∫−RR=F(R)−F(−R)=(πR2×R−π3R3)×2=43πR3\int_{-R}^{R}=F(R)-F(-R)=(\pi R^2 \times R - \frac{\pi}{3}R^3)\times 2=\frac{4}{3}\pi R^3∫−RR=F(R)−F(−R)=(πR2×R−3πR3)×2=34πR3

小笔记

Tue, 13 Sep 2022 00:00:00 GMT

1. 时间复杂度练习#

默写 O(n) 的递归快速幂、默写 O(logn) 的递归快速幂，找到区别。

1
#include <bits/stdc++.h>
2
#define ll long long
3
using namespace std;
4

5
/* O(n)的递归快速幂 */
6
ll bad_qpow(ll x,ll n){
7
  if(!(n-1)) return x;
8
  return bad_qpow(x,n/2)*bad_qpow(x,n/2)*(n%2?x:1);
9
}
10

11
/* O(logn)的递归快速幂 */
12
ll good_qpow(ll x,ll n){
13
  if(!(n-1))return x;
14
  ll res=good_qpow(x,n/2);
15
  return res*res*(n%2?x:1);
16
}
17

18
/* O(logn)的递归快速幂，且常数更优 */
19
ll best_qpow(ll x,ll n){
20
  ll base=x,res=1;
21
  while(n){
22
    if(n&1){
23
      res*=base;
24
    }
25
    base*=base;
26
    n>>=1;
27
  }
28
  return res;
29
}
30

31
ll x,n;
32

33
int main(){
34
  cin>>x>>n;
35
  cout<<bad_qpow(x,n)<<endl;
36
  cout<<good_qpow(x,n)<<endl;
37
  cout<<best_qpow(x,n)<<endl;
38
  return 0;
39
}

展开收起

区别： O(n)O(n)O(n) 的快速幂将函数分治后又调用了两次，算了两次相同的值，相当于没优化；而 O(logn)O(logn)O(logn) 的快速幂利用空间换时间，把得数保存下来再乘两次。

O(nlogn) 的归并排序和 O(n) 的递归快速幂复杂度区别在哪里。

归并排序：
```
1
void MergeSort(int* arr,int left,int right,int* s){//归并排序递归
2
  if(right-left<=1){//元素个数小于1，直接返回
3
    return;
4
  }
5
  int mid=left+(right-left)/2;
6
  MergeSort(arr,left,mid,s);//归并左半部分
7
  MergeSort(arr,mid,right,s);//归并右半部分
8
  MergeData(arr,left,mid,right,s);//将当前有序的序列进行归并
9
  memcpy(arr+left,s+left,sizeof(arr[0])*(right-left));//将归并后的将结果拷贝回原来的数组，为下次归并做准备
10
}
```
可以看到，对于每一层，不管怎么分治，最终均摊下来每一个元素都要走到；而每次对半分，最多可以分 lognlognlogn 层。所以总复杂度为 O(logn)O(logn)O(logn) 。

而 O(n)O(n)O(n) 的递归快速幂虽然也是每次对半分，但是它只是对一个数字进行对半分，并没有遍历什么数组，所以最终的复杂度应该是最后一层每次 return x ，返回了 nnn 遍。
程序阅读第二题订正时间复杂度、说明什么时候是 O(n) 什么时候是 O(nlogn)

注意原代码：
```
1
void dfs(...){
2
  ...
3
  if(...){
4
    return dfs(...n/2...);
5
  }else if(...){
6
    return dfs(...n/2...);
7
  }else{
8
    ...
9
  }
10
}
```
注意这里有 if...else... 的关系，所以两个 dfs 不会同时执行，而回只执行一个。那么执行次数就是 n+n/2+n/4+n/8+...+1=2∗n n+n/2+n/4+n/8+...+1=2*nn+n/2+n/4+n/8+...+1=2∗n ，即时间复杂度为 O(n)O(n)O(n) 。

如果没有 if...else... ，则每次两个 dfs 都会执行，每层复杂度 O(n)O(n)O(n) ，共 lognlognlogn 层，此时总复杂度为 O(nlogn)O(nlogn)O(nlogn) 。

2. 错题总结#

大规模集成电路的出现，推动了个人计算机的诞生。
一个汉字占两倍的英文字符长度。
5双手套5种颜色，先从5种颜色里选出3种，C(5,3), 对于每一种颜色的手套还可选(左手套和右手套不一样)，对于每种颜色有2种，三种颜色有8种，所以总共80种。

3. 组合数学难题#

555 双手套，拿三只，恰有一双匹配，方案数多少？（左右有区别）

先选出一个完整的颜色， C(5,3)=10C(5,3)=10C(5,3)=10 ，再在剩下的所有手套中选出1个， C(8,1)=8C(8,1)=8C(8,1)=8 。所以总方案为 808080 。

OIso | OI搜开发日志

Sun, 04 Sep 2022 00:00:00 GMT

OIso - 专为 OIer 而诞生#

当前域名：oiso.cf

OIso ，谐音 OI搜 。域名后缀是 cf ， OIer 们应该熟悉 CodeForces ？容易记住吧。

开发团队#

本项目前端由 @diyanqi 与 @Lotuses 共同开发，后端由 @diyanqi 开发。

特别鸣谢：@tobyLai 在研发时给我灵感与支持。

To-Do#

添加 封禁用户 tag 功能
用户主页备份功能
添加爬虫机器人自动登录获取 Cookie 功能
用户ID搜用户（&团队）

更新日志#

v1.1 正式版 - 2023.8.1#

更新 ChatGPT 用户体验
美化了主页页面
新增“手气不错”功能

v1.0 正式版 - 2023.3.4#

接入 OpenAI 的 AI 服务
推出 tamperOIso 油猴插件
开始正式推出 Premium 会员服务

v0.9 测试版 - 2023.2.1#

新增了直播功能，但由于服务器原因暂停开放用户接口
新增消息撤回功能
新增支持爬取第三方博客功能
新增 AI 作图、格式转换
首页采用必应壁纸，并支持自定义主题色
AI 智能回答（测试使用）
搜索智能联想
敏感词屏蔽系统

v0.8.x 测试版 - 2022.12.23#

添加了机器人功能

v0.7.1 测试版 - 2022.12.3#

新增了洛谷用户&团队搜索功能

v0.7 测试版 - 2022.11.12#

@Lotuses 参与了前端开发！
新增了爬虫状态功能
用户也可以提交爬虫请求

v0.6 测试版 - 2022.10.15#

重新布局了休闲区
更新了犇犇显示方式
更新了点歌系统

v0.5.x 测试版 - 2022.10.4#

新增了通过洛谷的登录系统

v0.3.6 测试版 - 2022.9.11#

添加了快速预览功能

v0.3 测试版 - 2022.9.4#

规范了一些 logo 和 title 。
增添了高亮显示。
添加了清空按钮
优化了部分 UI 细节
将前端部署至 CloudFlare Pages ，速度略有提升。

v0.2 测试版 - 2022.8.31#

增添了 文章 搜索功能。
修复了超链接重定向错误的 BUG 。

v0.1 测试版 - 2022.8.30#

初次发布，前端文件储存在 GitHub 上，并由 CloudFlare Pages 托管，由 CloudFlare 加速。
后端服务器利用 CloudFlare 保护。

树状数组进阶练习

Sat, 03 Sep 2022 00:00:00 GMT

通过这些练习，我们能对树状数组有更深刻的理解。这里给题目排的顺序是难度不严格递增的。

P4939 Agent2 #

image.png

这道题是典型的树状数组+差分。我们在开始咕的天数打上标记 +1+1+1 ，结束咕的那天的后一天打上标记 −1-1−1 ，那么这段天数就代表了多了一个咕咕咕。

P5057 [CQOI2006]简单题 #

image.png

这题同样也是树状数组的标签。注意，树状数组能处理的是和前缀有关的问题。不论是前缀和，还是这道题的前缀布尔。这道题仍然是差分的思想，但我们需要抽象成布尔，即让每一个数字都是由一些真/假的与运算得来的。为什么用与？因为对于任意一个布尔值，我再与一个真/假，最后的结果可以由我决定；如果用或，如果已经是真了，不管再或一个真假还是真。当然，异或理论上也是可行的。

我们可以在树状数组+差分代码的基础上稍加修改：

1
void change(int x){
2
    while(x<=n){
3
        bit[x]=!bit[x];
4
        x+=lowbit(x);
5
    }
6
}
7
bool query(int x){
8
    bool ans=0;
9
    while(x>0){//边界条件x>0!
10
        if(bit[x]){
11
            ans=!ans;
12
        }
13
        x-=lowbit(x);
14
    }
15
    return ans;
16
}

展开收起

P5094 [USACO04OPEN] MooFest G 加强版 #

image.png

我们来看样例：

1
位置: 1 2 3 4 5 6
2
听力: 3   4   2 2

首先当然不能 O(n2)O(n^2)O(n2) 地去求答案，第一步我们要想出一种办法能有序地求出答案。让我们对奶牛按听力进行从小到大排序，那么对于一个当前选出的奶牛来说，之前的奶牛的听力肯定比当前的小，所以它是目前听力最大的。这个时候，我们只需将这个奶牛的听力去乘上所有的位置之差即可。

我们根据这个想法，看样例列出以下算式：

1
2*(6-5)+3*((5-1)+(6-1))+4*((6-3)+(5-3)+(3-1))=57=样例输出

现在我们来处理每个加式的乘号后面的内容。我们注意到，对于位置在当前奶牛之前的，这个位置之差应当是当前的减去前面的；反之亦然。进一步展开，我们发现所有位置在当前奶牛之前的位置之差应当是前面的位置之和减去当前奶牛位置乘以前面奶牛的个数；反之亦然。所以我们需要维护的是位置比当前奶牛小的奶牛的位置值之和，以及位置比当前奶牛小的奶牛的个数。

这样只维护了位置比当前奶牛小的。大的呢需要再另外维护两个吗？我们可以把所有奶牛的位置加起来，个数加起来，这样总数减去前面的就是后面的了。

1
for(int i=1;i<=n;i++){
2
    sum+=a[i].x;
3
    change(a[i].x,1);
4
    change2(a[i].x,a[i].x);
5
    if(i==1){
6
        continue;
7
    }
8
    int xiao_geshu=query(a[i].x-1); // 小的个数
9
    int da_geshu=i-xiao_geshu-1;
10
    int xiao_zhihe=query2(a[i].x-1); // 小的之和
11
    int da_zhihe=sum-a[i].x-xiao_zhihe;
12
    ans+=a[i].v*(da_zhihe-da_geshu*a[i].x+xiao_geshu*a[i].x-xiao_zhihe);
13
    }

P1637 三元上升子序列 #

image.png

之前做过一个求字符串中子序列 gao 的个数。这题的其中一个思路是对于每一个 a ，向前向后看 g 和 o 的个数，然后乘起来，再累加。

而本题的思路也是相类似的。我们对于原数列中每一个数，将其前面比当前数字小的个数乘上后面比当前数字大的个数，然后再累加。遍历原数列中每个数是 O(n)O(n)O(n) 的，我们要再用 O(logn)O(logn)O(logn) 的复杂度求出前后的数字个数。

1
for(int i=1;i<=n;i++){
2
  change(a[i],1);
3
  if(i==1||i==n)continue;
4
  l[i]=query(a[i]-1);
5
}
6
init();
7
for(int i=n;i>=1;i--){
8
  change(maxn-a[i],1);
9
  if(i==1||i==n)continue;
10
  r[i]=query(maxn-a[i]-1);
11
}

P3431 [POI2005]AUT-The Bus #

image.png

对于这类题，首先考虑使用 dp 。令 dp[i] 表示看到第 i 个点，所能接到的乘客的最大值。显然， dp[i]=max{dp[k]，其中点k的在点i的左上角} 。注意数据范围： 1≤n≤1091\le n\le 10^91≤n≤109, 1≤m≤1091\le m\le 10^91≤m≤109, 1≤k≤1051\le k\le 10^51≤k≤105 。我们首先要给坐标离散化，然后对于每一个点找出它左上角点的最大值。

看到最大值，我们又可以对树状数组进行改造了。

1
void update(int x,int y){
2
  while(x<maxn-5){
3
    bit[x]=max(bit[x],y);
4
//    bit[x]+=y;
5
    x+=lowbit(x);
6
  }
7
}
8
int query(int x){
9
  int ans=0;
10
  while(x>0){
11
//    ans+=bit[x];
12
    ans=max(ans,bit[x]);
13
    x-=lowbit(x);
14
  }
15
  return ans;
16
}

展开收起

要想求出一个 dp[i]dp[i]dp[i] ，我们必须先求好所有横坐标、纵坐标都小于等于当前点的，那么让我们先把纵坐标从小到大排序，再横坐标从小到大排序。对于每一个纵坐标，遍历从左到右的横坐标。其上方的点肯定是更新过了，左边的点也更新过了。更新的时候把横坐标更新成当前算出来的 dpdpdp 值即可。

P2448 无尽的生命 #

image.png

这道题细节比较多，也比较毒瘤，首先要给输入离散化，完了以后把没有要求要交换空区间合并起来，然后再按逆序对做。是不是很简单？

image.png

事实上是我太菜了。

P3253 [JLOI2013]删除物品 #

image.png

讲的是把两个栈里的东西翻来倒去的逝情。我们简化一下题意。原来的两个栈是这样的：

image.png

想象一下把一个元素搞到另一个栈的栈顶的操作。我们把它演化成下面这样：

image.png

没错，就是把两个栈顶连起来。再把它拉直：

image.png

就像这样。其中，绿色的箭头标注了原来栈顶的位置。想要把一个元素放到另一个栈里，相当于就是改变了栈顶的位置，即移动绿色的箭头。

我们很容易把输入数据弄成这样一个数列。我们让这个绿色的箭头 ptrptrptr 表示 a[ptr]a[ptr]a[ptr] 与 a[ptr+1]a[ptr+1]a[ptr+1] 这两个元素在栈顶。我们每次要找到最大的那个数的位置，就要考虑如何求出移动的步数。因为数字是不重复的，所以我们记录每一个数字的下标，然后在树状数组中该下标加上 111 ，就代表此处有一个数字。那么显然要移动的步数就是两个数字间的数字个数，可以用树状数组处理。当删除了一个数字，就在当前位置减去 111 ，表示当前数字被删除了。

注意这道题也需要离散化。

P3531 [POI2012]LIT-Letters #

image.png

我们来考虑什么情况下交换次数最少。首先，如果字符串没有重复的字母，显然最少交换次数就类似于冒泡排序，一个一个相邻的排过去。如果有重复的字母，应该要让原来在前的，最后也在前。这恰好类似于一个稳定的冒泡排序。

然后我们怎样快速求出要交换的次数呢？事实上，对于一个本来就上升的数列，如 1, 2, 3, 4, 5 ，如果把其中任意一个数往前移一个，如变成了 1 , 3, 2 ,4 ,5 ，就会多出一个逆序对；再移一次，又多出一个，总共两个。以上是一个正确的结论，且对于任意一个数列（不论顺序是上升、下降还是乱序），只要移了一个，就会多出一个逆序对。

所以这道题我们也是求逆序对的个数就可以了。

P3605 [USACO17JAN]Promotion Counting P #

image.png

求子树中比当前点大的节点个数。由于一个节点所领导的一棵树可能会和其它并列的树产生冲突，所以我们在求本子树的答案前，先减去还没求本子树前就已经存在的比当前节点大的节点数，即排除了其它树的干扰。然后再递归下去，加上总的比当前大的个数。那么剩下的就是本子树中比当前大的个数了。

从树状数组到线段树

Wed, 31 Aug 2022 00:00:00 GMT

从三味书屋到百草园（误）

1 树状数组回顾#

1.1 lowbit 原理#

众所周知，lowbit 取的是一个二进制数的最低位的数值，代码如下：

1
int lowbit(int x){
2
  return x&-x;
3
}

那么，为什么 x&-x 就能取到最低位呢？

我们来考虑一个二进制正数。由于我们取的是最低位，那么只需关注最低位的 111 即可。下面让我们来大致描述一下这个数：

0101001⋯0100000101001 \cdots 0100000101001⋯010000

注意，这个数的第一位一定是 000 ，因为是个正数。而我们关注的是最后一个 111 ，所以只需观察它及其右边的 000 即可。我们考虑这个数的补码，由于这个数是正数，所以补码等于原码，所以 lowbit 函数中 & 的左边就是这个数。

那么 −x-x−x 又是多少呢？对于原码来说，两者的绝对值相同，只是符号位相反，所以 −x-x−x 的原码就是把原来那个数的第一位 000 改成 111 。再考虑它的反码，就是除了符号位以外其它位全部取反。我们来看看它的反码：

1010110⋯1011111010110 \cdots 1011111010110⋯101111

注意看，将这个数加上 111 ，也就是成为了补码。你会得到：

1010110⋯1100001010110 \cdots 1100001010110⋯110000

因为反码的后面一串全是 111 ，所以我们加上了 111 后后面的 111 全部进位，就进到了原码是 111 的位置，使后面的一串和正数的原码一样。而其余的位都不一样，进行与运算后，都变成了 000 ，就留下了 111 这一位。大功告成。

1.2 树状数组概念澄清#

在树状数组中有这么一些概念：

原数组（ aaa 数组）
bitbitbit 数组
addaddadd 函数
queryqueryquery 函数

任何的研究都应该从宏观到微观，所以我们研究树状数组也是先看使用对象再看实现过程。 ——鲁迅

image.png

现在我们的目标是求出一个原数组的区间和（或者说前缀和也行），并且还能支持单点修改原数组。注意，这里的原数组不管是什么东西，普通数组也好，差分数组也好，我们维护的是数组本身的前缀和，而不关心原数组是做什么的。

addaddadd 函数能够标记维护的数组中某个数值的改变， queryqueryquery 函数能够查询维护数组的前缀和。

这样一来，我们就对树状数组有了更深刻的理解。让我们来看看下面这一题。

1.3 区间修改，单点查询#

如题，已知一个数列，你需要进行下面两种操作：将某区间每一个数加上 x ；求出某一个数的值。 —— 洛谷 P3368

说到给某个区间全部加上一个数，我们很容易想到差分。在差分数组中，我们给差分数组的起始位置和末位置打标记，对于原数组，就是求差分数组的前缀和。

我们来看以上思路的两个关键点：

给差分数组的某些位置打上标记，也就是改变数值；
求差分数组的前缀和。

我们再来看上面刚刚说过的话：

addaddadd 函数能够标记维护的数组中某个数值的改变， queryqueryquery 函数能够查询维护数组的前缀和。

所以想到什么了吗？我们可以用树状数组维护差分数组，并单点修改差分数组，查询差分数组前缀和。而这个前缀和恰好就是题目中要求的某个数。所以代码就出来了。

基本代码还是一样，改一下两点：

在读入的时候，初始数组要分配到差分数组里，所以要进行如下操作：

1
for(int i=1;i<=n;i++){
2
  cin>>a[i];
3
  add(i,a[i]);
4
  add(i+1,-a[i]);
5
}

修改与查询操作，按照上面的思路即可：

1
for(int i=1;i<=m;i++){
2
  cin>>cmd;
3
  if(cmd==1){
4
    cin>>x>>y>>k;
5
    add(x,k);
6
    add(y+1,-k);
7
  }else{
8
    cin>>x;
9
    cout<<query(x)<<endl;
10
  }
11
}

1.4 区间修改，区间查询#

太复杂了，如果不用线段树，用树状数组怎么做呢？

如题，已知一个数列，你需要进行下面两种操作：将某区间每一个数加上 kk。求出某区间每一个数的和。 —— 洛谷 P3372

1.4.1 推导#

推公式时间到！我们沿用上一题差分数组的思想。

假设 aaa 是原数组， bbb 是差分数组。那么易知：

a[x]=∑i=1xb[i]a[x]=\sum_{i=1}^{x}b[i]a[x]=i=1∑xb[i]

对于一个 aaa 数组的前缀和，我们得到：

∑x=1na[x]=∑i=1x∑j=1ib[j]\sum_{x=1}^{n}a[x] = \sum_{i=1}^{x} \sum_{j=1}^{i} b[j]x=1∑na[x]=i=1∑xj=1∑ib[j]

展开，得到

∑x=1na[x]=∑i=1x(x−i−1)×b[i]\sum_{x=1}^{n} a[x] = \sum_{i=1}^{x} (x-i-1) \times b[i]x=1∑na[x]=i=1∑x(x−i−1)×b[i]

进行常变分离，得到：

∑x=1na[x]=∑i=1x(x−1)×b[i]−∑i=1xi×b[i]\sum_{x=1}^{n}a[x] = \sum_{i=1}^{x} (x-1) \times b[i] - \sum_{i=1}^{x} i \times b[i]x=1∑na[x]=i=1∑x(x−1)×b[i]−i=1∑xi×b[i]

公式推导完毕。我们发现 aaa 数组的前缀和与 (x−1)×b[i](x-1) \times b[i](x−1)×b[i] 有关，与 i×b[i] i \times b[i]i×b[i] 也有关。前面一个还好说，维护一个 bbb 数组的树状数组，求出其前缀和，在输出答案的时候乘上一个查询的 xxx 减去 111 即可。而 i×b[i] i \times b[i]i×b[i] 有 iii 又有 b[i]b[i]b[i] ，它的前缀和该如何维护呢？

陷入了思维困境。我们来仔细考虑一下，树状数组做的是什么？维护数组前缀和。那么 i×b[i] i \times b[i]i×b[i] 不是数组怎么办？注意，对于任意的 iii ，iii 是确定的， b[i]b[i]b[i] 也是确定的， i×b[i] i \times b[i]i×b[i] 就是确定的了！你一定假想 iii 和 b[i]b[i]b[i] 并没有一一对应的关系，然而它们是唯一确定的。

这么说就好办了，我们让每一个 i×b[i] i \times b[i]i×b[i] 成为另外一个数组的每一个元素，再进行运算。 bit1bit1bit1 用于维护 b[1]+...+b[x]b[1]+...+b[x]b[1]+...+b[x] ， bit2bit2bit2 用于维护 i×b[1]+(i−1)×b[2]+...+1×b[i]i \times b[1]+(i-1) \times b[2]+...+1 \times b[i]i×b[1]+(i−1)×b[2]+...+1×b[i] 。

对于 aaa 数组的前缀和，就是 bbb 数组的前缀和乘上 (x−1)(x-1)(x−1) 再减去 i×b[i]i \times b[i]i×b[i] 数组的前缀和。

bbb 是什么？ bbb 是差分数组。所以我们仍然要对其进行差分的基本操作。只是存储的时候要在 bbb 数组上加一点“花边”。

QWQ

1.4.2 Code#

1
#include <bits/stdc++.h>
2
#define int long long // 别忘了开 long long
3
using namespace std;
4
const int maxn=5e5+10;
5
int a[maxn];
6
int bit1[maxn];
7
int bit2[maxn];
8
int n,m;
9
int cmd,x,y,k;
10
int lowbit(int x){
11
    return x&-x;
12
}
13
void add1(int x,int y){
14
    while(x<=n){
15
        bit1[x]+=y;
16
        x+=lowbit(x);
17
    }
18
}
19
void add2(int x,int y){
20
    while(x<=n){
21
        bit2[x]+=y;
22
        x+=lowbit(x);
23
    }
24
}
25
int query1(int x){
26
    int ans=0;
27
    while(x>0){//边界条件x>0!
28
        ans+=bit1[x];
29
        x-=lowbit(x);
30
    }
31
    return ans;
32
}
33
int query2(int x){
34
    int ans=0;
35
    while(x>0){//边界条件x>0!
36
        ans+=bit2[x];
37
        x-=lowbit(x);
38
    }
39
    return ans;
40
}
41
signed main(){
42
    cin>>n>>m;
43
    for(int i=1;i<=n;i++){
44
        cin>>a[i];
45
        add1(i,a[i]);
46
        add1(i+1,-a[i]);
47
        add2(i,a[i]*i);
48
        add2(i+1,-a[i]*(i+1));
49
    }
50
    for(int i=1;i<=m;i++){
51
        cin>>cmd;
52
        if(cmd==1){
53
            cin>>x>>y>>k;
54
            add1(x,k);
55
            add1(y+1,-k);
56
            add2(x,k*x);
57
            add2(y+1,-k*(y+1));
58
        }else{
59
            cin>>x>>y;
60
            cout<<(query1(y)*(y+1)-query2(y))-(query1(x-1)*(x)-query2(x-1))<<endl;
61
        }
62
    }
63
    return 0;
64
}

展开收起

这么来看，树状数组过于复杂，其思路晦涩难懂，拓展性差。这时候，线段树就登场了。

2 线段树入门#

2.1 构造#

相较于树状数组，线段树没有复杂的二进制表示，而是使用了分治的思想，将一排数组一分为二，再一分为二，分成每一份都只有一个数字为止。如下图：

image.png

图片来自洛谷

其中，每一个节点逗号左右的两个数字表示了一个区间。最顶上的 [1,8][1,8][1,8] 表示这个节点的值为原数组的 a[1]+a[2]+...+a[8]a[1]+a[2]+...+a[8]a[1]+a[2]+...+a[8] 。同样，最底下的这些点如 [1,1][1,1][1,1] 就只表示原数组的 a[1]a[1]a[1] 。

下面我们来研究最基础的线段树：单点修改，区间查询。不考虑任何优化。

2.2 关于线段树的数组#

如你所见，线段树是个二叉树。所以对于任意一个节点 tree[x]tree[x]tree[x] ，我们用 tree[x×2]tree[x \times 2]tree[x×2] 表示它的左儿子，用 tree[x×2+1]tree[x \times 2+1]tree[x×2+1] 表示它的右儿子。其中，根节点的编号为 111 。

那么这个数组要开多大呢？我们假设有原数组 nnn 个元素。也就是线段树最后一排有 nnn 个叶子节点（如图）。又由于这是一个满二叉树（当然很多情况下不会是满二叉树），所以它的节点总数大约是 2×n2 \times n2×n 。但是，在编写代码时我们通常开 444 倍的 nnn ，甚至 888 倍，别问我为什么。

发出小草的声音.png

2.3 初始化#

下面是 init 函数！对于题目给出的原始数组，我们要把它存到线段树里面去。考虑一下，对于每一个数，这个数会影响到它头顶上哪些节点的值呢？当然是一路往上直到根节点上的所有节点都要修改。首先明确一点，在树上，我们用深度优先搜索。

我们定义 init(now,l,r) 表示当前在 nownownow 这个编号的节点，左边囊括到 lll ，右边延申到 rrr 。那么当 l=rl=rl=r 时，这个区间只有一个点了，那么就往回回溯，更新上面的点；如果 l≠rl \neq rl=r ，说明还没有到叶子节点，那么久将当前点区间一分为二，往下递归，递归完后再根据两个儿子更新自己的值。

1
void init(int now,int l,int r){
2
  if(l==r){
3
    tree[now]=a[now]; // a 是原数组
4
    return;
5
  }
6
  mid=l+r<<1; // 加号的优先级大于位运算！
7
  init(now*2,l,mid); // 左儿子
8
  init(now*2+1,mid+1,r); // 右儿子
9
  tree[now]=tree[now*2]+tree[now*2+1];
10
}
11

12
init(1,1,n);

2.4 单点更新操作#

对于一个叶子节点加或减的更新，同样会影响到它头顶上一条路径的节点。但是我们是深度优先搜索，所以事实上的路径是从根节点寻找这个叶子节点的过程。对于每一个节点，我们都面临两条路的选择。而如何选择就成为了重点。

1
void update(int tar,int v,int s,int t,int p){
2
  // 我们要将原数组中 tar 这个位置加上 v ，
3
  // 也就是线段树 [tar,tar] 的节点加上 v 。
4
  // 当前的位置是节点 p，范围是 [s,t] 。
5
  tree[p]+=v;
6
  if(s==tar&&t==tar){
7
    return;
8
  }
9
  int mid=s+t<<1;
10
  if(tar<=mid){
11
    update(tar,v,s,mid,p*2);
12
  }else{
13
    update(tar,v,mid+1,t,p*2+1);
14
  }
15
}

展开收起

2.5 区间查询操作#

应该比较好理解，把一个大区间放到线段树顶端，然后一层一层切割，最后剩下来刚好线段树某一个节点的区间吻合的，就可以把答案加上去了。具体请看代码。

1
int query(int l,int r,int s,int t,int p){
2
  // [l,r] 表示要查询的目标区间，
3
  // [s,t] 表示当前所在的点所表示的区间，
4
  // p 是当前所在的点的编号。
5
  if(l<=s&&t<=r){
6
    // 说明当前区间包含于目标区间里了，就加上答案
7
    // 不要担心空余的区间会被遗漏，想一想当前这个区间是怎么达到的。
8
    return tree[p];
9
  }
10
  int mid=s+t<<1,ans=0;
11
  // 如果能走到这里，说明当前区间一定大于目标区间
12
  if(l<=mid){
13
    // 说明 [s,t] 的左边有一部分在 [l,r] 里
14
    ans+=query(l,r,s,mid,p*2);
15
  }
16
  if(mid<r){
17
    // 说明 [s,t] 的右边有一部分在 [l,r] 里
18
    ans+=query(l,r,mid+1,r,p*2+1);
19
  }
20
  return ans;
21
}

展开收起

在线安装黑苹果 - 小U盘的福音

Mon, 15 Aug 2022 00:00:00 GMT

0 准备#

您的U盘至少 2GB ，可以远远少于原版镜像的 12~13GB 了。

本教程在Windows下进行。请您预装 Python 。

1 下载工具#

来到 https://github.com/corpnewt/gibMacOS ，点击 Code ，然后下载 zip 。

image.png

解压，打开文件夹。找到 gibMacOS.bat ，右键，管理员运行。

image.png

打开后慢慢等待，先会显示出 macOS Mojave ，要扫描好一会儿才会有您想要的较新的版本。

等到全部扫完，就会如下所示。

image.png

在选项界面输入 R ，回车，下载恢复模式的镜像。注意，这里默认会下载最新版本的 macOS 。这个时候会重新扫一遍，速度较慢。

image.png

CSP考前佛脚

Sat, 06 Aug 2022 00:00:00 GMT

1 set#

1.1 set 的定义#

1
set<int>s;
2
set<int>::iterator it;//定义迭代器

1.2 set 的各种函数#

1
s.begin(); // 返回第一个元素的迭代器
2
cout<<*s.begin(); // 输出最小值

1
s.end(); // 返回最后一个元素的下一个的迭代器
2
set<int>::iterator it=s.end();
3
it--;
4
cout<<*it; // 输出最大值
5
cout<<*(s.end()-1); // 非法操作：set的迭代器不是一个数值，不能做减法。
6
// 因为set不支持下标访问，它是一棵树（堆）。
7
// 而it--是支持的。
8

9
//与vector和数组的排序比较
10
vector <int> a;
11
sort(a.begin(),a.end()); // end()不用加一
12
const int maxn=1e5;
13
int arr[maxn];
14
sort(arr,arr+maxn+1); // 需要手动加一

1
s.rbegin(); // 倒着的最后一个迭代器
2
// 所以输出最大值不用 end() ，可以写成：
3
cout<<*s.rbegin();

1
s.erase(5); // 把 s 中的 5 删除（值）
2
s.erase(s.upper_bound(5)); // 删除第一个大于5的元素（迭代器）
3
s.erase(s.begin()); // 把 s 中的最小值删除（迭代器）
4
s.erase(*s.begin()); // 把 s 中的最小值删除（值，等价于上面一行）

1
set<int>::iterator it = s.find(3);
2
//如果有 3 就返回 3 的迭代器，否则返回 s.end() 。

1
s.count(3);
2
// 返回s中有几个3
3
// 注意：返回值只会是 0 或 1 ，因为 set 会自动去重！
4
// 所以 find 可以代替 count ，因为 find 还可以返回迭代器，比 count 更好！

1
// 其他函数
2
s.insert();
3
s.size();
4
s.clear();
5
s.lower_bound(); // 大于等于
6
s.upper_bound(); // 严格大于

set 可当作“双端去重优先队列”用，因为内部是从小到大排序的。

2 multiset#

2.1 定义方式#

真正的“双端优先队列”。

1
muiltiset<int>ms; // 可重集合

2.2 内建函数#

1
ms.count(3); // 返回 3 的出现次数
2
ms.erase();
3
// erase() 函数，如果传入一个值，会删掉所有这个值的元素；
4
// 如果传入一个迭代器，那么只会删去这个迭代器的元素。

其它函数和 set 一样，不过多赘述。

3 map#

3.1 基础知识#

1
map<int,int>m;
2
m.insert({5,6}); // 等价于 m[5]=6;
3
m.insert({5,7}); // 等价于 m[5]=7;
4
cout<<m.count(5)<<endl; // 输出 1 ，因为已经被覆盖了
5
cout<<m.count(6)<<endl;
6
if(m[6]==0){
7
  cout<<"没有6"<<endl;
8
}
9
if(m.count(6)){
10
  cout<<"有6"<<endl;
11
}

想一想：上面的代码会输出 有6 还是 没有6 呢？

正确输出为：

注意，在执行第6行引用了 m[6] ，此时 map 会自动为 m[6] 对应一个 0 ，所以在下面的代码中出现了 {6,0} 的键值对。

3.2 lower_bound()#

1
// map 的 lower_bound() 方法
2
map<int,int>m;
3
m[10]=20;
4
m[12]=7;
5
m[7]=6;
6
map<int.int>::iterator it=m.lower_bound(8); // 找到第一个键值大于 8 的
7
cout<<it->fisrt<<" "<<it->second<<endl; // 与下面的等价
8
cout<<(*it).first<<" "<<(*it).second<<endl;
9
// 注意：不能使用 *it.first ，会报错，因为 * 的优先级比 . 低，而 first 没有 * 操作。

4 默认数据类型小讲堂#

1
1
2
1ll
3
1ull
4
1<<10
5
1<<40ll // 爆掉，因为对 int 左移

1
cout<<10000000000<<endl;
2
// 输出 10000000000，而没有爆 int ，因为 c++ 会在你写下数字的时候自动选择数据类型
3

4
cout<<1000000*1000000<<endl;
5
// 会爆掉
6

7
cout<<1000000ll*1000000<<endl;
8
// 不会爆掉

5 比较大样例输出正确性#

5.1 使用 Hash#

Terminal window

1
certutil -hashfile <filepath>

这能得到两个文件的哈希值。

注意行末的换行，如果你的程序输出文件比大样例多/少了一个换行，哈希值也会完全不一样。

5.2 使用 fc 命令#

Terminal window

1
fc <filepath1> <filepath2>

如图：

image.png

6 位运算#

lowbit(x) = x & -x;
全排列 x 的二进制子集：

1
for(int i=x;i;i=x&(i-1)){
2
  cout<<i<<endl;
3
}

7 排序#

7.1 常见的排序#

冒泡排序（ nnn 趟，每趟从前往后，当前大就交换相邻）
计数排序（排结构体时，用邻接表限制插入排序，稳定）
选择排序（每次找到最大的，从很远的位置换过来，不稳定）
插入排序（复杂度 O(N2)O(N^2)O(N2) 无法优化；但省内存；反冒泡，稳定）

1
// 插入排序示例
2
for(int i=1;i<=n;i++){
3
  for(int j=i;j>=2;j--){
4
    if(a[j]>a[j-1]){
5
      swap(a[j],a[j-1]);
6
    }
7
  }
8
}

快速排序（分治，用了分治的思想，不能说用了递归的思想；时间复杂度不稳定，排序不稳定）
归并排序（分治，稳定， O(nlogn)O(nlogn)O(nlogn) ，时间复杂度也稳定）
基数排序（优先级低到高，从个位、十位到百位……排序， O(nlgn)O(nlgn)O(nlgn) ，基于计数排序，稳定）
桶排序（分成一些范围的桶，如110，1120……，然后对每个桶内再进行排序，👎）
堆排序（不稳定）
希尔排序（不稳定，👎）

7.2 关于比较次数#

求最大/小值： n−1n-1n−1 次。
冒泡排序/选择排序：第 iii （从 1 开始计数）趟比较 n−in-in−i 次。
通常代值 111, 222 。

8 存图 - 链式前向星#

优点：常数更小

以下代码转自 https://blog.csdn.net/sugarbliss/article/details/86495945 ：

1
#include<bits/stdc++.h>
2
using namespace std;
3
const int maxn = 1005;//点数最大值
4
int n, m, cnt;//n个点，m条边
5
struct Edge
6
{
7
    int to, w, next;//终点，边权，同起点的下一条边的编号
8
}edge[maxn];//边集
9
int head[maxn];//head[i],表示以i为起点的第一条边在边集数组的位置（编号）
10
void init()//初始化
11
{
12
    for (int i = 0; i <= n; i++) head[i] = -1;
13
    cnt = 0;
14
}
15
void add_edge(int u, int v, int w)//加边，u起点，v终点，w边权
16
{
17
    edge[cnt].to = v; //终点
18
    edge[cnt].w = w; //权值
19
    edge[cnt].next = head[u];//以u为起点上一条边的编号，也就是与这个边起点相同的上一条边的编号
20
    head[u] = cnt++;//更新以u为起点上一条边的编号
21
}
22
int main()
23
{
24
    cin >> n >> m;
25
    int u, v, w;
26
    init();//初始化
27
    for (int i = 1; i <= m; i++)//输入m条边
28
    {
29
        cin >> u >> v >> w;
30
        add_edge(u, v, w);//加边
31
        /*
32
        加双向边
33
        add_edge(u, v, w);
34
        add_edge(v, u, w);
35
        */
36
    }
37
    for (int i = 1; i <= n; i++)//n个起点
38
    {
39
        cout << i << endl;
40
        for (int j = head[i]; j != -1; j = edge[j].next)//遍历以i为起点的边
41
        {
42
            cout << i << " " << edge[j].to << " " << edge[j].w << endl;
43
        }
44
        cout << endl;
45
    }
46
    return 0;
47
}
48
/*
49
5 7
50
1 2 1
51
2 3 2
52
3 4 3
53
1 3 4
54
4 1 5
55
1 5 6
56
4 5 7
57
*/

展开收起

9 概率与期望#

打靶问题： nnn 个靶子，每个靶子给一个命中概率 a[i]a[i]a[i] （表示 a[i]a[i]a[i] 分之一，问期望多少次能够连续命中 nnn 个靶子。

1
for(int i=1;i<=n;i++){
2
  ans[i]=(ans[i-1]+1)*a[i];
3
  // 走到第 i 个靶需要付出代价
4
}

打靶问题2： nnn 个靶子，每个靶子给一个命中概率 a[i]b[i]\frac{a[i]}{b[i]}b[i]a[i] ，问期望多少次能够连续命中 nnn 个靶子。

1
for(int i=1;i<=n;i++){
2
  ans[i]=(ans[i-1]+1)*b[i]*inv[a[i]];
3
  // 走到第 i 个靶需要付出代价
4
}

搭建es和scrapy

Thu, 04 Aug 2022 00:00:00 GMT

0 前言#

本期目标：在树莓派上搭建搜索引擎。

1 搭建Scrapy框架#

1.1 检查Python与Pip#

您应该确保您的主机上已经安装了Python与Pip。其中，Pip的安装命令如下：

Terminal window

1
sudo apt install python3-pip

请自己适应版本。

1.1 Pip的换源工作#

如果您觉得您当前使用的pip源下载速度可以的话，可以不用更改。

修改 ~/.pip/pip.conf （若没有改文件或目录，创建一个即可），改成以下内容（清华源）：

1
[global]
2
index-url = https://pypi.tuna.tsinghua.edu.cn/simple

1.1.1 没有目录的话……#

请执行以下命令：

Terminal window

1
cd ~
2
mkdir .pip
3
cd .pip
4
nano pip.conf

然后进入nano，粘贴进上面的东西，最后Ctrl+O，Ctrl+X保存并退出即可。

image.png

1.2 安装scrapy-pip#

Terminal window

1
pip install scrapy

然后等待安装好就行了。

image.png

1.3 安装scrapy-py#

不知道为什么用pip安装之后不能使用scrapy。那么再用apt安装一次。

Terminal window

1
sudo apt install python3-scrapy

遇到提示框输入y再回车即可。这个安装会比pip慢很多，耐心稍微等一下。

1.4 验证安装#

Terminal window

1
scrapy bench

image.png

如果输出类似下面图片所示的信息就说明安装成功了（它已经在爬取数据了）。

按 Ctrl+C 退出。

2 安装Java#

整理自：https://mirrors.tuna.tsinghua.edu.cn/help/adoptium/。

下面我们假设您使用的是Debian/Ubuntu系统。如果不是，那就请按照上面的链接里面的内容操作。

如果下面的内容出现了权限错误，请尝试使用sudo执行，或使用sudo -s切换到管理员模式。

2.1 安装依赖#

Terminal window

1
apt-get update && apt-get install -y wget apt-transport-https

2.2 信任 GPG 公钥:#

Terminal window

1
wget -O - https://packages.adoptium.net/artifactory/api/gpg/key/public | sudo tee /etc/apt/keyrings/adoptium.asc

2.3 随后执行以下命令来添加 apt 存储库#

Terminal window

1
echo "deb [signed-by=/etc/apt/keyrings/adoptium.asc] https://mirrors.tuna.tsinghua.edu.cn/Adoptium/deb $(awk -F= '/^VERSION_CODENAME/{print$2}' /etc/os-release) main" | sudo tee /etc/apt/sources.list.d/adoptium.list

2.4 更新#

Terminal window

1
sudo apt-get update

2.5 安装#

我们需要使用的是JDK18。

Terminal window

1
sudo apt-get install temurin-18-jdk

2.6 验证#

Terminal window

1
java -version

输出：

image.png

安装成功。

3 Elasticsearch的安装#

3.1 下载#

首先进入官网https://www.elastic.co/cn/downloads/elasticsearch，下载合适的版本。

注意要下载的应该是一个压缩文件，不要下载安装包！

如笔者所选的 Linux arm64 架构：

image.png

右键复制下载地址，然后在服务器里执行：

Terminal window

1
wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-8.3.3-linux-aarch64.tar.gz

其中，请把命令后面的一长串链接改成你复制来的链接。

然后解压（同样，请将文件名改成您下载来的文件名）：

Terminal window

1
tar -zxvf elasticsearch-8.3.3-linux-aarch64.tar.gz

3.2 启动#

切换目录：请将cd目录时的目录版本号改成适合您的：

Terminal window

1
cd elasticsearch-8.3.3/
2
./bin/elasticsearch

当出现这些信息的时候就是启动好了，此时应用会使用9200端口。如果需要，记得开放安全组。

image.png

请及时保存一下这些密钥数据！

3.2.1 可选配置-小贴士#

如果您想把 Elasticsearch 作为一个守护进程在后台运行，那么可以在后面添加参数 -d ：

Terminal window

1
./bin/elasticsearch -d

您还可以使用最新版本的宝塔面板来守护Java进程。

3.3 验证#

执行命令：

Terminal window

1
curl 'http://localhost:9200/?pretty'

如果出现这样的报错：

image.png

是因为ES8开启了ssl认证，我们需要把它关掉。

首先进入 /elasticsearch-8.3.3/config 目录，再修改 elasticsearch.yml 文件。

找到这里：

image.png

将 true 改成 false ，保存：

image.png

然后重新启动ElasticSearch。

再次执行上面的命令，你就能得到：

1
{
2
  "name" : "localhost",
3
  "cluster_name" : "elasticsearch",
4
  "cluster_uuid" : "KVhgIWuSQT-J1oUy8kMa5w",
5
  "version" : {
6
    "number" : "8.3.3",
7
    "build_flavor" : "default",
8
    "build_type" : "tar",
9
    "build_hash" : "801fed82df74dbe537f89b71b098ccaff88d2c56",
10
    "build_date" : "2022-07-23T19:30:09.227964828Z",
11
    "build_snapshot" : false,
12
    "lucene_version" : "9.2.0",
13
    "minimum_wire_compatibility_version" : "7.17.0",
14
    "minimum_index_compatibility_version" : "7.0.0"
15
  },
16
  "tagline" : "You Know, for Search"
17
}

展开收起

安装成功了。

重学ST表

Fri, 29 Jul 2022 00:00:00 GMT

ST表能做什么？#

预处理并 O(1)O(1)O(1) 求出区间最大/最小值（也就是 RMQ, Range Maximum/Minimum Query ）。
区间 GCD 问题。
区间按位和/或。

而以上这些，都有一个特性：一个值对于好几段包含自己的区间都会有贡献。这一类题大多都可以用ST表解决。

ST表的实现？#

我们以 P3865 【模板】ST 表为例，讲述一下ST表是如何实现 O(1)O(1)O(1) 地求出静态区间最大值的。

原题样例：

1
9 3 1 7 5 6 0 8

推导方程#

我们令 st[i][j]st[i][j]st[i][j] 表示原序列中第 iii 个数字起（含）往后 2j2^j2j 个，也就是原数组 a[i]a[i]a[i] 到 a[i+2j−1]a[i+2^j-1]a[i+2j−1] （两边都含）的区间最大值。显然，对于单个的 a[i]a[i]a[i] 的区间的最大值就是 a[i]a[i]a[i] 本身。而这一段区间的长度为 1=201=2^01=20 。所以我们可以得到 st[i][0]=a[i]st[i][0]=a[i]st[i][0]=a[i] 。

然后我们继续初始化st表。我们要先定下来区间长度 2j2^j2j ，再枚举第 iii 个数（为什么要这样的顺序呢？请往下看）。现在我们想要得出 st[i][j]st[i][j]st[i][j] ，也就是 a[i]a[i]a[i] 到 a[i+2j−1]a[i+2^j-1]a[i+2j−1] 的区间最大值，应该由哪些 ststst 转移过来呢？答案是 st[i][j−1]st[i][j-1]st[i][j−1] 和 st[i+(1<<(j−1))][j−1]st[i+(1<<(j-1))][j-1]st[i+(1<<(j−1))][j−1] 。为什么呢？

对于一个区间，如果它的长度为 2=212=2^12=21 ，那么它就由两个长度为 111 的区间得来（因为区间为 111 的 ststst 早就处理好了）。长度为 4=224=2^24=22 ，是由两个长度为 222 的区间得来的。以此类推，我们发现只要把当前区间对半分，就能推导出当前区间的值了。原因很简单，我们的st表的第二位是 2j2^j2j ，这也决定了它是由一个一个的 222 累积起来的结果。

我们已经知道了上一个区间的长度是 2j−12^{j-1}2j−1 ，也就是 ststst 数组的第二维是 j−1j-1j−1 。下面我们来推导第一维是几。例如，对于 [1,4][1, 4][1,4] 这个区间，两个子区间是 [1,2][1, 2][1,2] 和 [3,4][3, 4][3,4] 。可以知道较大的那个区间的左端点是 333 ，这是大区间的左端点加上区间长度的一半得到的，也就是 i+2j−1i+2^{j-1}i+2j−1 。由于st表只需要知道左端点和区间长度即可，那么两个 ststst 分别是 st[i][j−1]st[i][j-1]st[i][j−1] 和 st[i+(1<<(j−1))][j−1]st[i+(1<<(j-1))][j-1]st[i+(1<<(j−1))][j−1] 。

注意，1<<k=1k1<<k=1^k1<<k=1k ，这应该不难理解。下面是对于每个 ststst 转移的代码：

1
st[i][j]=max(st[i][j-1],st[i+(1<<(j-1))][j-1]);

现在也解答了两层循环遍历顺序的问题。假使我们一定要先枚举第一维 iii ，对于每一个 a[i]a[i]a[i] 计算它在某个区间内的贡献。然而这个区间是往后的，也就是说， a[i]a[i]a[i] 以后的 ststst 全没有处理好，也就无法递推了。

循环条件#

第一层循环：枚举 jjj ，范围： 2≤len=2j≤n2 \leq len = 2^j \leq n2≤len=2j≤n ，即 1≤j≤log2n1 \leq j \leq log_2{n}1≤j≤log2n （由于 st[i][0]st[i][0]st[i][0] ，就是长度为 111 的情况已经得知了，不用再来一遍）。
第二层循环：枚举 iii ，即考虑当前 a[i]a[i]a[i] 对于 jjj 所规定的区间的贡献。由于长度为 2j2^j2j ，所以 1≤i1 \leq i1≤i 且 i+[1<<(j−1)]≤ni+[1<<(j-1)] \leq ni+[1<<(j−1)]≤n 。刚才不是说长度为 2j2^j2j 吗？那为什么不是 i+(1<<j)i+(1<<j)i+(1<<j) 呢？因为st表要把 aaa 中末尾几个数字也要考虑进去。那么我们只需满足推导方程中数组中的条件 st[i+(1<<(j−1))][j−1]st[i+(1<<(j-1))][j-1]st[i+(1<<(j−1))][j−1] 即可。

以上理解似乎有些问题，有待改进。

区间查询#

现在已经完成了预处理，要来进行查询了。给定区间 [l,r][l, r][l,r] ，要求其中的最大值。如果这个 [l,r][l, r][l,r] 恰好是 ststst 中已有的区间，那最好了，直接输出。若 [l,r][l, r][l,r] 的长度恰好不是 2j2^j2j 的整区间呢？那就要把这个区间再分成两块。可是，即使是这样也不能保证这两个被分出来的区间的长度是 2j2^j2j 。既然我们不能恰好分，那就让这两个区间有所重叠吧。于是我们得到了查询函数：

1
int solve(int l,int r){
2
    return max(st[l][(int)log2(r-l+1)],st[r-(1<<int(log2(r-l+1)))+1][(int)log2(r-l+1)]);
3
}

这里应该不难理解。下面给出完整代码。

P3865 AC Code#

1
#include <bits/stdc++.h>
2
using namespace std;
3
inline int read()
4
{
5
  int x=0,f=1;char ch=getchar();
6
  while (ch<'0'||ch>'9'){if (ch=='-') f=-1;ch=getchar();}
7
  while (ch>='0'&&ch<='9'){x=x*10+ch-48;ch=getchar();}
8
  return x*f;
9
}
10
const int maxn=1e6+5;
11
int n,m;
12
int a[maxn];
13
int st[maxn][(int)log2(maxn)+1];
14
int l,r;
15
int solve(int l,int r){
16
    return max(st[l][(int)log2(r-l+1)],st[r-(1<<int(log2(r-l+1)))+1][(int)log2(r-l+1)]);
17
}
18
int main(){
19
    n=read(),m=read();
20
    for(int i=1;i<=n;i++){
21
        a[i]=read();
22
        st[i][0]=a[i];
23
    }
24
    for(int j=1;j<=log2(n);j++){
25
        for(int i=1;i+(1<<(j-1))<=n;i++){
26
            st[i][j]=max(st[i][j-1],st[i+(1<<(j-1))][j-1]);
27
        }
28
    }
29
    while(m--){
30
        l=read(),r=read();
31
        cout<<solve(l,r)<<"\n";
32
    }
33
    return 0;
34
}

展开收起

T244841 分配学号题解

Sun, 24 Jul 2022 00:00:00 GMT

原题传送门（鸡尾酒的原创题！请谨慎转载）#

题目描述#

给定一些数，其中有一些相同的数字，现在需要修改其中的一些数字（只增不减），并且使得修改后所有数字的总和减去原来所有数字的总和最小，求按这样的要求修改有多少种不同的方式。

思考#

要想知道怎样修改，我们就要先知晓最终的答案是那几个数。让我们来观察几组样例寻找规律。

请注意，这里的样例中的数字都是从小到大给出的，便于后续的观察与计算。然而题目中可没有保证数据一定是递增的！

样例 1#

显而易见，最终的学号应该变为 1 2 3 。

样例 2#

最终的学号应该变成 1 2 3 4 5 。到这里，我们似乎找到了一些规律：假设有 nnn 个数，最终的序列必定是 1, 2, 3, ..., n-1, n 。真的是这样吗？让我们来看下一个样例。

样例 3#

请注意，该样例仅仅在 样例1 后面加上了两个数。按照刚才的出来的结论，最终的序列是 1 2 3 4 5 吗？显然不是。虽然 1 1 2 能变成 1 2 3 ，但是 7 7 并不能成为 4 5 ，因为数字只增不减。对于这种特殊情况，我们不妨称之为“断点”。当出现断点时，原本的递增序列的当前值小于该位置的真实值（断点的定义）。在断点处，我们需要重新开始计算一段序列。就比如在 2 和 7 之间就是一个端点。前三个数字的 1 2 3 没有问题，但是从 7 开始，序列就应该变成 7 8 。我们可以简单归纳为，“基数”从 1 变成了 7 。

再来明确一点：对于每一个断点分开的区间，其最终形成的理想序列仅适用于当前区间。如 样例3 中，前一段 1 1 2 只可能变成 1 2 3 ，具体哪个数字变成哪一个无所谓，但是不能有任意一个变成 7 8 ，不然后面的两个数字就不能完全满足其变化的需求了。

有了这些铺垫，让我们来计算答案。

使用乘法原理#

现在我们仅来关注一个区间。来看样例：

我们都知道，最终的序列会变成 1 2 3 。那么，如何计算其中的方案数呢？

学过1+1的同学都知道，要计算乘法原理，我们要先从条件苛刻的数字算起。对于第一个数字 1 ，可以变成 1 、 2 或 3 ，有两种方案；第二个数字亦是如此。至于第三个数字 2 ，我们只能将其变成 2 或 3 ，只有两种方案。所以第三个数字 2 的条件比较苛刻。我们从 2 算起。现在 2 选走了一个数字，前面两个 1 就各剩下两种和一种。于是最终的方案数就是各个数字的方案数的乘积，也就是 2×2×1=42 \times 2 \times 1 = 42×2×1=4 。

对于每一个数，它的方案数就是它与“基数”的差加上1。这样我们就能一路乘过去了。

对于每一个区间，利用如上的算法。那么最终的终极答案就是每一个区间的乘积了。下面让我们用代码来实现这一过程。

代码实现#

首先最重要的一步，排序！！！别忘了我们之前一切推导都是建立在递增序列的基础上。

1
sort(a+1,a+1+n);

其次，让我们定义一个 last_max ，变量，用来记录基数以及当前的变化值。
- 如果当前值在 last_max 的承受范围内，即 a[i]≤lastmax+1a[i] \leq last_max + 1a[i]≤lastmax+1 ，则让 last_max 自增 111 ，随后答案乘上 lastmaxlast_maxlastmax ；
- 如果当前值超过了 last_max 的承受范围，说明这里出现了一个“断点”，则更新 last_max 的值为 a[i]a[i]a[i] 。
在解答过程中别忘了取模。

AC Code#

1
#include<bits/stdc++.h>
2
#define ll long long
3
using namespace std;
4
const ll mod=1e9+7;
5
ll n,a[100010];
6
ll cnt=1;
7
ll last_max;
8
int main(){
9
  cin>>n;
10
  for(ll i=1;i<=n;i++){
11
    cin>>a[i];
12
  }
13
  sort(a+1,a+1+n);
14
  last_max=a[1];
15
  for(ll i=2;i<=n;i++){
16
    if(a[i]<=last_max+1){
17
      last_max++;
18
    }else{
19
      last_max=a[i];
20
    }
21
    cnt*=(last_max-a[i]+1)%mod;
22
    cnt%=mod;
23
  }
24
  cout<<cnt%mod<<endl;
25
  return 0;
26
}

展开收起

单调栈学习笔记

Sat, 23 Jul 2022 00:00:00 GMT

以洛谷 P5788 【模板】单调栈为例。

题目描述 - 单调栈的基本作用#

题目很简单：给定一个数列，求每一个数往后看第一个比它大的数是谁。

我们来看样例：

显而易见，对于第一个数字 1 ，第一个比它大的数字是 4 ，排在第二位；对于第二个数字 4 ，第一个比它大的数字是 5 ，排在第五位……以此类推。

深入理解单调栈#

下面让我们把数据可视化。

首先迈出关键一步：因为题目中要求的是向右边看第一个比当前高的，也就是说已知信息应该在当前的右边。所以我们要以从右向左的顺序来寻找规律。否则，本题将难以解决。

我们先来看最后一个 5 。因为这是我们第一个看的，其右边没有更多信息了，所以按题目输出为 0 。

看完 5 ，往左一个看到 3 。由于 3 比 5 小，所以输出为 5 （这是真实 5 的位置）。同理， 2 的输出为 4 （这是真实 3 的位置）。

现在我们已经看了 2, 3, 5 ，也就是数字 4 的后面有 2, 3, 5。现在看到了数字 4 。我们发现 4 往后看一个是 2 ，然而 4>24 > 24>2 ，所以 2 不是我们要找的数，丢掉；丢掉了 2 ，看到 3 ，由于 4>34 > 34>3 ，所以 3 也不是要找的数，丢掉；终于看到了 5 ，由于 4<54 < 54<5 ，所以 5 就是我们要找的数了。

让我们来思考最后一个数字 1 。显然，它的对应数就是 4 。如果把 1 改成 7 呢？如图：

由于我们已经丢掉了 4 后面所有小于 4 的数字，所以这些被丢掉的数字一定也小于 7 ，我们不用操心这些数字里是否有我们可能要寻找的数字。那么，我们再次进行“丢掉”操作，现在 7 后面的数字有 4, 5 （ 2, 3 已经被 4 丢掉了），而 4, 5 都小于 7 ，所以 4, 5 都被丢掉了，剩下了一个‘空’，所以 7 的答案变成了 0 。

让我们来重新审视一下整个过程：

从右往左看，如果后面的数字有比当前的数字小的，就丢掉；
丢到剩下面对的第一个比当前的大为止，这个数就是满足要求的。

这样一看，这似乎就是一个栈的操作，而且这个栈中的元素是单调递增或递减的。我们就将其称作单调栈。

来看看 OI-wiki 上对单调栈的定义：

顾名思义，单调栈即满足单调性的栈结构。与单调队列相比，其只在一端进行进出。

代码实现#

读入完后，我们需要：

从右往左看：

1
for(int i=n;i>=1;i--)

弹出栈中所有小于等于当前元素的：

1
while(!s.empty()&&a[i]>=a[s.top()]){
2
        s.pop();
3
}

获得当前答案：

1
ans[i]=(s.empty()?0:s.top());

将当前元素压入栈中：

1
s.push(i);

注意：输入输出应该使用 scanf ，否则会超时。

Full Code#

1
#include <bits/stdc++.h>
2
using namespace std;
3
const int maxn=3e6+10;
4
int n;
5
int a[maxn];
6
int ans[maxn];
7
stack <int> s;
8
int main(){
9
    cin>>n;
10
    for(int i=1;i<=n;i++){
11
        scanf("%d",&a[i]);
12
    }
13
    for(int i=n;i>=1;i--){
14
        while(!s.empty()&&a[i]>=a[s.top()]){
15
            s.pop();
16
        }
17
        ans[i]=(s.empty()?0:s.top());
18
        s.push(i);
19
    }
20
    for(int i=1;i<=n;i++){
21
        printf("%d ",ans[i]);
22
    }
23
    return 0;
24
}

展开收起

树状数组自学笔记

Wed, 20 Jul 2022 00:00:00 GMT

1 树状数组能解决什么问题？#

先看例题 P3374 【模板】树状数组 1 。对于一个数列，我们需要支持以下两个操作：

将某一个数加上 xxx ；
求出某区间每一个数的和。

对于这道题，如果用普通的方法暴力枚举，我们可能只会拿到70%的分数。然而如果利用树状数组，我们就能获得满分。可见：树状数组能够支持动态修改并查询前缀和，从而求出某区间的和。

2 树状数组的结构是怎样的？#

我们直接来5个点（点中的数字是编号，不是值）。

接下来，让我们建立一棵树。

以每两个节点作为叶子结点向上建立二叉树。

每一个橙色的节点就表示其所有字树的和。下面让我们为橙色节点也标上编号。特别地，对于节点1, 3 和 5，我们把它标记为特殊的橙色节点（原因以及标法下面会讲）。节点编号用二进制表示。

我们先约定，对于原数组，我们用数组 aaa 来储存；而橙色节点的数组我们用 bitbitbit 来储存（注意，有些并不是所有橙色节点都有编号。对于没有编号的橙色节点，我们就不用管它了）。

下面我们列出一些等式关系：

bit[001]=a[001]bit[001] = a[001]bit[001]=a[001]
bit[010]=a[001]+a[010]bit[010] = a[001] + a[010]bit[010]=a[001]+a[010]
bit[011]=a[011]bit[011] = a[011]bit[011]=a[011]
bit[100]=a[001]+a[010]+a[011]+a[100]bit[100] = a[001] + a[010] + a[011] + a[100]bit[100]=a[001]+a[010]+a[011]+a[100]
bit[101]=a[001]+a[010]+a[011]+a[100]+a[101]bit[101] = a[001] + a[010] + a[011] + a[100] + a[101]bit[101]=a[001]+a[010]+a[011]+a[100]+a[101]

很难发现规律？我们换个角度看。

对于 a[001]a[001]a[001]，它被包含在 bit[010],bit[100]bit[010], bit[100]bit[010],bit[100] 中；
对于 a[010]a[010]a[010]，它被包含在 bit[010],bit[100]bit[010], bit[100]bit[010],bit[100] 中；
对于 a[011]a[011]a[011]，它被包含在 bit[100]bit[100]bit[100] 中；
对于 a[101]a[101]a[101]，它被包含在 bit[101]bit[101]bit[101] 中。

如果把树画得大一点，可能会更容易地发现规律。而规律就是：对于任意一个 a[x]a[x]a[x]，每次取 xxx 的最低位并加上 xxx，就能一步一步地找到它所有的父亲。

是不是很神奇？我们拿 a[001]a[001]a[001] 来举个例子，加深理解。

首先，a[001]a[001]a[001] 的第一个父亲为 001001001 本身，是 bit[001]bit[001]bit[001]；
取到 001001001 的最低位的值 001001001，001+001=010001 + 001 = 010001+001=010，那么bit[010]bit[010]bit[010] 就是它的第二个父亲。
再然后，010+010=100010 + 010 = 100010+010=100，则 bit[100]bit[100]bit[100] 就是第三个父亲。

3 用代码实现单点修改#

了解了基本的树状数组的构造方式，让我们来实现原数组的单点修改。

我们知道，bitbitbit 数组存的是它下面所有孩子的和；相反地，若要修改一个 aaa 的值，就要修改它每一个父亲的值。而这就要用到上一章节中提到的如何遍历每一个父亲的方法。

3.1 怎样获得最小一位二进制的值？#

先给出结论：x & - x。这需要用到反码补码的知识。

首先，xxx 是一个二进制正整数。那么，−x- x−x 的原码就是把最高位的0变成了1，其反码就是最高位的1不变，剩下的所有数位取反。−x- x−x 的补码就是在反码的基础上加1。而 xxx 的补码与原码相同。那么，两者取与，最高位一个是1一个是0，变成了0；剩下的数位，假设 xxx 的原码最低位是1，那么 xxx 的补码最低位就是1，而 −x- x−x 的补码的最低位是0+1=1，而其他数位都恰好相反，所以前面的全部是0，只有最低位为1。类似地，如果最低位不是1，那么负数的反码加上1后只有最低的那位会进位，使得只有这位和正数的补码与上后会变成1，其它都是0。

于是我们定义函数 lowbit：

1
int lowbit(int x){
2
  return x & -x;
3
}

它的作用是返回最低位的1的值。

3.2 实现遍历所有父亲节点并加上一个值#

首先，a[x]a[x]a[x] 的第一个父亲节点就是 bit[x]bit[x]bit[x]，这就是起点。
然后，我们将 xxx 每次加上 lowbit(x)lowbit(x)lowbit(x) （注意：lowbit(x)中的x是不断更新的x，而不是最开始的不变的x）x += lowbit(x); 。
对于每一个访问到的节点，都加上一个值 yyy bit[x] += y; 。
边界条件：当父亲节点编号 x>nx > nx>n 时（节点最多n个），退出循环 while(x <= n) 。

于是得到函数 change：

1
void change(int x, int y){
2
  while(x <= n){
3
    bit[x] += y;
4
    x += lowbit(x);
5
  }
6
}

change函数能将所有包含 x 的父亲加上 y。

OK，现在我们实现了第一个任务：动态修改区间和。下面我们要实现动态查询区间和。

4 查询区间和#

现在，给出任意的两个端点 [l,r][ l , r ][l,r]，要求出 a[l]+...+a[r]a[ l ] + ... + a[ r ]a[l]+...+a[r]，应该怎么做呢？

回想普通前缀和的做法，我们只要求出 pre[r]−pre[l−1]pre[ r ] - pre[ l - 1 ]pre[r]−pre[l−1] 即可。类似地，我们要利用树状数组求出区间和，就要写一个 query （查询）函数，来求出 a[1]+...+a[n]a[1] + ... + a[n]a[1]+...+a[n] 的值，相当于普通前缀和中 pre 的功效，从而就能轻松求出某一区间的和了。

4.1 实现 `query` 函数#

之前我们说过，要修改单点的值，就要遍历所有父亲，用的方法是 x += lowbit(x);。那如果是获取 a[1]+...+a[n]a[1] + ... + a[n]a[1]+...+a[n] 的值，是否也能用类似的方法呢？让我们把之前的图搬出来再来找找规律。

假设我们现在要获取 a[1]+a[2]+a[3]a[1] + a[2] + a[3]a[1]+a[2]+a[3] 的值。此时 n=011n = 011n=011 ，则 n−lowbit(n)=010n - lowbit(n) = 010n−lowbit(n)=010（既然修改时是加上lowbit，那么查询时就反一下，减去lowbit），恰好能得到 a[1]+a[2]a[1] + a[2]a[1]+a[2] 的和。如此一来，我们就能求出 1 n1 ~ n1 n 的区间和了。

1
int query(int x){
2
  int res = 0;
3
  while(x){
4
    res += bit[x];
5
    x -= lowbit(x);
6
  }
7
  return res;
8
}

注意边界条件：x应该大于0。

4.2 求出区间和#

之前说过，query 就相当于 pre，所以易得：

1
query(r) - query(l - 1)

这就是区间 [l,r][l , r][l,r] 的值了。

5 示例代码#

1
#include<cstdio>
2
#include<iostream>
3
using namespace std;
4
const int maxn=5e5+10;
5
int n,m;
6
int a[maxn];
7
int bit[maxn];
8
int k,x,y;
9
int lowbit(int x){
10
    return x & -x;
11
}
12
void change(int x,int y){
13
    while(x<=n){
14
        bit[x]+=y;
15
        x+=lowbit(x);
16
    }
17
}
18
int query(int x){
19
    int ans=0;
20
    while(x>0){//边界条件x>0!
21
        ans+=bit[x];
22
        x-=lowbit(x);
23
    }
24
    return ans;
25
}
26
int main(){
27
    cin>>n>>m;
28
    for(int i=1;i<=n;i++){
29
        scanf("%d",&a[i]);
30
        change(i,a[i]);//一开始都是0，要初始化加上a[i]
31
    }
32
    for(int i=1;i<=m;i++){
33
        scanf("%d%d%d",&k,&x,&y);
34
        if(k==1){
35
            change(x,y);//将第x个数加上y
36
        }else{
37
            printf("%d\n",query(y)-query(x-1));//求出区间和
38
        }
39
    }
40
    return 0;
41
}

展开收起

注意：请使用较快的输入输出，否则可能会超时。

6 FAQ#

为什么数组名称要叫做 bit ？答：因为树状数组的英文全称叫做 Binary Indexed Tree，简称 BIT。
树状数组的时间复杂度是多少？答：虽然树状数组和线段树的理论时间复杂度都是 O(log2n)O(log_2 n)O(log2n)，但是树状数组代码简单，实际时间复杂度会略低一些。
为什么能想到树状数组这样的数据结构？答：天才发明的，天知道。

安吉之行

Sat, 16 Jul 2022 00:00:00 GMT

CF1693B Fake Plastic Trees 题解

Fri, 15 Jul 2022 00:00:00 GMT

中文题意#

ttt 组数据，每组给定一个 nnn 个结点的树， 根为 111 ，给定 2,3,…,n2,3,\ldots ,n2,3,…,n 的父结点 p2,p3,…,pnp_2,p_3,\ldots ,p_np2,p3,…,pn 。再给出每个点权值 aia_iai 的范围 [li,ri][l_i,r_i][li,ri] 。

初始每个点的权值均为 000 。每次操作可以选择从 111 开始的树上路径 b1,b2,…,bkb_1,b_2,\ldots,b_kb1,b2,…,bk （不一定要在叶子处结束），将 abia_{b_i}abi 加上 cic_ici ，其中 {ci}\{c_i\}{ci} 是一个 非负单调非减 的整数数列。

问至少多少次操作，可以令所有点点权均在 [li,ri][l_i,r_i][li,ri] 范围内。

从最简单的情况开始#

我们把树简化成只有一条链，并且将每个点的最终范围也简化成一个定值。让我们根据这个情况造出以下样例：

graph 2.png

其中，根是1。题目要求我们从根开始到任意一点加上一个不严格递增的整数序列，显而易见，我们只需操作两次：

从根开始到4，加上1, 4。
从根开始到7，加上0, 0, 2, 3, 7。

由此可见，对于这种简单情况，最终操作的次数就取决于所谓的“瓶口”——后一个数小于前一个数的情况。因为我们的加上去的序列是连续递增的，所以当出现要求数字是递减时，就不得不让我们采取第二次行动。所以我们得出结论：操作次数等于链中后一个小于前一个的次数+1（这个1是最基本的操作次数，就是说即使这个链它全部直接是单调非减的，也要操作一次）。

如果是树呢？#

现在更进一步，我们假设这个链表成为了一棵树，但是任然地，要求最终的答案还是一个定值。让我们在上面的样例中添上几根枝条。

graph 3.png

想一想：在这种情况下，什么时候要使操作次数加一呢？

首先我们先确定，对于每一个叶子节点，都要至少操作一次，即上面所说的“基本地”加一。但是，对于任意一个有孩子的节点来说，如何确定其操作次数呢？让我们来观察下面两个不同的例子：

例1#

graph 6.png

在这棵树中，显然我们操作两次就够了，因为对于每一条枝，我们假设最差情况，让根和孩子都加上相同的孩子的值，这样孩子成为了理想数值，根能大于等于其理想数值。又因为我们可以随意调整减去的序列内容，所以可以让根加上的少一些，得到正确答案。

例2#

graph 5.png

这次仅将例1中的4改成了1。我们发现，如果按例1的思路，在两条路径上分别加上1, 1和2, 2，两个孩子是满足了，但根却只有3。此时我们需要再进行一次操作，让根加上2，成为5。

分析#

造成上面两个例子不同的原因是什么呢？不难发现，当孩子之和大于根时，我们能以孩子个数的操作次数解决问题。然而，当孩子之和小于根时，我们不能直接满足根的需求，还需要再对根单独进行一次处理。这就是对于这种情况得出的结论。

回到原题#

现在让我们再加上最后一个条件：将最终结果的定值改成一个区间。题目问的是最少几次操作，所以我们只需要想办法在之前树的基础上让答案最小。应该怎么做呢？在上一节中，我们已经得出了以下结论（请务必再看一遍）：

当孩子之和大于等于根时，操作次数不变；
当孩子之和小于根时，操作次数加一。

所以，想要让操作次数尽可能小，我们就要尽可能满足第一种情况，让操作次数不变。即，我们要让孩子之和尽可能大，才有可能大于根。下面就好办了。我们使用dfs，从叶子开始，让叶子先取到最大值（也就是右端点），然后逐层向上比较。如果当前根的孩子之和大于它本身范围内的任何一个值，即大于最小值（左端点），那么就能满足条件1；如果小于最小值，那么死马当活马医，反正操作次数要加1了，不如让当前根的值取最大，让再上面一层操作次数不变的可能性大一点。

AC代码展示#

1
#include <bits/stdc++.h>
2
#define int long long
3
using namespace std;
4
const int maxn=2e5+10;
5
int t,n;
6
int fa[maxn];
7
int l[maxn],r[maxn];
8
vector <int> G[maxn];
9
int ans=0;
10
int dfs(int step,int now){
11
    if(G[now].size()==0){
12
        ans++;
13
        return r[now];
14
    }
15
    int val=0;
16
    for(auto nxt:G[now]){
17
        val+=dfs(step+1,nxt);
18
    }
19
    if(l[now]<=val){
20
        // cout<<"val["<<now<<"]="<<val<<endl;
21
        return min(val,r[now]);
22
    }else{
23
        // cout<<"val["<<now<<"]="<<r[now]<<endl;
24
        ans++;
25
        return r[now];
26
    }
27
}
28
signed main(){
29
    cin>>t;
30
    while(t--){
31
        for(int i=0;i<maxn;i++){
32
            G[i].clear();
33
        }
34
        ans=0;
35
        cin>>n;
36
        for(int i=2;i<=n;i++){
37
            cin>>fa[i];
38
            G[fa[i]].push_back(i);
39
        }
40
        for(int i=1;i<=n;i++){
41
            cin>>l[i]>>r[i];
42
        }
43
        dfs(0,1);
44
        cout<<ans<<endl;
45
    }
46
    return 0;
47
}

展开收起

注意细节 需要开long long，否则会过不了第11个点。

10910^9109

1. 运动的描述

Tue, 29 Mar 2022 00:00:00 GMT

1 质点参考系

1.1 质点

定义：有些时候，颗粒忽略物体的大小和形状，把它当成一个只有质量的点。这个点，就是质点。（和几何上的点不同！）
特点：质点时人为创造的一个概念，是一种理想化（忽略次要因素，只关注主要因素）的思想。
条件：判断一个物体能不能被看作质点，要先看研究的问题是什么。没有影响就能，反之则不能。

2 时间位移

2.1 位置与位移

2.1.1 物体的位置

在一维空间（一条线）中描述位置：利用一维坐标系（有单位的数轴），正负号可以表示方向。
三要素：方向，距离，单位。

2.1.2 位移

如何描述位置的变化：距离+方向。
用一个物理量表示：位移l，可以用文字描述。
物理量的分类：
- 标量：只有数字；
- 矢量：有数字和方向。
位移的定义：从起点指向终点的有向线段。

2.1.3 位移与路程

路程和位移是两个不同的物理量，不能直接划等号。
位移的大小：从初位置到末位置的距离。
路程：轨迹的长度。
位移的大小不一定等于路程。
1. 单项直线运动：位移的大小=路程
2. 其他运动：位移的大小<路程

2.1.4 直线运动的位移

用坐标计算位移：末减初：Δx=x2-x1。
对于同一段运动，建立不同的坐标系，结果不一样。合适的方向，能使结果更简洁。

2.2 位移-时间图像

x-t图像

x-t图的横轴代表着时间，纵轴代表着位移。

3 位置变化快慢的描述——速度

3.1 速度

比较快慢：
- 过去，比较路程（×）
- 现在，比较位移（√）
速度=$位移/时间$
$$
v=\frac{Δx}{Δt}
$$

3.2 v-t图像

负数代表什么意思：与正方向相反。
速度大小等于图像上的点到x轴的距离。
v-t图像的信息：速度的大小和方向
v-t图像的描述
v-t图像的绘制：把信息转化成图像

4 速度变化快慢的描述——加速度

4.1 加速度

本质：变速运动中速度变化的过程。
$$
a=\frac{Δv}{Δt}
$$
加速度是描述速度变化快慢的一个物理量（物理意义）。
单位：$m/s^2$。
速度和加速度，没有直接关系。

4.2 用v-t图像求加速度

能算出加速度的大小和方向
1. 结果为正，和正方向相同
2. 结果为负，和正方向相反
能直观呈现加速度的大小和方向
1. 往上走，加速度是正的
2. 往下走，加速度是负的
3. 水平，加速度位0
4. 越陡峭，加速度越大（加速度等于斜率）
5. 大小不能比较数值，应比较绝对值。

C# WinForm 实战：随机点号器

Sat, 19 Mar 2022 00:00:00 GMT

Gitee上：https://gitee.com/diyanqi07/RandomCallUp

概要

在本文中，笔者整理了以下内容：

如何利用C#的随机数模块生成随机整数；
如何.NET6.0的特性进行await延时；
如何使用Tooltip；
利用技巧，让窗口内的所有元素都随窗口缩放；
读/写json文件；
限制文本框的输入为数字。

当然， ~~编程的生命在于复制粘贴~~ ，所以本文难免出现纰漏。笔者也不是专门学C#的，故小错误请大佬指出QWQ

正文

随机数

Random rd = new Random();//申明一个随机类
int rannumber = rd.Next(PublicValue.minnumber, PublicValue.maxnumber + 1);//生成随机数

warning 注意
Next函数中，第一个值是最小值（含），第二个值是最大值（不含）。

await特性

对于任何要使用await的函数，都应该在其外部申明子进程：

Task task = Task.Factory.StartNew(async () => //申明async
{
    //内部语句...
    for (double i = 0; i < PublicValue.loadtime; i += PublicValue.loaddelta)
    {
        await Task.Delay(100);
    }
});

但是，当您使用了Task子进程，您就无法直接访问源程序中的变量了。下面给出了解决方案：

Task task = Task.Factory.StartNew(async () => //申明async
{
    //内部语句...
    for (double i = 0; i < PublicValue.loadtime; i += PublicValue.loaddelta)
    {
        await Task.Delay(100);//await最大的作用莫过于使延时函数在执行语句块中真正延时生效了。这里的100单位是毫秒
        // do something...
    }
    //利用this.Invoke内部操作，直接访问源程序中的内容
    this.Invoke(new EventHandler(delegate
    {
        this.ranget.Text = "随机抽取!";
        this.ranget.Enabled = true;
        this.result.ForeColor = Color.Red;
    }));
});

warning 提示
await特性仅用于.NET6.0+。这意味着大部分平台都不能很好地兼容该特性，所以请谨慎使用。

Tooltip用法

ToolTip t = new ToolTip();//首先，创建一个ToolTip对象
//然后，设置该ToolTip的属性
t.ShowAlways = true;//是否显示
t.InitialDelay = 500;//多少时间后显示
t.AutoPopDelay = 0;//提示信息的可见时间
t.ReshowDelay = 500;//鼠标移动到另一个控件，间隔多少时间再显示

窗口内的元素全局缩放

#region 控件大小随窗体大小等比例缩放
        private float x;//定义当前窗体的宽度
        private float y;//定义当前窗体的高度
        private void setTag(Control cons)
        {
            foreach (Control con in cons.Controls)
            {
                con.Tag = con.Width + ";" + con.Height + ";" + con.Left + ";" + con.Top + ";" + con.Font.Size;
                if (con.Controls.Count > 0)
                {
                    setTag(con);
                }
            }
        }
        private void setControls(float newx, float newy, Control cons)
        {
            //遍历窗体中的控件，重新设置控件的值
            foreach (Control con in cons.Controls)
            {
                //获取控件的Tag属性值，并分割后存储字符串数组
                if (con.Tag != null)
                {
                    string[] mytag = con.Tag.ToString().Split(new char[] { ';' });
                    //根据窗体缩放的比例确定控件的值
                    con.Width = Convert.ToInt32(System.Convert.ToSingle(mytag[0]) * newx);//宽度
                    con.Height = Convert.ToInt32(System.Convert.ToSingle(mytag[1]) * newy);//高度
                    con.Left = Convert.ToInt32(System.Convert.ToSingle(mytag[2]) * newx);//左边距
                    con.Top = Convert.ToInt32(System.Convert.ToSingle(mytag[3]) * newy);//顶边距
                    int none;
                    Single currentSize;
                    if (!int.TryParse(this.result.Text, out none))
                    {
                        currentSize = (float)(System.Convert.ToSingle(mytag[4]) * newy*0.6);//字体大小
                    }
                    else
                    {
                        currentSize = (float)(System.Convert.ToSingle(mytag[4]) * newy);
                    }
                    //currentSize = ((float)((float) System.Convert.ToSingle(mytag[4]) * newy * 0.6));
                    con.Font = new Font(con.Font.Name, currentSize, con.Font.Style, con.Font.Unit);
                    if (con.Controls.Count > 0)
                    {
                        setControls(newx, newy, con);
                    }
                }
            }
        }
        private void Form1_Resize(object sender, EventArgs e)
        {
            float newx = (this.Width) / x;
            float newy = (this.Height) / y;
            setControls(newx, newy, this);
        }
1
    #endregion</pre>

  
   
  
   
  提示：本段代码也是从某博客直接粘贴过来的，但原链接我忘记了……或许您可以告诉我真相（（
  
   
  
   
  读/写JSON文件
  
   
  
   
  读json
  
   
  
   
  using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using Microsoft.Extensions.Configuration;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
public static string GetConnectionString(string value)
        {
            var configurationBuilder = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("config.json");
            IConfiguration config = configurationBuilder.Build();
            string connectionString = config[value];
            return connectionString;
        }
//使用：
resultnum = GetConnectionString(“maxnumber”);
resultstr = GetConnectionString(“maxstring”);

  
   
  
   
  对于上面的样例，我们假定有这样一个json文件：
  
   
  
   
  {
    "maxnumber":123,
    "maxstring":"123"
}
  
   
  
   
  那么，resultnum将会是数字类型的123，resultstr将会是字符串类型的123。
  
   
  
   
  写json
  
   
  
   
  写json的实质就是把json对象打包成字符串，然后储存字符串到文件即可。
  
   
  
   
  using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using Microsoft.Extensions.Configuration;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
1
            StreamReader reader = File.OpenText(&quot;config.json&quot;);
2
            JsonTextReader jsonTextReader = new JsonTextReader(reader);
3
            JObject jsonObject = (JObject)JToken.ReadFrom(jsonTextReader);
4
            jsonObject[&quot;minnumber&quot;] = minnumber;
5
            jsonObject[&quot;maxnumber&quot;] = maxnumber;
6
            reader.Close();
7
            string output = JsonConvert.SerializeObject(jsonObject, Formatting.Indented);
8
            File.WriteAllText(&quot;config.json&quot;, output);</pre>

  
   
  
   
  限制文本框输入为数字
  
   
  
   
  private void textBox2_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (!(e.KeyChar == '\b' || (e.KeyChar >= '0' && e.KeyChar <= '9')))
            {
                e.Handled = true;
            }
        }
  
   
  
   
  如上，只允许退格、0~9。

利用onenote-dump将OneNote笔记转换成markdown文件

Fri, 18 Mar 2022 00:00:00 GMT

最近在学线上课，用电脑记笔记再方便不过了。一开始，笔者使用的是OneNote，但操作麻烦，还有些BUG。在记完了第一章的笔记后，决定接下来使用markdown记笔记。于是，便有了下面将.one文件转换成.md文件的逝情。

本文用到的项目需要Python3环境，请预先安装好。

准备

进入上面的链接，下载这个项目。直链：https://codeload.github.com/HuimingPan/onenote-dump/zip/refs/heads/master。

在解压文件目录下执行命令安装依赖（当然，您可以切换pip版本）：

pip install -r requirements.txt

安装过程

耐心等待安装完就行。

过程

继续在这个根目录里操作。然后在终端输入以下命令：

python onenote-dump

其中，“notebook”——笔记本名；“output directory”——文档输出地址；比如：

python onenote-dump "Software Development Notes" C:\Temp\dump

输入命令后，程序会停顿一下

如果跳出来这样的窗口，点“允许访问”就行

在运行上述命令后，会打开一个浏览器页面，输入自己的Microsoft账号和密码，使脚本有权访问Onedrive中的有关笔记本。在第一次授权之后，可以不需要再次授权。

点“是”

笔记转换授权完成后，程序将会将你的笔记本转换承.md文件，并保存在处。

这样就行了！

Codeforces DP1400 题大赏

Thu, 17 Mar 2022 00:00:00 GMT

CF628B New Skateboard

大意

给定一个字符串，求其中能被4整除的字串数量。

思路

能被4整除的数字，其末两位数一定能被4整除。所以我们只需枚举末两位能被4整除的所有情况。对于每一个这样的两位数，其前面的所有组合都可以被4整除。而这两位数又分为两种情况：一种是个位数能被4整除。显然，这种情况意味着只能是这单个数字能被4整除，因为我们并不能保证前面的一位数字组合上这个数字能被4整除。另一种是两位数能被4整除，此时同样是任意的前面的数字与之组合能被4整除。下面给出这两种情况的解决方案：

如果当前数字本身就能被4整除，那么ans++；
如果（当前数字+前一个数字*10）能被4整除，则ans+=i（i为当前数字的下标）。因为对于每一个位置，都有其前面i个的连续组合。

那么只需利用for循环，遍历一遍字符串，就能轻易做出这道题目了。这道题并没有直接用上dp的状态转移方程，但确实有亿点点dp的推理思想。

AC代码

``` #include using namespace std; string s; long long ans=0; // int dp[300010]; //dp[i]表示到字符串的第i位为止能被4整除的字串的数量 bool check(int pos){ //获取s的第pos-1位到第pos位 string tmp = s.substr(pos-1,2); //将tmp转成数字 int num = int(tmp[0]-'0')*10+int(tmp[1]-'0'); //如果num%4==0，则返回true if(num%4==0) return true; else return false; } int main(){ cin>>s; int n=s.size(); for(int i=0;i

CF189A Cut Ribbon

大意：

给一长度为n的缎带，要求将其剪成若干长度为a,b,c的缎带，且缎带数量尽可能多。求这个最大值。注意，这里的缎带必须全部用a,b,c的长度剪且要刚好剪完。

思考

lls尝云：“dp的状态类似于dfs的参数。” 所以，如果直接定义dp的状态有困难，不如先思考用dfs如何解决这个问题。如果要用dfs解决这个问题，我们肯定要遍历选择到了第几个缎带，并枚举剪了几个当前的缎带。这样一来，就类似于完全背包，我们还能用一维数组空间压缩。只需输出dp[m]即可。

AC Code & Comments

``` #include using namespace std; int dp[4010];//dp[i]表示装了i个空间的背包最大价值 int n,w[5]; int main(){ cin>>n>>w[1]>>w[2]>>w[3]; memset(dp,-1,sizeof(dp)); dp[0]=0; for(int i=1;i<=3;i++){//枚举放第几个 for(int j=w[i];j<=n;j++){//枚举放的价值 //dp[j]由dp[j-w[i]]+w[i]算出来 if(dp[j-w[i]]!=-1)//如果dp[j-w[i]]没有计算过，则dp[j]也不会被计算 dp[j]=max(dp[j],dp[j-w[i]]+1); } } cout<

CF1178B WOW Factor

翻译

给定一个只含“v”和"o"字符串s(长度最大为$10^6$) 求字符串中有多少个wow（一个“w”即为连续的两个“v”）。

分析

对于任意的一个wow，都是由vv...o...vv组成的。所以，当遇到vv时，就令vv的计数器++；当遇到o时，就令vvo的计数器+==vv；当再次遇到vv时，令vvovv的计数器+=vvo（这部操作可以合并到上面的vv，没有冲突）。其思路来源于下面这题：

代码

``` #include using namespace std; long long v,vv,vvo,vvov,vvovv; string s; int main(){ cin>>s; for(int i=1;i

CF691B s-palindrome

这道题和dp似乎没有半毛钱关系。略去。

CF698A Vacations

题目大意

Vasya有n天的假期每天有四种选择：

0.在这一天，健身房关闭，比赛不进行；

1.在这一天，健身房关闭，比赛进行；

2.在这一天，健身房是开放的，比赛不进行；

3.在这一天，健身房是开放的，比赛是进行的。

在每一天，Vasya可以休息，比赛(如果在这一天进行)，或者做运动(如果健身房在这一天是开放的)。

但Vasya不想连续两天做同样的活动：这意味着，他不会连续两天做运动，也不会在连续两天写比赛。

找出Vasya休息的最少天数

解题过程

由题意不难得出，本题共有三个要素：

第几天

做什么

休息天数

其中，休息天数是所要求的答案。故dp的状态设计正好是两个：dp[i][j]表示第i天做j活动的最多工作（这里我们定义工作，便于理解，当然也可以最少休息天数）天数。j={1,2,3}，表示比赛，健身，与休息。

定义边界

根据我们的定义，当还未开始，即天数为0时，dp[0][j]=0，即没有休息。

状态转移方程

枚举每一天的情况。对于第i天，我们有下列转移方程：

当今天是比赛或休息，则明天可以是健身。否则明天健身的状态不存在。

``` if(a[i]==2||a[i]==3){ dp[i][1]=max(dp[i-1][2],dp[i-1][3])+1; }else{ dp[i][1]=INT_MIN; } ```

当今天是健身或休息，则明天可以是比赛。否则明天比赛的状态不存在。

``` if(a[i]==1||a[i]==3){ dp[i][2]=max(dp[i-1][1],dp[i-1][3])+1; }else{ dp[i][2]=INT_MIN; } ```

在任何情况下，明天都可以休息。

``` dp[i][3]=max(dp[i-1][1],max(dp[i-1][2],dp[i-1][3])); ```

最终只需输出n-max(dp[n][1],max(dp[n][2],dp[n][3]))，即总天数减去最后一天是比赛、健身、休息中的工作最大值。

AC Code

``` #include using namespace std; int n; int a[105]; int dp[105][4];//表示到第i天为止进行某一项活动的最多不休息天数 //1:健身 2:比赛 3:休息 int main(){ cin>>n; for(int i=1;i<=n;i++){ cin>>a[i]; } dp[0][1]=dp[0][2]=dp[0][3]=0; for(int i=1;i<=n;i++){ if(a[i]==2||a[i]==3){ dp[i][1]=max(dp[i-1][2],dp[i-1][3])+1; }else{ dp[i][1]=INT_MIN; } if(a[i]==1||a[i]==3){ dp[i][2]=max(dp[i-1][1],dp[i-1][3])+1; }else{ dp[i][2]=INT_MIN; } dp[i][3]=max(dp[i-1][1],max(dp[i-1][2],dp[i-1][3])); } cout<

CF1195C Basketball Exercise

题目

给定一个 $2 \times n$ 的矩阵 $\{h\}$，现从中选择若干数，且任意两个数不上下或左右相邻，求这些数的和最大是多少？

思路

状态设计

显而易见，题目中有三个要素：第几列，选或不选选第几行，最大和。这里最大和是最终要求的答案，所以设计一个两维数组，dp[i][j]表示选到第i列、当前列选择的状态时的最大和。我们不妨定义：选第一行为1，第二行为2；不选为0。

边界

根据状态设计，可以看出，当还没选择，即选到第0列时，无论选择的状态为什么，最大和都为0。

状态转移方程

对于每一种不同的情况，我们都要分类讨论：

当这列不选，则可以从上一列的选第一行、选第二行或不选中转移，因为如果这列不选，无论如何都不会有相邻的。

当这列选第一行，则可以从上一列的选第二行或不选转移来。

第二行同理。

``` dp[i][0]=max(dp[i-1][1],max(dp[i-1][2],dp[i-1][0])); dp[i][1]=max(dp[i-1][0],dp[i-1][2])+a[i]; dp[i][2]=max(dp[i-1][0],dp[i-1][1])+b[i]; ```

AC代码

``` #include using namespace std; long long n; long long a[100005],b[100005]; long long dp[100005][3]; //dp[i]表示选到第i列时这次选第几行 (0代表这列没选) 和的最大值 int main(){ cin>>n; for(int i=1;i<=n;i++){ cin>>a[i]; } for(int i=1;i<=n;i++){ cin>>b[i]; } for(int i=1;i<=n;i++){ dp[i][0]=max(dp[i-1][1],max(dp[i-1][2],dp[i-1][0])); dp[i][1]=max(dp[i-1][0],dp[i-1][2])+a[i]; dp[i][2]=max(dp[i-1][0],dp[i-1][1])+b[i]; } cout<

CF1245C Constanze's Machine

题目大意

给定一个字符串，规定可以将字符串中的连续两个nn变成m，也可以把连续两个vv变成w。当然也可以不变。现在请你求出有多少个可能得到的字符串。

解题

这道题可以换个角度思考，不用dp来解。

首先不难看出，我们需要找出几个连续的vv块和nn块，然后把它们的可能数乘起来，就是最终的答案。

那么现在的任务就转化为：给出v...v块和n...n块的长度，算出它的方案数。

我们再来回顾一下所谓方案数的定义（计算规则，这里就统一用字母v来举例了）：对任意的一串字母v...v，将其中每两个v变成一个w，求能有几种最终可能。

下面给出一个例子（5个v）：

vvvvv

首先先考虑只变两个v的情况：

wvvv

vwvv

vvwv

vvvw

接着是变化四个v：

wwv

wvw

vww

这样一算，共有7种可能。

更一般地，推广到长度为n的“v序列”，我们枚举以下可能：

变化两个v：

wvvv...(n-2个v)

vwvv...

vvwv...

...w可以一次占有n-1个位置，一共有n-1种。

变化四个v：

wwv...(n-4个v)

wvw...

...一共有n-2种。

...

变化[n/2]个v（[]是取整符号，因为要考虑到当n是奇数，最后一个v不够变化两个）：

www...w(v)

一共有1种。

所以，显而易见，最终的情况就是(1+2+...+n-1)。

代码时注意

根据上面的解析，我们容易知道要使用斐波那契数列。此时请您预处理好fib数列。

请注意取模$10^9+7$。应当在fib数列预处理中就要进行。

AC Code

``` #include using namespace std; string s; long long ans=1; long long fib[100005]; long long mod=1e9+7; long long solve(long long num){ return fib[num+1]%mod; } int main(){ //init fib fib[0]=0; fib[1]=1; for(int i=2;i<=100000;i++){ fib[i]=(fib[i-1]%mod+fib[i-2]%mod)%mod; } cin>>s; if(s.find("m")!=-1||s.find("w")!=-1){ cout<<0; return 0; } for(int i=0;s[i];i++){ if(s[i]=='u'){ long long now=i; while(s[i]&&s[i]=='u'){ i++; } ans*=solve(i-now)%mod; ans%=mod; i--; } if(s[i]=='n'){ long long now=i; while(s[i]&&s[i]=='n'){ i++; } ans*=solve(i-now)%mod; ans%=mod; i--; } } cout<

CF180C Letter

题意

给你一个字符串，我们每一次操作都可以将一个大写字母变成任意小写字母，当然同理也可以将小写字母变成任意大写字母，问最少操作多少次，能够使得字符串变成前边都是大写字母，后边都是小写字母。

答案

``` #include using namespace std; string s; int lower[500005],upper[500005]; int main(){ cin>>s; //计算从0~i(含)有多少个小写字母 if(s[0]>='a'&&s[0]<='z') lower[0]=1; else lower[0]=0; for(int i=1;i='a'&&s[i]<='z') lower[i]=lower[i-1]+1; else lower[i]=lower[i-1]; } lower[s.length()]=lower[s.length()-1]; //计算从n-1~i(含)有多少个大写字母 for(int i=s.length()-1;i>=0;i--){ if(s[i]>='A'&&s[i]<='Z') upper[i]=upper[i+1]+1; else upper[i]=upper[i+1]; } //计算答案 int ans=upper[0]; for(int i=0;i<=s.length();i++){ ans=min(ans,lower[i]+upper[i+1]); } cout<

高一数学第一章集合与常用逻辑用语笔记整理

Wed, 16 Mar 2022 00:00:00 GMT

集合的概念：把一些元素组成的总体叫做集合（set）（简称为集）。
元素用小写字母表示，集合用大写字母表示
集合相等：只要构成两个集合中的元素是一样的，则称这两个集合相等。
集合的三要素：确定性，互异性，无序性。
空集的表示方式：

如果a是集合A的元素，就说a属于A，用符号表示。
如果a不是集合A的元素，就说a不属于A，用符号表示。
数学中常用的数集及其记法：
1. 自然数集：
2. 正整数集：或
3. 整数集：
4. 负整数集：
5. 有理数集：
6. 负有理数集：
7. 实数集：
8. 正实数集：
9. 负实数集：
10. 复数集：

列举法：大括号，元素，逗号
描述法：竖线
1. {元素的属性|元素满足的条件}
2. 元素的属性：数字，坐标，点等
  1. 小写字母默认表示数字，xR可写可不写。
  2. 有序数对默认表示坐标。
  3. 大写字母默认表示点。

A包含于B：；称A是B的子集。
传递性：若，则。
Venn图：
1. 用一个圈表示一个集合。
2. 直观看出两个集合是否有包含关系。
空集和它本身，都是一个集合的子集。
真子集：如果集合A是集合B的子集，并且B中至少有一个元素属于A，那么集合A叫做集合B的真子集。
A真包含于B：⫋B
集合相等：如果A是B的子集，B是A的子集，那么A=B（集合元素完全相同）。
所有的空集都相等。

由集合A与集合B的所有公共元素构成的新集合，就叫做集合A与B的交集，记作A∩B。
A∩B={x|x∈A且x∈B}
性质：
1. A∩B=B∩A
2. A∩A=A
3. A∩

A∪B=B∪A
A∪A=A
A∪

B集合是A集合在全集U中的补集。
含有研究问题中所涉及的所有元素，称为全集。
研究数集时，常常用R作为全集。

把符号语言转换为图形语言。把韦恩图的各个部分编号。
图形和式子互相转化：关注每一个部分和集合之间的关系。

什么是命题：能判断真假的陈述句。
在客观上的存在的，但主观上不一定能判断出来。
命题的结构：研究对象+对研究对象的某种判断。

原命题：若p则q
逆命题：若q则p
否命题：若非p则非q
逆否命题：若非q则非p
逆否命题和原命题同真假（用集合证明）。

充分条件：“有我就够了”。“若p则q”是真命题，则p是q的充分条件。记作p=>q（推出）。
必要条件：“没我就不行”。q是p的必要条件。非q=>非p。
充要条件：能互相推出。“<=>”双箭头。

如果p=>q，则P是Q的子集。
小集合是大集合的充分条件。
否命题：若非p则非q
逆否命题：若非q则非p
逆否命题和原命题同真假（用集合证明）。

全称量词：“所有”“都”“任意一个”；
全程量词命题：研究对象全部符合。
存在量词：“某些”“存在”“有一个”；
存在量词命题：至少有一个符合，又叫特称命题。
“有些”=“至少一个”：如“有些质数是偶数”√。
任意：倒过来A
存在：反过来E

全称量词：“所有”“都”“任意一个”；
全程量词命题：研究对象全部符合。

[CSP-S 2021] 回文

Sun, 05 Dec 2021 00:00:00 GMT

原题传送门：P7915 [CSP-S 2021] 回文 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

kk

根据题意，第一次从a序列中取数字，要么拿最左边的，要么拿最右边的。这里以先拿最左边的为例，反之亦然。

例如样例中的数据4 1 2 4 5 3 1 2 3 5，先取出左边的4，放入b序列的第一个位置也就是b1中。

这时候，因为最终期望的b序列是回文序列，而b1被放置了a1，也就是4，于是b序列的最后一个数字也是4。

题目云云：1,2,…,n 分别各出现恰好 2 次。所以有且仅有一个不同于a1（例子中是4）的am使得am=a1。那么，这个am就会被放到b2n（b序列的最后一个）。

由于am是最后一个被取到的，所以在取am之前必须依次将am左右两边的的数字从外向内依次取出。

易知，依次取出数字可以用栈。于是将原序列中am的左右两边分开（不包括已经被取出的a1）：栈x1 2和栈y5 3 1 2 3 5。因为栈x在am左边，元素是从左往右拿，所以栈顶在最左侧；同理，栈y的栈顶在最右侧。

再回过来看a1。取出a1后，剩下可能取到的数字应在所有剩下数字中的开头与末尾（剩下数字指的是去除了a1和am后的序列），也就是a2与an（请先假定am不是a2也不是an）。倒过来思考，看向am。如果最后一个被取出的是am，那么倒数第二个被拿走的数字一定在am的相邻左边或右边，即a_m-1或a_m+1；也有可能我下面只取左边或只取右边，那么倒数第二个拿的就是a2或an。

而要组成回文，就要确保第二个拿的与倒数第二个拿的数字相同。再列出以下两个栈：

a2->a3->...->a_m-1 ； an->a_n-1->...a_m+1。

所以有以下几种情况：

a2=a_m+1
a2=a_m-1
an=a_m+1
an=a_m-1

当只存在一种情况时，把这两个相等的数字删除。显而易见，最终输出的答案应该分为正序和倒序的。对于从栈顶删除的，在答案正序的部分+L(从x栈删除)或R(从y栈删除)；对于从栈底删除的，在答案的倒序部分+ L(从x栈删除)或R(从y栈删除) 。这里不建议在操作的时候就将倒序部分转成顺序，而应该在最后，最终答案为正序+倒序的反转（也就是在操作的时候使倒序记录保持倒序，这样效率高）。

如果不存在上述四种情况之一，则表示无解；如有多种情况都同时满足，先选择位于x栈顶的数字，这样字典序最小。

最后，先对取a1进行讨论，若取a1的无解，再取an，同样操作。若还是无解，输出-1。

Dijkstra 入门

Sun, 05 Dec 2021 00:00:00 GMT

对于图论中最短路径的三种算法，我们可以总结为以下表格（m为边数，n为点数）：

算法	时间复杂度	功能	局限性
Dijkstra	O(mlogm)	寻找单源最短路	边权为正
Floyd	O(m³)	寻找多源最短路	无
SPFA	O(mn)	寻找单源最短路	边权为负

各最短路算法比较

接下来让我们来康康如何实现Dijkstra算法。

康康就康康

Dijkstra是寻找单源最短路的算法，即指定一个起点的最小值。所以我们需要先规定起点的点的标号为s，而终点的标号为e。

接着，我们再设dis[i]表示从s到i的最短路。显然，dis[s]=0，因为起点到自己本身的距离就是0；而我们要求的就是dis[e]。

下面，让我们来构造一个真实的例子（注意，Dijkstra可以处理无向图也可以是有向图）。

我们假定从1出发，走到6。

显然，对于和1相邻的点，我们可以先推出$dis[1]=0$，$dis[3]=1$，$dis[5]=5$。类似地，对于每一个确定了$dis$的点，都可以继续推出与其相邻的点的$dis$值。

那么根据上面的图，确定了$dis[5]=5$后，$dis[6]=dis[5]+2=7$；确定了dis[3]后，$dis[5]=dis[3]+2=3$……等等，dis[5]的值又被更新了一次。这意味着，如果先推dis[5]的相邻的点的话，其后面的推到都是错误的，因为如果从dis[3]推到dis[5]，dis[5]的值仅为3，说明了从1走到5的最小值并不是直接走到5，而是走到3再走到5。由此可见，对于一个已经确定dis的点，应该将其所有相邻的点的期望dis按从小到大排。优先算出期望dis最小的点。于是我们就需要用到优先队列，对于每个相邻的点记录下期望dis值并塞入队列（期望dis值即当前算出的dis值：$dis[next]=dis[now]+val$）。设置优先队列中期望dis值小的在队首，然后从队首一个个取出再塞进新的点即可，有点类似于广度优先搜索。于是$dis[next]=min(dis[next], dis[now]+val)$。这么一来，dis的初始值应全部设为无穷大。但不要忘记vis[s]=0！

一处优化

对于上方例子中的点3和点5被更新的问题，在经过改进后，不难发现5会先被点3的距离为3更新，此时一定是最优解。所以我们可以对于dis[now]!=now.val的直接跳过。

#include
   
using namespace std;
int n,m,s;
struct node{
int a,val;
bool operator < (node b) const{
return val>b.val;
}
};
vector

G[100010];
priority_queue

q;
int dis[100010];
int main(){
cin>>n>>m>>s;
int a,b,c;
for(int i=1;i<=m;i++){
cin>>a>>b>>c;
G[a].push_back({b,c});
}
q.push({s,0});
memset(dis,0x3f,sizeof dis);
dis[s]=0;
while(!q.empty()){
node now=q.top();
q.pop();
if(now.val!=dis[now.a])continue;
for(int i=0;i
<g[now.a].size();i++){ node="" nxt=“G[now.a][i];” if(dis[nxt.a]="">
dis[now.a]+nxt.val){
q.push({nxt.a,dis[now.a]+nxt.val});
dis[nxt.a]=now.val+nxt.val;
}
}
}
for(int i=1;i<=n;i++){
cout<
<dis[i]<<” ”;="" }="" return="" 0;="" }<="" re="">
1
    <p>
2
     <!-- /wp:enlighter/codeblock --></p>
3

4
   </dis[i]<<">
5
  </g[now.a].size();i++){>
6
 </node>
7
</node>

智力体验(?)

Sun, 12 Sep 2021 00:00:00 GMT

欢迎来到今天的智力体验。这意味着您将重新定义您的智力。

CF原题大赏

学习取模

题面

原题：

传送门：Problem - 1562A - Codeforces

You are given two integers $l$ and $r$, $l≤r$. Find the largest possible value of amodbamodb over all pairs $(a,b)$ of integers for which $r≥a≥b≥l$.

As a reminder, $a mod b$ is a remainder we get when dividing $a$ by $b$. For example, $26mod8=2$.

题目大意：

给您一个范围l和r，使得a和b在l到r的范围中且a mod b最大，输出该a mod b的值。

解题

对于任意的一个数a，要使a mod b尽可能大，容易得到b的值应为a÷2+1。
而现在b的范围已知，即b可以根据a的取值自由选择，那么应让a的取值尽量大，a mod b才会最大。

由上可知，我们需要对l和r的情况进行讨论。

当(r/2+1)≥l时，可以使得a取到最大值r，而b也可以取到a÷2+1的理想值。
当(r/2+1)＜l时，a可以是最大值r，但b能取到的最优解为l。此时答案为r mod l。

示例代码

#include
   
using namespace std;
int t;
int l,r;
int main(){
cin>>t;
while(t—){
cin>>l>>r;
if((r/2+1)>=l){
cout<<((r-1)/2)<
<endl; }else{="" cout<<r%l<<endl;="" }="" return="" 0;="" <="" re="">
1
 <p>
2
  <!-- /wp:enlighter/codeblock --></p>
3

4
 <p>
5
  <!-- wp:heading {"level":1} --></p>
6

7
 <h1>学习异或</h1>
8

9
 <p>
10
  <!-- /wp:heading --></p>
11

12
 <p>
13
  <!-- wp:paragraph --></p>
14

15
 <p>
16
  <s>
17
   好奇的宝宝
18
  </s>Bob又在搞事情了。</p>
19

20
 <p>
21
  <!-- /wp:paragraph --></p>
22

23
 <p>
24
  <!-- wp:heading --></p>
25

26
 <h2>题面</h2>
27

28
 <p>
29
  <!-- /wp:heading --></p>
30

31
 <p>
32
  <!-- wp:heading {"level":3} --></p>
33

34
 <h3>原题</h3>
35

36
 <p>
37
  <!-- /wp:heading --></p>
38

39
 <p>
40
  <!-- wp:paragraph --></p>
41

42
 <p>传送门：<a href="https://codeforces.com/contest/1567/problem/B">Problem - B - Codeforces</a></p>
43

44
 <p>
45
  <!-- /wp:paragraph --></p>
46

47
 <p>
48
  <!-- wp:quote --></p>
49

50
 <blockquote class="wp-block-quote">
51
  <p>Alice gave Bob two integers&nbsp;aa&nbsp;and&nbsp;bb&nbsp;(a&gt;0a&gt;0&nbsp;and&nbsp;b≥0b≥0). Being a curious boy, Bob wrote down an array of&nbsp;non-negative&nbsp;integers with&nbsp;MEXMEX&nbsp;value of all elements equal to&nbsp;aa&nbsp;and&nbsp;XORXOR&nbsp;value of all elements equal to&nbsp;bb.</p>
52

53
  <p>What is the&nbsp;shortest&nbsp;possible length of the array Bob wrote?</p>
54

55
  <p>Recall that the&nbsp;MEXMEX&nbsp;(<a href="https://vjudge.net/problem/description/163581?1631434219000">Minimum EXcluded</a>) of an array is the minimum non-negative integer that does&nbsp;not&nbsp;belong to the array and the&nbsp;XORXOR&nbsp;of an array is the&nbsp;<a href="https://en.wikipedia.org/wiki/Bitwise_operation#XOR">bitwise XOR</a>&nbsp;of all the elements of the array.</p>
56

57
 </blockquote>
58

59
 <p>
60
  <!-- /wp:quote --></p>
61

62
 <p>
63
  <!-- wp:heading {"level":3} --></p>
64

65
 <h3>大意</h3>
66

67
 <p>
68
  <!-- /wp:heading --></p>
69

70
 <p>
71
  <!-- wp:paragraph --></p>
72

73
 <p>给两个数<code>a</code>，<code>b</code>，表示在一个集合${0,1, ... , a-1, ... , x}$中，有<code>x-任意元素=b</code>的存在。</p>
74

75
 <p>
76
  <!-- /wp:paragraph --></p>
77

78
 <p>
79
  <!-- wp:paragraph --></p>
80

81
 <p><code>a</code>为<code>EXcluded</code>数，意思是在这个集合中，<strong>最小</strong>的<strong>不存在</strong>的<strong>非负数</strong>为<code>a</code>。并且在这个集合中，一定有两个数之差为<code>b</code>，输出这个集合最少有几个数。</p>
82

83
 <p>
84
  <!-- /wp:paragraph --></p>
85

86
 <p>
87
  <!-- wp:heading --></p>
88

89
 <h2>补充</h2>
90

91
 <p>
92
  <!-- /wp:heading --></p>
93

94
 <p>
95
  <!-- wp:list {"ordered":true} --></p>
96

97
 <ol>
98

99
  <li>如果<code>a^b=c</code>，则<code>a^c=b</code>。</li>
100

101
  <li><code>a^(a+1)^(a+2)^(a+3)=0 (a为4的倍数)</code> ，证明过程可参考二进制，末两位分别为<code>00</code>，<code>01</code>，<code>10</code>，<code>11</code>。</li>
102

103
 </ol>
104

105
 <p>
106
  <!-- /wp:list --></p>
107

108
 <p>
109
  <!-- wp:heading --></p>
110

111
 <h2>解题</h2>
112

113
 <p>
114
  <!-- /wp:heading --></p>
115

116
 <p>
117
  <!-- wp:paragraph --></p>
118

119
 <p>这题需要对多种情况进行分类讨论，根据<code>补充2</code>发现，其规律为4个一循环。</p>
120

121
 <p>
122
  <!-- /wp:paragraph --></p>
123

124
 <p>
125
  <!-- wp:heading --></p>
126

127
 <h2>示例代码</h2>
128

129
 <p>
130
  <!-- /wp:heading --></p>
131

132
 <p>
133
  <!-- wp:enlighter/codeblock --></p>
134

135
 <pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">#include
136
  <bits tdc++.h="">
展开收起
using namespace std;
int t;
int a,b;
int main(){
cin>>t;
while(t—){
int ans=0;
cin>>a>>b;
switch (a%4)
{
case 1:
ans=a-1;
break;
case 2:
ans=1;
break;
case 3:
ans=a;
break;
default:
ans=0;
break;
}
if(ans==b)cout<
<a<<endl; else="" if((b^ans)!=“a)cout<<a+1<<endl;” cout<<a+2<<endl;="" }="" return="" 0;="" }<="" re="">
1
    <p>
2
     <!-- /wp:enlighter/codeblock --></p>
3

4
    <p>
5
     <!-- wp:heading {"level":1} --></p>
6

7
    <h1>学习加法</h1>
8

9
    <p>
10
     <!-- /wp:heading --></p>
11

12
    <p>
13
     <!-- wp:heading --></p>
14

15
    <h2>题面</h2>
16

17
    <p>
18
     <!-- /wp:heading --></p>
19

20
    <p>
21
     <!-- wp:heading {"level":3} --></p>
22

23
    <h3>原题</h3>
24

25
    <p>
26
     <!-- /wp:heading --></p>
27

28
    <p>
29
     <!-- wp:paragraph --></p>
30

31
    <p>传送门：<a href="https://codeforces.com/problemset/problem/1567/C">Problem - 1567C - Codeforces</a></p>
32

33
    <p>
34
     <!-- /wp:paragraph --></p>
35

36
    <p>
37
     <!-- wp:separator --></p>
38

39
    <hr class="wp-block-separator" />
40

41
    <!-- /wp:separator -->
42
    <p></p>
43

44
    <p>
45
     <!-- wp:group --></p>
46

47
    <div class="wp-block-group">
48
     <!-- wp:paragraph -->
49
     <p></p>
50

51
     <p>Alice has just learned addition. However, she hasn't learned the concept of &quot;carrying&quot; fully&nbsp;— instead of carrying to the&nbsp;next&nbsp;column, she carries to the column&nbsp;two columns to the left.</p>
52

53
     <p>
54
      <!-- /wp:paragraph --></p>
55

56
     <p>
57
      <!-- wp:paragraph {"align":"center"} --></p>
58

59
     <p class="has-text-align-center">For example, the&nbsp;regular&nbsp;way to evaluate the sum&nbsp;2039+29762039+2976&nbsp;would be as shown:<img src="https://vj.ppsucxtt.cn/fdf82ba5355116a4525b30b0470264b9?v=1631085496" width="208" height="89" /></p>
60

61
     <p>
62
      <!-- /wp:paragraph --></p>
63

64
     <p>
65
      <!-- wp:paragraph --></p>
66

67
     <p>However, Alice evaluates it as shown:<img src="https://vj.ppsucxtt.cn/73d845a6f53bdbc0556975e371489630?v=1631085496" width="207" height="89" /></p>
68

69
     <p>
70
      <!-- /wp:paragraph --></p>
71

72
     <p>
73
      <!-- wp:paragraph --></p>
74

75
     <p>In particular, this is what she does:</p>
76

77
     <p>
78
      <!-- /wp:paragraph --></p>
79

80
     <p>
81
      <!-- wp:list --></p>
82

83
     <ul>
84

85
      <li>add&nbsp;99&nbsp;and&nbsp;66&nbsp;to make&nbsp;1515, and carry the&nbsp;11&nbsp;to the column&nbsp;two columns to the left, i.&nbsp;e. to the column &quot;00&nbsp;99&quot;;</li>
86

87
      <li>add&nbsp;33&nbsp;and&nbsp;77&nbsp;to make&nbsp;1010&nbsp;and carry the&nbsp;11&nbsp;to the column&nbsp;two columns to the left, i.&nbsp;e. to the column &quot;22&nbsp;22&quot;;</li>
88

89
      <li>add&nbsp;11,&nbsp;00, and&nbsp;99&nbsp;to make&nbsp;1010&nbsp;and carry the&nbsp;11&nbsp;to the column&nbsp;two columns to the left, i.&nbsp;e. to the column above the plus sign;</li>
90

91
      <li>add&nbsp;11,&nbsp;22&nbsp;and&nbsp;22&nbsp;to make&nbsp;55;</li>
92

93
      <li>add&nbsp;11&nbsp;to make&nbsp;11.</li>
94

95
     </ul>
96

97
     <p>
98
      <!-- /wp:list --></p>
99

100
     <p>
101
      <!-- wp:paragraph --></p>
102

103
     <p>Thus, she ends up with the incorrect result of&nbsp;1500515005.</p>
104

105
     <p>
106
      <!-- /wp:paragraph --></p>
107

108
     <p>
109
      <!-- wp:paragraph --></p>
110

111
     <p>Alice comes up to Bob and says that she has added two numbers to get a result of&nbsp;nn. However, Bob knows that Alice adds in her own way. Help Bob find the number of&nbsp;ordered pairs of positive integers&nbsp;such that when Alice adds them, she will get a result of&nbsp;nn. Note that pairs&nbsp;(a,b)(a,b)&nbsp;and&nbsp;(b,a)(b,a)&nbsp;are considered different if&nbsp;a≠ba≠b.</p>
112

113
     <p>
114
      <!-- /wp:paragraph --></p>
115
    </div>
116

117
    <p>
118
     <!-- /wp:group --></p>
119

120
    <p>
121
     <!-- wp:heading {"level":3} --></p>
122

123
    <h3>大意</h3>
124

125
    <p>
126
     <!-- /wp:heading --></p>
127

128
    <p>
129
     <!-- wp:quote --></p>
130

131
    <blockquote class="wp-block-quote">
132
     <p>爱丽丝刚刚学会了加法。然而，她还没有完全学会 &quot;携带 &quot;的概念--她不是携带到下一列，而是携带到左边两列的列。</p>
133

134
     <p>例如，评估2039+2976的常规方法是如图所示。</p>
135

136
     <p>然而，爱丽丝是按照图中的方式进行评估的。</p>
137

138
     <p>具体来说，她是这样做的。</p>
139

140
     <p>将9和6相加为15，并将1带到左边两列，即 &quot;0 9 &quot;列。<br />加3和7得10，并把1带到左边两列，即 &quot;2 2 &quot;列。<br />加1、0和9组成10，并将1带到左边两列，即加号上面的那一列。<br />加1，2和2组成5。<br />加1为1。<br />因此，她最后得到的结果是不正确的15005。<br />爱丽丝走过来对鲍勃说，她把两个数字相加得到的结果是n，但是，鲍勃知道爱丽丝是用自己的方式加的。请帮助鲍勃找出有秩序的正整数对，使爱丽丝将它们相加后得到的结果是n。请注意，如果a≠b，则成对的(a,b)和(b,a)被视为不同。</p>
141

142
     <p>输入<br />输入由多个测试案例组成。第一行包含一个整数t（1≤t≤1000）--测试案例的数量。测试用例的描述如下。</p>
143

144
     <p>每个测试用例的唯一一行包含一个整数n（2≤n≤109）--Alice给Bob看的数字。</p>
145

146
     <p>输出<br />对于每个测试用例，输出一个整数 - 有序的正整数对的数量，以便当Alice将它们相加时，她将得到一个n的结果。</p>
147

148
     <p><cite>—— 通过 www.DeepL.com/Translator 翻译</cite></p>
149
    </blockquote>
150

151
    <p>
152
     <!-- /wp:quote --></p>
153

154
    <p>
155
     <!-- wp:heading --></p>
156

157
    <h2>解题</h2>
158

159
    <p>
160
     <!-- /wp:heading --></p>
161

162
    <p>
163
     <!-- wp:paragraph --></p>
164

165
    <p>本题可思考Alice的加法方式和正常进位的加法方式。</p>
166

167
    <p>
168
     <!-- /wp:paragraph --></p>
169

170
    <p>
171
     <!-- wp:paragraph --></p>
172

173
    <p>Alice将个位的进位进到了百位，百位的进到了万位……反过来，十位的进到千位，如是往复。</p>
174

175
    <p>
176
     <!-- /wp:paragraph --></p>
177

178
    <p>
179
     <!-- wp:paragraph --></p>
180

181
    <p>不难发现，将互不相关的奇数位和偶数位分别提出来组成新的正常进位的数字，利用排列组合的原理即可求出最终答案。</p>
182

183
    <p>
184
     <!-- /wp:paragraph --></p>
185

186
    <p>
187
     <!-- wp:paragraph --></p>
188

189
    <p>对于自然数<code>n</code>，使得<code>a+b=n (a,b为正整数)</code>的方案数为<code>n-1</code>种。</p>
190

191
    <p>
192
     <!-- /wp:paragraph --></p>
193

194
    <p>
195
     <!-- wp:paragraph --></p>
196

197
    <p>通过比较发现，当<strong>A的奇偶都为0</strong>，且<strong>B的奇偶都为0</strong>时，应该将答案减去这两个舍去的情况。</p>
198

199
    <p>
200
     <!-- /wp:paragraph --></p>
201

202
    <p>
203
     <!-- wp:heading --></p>
204

205
    <h2>示例代码</h2>
206

207
    <p>
208
     <!-- /wp:heading --></p>
209

210
    <p>
211
     <!-- wp:enlighter/codeblock --></p>
212

213
    <pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">#include
214
     <bits tdc++.h="">
展开收起
using namespace std;
int t;
string n;
int num1,num2;
int main(){
cin>>t;
while (t—){
cin>>n;
num1=num2=0;
for(int i=0;i
<n.length();i++){ if(i%2=“=0)” num1=“num110+n[i]-‘0’;” else="" num2=“num210+n[i]-‘0’;” }="" cout<<”="">
”<
<num1<<” “<<num2<<endl;="" cout<<(num1+1)*(num2+1)-2<<endl;="" }="" return="" 0;="" }<="" re="">
1
        <p>
2
         <!-- /wp:enlighter/codeblock --></p>
3

4
       </num1<<">
5
      </n.length();i++){>
6
     </bits></pre>
7
   </a<<endl;>
8
  </bits></pre>
9
</endl;>

利用DeepFaceLab进行AI换脸

Wed, 25 Aug 2021 00:00:00 GMT

DeepFaceLab是众多开源的换脸软件之一。由于其对N卡良好的支持性以及易操作性，本教程使用DeepFaceLab进行AI换脸。

1 下载软件

warning 警告
在下载一切软件前，笔者默认您已经安装了N卡的Cuda 、Python 和 ffmpeg。教程百度。
不过没有N卡也行，用CPU。详情见下文。

首先打开项目的GitHub主页：iperov/DeepFaceLab: DeepFaceLab is the leading software for creating deepfakes. (github.com)。

找到下载链接：DeepFaceLab - нейросеть, меняющая лица в видео. :: RuTracker.org。

进入后是全俄语的。直接找到下载按钮并下载。

这是一个磁力链种子，用Motrix等下载器完成下载。

解压后的文件建议放在非C盘的根目录下。

如图

2 准备工作

将原视频和被换脸的视频（格式最好是MP4，其它的笔者没试过）复制到workspace目录下。

首先，先将原来的两个sample视频删除或重命名。然后再将您刚刚复制进去的视频分别命名：

原视频：data_src.mp4；
被换脸的视频：data_dst.mp4；

最后如图所示：

3 提取图片

3.1 分解原视频

首先提取图片，运行如图程序：

接下来的要求输入直接按回车即可。

显示Done.，按任意键即可。

3.2 分解目标视频

运行：

也按回车：

如图，直到输出Done.，按任意键退出。

3 提取脸部

提取原视频の脸

TIP：时间很慢，耐心等待。

运行：

这个时候直接按回车，选择默认的GPU（或CPU，输入CPU即可）。

首次启动可能会比较缓慢，会卡1分钟才要求输入。这可能是因为Python需要加载某些库的原因。

提取目标视频の脸

同上，时间缓慢，耐心等待：

（（（

4 训练模型

打开train Quick96.bat。

值得注意的是，这个程序不会自己结束，会一直运行下去，直到您终止它。

接着慢慢运行，可以查看右侧窗口的效果：

5 合并脸部

运行：

进入后，所有参数一律按回车。

记者程序自动拷贝脸图像（也就是转换！）。

您可以在\workspace\data_dst\merged目录下看到转换后的内容。出现Done.时就代表完成了。

6 合成视频

运行：

当然下面一个也可以，不过lossless是无损的意思。

等待两个ffmpeg的合成完成……

等待Done.，按任意键退出完成！

最后做的样例（qwq）：视频去哪了呢？_哔哩哔哩_bilibili

利用导数求代数式的最值

Sun, 15 Aug 2021 00:00:00 GMT

引言

先看这样一题：

函数$y=a^2+ab+b^2-a-2b$的最小值为_____。

题一

如果您按照常规配方法，会发现该代数式难以配方，或者即使成功配方，也无法求出最值（有三个平方项，却无法同时满足）。

这个时候就要用到主元配方法或“delta”法。

例如使用主元配方法：

$$y=(a+\frac{b-1}{2})^2+\frac{3}{4}(b-1)^2-1$$

经过一系列运算，就可以得到结论：当b=1，a=0是，函数有最小值-1。

有没有更快的方法？

问题就来了，如果按照主元配方法或者delta法，就需要大量的运算，慢，也难保证正确率。如果是下面这一题：

偏导数法

求偏导数，对于含有多个变量的求最值问题相当有用。

求导公式

我们称$y_x’$为关于$x$的导数。

对于任意的实数$n$，我们都可以得到$（ax^n）’=anx^{n-1}$。

相应的，如果我们设$h(n)$为$y$的第$i$项，$t(n)$为$n$的导数，那么$y_x’$就等于$\sum_{i=1}^{len(y)} t(h(i))$。

例如，关于x的导数$(6x^2+2kx-k)’=6x+2$。正如您所见，常数项视作0。

求解问题

下面再对题1进行求解。

分别对a，b进行求导得到方程组：

$$\begin{cases}a+1-1=0\\1+b-2=0\end{cases}$$

解得：

$$\begin{cases}a=0\\b=1\end{cases}$$

故：当a=0，b=1时，函数有最小值，代入得$y_min=-1$。

总结

二元二次式的最值问题如果用常规配方法不能完成，还可以使用不等式法、主元法配方以及“delta”法。不等式法对于初中生而言知识储备不够，主元法配方和“delta”法太复杂，偏导数方程法的确是解决这类问题的最简方法。

树上问题总结（一）

Mon, 09 Aug 2021 00:00:00 GMT

前置
树的重心
树的直径、中心
LCA

前置

快读

inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9')x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
    return x*f;
}

树的存储

通常我不喜欢什么儿子表示法父亲表示法。我通常直接链式前向星。

感觉还是很方便的。

#define N=100005;
int ver[N<<1],nxt[N<<1],head[N],tot,edge[N];
void add(int x,int y,int z)
{
    ver[++tot]=x,edge[tot]=z,nxt[tot]=head[x],head[x]=tot;
}
//搜索时
for(int i=head[x];i;i=nxt[i])
int y=ver[x];
//主函数中
for(int i=1;i<=n;i++)
{
int x=read(),y=read();
add(x,y),add(y,x);
}

树的搜索

通常喜欢直接DFS。

其中的边怎么弄就是链式前向星的基本操作了，感觉非常方便。

用参数$fa$判或者$vis$数组判都是可以的。

//a是DFS序,d是节点深度,s是子树大小
void dfs(int x)
{
    a[++m]=x,v[x]=1,s[x]=1;
    for(int i=head[x];i;i=next[i])
    {
        int y=ver[i];
        if(!v[y])
            d[y]=d[x]+1,dfs(y),s[x]+=s[y];
    }
    a[++m]=x;
}

P4914 二叉树深度

大概这个时候链式前向星的优势也就体现出来了。不需要什么繁琐的表示法，一个模板可以直接套到底。

const int SIZE=100005;
int nxt[SIZE<<1],ver[SIZE<<1],head[SIZE<<1],tot;
inline void add(int x,int y)
{
    ver[++tot]=y,nxt[tot]=head[x],head[x]=tot;
}
int n,dep[SIZE],ans;
void dfs(int x,int fa)
{
    dep[x]=dep[fa]+1;
    for(int i=head[x];i;i=nxt[i])
    {
        int y=ver[i];
        if(y!=fa)dfs(y,x);
    }
}
int main()
{
    n=read();
    for(int i=1;i<=n;i++)
    {
        int x=read(),y=read();
        if(x)add(i,x),add(x,i);
        if(y)add(i,y),add(y,i);
    }
    dfs(1,0);
    for(int i=1;i<=n;i++)ans=max(ans,dep[i]);
    printf("%d\n",ans);
    return 0;
}

P1305 新二叉树

此题是先序遍历板题。

先序遍历：先根后左右
中序遍历：先左中根后右
后序遍历：先左右后根

注意链式前向星建图是后加的边先被搜索到，因此这里建树的时候需要先建右子树再建左子树。

const int SIZE=100005;
int nxt[SIZE<<1],ver[SIZE<<1],head[SIZE<<1],tot;
inline void add(int x,int y)
{
    ver[++tot]=y,nxt[tot]=head[x],head[x]=tot;
}
int n,rt;
void dfs(int x,int fa)
{
    printf("%c",x+'A');
    for(int i=head[x];i;i=nxt[i])
    {
        int y=ver[i];
        if(y!=fa)dfs(y,x);
    }
}
int main()
{
    n=read();
    for(int i=1;i<=n;i++)
    {
        char x,y,z;cin>>x>>y>>z;
        int f=x-'A',l=y-'A',r=z-'A';
        if(z!='*')add(f,r),add(r,f);
        if(y!='*')add(f,l),add(l,f);
        if(i==1)rt=f;
    }
    dfs(rt,0);
    return 0;
}

树的重心

简单求解

一棵树的重心节点 $x$ 指的是：将 $x$ 从树中删除后，被分出的树中最大的部分最小。

因此我们任取一点为根，使用全局变量$mxpt$记录搜索到任意一点时，其最大子树的大小。然后对于每个节点，搜索结束后都更新$mxpt$。

void dfs(int x)
{
    v[x]=1,s[x]=val[x];
    int mxpt=0;
    for(int i=head[x];i;i=nxt[i])
    {
        int y=ver[i];
        if(!v[y])
            dfs(y),s[x]+=s[y],
            mxpt=max(mxpt,s[y]);
    }
    mxpt=max(mxpt,sum-s[x]);
    if(mxpt
   
1
<p>
2
 <!-- /wp:enlighter/codeblock --></p>
3

4
<p>
5
 <!-- wp:heading {"level":3} --></p>
6

7
<h3>重心的性质</h3>
8

9
<p>
10
 <!-- /wp:heading --></p>
11

12
<p>
13
 <!-- wp:paragraph --></p>
14

15
<p>树的重心的一个显然的性质就是： <em>在边权为$1$时，以重心为根的树，各点到根节点的距离和最小</em> 。</p>
16

17
<p>
18
 <!-- /wp:paragraph --></p>
19

20
<p>
21
 <!-- wp:paragraph --></p>
22

23
<p><strong>证明</strong></p>
24

25
<p>
26
 <!-- /wp:paragraph --></p>
27

28
<p>
29
 <!-- wp:quote --></p>
30

31
<blockquote class="wp-block-quote">
32
 <p>使用邻项交换（微扰分析法）。</p>
33

34
 <p>假设我们已经求出了重心 $x$。设要到达的根为 $p$，不妨先令 $p=x$。现在使 $p$ 点向任意一条边 $w(p,q)$ 移动，发现造成距离和变化的唯一原因就是经过 $w(p,q)$ 到达点根的子节点数量发生了变化。</p>
35

36
 <p>因为重心保证了最大的一棵子树最小。因为移动先后的总节点数目是不变的，因此 $p$ 移动到 $w(p,q)$ 另一端 $q$ 后，$w(p,q)$ 指向的子树必然增大。这样就会导致通过 $w(p,q)$ 到达根的节点数增多，显然更劣。</p>
37

38
</blockquote>
39

40
<p>
41
 <!-- /wp:quote --></p>
42

43
<p>
44
 <!-- wp:paragraph --></p>
45

46
<p>有个板子题<a href="https://www.luogu.com.cn/problem/P1364">P1364 医院设置</a>。</p>
47

48
<p>
49
 <!-- /wp:paragraph --></p>
50

51
<p>
52
 <!-- wp:paragraph --></p>
53

54
<p>那么假如我们加了点权怎么办？</p>
55

56
<p>
57
 <!-- /wp:paragraph --></p>
58

59
<p>
60
 <!-- wp:paragraph --></p>
61

62
<p>其实是一样的，改一改 $size$ 即可。至于如何求解距离和，可以强制换根，一遍$DFS$搞定。</p>
63

64
<p>
65
 <!-- /wp:paragraph --></p>
66

67
<p>
68
 <!-- wp:paragraph --></p>
69

70
<p>题目：<a href="https://www.luogu.com.cn/problem/P1395">P1395 会议</a>。</p>
71

72
<p>
73
 <!-- /wp:paragraph --></p>
74

75
<p>
76
 <!-- wp:heading --></p>
77

78
<h2>带边权的重心</h2>
79

80
<p>
81
 <!-- /wp:heading --></p>
82

83
<p>
84
 <!-- wp:heading {"level":3} --></p>
85

86
<h3>模板：<a href="https://www.luogu.com.cn/problem/P2986">P2986 Great Cow Gathering</a></h3>
87

88
<p>
89
 <!-- /wp:heading --></p>
90

91
<p>
92
 <!-- wp:paragraph --></p>
93

94
<p>我们有个结论： <em>边权不影响树的重心</em> 。</p>
95

96
<p>
97
 <!-- /wp:paragraph --></p>
98

99
<p>
100
 <!-- wp:paragraph --></p>
101

102
<p>证明方法是类似的。</p>
103

104
<p>
105
 <!-- /wp:paragraph --></p>
106

107
<p>
108
 <!-- wp:paragraph --></p>
109

110
<p><strong>证明</strong></p>
111

112
<p>
113
 <!-- /wp:paragraph --></p>
114

115
<p>
116
 <!-- wp:quote --></p>
117

118
<blockquote class="wp-block-quote">
119
 <p>假设在边权为$1$的情况下我们找到了重心，那么以此为根其他的子树最大的一个最小。</p>
120

121
 <p>现在加了边权。假设这个重心往旁边移了，那么有影响的只是移过的那一条边。因为移动之后破坏了点权和最大值最小的性质，所以通过移动后的那条边的所有点权一定比移动之前大。</p>
122

123
</blockquote>
124

125
<p>
126
 <!-- /wp:quote --></p>
127

128
<p>
129
 <!-- wp:paragraph --></p>
130

131
<p>我们能否总结出一个规律？简单观察后发现，在根移动过后对距离和有影响的，只是移动过的那条边 <em>移动前后指向子树的大小</em> 以及 <em>本身的边权</em> 。根据重心的定义，以及边权是不变的，因此重心可以保证在任意边权和点权的时候保持原有性质。</p>
132

133
<p>
134
 <!-- /wp:paragraph --></p>
135

136
<p>
137
 <!-- wp:paragraph --></p>
138

139
<p>这题搜索的方法就是将深度由每次增加$1$变为增加边的长度。然后返回统计就是类似的。</p>
140

141
<p>
142
 <!-- /wp:paragraph --></p>
143

144
<p>
145
 <!-- wp:enlighter/codeblock --></p>
146

147
<pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">ll maxx(ll a,ll b){return a&gt;b?a:b;}
展开收起
const ll SIZE=100005;
ll nxt[SIZE<<1],ver[SIZE<<1],head[SIZE<<1],val[SIZE<<1],tot;
inline void add(ll x,ll y,ll z)
{
ver[++tot]=y,nxt[tot]=head[x],head[x]=tot,val[tot]=z;
}
ll n,ans=10000000005,p,v[SIZE],s[SIZE],sum,w[SIZE];
void dfs(ll x)
{
v[x]=1,s[x]=w[x];
ll mxpt=0;
for(ll i=head[x];i;i=nxt[i])
{
ll y=ver[i];
if(!v[y])
dfs(y),s[x]+=s[y],
mxpt=maxx(mxpt,s[y]);
}
mxpt=maxx(mxpt,sum-s[x]);
if(mxpt
<ans)ans=mxpt,p=x; }="" void="" mvrt(ll="" x,ll="" fa,ll="" dep)="" {="" ans+=“w[x]*dep;” for(ll="" i=“1;i<n;i++)” ll="" y=“ver[i];” if(y!=“fa)mvrt(y,x,dep+val[i]);” int="" main()="" n=“read();” w[i]=“read(),sum+=w[i];” x=“read(),y=read(),z=read();” add(x,y,z),add(y,x,z);="" dfs(1),ans=“0,mvrt(p,-1,0);” printf(“%lld\n”,ans);="" return="" 0;="" }<="" re="">
1
  <p>
2
   <!-- /wp:enlighter/codeblock --></p>
3

4
  <p>
5
   <!-- wp:separator --></p>
6

7
  <hr class="wp-block-separator" />
8

9
  <!-- /wp:separator -->
10
  <p></p>
11

12
  <p>
13
   <!-- wp:heading {"level":1} --></p>
14

15
  <h1>树的直径、中心</h1>
16

17
  <p>
18
   <!-- /wp:heading --></p>
19

20
  <p>
21
   <!-- wp:heading --></p>
22

23
  <h2>树的直径</h2>
24

25
  <p>
26
   <!-- /wp:heading --></p>
27

28
  <p>
29
   <!-- wp:paragraph --></p>
30

31
  <p>一棵树上的最长链或最长链的长度称作这棵树的直径。</p>
32

33
  <p>
34
   <!-- /wp:paragraph --></p>
35

36
  <p>
37
   <!-- wp:paragraph --></p>
38

39
  <p>求解直径通常有三种方法。</p>
40

41
  <p>
42
   <!-- /wp:paragraph --></p>
43

44
  <p>
45
   <!-- wp:heading {"level":3} --></p>
46

47
  <h3>合并链法（树形dp）</h3>
48

49
  <p>
50
   <!-- /wp:heading --></p>
51

52
  <p>
53
   <!-- wp:paragraph --></p>
54

55
  <p>$dfs$ 找出每个节点下的最长链 $m_1$ 和次长链 $m_2$。</p>
56

57
  <p>
58
   <!-- /wp:paragraph --></p>
59

60
  <p>
61
   <!-- wp:paragraph --></p>
62

63
  <p>每次 $dfs$ 使 $ans$ 的值为最长和次长链的合并结果即可。</p>
64

65
  <p>
66
   <!-- /wp:paragraph --></p>
67

68
  <p>
69
   <!-- wp:enlighter/codeblock --></p>
70

71
  <pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">int dp(int x,int fa)
展开收起
{
int m1=0,m2=0;
for(int i=head[x];i;i=nxt[i])
{
int y=ver[i];
if(y!=fa)
{
int r=dp(y,x)+edge[i];
if(m1
<r)m2=m1,m1=r; else="" if(m2<r)m2=“r;” }="" ans=“max(m1+m2);” return="" m1;="" }<="" re="">
1
    <p>
2
     <!-- /wp:enlighter/codeblock --></p>
3

4
    <p>
5
     <!-- wp:paragraph --></p>
6

7
    <p>这种求法有另一种写法。</p>
8

9
    <p>
10
     <!-- /wp:paragraph --></p>
11

12
    <p>
13
     <!-- wp:paragraph --></p>
14

15
    <p>设 $d_x$ 为从 $x$ 出发走向以 $x$ 为根的子树的最远距离。我们可以通过此求出 $f_x$ 即经过 $x$ 的最长链长度。求解 $f_x$ 事实上就是合并最长链和次长链的过程。我们可以自底向上地统计结果。</p>
16

17
    <p>
18
     <!-- /wp:paragraph --></p>
19

20
    <p>
21
     <!-- wp:paragraph --></p>
22

23
    <p>当回溯到一个节点 $x$ 的时候，设其任意一个子节点为 $y$，我们直接将 $d_x$ 更新为 $\max\big(d_x,d_y+w(y,x)\big)$。这个转移的意义是，在搜索子节点的时候，将 <em>目前求出的最长链</em> 与其 <em>子节点 $y$ 的最长链加上 $w(y,x)$ 边</em> 这条候选的最长链作比较。</p>
24

25
    <p>
26
     <!-- /wp:paragraph --></p>
27

28
    <p>
29
     <!-- wp:paragraph --></p>
30

31
    <p>全局变量 $ans=\max\big(ans,x_x+d_y+w(y,x)\big)$，即是计算两条链的长度之和。</p>
32

33
    <p>
34
     <!-- /wp:paragraph --></p>
35

36
    <p>
37
     <!-- wp:enlighter/codeblock --></p>
38

39
    <pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">void dp(int x)
展开收起
{
v[x]=1;
for(int i=head[x];i;i=nxt[i])
{
int y=ver[i];
if(!v[y])
{
dp(y);
ans=max(ans,d[x]+d[y]+edge[i]),
d[x]=max(d[x],d[y]+edge[i]);
}
}
}

1
    <p>
2
     <!-- /wp:enlighter/codeblock --></p>
3

4
    <p>
5
     <!-- wp:heading {"level":3} --></p>
6

7
    <h3>两次搜索</h3>
8

9
    <p>
10
     <!-- /wp:heading --></p>
11

12
    <p>
13
     <!-- wp:paragraph --></p>
14

15
    <p>使用两次搜索的方法能够求出直径的端点和直径的路径。</p>
16

17
    <p>
18
     <!-- /wp:paragraph --></p>
19

20
    <p>
21
     <!-- wp:paragraph --></p>
22

23
    <p>任取一个点 $x$，以 $x$ 为根寻找距离 $x$ 最远的点 $p$；然后以 $p$ 为根同样寻找到离 $p$ 最远的点 $q$，$p$ 和 $q$ 就是直径的两个端点。</p>
24

25
    <p>
26
     <!-- /wp:paragraph --></p>
27

28
    <p>
29
     <!-- wp:paragraph --></p>
30

31
    <p>记 $d_x$ 为到根的距离，简单搜索即可。</p>
32

33
    <p>
34
     <!-- /wp:paragraph --></p>
35

36
    <p>
37
     <!-- wp:paragraph --></p>
38

39
    <p><strong>正确性证明</strong></p>
40

41
    <p>
42
     <!-- /wp:paragraph --></p>
43

44
    <p>
45
     <!-- wp:quote --></p>
46

47
    <blockquote class="wp-block-quote">
48
     <p>$p$ 必然是直径的一端。如果不是，设另一点 $y$ 是直径的一段，因为求出的 $p$ 是距离 $x$ 最远的点，所以 $dis(p,x)&gt;dis(y,x)$。这与直径最长性矛盾，所以找不到符合要求的点 $y$，$p$ 是直径的一端。</p>
49

50
     <p>同理，$q$ 是距离直径的一端 $p$ 最远的点，自然就是直径的另一端。</p>
51

52
    </blockquote>
53

54
    <p>
55
     <!-- /wp:quote --></p>
56

57
    <p>
58
     <!-- wp:paragraph --></p>
59

60
    <p><strong>BFS求解</strong></p>
61

62
    <p>
63
     <!-- /wp:paragraph --></p>
64

65
    <p>
66
     <!-- wp:enlighter/codeblock --></p>
67

68
    <pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">int bfs(int s)

展开收起

{ int x,y; memset(d,0x3f,sizeof(d)); q.push(s),d[s]=0,pre[s]=0; while(q.size()) { x=q.front(),q.pop(); for(int i=head[x];i;i=next[i]) if(d[ver[i]]>=INF) d[ver[i]]=d[x]+edge[i], pre[ver[i]]=x, //记录前驱(路径) q.push(ver[i]); } for(x=1,y=1;x<=n;x++) if(d[x]>d[y])y=x; return y; }

//主函数中 p=bfs(1); q=bfs(p);

1
    <p>
2
     <!-- /wp:enlighter/codeblock --></p>
3

4
    <p>
5
     <!-- wp:paragraph --></p>
6

7
    <p><strong>DFS求解</strong></p>
8

9
    <p>
10
     <!-- /wp:paragraph --></p>
11

12
    <p>
13
     <!-- wp:enlighter/codeblock --></p>
14

15
    <pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">int dfs(int x,int fa)

展开收起

{ int pnt; for(int i=head[x];i;i=nxt[i]) { int y=ver[i]; if(y!=fa) { d[y]=d[x]+edge[i],pre[y]=x; if(d[y]>d[pnt])pnt=y; dfs(y,x); } } return pnt; }

//主函数中 p=dfs(1,-1); memset(d,0x3f,sizeof(d)); q=dfs(p,-1);

1
    <p>
2
     <!-- /wp:enlighter/codeblock --></p>
3

4
    <p>
5
     <!-- wp:heading --></p>
6

7
    <h2>树的中心</h2>
8

9
    <p>
10
     <!-- /wp:heading --></p>
11

12
    <p>
13
     <!-- wp:paragraph --></p>
14

15
    <p>一棵树的中心 $x$ 满足，在树上所有的点中，到 $x$ 的最大距离最小。</p>
16

17
    <p>
18
     <!-- /wp:paragraph --></p>
19

20
    <p>
21
     <!-- wp:paragraph --></p>
22

23
    <p>$\color{black}{\mathbf{中心的性质及求法}}$</p>
24

25
    <p>
26
     <!-- /wp:paragraph --></p>
27

28
    <p>
29
     <!-- wp:paragraph --></p>
30

31
    <p>树的中心有一个很好的性质： <em>一棵树的中心是直径的中点</em> 。这里的中点是考虑边权的。</p>
32

33
    <p>
34
     <!-- /wp:paragraph --></p>
35

36
    <p>
37
     <!-- wp:paragraph --></p>
38

39
    <p><strong>简单证明</strong></p>
40

41
    <p>
42
     <!-- /wp:paragraph --></p>
43

44
    <p>
45
     <!-- wp:quote --></p>
46

47
    <blockquote class="wp-block-quote">
48
     <p>根据两次搜索的证明，我们已经知道距离任意一个点最远的点 $p$ 是直径的端点，而 $p$ 到达 $x$ 必然先经过直径的一段。</p>
49

50
     <p>假设路径 $(p,x)$ 拐出直径的点为 $y$，则我们先要最小化 $dis(p,y)+dis(x,y)$。因为 $dis(p,y)$ 在 $y$ 固定时是不变的，因此我们当然让 $dis(x,y)=0$，即 $x$ 在直径上。</p>
51

52
     <p>那么我们的 $y$ 点（即 $x$）如何选取？也就是使 $\max\big(dis(p,y),dis(q,y)\big)$ 最小，显然 $p$ 在直径的中点上。</p>
53

54
    </blockquote>
55

56
    <p>
57
     <!-- /wp:quote --></p>
58

59
    <p>
60
     <!-- wp:paragraph --></p>
61

62
    <p>证毕。</p>
63

64
    <p>
65
     <!-- /wp:paragraph --></p>
66

67
    <p>
68
     <!-- wp:paragraph --></p>
69

70
    <p>那么中心怎么求呢？</p>
71

72
    <p>
73
     <!-- /wp:paragraph --></p>
74

75
    <p>
76
     <!-- wp:paragraph --></p>
77

78
    <p>其实只需要这么一句话：</p>
79

80
    <p>
81
     <!-- /wp:paragraph --></p>
82

83
    <p>
84
     <!-- wp:enlighter/codeblock --></p>
85

86
    <pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">for(int i=1;i&lt;=(d[q]+1)/2;i++)x=pre[x];</pre>
87

88
    <p>
89
     <!-- /wp:enlighter/codeblock --></p>
90

91
    <p>
92
     <!-- wp:paragraph --></p>
93

94
    <p>如果是带边权的话，我们可以记录 $pre$ 的同时记录边权，然后先求出直径长度，接着直径上每个点扫描过去，判断一下长度即可。</p>
95

96
    <p>
97
     <!-- /wp:paragraph --></p>
98

99
    <p>
100
     <!-- wp:heading --></p>
101

102
    <h2>直径、中心若干题目</h2>
103

104
    <p>
105
     <!-- /wp:heading --></p>
106

107
    <p>
108
     <!-- wp:heading {"level":3} --></p>
109

110
    <h3><a href="https://www.luogu.com.cn/problem/P4408">P4408 逃学的小孩</a></h3>
111

112
    <p>
113
     <!-- /wp:heading --></p>
114

115
    <p>
116
     <!-- wp:paragraph --></p>
117

118
    <p>找直径没有问题罢。</p>
119

120
    <p>
121
     <!-- /wp:paragraph --></p>
122

123
    <p>
124
     <!-- wp:paragraph --></p>
125

126
    <p>找完之后我们枚举直径外其他的点，这些点和俩端点形成类似于一个三角形的东西。</p>
127

128
    <p>
129
     <!-- /wp:paragraph --></p>
130

131
    <p>
132
     <!-- wp:paragraph --></p>
133

134
    <p>然后直径这条边是必须选的，剩下两条边要考虑走哪条边。题目告诉你先走近的，所以剩下俩边选取短的那条就行了。</p>
135

136
    <p>
137
     <!-- /wp:paragraph --></p>
138

139
    <p>
140
     <!-- wp:paragraph --></p>
141

142
    <p>然后这些点都枚举完之后取最大值即可。</p>
143

144
    <p>
145
     <!-- /wp:paragraph --></p>
146

147
    <p>
148
     <!-- wp:heading {"level":3} --></p>
149

150
    <h3><a href="https://www.luogu.com.cn/problem/P5536">P5536 核心城市</a></h3>
151

152
    <p>
153
     <!-- /wp:heading --></p>
154

155
    <p>
156
     <!-- wp:paragraph --></p>
157

158
    <p>根据中心的定义，首先可以明确的是选取的城市必然包含中心。</p>
159

160
    <p>
161
     <!-- /wp:paragraph --></p>
162

163
    <p>
164
     <!-- wp:paragraph --></p>
165

166
    <p>于是我们以中心为根，设 $D_x$ 表示从 $x$ 出发走向以 $x$ 为根的子树的最远距离。我们每次选一个城市的时候，因为要保证最大值最小，所以肯定是先选择剩下城市中 $D_x$ 最大的。因此这样下去，最终选择的是 $D_x$ 前 $k$ 大的。</p>
167

168
    <p>
169
     <!-- /wp:paragraph --></p>
170

171
    <p>
172
     <!-- wp:paragraph --></p>
173

174
    <p>所以我们只需$DFS$求出 $D_x$，然后排序即可。</p>
175

176
    <p>
177
     <!-- /wp:paragraph --></p>
178

179
    <p>
180
     <!-- wp:enlighter/codeblock --></p>
181

182
    <pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">bool cmp(int a,int b){return a&gt;b;}

展开收起

const int SIZE=200010; int nxt[SIZE],ver[SIZE],head[SIZE],tot; inline void add(int x,int y) { ver[++tot]=y,nxt[tot]=head[x],head[x]=tot; } int d[SIZE],pre[SIZE],dpx[SIZE],jed[SIZE]; int n,k,maxd,p,q,ans,t; void dfs1(int x,int fa) { if(d[x]>maxd)maxd=d[x],p=x; for(int i=head[x];i;i=nxt[i]) { int y=ver[i]; if(y!=fa) d[y]=d[x]+1, dfs1(y,x); } } void dfs2(int x,int fa) { if(d[x]>maxd)maxd=d[x],q=x; for(int i=head[x];i;i=nxt[i]) { int y=ver[i]; if(y!=fa) d[y]=d[x]+1, pre[y]=x,dfs2(y,x); } } void dfs3(int x,int fa) { dpx[x]=d[x]; for(int i=head[x];i;i=nxt[i]) { int y=ver[i]; if(y!=fa) d[y]=d[x]+1,dfs3(y,x), dpx[x]=max(dpx[x],dpx[y]); } } int main() { n=read(),k=read(); for(int i=1;i <n;i++) {="" int="" x=“read(),y=read();” add(x,y),add(y,x);="" }="" dfs1(1,-1);="" memset(dp,0,sizeof(dp));="" maxd=“0,dfs2(p,-1),t=q;” for(int="" i=“k+1;i<=n;i++)” t=“pre[t];” dfs3(t,0);="" jed[i]=“dpx[i]-d[i];” sort(jed+1,jed+n+1,cmp);="" ans=“max(ans,jed[i]+1);” printf(“%d\n”,ans);="" return="" 0;="" }<="" re="">

1
      <p>
2
       <!-- /wp:enlighter/codeblock --></p>
3

4
      <p>
5
       <!-- wp:heading {"level":3} --></p>
6

7
      <h3><a href="https://www.luogu.com.cn/problem/P2195">P4914 HXY造公园</a></h3>
8

9
      <p>
10
       <!-- /wp:heading --></p>
11

12
      <p>
13
       <!-- wp:paragraph --></p>
14

15
      <p>用并查集维护森林，然后每次合并两棵树就连接其中心，更新即可。</p>
16

17
      <p>
18
       <!-- /wp:paragraph --></p>
19

20
      <p>
21
       <!-- wp:paragraph --></p>
22

23
      <p>具体而言，我们建立数组 $C$ 表示每个集合的最长路径。合并集合的时候，定义 $tmp$ 为连接两个中心后的最长距离，当合并集合 $x,y$ 时，显而易见</p>
24

25
      <p>
26
       <!-- /wp:paragraph --></p>
27

28
      <p>
29
       <!-- wp:paragraph --></p>
30

31
      <p>$$tmp=\max\left(C_x\,,\;\Big\lfloor\frac{C_x}{2}\Big\rfloor+\Big\lfloor\frac{C_y}{2}\Big\rfloor+1\,,\;C_y\right)$$</p>
32

33
      <p>
34
       <!-- /wp:paragraph --></p>
35

36
      <p>
37
       <!-- wp:paragraph --></p>
38

39
      <p>因此我们用并查集合并集合，并且用 $tmp$ 去更新 $C$ 即可。</p>
40

41
      <p>
42
       <!-- /wp:paragraph --></p>
43

44
      <p>
45
       <!-- wp:enlighter/codeblock --></p>
46

47
      <pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">const int SIZE=300005;

展开收起

int nxt[SIZE<<1],ver[SIZE<<1],head[SIZE<<1],tot; inline void add(int x,int y) { ver[++tot]=y,nxt[tot]=head[x],head[x]=tot; } int d[SIZE],g[SIZE],f[SIZE],c[SIZE],n,m,q,len; bool vis[SIZE]; inline int find(int x) { if(f[x]==x)return x; return f[x]=find(f[x]); } void dfs(int x,int fa) { int m1=0,m2=0,tmp; for(int i=head[x];i;i=nxt[i]) { int y=ver[i]; if(y!=fa) { dfs(y,x),tmp=d[y]+1; d[x]=max(d[x],tmp); if(tmp>m1)m2=m1,m1=tmp; else if(tmp>m2)m2=tmp; } } g[x]=max(max(0,m1+m2),max(m1,m2)); len=max(len,g[x]); } int main(){ n=read(),m=read(),q=read(); for(int i=1;i<=n;i++)f[i]=i; for(int i=1;i<=m;i++) { int x=read(),y=read(); f[find(x)]=find(y); add(x,y),add(y,x); } for(int i=1;i<=n;i++) if(f[i]==i&&(!vis[i])) { len=0,dfs(i,0); c[i]=len,vis[i]=1; } while(q—) { int opt=read(),x=read(); if(opt==1) { printf(“%d\n”,c[find(x)]); continue; } int y=read(); x=find(x),y=find(y); if(x!=y) { int tmp=ceil(c[x]/2.0)+ceil(c[y]/2.0)+1; tmp=max(tmp,max(c[x],c[y])); f[find(x)]=find(y); c[find(x)]=tmp; } } return 0; }

1
      <p>
2
       <!-- /wp:enlighter/codeblock --></p>
3

4
      <p>
5
       <!-- wp:heading {"level":3} --></p>
6

7
      <h3><a href="https://www.luogu.com.cn/problem/P1099">P1099 树网的核</a></h3>
8

9
      <p>
10
       <!-- /wp:heading --></p>
11

12
      <p>
13
       <!-- wp:paragraph --></p>
14

15
      <p>先找直径。</p>
16

17
      <p>
18
       <!-- /wp:paragraph --></p>
19

20
      <p>
21
       <!-- wp:paragraph --></p>
22

23
      <p>我们先确定一个端点，核的另一端点显然越远越好，所以直接确定那个点然后遍历树即可，复杂度二次。</p>
24

25
      <p>
26
       <!-- /wp:paragraph --></p>
27

28
      <p>
29
       <!-- wp:paragraph --></p>
30

31
      <p>联想到树的中心，我们能够容易地证明，核的端点越靠近树的中心越好，因此我们从中心出发向外找两个点让它最远。</p>
32

33
      <p>
34
       <!-- /wp:paragraph --></p>
35

36
      <p>
37
       <!-- wp:paragraph --></p>
38

39
      <p>因此我们略作转化。设 $p,q$ 为直径的两端，二分判定一个偏心距，求出这个偏心距的最短的核，然后判定这个偏心距的核满不满足条件。具体来说，我们判定偏心距 $mid$，从 $p,q$ 分别在直径上找到距离小于等于 $mid$ 的最远的两点，然后判定这两个点是否过长即可。正确性由直径最长性保证。</p>
40

41
      <p>
42
       <!-- /wp:paragraph --></p>
43

44
      <p>
45
       <!-- wp:paragraph --></p>
46

47
      <p>然而你会发现上述做法纯属多余。我们为什么不能直接 $DFS$ 处理出不经过直径上的其他点能到达的最远距离 $D_x$ 呢？</p>
48

49
      <p>
50
       <!-- /wp:paragraph --></p>
51

52
      <p>
53
       <!-- wp:paragraph --></p>
54

55
      <p>计直径上的节点为 $u_k(0
56
       <k\leq t)$，单调队列维护="" $i,j$，求下式最小值<="">
57

58
       </k\leq></p>
59
      <p>
60
       <!-- /wp:paragraph --></p>
61

62
      <p>
63
       <!-- wp:paragraph --></p>
64

65
      <p>$$\max\left(\max_{i\leq k\leq j}{d_{u_i}},dis(u_1,u_i),dis(u_j,u_t)\right)$$</p>
66

67
      <p>
68
       <!-- /wp:paragraph --></p>
69

70
      <p>
71
       <!-- wp:paragraph --></p>
72

73
      <p>复杂度降为 $O(n)$。</p>
74

75
      <p>
76
       <!-- /wp:paragraph --></p>
77

78
      <p>
79
       <!-- wp:paragraph --></p>
80

81
      <p>进一步，根据直径的最长性，$i,j$ 两点上的 $D$ 数组的值是不会大于 $dis(u_1,u_i)$ 或 $dis(u_j,u_t)$ 的；并且，在 $kj$ 的时候，$D_k$ 也不会大于$dis(u_1,u_i)$ 或 $dis(u_j,u_t)$。因此，真正对 $\max$ 做贡献 $D_k$ 的只是 $i
82
       <k<j$ 的部分。<="">
83

84
       </k<j$></p>
85
      <p>
86
       <!-- /wp:paragraph --></p>
87

88
      <p>
89
       <!-- wp:paragraph --></p>
90

91
      <p>这表示我们可以随意扩大 $\max$ 下方的范围！也就是说，我们完全可以将式子变为下面这个样子而不改变正确性，从而内部的那个 $max$ 函数的结果成为了定值，也就不需要单调队列了：</p>
92

93
      <p>
94
       <!-- /wp:paragraph --></p>
95

96
      <p>
97
       <!-- wp:paragraph --></p>
98

99
      <p>$$\max\left(\max_{1\leq k\leq t}{d_{u_i}},dis(u_1,u_i),dis(u_j,u_t)\right)$$</p>
100

101
      <p>
102
       <!-- /wp:paragraph --></p>
103

104
      <p>
105
       <!-- wp:paragraph --></p>
106

107
      <p>至此，这道题的最简解法也就明晰了。</p>
108

109
      <p>
110
       <!-- /wp:paragraph --></p>
111

112
      <p>
113
       <!-- wp:heading {"level":3} --></p>
114

115
      <h3><a href="https://www.luogu.com.cn/problem/P2491">P2491 消防</a></h3>
116

117
      <p>
118
       <!-- /wp:heading --></p>
119

120
      <p>
121
       <!-- wp:paragraph --></p>
122

123
      <p>这题是树网的核的双倍经验，除了证明选点在直径上之外，是完全一样了。</p>
124

125
      <p>
126
       <!-- /wp:paragraph --></p>
127

128
      <p>
129
       <!-- wp:paragraph --></p>
130

131
      <p>链在直径上的证明基本只是用到了最长性，很好证，不赘述了。</p>
132

133
      <p>
134
       <!-- /wp:paragraph --></p>
135

136
      <p>
137
       <!-- wp:heading {"level":3} --></p>
138

139
      <h3><a href="https://www.luogu.com.cn/problem/P3629">P3629 巡逻</a></h3>
140

141
      <p>
142
       <!-- /wp:heading --></p>
143

144
      <p>
145
       <!-- wp:paragraph --></p>
146

147
      <p>首先不加边的话，显然每条边走过两次。</p>
148

149
      <p>
150
       <!-- /wp:paragraph --></p>
151

152
      <p>
153
       <!-- wp:paragraph --></p>
154

155
      <p>可以发现的是，在树中加入一条边后，会形成一个环。这个环上的所有点都只需要走过一次，比原先的两次减少了一次。</p>
156

157
      <p>
158
       <!-- /wp:paragraph --></p>
159

160
      <p>
161
       <!-- wp:paragraph --></p>
162

163
      <p>所以当 $k=1$ 时，我们显然找直径，这样可以最大化环的大小。设直径长度 $l$，总边数 $x$，则最终答案为 $2x-l+1$。</p>
164

165
      <p>
166
       <!-- /wp:paragraph --></p>
167

168
      <p>
169
       <!-- wp:paragraph --></p>
170

171
      <p>当 $k=2$ 时，我们的第二条边与第一条边所形成的环的重叠边会需要走两次（画图理解），这样这部分就等于没有变化。因此我们在直径的基础上，需要让重叠部分小、不重叠部分多。</p>
172

173
      <p>
174
       <!-- /wp:paragraph --></p>
175

176
      <p>
177
       <!-- wp:paragraph --></p>
178

179
      <p>这两个要素没有优先级之分，但是我们注意到，对于缩小走的边数而言，不重叠部分的边贡献为 $1$，重叠的边贡献为 $-1$，我们要最大化贡献和。所以我们可以将第一条直径上的边赋值为 $-1$，其余赋值为 $1$，再找一次直径。这样我们得出的第二条直径就是能够最大化贡献的第二个环（当然这个环包含了端点之间的边）。</p>
180

181
      <p>
182
       <!-- /wp:paragraph --></p>
183

184
      <p>
185
       <!-- wp:paragraph --></p>
186

187
      <p>于是当 $k=2$ 时，设第一条直径长度为 $l_1$，第二条为 $l_2$，原边数为 $x$，则最终答案为 $2x-l_1-l_2+2$。</p>
188

189
      <p>
190
       <!-- /wp:paragraph --></p>
191

192
      <p>
193
       <!-- wp:separator --></p>
194

195
      <hr class="wp-block-separator" />
196

197
      <!-- /wp:separator -->
198
      <p></p>
199

200
      <p>
201
       <!-- wp:heading {"level":1} --></p>
202

203
      <h1>最近公共祖先 $\text{LCA}$</h1>
204

205
      <p>
206
       <!-- /wp:heading --></p>
207

208
      <p>
209
       <!-- wp:paragraph --></p>
210

211
      <p>朴素方法就是两个点先移到同样的深度，然后一条边一条边向上移。这种方法单次求就达到了线性的复杂度，不能处理较大数据。</p>
212

213
      <p>
214
       <!-- /wp:paragraph --></p>
215

216
      <p>
217
       <!-- wp:paragraph --></p>
218

219
      <p>我们能否再低于线性的复杂度内求得 $LCA$？当然是可以的，使用 <em>倍增算法</em>。</p>
220

221
      <p>
222
       <!-- /wp:paragraph --></p>
223

224
      <p>
225
       <!-- wp:paragraph --></p>
226

227
      <p>我们定义 $f[i][j]$ 表示节点 $i$ 的上 $2^j$ 级祖先。我们可以先一遍 $dfs$ 预处理出相关信息。</p>
228

229
      <p>
230
       <!-- /wp:paragraph --></p>
231

232
      <p>
233
       <!-- wp:enlighter/codeblock --></p>
234

235
      <pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">void dfs(int x,int fa)

展开收起

{ f[x][0]=fa,d[x]=d[fa]+1; for(int i=1;i<=lg[d[x]];i++) f[x][i]=f[f[x][i-1]][i-1]; for(int i=head[x];i;i=nxt[i]) if(ver[i]!=fa)dfs(ver[i],x); }

1
      <p>
2
       <!-- /wp:enlighter/codeblock --></p>
3

4
      <p>
5
       <!-- wp:paragraph --></p>
6

7
      <p>于是我们用树上倍增求出 $x,y$ 的最近公共祖先，具体而言：</p>
8

9
      <p>
10
       <!-- /wp:paragraph --></p>
11

12
      <p>
13
       <!-- wp:list {"ordered":true} --></p>
14

15
      <ol>
16

17
       <li>将点的深度调节一致；</li>
18

19
       <li>将 $x,y$ 树上倍增上移至 $f[x][0]=f[y][0]$。</li>
20

21
      </ol>
22

23
      <p>
24
       <!-- /wp:list --></p>
25

26
      <p>
27
       <!-- wp:paragraph --></p>
28

29
      <p>然后 $f[x][0]$ 即为所求。</p>
30

31
      <p>
32
       <!-- /wp:paragraph --></p>
33

34
      <p>
35
       <!-- wp:enlighter/codeblock --></p>
36

37
      <pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">//树上倍增

展开收起

inline int LCA(int x,int y) { if(d[x] <d[y])swap(x,y); while(d[x]=""> d[y]) x=f[x][lg[d[x]-d[y]]-1]; if(x==y)return x; for(int k=lg[d[x]]-1;k>=0;k—) if(f[x][k]!=f[y][k]) x=f[x][k],y=f[y][k]; return f[x][0]; }

//主函数中 for(int i=1;i<=n;i++) lg[i]=lg[i-1]+(1< <lg[i-1]==i); d[1]=“1,dfs(1,1);” for(int="" i=“1;i<=m;i++)” {="" int="" x=“read(),y=read();” printf(“%d\n”,lca(x,y));="" }<="" re="">

1
         <p>
2
          <!-- /wp:enlighter/codeblock --></p>
3

4
         <p>
5
          <!-- wp:heading --></p>
6

7
         <h2>$\text{LCA}$ 的应用</h2>
8

9
         <p>
10
          <!-- /wp:heading --></p>
11

12
         <p>
13
          <!-- wp:heading {"level":3} --></p>
14

15
         <h3><a href="https://www.luogu.com.cn/problem/P3398">P3398 仓鼠找sugar</a></h3>
16

17
         <p>
18
          <!-- /wp:heading --></p>
19

20
         <p>
21
          <!-- wp:paragraph --></p>
22

23
         <p>判断 $(a,b),(c,d)$ 两条路径是否相交。</p>
24

25
         <p>
26
          <!-- /wp:paragraph --></p>
27

28
         <p>
29
          <!-- wp:paragraph --></p>
30

31
         <p>有个非常显然的结论就是，当 $LCA(a,b)$ 在路径 $(c,d)$ 上或 $LCA(c,d)$ 在路径 $(a,b)$ 时就是相交的。</p>
32

33
         <p>
34
          <!-- /wp:paragraph --></p>
35

36
         <p>
37
          <!-- wp:quote --></p>
38

39
         <blockquote class="wp-block-quote">
40
          <p>这是因为每个节点的父亲是唯一的。所以如果相交的话，必然会有一个点同时在两条路径上，而且是其中一条的公共祖先。否则若所有相交的点都不是 $LCA$，那么至少会出现一个点有两个父亲，这不符合树的定义。</p>
41

42
         </blockquote>
43

44
         <p>
45
          <!-- /wp:quote --></p>
46

47
         <p>
48
          <!-- wp:paragraph --></p>
49

50
         <p>上面只是一个粗略的证明，详细内容就不写了，感性理解一下。</p>
51

52
         <p>
53
          <!-- /wp:paragraph --></p>
54

55
         <p>
56
          <!-- wp:paragraph --></p>
57

58
         <p>于是我们判断深度较大的 $LCA$ 是否在另一条的路径上即可。</p>
59

60
         <p>
61
          <!-- /wp:paragraph --></p>
62

63
         <p>
64
          <!-- wp:heading {"level":3} --></p>
65

66
         <h3><a href="https://www.luogu.com.cn/problem/P4281">P4281 紧急集合</a></h3>
67

68
         <p>
69
          <!-- /wp:heading --></p>
70

71
         <p>
72
          <!-- wp:paragraph --></p>
73

74
         <p>因为树上的最短路径是唯一的，所以我们不妨先求出三个点的 $LCA$。</p>
75

76
         <p>
77
          <!-- /wp:paragraph --></p>
78

79
         <p>
80
          <!-- wp:paragraph --></p>
81

82
         <p>设三个点的 $LCA$ 分别为 $x,y,z$，经过简单的思考，我们不难得出以下两个结论：</p>
83

84
         <p>
85
          <!-- /wp:paragraph --></p>
86

87
         <p>
88
          <!-- wp:list {"ordered":true} --></p>
89

90
         <ol>
91

92
          <li>这三个点最多会在两个不同的位置；</li>
93

94
          <li>集合点选取在两两重合的 $LCA$ 处比单独的 $LCA$ 处更优。</li>
95

96
         </ol>
97

98
         <p>
99
          <!-- /wp:list --></p>
100

101
         <p>
102
          <!-- wp:paragraph --></p>
103

104
         <p>直接找到即可。</p>
105

106
         <p>
107
          <!-- /wp:paragraph --></p>
108

109
         <p>
110
          <!-- wp:paragraph --></p>
111

112
         <p><strong>证明</strong></p>
113

114
         <p>
115
          <!-- /wp:paragraph --></p>
116

117
         <p>
118
          <!-- wp:quote --></p>
119

120
         <blockquote class="wp-block-quote">
121
          <p>对于第一个结论，我们先在树上选取 $LCA$，然后证明至少有两个点要选在同一个位置。</p>
122

123
          <p>计以第一次选取的点 $x$ 为共同祖先的两条路径为 $U_1,V_1$。当我们选取第二个点 $y$ 作为 $LCA$ 的时候，我们必须要让它的两条路径 $U_2,V_2$ 中的一条经过 $x$，且覆盖其中一条路径的全部。这是因为如果不经过 $x$，则会有一个点出现两个父亲；而如果不覆盖全部路径的话，会除了 $x$ 和 $y$ 之外会出现四个端点，这与题目中的三个点不符。</p>
124

125
          <p>关于第二个结论，证明类似树的重心，故不放出了。</p>
126

127
         </blockquote>
128

129
         <p>
130
          <!-- /wp:quote --></p>
131

132
         <p>
133
          <!-- wp:heading {"level":3} --></p>
134

135
         <h3><a href="https://www.luogu.com.cn/problem/P1967">P1967 货车运输</a></h3>
136

137
         <p>
138
          <!-- /wp:heading --></p>
139

140
         <p>
141
          <!-- wp:paragraph --></p>
142

143
         <p>在原图上构建最大生成树，然后在生成树上跑 $LCA$ 求解。</p>
144

145
         <p>
146
          <!-- /wp:paragraph --></p>
147

148
         <p>
149
          <!-- wp:enlighter/codeblock --></p>
150

151
         <pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">const int SIZE=100005;

展开收起

const int INF=99999999; int ver[SIZE],nxt[SIZE],val[SIZE],tot,head[SIZE]; void add(int x,int y,int z) { nxt[++tot]=head[x],ver[tot]=y,val[tot]=z,head[x]=tot; } struct node{int u,v,w;}a[SIZE]; int n,m,d[SIZE],f[SIZE],fat[SIZE][50],dp[SIZE][50],q,v[SIZE]; bool cmp(node x,node y){return x.w>y.w;} int find(int x) { if(f[x]==x)return x; return f[x]=find(f[x]); } void dfs(int x) { v[x]=1; for(int i=head[x];i;i=nxt[i]) { int y=ver[i],z=val[i]; if(!v[y]) d[y]=d[x]+1,fat[y][0]=x, dp[y][0]=z,dfs(y); } } int LCA(int x,int y) { if(find(x)!=find(y))return -1; int ans=INF; if(d[x]>d[y])swap(x,y); for(int i=25;i>=0;i—) if(d[fat[y][i]]>=d[x]) ans=min(ans,dp[y][i]),y=fat[y][i]; if(x==y)return ans; for(int i=25;i>=0;i—) if(fat[x][i]!=fat[y][i]) ans=min(ans,min(dp[x][i],dp[y][i])), x=fat[x][i],y=fat[y][i]; ans=min(ans,min(dp[x][0],dp[y][0])); return ans; } void kruskal() { sort(a+1,a+m+1,cmp); for(int i=1;i<=n;i++)f[i]=i; for(int i=1;i<=m;i++) if(find(a[i].u)!=find(a[i].v)) { f[find(a[i].u)]=find(a[i].v); add(a[i].u,a[i].v,a[i].w); add(a[i].v,a[i].u,a[i].w); } } int main() { n=read(),m=read(); for(int i=1;i<=m;i++) { int x=read(),y=read(),z=read(); a[i].u=x,a[i].v=y,a[i].w=z; } kruskal(); for(int i=1;i<=n;i++) if(!v[i]) d[i]=1,dfs(i), fat[i][0]=i,dp[i][0]=INF; for(int i=1;i<=25;i++) for(int j=1;j<=n;j++) fat[j][i]=fat[fat[j][i-1]][i-1], dp[j][i]=min(dp[j][i-1],dp[fat[j][i-1]][i-1]); q=read(); for(int i=1;i<=q;i++) { int x=read(),y=read(); printf(“%d\n”,LCA(x,y)); } return 0; }

1
         <p>
2
          <!-- /wp:enlighter/codeblock --></p>
3

4
         <p>
5
          <!-- wp:paragraph --></p>
6

7
         <p>
8
          <!-- /wp:paragraph --></p>
9

10
        </lg[i-1]==i);>
11
       </d[y])swap(x,y);></pre>
12
     </n;i++)></pre>
13
   </r)m2=m1,m1=r;></pre>
14
 </ans)ans=mxpt,p=x;></pre>

</ans)ans=mxpt,p=x;>

树莓派上部署MC服务器（Java版）

Fri, 06 Aug 2021 00:00:00 GMT

MC毕竟是沙盒游戏，一个人玩未免感觉无聊
本篇教程会引导你如何搭建一台多人联机的MC服务器

0.安装OpenJDK

OpenJDK不用到处找了，使用这个文件就好（清华源）
Arm64版OpenJDK1.8
h ttps://mirrors.tuna.tsinghua.edu.cn/AdoptOpenJDK/deb/pool/main/a/adoptopenjdk-8-openj9/adoptopenjdk-8-openj9_8u292-b10.openj9-0.26.0-3_arm64.deb
如果你用的是x64架构的Linux，使用这个文件：
https://mirrors.tuna.tsinghua.edu.cn/AdoptOpenJDK/deb/pool/main/a/adoptopenjdk-8-openj9/adoptopenjdk-8-openj9_8u292-b10.openj9-0.26.0-3_amd64.deb

文件下载好了，就开始安装吧

#推荐使用gdebi安装
sudo apt install gdebi-core #安装gdebi
sudo gdebi [你下载的deb]

看到这些就好了

1.下载服务器Jar包

这里使用Spigot服务器，玩mod的可用forge
官方安装办法是自己使用buildtools构建，但是下载构建文件速度太慢，这里推荐直接下载
到这里选择版本：https://getbukkit.org/download/spigot
这里以MC版本1.16.5为例

cd 你想要安装mc服务器的文件夹/
wget -O spigot.jar https://cdn.getbukkit.org/spigot/spigot-1.16.5.jar #1.16.5可以换成你要的版本，比如1.17.1

2.运行服务器&服务器配置

java -jar spigot.jar

运行后，有可能出现这种情况，等20秒就好了（这提示真的烦）：

等了20秒还没启动，输出了一些信息：

多了一点文件，找到eula.txt，然后把false改成true就行

server.properties的配置内容很易懂 ~~（不懂你翻译一下嘛）~~
很重要的一点是把online-mode设置为false，否则非正版/第三方进不来

重新运行~ ~~（然后又要等20秒）~~

你就会发现，他正在加载了！

等到终端输出Done，你就可以在MC里输入服务器ip:25565 进服了！

在树莓派上部署神经机器翻译（附API）

Thu, 29 Jul 2021 00:00:00 GMT

在完成?这一章的环境搭建，接着就可以开心地搭建神经机器应用了！

warning 注意
本教程树莓派的环境是树莓派4B+4G，Ubuntu20.04LTS，Linux ubuntu 5.4.0-1041-raspi #45-Ubuntu SMP PREEMPT Thu Jul 15 01:17:56 UTC 2021 aarch64 aarch64 aarch64 GNU/Linux。您可以命令 uname -a 来查看。

导入仓库

这里从GitHub上找来了一个成品，在此感谢作者。仓库链接：taoztw/Transformer: pytorch实现Transformer，提供机器翻译案例和简单的翻译api接口(flask)。评分组件使用BLEU。 (github.com)

克隆一下：

git clone https://github.com/taoztw/Transformer.git

GitHub速度慢的可以自行百度换源。克隆完成后，进入文件夹目录。

cd Transformer/

这时还不能直接运行，需要修改一下代码。

打开model.py。

找到第75、76行，替换成以下内容：

        div_term = torch.exp(torch.tensor(torch.arange(0,d_model,2,device=DEVICE) *
                             (-math.log(10000.0) / d_model),dtype=torch.float))

将第79、80行替换成：

        pe[:,0::2] = torch.sin(position.float() * div_term)
        pe[:,1::2] = torch.cos(position.float() * div_term)

改完后如图所示：

安装依赖库

warning 警告
请保持所有您命令行中python、pip的版本和原来安装pytorch的版本一致，否则无法使用。

安装nltk

pip install nltk

最后安装成功：

Installing collected packages: typing-extensions, zipp, importlib-metadata, click, regex, tqdm, joblib, nltk
Successfully installed click-8.0.1 importlib-metadata-4.6.1 joblib-1.0.1 nltk-3.6.2 regex-2021.7.6 tqdm-4.61.2 typing-extensions-3.10.0.0 zipp-3.5.0

下载punkt

如果您使用nltk.download()来下载punkt，恐怕不是非常好用。您很可能会失败。这里用wget直接下载导入。

在仓库的主目录创建一个文件夹tokenizers并进入。

TIP：这里同时新建一个save文件夹，用来存放训练好的东西。

mkdir tokenizers
mkdir save
cd tokenizers

用国内源下载，解压：

wget https://codechina.csdn.net/mirrors/nltk/nltk_data/-/raw/gh-pages/packages/tokenizers/punkt.zip
unzip punkt.zip

最后结构如图所示：

运行，开始训练

返回主目录，然后运行训练模块。

cd ..
python train.py

遇到如下输出不用着急：

/home/ubuntu/Transformer/model.py:75: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).
  (-math.log(10000.0) / d_model),dtype=torch.float))

不用理会，慢慢等待数据跑完（CPU满负荷ing...）。

此时，不要浪费时间了，我们应该去干一些有意义的事情 ，比如——学习。

启动服务

安装依赖

首先安装依赖。

pip install flask
pip install flask_sqlalchemy
pip install flask_cors
pip install pymysql
pip install mysqlclient

然后往服务器上添加如图所示的数据库。数据库名：message，编码：utf-8，用户名：message，密码随意。

warning 警告
数据库一般来说是MySQL类型，不是的话请您自行百度。

打开app.py，将第17行修改如下：

app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://message:密码@127.0.0.1:3306/message?charset=utf8'

训练完成，启动服务。运行：

python app.py

一开始会有几行警告内容。然后输出：

 * Debugger is active!
 * Debugger PIN: 133-091-512

此时说明服务启动成功了。

测试！

下面随便测试了一些字词：

翻译结果有些奇奇怪怪，大概是训练次数不够多。不过强差人意，勉强能用。

flask api请求参数

简单api，没有进行检查校验和异常处理

转作者readme.md

// POST请求参数
{
  "sentence": "your  translation sentences"
}
// return
{
  "result": "翻译结果",
  "msg": 'success',
  "code": 200
}

在树莓派4B Ubuntu20.04LTS 上部署 Conda 与 Pytorch

Wed, 28 Jul 2021 00:00:00 GMT

为了写这篇文章折腾了一个星期。在网上都没有找到合适的教程，只能自己东拼西凑地摸索。下面总结出了搭建的方法，大家可以少踩?。

安装Conda

下面列举了几种时下流行的Conda版本：

版本	特性	√or×
原生Conda	不支持armv8、aarch64（反正在本机上没法装）	×
berryConda	版本过老，不推荐使用	×
achiConda	完美解决以上问题，即适配，版本也新	√

所以在armv8的Ubuntu20.04LTS上，装achiConda是最好的选择。

achiConda的GitHub下载页面：Release Archiconda With just conda-forge · Archiconda/build-tools (github.com)。

您当然可以下载最新的版本。这里以当前0.2.3版本为例（不过我觉得作者不打算更新了）。

下载并安装安装包（不需要管理员身份）：

wget https://github.com/Archiconda/build-tools/releases/download/0.2.3/Archiconda3-0.2.3-Linux-aarch64.sh
chmod +x Archiconda3-0.2.3-Linux-aarch64.sh
bash Archiconda3-0.2.3-Linux-aarch64.sh

接着您需要手动操作。狂按Enter阅读协议，然后输入yes安装。

等待安装完毕，在命令行中输入python，看看是否安装成功。

当出现如图圈出来的信息时，就说明安装成功了。

按CTRL+Z退出python。

Pytorch编译并安装

warning TIP
不想自己编译的可以使用笔者编译好的。下载后导入服务器，直接转到“安装”一节进行操作。下载链接：https://wwr.lanzoui.com/io6nmrxydzc 请自行解压。

编译

首先安装一些依赖：

sudo apt-get install libopenblas-dev cython3 libatlas-base-dev m4 libblas-dev cmake
sudo apt-get install python3-dev python3-yaml python3-setuptools python3-wheel python3-pillow python3-numpy

接着设置基本参数：

export NO_CUDA=1
export NO_DISTRIBUTED=1
export NO_MKLDNN=1
export NO_NNPACK=1
export NO_QNNPACK=1

warning 提示
如果您在后面的操作中发现终端提示该“NO_...”以弃用，请使用“USE_...”，那么请输入终端：

export USE_CUDA=0
export USE_DISTRIBUTED=0
export USE_MKLDNN=0
export USE_NNPACK=0
export USE_QNNPACK=0

安装numpy：

pip3 install numpy pyyaml

warning 提示
不装numpy也可以，但是您在使用pytorch的时候将无法支持numpy。

设置交换内存：

当您的树莓派内存小于8G的时候，建议设置交换内存。笔者用4G的编译的时候，发现还是内存溢出。这里设置4G的交换内存。

sudo dd if=/dev/zero of=/swapfile count=4096 bs=1M
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

交换内存设置开机启动：

sudo nano /etc/fstab
#在最后一行加入：
/swapfile none swap sw 0 0
#退出保存即可

克隆Pytorch库：

git clone https://github.com/pytorch/pytorch.git
cd pytorch
git checkout v1.6.0
git submodule update --init  --recursive
git submodule update --remote third_party/protobuf

由于网络环境有差异，您可能需要将第4条命令多执行几遍。笔者这里总共大约克隆了2小时QWQ……

编译！

python3 setup.py bdist_wheel

编译过程大约5小时。您可以睡一觉。如果发现意外退出了，一般来说是因为内存不够。试着添加swap内存。

最后，当您看到如图所示的信息，恭喜，编译成功了！

安装

安装相对快多了。输入命令（请注意文件名）：

cd dist
pip3 install torch-1.2.0a0+8554416-cp37-cp37m-linux_aarch64.whl

如果出现以下错误：

不要担心。试着使用其他版本的pip。该pip版本应该是您编译Pytorch时使用的python版本。

试着输入：

pip install torch-1.2.0a0+8554416-cp37-cp37m-linux_aarch64.whl

安装成功！打开python试验一下：

成功导入！至此，安装全部完成！撒花！

iPhone越狱失败后无法退出DFU界面解决方法

Tue, 27 Jul 2021 00:00:00 GMT

如题，新装的iPhone想要越狱，在某思助手的操作下安装了unCl0ver，但遗憾的是越狱失败，无法正常开机。

在网上search了一番无果。后来经过自己摸索，避免大家踩坑，本教程教您无损开机，保留手机原数据。

解决方案

打开某思助手，进入刷机界面。

选择一键刷机。在找到并下载合适的固件后，请在下方菜单栏中选择保留用户资料刷机，然后点击立即刷机。

耐心等待，直到刷机进度到达大约80%，会显示刷机失败错误。此时关闭助手，直接拔掉数据线，将iPhone长安Home键和关机键（全面屏机型为音量键和关机键），等待iPhone重启，进入主屏幕。

注意，以后要小心，不能随意关机了！注意备份！

原理

越狱失败后手机部分文件系统损坏，故无法正常开机。部分刷机后修复了损坏的系统文件，故又能正常开机。

善用快捷指令：快速打开健康码

Fri, 09 Jul 2021 00:00:00 GMT

快捷指令是一个神奇而强大的工具。利用快捷指令，您可以完成许多自动化的操作。这期教程教您如何轻点iPhone背面快速打开健康码。

本教程需要用到支付宝小程序

预备节

首先打开健康码小程序。点击右上角的“···”调出菜单。

点击“添加到桌面”。

这时您的默认浏览器会打开。

复制上方的地址。

不出意外，该地址或许是：

https://render.alipay.com/p/s/shortcut/index?appId=2019011763060066&appName=国家政务服务平台&appIcon=https://appstoreisvpic.alipayobjects.com/prod/90d1c8cf-3f1f-41c2-b7df-2dbbf428f1a0.png@120w.png

快捷指令操作

打开快捷指令，新建一个指令。

插入一个文本块。

把刚刚复制的粘贴进去。

切换至英文输入，将其中的https://render.alipay.com/p/s/shortcut/index?替换成alipays://。

前

后

接着在其后插入一个“打开url”。

基本程序完成了。接着命名程序并保存。

实现轻点背面打开

注：该功能只支持全面屏机型。

打开设置->辅助功能->触控->轻点背面->轻点两下（三下也?️）。

滑动到下面，找到“快捷指令”选项，再选择刚才创建的指令。

大功告成！

现在轻轻敲击iPhone背面两下（敲击区域在Apple的logo处灵敏度最佳），看看是否奏效。

宁夏の旅 Day5

Fri, 09 Jul 2021 00:00:00 GMT

早上来到了当地的北堡影视城。在这里拍过超300部电视剧&影片。

取景地

在这里曾经拍摄过周星驰的大话西游。整个影视城主要分布有明城、清城和民国城。在园区内还分有很多重要取景处，是上好的网红打卡点。

贺兰山岩画

贺兰山岩画与影视城相差并不远，大约20分钟的车程就能达到。

在贺兰山东麓发现了数以万计的古代岩画，它记录了远古人类在3000年前至10000年前放牧、狩猎、祭祀、争战、娱舞、交媾等生活场景，以及羊、牛、马、驼、虎、豹等多种动物图案和抽象符号，揭示了原始氏族部落自然崇拜、生殖崇拜、图腾崇拜、祖先崇拜的文化内涵，是研究中国人类文化史、宗教史、原始艺术史的文化宝库。

——百度百科

害怕的羊

酒庄

小憩过后，与傍晚来到一处酒庄。

这里拥有许多酒种，色泽鲜艳，（但未品尝）。

iPhone 相机升值指南

Thu, 08 Jul 2021 00:00:00 GMT

打开九宫格

先打开设置，进入“相机”设置选项。

然后开启“网格”选项。

然后在相机中就能看到九宫格了。

善用拍照按钮

在默认的照片界面，您可以快捷地进行连拍快照和视频录制。

连拍快照

在iOS13及以前的版本中，连拍快照通常是长按拍照按钮进行的。但现在进行连拍快照的方法是，将拍照按钮拖到左边。

视频录制

相反，长按拍照按钮就可以快速进行录像。

从视频里还可以看到，将小红点拖到右边就不用辛苦地一直按着了。

广角摄像头

注：该功能只适合部分机型。

轻点1x的按钮就能切换成0.5x的广角；再轻点一下，就能切换回正常模式。

夜景：持续曝光

在相对黑暗的环境中，iPhone才能自动打开持续曝光功能。

点击左上角“太阳/月亮”按钮，进一步调整。

那个黄色的按钮

接着可以进行曝光时常的调整。

如图

接着进行拍照。当时长超过1秒，您就回看到以下界面。请保持十字在中心尽量保持不变。

宁夏の旅 Day4

Thu, 08 Jul 2021 00:00:00 GMT

水洞沟

水洞沟是国家AAAAA级景区。这是中国最早发掘的旧石器时代文化遗址，被誉为“中国史前考古的发祥地”，还被《国家地理》和《中国遗产》杂志联合评选为中国“最具中华文明意义的百项考古发现之一”。

大门口

博物馆实景体验

进入园区，首先游览博物馆。在博物馆内部，有一体验馆。该体验馆为游客展示了水洞沟石器时代的人类文明进程。内有地震模拟器、全息投影，感官逼真。

内景

张三小店

没错，这个人名就叫张三。当时在水洞沟进行考古发掘的两个法国人就在这个小店住宿。出了博物馆就能看到。

大门

床铺

一脚跨两省：长城遗址

走出张三小店，就可以看到一段长城遗址。这是“中国保留的最好的立体长城遗址”。

两省分界线：建于长城之上

真

特色观光车

接着，就可以连续乘上两种特色观光车：马车与驼车。驾车员还会在车上高歌一曲当地的民歌（?）。

坐在车里看风景

赠送一首录音下来的山西民歌

藏兵洞

藏兵洞是古代的一种军事设施，类似近代的地堡暗道，可埋伏奇兵出其不意攻击对方，多建于古代城市城墙或者关隘。

——百度百科

藏兵洞里很黑，装有各种暗器，左生右死。当然现在已没有安全隐患。

枸杞馆

提示：本文不含任何商业推广信息！

没什么好讲的，不过于推销，推销，再推销。就上几张图了。

宁夏の旅 Day3

Wed, 07 Jul 2021 00:00:00 GMT

早上起不来了，匆匆罢完早饭，即刻启程。

早上前往沙坡头。

大门口

往景区里走，最重要的游览项目在一座大沙丘上。通往沙丘上，可以步行、坐索道，或是乘电梯，电梯分为三节。

挺高的

电梯（扶梯）大约乘了5分钟，到达沙丘顶。沙丘顶上可以看到浊流婉转的黄河。

黄河

沙丘上仍有治沙的标语。

那上面的是公路

向沙漠进军

——竺可桢

顺带一提，这里的沙子非常细。比松兰山的细了很多。

黄河玻璃桥

顾名思义，这个玻璃桥悬空而建，桥底是透明的玻璃。

还有部分桥段的地面是贴着不透明图形的，可以拍起特效。

青铜峡黄河大峡谷

石碑

大门

干货！

青铜峡水利枢纽

进入景区，先乘观光车，游览青铜峡水利枢纽。

干货✖️2

大坝✖️水电站

一百零八塔

地面上的石碑

山顶俯瞰

一百零八塔是佛教建筑。这些塔原本是一百零八个土堆，现在是后期用砖头垒起来的。

108在佛教里是个重要的数字，塔代表着108种忧愁。据说按顺时针登上这些塔，就能消除一切忧愁。

黄河楼·夜景

众多景点

正值日落时分。驱车来到黄河楼。

大门口

内景

黄河楼的主楼不在整体的正中心位置上。从上图可以看到，如果要把黄河楼置于正中心上的话，拍摄者就必须站在斜对角的位置上。

日暮将至，夜穹袭来。拍摄夜景的好机会来了。

登上塔楼（电梯），鸟瞰全市。

再来：

我在黄河边等你

走出黄河楼，是黄河母亲雕塑。

在该巨大的石像中，左手托着的是书卷，右手托着的是稻穗。与青海的一样，这寓意着中原文化在黄河的哺育下发源滋长！

相关链接：拍夜景（详见文末）

宁夏の旅 Day2

Tue, 06 Jul 2021 00:00:00 GMT

沙湖

今天8:00从酒店启程。前往沙湖。

沙湖生态景区位于宁夏内部，在沙丘中有类似“元宝眼”的中心湖泊。

通湖草原

下午前往位于内蒙古的通湖草原。

其实也就是宁夏与内蒙古的边境

有关当地的一些笔记

内蒙古降水不到100ml，土质为砂石岩，不适合植物生长。

游客游览的普遍是流动沙丘，这是在风吹的作用下形成的高低起伏的沙丘。

在跨过贺兰山的高速公路上，海拔不断升高。高速公路是建在贺兰山的山缺口上的，信号不好，车流稀少。沿途有牛、骆驼和羊。

路牌有蒙古语和汉语（宁夏只有汉语cuz回族没有自己的语言和文字）。

在中国有很多地方有沙漠。有些沙漠只有一个驼峰，如撒哈拉沙漠的骆驼，当地为热带沙漠，处于赤道附近。而蒙古当地的沙漠骆驼为双峰驼，由于处于热带沙漠，早晚温差大，能量不易储存，散发热量多。

这是对环境的适应。当有风沙时，骆驼的瓣膜就会脱落下来抵挡风沙。

骆驼的鼻孔能感知方圆1.5km内的水源。它还能做到15至20天不进食，但2至3天需要喝一次水。

沙漠是能涵养水源的。事实上，低矮的沙丘里储存有水。

关于当地的生态保护措施：当地政府推平沙丘，防风固沙+发电（太阳板），若干年后沙丘上撤去了太阳板，地上长草，形成草坪。

多年前，这里改造过一条战略铁路。当时前苏联与我国关系恶化，便需要运输部队至边疆区域。于是，这条战略铁路孕育而生了。

施工人员们很快遇到了难题：不能在沙地上建造顽固的地基。只能防风固沙。

为了解决这一问题，麦草方格出现了（这是中卫人民的发明）。它能固定流动沙丘。在方格子内撒种子，并长出草种一季草还不够，才可能会因为营养不足而死亡。于是，反复种植，枯死的草作为肥料，进行下一季的种植。

进入景区

4K 壁纸

这基本上就是沙漠景观了。成堆的沙丘中，您可以进行多种有趣的活动。

篝火晚会

最后的最后，在景区内部举行了蒙古族的篝火晚会。 ~~世界灿烂盛大，欢迎回家~~

刚开始

快结束

附4K60fps视频

宁夏の旅 Day1

Mon, 05 Jul 2021 00:00:00 GMT

清晨启程，随团乘上大巴。前往杭州萧山机场。

10:00，到达萧山机场。

收费站

机场内部

等飞机……买了杯……

整整迟了四个小时，才登上飞机。

乘上飞机，在山东经停了一站，最后耗时12个小时辗转到宁夏银川机场。此时已是下午8:00。

千沟万壑

黄土高原

7:30的宁夏仍是落日时分

沿途路上

奇特的树木

今年宁夏的对外宣传口号是“塞上江南 神奇宁夏”，当地降水量不到200ml，但大面积种植水稻。您基本上不会看到降雨天气（附：机场厕所的水龙头都是喷水状的，以节约水资源）。在当地8:00落日是常态，晚餐大约在7:00举行。

宁夏在贺兰山和黄河东边，故当地银川市机场名为河东机场。

附灰机降落?️视频：

当地35%的人口为回族，是几大自治区之一。回族信奉的是伊斯兰教，出于尊重当地名族，该地餐馆基本上为清真餐馆。人们以“大肉”代替“猪肉”。

走，去钓黄鳝！

Fri, 02 Jul 2021 00:00:00 GMT

warning FBI WARNING!!!
本文含有大量【高清】图片和【高帧】视频。请小心您的流量（

无聊的暑假又到了！出去走走！

地点

~~真是一块风水宝地！~~ 下午，约了个同学，驱车前往某村。

lj全景图，拍得不好

弃置的船

切入正题

钓黄鳝首先要做一些准备工作。初次学习，比较繁琐。

引导

您放大一下图片就会发现，末端是一段铁丝，可以用来穿蚯蚓做诱饵；末端的方块是泡沫板，可以浮在水面；最后面还有铃铛和挂钩。（至于作用……hh

ffafanfangfanfaf

↑放蚯蚓的桶

置入洞穴中

众所周知，黄鳝藏身与荷塘边的洞穴中。笔者得知：

黄鳝可馋了

（

我们需要用一个带接口的长铁棍（很遗憾没拍到）把引导固定在其末端，然后伸入洞穴中，再向上一提，引导就能待在洞里了（当然，末端蚯蚓部分是深深伸入洞中的）。

然后就像这样了：

浮动的引导

接着，就等黄鳝咬蚯蚓了。如果咬上了，那么恭喜，铃铛摇响，您可以前去查看了。

于是乎，等了一会，一个引导果然响了。前去查看。

捕捉！

你以为引导就能直接把黄鳝钓上来？没那么简单！引导上又没有鱼钩。

您还需要另一个特殊构造的鱼竿，勾上蚯蚓。先把引导从洞里抽出来，然后再把“鱼竿”伸进去（这个“鱼竿”上是有钩子的）。

↑鱼竿长这样（已经钓上来了哈）

意外的惊喜

第一次上钩，黄鳝倒是没掉上，倒是钓上了个……（？）

好家伙。被当玩具玩了……（逃

大鹏展翅

改邪归正

总算又一个上钩了。拍了一个慢动作视频（不知道为什么传到电脑上就没有慢动作了，倒是帧数很高）：

接着，把虾哥和黄鳝放在一起了：

还在玩（

接着，其他几个引导接二连三地响起。一条条黄鳝都被捕获。

彩蛋

不甘心就这样结束了，于是到周围逛了逛，风景很好。拍了几张照片以及一些视频。

鸭鸭！

Sublime Text 4与VSCode的汉化

Mon, 14 Jun 2021 00:00:00 GMT

某天突然手残重装了系统，结果软件全部灰飞烟灭了QWQ，许多软件不得不重新安装……趁着这次 ~~好机会~~ ，本人顺便就写了些教程……

Sublime Text 4的汉化

首先打开sublime。

点击菜单栏里的Tools，点击Install Package Control。

接着，Sublime会卡那么一下子，然后提示安装完成。

提示安装完成

接着点击Preferences -> Package Control。

在弹出的对话框中输入Install Package，并选择其选项。您可以单击也可以按回车以选择（如下图）。

选择该选项

接着，在输入框里输入ChineseLocalizations，并选择。

选择语言插件

等待左下角提示安装完成。

然后就能完成汉化啦！

成功！

VSCode的汉化

打开VSCode的扩展程序菜单，在搜索框里输入Chinese。

点击第一个中文(简体)选项的Install。

过几秒后，点击右下角提示框的Restart Now。

然后您的VSCode就是中文的了！

QWQ！

CloudFlare 自选IP测试

Tue, 01 Jun 2021 00:00:00 GMT

在搭建*2**yN服务器时，因反向代理需要用到CF的自选IP，在网上搜寻发现有很多IP都已失效了。于是自己搞了个代码测试了一下，供大家使用。

首先进入CloudFlare的官方IP list：IP Ranges | Cloudflare

您可以在这里看到CF最近更新的IP地址库。当然，您也可以点击IPv4 text list以及IPv6 text list来查看以txt形式呈现的IP列表。

考虑到IPv4普及度较高，这里就以IPv4进行测试。

把IP地址都复制下来，编辑进代码里：

from ping3 import ping
def p(ip):
ip_address = ip
response = ping(ip_address)
if response is not None:
delay = int(response * 1000)
return delay
else:
return 2333
l=[
“173.245.48.0/20”,
“103.21.244.0/22”,
“103.22.200.0/22”,
“103.31.4.0/22”,
“141.101.64.0/18”,
“108.162.192.0/18”,
“190.93.240.0/20”,
“188.114.96.0/20”,
“197.234.240.0/22”,
“198.41.128.0/17”,
“162.158.0.0/15”,
“172.64.0.0/13”,
“131.0.72.0/22”,
“104.16.0.0/13”,
“104.24.0.0/14”
]
for i in l:
root=i[.rfind(”.”)]+’.’
j=0
while j<=int(i[i.find(”/”)+1:]):
j+=1
b = p(str(root)+str(j))
if(b==2333):
print(str(root)+str(j),”×”)
else:
print(str(root)+str(j),b)

然后慢慢运行。笔者本地的网络运营商是电信，一下数据可供您参考：

173.245.48.1 184
173.245.48.2 ×
173.245.48.3 ×
173.245.48.4 ×
173.245.48.5 ×
173.245.48.6 ×
173.245.48.7 ×
173.245.48.8 ×
173.245.48.9 ×
173.245.48.10 ×
173.245.48.11 ×
173.245.48.12 ×
173.245.48.13 ×
173.245.48.14 ×
173.245.48.15 ×
173.245.48.16 ×
173.245.48.17 ×
173.245.48.18 ×
173.245.48.19 ×
173.245.48.20 ×
173.245.48.21 ×
103.21.244.1 221
103.21.244.2 254
103.21.244.3 237
103.21.244.4 261
103.21.244.5 221
103.21.244.6 240
103.21.244.7 218
103.21.244.8 240
103.21.244.9 238
103.21.244.10 258
103.21.244.11 224
103.21.244.12 241
103.21.244.13 238
103.21.244.14 287
103.21.244.15 240
103.21.244.16 238
103.21.244.17 239
103.21.244.18 240
103.21.244.19 247
103.21.244.20 242
103.21.244.21 261
103.21.244.22 279
103.21.244.23 238
103.22.200.1 155
103.22.200.2 ×
103.22.200.3 ×
103.22.200.4 ×
103.22.200.5 ×
103.22.200.6 ×
103.22.200.7 ×
103.22.200.8 ×
103.22.200.9 ×
103.22.200.10 ×
103.22.200.11 ×
103.22.200.12 ×
103.22.200.13 ×
103.22.200.14 ×
103.22.200.15 ×
103.22.200.16 ×
103.22.200.17 ×
103.22.200.18 ×
103.22.200.19 ×
103.22.200.20 ×
103.22.200.21 ×
103.22.200.22 ×
103.22.200.23 ×
103.31.4.1 ×
103.31.4.2 ×
103.31.4.3 ×
103.31.4.4 ×
103.31.4.5 ×
103.31.4.6 ×
103.31.4.7 ×
103.31.4.8 ×
103.31.4.9 ×
103.31.4.10 ×
103.31.4.11 ×
103.31.4.12 ×
103.31.4.13 ×
103.31.4.14 ×
103.31.4.15 ×
103.31.4.16 ×
103.31.4.17 ×
103.31.4.18 ×
103.31.4.19 ×
103.31.4.20 ×
103.31.4.21 ×
103.31.4.22 ×
103.31.4.23 ×
141.101.64.1 1587
141.101.64.2 ×
141.101.64.3 ×
141.101.64.4 270
141.101.64.5 257
141.101.64.6 264
141.101.64.7 237
141.101.64.8 268
141.101.64.9 ×
141.101.64.10 ×
141.101.64.11 256
141.101.64.12 264
141.101.64.13 267
141.101.64.14 258
141.101.64.15 253
141.101.64.16 251
141.101.64.17 261
141.101.64.18 255
141.101.64.19 ×
108.162.192.1 156
108.162.192.2 ×
108.162.192.3 168
108.162.192.4 149
108.162.192.5 156
108.162.192.6 169
108.162.192.7 155
108.162.192.8 151
108.162.192.9 162
108.162.192.10 141
108.162.192.11 143
108.162.192.12 153
108.162.192.13 148
108.162.192.14 186
108.162.192.15 155
108.162.192.16 166
108.162.192.17 170
108.162.192.18 165
108.162.192.19 143
190.93.240.1 ×
190.93.240.2 ×
190.93.240.3 ×
190.93.240.4 ×
190.93.240.5 ×
190.93.240.6 ×
190.93.240.7 ×
190.93.240.8 ×
190.93.240.9 ×
190.93.240.10 ×
190.93.240.11 ×
190.93.240.12 ×
190.93.240.13 ×
190.93.240.14 ×
190.93.240.15 ×
190.93.240.16 ×
190.93.240.17 ×
190.93.240.18 ×
190.93.240.19 ×
190.93.240.20 ×
190.93.240.21 ×
188.114.96.1 ×
188.114.96.2 ×
188.114.96.3 ×
188.114.96.4 ×
188.114.96.5 ×
188.114.96.6 ×
188.114.96.7 ×
188.114.96.8 ×
188.114.96.9 ×
188.114.96.10 ×
188.114.96.11 ×
188.114.96.12 ×
188.114.96.13 ×
188.114.96.14 ×
188.114.96.15 ×
188.114.96.16 ×
188.114.96.17 ×
188.114.96.18 ×
188.114.96.19 ×
188.114.96.20 ×
188.114.96.21 ×
197.234.240.1 394
197.234.240.2 451
197.234.240.3 431
197.234.240.4 412
197.234.240.5 459
197.234.240.6 ×
197.234.240.7 ×
197.234.240.8 ×
197.234.240.9 ×
197.234.240.10 ×
197.234.240.11 ×
197.234.240.12 ×
197.234.240.13 ×
197.234.240.14 ×
197.234.240.15 ×
197.234.240.16 ×
197.234.240.17 ×
197.234.240.18 ×
197.234.240.19 ×
197.234.240.20 ×
197.234.240.21 ×
197.234.240.22 ×
197.234.240.23 ×
198.41.128.1 ×
198.41.128.2 ×
198.41.128.3 ×
198.41.128.4 ×
198.41.128.5 ×
198.41.128.6 ×
198.41.128.7 ×
198.41.128.8 ×
198.41.128.9 ×
198.41.128.10 ×
198.41.128.11 ×
198.41.128.12 ×
198.41.128.13 ×
198.41.128.14 ×
198.41.128.15 ×
198.41.128.16 ×
198.41.128.17 ×
198.41.128.18 ×
162.158.0.1 261
162.158.0.2 260
162.158.0.3 319
162.158.0.4 ×
162.158.0.5 ×
162.158.0.6 ×
162.158.0.7 ×
162.158.0.8 ×
162.158.0.9 ×
162.158.0.10 ×
162.158.0.11 ×
162.158.0.12 ×
162.158.0.13 ×
162.158.0.14 ×
162.158.0.15 ×
162.158.0.16 ×
172.64.0.1 168
172.64.0.2 153
172.64.0.3 166
172.64.0.4 160
172.64.0.5 162
172.64.0.6 ×
172.64.0.7 149
172.64.0.8 ×
172.64.0.9 161
172.64.0.10 ×
172.64.0.11 ×
172.64.0.12 164
172.64.0.13 173
172.64.0.14 149
131.0.72.1 ×
131.0.72.2 ×
131.0.72.3 ×
131.0.72.4 ×
131.0.72.5 ×
131.0.72.6 ×
131.0.72.7 ×
131.0.72.8 ×
131.0.72.9 ×
131.0.72.10 ×
131.0.72.11 ×
131.0.72.12 ×
131.0.72.13 ×
131.0.72.14 ×
131.0.72.15 ×
131.0.72.16 ×
131.0.72.17 ×
131.0.72.18 ×
131.0.72.19 ×
131.0.72.20 ×
131.0.72.21 ×
131.0.72.22 ×
131.0.72.23 ×
104.16.0.1 146
104.16.0.2 159
104.16.0.3 149
104.16.0.4 172
104.16.0.5 158
104.16.0.6 154
104.16.0.7 ×
104.16.0.8 ×
104.16.0.9 148
104.16.0.10 147
104.16.0.11 145
104.16.0.12 ×
104.16.0.13 540
104.16.0.14 598
104.24.0.1 154
104.24.0.2 247
104.24.0.3 704
104.24.0.4 291
104.24.0.5 155
104.24.0.6 157
104.24.0.7 683
104.24.0.8 159
104.24.0.9 169
104.24.0.10 177
104.24.0.11 187
104.24.0.12 191
104.24.0.13 148
104.24.0.14 172
104.24.0.15 163
[Finished in 794.4s]

其中，IP地址后的数字为ping延迟时间，单位是ms。打×的是ping不通的，可能是被墙了。

值得一提的是，并不是所有能ping通的IP地址都可用作自选IP，笔者测试了几个，如104.24.0.*和108.162.192.*都不可做*2**yN的服务器自选IP。

浅谈：电学在简单逻辑学方面的应用

Sat, 24 Apr 2021 00:00:00 GMT

前端阵子简单学了下电学，发现逻辑与其有一定的联系之处。细究发现，我们可以用某些特定的电路来表现几种简单逻辑。

简单实现

为了方便表示，我们令开关为输入，灯泡为输出：开关闭合代表True，断开表示False；灯泡亮起代表True，熄灭代表False。

基本图像

串联：与

首先不烦笔者列出与的逻辑关系：

与运算	True	False
True	True	False
False	False	False

可以看出，当两个输入均为True时，输出才为True，否则输出为False。转换到电路上，当两个开关均为闭合时，电路才连通，小电灯泡才发亮。

AND

很明显，在一个串联的电路中，只要有任意一个开关没有闭合，电路都不会连通。

并联：或

以下是或的逻辑运算表格：

或运算	True	False
True	True	True
False	True	False

很明显，或的特点是：只要有任意一个输入为True，其输出结果必然为True。也就是说，只要有任意一个开关闭合，小电灯泡必然发亮，即电路连通。

在一个并联电路中，其支路上任意一个开关闭合，干路就会有电流通过。

短路：非

这个就有点 ~~无厘头~~ 了，让小电灯泡短路，电灯泡不就不亮了吗？于是乎……

NOT

~~瞧，你开关一闭，就短路了~~

关于抑或

笔者想了很久，发现抑或似乎并不能用电路来表示（抑或：输入不相同返回True，反之为False）。目前只了解了并联和串联，布吉岛混联是否能实现（好像也不行（？））……

逆元笔记

Wed, 21 Apr 2021 00:00:00 GMT

问题引入

对于任意两个数字a，b和一个模数mod，我们不难得出以下三个式子（均取模mod）：

(a+b)%mod=a%mod+b%mod;
(a-b)%mod=a%mod-b%mod;
(a*b)%mod=a%mod*b%mod.

然后，您就会发现唯独缺了一个：

(a/b)%mod=a%mod/b%mod.

显然这是不成立的。下面举出两组反例：

当a=4，b=7，mod=5，(a/b)%mod=(4/7)%5=4/7，a%mod/b%mod=4%5/7%5=4/2=2，显然4/7≠2；
当a=11，b=6，mod=6，(a/b)%mod=(11/6)%6=11/6，a%mod/b%mod=11%6/6%6=5/0=RE！

所以，为了解决这个棘手的问题，我们不得不引入一个新的概念——逆元。

何为逆元

定义

我们定义模mod意义下关于除数（分母）b的逆元i使得(a/b)%mod=(a*i)/mod=a%mod/i%mod。

费马小定理

设i为模mod意义下b的逆元，则i=a^mod-2（a，mod互质）。

线性递推求逆元（划重点）

在OI竞赛中，OIer常被要求将答案取模。然而对于如上所述的除法运算，取模并不是那么简单；同时，若有多组数据，针对每组数据一个个求逆元也不是一件简单的事。由此，我们需要推导线性递推求逆元的公式。

公式推导&证明

我们对mod进行有余数除法，即mod÷i=⌊mod÷i⌋……mod%i，变形得mod=⌊mod÷i⌋×i+mod%i。
由于是在模mod意义下，所以我们将等式左侧的mod取模为0，即0=⌊mod÷i⌋×i+mod%i。
整理式子，得-mod%i=⌊mod÷i⌋×i，再将等式两边同时除以[(mod%i)×i]，得：
-i^-1=⌊mod÷i⌋÷(mod%i)，即i^-1=-⌊mod÷i⌋÷(mod%i)，即i^-1=-⌊mod÷i⌋×(mod%i)^-1。

代码实现

我们设inv[n]为n的逆元，其中需要注意的是，inv[1]=1，又根据上方推导的结果，inv[i]=(mod-mod/i)*inv[mod%i]%mod（C++，除法下取整）。

inv[1]=1;
for(int i=2;i

Andy种树

Wed, 14 Apr 2021 00:00:00 GMT

原题题面

描述

andy在他的庄园里种了n棵树，排列成一排，标号为1到n。最开始的时候n棵树的高度都是0，也就是种子刚刚被埋下，树还没有长出来。

andy会一种魔法，他每使用一次魔法，就可以让树标号落在连续区间[l, r]里的树的高度增加1。他可以使用q次这种魔法，然后他很好奇，在使用了q次魔法之后，他的所有树的高度分别是多少呢？

输入

第一行输入两个整数n，q。(1<= n, q <= 1e5)

接下来q行，每行输入两个整数l, r(l <= r)，表示andy让标号落在区间[l, r]里的数高度都加1。

输出

输出有一行n个整数，每个整数后面有空格。输出末尾没有换行。

第i个数表示第i棵树的高度。

样例输入

样例输出

1 2 3 1 0 0 0 0 0 0

提示

andy种了10棵树

第一次使用魔法使得1、2、3棵树的高度增加1,

所有树的高度为

1 1 1 0 0 0 0 0 0 0

第二次使用魔法使得2、3、4棵树的高度增加1，

所有树的高度为

1 2 2 1 0 0 0 0 0 0

第三次使用魔法使得第3棵树的高度增加1

所有树的高度为

1 2 3 1 0 0 0 0 0 0

解析

不愧是C艹

刚看到题目，也就想到了用暴力做（蒟蒻实在没有什么好法子了），于是用一个数组记录每一棵树的高度，易得代码：

#include
   
using namespace std;
int n,q;
int l,r;
int a[5000000];
int main(){
cin>>n>>q;
while(q—){
cin>>l>>r;
for(int i=l;i<=r;i++){
a[i]++;
}
}
for(int i=1;i<=n;i++){
cout<
<a[i]<<” ”;="" }="" return="" 0;="" }<="" re="">
1
 <p>
2
  <!-- /wp:enlighter/codeblock --></p>
3

4
 <p>
5
  <!-- wp:image {"align":"center","id":143,"sizeSlug":"large","linkDestination":"none"} --></p>
6

7
 <div class="wp-block-image">
8

9
  <figure class="aligncenter size-large">
10
   <img src="https://blog.amzcd.top:32323/wp-content/uploads/2021/04/image-1024x86.png" alt="" class="wp-image-143" />
11
  </figure>
12

13
 </div>
14

15
 <p>
16
  <!-- /wp:image --></p>
17

18
 <p>
19
  <!-- wp:paragraph --></p>
20

21
 <p>众所周知，然后就……<code>TLE</code>了。</p>
22

23
 <p>
24
  <!-- /wp:paragraph --></p>
25

26
 <p>
27
  <!-- wp:heading --></p>
28

29
 <h2>学习新知</h2>
30

31
 <p>
32
  <!-- /wp:heading --></p>
33

34
 <p>
35
  <!-- wp:paragraph --></p>
36

37
 <p>待老师讲解该题时，才了解到要使用一种<code>差分</code>的思想。</p>
38

39
 <p>
40
  <!-- /wp:paragraph --></p>
41

42
 <p>
43
  <!-- wp:heading {"level":3} --></p>
44

45
 <h3>所谓差分</h3>
46

47
 <p>
48
  <!-- /wp:heading --></p>
49

50
 <p>
51
  <!-- wp:heading {"level":4} --></p>
52

53
 <h4>概念</h4>
54

55
 <p>
56
  <!-- /wp:heading --></p>
57

58
 <p>
59
  <!-- wp:paragraph --></p>
60

61
 <p>我们用数组来记录差分，<code>a[i]</code>表示的是<code>第i个元素</code>与<code>第i-1个元素</code>之差。</p>
62

63
 <p>
64
  <!-- /wp:paragraph --></p>
65

66
 <p>
67
  <!-- wp:heading {"level":4} --></p>
68

69
 <h4>基本操作</h4>
70

71
 <p>
72
  <!-- /wp:heading --></p>
73

74
 <p>
75
  <!-- wp:list --></p>
76

77
 <ul>
78

79
  <li>加/减第i个数字：将<code>a[i]&plusmn;x</code>，<code>a[i+1]&plusmn;(-x)</code>。</li>
80

81
  <li>同时加/减第i~j个数字：将<code>a[i]&plusmn;x</code>，<code>a[j+1]&plusmn;(-x)</code>。</li>
82

83
  <li>还原数字：遍历<code>a</code>数组，并用<code>sum</code>累加当前值。结束当前一次累加后，<code>sum</code>即为该数字。</li>
84

85
 </ul>
86

87
 <p>
88
  <!-- /wp:list --></p>
89

90
 <p>
91
  <!-- wp:heading {"level":3} --></p>
92

93
 <h3>代码实现</h3>
94

95
 <p>
96
  <!-- /wp:heading --></p>
97

98
 <p>
99
  <!-- wp:enlighter/codeblock {"language":"cpp"} --></p>
100

101
 <pre class="EnlighterJSRAW" data-enlighter-language="cpp" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">#include
102
  <bits tdc++.h="">
展开收起
using namespace std;
int n,q,a[100005],l,r;
//a[i]表示第i棵树比第i-1棵树高多少 差分
int main(){
cin>>n>>q;
for(int qwq=1;qwq<=q;qwq++){
cin>>l>>r;
a[l]++;//第l棵树比前面一棵树高1，且后面的树
a[r+1]—;//到r位置都一样高，第r+1棵树是原来那么高，所以减一减回去
}
for(int i=1;i<=n;i++){
a[i]+=a[i-1];
cout<
<a[i]<<” ”;="" }="" return="" 0;="" }<="" re="">
1
    <p>
2
     <!-- /wp:enlighter/codeblock --></p>
3

4
    <p>
5
     <!-- wp:quote --></p>
6

7
    <blockquote class="wp-block-quote">
8
     <p>QWQ.</p>
9

10
    </blockquote>
11

12
    <p>
13
     <!-- /wp:quote --></p>
14

15
    <p>
16
     <!-- wp:heading {"level":1} --></p>
17

18
    <h1>最后的最后</h1>
19

20
    <p>
21
     <!-- /wp:heading --></p>
22

23
    <p>
24
     <!-- wp:paragraph --></p>
25

26
    <p>总结一下<strong>前缀和</strong>和<strong>差分</strong>的异同点。</p>
27

28
    <p>
29
     <!-- /wp:paragraph --></p>
30

31
    <p>
32
     <!-- wp:table {"hasFixedLayout":true,"className":"is-style-stripes"} --></p>
33

34
    <figure class="wp-block-table is-style-stripes">
35

36
     <table class="has-fixed-layout">
37

38
      <tbody>
39

40
       <tr>
41

42
        <td>：）</td>
43

44
        <td>前缀和</td>
45

46
        <td>差分</td>
47

48
       </tr>
49

50
       <tr>
51

52
        <td>记录值</td>
53

54
        <td>Σa[i]-&gt;a[n]</td>
55

56
        <td>a[i]-a[i-1]</td>
57

58
       </tr>
59

60
       <tr>
61

62
        <td>预处理</td>
63

64
        <td>遍历数组，O(n)</td>
65

66
        <td>O(1)</td>
67

68
       </tr>
69

70
       <tr>
71

72
        <td>计算a[n]</td>
73

74
        <td>O(1)</td>
75

76
        <td>遍历数组，O(n)</td>
77

78
       </tr>
79

80
       <tr>
81

82
        <td>特点/适用题型</td>
83

84
        <td>高效求出连续一段和</td>
85

86
        <td>连续一段同时加减</td>
87

88
       </tr>
89

90
      </tbody>
91

92
     </table>
93

94
    </figure>
95

96
    <p>
97
     <!-- /wp:table --></p>
98

99
   </a[i]<<">
100
  </bits></pre>
101
</a[i]<<">
展开收起

序列排序Ⅱ

Mon, 29 Mar 2021 00:00:00 GMT

原题题面

描述

ldz 交给你了一个 1~n 的排列，当某两个相邻的数字满足互质时，则可以交换这两个数字，请问你进行若干次交换后，能否将这个排列变为严格递增的。（即 1, 2, 3, 4... , n-1, n）

两个数字互质的定义：若两个数字的最大公约数为 1 时，即认为这两个数字互质。

输入

输入第一行包含一个正整数 n(1≤n≤105)。

接下来一行包含由空格隔开的 nn 个正整数，第i个整数记为 a_iai，保证每个数字仅出现一次，且满足 (1≤a_i≤n)(1≤ai≤n)。

输出

输出 "Yes" 代表可以使得序列有序，否则输出 "No"。(不要输出引号)

输入样例 1

8
1 2 8 4 5 6 7 3

输出样例 1

No

提示

由于只能交换相邻的数字，所以无法使得排列递增。

解析

对于任意两个数……

让我们以样例的这组序列为例：1 2 8 4 5 6 7 3。

随便挑出两个数字，如8和6。显然，这8在前而6在后。也就是说，不管8和6如何运动，最终将会靠在一起并交换位置。显然，此时8和6并不互质，所以6无法移动位置至8前面。

理清思路

如上所述，若是两个数a和b满足以下3个条件：

a>b；
a在b前；
a和b不互质。

那么，如果在一个序列中只要有任意的如是两个数，该序列就无法满足题意。

基本实现

如果只根据以上思路，把序列双重循环地遍历，复杂度就到了O(n²)，显然会超时。然而，如果把不互质的所有数拎出来，就满足了第3个条件；另外要依次取出，就满足了第2个条件；最后只需对与这一个被拎出来的子序列进行遍历，如果发现有任意的a＞b，即满足了第1个条件，那么该序列就无法满足题意，输出No。

示例代码

#include
    
using namespace std;
const int maxn=100005;
int n,a[maxn];
vector

G[maxn];
int main(){
cin>>n;
for(int i=1;i<=n;i++){
cin>>a[i];
for(int j=2;j*j<=a[i];j++){
if(a[i]%j==0){
G[j].push_back(a[i]);
G[a[i]/j].push_back(a[i]);
}
}
}
for(int i=2;i<=n;i++){
for(int j=1;j
<g[i].size();j++){ if(g[i][j]<g[i][j-1]){="" cout<<“no”;="" return="" 0;="" }="" cout<<“yes”;="" }<="" ode=""></g[i].size();j++){>

利用自动化程序获取B站视频

Tue, 23 Mar 2021 00:00:00 GMT

引文链接：

在上一章的叙述中，我们已经了解了获取B站视频的方式。接下来让我们考虑如何把它变为自动化程序。

warning 提示
这里以Python为例，您也可以改造其他语言的版本。

头绪

现在问题来了，我们的程序不能依赖浏览器解析原视频链接（就算依赖了也难以实现）。当务之急，就是找到源视频链接隐藏在什么地方。

比如说我现在打开这个视频：

然后看到视频URL是https://upos-sz-mirrorks3.bilivideo.com/upgcxcode/87/39/295443987/295443987-1-16.mp4?e=ig8euxZM2rNcNbdlhoNvNC8BqJIzNbfq9rVEuxTEnE8L5F6VnEsSTx0vkX8fqJeYTj_lta53NCM=&uipk=5&nbs=1&deadline=1616501273&gen=playurlv2&os=ks3bv&oi=1018424233&trid=e4a339385c1742cc935ec43bee36eac1h&platform=html5&upsig=ba6920880404564592895256cded0950&uparams=e,uipk,nbs,deadline,gen,os,oi,trid,platform&mid=504293988&logo=80000000。

接着，我们看一看网页源代码：

CTRL+U即刻调出源代码界面

如你所见，你会看到在中间的options的json里看到以下几个链接。下面笔者粘贴出来做样例解析。

var options = {
            aid: 331505664,
            bvid: 'BV1yA411u7RR',
            cid: 295443987,
            readyPoster: '//i0.hdslb.com/bfs/archive/efc17d8ae488470712d57e4ad6d84ef07c3c40cd.jpg@480w_270h_1c',
            readyVideoUrl: 'https://upos-sz-mirrorks3.bilivideo.com/upgcxcode/87/39/295443987/295443987-1-16.mp4?e=ig8euxZM2rNcNbdlhoNvNC8BqJIzNbfq9rVEuxTEnE8L5F6VnEsSTx0vkX8fqJeYTj_lta53NCM=&uipk=5&nbs=1&deadline=1616501764&gen=playurlv2&os=ks3bv&oi=1018424233&trid=5c99efb95f0d41988373e18489074183h&platform=html5&upsig=070c72c614ca3411f70365b62c279b96&uparams=e,uipk,nbs,deadline,gen,os,oi,trid,platform&mid=504293988&logo=80000000',
            readyDuration: 184,
            noRecommend: gqs('from') == 'game'
          }

bvid：视频号；
readyPoster：视频封面图片；
readyVideoUrl：源视频链接。

（有些不知道什么含义的没列出，望大佬指教QWQ）

好家伙，这里我们直接获取视频即可。

代码实现

warning 注意
您应该使用移动端的标头（headers）进行GET请求。

这里粘贴出基本代码：

from requests import *
import os
from json import *
def get_and_save(vid,path):
    headers={'user-agent':'Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Mobile Safari/537.36'}
    print("getting HTML...",end=' ')
    r=get(url='https://m.bilibili.com/video/'+vid,headers=headers)
    html=r.text
    print("done! parsing...")
    vurl=(html[html.find('readyVideoUrl: ')+18:html.find("readyDuration")-15])
    name=html[html.find('''data-vue-meta="true">''')+21:html.find("")]
    if os.path.exists(path+name+'.mp4')==False:
        print("downloading video...",end=' ')
        resp = get('ht'+vurl,headers=headers)
        print("done!\nsaving video...",end=' ')
        with open(path+name+'.mp4','wb') as f:
            f.write(resp.content)
        print("done!")
    return path+name+'.mp4'

无聊的时候，把B站视频下载下来，弄成音频保存在本地听，怪无聊的（

——该代码从何而来

已经为您包装好了函数，即get_and_save部分的代码，谢谢。（

复杂度判断

Fri, 19 Mar 2021 00:00:00 GMT

原题题面

今天高川老师给大家讲解了算法复杂度（也可称为时间复杂度）的计算，并布置了作业题。高川在一个程序中写了很多个 for 循环，每一个 for 循环都是形如 for(int i = 1; i <= n; i++) ，且中间没有 continue，break 等影响循环执行的语句，即每一个 for 都会运行 n 轮（注意，并不是每一个循环里面定义的变量都叫 i，但是这个循环变量一定是从 1 到 n，执行 n 次）。现在高川想知道，他写的这个程序的算法复杂度是 n 的几次方。

在本题中，你可以将“算法复杂度”理解为“for循环最多嵌套的层数”。

输入描述

输入一个长度为 2n 的字符串，字符串的内容只可能是 0 或者 1，且 0 和 1 的数量相等。0 代表一个 for 循环的开始，1 代表一个 for 循环的结束。保证字符串合法。

输出描述

输出一行一个整数代表这个程序的算法复杂度是 n 的多少次方。

输出时每行末尾的多余空格，不影响答案正确性

样例输入1

样例输出1

样例输入2

样例输出2

样例解释2

样例 1 中，最多有两层循环嵌套，即 0011，所以算法复杂度是 n²，所以输出 2。

将样例 1 转化为代码即为：

for(int i = 1; i <= n; i++){
    for(int j = 1; j <= n; j++){
1
}

}
for(int i = 1; i <= n; i++){
}

样例 2 中，最多有一层循环嵌套，所以输出 1。

解析

样例不够有说服力，让我们人造一组数据：

001100100111

如果我们将上面的数据转换成直观图：

如上图，把原本整齐的一串数字进行分层，你就会发现一下规律：

复杂度取决于最后一行的复杂度（即最高复杂度）；
遇0上一层，遇1下一层（想象成一个山陵，最左边也就是上行的都是0，反之为1）；

显而易见的，我们只需要设定一个变量来记录当前的层数即可。再记录下层数的最大值即可。

示例代码

#include
    
using namespace std;
string s;
stack

st;
long long maxn=-1;
int main(){
cin>>s;
long long law=0;
for(int i=0;i
<s.length();i++){ if(s[i]=”=‘0’){” law++;="" st.push(law);="" }else{="" maxn=“max(maxn,st.top());” st.pop();="" law—;="" }="" cout<<maxn;="" return="" 0;="" }<="" ode=""></s.length();i++){>

 
 
 这里有点复杂化，用了stack，不过直接用for循环就行了。笔者一开始看到这题就直接上了stack，不过现在看来并不是每一道带有“匹配”意味的题都要使用stack。

入站前必看（

Wed, 17 Mar 2021 00:00:00 GMT

Welcome to 蒟蒻's Blog！

这是来自浙江省宁波市的一只蒟蒻OIer，正就读初中。喜欢 ~~唱、跳、Rap和篮球~~ 偶尔搞点小项目。接触OI比较早，也比较感兴趣，可惜没能得到很好的重视，也无法得到即时的教育，所以信息学也只能当副业搞搞，跳回了文化课的深渊……

本博客记录了本人一些OI题解、游记以及踩过的坑等等。当然，写文章时难以避免出现错误。希望您可以在文章下方留言，救救这个可怜的笔者。

What you should know

由于经费稀缺，本站勉勉强强跑在一个树莓派4B上，内网穿透。望大佬们不要炸锅。
所有的评论都应认真填写名称、邮箱和内容。如果不，您可能会被系统默认为垃圾评论处理，我将无法及时回复。为了避免以上问题，请避免将内容设置为全英文或是俄语日语什么的，那看上去就很垃圾。
如果您觉得不错，可以分享给您身边更多的人。本站是非营利性，当然赞赏我是不指望了……
本站全部文章采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。这意味着，您可以以任何形式复制本站的文章，但不能商用，同时必须以同样的方式进行许可。如果您违反了上述规则……我好像也不能怎么办（？）
本站全局由CloudFlare进行保护。每日，以中国和美国的访客居多，每天大约有2500请求。独立访问者每天约有210个。与此同时，来自全球各地的攻击请求也不容小觑。以美国为首，就有113攻击。另外，各大搜索引擎也会爬取一些小站的页面，到目前爬取过的有Google，Bing，Baidu和Yandex（本整个条目数据统计日期：2022年3月19日）。
本站使用Cookie来改善您的浏览记录。如果您不同意，可以退出本站。

about 友链

只允许非营利性网站申请友链，如个人博客、部门网站等。
您的网站需包含至少70%以上的原创内容，信息密度应不小于50%。
如果您希望申请，可以在留言墙下方留言。请填写正确的留言，阐述清楚您的身份、网站地址、类型以及备注。
请确保您是网站的拥有者或管理者。对于提交申请的网站友链申请，我将尽力在第一时间处理并给予回复。所以，填写正确的邮件地址非常重要。

any problems?

您可以在任何地方留言。我将第一时间为您解答！

小破站日志

2022年3月19日重建本页面

子序列

Wed, 17 Mar 2021 00:00:00 GMT

原题题面

题目背景

今天高川学习了子序列的概念，子序列就是在原来序列中（按顺序）找出一部分组成的序列，取出的子序列在原序列中可以不连续。

题目描述

例如，字符串 abccd 中， acd 是一个子序列，而 dc 则不是。

现在高川拿到了一个很长的字符串，他在研究里面子序列的种类问题。例如，对于字符串 abccd 来说，总共有两种子序列内容为 acd。（原串中第一，第三，第五个位置可以组成一个子序列 acd，并且第一，第四，第五个位置也可以组成一个子序列 acd，所以有两种）

高川姓高，拼音是 gao，他想知道在一个字符串中有多少个不同的子序列，其内容为 gao。

注意：对于两个内容均为 gao 的子序列来说，只要 gao 的这三个字母中的任何一个字母在原字符串中的位置不同，则认为这两个子序列是不同的子序列。

输入描述

第一行输入一个 n，代表字符串的长度。

接下来给出一个字符串，字符串仅由小写字母组成。

输出描述

输出一行一个整数表示答案。

输出时每行末尾的多余空格，不影响答案正确性

样例输入

5
ggaoo

样例输出

提示

对于 20% 的数据范围，满足 1≤n≤100

对于 60% 的数据范围，满足 1≤n≤1000

对于 100% 的数据范围，满足1≤n≤1000000

解析

此题有两种思路，一种思路比较复杂，由暴力枚举一步步优化而来；而这里介绍的是笔者发现的另一种方法。

从“1”开始

一切归纳的思想都由最简单的境况开始。我们首先来看以下这个简化版的问题：

给你一个字符序列，求这个序列中有几个字符‘g’。

很显然，这个题目用一个for循环就能实现（事实上本人觉得题目给的n还是不用为妙，万一数据出错了呢( ）。

string s;
cin>>s;
long long cnt=0;//计数器别忘了用longlong与归零
for(int i=0;i

 
    
 
    
 向“2”进发
 
    
 
    
 让我们再升级一下问题：
 
    
 
    
   
    给你一个字符序列，求这个序列中有几个子序列为‘ga’。
   
 
    
 
    
 思索一番
 
    
 
    
 让我们深入思考一下。在上面的代码中，您已经能统计出有几个‘g’的个数了。然而，想要组成‘ga’的子序列，就必须找到对于每一个‘g’来说后面有几个‘a’。显而易见，这种方式的复杂度到达了O(n²)，是肯定要超时的。
 
    
 
    
 思考一下，在什么情况下复杂度能到达O(n)？比如在上一块内容中，我们是枚举每一个‘g’，对‘g’来说复杂度是O(n)。
 
    
 
    
 所以，想要在寻找‘a’的时候将复杂度将为O(n)，何尝不妨以‘a’为枚举对象，同时保留对‘g’的统计，然后进行操作呢？这样，把两样东西放在同一个for循环中，复杂度将保留至O(n)。
 
    
 
    
 如何实现
 
    
 
    
 既然我们能在任意时刻获得该字符前‘g’的个数，那么在‘a’之前当然可以获得之前有几个‘g’了。‘ga’的个数就是在遇到‘a’的时候将其前面所有的‘g’的个数累加起来即可。
 
    
 
    
 #include
     
using namespace std;
long n;
string s;
long long g,ga;
int main(){
cin>>n>>s;
for(int i=0;i
<n;i++){ if(s[i]=”=‘a’)ga+=g;” else="" }="" cout<<ga;="" return="" 0;="" }<="" ode=""></n;i++){>
 
 
 奔向终点
 
 
 有了如上的称述，进行举一反三，相信很快就能归纳出当3个字符‘gao’的子序列的代码来。
 
 
 #include
<bits tdc++.h="">
using namespace std;
long n;
string s;
long long g,ga,gao;
int main(){
cin>>n>>s;
for(int i=0;i
<n;i++){ if(s[i]=”=‘o’)gao+=ga;” else="" }="" cout<<gao;="" return="" 0;="" }<="" ode=""></n;i++){>
 
 
 同样，当遇到‘o’的时候，只需要累加其前面出现过的‘ga’的次数即可。
 
 
 更进一步
 
 
 有了如上铺垫，我们还可以尝试将题目改为这样：
 
 


给你两个字符串s1和s2，求s2当中有多少个子序列为s1。
保证s1.length()<=s2.length()。
 
 
 那么，我们可以使用一个数组来保存目标子序列s1，在对s2进行搜索时同时遍历s1，并将计数的结果也保存在一个数组中。
 
 
 这样，时间复杂度即为O(n²)。

Windows40年发展史

Thu, 11 Mar 2021 00:00:00 GMT

本文大多摘自百度百科。

一切都从`MS-DOS`说起

MS-DOS（微软磁盘操作系统），是美国微软公司提供的磁盘操作系统。在美国微软公司推出Windows1.0、Windows3.0、1995年8月24日推出的操作系统Windows 95以前，磁盘操作系统是IBM PC及兼容机中的最基本配备，而MS-DOS则是个人电脑中最普遍使用的磁盘操作系统之一。

严格意义上来说，MS-DOS还不能被算作Windows系统。不过它仍为Windows的前身，为Windows的发展做了很大的铺垫。

背后鲜为人知的“黑历史”

1980年，西雅图电脑产品公司（Seattle Computer Products）的一名24岁的程序员蒂姆·帕特森（Tim Paterson）花费了四个月时间编写出了86-DOS操作系统。1981年7月，微软以五万美元的代价向西雅图公司购得本产品的全部版权，并将它更名为MS-DOS。最早在1979年年底，Seattle Computer公司开发了第一款基于8086芯片的操作系统CP/M-86，经过改进后推出了QDOS，并在80年年底推出了86-DOS0.3版，比尔·盖茨以极低的价格买下了86-DOS的销售经营权。1981年4月，Seattle Computer正式发布了86-DOS v1.0版，微软在当年7月，将86-DOS的版权和其他所有权力买断，并将其改名为MS-DOS向市场发布。这是微软赖以发迹的第一个成功的操作系统产品。

MS-DOS的三个基本模块

IO.SYS模块

IO.SYS是MS—DOS和ROMBIOS之间的接口程序。它和ROM BIOS一起完成系统设备的管理。

MSDOS.SYS

MSDOS．SYS用于实现文件管理，包括文件管理、目录管理、内存管理等功能。它以功能调用的形式实现用户和MS—DOS之间的程序级接口。

COMMAND.COM

COMMAND.COM的主要功能是负责接收、识别、解释和执行用户从键盘输入的MS-DOS命令。

Windows1.0——小试图形界面

Windows 1.0是微软公司第一次对个人电脑操作平台进行用户图形界面的尝试。Windows 1.0基于MS-DOS操作系统。Microsoft Windows 1.0是Windows系列的第一个产品，于1985年开始发行。

Windows 1.0 可以显示256种颜色，窗口可以任意缩放，当窗口最小化的时候桌面上会有专门的空间放置这些窗口（其实就是任务栏）。在Windows 1.0中已经出现了控制面板（Control Panel），对驱动程序、虚拟内存有了明确的定义，不过功能非常有限。

基于MS-DOS的Windows1.0

Windows2.0——又一次突破

1987年12月9日，Windows 2.0发布，最初售价为100美元。

在Windows 2.0中，用户不但可以缩放窗口，而且可以在桌面上同时显示多个窗口（也就是层叠模式），而在Windows 1.0中屏幕上不能同时显示多个窗口，打开一个窗口时其他窗口必须最小化。

Windows 2.0的另外一个重大突破是在1987年的年底，微软为Windows 2.0增加了386扩展模式支持，Windows第一次跳出了640K基地址内存的束缚，更多的内存可以充分发挥Windows的优势。

多窗口！

Windows3.0——趁热打铁

Windows 3.0是微软于1990年5月22日发布的电脑操作系统。由于在界面、人性化、内存管理多方面的巨大改进，终于获得用户的认同。之后微软公司趁热打铁，于1991年10月发布了Windows 3.0的多语版本，为Windows在非英语母语国家的推广起到了重大作用。

3.0正版

Windows3.1——日趋成熟

Windows 3.1（中文名：视窗操作系统3.1）是微软于1992年4月6日发布的Windows 3.x系列的基于MS-DOS的操作系统。此版本添加了对声音输入输出的基本多媒体的支持和一个CD音频播放器，以及对桌面出版很有用的TrueType字体。从该版本开始也有了“扫雷”游戏。

有内味了（

彼时的比尔·盖茨

Windows95——从此开始

1995年8月24日，微软公司推出了Windows 95，它是第一个不要求先安装DOS的32位操作系统。Windows 95的大部分内核代码都重新改写，虽然仍有部分16位代码（如USER.EXE和GDI.EXE）存在于Windows 95之中，但大多数代码是32位的。Windows 95的大多数I/O操作、存储管理和进程管理是保护模式的。

Windows 95自身的32位Windows应用程序接口(Win32)能使应用程序得到更快的响应，能更快地处理CPU密集的任务。Windows 95不需要利用DOS或进入实模式来访问磁盘，使得运行频繁的I/O程序仍具有很高的效率。

95发布会

重要的是：它还包含有Internet Explorer 3.0。

分享一个信息课上老师给我们讲的故事：

早在90年代初的时候，拥有一台计算机是一件很奢侈的事情。当时一台电脑要大概10000大洋（当时的10000大洋是什么概念）。众所周知，那个时候中国首次接入了互联网。不过学校里用的都是DOS系统（没见过）。直到95年，本地一所高中首次引入了第一批Windows95图形化系统电脑，想必学校也是破了费。同时，该批计算机也标志着本地接入Internet。随后，笔者所在的学校也装上了Windows95，不过机房并不开放使用，学生上课仍然用DOS。进95机房要收费的啊！价格不菲。不过和今天比较，也就只能一笑而过了。

Windows98——增强的功能

1998年6月25日发布的Windows 98是Windows 95的改进版。Windows 98中集成了Internet Explorer 4.0。Windows 98具有Web集成和活动桌面，增加了频道等网络功能，Windows 98采用FAT32文件系统，并提供FAT32转换工具，Windows 98支持ACPI电源管理、USB总线，IEEE1394总线和AGP总线。它同时支持DVD功能，DirectX是Windows 98中增强多媒体功能的实用程序。

Windows98SE——核心突破

Windows 98 SE（第二版）发行于1999年5月5日。它包括一系列改进，如Internet Explorer 5、Windows Netmeeting 3、Internet Connection Sharing、对DVD-ROM和对USB的支持。另外98SE的核心部分比Windows 98多支援了影音流媒体接收能力，以及5.1声道支持。

不过貌似和Windows98有什么特别大的区别啊QWQ

WindowsME——新概念短命（？）

2000年9月14日微软公司发布Windows ME( Windows Millennium Edition，简称Windows ME)，Windows ME是在Windows 9X的基础上开发的，主要针对的是家庭和个人用户，Windows ME重点改进了对多媒体和硬件设备的支持，但同时也加入了不少在Windows 2000上拥有的新概念。主要增加的功能包括系统恢复、UPnP即插即用、自动更新等。由于WindowsME的稳定性和可靠性较差，相当多的Dos程序无法在Windows ME上运行。相比其他版本的Windows系统，Windows ME只延续了短短一年，就被Windows XP取代了。

外观也没有太多区别

WindowsNT——悲欢离合

Windows NT是基于OS/2 NT的基础编制的。OS/2是由微软和IBM联合研制，分为微软的Microsoft OS/2 NT与IBM的IBM OS/2。由于种种原因，协作后来不欢而散，IBM继续向市场提供先前的OS/2版本，而微软则把自己的OS/2 NT的名称改为Windows NT，即第一代的Windows NT 3.1（1993年8月31日发布）。Windows NT是纯32位操作系统，采用先进的NT核心技术，NT即新技术（New Technology）。1996年4月发布的Windows NT 4.0是NT系列的一个里程碑，该系统面向工作站、网络服务器和大型计算机，它与通信服务紧密集成，提供文件和打印服务，能运行客户机/服务器应用程序，内置了Internet/Intranet功能。

这……感觉像退化版……

Windows2000——21世纪新作

Microsoft Windows 2000是沿袭微软公司Windows NT系列的32位视窗操作系统，是Windows操作系统发展的一个新里程碑。Windows 2000起初称为Windows NT 5.0。它的英文版于1999年12月19日上市，中文版于次年2月上市。Windows 2000是一个先占式多任务、可中断的、面向商业环境的图形化操作系统，为单一处理器或对称多处理器的32位Intelx86电脑而设计。它的客户机版本（Professional版本）在2001年10月被Windows XP所取代；而服务器版本则在2003年4月被Windows Server 2003所取代。

怪怪的呢

WindowsXP——不用多说

Windows XP是Microsoft公司于2001年10月发布的一款操作系统。它不再采用微软公司一贯的以年份命名的方式（如先前的Windows 95、Windows 98和Windows 2000），而是以一个全新的名字Windows XP来命名这款全新的操作系统。按照微软公司的解释，XP是experience的缩写，旨在在全新技术和功能的引导下，让使用者拥有更加丰富而广泛的全新计算机使用体验，感受科技带来的乐趣。

Windows XP是个人计算机的一个重要里程碑，它集成了数码媒体、远程网络等最新的技术规范，还具有很强的兼容性，外观清新美观，能够带给用户良好的视觉享受。Windows XP产品功能几乎包含了所有计算机领域的需求。同时，根据不同用户的需求，Windows XP又包括了多个版本。其中最为常见的是针对个人用户的家庭版Windows XP Home Edition和针对商业用户的专业版Windows XP Professional。家庭版的消费者是家庭用户，专业版则在家庭版的基础上添加了新的面向商业而设计的网络认证、双处理器等特性。

放点不一样的（

Windows Vista——Aero潮流+“超强”体验

你懂的

2005年7月22日，微软宣布 Windows Vista 为这款新操作系统的名字。微软于2006年11月2日完成GA版本，向OEM 和企业用户发布。2007年1月30日，正式向普通用户出售，这是Windows 历史上间隔时间最久的一次发布。

2011年7月12日，微软已终止Service Pack 1的支持。2012年4月10日，微软已终止Windows Vista的主流技术支持。

微软于2017年4月11日正式终止对Windows Vista的一切支持。至此，Windows Vista寿终正寝。

值得一提的是，这款操作系统曾一度被称为“蓝屏小王子”，针不戳。

Windows7——经典的经典

2009年10月，微软公司推出了Windows 7，核心版本号为Windows NT 6.1。Windows7可供家庭及商业工作环境、笔记本电脑、平板电脑、多媒体中心等使用。Windows 7先后推出了简易版、家庭普通版、家庭高级版、专业版、企业版等多个版本。Windows 7的启动时间大幅缩减，增加了简洁的搜索和信息使用方式，改进了安全和功能合法性，使用Aero效果更显华丽和美观。

不得不吐槽一句，这系统好是好，不过我们学校还在用7，别的学校都10了（至少8），……

Windows8——还行的还行

不怎么稳定。

2012年10月26日，微软正式推出Windows 8。Windows 8是由微软公司开发的具有革命性变化的操作系统。该系统旨在让人们的日常电脑操作更加简单和快捷，为人们提供高效易行的工作环境。Windows 8支持个人电脑（X86构架）及平板电脑(X86构架或ARM构架)。Windows 8大幅改变以往的操作逻辑，提供更佳的屏幕触控支持。新系统画面与操作方式变化极大，采用全新的Metro风格用户界面，各种应用程序、快捷方式等能以动态方块的样式呈现屏幕上，用户可自行将常用的浏览器、社交网络、游戏、操作界面融入。

扁平UI来了

Windows8.1——成功update

微软于北京时间2013年10月17日晚上7点发布Windows 8.1正式版。通过Windows应用商店进行更新推送及其订阅可免费下载。Windows 8.1中，微软发布了与Windows 8有区别的多个重要更新。在Windows 8.1更新正式发布后，搭载Windows 8.1的全新设备，在世界各地的零售渠道陆续上市。

Windows 8.1是微软公司在2012年10月推出Windows 8之后，着手开发的 Windows 8更新。在代号为“Blue”的项目中，微软将实现操作系统升级标准化，以便向用户提供更常规的升级。Windows 8.1 具有承上启下的作用，为Windows 10铺路。

日趋成熟

Windows10——赶紧让道

你永远不会想到，它早就发布了。

2015年7月29日，美国微软公司正式发布计算机和平板电脑操作系统Windows 10。^[9]Windows10（LTSB 2015）2014年10月1日，微软在旧金山召开新品发布会，对外展示了新一代Windows操作系统，将它命名为“Windows 10”，新系统的名称跳过了数字“9”。2015年1月21日，微软在华盛顿发布新一代Windows系统，并表示向运行Windows 7、Windows 8.1以及Windows Phone 8.1的所有设备提供，用户可以在Windows 10发布后的第一年享受免费升级服务。 2月13日，微软正式开启Windows 10手机预览版更新推送计划。 3月18日，微软中国官网正式推出了Windows 10中文介绍页面。 4月22日，微软推出了Windows Hello和微软Passport用户认证系统，微软又公布了名为“Device Guard”(设备卫士)的安全功能。 4月29日，微软宣布Windows 10将采用同一个应用商店，即可展示给Windows 10覆盖的所有设备用，同时支持Android和iOS程序。 7月29日，微软发布Windows 10正式版。

你15年在用什么系统。

Windows Server系列

不过多赘述了，放几张图片一睹为快。

至此，Windows系列以Windows10告终（Windows10为Microsoft的最后一款Windows产品，当然会不断更新）。

Microsoft sells the service, not only Windows.

小小马

Sun, 07 Mar 2021 00:00:00 GMT

描述#

鸡尾酒是小小马的粉丝，于是他比较喜欢研究关于“马”的问题。给你一个n*m的棋盘，每次可以在任意点放一个象棋中的“马”，假设在x,y点放置一个马，则马对应移动的8个位置都不能放置其他马。即(x+1,y+2),(x-1,y+2),(x+1,y-2),(x+1,y-2),(x+2,y-1),(x+2，y+1),(x-2,y+1),(x-2,y-1)这八个点都不能再放置马。鸡尾酒邀请了wls来玩这个游戏，wls先手，首先无法操作的人输。假设对阵双方**都玩得很好**，请问谁会赢得这场比赛。 ## 输入输入两个整数n，m(1<=n,m<1e18) ## 输出如果先手赢，输出wls，否则输出cocktail ## 输入样例 1 ``` 1 1 ``` ## 输出样例 1

`wls`

## 输入样例 2

`1 2`

## 输出样例 2

`cocktail`

* * *

## 分析初级思路——搜索乍一看，这道题有点像搜索题，也就是一个一个枚举`cocktail`和`wls`的棋子，再把`(x+1,y+2),(x-1,y+2),(x+1,y-2),(x+1,y-2),(x+2,y-1),(x+2，y+1),(x-2,y+1),(x-2,y-1)`这些位置标记掉。事实上，题目当然不会那么简单。来康康几位同学的结果：

![](https://blog.amzcd.top:32323/wp-content/uploads/2021/03/image-4.png)

全WA了……

用这样的方法，不是TLE就是RE（还有WA），看来我们急需更简单一些的方法。更进一步——归纳规律于是，笔者使用表格模拟棋盘，进行归纳：

提示

_keyboard_arrow_down_

（括号）里的数字表示该棋子是第几回合下的；（数字+）表示该回合下的棋同时占用的位置（不是每个马会使8个位置不能下棋吗）。

1×1的时候：

（1）wls

wls胜

1×2的时候：

（1）wls

（2）cocktail

cocktail胜

1×3的时候：

（1）wls

（2）cocktail

（3）wls

wls胜

2×2的时候：

（1）wls	（2）cocktail
（3）wls	（4）cocktail

cocktail胜

2×3的时候：

（1）wls	（3）wls	（2）cocktail
（2+）	（4）cocktail	（1+）

cocktail胜

3×3的时候：

（1）wls	（2+）	（5）wls
（2+）	（4）cocktail	（1+）
（3）wls	（1+）	（2）cocktail

wls胜

> _warning_ 注意 > **题目描述里明确规定，“对阵双方都玩得很好”，所以不用考虑下棋顺序的先后，最后所呈现出的棋盘布局和胜负都是唯一的。** 列个表归纳总结一下：

长×宽	1	2	3
1	wls	cocktail	wls
2	cocktail	cocktail	cocktail
3	wls	cocktail	wls

有兴趣的童鞋如果继续列表探索下去的话，就会发现如下规律： > 当`长×宽为偶数`时，`cocktail`总赢； > > 反之，当`长×宽为奇数`时，`wls`总赢。于是简单地给出了代码：

`#include
   using namespace std;
long long a,b;
int main(){
cin>>a>>b;
if((a*b)%2==0){
cout<<“cocktail”;
}else{
cout<<“wls”;
}
return 0;
}`

> _warning_ 提示 > **注意数据范围：n，m(1<=n,m<1e18)。** * * *

## 你以为这就结束了？一提交上去，又WA了。仔细一看上面提示的**数据范围**：`n，m(1<=n,m<1e18)`。试求`n×m`？`1<=n*m<=1e36`！这连`long long`都存不下啊！于是，只好分别判断两个数的奇偶性了。 ## 最终示例代码 ``` #include using namespace std; long long a,b; int main(){ cin>>a>>b; if(a%2==0||b%2==0){ cout<<"cocktail"; }else{ cout<<"wls"; } return 0; } ```

白浅吃糖果(easy version)

Sun, 07 Mar 2021 00:00:00 GMT

描述#

白浅喜欢吃糖，有一天她到了一个可以免费吃糖果的游乐园。游乐园摆放着一排共n个糖果，对于任意的i(1<=i<n-1),第i个糖果与第i+1个糖果相邻。第i个糖果具有一个甜度值ai。妈妈说吃甜食太多了会得蛀牙，所以白浅吃的糖果的甜度值总和不能超过k。她可以以任意的顺序吃糖，请问她最多能吃多少个糖果？

输入#

第一行给出两个正整数n，k (1<=n<=2e5,1<=k<=1e9)，意义如题面所描述第二行有n个整数，分别代表每一个糖果的甜度值a(1<=a<=1e9)

输出#

输出一行一个整数代表白浅最多可以吃掉的糖果数。

输入样例 1 #

输出样例 1#

1
2

基本思路#

对于这道题，显而易见，可以以任意的顺序拿糖；也就是说，可以不连续地挑选其中的几颗糖。
对于每一颗糖来说，都有一个甜度值。所有被挑选出来的糖的甜度值必须小于k，且挑出的糖要尽量多。
可以想到，就是把甜度值从小到大排列出来，从前往后选糖直到甜度值之和大于k为止。

代码实现#

1
#include<bits/stdc++.h>
2
using namespace std;
3
long long n,k;
4
long long a&#91;200005];
5
long long cnt=0;
6
long long sum=0;
7
int main(){
8
  cin>>n>>k;
9
  for(long long i=1;i<=n;i++){
10
    cin>>a&#91;i];
11
  }
12
  sort(a+1,a+1+n);
13
  for(long long i=1;i<=n;i++){
14
    if(sum+a&#91;i]>k)break;
15
    else{
16
      cnt++;
17
      sum+=a&#91;i];
18
    }
19
  }
20
  cout<<cnt;
21
  return 0;
22
}

展开收起

warning 注意事项 请注意数据范围：n，k (1<=n<=2e5,1<=k<=1e9)。所以变量可以使用long long，数组也要开到2e5。

简单获取B站视频

Sat, 06 Mar 2021 00:00:00 GMT

今天正在做视频，想要把自己发在B站上的视频作为素材引用下来（本地已删除qwq），然而网络又不给力，用某种工具无法下载，只得自己钻研另一种方法。

本文使用的视频来自作者本人，视频链接https://m.bilibili.com/video/BV1py4y1a7GH

突然想到手机不也是可以在网页版浏览B站视频么，于是打开浏览器模拟手机试了试：

好家伙，接着在控制台转到“网络”选项卡，如上图所示。

对于一部手机来说，是很难进行像PC端那样复杂的方式来获取视频的。于是抱着侥幸心理，把筛选器点到了媒体处。

惊呆了，竟然还真有一个视频文件。赶紧点进去康康：

于是，我毫不犹豫地复制了这段链接，看看到底能获取到什么东西。

竟然还能真获取到一个视频！不过考虑到这本是在手机端上播放的，所以分辨率不会太高。

比较一下_普通获取方式_与_本文所述方式_的区别与优劣：

Firefly 代码块示例

Sat, 03 Jan 1970 00:00:00 GMT

在这里，我们将探索如何使用 Expressive Code 展示代码块。提供的示例基于官方文档，您可以参考以获取更多详细信息。

表达性代码#

语法高亮#

语法高亮

常规语法高亮#

1
console.log('此代码有语法高亮!')

渲染 ANSI 转义序列#

Terminal window

1
ANSI colors:
2
- Regular: Red Green Yellow Blue Magenta Cyan
3
- Bold:    Red Green Yellow Blue Magenta Cyan
4
- Dimmed:  Red Green Yellow Blue Magenta Cyan
5

6
256 colors (showing colors 160-177):
7
160 161 162 163 164 165
8
166 167 168 169 170 171
9
172 173 174 175 176 177
10

11
Full RGB colors:
12
ForestGreen - RGB(34, 139, 34)
13

14
Text formatting: Bold Dimmed Italic Underline

编辑器和终端框架#

编辑器和终端框架

代码编辑器框架#

my-test-file.js

1
console.log('标题属性示例')

src/content/index.html

1
<div>文件名注释示例</div>

终端框架#

Terminal window

1
echo "此终端框架没有标题"

PowerShell 终端示例

1
Write-Output "这个有标题!"

覆盖框架类型#

1
echo "看，没有框架!"

PowerShell Profile.ps1

1
# 如果不覆盖，这将是一个终端框架
2
function Watch-Tail { Get-Content -Tail 20 -Wait $args }
3
New-Alias tail Watch-Tail

文本和行标记#

文本和行标记

标记整行和行范围#

1
// 第1行 - 通过行号定位
2
// 第2行
3
// 第3行
4
// 第4行 - 通过行号定位
5
// 第5行
6
// 第6行
7
// 第7行 - 通过范围 "7-8" 定位
8
// 第8行 - 通过范围 "7-8" 定位

选择行标记类型 (mark, ins, del)#

line-markers.js

1
function demo() {
2
  console.log('此行标记为已删除')
3
  // 此行和下一行标记为已插入
4
  console.log('这是第二个插入行')
5

6
  return '此行使用中性默认标记类型'
7
}

为行标记添加标签#

labeled-line-markers.jsx

1
<button
2
  role="button"
3
  {...props}
4
  value={value}
5
  className={buttonClassName}
6
  disabled={disabled}
7
  active={active}
8
>
9
  {children &&
10
    !active &&
11
    (typeof children === 'string' ? <span>{children}</span> : children)}
12
</button>

在单独行上添加长标签#

labeled-line-markers.jsx展开收起

1
<button
2
  role="button"
3
  {...props}
4

5
  value={value}
6
  className={buttonClassName}
7

8
  disabled={disabled}
9
  active={active}
10
>
11

12
  {children &&
13
    !active &&
14
    (typeof children === 'string' ? <span>{children}</span> : children)}
15
</button>

展开收起

使用类似 diff 的语法#

1
此行将标记为已插入
2
此行将标记为已删除
3
这是常规行

1
--- a/README.md
2
+++ b/README.md
3
@@ -1,3 +1,4 @@
4
+this is an actual diff file
5
-all contents will remain unmodified
6
 no whitespace will be removed either

结合语法高亮和类似 diff 的语法#

1
function thisIsJavaScript() {
2
  // 整个块都会以 JavaScript 高亮显示，
3
  // 并且我们仍然可以为其添加 diff 标记！
4
  console.log('要删除的旧代码')
5
  console.log('新的闪亮代码！')
6
}

标记行内的单独文本#

1
function demo() {
2
  // 标记行内的任何给定文本
3
  return '支持给定文本的多个匹配项';
4
}

正则表达式#

1
console.log('单词 yes 和 yep 将被标记。')

转义正斜杠#

Terminal window

1
echo "Test" > /home/test.txt

选择内联标记类型 (mark, ins, del)#

1
function demo() {
2
  console.log('这些是插入和删除的标记类型');
3
  // return 语句使用默认标记类型
4
  return true;
5
}

自动换行#

自动换行

为每个块配置自动换行#

1
// 启用换行的示例
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

1
// wrap=false 的示例
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

配置换行的缩进#

1
// preserveIndent 示例（默认启用）
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

1
// preserveIndent=false 的示例
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

可折叠部分#

可折叠部分


5 collapsed lines
1
// 所有这些样板设置代码将被折叠
2
import { someBoilerplateEngine } from '@example/some-boilerplate'
3
import { evenMoreBoilerplate } from '@example/even-more-boilerplate'
4

5
const engine = someBoilerplateEngine(evenMoreBoilerplate())
6

7
// 这部分代码默认可见
8
engine.doSomething(1, 2, 3, calcFn)
9

10
function calcFn() {
11
  // 您可以有多个折叠部分
3 collapsed lines
12
  const a = 1
13
  const b = 2
14
  const c = a + b
15

16
  // 这将保持可见
17
  console.log(`计算结果: ${a} + ${b} = ${c}`)
18
  return c
19
}
20

4 collapsed lines
21
// 直到块末尾的所有代码将再次被折叠
22
engine.closeConnection()
23
engine.freeMemory()
24
engine.shutdown({ reason: '示例样板代码结束' })

展开收起

行号#

行号

为每个块显示行号#

1
// 此代码块将显示行号
2
console.log('来自第2行的问候!')
3
console.log('我在第3行')

// 此块禁用行号
console.log('你好?')
console.log('抱歉，你知道我在第几行吗?')

更改起始行号#

5
console.log('来自第5行的问候!')
6
console.log('我在第6行')

Firefly 布局系统详解

Sat, 03 Jan 1970 00:00:00 GMT

📖 概述#

Firefly 提供了灵活的布局系统，允许您根据内容需求和个人喜好自定义博客的视觉呈现方式。布局系统主要包括侧边栏布局和文章列表布局两个维度，它们相互配合，共同决定了页面的整体结构。

本文将详细介绍 Firefly 的各种布局模式、它们的特点、使用场景，以及不同布局组合的效果。

左侧边栏+列表布局

右侧边栏+网格布局

左侧边栏+三列网格布局

双侧边栏+列表布局

双侧边栏+网格布局

双侧边栏+网格瀑布流布局

一、侧边栏布局系统#

侧边栏是博客页面的重要组成部分，用于展示导航、分类、标签、统计信息等辅助内容。Firefly 支持两种侧边栏布局模式。

1.1 单侧边栏模式#

左侧边栏 (position: “left”)#

左侧边栏布局

右侧边栏 (position: “right”)#

右侧边栏布局

特点#

侧边栏固定在页面其中一侧
文章阅读区域体验更佳，更宽敞
更加简约，没有那么紧凑

适用场景#

传统博客风格
强调导航和分类的博客
需要突出用户资料的个人博客
内容为主，辅助信息次之的场景

Tip

可以通过showBothSidebarsOnPostPage配置是否在文章详情页显示双侧边栏

当position为left或right时开启此项后，文章详情页将显示双侧边栏，主页等其他页面保持单侧边栏

适用在只想用单侧栏，但在文章详情页想用对侧栏的目录等组件的场景

配置示例#

src/config/sidebarConfig.ts

1
export const sidebarLayoutConfig: SidebarLayoutConfig = {
2
  enable: true,
3
  position: "left", // 左侧边栏
4
  showBothSidebarsOnPostPage: true, // 是否在文章详情页显示双侧边栏
5
};

1.2 双侧边栏模式 (position: “both”)#

特点#

左右两侧同时存在侧边栏
主内容区域位于中间
最大化利用屏幕空间
可以展示更多辅助信息
适合宽屏显示器

布局结构#

双侧边栏+列表布局

双侧边栏+网格布局

适用场景#

宽屏桌面端浏览
信息密集型博客
需要展示大量辅助内容
专业性强的技术博客

配置示例#

src/config/sidebarConfig.ts

1
export const sidebarLayoutConfig: SidebarLayoutConfig = {
2
  enable: true,
3
  position: "both", // 双侧边栏

二、文章列表布局系统#

文章列表是博客首页和归档页的核心内容，Firefly 提供两种展示方式，并支持多种网格配置。

2.1 列表模式 (defaultMode: “list”)#

特点#

单列纵向排列
显示文章封面图
展示更多文章摘要
适合深度阅读

列表布局结构#

列表模式布局

优点#

✅ 视觉冲击力强，封面图吸引眼球
✅ 可以展示更多文章信息（摘要、标签等）
✅ 适合图片内容丰富的博客
✅ 移动端友好，单列更易阅读
✅ 兼容所有侧边栏配置（单侧、双侧）

配置示例#

src/config/siteConfig.ts

1
export const siteConfig: SiteConfig = {
2
  postListLayout: {
3
    defaultMode: "list", // 列表模式
4
    allowSwitch: true,   // 允许用户切换
5
  },
6
};

2.2 网格模式 (defaultMode: “grid”)#

特点#

自适应列数，根据浏览器宽度自动调整
紧凑布局，信息密度高
适合快速浏览

自适应网格#

网格模式通过 columnWidth 配置卡片的最小宽度（单位 px），浏览器会根据容器可用宽度自动计算能容纳多少列。

网格布局

配置示例#

src/config/siteConfig.ts

1
export const siteConfig: SiteConfig = {
2
  postListLayout: {
3
    defaultMode: "grid",
4
    allowSwitch: true,
5
    grid: {
6
      masonry: true,      // 开启瀑布流
7
      columnWidth: 320,   // 卡片最小宽度(px)，浏览器自动计算列数
8
    },
9
  },
10
};

2.3 瀑布流布局 (Masonry)#

Firefly 的网格模式内置了智能瀑布流布局支持，解决了网格布局中因图文混合文章导致的卡片高度不一致导致的空白问题。

瀑布流布局

智能排版：自动将卡片放置到最短的列，最大化利用垂直空间。
消除空白：通过绝对定位精确计算每个卡片的位置，让卡片紧贴上方卡片，消除垂直方向的空白间隙。
自适应列数：瀑布流同样根据 columnWidth 和容器宽度动态计算列数，无需固定配置。
配置灵活：您可以在 siteConfig.ts 中通过 postListLayout.grid.masonry 选项自由开启或关闭此功能。

三、布局组合指南#

Firefly 允许您自由组合侧边栏和文章列表布局。以下是各种组合的效果说明。

侧边栏模式	文章列表模式	推荐度	适用场景
单侧边栏	列表模式	⭐⭐⭐⭐⭐	摄影、设计、生活类博客，强调图片和沉浸感
单侧边栏	网格模式	⭐⭐⭐⭐⭐	技术、笔记类博客，平衡阅读与检索效率
双侧边栏	列表模式	⭐⭐⭐⭐⭐	需要展示大量侧边栏信息的站点
双侧边栏	网格模式	⭐⭐⭐⭐⭐	极客风格，追求最高信息密度

四、响应式布局行为#

Firefly 的布局系统具有智能的响应式设计，会根据屏幕尺寸自动调整。

为了保证最佳阅读体验，系统会在屏幕变窄时自动调整布局：

网格列数自动减少：网格模式的列数由 columnWidth 和容器宽度自动决定，屏幕越窄列数越少。
列表模式 -> 网格模式：当屏幕宽度小于 380px（超小屏设备）时，列表模式会自动切换为网格模式，以保证卡片内容的可读性。
双侧边栏 -> 单侧边栏：当屏幕宽度小于 1280px 时，会根据tabletSidebar配置显示单侧边栏，隐藏其中一个侧边栏，文章目录导航会切换成浮动目录导航。

五、常见问题#

Q1: 如何调整网格列数？#

A: 通过 columnWidth 配置卡片最小宽度即可。值越小，同等宽度下列数越多；值越大，列数越少。浏览器会自动根据可用宽度计算最佳列数。

六、总结#

Firefly 的布局系统给予了您更大的自由度，您都可以通过简单的配置实现。

我们建议您根据自己的内容类型和目标读者的设备偏好，尝试不同的组合，找到最适合您的博客形态。

Firefly 文章加密

Fri, 02 Jan 1970 00:00:00 GMT

这是一篇密码保护的示例文章，用于演示文章加密功能。

Firefly 一款清新美观的 Astro 博客主题模板

Fri, 02 Jan 1970 00:00:00 GMT

🌟 项目概述#

Firefly 是一款基于 Astro 框架和 Fuwari 模板开发的清新美观且现代化个人博客主题模板，专为技术爱好者和内容创作者设计。该主题融合了现代 Web 技术栈，提供了丰富的功能模块和高度可定制的界面，让您能够轻松打造出专业且美观的个人博客网站。

🖥️在线预览： Firefly - Demo site

🏠我的博客： https://blog.cuteleaf.cn

📝Firefly使用文档： https://docs-firefly.cuteleaf.cn

⭐Firefly开源地址：https://github.com/CuteLeaf/Firefly

⭐Fuwari开源地址：https://github.com/saicaca/fuwari

CuteLeaf

Firefly

Waiting for api.github.com...

Waiting for api.github.com...

00K

Waiting...

Firefly

🚀 技术架构#

静态站点生成: 基于 Astro ，提供极快的加载速度和优秀的 SEO 优化
TypeScript 支持: 完整的类型安全，提升开发体验和代码质量
响应式设计: 使用 Tailwind CSS 构建，完美适配桌面端和移动端
组件化开发: 支持 Astro、Svelte 组件，灵活可扩展

📖 配置说明#

📚 详细配置文档: 查看 Firefly使用文档获取完整的配置指南

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 会自动转换为小写

KaTeX 数学公式示例

Fri, 02 Jan 1970 00:00:00 GMT

本文展示了 Firefly 主题对 KaTeX 数学公式的渲染支持。

行内公式 (Inline)#

行内公式使用单个 $ 符号包裹。

例如：欧拉公式 eiπ+1=0e^{i\pi} + 1 = 0eiπ+1=0 是数学中最优美的公式之一。

质能方程 E=mc2E = mc^2E=mc2 也是家喻户晓。

块级公式 (Block)#

块级公式使用两个 $$ 符号包裹，会居中显示。

∫−∞∞e−x2dx=π\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}∫−∞∞e−x2dx=πx=−b±b2−4ac2ax = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}x=2a−b±b2−4ac

复杂示例#

矩阵 (Matrices)#

(abcd)(αβγδ)=(aα+bγaβ+bδcα+dγcβ+dδ)\begin{pmatrix} a & b \\ c & d \end{pmatrix} \begin{pmatrix} \alpha & \beta \\ \gamma & \delta \end{pmatrix} = \begin{pmatrix} a\alpha + b\gamma & a\beta + b\delta \\ c\alpha + d\gamma & c\beta + d\delta \end{pmatrix}(acbd)(αγβδ)=(aα+bγcα+dγaβ+bδcβ+dδ)

极限与求和 (Limits and Sums)#

∑n=1∞1n2=π26\sum_{n=1}^{\infty} \frac{1}{n^2} = \frac{\pi^2}{6}n=1∑∞n21=6π2lim⁡x→0sin⁡xx=1\lim_{x \to 0} \frac{\sin x}{x} = 1x→0limxsinx=1

麦克斯韦方程组 (Maxwell’s Equations)#

∇⋅E=ρε0∇⋅B=0∇×E=−∂B∂t∇×B=μ0J+μ0ε0∂E∂t\begin{aligned} \nabla \cdot \mathbf{E} &= \frac{\rho}{\varepsilon_0} \\ \nabla \cdot \mathbf{B} &= 0 \\ \nabla \times \mathbf{E} &= -\frac{\partial \mathbf{B}}{\partial t} \\ \nabla \times \mathbf{B} &= \mu_0\mathbf{J} + \mu_0\varepsilon_0\frac{\partial \mathbf{E}}{\partial t} \end{aligned}∇⋅E∇⋅B∇×E∇×B=ε0ρ=0=−∂t∂B=μ0J+μ0ε0∂t∂E

化学方程式 (Chemical Equations)#

CHX4+2 OX2→COX2+2 HX2O\ce{CH4 + 2O2 -> CO2 + 2H2O}CHX4+2OX2COX2+2HX2O

符号	代码	渲染结果
Alpha	`\alpha`	α\alphaα
Beta	`\beta`	β\betaβ
Gamma	`\Gamma`	Γ\GammaΓ
Pi	`\pi`	π\piπ
Infinity	`\infty`	∞\infty∞
Right Arrow	`\rightarrow`	→\rightarrow→
Partial	`\partial`	∂\partial∂

MDX 格式文章示例

Fri, 02 Jan 1970 00:00:00 GMT

Tip

Firefly 支持 MDX 和 Markdown 两种类型的文章，你可以在文章中混合使用两种格式，如果没有特别复杂内容和需求，推荐使用 Markdown 格式就够了。

Markdown 和 MDX 的区别#

Markdown (MD) 是一种轻量级标记语言，允许用户使用纯文本格式编写文档，然后将其转换为格式化的HTML。它因其简洁易用的语法而广受欢迎，特别适合编写文档和博客文章。
MDX 是一种扩展了 Markdown 语法的格式，允许在 Markdown 文档中无缝地插入 JSX 代码。通过 MDX，用户可以在文档中嵌入 React 组件，从而实现更丰富的交互性和动态性。

特性	Markdown	MDX
基础语法	支持 (CommonMark)	支持 (CommonMark)
HTML 标签	支持	支持 (作为 JSX)
组件导入	不支持	支持 (import)
动态数据	不支持	支持 (JS 表达式)
样式定制	有限 (class/style)	灵活 (className/CSS-in-JS)

使用组件#

这是一个图标组件：

1
import { Icon } from 'astro-icon/components'
2

3
<div class="flex items-center gap-2 my-4">
4
  <Icon name="fa7-solid:rocket" class="text-4xl text-red-500" />
5
  <span>火箭发射！</span>
6
</div>

火箭发射！

使用 JSX#

你也可以直接写 HTML/JSX：

1
<div className="p-4 bg-blue-100 dark:bg-blue-900 rounded-lg my-4">
2
  这是一个自定义样式的 div 块，使用了 Tailwind CSS 类。
3
</div>

这是一个自定义样式的 div 块，使用了 Tailwind CSS 类。

简单的变量导出#

1
export const year = new Date().getFullYear()
2

3
今年是 {year} 年。

今年是 2026 年。

更多信息，请查看 MDX 文档

Markdown 扩展功能

Thu, 01 Jan 1970 00:00:00 GMT

GitHub 仓库卡片#

您可以添加链接到 GitHub 仓库的动态卡片，在页面加载时，仓库信息会从 GitHub API 获取。

CuteLeaf

Firefly

Waiting for api.github.com...

00K

Waiting...

使用代码 ::github{repo="CuteLeaf/Firefly"} 创建 GitHub 仓库卡片。

1
::github{repo="CuteLeaf/Firefly"}

提醒框(Admonitions)配置#

Firefly 采用了 rehype-callouts 插件，支持了三种风格的提醒框主题：GitHub、Obsidian 和 VitePress。您可以在 src/config/siteConfig.ts 中进行配置：

src/config/siteConfig.ts

1
export const siteConfig: SiteConfig = {
2
  // ...
3
  rehypeCallouts: {
4
    // 选项: "github" | "obsidian" | "vitepress"
5
    theme: "github",
6
  },
7
  // ...
8
};

注意：更改配置后需要重启开发服务器才能生效。

以下是各个主题支持的类型列表，每个主题风格和语法不同，可根据喜好选择。

1. GitHub 主题风格#

这是 GitHub 官方支持的 5 种基本类型。

GitHub

基本语法

1
> [!NOTE] NOTE
2
> 突出显示用户应该考虑的信息。
3

4
> [!TIP] TIP
5
> 可选信息，帮助用户更成功。
6

7
> [!IMPORTANT] IMPORTANT
8
> 用户成功所必需的关键信息。
9

10
> [!WARNING] WARNING
11
> 关键内容，需要立即注意。
12

13
> [!CAUTION] CAUTION
14
> 行动的负面潜在后果。
15

16
> [!NOTE] 自定义标题
17
> 这是一个带有自定义标题的示例。

展开收起

2. Obsidian 主题风格#

Obsidian 风格支持非常丰富的类型和别名。

点击展开 Obsidian 语法列表

1
> [!NOTE] NOTE
2
> 通用的笔记块。
3

4
> [!ABSTRACT] ABSTRACT
5
> 文章的摘要。
6

7
> [!SUMMARY] SUMMARY
8
> 文章的总结（同 Abstract）。
9

10
> [!TLDR] TLDR
11
> 太长不看（同 Abstract）。
12

13
> [!INFO] INFO
14
> 提供额外信息。
15

16
> [!TODO] TODO
17
> 需要完成的事项。
18

19
> [!TIP] TIP
20
> 实用技巧或提示。
21

22
> [!HINT] HINT
23
> 暗示（同 Tip）。
24

25
> [!IMPORTANT] IMPORTANT
26
> 重要信息（Obsidian 风格通常使用类似的图标）。
27

28
> [!SUCCESS] SUCCESS
29
> 操作成功。
30

31
> [!CHECK] CHECK
32
> 检查通过（同 Success）。
33

34
> [!DONE] DONE
35
> 已完成（同 Success）。
36

37
> [!QUESTION] QUESTION
38
> 提出问题。
39

40
> [!HELP] HELP
41
> 寻求帮助（同 Question）。
42

43
> [!FAQ] FAQ
44
> 常见问题（同 Question）。
45

46
> [!WARNING] WARNING
47
> 警告信息。
48

49
> [!CAUTION] CAUTION
50
> 注意事项（同 Warning）。
51

52
> [!ATTENTION] ATTENTION
53
> 引起注意（同 Warning）。
54

55
> [!FAILURE] FAILURE
56
> 操作失败。
57

58
> [!FAIL] FAIL
59
> 失败（同 Failure）。
60

61
> [!MISSING] MISSING
62
> 缺失内容（同 Failure）。
63

64
> [!DANGER] DANGER
65
> 危险操作警告。
66

67
> [!ERROR] ERROR
68
> 错误信息（同 Danger）。
69

70
> [!BUG] BUG
71
> 报告软件缺陷。
72

73
> [!EXAMPLE] EXAMPLE
74
> 展示一个例子。
75

76
> [!QUOTE] QUOTE
77
> 引用一段话。
78

79
> [!CITE] CITE
80
> 引证（同 Quote）。
81

82
> [!NOTE] 自定义标题
83
> 这是一个带有自定义标题的示例。

展开收起

Obsidian

3. VitePress 主题风格#

VitePress 风格提供了一套现代化的、扁平的默认样式。目前仅包含与 GitHub 一致的 5 种 基础类型。

点击展开 VitePress 语法列表

1
> [!NOTE] NOTE
2
> 对应 GitHub 的 Note。
3

4
> [!TIP] TIP
5
> 对应 GitHub 的 Tip。
6

7
> [!IMPORTANT] IMPORTANT
8
> 对应 GitHub 的 Important。
9

10
> [!WARNING] WARNING
11
> 对应 GitHub 的 Warning。
12

13
> [!CAUTION] CAUTION
14
> 对应 GitHub 的 Caution。
15

16
> [!TIP] 自定义标题
17
> VitePress 风格同样支持自定义标题。

展开收起

VitePress

4. Docusaurus 风格语法#

仅支持语法，风格保持跟上面三个主题相同。

点击展开 Docusaurus 语法列表

支持以下类型的提醒框：note tip important warning caution

1
:::note
2
突出显示用户应该考虑的信息，即使在快速浏览时也是如此。
3
:::
4

5
:::tip
6
可选信息，帮助用户更成功。
7
:::
8

9
:::important
10
用户成功所必需的关键信息。
11
:::
12

13
:::warning
14
由于潜在风险需要用户立即注意的关键内容。
15
:::
16

17
:::caution
18
行动的负面潜在后果。
19
:::
20

21
:::tip[自定义标题]
22
可选信息，帮助用户更成功。
23
:::

展开收起

剧透#

您可以为文本添加剧透。文本也支持 Markdown 语法。

内容被隐藏了哈哈！

1
内容 :spoiler[被隐藏了 **哈哈**]！

图片画廊网格 (Image Grid)#

您可以使用 [grid] 和 [/grid] 标签将多张图片纵向并排展示。这对于展示照片画廊或对比图非常有用。系统会自动根据包裹在其中的图片数量（最多支持并排展示4张）以响应式网格进行布局。

自动补齐图片高度： 同一排中如果有高度、大小或者比例不一的图片，会像「九宫格画廊相册」一样自动撑满。较短或不协调的图片会自动使用 object-cover 进行完美中心裁剪补充视野。图片边框水平彻底对齐无缝隙，但被裁剪后，只有点击图片通过灯箱才能查看完整图片，所以建议尽量避免使用长宽比例不一致的图片在同一排中。

图注恒定底端对齐： 不论上面的图片长宽如何变化，在同一行的所有图像解释文字（图注）都会对标到一条完美的水平基线上了。

示例图片一

示例图片二

基本语法

1
[grid]
2
![示例图片一](./images/firefly1.avif)
3
![示例图片二](./images/firefly2.avif)
4
![示例图片二](./images/firefly3.avif)
5
[/grid]

Markdown Mermaid 图表

Thu, 01 Jan 1970 00:00:00 GMT

Markdown 中 Mermaid 图表完整指南#

本文演示如何在 Markdown 文档中使用 Mermaid 创建各种复杂图表，包括流程图、时序图、甘特图、类图和状态图。

流程图示例#

流程图非常适合表示流程或算法步骤。

graph TD A[开始] --> B{条件检查} B -->|是| C[处理步骤 1] B -->|否| D[处理步骤 2] C --> E[子过程] D --> E subgraph E [子过程详情] E1[子步骤 1] --> E2[子步骤 2] E2 --> E3[子步骤 3] end E --> F{另一个决策} F -->|选项 1| G[结果 1] F -->|选项 2| H[结果 2] F -->|选项 3| I[结果 3] G --> J[结束] H --> J I --> J

时序图示例#

时序图显示对象之间随时间的交互。

sequenceDiagram participant User as 用户 participant WebApp as 网页应用 participant Server as 服务器 participant Database as 数据库 User->>WebApp: 提交登录请求 WebApp->>Server: 发送认证请求 Server->>Database: 查询用户凭据 Database-->>Server: 返回用户数据 Server-->>WebApp: 返回认证结果 alt 认证成功 WebApp->>User: 显示欢迎页面 WebApp->>Server: 请求用户数据 Server->>Database: 获取用户偏好 Database-->>Server: 返回偏好设置 Server-->>WebApp: 返回用户数据 WebApp->>User: 加载个性化界面 else 认证失败 WebApp->>User: 显示错误消息 WebApp->>User: 提示重新输入 end

甘特图示例#

甘特图非常适合显示项目进度和时间线。

gantt title 网站开发项目时间线 dateFormat YYYY-MM-DD axisFormat %m/%d section 设计阶段需求分析 :a1, 2023-10-01, 7d UI设计 :a2, after a1, 10d 原型创建 :a3, after a2, 5d section 开发阶段前端开发 :b1, 2023-10-20, 15d 后端开发 :b2, after a2, 18d 数据库设计 :b3, after a1, 12d section 测试阶段单元测试 :c1, after b1, 8d 集成测试 :c2, after b2, 10d 用户验收测试 :c3, after c2, 7d section 部署生产环境部署 :d1, after c3, 3d 发布 :milestone, after d1, 0d

类图示例#

类图显示系统的静态结构，包括类、属性、方法及其关系。

classDiagram class User { +String username +String password +String email +Boolean active +login() +logout() +updateProfile() } class Article { +String title +String content +Date publishDate +Boolean published +publish() +edit() +delete() } class Comment { +String content +Date commentDate +addComment() +deleteComment() } class Category { +String name +String description +addArticle() +removeArticle() } User "1" -- "*" Article : 写作 User "1" -- "*" Comment : 发表 Article "1" -- "*" Comment : 拥有 Article "1" -- "*" Category : 属于

状态图示例#

状态图显示对象在其生命周期中经历的状态序列。

stateDiagram-v2 [*] --> 草稿草稿 --> 审核中 : 提交审核中 --> 草稿 : 拒绝审核中 --> 已批准 : 批准已批准 --> 已发布 : 发布已发布 --> 已归档 : 归档已发布 --> 草稿 : 撤回 state 已发布 { [*] --> 活跃活跃 --> 隐藏 : 临时隐藏隐藏 --> 活跃 : 恢复活跃 --> [*] 隐藏 --> [*] } 已归档 --> [*]

饼图示例#

饼图非常适合显示比例和百分比数据。

pie title 网站流量来源分析 "搜索引擎" : 45.6 "直接访问" : 30.1 "社交媒体" : 15.3 "推荐链接" : 6.4 "其他来源" : 2.6

总结#

Mermaid 是在 Markdown 文档中创建各种类型图表的强大工具。本文演示了如何使用流程图、时序图、甘特图、类图、状态图和饼图。这些图表可以帮助您更清晰地表达复杂的概念、流程和数据结构。

要使用 Mermaid，只需在代码块中指定 mermaid 语言，并使用简洁的文本语法描述图表。Mermaid 会自动将这些描述转换为美观的可视化图表。

尝试在您的下一篇技术博客文章或项目文档中使用 Mermaid 图表 - 它们将使您的内容更加专业且更易理解！

Markdown 教程

Thu, 01 Jan 1970 00:00:00 GMT

这是一个展示如何编写 Markdown 文件的示例。本文档汇总了核心语法与常见扩展（GFM）。

块级元素
- 段落与换行
- 标题
- 引用
- 列表
- 代码块
- 分割线
- 表格
内联元素
- 链接
- 强调
- 行内代码
- 图片
- 删除线
杂项
- 自动链接
- 反斜杠转义
内联 HTML

块级元素#

段落与换行#

段落#

HTML 标签：<p>

使用一个或多个空行分隔段落。（仅包含空格或制表符的行也视为空行。）

代码：

1
This will be
2
inline.
3

4
This is second paragraph.

预览：

This will be inline.

This is second paragraph.

换行#

HTML 标签：<br />

在行末添加两个或更多空格来产生换行。

代码：

1
This will be not
2
inline.

预览：

This will be not
inline.

标题#

Markdown 支持两种标题样式：Setext 与 atx。

Setext#

HTML 标签：<h1>，<h2>

使用等号 (=) 表示 <h1>、使用短横线 (-) 表示 <h2>，数量不限，作为“下划线”。

代码：

1
This is an H1
2
=============
3
This is an H2
4
-------------

预览：

This is an H1#

This is an H2#

atx#

HTML 标签：<h1>，<h2>，<h3>，<h4>，<h5>，<h6>

在行首使用 1-6 个井号 (#)，对应 <h1> 至 <h6>。

代码：

1
# This is an H1
2
## This is an H2
3
###### This is an H6

预览：

This is an H1#

This is an H2#

This is an H6#

可选：你可以在行尾“闭合” atx 标题。末尾的井号数量不必与开头一致。

代码：

1
# This is an H1 #
2
## This is an H2 ##
3
### This is an H3 ######

预览：

This is an H1#

This is an H2#

This is an H3#

引用#

HTML 标签：<blockquote>

Markdown 使用邮件风格的 > 作为引用符号。若手动换行并在每行前加 >，显示效果最佳。

代码：

1
> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
2
> consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
3
> Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
4
>
5
> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
6
> id sem consectetuer libero luctus adipiscing.

预览：

This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing.

Markdown 允许“偷懒”：在一个硬换行段落中，只在第一行前加 > 即可。

代码：

1
> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
2
consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
3
Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
4

5
> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
6
id sem consectetuer libero luctus adipiscing.

预览：

This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.

Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing.

引用可以嵌套（引用中的引用），通过增加 > 层级实现。

代码：

1
> This is the first level of quoting.
2
>
3
> > This is nested blockquote.
4
>
5
> Back to the first level.

预览：

This is the first level of quoting.
This is nested blockquote.
Back to the first level.

引用内可包含其他 Markdown 元素，包括标题、列表与代码块。

代码：

1
> ## This is a header.
2
>
3
> 1.   This is the first list item.
4
> 2.   This is the second list item.
5
>
6
> Here's some example code:
7
>
8
>     return shell_exec("echo $input | $markdown_script");

预览：

This is a header.#

This is the first list item.

This is the second list item.

Here’s some example code:
1
return shell_exec("echo $input | $markdown_script");

列表#

Markdown 支持有序（数字）与无序（圆点）列表。

无序列表#

HTML 标签：<ul>

无序列表可使用 星号 (*)、加号 (+) 或 短横线 (-)。

代码：

1
*   Red
2
*   Green
3
*   Blue

预览：

Red
Green
Blue

等价于：

代码：

1
+   Red
2
+   Green
3
+   Blue

或者：

代码：

1
-   Red
2
-   Green
3
-   Blue

有序列表#

HTML 标签：<ol>

有序列表使用数字加英文句点：

代码：

1
1.  Bird
2
2.  McHale
3
3.  Parish

预览：

Bird
McHale
Parish

注意：像下面这样可能会“意外触发”有序列表：

代码：

1
1986. What a great season.

预览：

What a great season.

你可以用反斜杠转义 (\) 句点：

代码：

1
1986\. What a great season.

预览：

1986. What a great season.

列表中的缩进内容#

列表项里的引用#

在列表项内放置引用，需要将 > 符号整体缩进：

代码：

1
*   A list item with a blockquote:
2

3
    > This is a blockquote
4
    > inside a list item.

预览：

A list item with a blockquote:

This is a blockquote inside a list item.

列表项里的代码块#

在列表项内放置代码块，需要缩进两层——8 个空格或两个 Tab：

代码：

1
*   A list item with a code block:
2

3
        <code goes here>

预览：

A list item with a code block:
```
1
<code goes here>
```

嵌套列表#

代码：

1
* A
2
  * A1
3
  * A2
4
* B
5
* C

预览：

A
- A1
- A2
B
C

代码块#

HTML 标签：<pre>

将代码块中的每行缩进至少4 个空格或1 个制表符。

代码：

1
This is a normal paragraph:
2

3
    This is a code block.

预览：

This is a normal paragraph:

1
This is a code block.

代码块会一直持续，直到遇到未缩进的行（或文末）。

在代码块内，与号 (&) 和尖括号 (< >) 会自动转为 HTML 实体。

代码：

1
    <div class="footer">
2
        &copy; 2004 Foo Corporation
3
    </div>

预览：

1
<div class="footer">
2
    &copy; 2004 Foo Corporation
3
</div>

下文的“围栏代码块”和“语法高亮”属于扩展语法，你也可以用它们来书写代码块。

围栏代码块#

使用成对的反引号围起来（如下所示），就不需要四空格缩进了。

代码：

1
Here's an example:
2

3
```
4
function test() {
5
  console.log("notice the blank line before this function?");
6
}
7
```

预览：

Here’s an example:

1
function test() {
2
  console.log("notice the blank line before this function?");
3
}

语法高亮#

在围栏代码块后添加可选的语言标识，即可启用语法高亮（参见支持语言列表）。

代码：

1
```ruby
2
require 'redcarpet'
3
markdown = Redcarpet.new("Hello World!")
4
puts markdown.to_html
5
```

预览：

1
require 'redcarpet'
2
markdown = Redcarpet.new("Hello World!")
3
puts markdown.to_html

分割线（水平线）#

HTML 标签：<hr /> 一行中放置三个或以上的短横线 (-)、星号 (*) 或下划线 (_)。符号之间允许有空格。

代码：

1
* * *
2
***
3
*****
4
- - -
5
---------------------------------------
6
___

预览：

表格#

HTML 标签：<table>

这是扩展语法。

用竖线 (|) 分隔列，用短横线 (-) 分隔表头，使用冒号 (:) 指定对齐方式。

两侧的竖线 (|) 与对齐可选。用于表头分隔时，每列至少需要 3 个短横线。

代码：

1
| Left | Center | Right |
2
|:-----|:------:|------:|
3
|aaa   |bbb     |ccc    |
4
|ddd   |eee     |fff    |
5

6
 A | B
7
---|---
8
123|456
9

10

11
A |B
12
--|--
13
12|45

预览：

Left	Center	Right
aaa	bbb	ccc
ddd	eee	fff

A	B
123	456

A	B
12	45

内联元素#

链接#

HTML 标签：<a>

Markdown 支持两种链接样式：行内链接与引用式链接。

行内链接#

行内链接格式：[文本](URL "标题")

标题可选。

代码：

1
This is [an example](http://example.com/ "Title") inline link.
2

3
[This link](http://example.net/) has no title attribute.

预览：

This is an example inline link.

This link has no title attribute.

如果引用同一站点的本地资源，可以使用相对路径：

代码：

1
See my [About](/about/) page for details.

预览：

See my About page for details.

引用式链接#

可以预定义链接引用。定义格式：[id]: URL "标题"

标题同样可选。引用时使用：[文本][id]

代码：

1
[id]: http://example.com/  "Optional Title Here"
2
This is [an example][id] reference-style link.

预览：

This is an example reference-style link.

说明：

方括号中包含链接标识（不区分大小写，可在左侧缩进最多三格空格）；
随后是冒号；
再跟一个或多个空格（或 tab）；
然后是链接 URL；
URL 可选地用尖括号包裹；
可选地跟随标题属性，用引号或圆括号包裹。

以下三种定义等价：

代码：

1
[foo]: http://example.com/  "Optional Title Here"
2
[foo]: http://example.com/  'Optional Title Here'
3
[foo]: http://example.com/  (Optional Title Here)
4
[foo]: <http://example.com/>  "Optional Title Here"

如果使用空的方括号，则链接文本本身会作为名称。

代码：

1
[Google]: http://google.com/
2
[Google][]

预览：

Google

强调#

HTML 标签：<em>，<strong>

Markdown 使用 星号 (*) 或 下划线 (_) 表示强调。一个分隔符对应 <em>；两个分隔符对应 <strong>。

代码：

1
*single asterisks*
2

3
_single underscores_
4

5
**double asterisks**
6

7
__double underscores__

预览：

single asterisks

single underscores

double asterisks

double underscores

但如果两侧有空格，则会被视作普通字符而非强调语法。

你可以使用反斜杠进行转义：

代码：

1
\*this text is surrounded by literal asterisks\*

预览：

*this text is surrounded by literal asterisks*

行内代码#

HTML 标签：<code>

用反引号 (`) 包裹。

代码：

1
Use the `printf()` function.

预览：

Use the printf() function.

若行内代码中需要包含反引号字符，可使用多重反引号作为定界符：

代码：

1
``There is a literal backtick (`) here.``

预览：

There is a literal backtick (`) here.

行内代码两侧的定界符允许包含空格（开头一个、结尾一个），方便在代码起始或结尾放置反引号字符：

代码：

1
A single backtick in a code span: `` ` ``
2

3
A backtick-delimited string in a code span: `` `foo` ``

预览：

A single backtick in a code span: `

A backtick-delimited string in a code span: `foo`

图片#

HTML 标签：<img />

Markdown 的图片语法与链接类似，支持行内与引用两种方式。

行内图片#

行内图片语法：![替代文本](URL "标题")

标题可选。

代码：

1
![Alt text](/path/to/img.jpg)
2

3
![Alt text](/path/to/img.jpg "Optional title")

预览：

Alt text

说明：

一个感叹号 !；
后接方括号，放置图片的替代文本；
再接圆括号，内含图片 URL/路径，及可选的标题（引号包裹）。

引用式图片#

引用式图片语法：![替代文本][id]

代码：

1
[img id]: https://s2.loli.net/2024/08/20/5fszgXeOxmL3Wdv.webp  "Optional title attribute"
2
![Alt text][img id]

预览：

Alt text

删除线#

HTML 标签：<del>

这是扩展语法。

GFM 增加了删除线语法。

代码：

1
~~Mistaken text.~~

预览：

Mistaken text.

杂项#

自动链接#

Markdown 支持一种便捷写法来创建“自动链接”（URL 与邮箱地址）：只需用尖括号将其包住即可。

代码：

1
<http://example.com/>
2

3
<address@example.com>

预览：

http://example.com/

address@example.com

GFM 会自动识别标准 URL 并转换为链接。

代码：

1
https://github.com/emn178/markdown

预览：

https://github.com/emn178/markdown

反斜杠转义#

Markdown 允许使用反斜杠来转义那些本用于 Markdown 语法的特殊字符，使其按字面显示。

代码：

1
\*literal asterisks\*

预览：

*literal asterisks*

以下字符可通过反斜杠转义以按字面量输出：

Code:

1
\   backslash
2
`   backtick
3
*   asterisk
4
_   underscore
5
{}  curly braces
6
[]  square brackets
7
()  parentheses
8
#   hash mark
9
+   plus sign
10
-   minus sign (hyphen)
11
.   dot
12
!   exclamation mark

内联 HTML#

对于 Markdown 语法未覆盖的标记，直接使用原生 HTML 即可。无需特别声明从 Markdown 切换到 HTML，直接写标签就行。

代码：

1
This is a regular paragraph.
2

3
<table>
4
    <tr>
5
        <td>Foo</td>
6
    </tr>
7
</table>
8

9
This is another regular paragraph.

预览：

This is a regular paragraph.

Foo

This is another regular paragraph.

请注意：在块级 HTML 标签内不会处理 Markdown 语法。

与块级标签不同，在行内级标签内会处理 Markdown 语法。

代码：

1
<span>**Work**</span>
2

3
<div>
4
    **No Work**
5
</div>

预览：

Work

**No Work**

***

在文章中嵌入视频

Thu, 01 Jan 1970 00:00:00 GMT

只需从 YouTube 或其他平台复制嵌入代码，然后将其粘贴到 markdown 文件中。

1
---
2
title: 在文章中嵌入视频
3
published: 2023-10-19
4
// ...
5
---
6

7
<iframe width="100%" height="468" src="https://www.youtube.com/embed/5gIf0_xpFPI?si=N1WTorLKL0uwLsU_" title="YouTube video player" frameborder="0" allowfullscreen></iframe>

无穷大？

Chrome 将我的后台登录页标记为危险：一次 Safe Browsing 误判排查记录

Chrome 将我的后台登录页标记为危险：一次误判排查记录#

一、问题页面结构#

二、为什么会被误判？#

三、排查过程#

1. 检查是否存在恶意代码#

2. 检查服务器与容器#

3. 确认问题本质#

四、修复措施#

1. 去掉默认用户名#

2. 增加品牌与归属说明#

3. 更新页面 metadata#

4. 改善页面语义结构#

5. 限制后台访问#

五、提交复审#

六、经验总结#

不要公开暴露后台登录页#

安全系统判断的是“像不像”#

七、最终建议#

结语#

使用AI开发纯血鸿蒙arkTS应用的进阶指南（VSCode+Copilot）

【爽文】万律之主：从AK高考开始。

第一章：凡人的计算与神明的答案#

第二章：维度的臣服#

第三章：英语考场上的因果律崩溃#

第四章：真理的强制执行#

第五章：维度跃迁与文明重构#

第六章：回归与永恒的草稿纸#

深入浅出 gRPC：构建高性能微服务的现代 RPC 框架

什么是 gRPC？#

RPC 的核心思想#

gRPC 的三大支柱#

1. Protocol Buffers (Protobuf)#

2. HTTP/2 传输协议#

3. 代码生成#

gRPC 的四种通信模式#

gRPC vs REST：该如何选择？#

gRPC 的优势#

缺点与挑战#

快速上手：.proto 定义示例#

总结：什么时候该用 gRPC？#

打油诗一首

The Classroom Backyard#

像 AI 一样学习：我们能从 AI 身上学到什么？

Cloisonné

社团改名：一种文化心态的反思

班级神人之随地认义父

班级神人之崇洋媚外者

班级神人之 Vim 大神

GitHub新版学生认证——其实更容易了？

1. 翻译学生证明#

2. 修改 GitHub 个人资料#

3. 前往认证#

4. 等待审核#

1Panel V1 到 V2 升级：详细指南与避坑分享

1. 准备阶段：下载并配置迁移工具#

2. 核心服务升级#

3. 网站服务升级与问题解决#

4. 升级完成#

野史：俗世奇人章大神

一、扫描之王#

二、义管之王#

三、学海之王#

四、体活之王#

五、MC 之王#

课。

第一站 服务器程序的注入#

注入是什么？#

原题【CTF】Web#

题目背景#

题目描述#

一句话题意#

完整题意#

输入格式#

输出格式#

说明/提示#

运行测试#

代码审查#

继续#

快速上手：`.proto` 定义示例#

第一站服务器程序的注入#

3.2 图的构建与最短路#

第壹节初识服务器：选购、安装与配置#