xmy 2025-12-08T16:55:31.000Z https://xmy1107.github.io/ Mingyang Xu Hexo https://xmy1107.github.io/post/htmls/map.html.html 2025-12-08T16:55:54.234Z 2025-12-08T16:55:31.000Z 2025年度总结 https://xmy1107.github.io/post/2025%E5%B9%B4%E5%BA%A6%E6%80%BB%E7%BB%93.html 2025-12-08T16:41:00.000Z 2026-01-21T14:07:50.086Z 几乎是完全做到了24年末总结里说的“给我好好去玩”，但相应的，可以写下来的那些“收获”就少一些了。

保研

三作的论文辗转 CAD/Graphics、PRCV、CVM，说是全被拒，那我是真不想继续帮打工了，搞了半天的东西没在保研上给我一点点的优势，联系的老师即便对我评价好，但不招人又有啥用呢。。。浙大是我最错付的地方了。。。

邮件从三月到九月发了 20 + 19 + 21 + 15 + 14 + 65 = 154 封，可能有人好奇为啥七个月只有六个数字，因为八月没发，夏令营全没进摆烂了，甜蜜蜜了一个月。

下面是最终结果。

夏令营就进了浙软，剩下的全没进：
软微、国科大、贵系、北大智能、华东师大、上交计算机、哈工深、中科大、南大计算机、南软、复旦大数据
自以为浙软那不到一周时间里做的东西蛮有竞争力的，是对数据闭源模型的全流程复现，听完其他人的报告真觉得自己做得挺好，包括“我导”，但这就不细讲了，总之结果是大败。跟十几进一还有我的双非背景都有关系，是场注定打不赢的仗。alphageometry

预推免就进了华东师大计院、北航国新院、北航软院，后两者冲突了，就把北航软院丢了。
未入：清华仨院、浙软、复旦工程硕博、南大智能、南大软院、南大计院、哈工深电子信息 计算机技术、哈工深智能学部 电子信息 人工智能、东南、南开卓越工程师、同济、北航计院、软微、北深、中科大工程硕博、上交人工智能、复旦智能机器人

最后拿了华师大和北航俩offer，去了国新院。虽有不甘，但只能认命，并在之后的日子也是找到了新的意义——在压力小的地方我可以自由拓展我那恣意生长的兴趣爱好。

教培

1月2月寒假在家，顺带教下 USACO 铜升银

2024.12 ~ 2025.3 发现一个小商机，断断续续挣了点

7.27 ~ 8.12 苏州新东方 CSP-J

国庆 & CSP前，扬州新东方

算钱的话，加上 minmax 实习，和省政府奖学金（对，国奖也没评上，今年纯小丑）到手10个不到点，而且换新设备、恋爱支出、日本旅游等，也没攒下多少钱

情感

谈了一段十分真挚的恋爱，但似乎没法坚持到农历新年了

具体的恋爱经历都在自己的小本本里记着，不方便公之于众，但这儿得记一笔！

零碎

此外还有一些诸如省赛金、手术、日本旅游等比较大但又没有合适分类的事情，就在这带过了。

今年的收获可能大多难以通过文字表达，保研、教培、实习、恋爱本身可量化的收获其实并不多，更多的是我做了这些事后的体会和成长，私以为今年的收获不逊于去年。

]]> <p>几乎是完全做到了24年末总结里说的“给我好好去玩”，但相应的，可以写下来的那些“收获”就少一些了。</p> <h1>保研</h1> <p>三作的论文辗转 CAD/Graphics、PRCV、CVM，说是全被拒，那我是真不想继续帮打工了，搞了半天的东西没在保研上给我一点点的优 洛谷网页 html bug https://xmy1107.github.io/post/%E6%B4%9B%E8%B0%B7%E7%BD%91%E9%A1%B5%20html%20bug.html 2025-11-30T16:37:13.000Z 2025-12-08T16:39:49.000Z 在包含代码的网页中检视，选中 Element 中的代码对应元素，可以发现其 Style 为 font-family: var(--lfe-code-font, monospace) !important;

而 monospace 为字面量，并非变量，不应该在 var 中，这样前者的值 “Consolas” 在 Mac 上没安装（Win 可以），后者因语法错误无法被识别，只能显示 PingFang SC 字体

正确语法是 var(--lfe-code-font), monospace，这样才能在 Consolas 没有安装时回退到 monospace，正确显示等宽字体

解决方法：安装浏览器插件 Stylus，添加规则代码，作用为修改 --lfe-code-font 变量值，这样可以直接显示 Menlo 字体

1
2
3
body {
    --lfe-code-font: "Menlo", "Monaco" !important;
}

在验证本地的确没有安装 Consolas 时发现，回退会模拟原始字体的某些视觉特征。测试中 font-family: Consolas, monospace; 虽然显示的字体是 monospace 中的 Menlo，但大小和 font-family: monospace; 并不同：

]]> <p>在包含代码的网页中检视，选中 Element 中的代码对应元素，可以发现其 Style 为 <code>font-family: var(--lfe-code-font, monospace) !important;</code></p> <p><img src="Imag 记录新电脑配置 https://xmy1107.github.io/post/%E8%AE%B0%E5%BD%95%E6%96%B0%E7%94%B5%E8%84%91%E9%85%8D%E7%BD%AE.html 2025-11-16T12:36:13.000Z 2026-01-07T14:43:39.000Z 文件备份

对 windows 上所有文件分类并打包到固态硬盘，不常用文件，比如上完的课的资料直接放进去，常用文件留在桌面，将整个桌面拷贝到固态，最后转移到 mac。其中所有内容都在夸克网盘再备份。

同步规则

电脑文件/手机中图片视频等：夸克网盘增量同步

Obsidian上笔记/Zotero上论文：WebDAV全量同步，服务器为InfiniCLOUD

手机备忘录/录音：小米云盘备份

notability中笔记：OneDrive -> WebDAV全量同步

iCloud 不论 mac 还是 pad 上一律关闭

快捷键

设置 QQ、微信、飞书热键，cmd + shift + 1/2/W 分别对应三个应用

Karabiner 交换 command + tab 与 ctrl + tab

Scroll Reverser 令鼠标单独关闭自然滚动

Dozer 管理桌面小图标

超级右键 创建文本文件、进入终端（这几个操作竟也要我安装个 app！）

安装 maccy 代替 windows 剪切板功能

ToDesk 竟必须开了后台权限才能登录。ps：ToDesk 很有用，比如 WebDAV 的账号密码，我可以直接打开 Ubuntu 的 Obsidian 然后直接复制到这台电脑。

cmd+H, cmd+M 调度中心里看不到（H 藏窗口，M 藏应用）

cmd+W 无窗口，是否在后台或程序坞取决于具体应用

cmd+Q 应用关闭

fn 关闭状态，因为 Windows 上常用的 F2、F5 本身也无法生效

mac 中英文切换发现 bug，改搜狗输入法，顺带还能贴合我其他设备使用逻辑

键盘设置关闭“使用大写锁定切换ABC输入法”和“连按两下空格输入句号”这些功能，然后 ctrl + space 切换搜狗和ABC，shift 切换中英文，caps lock 切换大小写。

洛谷网页的 html 有 bug，加上 macOS 上没 Consolas，需安装插件 Stylus，添加规则代码（应用范围可以选择全部网页）：

1
2
3
body {
    --lfe-code-font: "Menlo", "Monaco" !important;
}

日志相关

随笔直接飞书记，博客先下 Obsidian，remotely save 插件同步所有博客，仓库名必须是 _posts，否则无法和云上文件夹名字对齐，无法同步。

顺带记录 Obsidian 撰写博客要点

首先 hexo new "title" 创建文章，然后直接在 Obsidian 中编辑，属性分类等都可以图形化操作。

粘贴图片会直接将图片放到 Images 文件夹下，且用相对路径，不管本地还是网页都可以正常查看（这里设置了 _config.yml 的 post_asset_folder 为 false，原本会放到 $(filename) 文件夹下，且原本改标题还要顺带改好多东西，现在不用了）。

写完需要先点击同步，同步到服务器，然后通过 ToDesk 在 Ubuntu 上也点击同步，之后的 hexo cl && hexo g && hexo s通过 ToDesk 还是 ssh 都可以。

一些配置

cursor

code-runner.runInTerminal 打开，不然在输出视图是没法输入内容的

inlay hints 工程代码打开，竞赛代码关闭，或者也可以默认隐藏，ctrl + option 显示

Preferences: Open User Settings (JSON) 中加入如下代码，这样文件名出现空格等符号均可以运行：

1
2
3
"code-runner.executorMap": {
    "cpp": "cd \"$dir\" && g++ \"$fileName\" -o \"$fileNameWithoutExt\" && \"$dir/$fileNameWithoutExt\"" 
}

同样的地方，可以加入如下代码，避免打一个 tab 变成四个空格

1
2
3
"editor.insertSpaces": false,
"editor.tabSize": 4,
"editor.detectIndentation": false

自动补全提示关闭：

1
2
3
4
5
6
"editor.quickSuggestions": {
"other": false,
"comments": false,
"strings": false
},
"editor.suggestOnTriggerCharacters": false
]]> <h1>文件备份</h1> <p>对 windows 上所有文件分类并打包到固态硬盘，不常用文件，比如上完的课的资料直接放进去，常用文件留在桌面，将整个桌面拷贝到固态，最后转移到 mac。其中所有内容都在夸克网盘再备份。</p> <h2 id="同步规则">同步规则</h2> < 圆上的整点 https://xmy1107.github.io/post/%E5%9C%86%E4%B8%8A%E7%9A%84%E6%95%B4%E7%82%B9.html 2025-11-16T06:14:13.000Z 2025-11-16T12:28:10.000Z 问题引入

考虑这样一个问题：求满足 的有序整数对 的个数，即求以原点为圆心、半径为 的圆上的格点（整数点）个数。

高斯整数视角

我们注意到 可以表示为 ，这启发我们从高斯整数的角度来思考这个问题。

高斯整数是形如 的数，其中 是整数。高斯整数环 是一个唯一分解整环，每个高斯整数可以唯一分解为高斯素数的乘积（唯一性是在可乘单位 的意义下）。

费马平方和定理与素数分解

根据费马平方和定理，一个奇素数 可以表示为两个整数的平方和 当且仅当 。

对于高斯整数分解：

  • ，其中
  • 对于 的素数，，其中 和 是共轭的高斯素数
  • 对于 的素数， 在高斯整数中仍然是素数

方案计数详解

设 的素因数分解为：

我们要将 分解为两个共轭高斯整数的乘积：。考虑每个素因子的分配方式：

对于 的素数

设 ，那么 。在分解 时，我们需要将 分配到两个因子中。

设左边 包含 ，那么右边 包含 。由于两个因子必须共轭，即 ，我们有：

这必须等于右边的 ，因此：

所以 。这意味着我们只需要决定左边取 的指数 ，那么左边取 的指数就是 。 可以取 ，共 种选择。

对于 的素数

这类素数 在高斯整数中仍然是素数，且是实的（自共轭）。设 ，在分解时，左边取 ，右边取 。

由于两个因子必须共轭，且 是实的，我们有：

因此， 必须是偶数，且此时 ，只有一种分配方式。如果 是奇数，则无法分配，解数为 0。

素数 2 的处理

对于素数 ，注意到 ，因此两者只差一个单位元。

在分配 到两个共轭因子时，由于单位元 的调整作用，不同的分配方式实际上是等价的。

因此，无论 取何值，素数 的贡献因子始终为 ，不影响最终解数。

在公式中，我们直接忽略素数 的指数，其贡献因子为 。

单位元的影响与总解数

上述分配方式给出了 分解为两个共轭高斯整数乘积的所有可能。但注意，如果 是一个解，那么乘以单位元 () 后， 也对应一个解，且这些解是不同的（除非 ）。

实际上，每个分配方式对应一个高斯整数 满足 ，而这样的 的个数就是解数。通过详细分析（考虑单位元的作用和分配方式的等价性），我们得到最终解数为：

如果所有为偶数否则

例：

  • ：指数为 1，但最终不影响解数（因为单位元调整后，2 的分配不产生额外因子）
  • ：指数为 2（偶数），贡献因子 1
  • ：指数为 2，贡献因子
  • 总解数为

引申：特征函数方法

到此为止其实已经得到了问题的解法，且为已知的最优复杂度 ，即分解质因数复杂度。

为了更统一地表达解数公式，我们引入特征函数 ：

积性证明： 是完全积性函数，即对于任意 ，有 。

考虑模 4 的余数，若 或 是偶数，则 也是偶数，，而 （因至少一个因子为 0）。若 均为奇数，则 ，，乘积 ，即 当且仅当 同余，否则 。而 在同余时为正，异号时为负，故成立。

约数和公式

对于正整数 ，其所有正约数可以表示为 ，其中 。

由于 是完全积性函数，我们有：

因此，所有约数的 值之和为：

这就是约数和公式的由来：每个素因子 独立地贡献一个因子 ，而所有约数的 值之和就是这些因子的乘积。

各类素数的贡献

分别计算每类素数的贡献：

  • ：，
  • ：，为偶数为奇数
  • ：，（），

因此，所有的指数为偶数否则

最终公式

半径为 的圆上格点数为：

这个简洁的公式统一了不同类型素数对解数的影响，体现了特征函数在数论问题中的强大威力。

与圆周率的联系

当 时，圆内格点数（满足 的格点个数）近似于圆的面积 （半径为 ），即：

其中 是半径为 的圆上格点数。代入得：

通过夹逼定理，当 时， 可替换为 ，在此不作详细证明，因此：

另一方面，由微积分知识：

这个优美的巧合体现了数学不同分支之间的深刻联系——数论中的格点问题与微积分中的级数展开殊途同归，共同揭示了圆周率的本质。

]]> <h1>问题引入</h1> <p>考虑这样一个问题：求满足 <mjx-container class="MathJax" jax="SVG"><svg style="vertical-align: -0.464ex;" xmlns="http://www.w3.org/2000/ 专业课复习 https://xmy1107.github.io/post/%E4%B8%93%E4%B8%9A%E8%AF%BE%E5%A4%8D%E4%B9%A0.html 2025-08-25T11:19:46.000Z 2025-08-25T12:53:50.116Z C/C++

const

（为了方便记忆可以想成）被 const 修饰（在 const 后面）的值不可改变

1
2
3
4
const int *p=&a,r=10;//指向常量的指针（const 后面是 int，说明指向的整形变量不可改变）
int* const q=&a;//自身是常量的指针
int *t=r;//这句错误，前必须加const
int* const s;//这句编译错误，必须初始化，否则定义了一个永久野指针
指向常量的指针自身是常量的指针
可以同时定义别的常量无法一句话中定义多个变量
可以不立即初始化必须初始化，否则无意义
]]> <h1>C/C++</h1> <h2 id="const">const</h2> <blockquote><span class="custom-blockquote-svg"><svg width="24" height="24" viewBox="0 0 24 24" fil alphageometry复现 https://xmy1107.github.io/post/alphageometry%E5%A4%8D%E7%8E%B0.html 2025-07-03T10:48:15.000Z 2025-11-16T12:42:19.000Z Code

项目链接

fixed：numericals.pycheck_cyclic(a, b, c), *ps = points => a, b, c, *ps = points

Method

论文概要

AlphaGeometry Syntax

解读1（from知乎）

解读2（from谷歌共享文档）

解读3（from某github项目）

原语：

coll a b c : points a b c are collinear

cong a b c e : segments ab and cd are congruent (length equal)

contri a b c p q r : triangles abc and pqr are congruent

cyclic a b c d : 4 points a b c d are cocyclic

eqangle a b c d p q r s : the angles between lines ab-cd and pq-rs are equal. Note that angles have directions (signs) so the order between a b and c d matters. eqangle a b c d c d a b is false. The way to think about it is, angle ab-cd is the angle to turn line ab clockwise so it is parallel with the line cd. You can use counter-clockwise as the convention too, as long as for all angles the same convention is used

eqratio a b c d p q r s : segment length ab/cd = pq/rs

midp m a b : point m is the midpoint of a and b

para a b c d : segments ab and cd are parallel

perp a b c d : segments ab and cd are perpendicular to each other

simtri a b c p q r : triangles abc and pqr are similar

DD推导的公式基于rules.txt：

1
2
3
4
5
perp A B C D, perp C D E F, ncoll A B E => para A B E F# AB ⊥ CD, CD ⊥ EF, ABE不共线 => AB // EF
cong O A O B, cong O B O C, cong O C O D => cyclic A B C D# OA = OB, OB = OC, OC = OD => ABCD共圆
eqangle A B P Q C D P Q => para A B C D
cyclic A B P Q => eqangle P A P B Q A Q B
......

所有的操作都记录在defs.txt中，操作表：

六行为一组：construction, rely, deps, basics, numerics, _ = data.split('\n')

1
2
3
4
5
6
7
8
9
10
11
12
angle_mirror x a b c# 对角abc以bc为对称轴作镜像反转
x : a b c x# x由abcx决定
a b c = ncoll a b c# abc需要满足的条件
x : eqangle b a b c b c b x# ∠abc = ∠xbc
amirror a b c# 另一种表示

circle x a b c# 定义x为由abc确定的圆的圆心
x : a b c
a b c = ncoll a b c
x : cong x a x b, cong x b x c# xa = xb = xc
bline a b, bline a c# bline代表中垂线，这句是第一句的另一种表示
......

点+ ‘=’ + 1-2个操作 => 点的构造，点的构造间用分号分隔。以一道证明垂心的题举例：

1
2
3
orthocenter
a b c = triangle; h = on_tline b a c, on_tline c a b ? perp a h b c
# abc为一三角形；hb ⊥ ac 并且 hc ⊥ ab。证明ha垂直bc

tips：

空格敏感，出现一个多余空格，哪怕不是在当前题目中，也会无法运行

Configuration

issue：GPU用不了

meliad库需要git checkout e8af054

Data Generation

随机生成图

image_generate.py将常用的一些操作分为三类调用，除了第一句的segment a b或triangle a b c外，剩下每轮加一个点，每个点用以下三类调用中的其中一种生成

第三类调用较为特殊，可以通过生成两个条件，即两条线唯一确定一个点，也可以只生成一个条件，表明点在这条线上。

1
2
3
calls1 = ["circle"]               # 3 点 → 点
calls2 = ["midpoint", "mirror"]   # 2 点 → 点
calls3 = ["on_line","on_tline","on_bline","on_circle","on_pline"]  # 2 点 → 线

可视化

draw.py 利用 DDAR 中提供的 graph 等模块用于可视化，便于debug。由于上面的随机生成图不是一道完整的题目，没有证明目标 goal ，所以自然不能 write_solution 和结合 premises 和 goal 检验题目的正确性，graph.py 内 build_problem对应的部分要注释掉。

加入发现辅助点模块

随机生成的图是依次加点实现的，在加点过程中，如果产生了新的结论，且新的结论中包含的点不含这个新加的点，说明新点是辅助点。

ddar.get_proof_steps 等地方提供的方法只能由 goal 出发生成依赖关系，但由前文所述，随机生成的内容不包含 goal，自己手动造结论很可能出现冲突导致异常，造出正确且不是条件中的结论很难，急需一个遍历所有结论的方法。

如果对 trace_back.py geometry.py等代码有足够深的理解可能可以直接调用其数据结构，我能想到的替代方案是在 graph.py 中 add_algebra 中加一句 self.all_conclusions.append([name] + [a.name for a in args])，可以收集所有可达结论（后面提到这里的结论是假的，不全的）。

然后便遇到了同构问题，在规定其格式后解决，但依然会有“假”辅助点。因为DDAR虽然是一直运行到结论形成闭包，但内部并不是将所有结论存起来，而是将父类Node 分为 Point,Line,Angle 等子类，所谓的闭包是说这些子类之间无法产生新的结论。只能通过 check 得到单对 Node 之间的关系。不过这个问题只要调用 write_solution 进行进一步检验即可，在输出证明过程的时候会输出其中的辅助点，不为空即可行。

之后又碰到一个新问题，即便 DDAR 引擎判为辅助点也不代表这个点非加不可，只能是这个证明中必须要这个点，删掉以后就不成立；实际的辅助点需要对于任意证明都需要加这样一个新的点。不过这样训出来的模型可以添加 DDAR 认为是辅助点的点。

TODO：用枚举方法生成结论，生成更高质量的数据

生成数据

训练模型

OpenNMT

Encoutered problems

  • 有AB = BC, AB = AD，但无AC = BD。这里的发现让我多一层检查：将最新加的点删除如果依然能证明说明这个点不算辅助点。

image-20250707133220846

image-20250707134712016

  • 垂心的结论去掉以后，光由DDAR推导无法推到该结论，说明结论应当通过枚举获得。

  • 这里的∠(EB-CD) = ∠(EC-AB)是对的，开始搞错了

image-20250707141750313

  • 能训出让DDAR认为是辅助点的辅助点添加建议

image-20250708135619534

]]> <h1>Code</h1> <p><a href="https://github.com/google-deepmind/alphageometry">项目链接</a></p> <p>fixed：<a href="http://numericals.py">numericals. 大模型学习 https://xmy1107.github.io/post/%E5%A4%A7%E6%A8%A1%E5%9E%8B%E5%AD%A6%E4%B9%A0.html 2025-07-01T22:01:02.000Z 2025-07-03T02:17:06.206Z 知识点：]]> <h1>知识点：</h1> <ul> <li> <p>RNN：用于处理序列数据的神经网络，比FNN多“记忆”能力</p> <p><a href="https://www.runoob.com/nlp/recurrent-neural-network.html">https://w 图形学知识点记录 https://xmy1107.github.io/post/%E5%9B%BE%E5%BD%A2%E5%AD%A6%E7%9F%A5%E8%AF%86%E7%82%B9%E8%AE%B0%E5%BD%95.html 2025-05-29T16:46:22.000Z 2025-05-29T16:51:13.307Z 头歌图形学平台链接

  • 曲线/曲面绘制

    • de Casteljau算法：重复线性插值

    • 调和函数：最终结果（二次项系数）

    • rationalBezier：bernstein基函数基础上乘上权重

    • Bezier曲面：本质将Bezier曲线扩展到二维

  • 三角形填充

    • 重心坐标法：枚举bounding box每个点，根据重心坐标判断是否在三角形内
    • 同侧判断法：枚举bounding box每个点，判断是否在三条边的“右侧”
    • 扫描线法：从下往上扫描每条线，每次找这条线上三角形的左右边界，分成两个小三角形分类讨论，每一块都按比例算一下即可算出坐标

  • 多边形填充

    • 扫描线填充算法（活动边表AET法）：把每条边miny顶点放进NET(Network Table)中，只记录x,dx,ymax（每个顶点有左上和右上两组）。y在miny到maxy遍历的时候，若比某个NET大了就从NET转移到AET(Active Edge Table)，大于顶点的ymax了就删除，这样就能得到这条扫描线和多边形的所有交点。对x排序后按两个一组着色即可。
    • 边缘填充法：先求出多边形的每条边与扫描线的交点，然后将交点右侧的所有像素颜色全部取为补色。实际写起来很简单，用任何方式把整个多边形的每个点遍历一遍即可。
    • 区域四连通种子填充算法：dfs
    • 区域扫描线种子填充算法：初始一个种子，然后x方向上不断往上往下扩展新种子，每个种子都可以向左向右一直着色到碰到边界left,right为止。新种子的确定是[left+1,right-1]若碰到边界点就多拆一个种子。下图不需要担心凹下的部分被着色。因为从下往上扩展的过程会先碰到顶点，已经被拆成两个小种子继续着色左上角和右上角了，不用担心变成三块，把中间也着色。
    • 预览大图
]]> <p><a href="https://www.educoder.net/classrooms/rv89ytno/shixun_homework">头歌图形学平台链接</a></p> <ul> <li>曲线/曲面绘制 <ul> <li> <p>de Casteljau算法：重复线 Azure上创建和使用虚拟机 https://xmy1107.github.io/post/Azure%E4%B8%8A%E5%88%9B%E5%BB%BA%E5%92%8C%E4%BD%BF%E7%94%A8%E8%99%9A%E6%8B%9F%E6%9C%BA.html 2025-03-02T06:17:37.000Z 2026-03-15T15:58:20.458Z 不要忽略下面这行

服务器一直要扣费，又重新配置了一下，用户xmy，ip：52.230.67.203，遇到${USER} 和 ${IP} 字样请自行替换。

Step 1：预备步骤

参照链接，使用Azure学生订阅创建免费的Linux服务器。其中学生认证用github登录的话能方便很多。创建服务器后，用ssh连接即可进入虚拟机

此处注意 azure 默认用户是 azureuser，我猜了半天

第一次登录指令是ssh -i AzureServer_key.pem ${USER}@${IP}，通过私钥登录

之后可以本地cat ~/.ssh/id_ed25519.pub获取公钥后，vim .ssh/authorized_keys加到服务器中，即可直接ssh ${USER}@${IP}登录（现在不行了，得ssh -i /home/xmy/.ssh/id_ed25519 xmy@${IP}，呜呜呜，但确实初始登录是服务器生成密钥，密钥由云平台控制，安全性较低；后续登录时客户端生成密钥但需要手动配置公钥到服务器）

不过可以配置~/.ssh/config，进行如下配置后即可直接ssh myserver登录：

1
2
3
4
Host myserver
  HostName ${IP}
  User xmy
  IdentityFile ~/.ssh/id_ed25519

阿里云下注册一个域名xmy.zone：

Step 2：配置frps

过程可以参考frp参考文档

bash中的操作也不需要额外讲解了，说几个注意点：

  1. frps 和 frpc 不要搞错

  2. 老版本的配置文件是 frps.ini ，新版是 frps.toml ，并且新版采取驼峰命名法，而不是蛇形命名法

  3. 最好重命名一下下载下来的文件夹为frp，之后总要用到，太长不方便

  4. 配置 /etc/systemd/system/frps.service 时软链接到 /home/${USER}/frp/frps.service 会方便很多，并且软链接最好都用绝对路径

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~/Azure$ ssh -i AzureServer_key.pem ${USER}@${IP}
Welcome to Ubuntu 22.04.5 LTS (GNU/Linux 6.8.0-1021-azure x86_64)
（省略欢迎页面）
${USER}@AzureServer:~$ wget https://github.com/fatedier/frp/releases/download/v0.61.1/frp_0.61.1_linux_amd64.tar.gz
--2025-03-02 07:24:38--  https://github.com/fatedier/frp/releases/download/v0.37.0/frp_0.37.0_linux_amd64.tar.gz
（省略下载过程）
${USER}@AzureServer:~$ tar -xvf frp_0.61.1_linux_amd64.tar.gz 
frp_0.61.1_linux_amd64/
frp_0.61.1_linux_amd64/frpc
frp_0.61.1_linux_amd64/frps
frp_0.61.1_linux_amd64/LICENSE
frp_0.61.1_linux_amd64/frpc.toml
frp_0.61.1_linux_amd64/frps.toml
${USER}@AzureServer:~$ cd frp_0.61.1_linux_amd64/
${USER}@AzureServer:~/frp_0.61.1_linux_amd64$ vim frps.toml
${USER}@AzureServer:~/frp_0.61.1_linux_amd64$ vim frps.service
${USER}@AzureServer:~/frp_0.61.1_linux_amd64$ cd ..
${USER}@AzureServer:~$ mv frp_0.61.1_linux_amd64 frp
${USER}@AzureServer:~$ cd frp
${USER}@AzureServer:~/frp$ pwd
/home/${USER}/frp
${USER}@AzureServer:~/frp$ sudo ln -s /home/${USER}/frp/frps.service /etc/systemd/system/frps.service
${USER}@AzureServer:~/frp$ sudo systemctl daemon-reload
${USER}@AzureServer:~/frp$ sudo systemctl enable frps
Created symlink /etc/systemd/system/multi-user.target.wants/frps.service → /home/${USER}/frp/frps.service.
${USER}@AzureServer:~/frp$ sudo systemctl start frps
${USER}@AzureServer:~/frp$ sudo systemctl status frps
● frps.service - frps (Fast Reverse Proxy Server)
（省略一万字，总之配置成功）

其中frps.toml配置如下：

1
bindPort = 7000

frps.service配置如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
[Unit]
Description=frps (Fast Reverse Proxy Server)
After=network.target

[Service]
Type=simple
User=root
ExecStart=/home/${USER}/frp/frps -c /home/${USER}/frp/frps.toml
Restart=on-failure
LimitNOFILE=4096

[Install]
WantedBy=multi-user.target

Step 3：配置frpc

流程与配置 frps 基本相同，这里记录如下几点：

需要在 Azure 的网络设置中添加入站端口规则，否则会出现：

1
2
3
4
5
6
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~/frp_0.61.1_linux_amd64$ ./frpc -c frpc.toml
2025-03-02 15:45:25.171 [I] [sub/root.go:142] start frpc service for config file [frpc.toml]
2025-03-02 15:45:25.171 [I] [client/service.go:295] try to connect to server...
2025-03-02 15:45:32.689 [W] [client/service.go:298] connect to server error: EOF
2025-03-02 15:45:32.689 [I] [sub/root.go:160] frpc service for config file [frpc.toml] stopped
login to the server failed: EOF. With loginFailExit enabled, no additional retries will be attempted

frpc.toml配置如下：

1
2
3
4
5
6
7
8
9
serverAddr = "xmy.zone"
serverPort = 7000

[[proxies]]
name = "test-tcp"
type = "tcp"
localIP = "127.0.0.1"
localPort = 22
remotePort = 6000

frpc.service配置如下（权限要 chown 给root，并且 chmod 调整合适的权限，否则 enable 了依旧开机没反应，需要手动 restart）：

1
2
3
4
5
6
7
8
9
10
11
12
13
[Unit]
Description=frps (Fast Reverse Proxy Server)
After=network.target

[Service]
Type=simple
User=root
ExecStart=/home/xmy/frp/frpc -c /home/xmy/frp/frpc.toml
Restart=on-failure
LimitNOFILE=4096

[Install]
WantedBy=multi-user.target

最后，输入以下指令，即可登录自己的电脑： ssh -o Port=6000 xmy@${IP}

由于 ssh 连自己后命令行与本地的命令行完全相同，一般可以靠延迟判断是自己还是分身。

在阿里云那边认证通过，且配置过域名后，可以直接 ping 或者 dig 检验

1
2
3
4
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~$ ping xmy.zone
ping: xmy.zone: 未知的名称或服务
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~$ ping xmy.zone
PING xmy.zone (${IP}) 56(84) bytes of data.
1
2
3
4
5
6
7
8
ssh xmy@xmy.zone   # 非法
# 以下两者等价
ssh xmy@${IP} -p 6000
ssh xmy@xmy.zone -p 6000

# 以下两者等价
ssh ${USER}@xmy.zone
ssh ${USER}@xmy.zone -p 22

Step 4：Nginx反向代理

sudo nano /etc/nginx/sites-available/xmy.zone 后，在文件中输入：

1
2
3
4
5
6
7
8
9
10
11
server {
    listen 80;
    server_name xmy.zone;  # 配置您的域名

    root /home/xmy/blog/public;  # Hexo 生成的静态文件所在的目录
    index index.html index.htm;

    location / {
        try_files $uri $uri/ =404;
    }
}

sudo nano /etc/nginx/nginx.conf 中第一行的user要改成root，这个非常重要且没有人说

1
2
3
sudo ln -s /etc/nginx/sites-available/xmy.zone /etc/nginx/sites-enabled/
sudo nginx -t  # 检查配置是否正确
sudo systemctl reload nginx  # 重新加载以应用配置

修改frp配置，使其可以转发http请求

frps.toml：

1
2
3
4
5
6
7
8
bindPort = 7000
vhostHTTPPort = 80  # 接收 HTTP 请求并将其转发到客户端
vhostHTTPSPort = 443

[webServer]   # dashboard最新版需要这么写
port = 7500
user = "${USER}"
password = "密码"

frpc.toml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
serverAddr = "xmy.zone"
serverPort = 7000

[[proxies]]
name = "test-tcp"
type = "tcp"
localIP = "127.0.0.1"
localPort = 22
remotePort = 6000

[[proxies]]
name = "http-proxy"
type = "http"
localIP = "127.0.0.1"
localPort = 80
customDomains = ["xmy.zone"]

到这里就可以用 xmy.zone 打开博客了，如果需要检查中间哪部出了错可以采取下述步骤：

如果没有跳出 Nginx 相关字样，或者 404、403，说明 frp 就出现了错误，可以通过 sudo systemctl status 检查，还不够就用 dashboard。

重新配置完 frps 可以在 VSCode作端口映射后用本地 localhost 打开 dashboard

这里碰到问题的话记得入站规则加上 7500 端口

跳出来的话就说明 Nginx 配置出现问题，这个就比较便于检查了。

总结

ssh

ssh 请求连接 xmy.zone 时，DNS解析到公网ip ，它是我的 Azure 虚拟机，由于上面有 frps 服务，并且配置了 6000 端口监听，监听到连接请求后，会转发到 7000 端口与客户机的 22 端口通信（ 22 端口是 ssh ），所以 ssh -o Port=6000 xmy@${IP} 就等于 ssh 客户机

客户机与服务器通信同理，区别是 tcp client 不需要指定发送端口，所以任意端口出发，都能被服务器 7000 端口监听

HTTP请求

访问 xmy.zone 时，服务器监听 80 端口并转发到客户端，客户端有 Nginx 监听 80 端口，反向代理到本地 Hexo 生成静态文件所在目录，可以免去之前 hexo s 或 hexo d 的步骤

dashboard

配置了 7500 端口监听，通过 VSCode 端口映射到本地 7500 端口，即可直接打开

自己对自己的Q&A

Q：为什么 ssh 服务，服务器的监听端口 6000 是在 frpc 配置的，而 http 请求的监听端口 80 就是在 frps 上配置？

A：ssh 是 TCP 协议，无法共用一个端口。假设还要连MC，需要把服务器 65535 端口穿透到本地，那本地开放一个9000端口，肯定形如
localPort = 9000 remotePort = 65535 。HTTP 之所以可以放在 frps 上是因为 HTTP 协议可以共用端口。

]]> <p><em>不要忽略下面这行</em></p> <p>服务器一直要扣费，又重新配置了一下，用户xmy，ip：52.230.67.203，遇到<code>${USER}</code> 和 <code>${IP}</code> 字样请自行替换。</p> <h1>Step 1：预备步 微表面重建 https://xmy1107.github.io/post/%E5%BE%AE%E8%A1%A8%E9%9D%A2%E9%87%8D%E5%BB%BA.html 2024-12-19T07:01:21.000Z 2025-05-29T16:53:04.107Z 摸索

这里是初始学长定的流程，但后来发现和实际情况相差很大，所有标定步骤都不用做了……权当记录一下。其实可以直接跳下一节。

整体流程

整个流程可以分为以下几个部分：

  • 在待测物体和校准使用的镜子上粘贴 ArUco 标记。

  • 图像采集（这部分通过另一个独立程序完成）。

  • 内参标定（Intrinsic Calibration）。

  • 几何标定（Geometric Calibration）。

  • 辐射标定（Radiometric Calibration）。

  • 表面法线计算（Surface Normal Calculation）。

漫反射表面法线计算

计算表面法线的代码异常简单，只需如下步骤：

1
2
3
self.diff_x = frames_x_n[..., 1] - frames_x_n[..., 0]
self.diff_y = frames_y_n[..., 1] - frames_y_n[..., 0]
z = np.sqrt(1 - np.square(self.diff_x) - np.square(self.diff_y))

其中frames_x_n[..., 0]，frames_x_n[..., 1]是屏幕顺着方向分别从亮到暗和从暗到亮打光到物体表面后拍摄的两张图。

看了SKINSCAN论文，研究了几天终于研究出来了（论文里就两行公式，包括条件，全得自己脑补）。

提前说一下有两个条件要满足：

  1. 屏幕正对物体
  2. 假设屏幕与物体相比足够大

回顾双向反射分布函数（BRDF），

在这里，假设物体有朗伯反射特性，表面在所有方向上的辐射率都是均匀的，令

则，

其中：
：屏幕上生成的光图案，作为入射光的分布。
：定义表面材料的反射特性。
：衡量材料对入射光的漫反射能力。
：描述入射光的方向。
：定义表面的法向量，影响光与表面交互的方向性。

屏幕是个面光源，假设物体表面坐标 确定，其法向量为 ，对屏幕表面的每个点 积分，根据BRDF计算该点在两个场景中收到的辐射：

由于屏幕正对物体，所以 和 点积一定大于 ，不用 ，忽略系数可以得到：

公式有点丑，调整一下：

此时发现，如果，则

在屏幕足够大的情况下，可视为这种情况，故法向量在 方向上的值与 成正比。

碰到的困难（随手记）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
Q：8_11_checker.npz得想办法自己搞一个出来
A：搞出来了以后发现并不需要，它mirror数据中确实是8*24的

Q：imgDistortFilelist = readFileList(imgDistortFolder)竟然能出错
A：断点定错了，是读该目录下文件出现的问题

Q：h, w = imgDistort.shape[:2]，明明看图像明显可以看出宽>高，但输出shape是2448，2048，高>宽
A：shape没问题，(6692, 7996, 3)，是我搞错了，shape属性和图像显示工具的宽高定义方式不同
shape是(h,w,3)；图像显示工具是w*h；坐标轴是x为宽，y为高

Q：高阶径向很大，导致结果很不理想
[[-1.79807615e+00 -1.51664935e+00  2.15608648e-03  9.33400363e-04
   2.45988598e+00 -1.72972173e+00 -1.76633092e+00  2.70524422e+00
   0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
   0.00000000e+00  0.00000000e+00]]
A：关闭原代码中的cv2.CALIB_RATIONAL_MODEL选项，重新运行，畸变系数如下
[[-0.06838548  0.1297082   0.00215606  0.00093164 -0.10610527]]
但结果还是不理想\
继续Q：fxfy对焦问题？cxcy图像中心？标定图像？
A：我在计算相机内参时的图像分辨率为2448*2048像素，而需要反畸变的图像分辨率为7996*6992，我觉得这是反畸变失败的核心原因，焦距和光学中心在新的图上都失效了
解决方案是缩放，终于得到正确结果了呜呜呜

Q：geometric calibration检测不到checker board，代码都是原先的，似乎数据上有问题。到底是因为镜子尺寸不同，
还是arucoBoardHeight= 0.2884, arucoBoardWidth= 0.5932有问题？
half_length = 0.2000 - 0.005这部分肯定有问题，我肉眼几乎观察不到边框
A：罪魁祸首img = (img/65535*255).astype(np.uint8)，搞得图全黑了

Q：ARUCO_BOARD_HEIGHT = half_height * 2
    ARUCO_BOARD_WIDTH = half_length * 2
这两句，前面传入的half_height、half_length是镜子的一半高度和宽度，在这里变成了aruco board的高度和宽度，
A：好吧一样，但是checker board的数据消失了

Q：整张图绿油油的
A：frame_markers = aruco.drawDetectedMarkers(img.copy(), corners, ids)输入BGR，返回BGR，但matplotlib用的是RGB

Q：镜子放反了。相机内参是不能变动的，图像翻转180度可以视为世界翻转了180度，理论还是能继续实验，但还是不行
A：相机内参也变了似乎

Q：id为4的aruco标记左上角坐标为1885., 1270.，理论是正确的，但在图中发生偏移
A1：reProjAruco中没用到检测的aruco
A2：前面检测的aruco已经把位姿 (rvec, tvec)计算出了，通过位姿重投影，然后函数前面的默认值没有修改，导致投影错误

Q：标记只能检测出4个，重投影计算正确，但后续工作无法继续进行
A：换了张图ok了，可能光线强了点，这个要看运气

Q：重影极其严重
A1：畸变出了问题，flags=cv2.CALIB_FIX_K3忽略高阶径向畸变可以基本解决
A2：基本可以视为没有问题了，因为普通镜头通常不会需要高阶修正。下次可以多拍几张图片，并且把镜子尽可能放正来减小切向畸变的影响。然后修改参数重新试一试

Q：aruco的重投影啥的都没问题，但是z轴反了，才发现
A：说是可以不用管

Q：PMD的结果很奇怪
A：得到相位图需要分别投射同一频率的多幅光栅图像至物体表面用以获得物体表面信息对应相位，一组图像之间有固定的相位差，这里没有这么做，也没有这个需求

Q：calibration.npz和PhaseMapHV.npz的导出
A：ok

Q：还是有重影
A：通过比较反畸变后图片，认为径向畸变的量计算有误，标定板不光要各个角度，还要尽可能在屏幕边缘

Q：could not broadcast input array from shape (4194304,) into shape (5013504,)
A：原本代码的height和width有一些错误，参看前文宽和高

年后工作

过年一个多月放假，年前三四个月的所有工作似乎都只是在摸索。年后开了个会，大致定了做的内容，所以下面才是正题（还是好没底啊，真的能行吗）。

其实我对法向图的生成就有些许怀疑，但论文和学长在人皮肤表面的实验放在这，也挺有说服力的，没有实质性证据的话也不要去猜疑了，好好完成任务。

这里能感受出不是颜色影响，而是高度影响，相信！

NEW整体流程

  • 利用拍的六张图重建表面法向图
  • 拼接局部图片为完整的图（相机分辨率有上限，实验表明需要离画近到一定程度才有效）
  • 用Frankot-Chellappa算法重建Mesh
  • 通过前面的结果（法向图和Mesh），自动分析笔触和推断画的破损情况（后认为手标+算法加强稍微有可行性一点）
  • 开发系统

3.7小记

3.5的会议给我安排了几个任务：

  1. 之前有一个图重复拍5次取平均进行去噪，确实少了很多噪点，但同时抹平了很多信息，这次考虑方差大到一定程度取平均或者其他算法保留原本信息前提下尽可能去噪；
  2. 下图分别是x和y方向的法向量，但似乎一个凹一个凸，判断xy哪个反了，修改代码；

  1. 直接生成z方向的法向图；

  2. 拼接原图和法向图。

3.8小记

上面几个任务都有问题

  1. 虽然判断的方法很多，但处理的手段很单一，最多取平均、取中位数、随机……尝试后发现效果不佳。

  2. x和y方向的法向量并没有什么所谓的凹和凸，它只是微分后的结果，并没有实际意义，实际意义得生成深度图和mesh以后才能显现，可又碰到两个问题，一个是噪点太多生成不出细节，另一个是单位不对，z的计算前提是单位向量，但并不知道x,y变成单位向量需要乘什么系数。

  3. 同2

  4. SuperGlue拼不出，也许是重合面积不够大；并且之前还发现过图片多显存会炸。再试试不用默认选项有什么效果。

3.11小记

TODO LIST：

  1. 法向图左侧偏红，右侧偏蓝，这可能是导致深度图有弯折的重要原因，推测是光源非论文中的球体导致的，尝试通过法向图中加入高通滤波解决，再不行在frankot-chellappa中加。

  2. 大图片无法生成法向图的问题暂时通过降低分辨率解决，并用blender打开便于观察。用pil的bilinear interpolation

  3. xy方向matplotlib热力图，推测x和y方向的视错觉问题成因

  4. 稳定图像拼接结果

  5. 说明文档

3.15小记

主要记录3.14会议内容和3.15工作内容

  1. 高通滤波试过不可以，试试频谱图分析后带通滤波

  2. 原图已经都可以匹配了，可试着通过原图的匹配点匹配法向量图，或改变blending strategy

  3. 深度图降采样后可以完整生成了，并且只要一分钟，弯折程度很厉害，就看1解决情况

  4. xy方向matplotlib热力图，推测x和y方向的视错觉问题成因

图片不需要管cv2是BGR读进来的，因为一律转成了灰度，之后都以RGB在操作，输出时要注意转化成BGR

3.23小记

记录3.19会议内容和后几天的工作

  1. stitching（分步已用开源库解决，但效果略差于cv的stitcher，需要更大重合面积）

  2. 整体颜色(127,127,255)

  3. 简化mesh

  4. matlab分析频谱（个人觉得意义不大，先放最后）

3.29小记

记录3.26会议内容和后几天的工作

  1. opencv图像大小限制会导致生成的生成的全景图偏小（imwrite为jpg大小损失了，ok）

  2. 继续简化mesh（还没简化已经从243MB->178MB，合并了重复点，导出速度从半分钟到了一秒，不懂为啥这么快，法向量信息消失但反而更易于观察了）

  3. 整理结果，包括错误结果

  4. 完成所有任务后可以封装一下api

  5. 代码注释、规范和README

3.31小记

记录3.30会议和实验内容和后几天工作

  1. 深度图太凹（）

  2. 拼接完特征消失（调整参数，但要牺牲拼接的流畅度）

  3. case by case（取局部30*30个点的中位数计算参数）

  4. 纹理，RGB2BGR（好解决）

4.3小记

记录4.2会议内容和后几天工作

  1. 图片pattern顺序（这次由于屏幕上方对应画下方，所以y方向反了，ok）

  2. 法向量降采样问题（Stitching可以不降采样，可以生成深度图前降采样，ok，荷花太长了不能拼接）

  3. 深度图简化（可以没有纹理）

  4. 深度图太凹（变好了，不知道算不算解决，ok一半）

  5. 颜色深浅的影响（不出意外是有的）

  6. 法向图加强手段（暂时没时间做，而且感觉没有意义，宇宸那边本来就要做）

  7. 降采样对原始数据影响大小（4影响不大，6影响就大了，暂定4）

网格简化：从开始obj的290M到ply90M，到简化后5M，我没想到效果这么好，明显比通过降采样到83M的obj清楚

5.20最新状态

已在 CAD/Graphics 投出，期待审稿通过。

]]> <h1>摸索</h1> <p>这里是初始学长定的流程，但后来发现和实际情况相差很大，所有标定步骤都不用做了……权当记录一下。其实可以直接跳下一节。</p> <h2 id="整体流程">整体流程</h2> <p>整个流程可以分为以下几个部分：</p> <ul> <li> <p>在待 min25筛 https://xmy1107.github.io/post/min25.html 2024-12-19T05:33:54.000Z 2025-11-16T12:44:41.000Z 前面部分引用自OI wiki

定义

从此种筛法的思想方法来说，其又被称为「Extended Eratosthenes Sieve」。

由于其由 Min_25 发明并最早开始使用，故称「Min_25 筛」。

性质

其可以在 或 的时间复杂度下解决一类 积性函数 的前缀和问题。

要求： 是一个关于 可以快速求值的完全积性函数之和（例如多项式）； 可以快速求值。

记号

  • 如无特别说明，本节中所有记为 的变量的取值集合均为全体质数。
  • ，即 为质数时其值为 ，否则为 。
  • ：全体质数中第 小的质数（如：）。特别地，令 。
  • ，即 的最小质因数。特别地， 时，其值为 。

解释

观察 的定义，可以发现答案即为 。

考虑如何求出 。通过枚举每个 的最小质因子及其次数可以得到递推式：

最后一步推导基于这样一个事实：对于满足 的 ，有 ，故 。
其边界值即为 。

假设现在已经求出了所有的 ，那么有两种方式可以求出所有的 ：

  1. 直接按照递推式计算。
  2. 从大到小枚举 转移，仅当 时转移增加值不为零，故按照递推式后缀和优化即可。

现在考虑如何计算 。
观察求 的过程，容易发现 有且仅有 这 处的点值是有用的。
一般情况下， 是一个关于 的低次多项式，可以表示为 。
那么对于每个 ，其对 的贡献即为 。
分开考虑每个 的贡献，问题就转变为了：给定 ，对所有的 ，求 。

Notice： 是完全积性函数！

于是设 ，即埃筛第 轮筛完后剩下的数的 值之和。
对于一个合数 ，必定有 。设 为不大于 的最大质数，则 ，即在埃筛进行 轮之后剩下的均为质数。
考虑 的边界值，显然为 。（还记得吗？特别约定了 ）
对于转移，考虑埃筛的过程，分开讨论每部分的贡献，有：

  1. 对于 的部分， 值不变，即 。
  2. 对于 的部分，被筛掉的数必有质因子 ，即 。
  3. 对于第二部分，由于 ，满足 的 会被额外减去。这部分应当加回来，即 。

则有：

复杂度分析

对于 的计算，其第一种方法的时间复杂度被证明为 （见 zzt 集训队论文 2.3）；
对于第二种方法，其本质即为洲阁筛的第二部分，在洲阁论文中也有提及（6.5.4），其时间复杂度被证明为 。

对于 的计算，事实上，其实现与洲阁筛第一部分是相同的。
考虑对于每个 ，只有在枚举满足 的 转移时会对时间复杂度产生贡献，则时间复杂度可估计为：

对于空间复杂度，可以发现不论是 还是 ，其均只在 处取有效点值，共 个，仅记录有效值即可将空间复杂度优化至 。

首先，通过一次数论分块可以得到所有的有效值，用一个大小为 的数组 记录。对于有效值 ，记 为 在 中的下标，易得：对于所有有效值 ，。

然后分开考虑小于等于 的有效值和大于 的有效值：对于小于等于 的有效值 ，用一个数组 记录其 ，即 ；对于大于 的有效值 ，用一个数组 记录 ，由于 过大所以借助 记录 ，即 。

这样，就可以使用两个大小为 的数组记录所有有效值的 并 查询。在计算 或 时，使用有效值的 代替有效值作为下标，即可将空间复杂度优化至 。

过程

对于 的计算，我们实现时一般选择实现难度较低的第一种方法，其在数据规模较小时往往比第二种方法的表现要好；

对于 的计算，直接按递推式实现即可。

对于 ，可以用线性筛预处理出 来替代 递推式中的 。
相应地， 递推式中的 也可以用此方法预处理。

用 Extended Eratosthenes Sieve 求 积性函数 的前缀和时，应当明确以下几点：

  • 如何快速（一般是线性时间复杂度）筛出前 个 值；
  • 的多项式表示；
  • 如何快速求出 。

明确上述几点之后按顺序实现以下几部分即可：

  1. 筛出 内的质数与前 个 值；
  2. 对 多项式表示中的每一项筛出对应的 ，合并得到 的所有 个有用点值；
  3. 按照 的递推式实现递归，求出 。

例题

求莫比乌斯函数的前缀和

求 。

易知 。则 。
直接筛即可得到 的所有 个所需点值。

求欧拉函数的前缀和

求 。

首先易知 。
对于 的一次项 ，有 ；
对于 的常数项 ，有 。
筛两次加起来即可得到 的所有 个所需点值。

「LOJ 6053」简单的函数

给定 ：

易知 。则按照筛 的方法筛，对 讨论一下即可。
此处给出一种 C++ 实现（也是我的min25筛模板）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
/* 「LOJ #6053」简单的函数 */
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxs = 200000, mod = 1000000007, inv2 = (mod+1)>>1;  // 2sqrt(n)
int pri[maxs / 7], lpf[maxs + 1], spri[maxs + 1], pcnt, lim, G[maxs + 1][2], Fprime[maxs + 1], cnt;
ll lis[maxs + 1], global_n;

#define sqr(x) (1ll*(x)*(x))
#define idx(v) (v <= lim ? le[v] : ge[global_n / v])  // n/i的值为v时，i在数论分块中是第几块 
int le[maxs + 1],  // x <= \sqrt{n}
ge[maxs + 1];  // x > \sqrt{n}

int sum(int x,int y){x+=y;if(x>=mod)x-=mod;return x;}
int sub(int x,int y){x-=y;if(x<0)x+=mod;return x;}
void inc(int &x,int y){x+=y;if(x>=mod)x-=mod;}
void dec(int &x,int y){x-=y;if(x<0)x+=mod;}
void sieve(int n) {
for (int i = 2; i <= n; ++i) {
if (lpf[i] == 0) {  // 记录质数
lpf[i] = ++pcnt; // i的最小质因数编号 
pri[lpf[i]] = i; // 第i个质数 
spri[pcnt] = sum(spri[pcnt - 1], i);  // 前缀和
}
for (int j = 1, v; j <= lpf[i] && (v = i * pri[j]) <= n; ++j) lpf[v] = j;
}
}

void init(ll n) {
for (ll i = 1, j, v; i <= n; i = n / j + 1) {
j = n / i;
v = j % mod;
lis[++cnt] = j;
idx(j) = cnt;
G[cnt][0] = sub(v, 1ll); // \sum_2^v i^0
G[cnt][1] = 1ll * (v + 2ll) * (v - 1ll) % mod * inv2 % mod; // \sum_2^v i^1
}
}

void calcFprime() {//求Fprime
for (int k = 1; k <= pcnt; ++k) {
int p = pri[k];
ll sqrp = sqr(p);
for (int i = 1; lis[i] >= sqrp; ++i) {
ll v = lis[i] / p;
int id = idx(v);
dec(G[i][0], sub(G[id][0], k - 1));
dec(G[i][1], 1ll* p * sub(G[id][1], spri[k - 1]) % mod); // g(p_k)=p, G_{k-1}(p_{k-1})=sum_pri
}
}
/* F_prime = G_1 - G_0 */
for (int i = 1; i <= cnt; ++i) Fprime[i] = sub(G[i][1], G[i][0]); // F(p)=p-1
}

int f_p(int p, int c) {
/* f(p^{c}) = p xor c */
return p xor c;
}

int F(int k, ll n) {//已知Fprime求F
if (n < pri[k] || n <= 1) return 0;
int id = idx(n);
ll ans = Fprime[id] - (spri[k - 1] - (k - 1)); // Fprime(n)-Fprime(p_{k-1})
if (k == 1) ans += 2;
for (int i = k; i <= pcnt && sqr(pri[i]) <= n; ++i) {
ll pw = pri[i], pw2 = sqr(pw);
for (int c = 1; pw2 <= n; ++c, pw = pw2, pw2 *= pri[i])
ans += (1ll * f_p(pri[i], c) * F(i + 1, n / pw) + f_p(pri[i], c + 1)) % mod;
}
return ans % mod;
}

int main() {
scanf("%lld", &global_n);
lim = sqrt(global_n);  // 上限
sieve(lim + 1000);  // 预处理
init(global_n);
calcFprime();
printf("%lld\n", (F(1, global_n) + 1ll + mod) % mod); // F(1)单独加上 
}

ICPC2024昆明 F. Flowers

转化后题意：给定，求，其中 为 不同质因子个数

方法1（min25+拉插+CRT，麻烦）：

令 ，则 为积性函数。

由于 的值不会超过 ，故枚举 ，依次求出 。

可表示为 ，通过拉格朗日插值求出 后，即可求出答案：

，通过这个式子也可以发现不需要求。

因为拉格朗日插值中会遇到很大的数，所以需要对两个大质数分别取模后CRT合并。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define int long long
const int maxs = 200000,M1=998244353,M2=1e9+7;
int pri[maxs / 7], lpf[maxs + 1], spri[maxs + 1], pcnt;

void sieve(const int &n) {
      for (int i = 2; i <= n; ++i) {
        if (lpf[i] == 0) {  // 记录质数
          lpf[i] = ++pcnt;
          pri[lpf[i]] = i;
          spri[pcnt] = spri[pcnt - 1]+i;  // 前缀和
        }
        for (int j = 1, v; j <= lpf[i] && (v = i * pri[j]) <= n; ++j) lpf[v] = j;
      }
}

long long global_n;
int lim;
int le[maxs + 1],  // x <= \sqrt{n}
    ge[maxs + 1];  // x > \sqrt{n}
#define idx(v) (v <= lim ? le[v] : ge[global_n / v])

int G[maxs + 1][2], Fprime[maxs + 1];
long long lis[maxs + 1];
int cnt;

void init(const long long &n,int x) {
      for (long long i = 1, j, v; i <= n; i = n / j + 1) {
        j = n / i;
        v = j;
        lis[++cnt] = j;
        (j <= lim ? le[j] : ge[global_n / j]) = cnt;
G[cnt][0]=(v-1)*x;//tip1
      }
}

void calcFprime(int x) {
      for (int k = 1; k <= pcnt; ++k) {
        const int p = pri[k];
        const long long sqrp = p*p;
        for (int i = 1; lis[i] >= sqrp; ++i) {
          const long long v = lis[i] / p;
          const int id = idx(v);
            G[i][0]-=G[id][0]-(k-1)*x;//tip2
        }
      }
      for (int i = 1; i <= cnt; ++i) Fprime[i] = G[i][0];//tip3
}

int f_p(const int &p, const int &c,int x) {
        return x;
}

int F(const int &k, const long long &n,int x) {
      if (n < pri[k] || n <= 1) return 0;
      const int id = idx(n);
      long long ans = Fprime[id] - (k-1)*x;//tip4
      for (int i = k; i <= pcnt && pri[i]*pri[i] <= n; ++i) {
        long long pw = pri[i], pw2 =pw*pw;
        for (int c = 1; pw2 <= n; ++c, pw = pw2, pw2 *= pri[i])
          ans +=
          ((long long)f_p(pri[i], c,x) * F(i + 1, n / pw,x) + f_p(pri[i], c + 1,x));
      }
  return ans;
}

int mod;
int inv(int k,int MOD) {
  int res = 1;
  for (int e = MOD - 2; e; e /= 2) {
    if (e & 1) res = res * k % MOD;
    k = k * k % MOD;
  }
  return res;
}
int Pw(int k,int y,int MOD) {
  int res = 1;
  for (int e = y; e; e /= 2) {
    if (e & 1) res = res * k % MOD;
    k = k * k % MOD;
  }
  return res;
}
std::vector<int> lagrange_interpolation(const std::vector<int> &x,
                                        const std::vector<int> &y,int MOD) {
  const int n = x.size();
  std::vector<int> M(n + 1), xx(n), f(n);
  M[0] = 1;
  for (int i = 0; i < n; ++i) {
    for (int j = i; j >= 0; --j) {
      M[j + 1] = (M[j] + M[j + 1]) % MOD;
      M[j] = M[j] * (MOD - x[i]) % MOD;
    }
  }
  for (int i = n - 1; i >= 0; --i) {
    for (int j = 0; j < n; ++j) {
      xx[j] = (xx[j] * x[j] + M[i + 1] * (i + 1)) % MOD;
    }
  }
  for (int i = 0; i < n; ++i) {
    int t = y[i]%MOD * inv(xx[i],MOD) % MOD, k = M[n];
    for (int j = n - 1; j >= 0; --j) {
      f[j] = (f[j] + k * t) % MOD;
      k = (M[j] + k * x[i]) % MOD;
    }
  }
  return f;
}
void exgcd(int a, int b, int& x, int& y) {
      if (b == 0) {
            x = 1, y = 0;
            return;
      }
      exgcd(b, a % b, y, x);
      y -= a / b * x;
}
signed main() {
      scanf("%lld%lld", &global_n,&mod);
      lim = sqrt(global_n);  // 上限
      sieve(lim + 1000);  // 预处理
      vector<int>A,B;
      A.pb(0),B.pb(0);
      A.pb(1),B.pb(global_n);
      for (int x=2;x<=10;x++){
            cnt=0;
            init(global_n,x);
            calcFprime(x);
            B.pb(F(1, global_n,x) + x);
            A.pb(x);
        }
        auto f1 = lagrange_interpolation(A,B,M1);
        auto f2 = lagrange_interpolation(A,B,M2);
        vector<int>f;
        int M=M1*M2;
        for (int i=0;i<f1.size();i++){
int b,y;
            exgcd(M2, M1, b, y);
            int tmp=(__int128)f1[i]*M2*b%M;//处理爆long long 
            exgcd(M1, M2, b, y);
            tmp=((tmp+(__int128)f2[i]*M1*b)%M+M)%M;//模完才是算好的值，才能模mod-1 
            f.pb(tmp);
        }
        int ans=1;
        for (int i=2;i<f.size();i++) ans=(ans*Pw(A[i],f[i],mod))%mod;
        cout<<ans<<endl;
}

方法2（需充分理解min25，巧妙）：

观察转移

发现包含质数的个数已经在转移里一目了然了

对应：

1
ans[w + 1] += Fprime[id] - (k - 1);

对应：

1
2
ans[w + 1]++;
F(i + 1, n / pw, w + 1);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxs = 200000, mod = 1000000007, inv2 = (mod+1)>>1;  // 2sqrt(n)
int pri[maxs / 7], lpf[maxs + 1], spri[maxs + 1], pcnt, lim, G[maxs + 1][2], Fprime[maxs + 1], cnt;
ll lis[maxs + 1], global_n;

ll ans[99];

#define sqr(x) (1ll*(x)*(x))
#define idx(v) (v <= lim ? le[v] : ge[global_n / v])  // n/i的值为v时，i在数论分块中是第几块 
int le[maxs + 1],  // x <= \sqrt{n}
ge[maxs + 1];  // x > \sqrt{n}

int sum(int x,int y){x+=y;if(x>=mod)x-=mod;return x;}
int sub(int x,int y){x-=y;if(x<0)x+=mod;return x;}
void inc(int &x,int y){x+=y;if(x>=mod)x-=mod;}
void dec(int &x,int y){x-=y;if(x<0)x+=mod;}
void sieve(int n) {
for (int i = 2; i <= n; ++i) {
if (lpf[i] == 0) {  // 记录质数
lpf[i] = ++pcnt; // i的最小质因数编号 
pri[lpf[i]] = i; // 第i个质数 
spri[pcnt] = sum(spri[pcnt - 1], i);  // 前缀和
}
for (int j = 1, v; j <= lpf[i] && (v = i * pri[j]) <= n; ++j) lpf[v] = j;
}
}

void init(ll n) {
for (ll i = 1, j, v; i <= n; i = n / j + 1) {
j = n / i;
v = j % mod;
lis[++cnt] = j;
idx(j) = cnt;
G[cnt][0] = sub(v, 1ll); // \sum_2^v i^0
}
}

void calcFprime() {//求Fprime
for (int k = 1; k <= pcnt; ++k) {
int p = pri[k];
ll sqrp = sqr(p);
for (int i = 1; lis[i] >= sqrp; ++i) {
ll v = lis[i] / p;
int id = idx(v);
dec(G[i][0], sub(G[id][0], k - 1));
}
}
for (int i = 1; i <= cnt; ++i) Fprime[i] = G[i][0];
}

void F(int k, ll n, int w) {//已知Fprime求F
if (n < pri[k] || n <= 1) return;
int id = idx(n);
ans[w + 1] += Fprime[id] - (k - 1);
for (int i = k; i <= pcnt && sqr(pri[i]) <= n; ++i) {
ll pw = pri[i], pw2 = sqr(pw);
for (int c = 1; pw2 <= n; ++c, pw = pw2, pw2 *= pri[i]){
ans[w + 1]++;
F(i + 1, n / pw, w + 1);
}
//ans += (1ll * f_p(pri[i], c) * F(i + 1, n / pw) + f_p(pri[i], c + 1)) % mod;
}
}

int M;
int pw(int x, ll y, int M){
int z = 1;
for (; y; y >>= 1, x = 1ll * x * x % M)
if (y & 1) z = 1ll * z * x % M;
return z;
}
int main() {
scanf("%lld%d", &global_n, &M);
lim = sqrt(global_n);  // 上限
sieve(lim + 1000);  // 预处理
init(global_n);
calcFprime();
F(1, global_n, 0);
int pi = 1;
for (int i = 2; i <= 10; i++) pi = 1ll * pi * pw(i, ans[i], M) % M;
cout << pi << '\n';
}

a*b problem（我出的题）

题意： 且 ，求有序数对 数量，答案对1e9+7取模

令表示 且 数对数量，，则答案为

等价于每个质因子在中次数的最小值都是 ，易知各个质因子之间独立，为积性函数，问题在于怎么求

方法1（我的，背包+dfs+组合数+min25）

时，等价于将划分给个数，第 个数必须是 的倍数，且个数里至少有一个为的方案数

用至多不超过的时间 （， 中c的取值小于等于33）预处理，可以得出结果

时，，其中是中1的数量，p只有1次，只能是1的倍数

此时发现为关于的零次多项式，可快速求，故答案可用min25筛快速求得

时间复杂度，此时在情况下都没有问题，更大的时候复杂度瓶颈的 需要优化

考虑枚举某个集合的元素均为0，剩余部分形如 （）

如果已知 在每个c处的方案数，那么可以的时间内推出在每个c处的方案数

发现对于值相同的，性质是一样的，可以直接用这个值有几个来代替，不需要枚举，加上一些剪枝，可以通过的数据

我的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxs = 200000,mod = 1e9+7,maxc=33,maxk=1e5+5;
void inc(int &x, int y) {
x += y;
(mod <= x) && (x -= mod);
}
void dec(int &x, int y) {
x -= y;
(x < 0) && (x += mod);
}
int sub(int x, int y) {
return x < y ? x - y + mod : (x - y);
}
int div2(int x) {
return ((x & 1) ? x + mod : x) >> 1;
}
ll sqrll(int x){return 1ll*x*x;}
int pw(int x,int y){int z=1;for(;y;y>>=1,x=1ll*x*x%mod)if(y&1)z=1ll*z*x%mod;return z;}
int pri[maxs / 7], lpf[maxs + 1], pcnt;

void sieve(const int &n) {
for (int i = 2; i <= n; ++i) {
if (lpf[i] == 0) {// 记录质数
lpf[i] = ++pcnt;
pri[lpf[i]] = i;
}
for (int j = 1, v; j <= lpf[i] && (v = i * pri[j]) <= n; ++j) lpf[v] = j;
}
}

typedef vector<int> V;
map<V,int>mp;
queue<V>q;
const int TMP=400000;//上限239496 
int fun[TMP][maxc+3];//fun[i][j]，id为i的表达式和为j的方案数，如2x+2y+3z=10 
int sum[TMP];//sum为表达式左边有几个数，必须小于K
int Sum[TMP];//Sum为当前所有数的和，必须<=maxc 
int f[maxc+3];//F[c]表示f(p^c)的答案 
ll global_n;
int lim;
int le[maxs + 1],// x <= \sqrt{n}
ge[maxs + 1];// x > \sqrt{n}
#define idx(v) (v <= lim ? le[v] : ge[global_n / v])

V num(maxc+1);
int G[maxs + 1], Fprime[maxs + 1],fac[maxk],ifac[maxk];
ll lis[maxs + 1];
int cnt;
int K,t[102];

void init(ll n) {
for (ll i = 1, j, v; i <= n; i = n / j + 1) {
j = n / i;
v = j % mod;
lis[++cnt] = j;
(j <= lim ? le[j] : ge[global_n / j]) = cnt;
G[cnt]=sub(v, 1ll);
}
}

void calcFprime() {
for (int k = 1; k <= pcnt; ++k) {
int p = pri[k];
ll sqrp = sqrll(p);
for (int i = 1; lis[i] >= sqrp; ++i) {
ll v = lis[i] / p;
int id = idx(v);
dec(G[i], sub(G[id], (k - 1)));
}
}
for (int i = 1; i <= cnt; ++i) Fprime[i]=G[i]*num[1];
}
int tot;
void bfs(){
V u(maxc+1);
mp[u]=++tot;
sum[1]=0;
Sum[1]=0;
fun[1][0]=1;
q.push(u);
while (!q.empty()){
u=q.front(),q.pop();
int id=mp[u];
if (sum[id]+1==K) break;
for (int i=1;i<=maxc && Sum[id]+i<=maxc;i++)
if (u[i]<num[i]){
u[i]++;
if (!mp.count(u)){
mp[u]=++tot;
sum[tot]=sum[id]+1;
Sum[tot]=Sum[id]+i;
for (int j=i;j<=maxc;j++)
fun[tot][j]=(fun[id][j-i]+fun[tot][j-i])%mod;
//for (int j=0;j<=maxc;j++)
//for (int k=1;k*i<=j;k++) inc(fun[tot][j],fun[id][j-k*i]);
int tmp=1;
for (int j=1;j<=maxc;j++) tmp=1ll*tmp*fac[num[j]]%mod*ifac[u[j]]%mod*ifac[num[j]-u[j]]%mod;
for (int j=0;j<=maxc;j++)
inc(f[j],1ll*fun[tot][j]*tmp%mod);
q.push(u);
}
u[i]--;
}
}
}
int f_p(int p, int c) {return f[c];}

int F(const int &k, const long long &n) {
if (n < pri[k] || n <= 1) return 0;
int id = idx(n);
ll ans = Fprime[id] - (k-1)*num[1];

for (int i = k; i <= pcnt && sqrll(pri[i]) <= n; ++i) {
ll pw = pri[i], pw2 = sqrll(pw);
for (int c = 1; pw2 <= n; ++c, pw = pw2, pw2 *= pri[i])
ans +=(1ll*f_p(pri[i], c) * F(i + 1, n / pw) + f_p(pri[i], c + 1)) % mod;
}
return ans % mod;
}
int main() {
scanf("%lld%d", &global_n,&K);
fac[0]=1;
for (int i=1;i<=K;i++) fac[i]=1ll*fac[i-1]*i%mod;
ifac[K]=pw(fac[K],mod-2);
for (int i=K;i;i--) ifac[i-1]=1ll*ifac[i]*i%mod;
for (int i=1;i<=K;i++) scanf("%d",&t[i]),num[t[i]]++;
bfs();
lim = sqrt(global_n);// 上限
sieve(lim + 1000);// 预处理
init(global_n);
calcFprime();
printf("%lld\n", (F(1, global_n) + 1ll + mod) % mod);
}

方法2（更优秀，背包+组合数+min25）

由前文可知，关键在于预处理 。等价于将划分给个数，

第 个数必须是 的倍数，且个数里至少有一个为 的方案数。

事实上，计算所有方案减去 个数都不是 的方案即可。

jiangly代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
#include <bits/stdc++.h>

using u32 = unsigned;
using i64 = long long;
using u64 = unsigned long long;

// TODO: Dynamic ModInt

template<typename T>
constexpr T power(T a, u64 b) {
    T res {1};
    for (; b != 0; b /= 2, a *= a) {
        if (b % 2 == 1) {
            res *= a;
        }
    }
    return res;
}

template<u32 P>
constexpr u32 mulMod(u32 a, u32 b) {
    return 1ULL * a * b % P;
}

template<u64 P>
constexpr u64 mulMod(u64 a, u64 b) {
    u64 res = a * b - u64(1.L * a * b / P - 0.5L) * P;
    res %= P;
    return res;
}

template<typename U, U P>
requires std::unsigned_integral<U>
struct ModIntBase {
public:
    constexpr ModIntBase() : x {0} {}
    
    template<typename T>
    requires std::integral<T>
    constexpr ModIntBase(T x_) : x {norm(x_ % T {P})} {}
    
    constexpr static U norm(U x) {
        if ((x >> (8 * sizeof(U) - 1) & 1) == 1) {
            x += P;
        }
        if (x >= P) {
            x -= P;
        }
        return x;
    }
    
    constexpr U val() const {
        return x;
    }
    
    constexpr ModIntBase operator-() const {
        ModIntBase res;
        res.x = norm(P - x);
        return res;
    }
    
    constexpr ModIntBase inv() const {
        return power(*this, P - 2);
    }
    
    constexpr ModIntBase &operator*=(const ModIntBase &rhs) & {
        x = mulMod<P>(x, rhs.val());
        return *this;
    }
    
    constexpr ModIntBase &operator+=(const ModIntBase &rhs) & {
        x = norm(x + rhs.x);
        return *this;
    }
    
    constexpr ModIntBase &operator-=(const ModIntBase &rhs) & {
        x = norm(x - rhs.x);
        return *this;
    }
    
    constexpr ModIntBase &operator/=(const ModIntBase &rhs) & {
        return *this *= rhs.inv();
    }
    
    friend constexpr ModIntBase operator*(ModIntBase lhs, const ModIntBase &rhs) {
        lhs *= rhs;
        return lhs;
    }
    
    friend constexpr ModIntBase operator+(ModIntBase lhs, const ModIntBase &rhs) {
        lhs += rhs;
        return lhs;
    }
    
    friend constexpr ModIntBase operator-(ModIntBase lhs, const ModIntBase &rhs) {
        lhs -= rhs;
        return lhs;
    }
    
    friend constexpr ModIntBase operator/(ModIntBase lhs, const ModIntBase &rhs) {
        lhs /= rhs;
        return lhs;
    }
    
    friend constexpr std::ostream &operator<<(std::ostream &os, const ModIntBase &a) {
        return os << a.val();
    }
    
    friend constexpr bool operator==(ModIntBase lhs, ModIntBase rhs) {
        return lhs.val() == rhs.val();
    }
    
    friend constexpr bool operator!=(ModIntBase lhs, ModIntBase rhs) {
        return lhs.val() != rhs.val();
    }
    
    friend constexpr bool operator<(ModIntBase lhs, ModIntBase rhs) {
        return lhs.val() < rhs.val();
    }
    
private:
    U x;
};

template<u32 P>
using ModInt = ModIntBase<u32, P>;

template<u64 P>
using ModInt64 = ModIntBase<u64, P>;

constexpr u32 P = 1000000007;
using Z = ModInt<P>;

constexpr int K = 33;

struct Comb {
    int n;
    std::vector<Z> _fac;
    std::vector<Z> _invfac;
    std::vector<Z> _inv;
    
    Comb() : n{0}, _fac{1}, _invfac{1}, _inv{0} {}
    Comb(int n) : Comb() {
        init(n);
    }
    
    void init(int m) {
        m = std::min<i64>(m, P - 1);
        if (m <= n) return;
        _fac.resize(m + 1);
        _invfac.resize(m + 1);
        _inv.resize(m + 1);
        
        for (int i = n + 1; i <= m; i++) {
            _fac[i] = _fac[i - 1] * i;
        }
        _invfac[m] = _fac[m].inv();
        for (int i = m; i > n; i--) {
            _invfac[i - 1] = _invfac[i] * i;
            _inv[i] = _invfac[i] * _fac[i - 1];
        }
        n = m;
    }
    
    Z fac(int m) {
        if (m > n) init(2 * m);
        return _fac[m];
    }
    Z invfac(int m) {
        if (m > n) init(2 * m);
        return _invfac[m];
    }
    Z inv(int m) {
        if (m > n) init(2 * m);
        return _inv[m];
    }
    Z binom(int n, int m) {
        if (n < m || m < 0) return 0;
        return fac(n) * invfac(m) * invfac(n - m);
    }
} comb;
std::vector<int> minp, primes;

void sieve(int n) {
    minp.assign(n + 1, 0);
    primes.clear();
    
    for (int i = 2; i <= n; i++) {
        if (minp[i] == 0) {
            minp[i] = i;
            primes.push_back(i);
        }
        
        for (auto p : primes) {
            if (i * p > n) {
                break;
            }
            minp[i * p] = p;
            if (p == minp[i]) {
                break;
            }
        }
    }
}

void solve() {
    i64 n;
    int k;
    std::cin >> n >> k;
    
    std::vector<int> cnt(K + 1);
    for (int i = 0; i < k; i++) {
        int t;
        std::cin >> t;
        cnt[t]++;
    }
    
    std::vector<Z> dp(K + 1), dp2(K + 1);
    dp[0] = 1;
    dp2[0] = 1;
    for (int i = 1; i <= K; i++) {
        if (cnt[i] == 0) {
            continue;
        }
        for (int s = K; s >= 0; s--) {
            for (int j = 1; s + j * i <= K; j++) {
                Z w = comb.binom(j - 1 + cnt[i], cnt[i] - 1);
                dp[s + j * i] += dp[s] * w;
                w = comb.binom(j - 1, cnt[i] - 1);
                dp2[s + j * i] += dp2[s] * w;
            }
            dp2[s] = 0;
        }
    }
    for (int i = 0; i <= K; i++) {
        dp[i] -= dp2[i];
        // std::cerr << dp[i] << " \n"[i == K];
    }
    
    const int sqrtn = std::sqrt(n);
    std::vector<i64> v;
    for (int i = 1; i <= sqrtn; i++) {
        v.push_back(n / i);
    }
    for (int i = n / sqrtn - 1; i >= 1; i--) {
        v.push_back(i);
    }
    
    const int m = v.size();
    
    auto idx = [&](i64 x) {
        if (x <= sqrtn) {
            return m - x;
        } else {
            return n / x - 1;
        }
    };
    
    std::vector<Z> f(m);
    for (int i = 0; i < m; i++) {
        f[i] = dp[1] * (v[i] - 1);
    }
    
    for (int i = 0; i < primes.size(); i++) {
        if (1LL * primes[i] * primes[i] > n) {
            break;
        }
        for (int j = 0; j < m && v[j] >= 1LL * primes[i] * primes[i]; j++) {
            Z w = f[idx(v[j] / primes[i])] - i * dp[1];
            f[j] -= w;
        }
    }
    for (int i = primes.size() - 1; i >= 0; i--) {
        if (1LL * primes[i] * primes[i] > n) {
            continue;
        }
        for (int j = 0; j < m && v[j] >= 1LL * primes[i] * primes[i]; j++) {
            int t = 1;
            i64 c = v[j] / primes[i];
            while (c >= primes[i]) {
                f[j] += (f[idx(c)] - (i + 1) * dp[1]) * dp[t] + dp[t + 1];
                t++;
                c /= primes[i];
            }
        }
    }
    std::cout << f[0] + 1 << "\n";
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    sieve(1E6);
    
    int T;
    std::cin >> T;
    
    while (T--) {
        solve();
    }
    
    return 0;
}

]]> <p>前面部分引用自<a href="https://oi-wiki.org/math/number-theory/min-25/">OI wiki</a></p> <h1>定义</h1> <p>从此种筛法的思想方法来说，其又被称为「Extended Eratosthenes S 2024年度总结 https://xmy1107.github.io/post/2024%E5%B9%B4%E5%BA%A6%E6%80%BB%E7%BB%93.html 2024-12-09T08:30:10.000Z 2025-08-25T12:11:36.606Z Part 1: ACM

比赛

去各地比赛的地图（标签可拖动）

网页里写的很全了，我文字也写一下吧，中间有很多坎坷，也有很多心路历程，但已经在别处记录过了，就不再赘述

4月，团体程序设计天梯赛二等奖

4月，浙江省大学生程序设计竞赛季军

5.12，河南省大学生程序设计竞赛第六名

5.19，北京市大学生程序设计竞赛银奖

5.27，山东省大学生程序设计竞赛季军

10.20，全国大学生程序设计竞赛哈尔滨站银奖

11.3，国际大学生程序设计竞赛南京站金奖

11.10，全国大学生程序设计竞赛重庆站季军（与PKU随机匹配在榜单上并列第二哦）

11.17，国际大学生程序设计竞赛上海站银奖

12.29，国际大学生程序设计竞赛东亚赛区总决赛银奖

12.30，华为挑战赛202名，铁牌（删边我嫌哈希、map和unordered_map慢，竟然用vector+重构去做，直接一个十倍常数，我简直是天才，这些数据结构慢那这些存在的意义是啥）

至此，我十一年半的算法竞赛生涯（2013.8~2024.12）也算是圆满落幕了。其实未来的日子肯定还是会总是和算法竞赛打交道，但身份变了，心态变了，结束了就是结束了。希望离开算法竞赛后，我依旧可以绽放自己的光芒。

出题&验题

今年在内蒙省赛、杭电多校、校新生赛上各出了一道题，帮雄哥小验了一下广西省赛（就验了一道，但也算验题人是吧）。

内蒙省赛用的是我初一出的一道题，完全没改动，没想到全省只有两个队过（甚至不如我不打acm但极其天才的室友，给了点提示人家就能做出来）。

我着重讲一下杭电多校出的那道题吧，出完这道题的时候我整个人都惊了，这种难度的题我自己都很少很少能做出来，结果竟然被我出出来了。并且幸亏一队在验题的时候验出我题目的错误，不然就是丢大人了，而不是光辉事迹。

给大家看一下战绩：
全国打杭电多校的大学生队伍就四个队做出来，三支是PKU，高中生的话多俩杭二和南外的队伍。我何德何能啊。

题目： 且 ，求有序数对 数量，答案对取模

题解就不放在这了，放了跑题了……

Part 2: 数模

美赛的名额是靠acm金软磨硬泡出来的，训了两次就正式比赛了，拿了M奖非常的意料之外，因为之前只在新生赛做过一次数模，就一个成功参赛奖。跟她俩确实也学到很多数模的经验。但打完以后，我可以说就出师了，要学的东西很少，或者说都是可以现学的。

有了美赛的经历，加上周慧的鼓动，还有我需要保研的特推名额等种种因素，让我决定打国赛。软磨硬泡*2，训练三次就去打国赛。王景煜是个特别强的队友，文本、建模、代码都很顶级，只可惜周慧这货纯傻逼，之前打美赛根本没看清这个人，这直接导致最后只拿到了国二。

通过聊天记录说明一下国二的原因吧

控诉一下周慧的n宗罪：完全听不懂我们的建模瞎出主意、二维的题目直接拿GPT生成三维的模型用、比赛期间游戏打到凌晨五点早上不来做题、问题复述都写不端正、没事干就在旁边打游戏干扰我们、抄个数据抄错了还是王景煜找出来的错误……但凡她有点正贡献，给我省下三四个小时的时间，我所有代码的变步长搜索的手动调参都可以改成自动调参，这也是我本来就要改的东西。她这些行为直接导致所有文本建模都是王景煜一人完成的，代码和结果都是我完成的，而且独立运作，到提交我都没有细看过一遍论文！

图片1 图片2

中国大学生助手查的

Part 3: 一些不算项目的项目或未完成的项目

华为嵌入式软件大赛

初赛交了个输出0的代码，结果直接进复赛了。但我真没想好好打复赛，练习赛就草草写了个还跑不出的代码就去杭研所了，没想到最后跑出来了，还跑了22w分，第六名。一共开放了三个月的时间大概，我就做了一个下午+一晚上+比赛的五个小时就第六了，真是意外。

三维重建

题目就是给定rgb图、深度图和相机内参，重建模型和渲染。
主要靠的龙哥和慧源。但我该做的也都做了，nerf跟着跑了，sam分割图像部分我做了，还做了个手动标点的小工具。但最后就19名，也没成果产出，用的都是开源的东西，似乎也不好放进简历，算是个小锻炼吧。

微表面建模

still working

Part 4: 一些零零散散的小收获

虽然标题是小收获，但合在一起是我这一年最最最大的收获，这些才是我在大学里最想要获得的东西。

健身

3月开始划水到现在，小有成效。体重从120增到了140，能稍微看出点肌肉了（但对于健身人来讲就是，排骨精=>毫无健身痕迹。慢慢练吧，右手有缺陷，强度大会痛，上限就摆在这）。体测的时候引体硬拉15个，立定跳远两米八（其实我觉得是2.85），卧推可以40kg做十几个，我挺满意的，嘻嘻。

唱歌

基本功一直不大扎实，且不大学的会（真的已经很努力了，大一天天去楼梯间，之前还花了小两千买线上课自己学，真学不会），待在合唱队感觉好自卑。所以干脆退了合唱队的训练群，自己瞎练。还真给我练出点东西来了，不过都不是服务于舞台的，主要应用场景还是自嗨或者和朋友嗨。

High D, 不是假音哦

咽音、怒音、撕裂音、C6的头声都解锁了，且都已经在KTV中多次应用。不过离登台的演唱还是差太多，希望未来有一天可以在舞台上用。

3.24看了张杰演唱会上海站，5月123场外看了两场演唱会。张杰的唱过的歌我现在至少会唱一百首！

12.22看了邓紫棋演唱会厦门站，本来她杭州站就抢到票的，因为比赛前两站发挥太差，不想因为演唱会影响之后的上海站比赛，扣了一百多手续费，含泪把票退了……

理论计算机（TCS）

今年四月份转的专业方向，在这之前还是一直有在读论文和寻找tcs的idea的，是占用我时间的最大头。虽然有人“挖苦”我，在这上面白花这么多时间，但我其实并不后悔。哪怕没有产出，其中的体悟都是留在我的记忆中的。比如有一个感悟就是这个世界就是存在很多无法用简洁语言描述的东西。即便是正态分布、傅里叶变换的公式我也会觉得很简洁很优美，但tcs真给我当头一棒，全都是那种恶心到爆，还无法简化的证明。正是在书桌前一整天一整天的绞尽脑汁，才让我真的认命。

思想

其实我认为这一年进步最大的是我的思想，它比较抽象所以我也没放上面说。我遇到了许许多多的人、碰到了许许多多的困难，也有许许多多开心的事情让我回味。和人打交道让我越来越像个人了，能渐渐把“抽象”变成“幽默”（以前真不是人吧，用lsh的话讲就是“是不是刚来地球”），解决一个又一个我以为我解决不了的困难也我有了面对一切困难的勇气。总的来说，一切都在越来越好，这一年我捋清楚了我是怎样一个人，我要干什么，我的未来在哪里，成功回答了去年留给自己的那些疑问。希望新的一年，一切都能变得更好！！！

Entertainment

用英语显得正经一点，符合文章的基调。

今年打了老多游戏。特别是装了双系统之后，4070s+1TB的游戏+潘泽宇300多个游戏的账号，真的如虎添翼如鱼得水。黑猴、传送门、Dying Light、地平线……但玩了一圈发现还是原神、箭箭剑这种好玩儿。以后可以考虑玩奇迹暖暖[doge]

游戏玩厌了，感觉追剧贼有意思。永夜星河和其团综刚看完，月光变奏曲、九重紫啥的都是接下来想看的。感觉玩游戏可累了，追剧一点都不累，还养眼。

一些更琐碎、难分类的东西

比如上面用高德api做的地图、比如搭了博客、比如花了三天时间自己装的电脑

还有双放手很熟练喽，都可以转弯了，录的视频不多，只能放一下这个有点丢人的了
双放手录视频+唱歌，九十度弯摔了

当了班助，排了节目（没上心，所以效果确实差了点，但完成任务就挺好了），加了朗诵社，认识了很多新的朋友，新生们也都很有意思。可惜班里人数太多，新生谈话没法谈得很久，本来还挺享受这种和两年前的我交流的感觉的，我也很喜欢代入一个个同学的角度进行分析。本以为这学期会比较闲，朗诵社可以全勤了，没想到请了一半的假……真是有点……

8.1组织了同学聚会，不得不说，召集和组织八年未见的老同学们还是颇有难度的。从开始的建群拉人到中间定时间定酒店，每个步骤都能碰到问题。核心的难点线上通知下达落实的太慢，以及无法兼顾每个人的情绪。当时也挺害怕自己搞砸的。不过一切都顺利完成，并且和好多小学的同学都恢复了联系！

化妆会了一捏捏，但几乎完全不用，或者说只有不见人的时候才会自己玩玩。双眼皮贴会贴了，直板夹能稍微夹出点纹理，素颜霜会涂，知道化妆的流程，所以也没很卡粉，还能消黑眼圈和遮痘印。

拍了写真，去厦门玩的时候也拍了很多照片，觉得自己虽然现在不行，但还是有变帅的潜力在的，收获了一点点自信。

进行了国奖答辩、科创先锋、笃学模范、青年领英的答辩，颇有收获，知道了汇报的重心、评奖的机制和其核心要领等等（不细讲了，这部分就写给自己看一下），希望明年能汲取今年积累的经验，百战百胜。

干了两件半大事，大事是什么我不说。

对2025的展望

总是说着要摆烂要摆烂，结果不知不觉还是干了一件又一件事，甚至下学期很多事也找了上门，我会想办法推掉一点。

工作的机会、保研的机会、挣钱的机会……我总是想不错过任何一个机会，但若是一直这样，我对学习外事物的热情会一点点被消磨殆尽。列了几十件想干的事了，虽然有的太天马星空难以实现，但怎么说也去做一点吧，不然这一辈子也太无趣了。我总是想着现在努力了，以后就可以少努力一点，可我现在觉得，越努力，之后越是有的努力，越吃苦，越是要吃一辈子的苦，所以别把时间荒废在学习上了，给我去玩！

新的一年，我要做到以下四点：活得轻松一点，想法简单一点，性格阳光一点，每天开心一点。别的么，走一步看一步吧。

]]> <h1>Part 1: ACM</h1> <h2 id="比赛">比赛</h2> <p><a href="/htmls/map.html">去各地比赛的地图（标签可拖动）</a></p> <p>网页里写的很全了，我文字也写一下吧，中间有很多坎坷，也有很多心路历程，但已经在别处记录 搭建过程记录 https://xmy1107.github.io/post/%E6%90%AD%E5%BB%BA%E8%BF%87%E7%A8%8B%E8%AE%B0%E5%BD%95.html 2024-11-07T03:07:08.000Z 2025-08-25T11:58:15.734Z hexo官方文档

以下是自己的搭建过程（包括怎么git）：

1. 建立名为 username.github.io的储存库

2. first commit

1
2
3
4
5
6
7
8
9
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~$ mkdir blog
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~$ cd blog
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~/blog$ hexo init
INFO  Cloning hexo-starter https://github.com/hexojs/hexo-starter.git
INFO  Install dependencies
INFO  Start blogging with Hexo!
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~/blog$  git push -u origin main
fatal: 不是 git 仓库（或者直至挂载点 / 的任何父目录）
停止在文件系统边界（未设置 GIT_DISCOVERY_ACROSS_FILESYSTEM）。

完全按hexo步骤来会在这步卡住，因为git仓库都没有初始化

1
2
3
4
5
6
7
8
9
10
11
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~/blog$ echo "# xmy1107.github.io" >> README.md
（这里漏了git init，这个记得输入）
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~/blog$ git add README.md
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~/blog$ git commit -m "first commit"
[main （根提交） 8956e78] first commit
 1 file changed, 1 insertion(+)
 create mode 100644 README.md
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~/blog$ git remote add origin https://github.com/xmy1107/xmy1107.github.io.git
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~/blog$ git push -u origin main
Username for 'https://github.com': xmy1107
Password for 'https://xmy1107@github.com':

这里初始化并进行第一次提交以后就建站成功了。注意password不是你用户的密码，而是personal access token。如果是ssh连接就是这样（我用PAT能登进去，但每次都要重新输入，但用ssh在把公钥放进去以后不用这样，就用ssh了）：

1
2
3
4
5
6
7
8
9
10
11
12
13
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~/blog$ git remote get-url origin
https://github.com/xmy1107/xmy1107.github.io.git
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~/blog$ git remote set-url origin git@github.com:xmy1107/xmy1107.github.io.git
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~/blog$ git remote get-url origin
git@github.com:xmy1107/xmy1107.github.io.git
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~/blog$ git push -u origin main
枚举对象中: 3, 完成.
对象计数中: 100% (3/3), 完成.
写入对象中: 100% (3/3), 227 字节 | 227.00 KiB/s, 完成.
总共 3（差异 0），复用 0（差异 0），包复用 0
To github.com:xmy1107/xmy1107.github.io.git
 * [new branch]      main -> main
分支 'main' 设置为跟踪 'origin/main'。

然后在 https://xmy1107.github.io/ 下就有一个空的网页：

image-20240925132827002

ps：PAT想要不每次输密码可以尝试

vim ~/.gitconfig后输入以下内容（虽然我没成功）

1
2
3
4
5
6
7
[init]
        defaultBranch = main
[user]
        name = 
        email = 
[github]
        token =

3. 网站正式建立

上面是因为只push了一个README，下面对github工作流配置后再次push可以得到”正常“的一个网页

  1. 使用 node --version 指令检查你电脑上的 Node.js 版本。 记下主要版本（我是v20.17.0）

  2. 在储存库中前往 Settings > Pages > Source 。 将 source 更改为 GitHub Actions，然后保存。

  3. 在储存库中建立 .github/workflows/pages.yml，并填入以下内容 (将 20 替换为上个步骤中记下的版本)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
.github/workflows/pages.ymlname: Pages

on:
  push:
    branches:
      - main # default branch

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          # If your repository depends on submodule, please see: https://github.com/actions/checkout
          submodules: recursive
      - name: Use Node.js 20
        uses: actions/setup-node@v4
        with:
          # Examples: 20, 18.19, >=16.20.2, lts/Iron, lts/Hydrogen, *, latest, current, node
          # Ref: https://github.com/actions/setup-node#supported-version-syntax
          node-version: "20"
      - name: Cache NPM dependencies
        uses: actions/cache@v4
        with:
          path: node_modules
          key: ${{ runner.OS }}-npm-cache
          restore-keys: |
            ${{ runner.OS }}-npm-cache
      - name: Install Dependencies
        run: npm install
      - name: Build
        run: npm run build
      - name: Upload Pages artifact
        uses: actions/upload-pages-artifact@v3
        with:
          path: ./public
  deploy:
    needs: build
    permissions:
      pages: write
      id-token: write
    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}
    runs-on: ubuntu-latest
    steps:
      - name: Deploy to GitHub Pages
        id: deployment
        uses: actions/deploy-pages@v4

这个过程相当于hexo generate和hexo deploy，区别是在git push时才执行，然后用github工作流完成渲染和部署。

这一步结束后重新打开博客便是如下页面：

image-20240925134647445

  1. 部署完成后，前往 username.github.io/repository 查看网页。

4.一键部署

  1. 安装 hexo-deployer-git，即输入npm install hexo-deployer-git --save
  2. 在 _config.yml 中添加以下配置（如果配置已经存在，请将其替换为如下）:
1
2
3
4
5
6
7
deploy:
  type: git
  repo: https://github.com/<username>/<project>
  # example, https://github.com/hexojs/hexojs.github.io
  # 我这里是git@github.com:xmy1107/xmy1107.github.io.git，因为我是ssh连接的
  # git@github.com:xmy1107/blog.git是项目页面
  branch: main # hexo给的是gh-pages，无所谓
  1. 这里要把网站建立中GitHub Actions改回Deploy from a branch，因为使用 hexo d 时，它会跳过 GitHub Actions，直接将 public 文件夹中的静态文件推送到 gh-pages 分支。 GitHub Actions对应的操作是git push
  2. 执行 hexo clean && hexo deploy 。
  3. 浏览 username.github.io，检查你的网站能否运作。

5.后续配置

主题选用Academia

改用aurora

6.Aurora

见doc

Gitalk

创建一个 comments 仓库，配置一下 OAuth App 即可

1
2
3
4
5
6
7
8
9
10
11
12
13
gitalk:
  enable: true
  autoExpand: true
  clientID: ''
  clientSecret: ''
  repo: 'blog-comments' ## dev-blo-comments
  owner: 'xmy1107' ## owner name
  admin: ['xmy1107'] ## ['admin_name']
  id: location.pathname
  language: en
  distractionFreeMode: true
  recentComment: true
  proxy: ''

开始一直无法启用是因为一直在本地测试，而 GitHub OAuth 不允许本地地址作为 Authorization callback URL，redirect_uri 一直与其冲突。部署上去就大功告成了！

对话功能

一个简单的示例：

在/home/xmy/blog/node_modules/hexo-theme-aurora/layout下修改index.ejs中代码为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width,initial-scale=1">
    <link rel="icon" href="/favicon.ico">
    <script type="module" crossorigin src="/static/js/120aa8f8.js"></script>
    <link rel="stylesheet" href="/static/css/a14e1a22.css">
    <!-- 引入 KaTeX -->
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/katex.min.css">
    <script src="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/katex.min.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/contrib/auto-render.min.js"></script>
    <!-- 引入 marked.js 和 DOMPurify 库 -->
    <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/dompurify@2.4.0/dist/purify.min.js"></script>
    <style>
        #aurora-chatbox {
            transition: opacity 0.3s ease-in-out, transform 0.3s ease-in-out;
            opacity: 0;
            transform: translateY(10px);
        }

        #aurora-chatbox.active {
            opacity: 1;
            transform: translateY(0);
        }
    </style>
</head>

<body id="body-container">
    <noscript>
        <strong>We're sorry but this app doesn't work properly without JavaScript enabled.
            Please enable it to continue.</strong>
    </noscript>
    <div id="app"></div>
    <button id="showChatbox" style="
    position: fixed;
    bottom: 20px;
    left: 20px;
    width: 80px;
    height: 80px;
    padding: 0;
    background-color: #007bff;
    color: white;
    border: none;
    border-radius: 50%;
    font-size: 16px;
    cursor: pointer;
    z-index: 10000;
    box-shadow: 0px 4px 10px rgba(0, 0, 0, 0.2);
    opacity:0;">
    聊天
    </button>


    <!-- Aurora 机器人聊天框，固定在页面左下角 -->
    <div id="aurora-chatbox" style="
    position: fixed;
    bottom: 200px;
    left: 20px;
    width: 350px;
    background: linear-gradient(to bottom right, #ffffff, #f1f7ff);
    border: none;
    border-radius: 12px;
    box-shadow: 0px 4px 20px rgba(0, 0, 0, 0.1);
    z-index: 9999;
    font-family: Arial, sans-serif;
    overflow: hidden;
    ">
    <!-- 标题栏 -->
    <!-- <div style="
        background-color: #007bff;
        color: #ffffff;
        padding: 10px 15px;
        font-size: 16px;
        font-weight: bold;
        border-top-left-radius: 12px;
        border-top-right-radius: 12px;
        text-align: center;">
        Aurora 聊天机器人
    </div> -->
    <!-- 聊天框主体 -->
    <div style="
        padding: 15px;
        display: flex;
        flex-direction: column;">
        <p style="margin: 0; font-size: 14px; color: #333; margin-bottom: 8px;">
            和我聊天吧🤖
        </p>
        <input type="text" id="userInput" placeholder="输入你的问题..."
            style="
                width: calc(100% - 10px);
                padding: 8px;
                margin: 0 auto;
                border-radius: 8px;
                border: 1px solid #ddd;
                box-shadow: inset 0 1px 3px rgba(0,0,0,0.1);
                transition: all 0.3s ease;" />
        <button id="sendMessage" style="
                margin-top: 10px;
                padding: 10px 15px;
                background-color: #007bff;
                color: white;
                border: none;
                border-radius: 8px;
                font-size: 14px;
                cursor: pointer;
                box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2);
                transition: background-color 0.3s ease;">
            发送
        </button>
        <div id="responseBox" style="
                margin-top: 15px;
                min-height: 50px;
                font-size: 12px;
                color: #555;
                background: #f9f9f9;
                border-radius: 8px;
                padding: 8px;
                box-shadow: inset 0px 1px 3px rgba(0,0,0,0.05);
                overflow-y: auto;">
            <!-- 机器人响应展示 -->
        </div>
    </div>
    </div>


    <!-- JavaScript 逻辑 -->
    <script>
        // document.getElementById("showChatbox").addEventListener("click", function () {
        //     const chatbox = document.getElementById("aurora-chatbox");
        //     if (chatbox.style.display === "none" || chatbox.style.display === "") {
        //         chatbox.style.display = "block"; // 显示聊天框
        //     } else {
        //         chatbox.style.display = "none"; // 隐藏聊天框
        //     }
        // });
        document.getElementById("showChatbox").addEventListener("click", function () {
            const chatbox = document.getElementById("aurora-chatbox");
            if (!chatbox.classList.contains("active")) {
                chatbox.classList.add("active"); // 显示聊天框
            } else {
                chatbox.classList.remove("active"); // 隐藏聊天框
            }
        });

        //开发者平台：https://platform.moonshot.cn/console/api-keys
        const API_URL = "https://api.moonshot.cn/v1/chat/completions"; // Kimi AI的API地址
        const API_KEY = "YOUR-KEY"; // 替换为您的Kimi API密钥
    
        async function sendMessage() {
            const userInput = document.getElementById("userInput").value.trim();
            const responseBox = document.getElementById("responseBox");
    
            if (!userInput) {
                responseBox.innerText = "请输入你的问题！";
                return;
            }
    
            responseBox.innerText = "思考中，请耐心等候（需要10秒左右）...";
    
            try {
                // 发起 Kimi AI API 请求
                const response = await fetch(API_URL, {
                    method: "POST",
                    headers: {
                        "Content-Type": "application/json",
                        "Authorization": `Bearer ${API_KEY}`
                    },
                    body: JSON.stringify({
                        model: "moonshot-v1-8k", // Kimi 模型名称
                        messages: [
                            { role: "system", content: "你是一个网站的助手，下面我会给你一些这个网站的相关信息。\
                            \n网站的主人叫虚名羊，网站是用hexo搭建的，网站链接是https://xmy1107.github.io/，\
                            内容以技术和生活为主。" },
                            { role: "user", content: userInput }
                        ]
                    })
                });
    
                if (!response.ok) {
                    throw new Error("API 请求失败，请检查网络或密钥。");
                }
    
                const data = await response.json();
                const kimiResponse = data.choices[0]?.message?.content || "未获取到有效响应内容。";
                console.log("Kimi Response:", kimiResponse);
    
                // 渲染处理与数学公式展示
                const placeholder = '%%MATH_FORMULA%%';
                let mathBlocks = [];
    
                // 预处理数学公式
                const preprocessedResponse = kimiResponse.replace(/\\\[.*?\\\]|\\\(.*?\\\)/gs, (match) => {
                    mathBlocks.push(match);
                    return placeholder;
                });
    
                // 使用 marked 渲染 Markdown
                const renderedHTML = marked.parse(preprocessedResponse);
    
                // 替换占位符回原始数学公式
                let finalHTML = renderedHTML;
                mathBlocks.forEach((math, i) => {
                    finalHTML = finalHTML.replace(placeholder, math);
                });
    
                // 安全插入 HTML 并渲染数学公式
                responseBox.innerHTML = DOMPurify.sanitize(finalHTML);
                renderMathInElement(responseBox, {
                    delimiters: [
                        { left: "\\(", right: "\\)", display: false }, // 行内公式
                        { left: "\\[", right: "\\]", display: true }  // 块级公式
                    ],
                    throwOnError: false
                });
            } catch (error) {
                responseBox.innerText = "抱歉，出错了：" + error.message;
            }
    
            // 清空输入框
            document.getElementById("userInput").value = "";
        }
    
        // 事件监听：发送按钮和回车键
        document.getElementById("sendMessage").addEventListener("click", sendMessage);
        document.getElementById("userInput").addEventListener("keydown", function (event) {
            if (event.key === "Enter") {
                event.preventDefault();
                sendMessage();
            }
        });
    </script>
    
</body>

</html>

令我最头疼的点：正则表达式识别
小小记录下：

.*?：非贪婪匹配，匹配中间的任意字符，直到遇到下一个 \] 为止。

s 标志：启用 dotall 模式，使 . 匹配换行符。

g 标志：全局匹配。

upd：改kimi ai了，gpt有的人可能用不了。

一些自己写博客的注意点

关于贴html

贴html用绝对路径：[去各地比赛的地图（标签可拖动）](/htmls/map.html)

贴图片用相对路径：![image-20240925134647445](搭建过程记录/image-20240925134647445.png)

因为渲染后所有静态网页都在 public/post 中，不管这里的绝对还是相对，都是基于根目录为 public 的路径，图片用相对路径是为了编辑时也可以预览，因为图片相对于当前都是 ${filename}/image_name.png，现在在 Typora 中编辑且设置好路径表示的偏好就很方便，直接粘贴即可。

html文件要禁止渲染，默认会渲染并且放进page目录中。需要在config中加入以下配置：

1
2
skip_render:
  htmls/**/*.html

要放进地址栏的部分得用英文字符，但只是文件链接就不用

[双放手录视频+唱歌，九十度弯摔了](/htmls/双放手.html)

html文件中是

1
2
3
4
<video controls width="500">
    <source src="/videos/shuangfangshou.mp4" type="video/mp4">
    您的浏览器不支持视频标签。
</video>

本地的目录，供以后参考

hexo s后台运行

数学公式

hexo-filter-mathjax

记得front-matter里加上mathjax: true

公式换行需要\\\\

需要_config.yml把highlight enable一下，不然只有部分公式可以显示，不知道原理

TODO LIST

小机器人可以想办法搞得更生动一点
用nodejs啥的把api封装到后端（目前感觉没啥关系，小白不在乎安全性）
代码高亮真的搞不好，主题必须要shiki高亮引擎，而shiki是一个ES Module，与hexo环境不兼容。

没搞清楚的部分

项目页面（这部分没完全搞清楚）

  1. 导航到 GitHub 上的存储库。 转到 Settings 选项卡。 建立名为 <repository 的名字> 的储存库，这样你的博客网址为 <你的 GitHub 用户名>.github.io/<repository 的名字>，repository 的名字可以任意，例如 blog 或 hexo。
  2. 编辑你的 _config.yml，将 url: 更改为 <你的 GitHub 用户名>.github.io/<repository 的名字>。
  3. 在 GitHub 仓库的设置中，导航至 Settings > Pages > Source 。 将 source 更改为 GitHub Actions，然后保存。
  4. Commit 并 push 到默认分支上。

注意这里要修改远程的仓库，需要push到新建的那个仓库中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~/blog$ git remote set-url origin git@github.com:xmy1107/blog.git
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~/blog$ git remote -v
origingit@github.com:xmy1107/blog.git (fetch)
origingit@github.com:xmy1107/blog.git (push)
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~/blog$ git add .
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~/blog$ git status
位于分支 main
您的分支与上游分支 'origin/main' 一致。

要提交的变更：
  （使用 "git restore --staged <文件>..." 以取消暂存）
修改：     _config.yml

(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~/blog$ git commit -m "first commit"
[main fa6cdc7] first commit
 1 file changed, 1 insertion(+), 1 deletion(-)
(base) xmy@xmy-Z790M-AORUS-ELITE-AX:~/blog$ git push
枚举对象中: 30, 完成.
对象计数中: 100% (30/30), 完成.
使用 16 个线程进行压缩
压缩对象中: 100% (19/19), 完成.
写入对象中: 100% (30/30), 31.32 KiB | 3.48 MiB/s, 完成.
总共 30（差异 3），复用 0（差异 0），包复用 0
remote: Resolving deltas: 100% (3/3), done.
To github.com:xmy1107/blog.git
 * [new branch]      main -> main
]]> <p><a href="https://hexo.io/zh-cn/docs/">hexo官方文档</a></p> <p>以下是自己的搭建过程（包括怎么git）：</p> <h1>1. 建立名为 <strong><a href="http://username.github.io