Posts on StarryReverie 繁星筑梦星缀夜空

现代 Linux 桌面会话管理

Wed, 18 Feb 2026 20:47:53 +0800

最近尝试了使用 Wayfire 作为 Wayland 混成器，整体体验后，Wayfire 的功能是不错的，可惜其没有 systemd 支持，对于依赖 systemd 的我来说，这显然是不能够满足日常需求的。因此，我研究了如何为其添加基于 systemd 的会话管理机制，记录在此文中。

桌面会话的生命周期

传统方式

在 Linux 中，本没有什么非常精细的会话管理机制，无论是 Shell 登录还是图形界面登录，一切都可以是非常简洁的流程完成。 Shell 登录时，Login Manager 以登录用户身份启动 Login Interactive Shell 进程，Shell 则运行相应的 Profile 脚本，如 bash(1) 加载 ~/.bash_profile 或 ~/.profile，作为最简单的会话管理机制，运行一些后台任务。对于图形界面来说，可以直接 startx、加载 ~/.xinitrc 、启动 X 服务器和 Window Manager 等进程，或者运行 Wayland 混成器，或者由 Display Manager 负责创建 X 服务器或 Wayland 混成器进程，而图形环境所需要的程序要么通过 ~/.xinitrc 这样的脚本启动，要么在 Window Manager 的配置文件中指定。

无论是什么方法，都是原始的机制。尽管它们原理十分简单，却存在诸多弊端，比如配置服务启动的方式不统一，Shell 登录、X 环境登录和 Wayland 环境登录需要各种不同的配置文件、需要写脚本以命令式的方式完成；比如这种方式没有充分利用 systemd 的支持，集成差、体验割裂。在 Linux 桌面系统中 systemd 早已普及的今天，这种原始方式显然跟不上时代。

基于 systemd 的现代方式

systemd 早已为 Linux 的各种应用场景设计好了一套服务和会话管理的框架，其关键点在于各种预定义的 target。target 是系统的生命周期的各个阶段起始或终止的标志，只要为每个程序写好 service 文件，并设置好其与 target 的关系，systemd 即可完全自动地在特定时间节点做好规划的工作，运行各种服务。

为 EndeavourOS 构建 Linux 内核

Wed, 15 Oct 2025 22:59:02 +0800

简单记录一下在 EndeavourOS 上手动编译 Linux 内核的过程。

环境准备

整个过程在虚拟机上完成，具体配置参数如下：

Hypervisor: VMware Workstation Pro 17
OS: EndeavourOS Mercury Neo
Bootloader: systemd-boot
Old Kernel: 6.16.8-arch3-1
New Kernel: 6.17.1
CPU: 8 x 13th Gen Intel(R) Core(TM) i7-13700HX @ 2.30 GHz
RAM: 8 GB
IP：VMnet8 (NAT) 192.168.255.11

为了操作方便，通过 SSH 从宿主机连接到虚拟机，运行以下命令连接，其中 starryreverie 为已创建用户：

ssh starryreverie@192.168.255.11

获取内核源码

内核源码可以从 kernel.org 下载。选择 linux-6.17.1.tar.xz 源码包，并使用以下命令下载：

wget https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.17.1.tar.xz

在本地新建目录 build，并解压源码包：

mkdir build
tar -xvf linux-6.17.1.tar.xz -C build

cd build/linux-6.17.1
ls -alh

配置编译环境

在编译内核前，需要安装必要的工具和依赖包。使用以下命令安装：

结合 SPPM 的 Path Tracing

Sun, 10 Aug 2025 19:55:17 +0800

随机渐进式光子映射（Stochastic Progressive Photon Mapping, SPPM）是光子映射系列算法的进阶算法，本文介绍如何实现 SPPM 以及如何将 SPPM 与路径追踪（Path Tracing, PT）结合。

光子映射系列算法

光子映射

光子映射（Photon Mapping, PM）是光子映射系列算法中的初代算法，是一个两阶段算法，包括光子追踪和光子映射。其思想就是首先从光源发射光子，光子在场景中不断反弹，模拟现实世界的过程，然后再使用 Path Tracing，过程中在合适的地方使用光子来估计 radiance，加速渲染。

光子的发射

光子是光源的通量/功率的载体，光源实质上是通过发射光子来实现照明。PM 中的光子与物理中的光子不同，物理学中的光子是光能传递的最小单元，即量子化的性质，单个光子的能量是 $E = h\nu$，而 PM 中的光子实际上是一堆物理中的光子，是更符合应用的模型。所以，接下来所讨论的光子都是 PM 意义下的光子。

如何计算单个光子的通量呢？发射光子的过程实际上就类似于对光源的总通量进行 Monte Carlo 估计的过程，每个光子都是一个样本，每一份通量相加就得到了总通量。所以我们就对光源表面和出射方向进行采样，按照类似的过程计算每一个光子的通量。总通量按照以下积分计算

$$ \begin{aligned} \Phi & = \int_M \int_{\Omega^+} L_e(x, \omega) (n \cdot \omega) \mathrm d\omega \mathrm dA \\ & \approx \dfrac{1}{N} \sum_{i = 1}^N \dfrac{L_e(x, \omega) (n \cdot \omega)}{p(x)p(\omega)} \end{aligned} $$

所以单个光子的通量就是 $\dfrac{1}{N} \dfrac{L_e(x, \omega) (n \cdot \omega)}{p(x)p(\omega)}$，$N$ 表示被发射光子的总数。严格意义上来说，通量的定义是不考虑立体角和照明面积的，所以所谓的单个光子的通量实际上是通量的二阶差分 $\Delta^2 \Phi$。在实际实现中，我们在计算通量时并不会除以 $N$，这是因为在 SPPM 中光子数量会随着迭代次数增加而增加，因此我们也将其 $\dfrac{L_e(x, \omega) (n \cdot \omega)}{p(x)p(\omega)}$ 视为一种没有放缩的通量，直到最后再除以 $N$ 得到真正的通量。

光线追踪中的 Multiple Importance Sampling

Thu, 07 Aug 2025 09:34:03 +0800

本文主要介绍多重重要性采样（Multiple Importance Sampling）及其在光线追踪中的典型应用。

Multiple Importance Sampling

Monte Carlo Path Tracing

在 Ray Tracing 中，最核心的技术就是 Monte Carlo Estimation。通过使用 Monte Carlo Estimation，我们可以求解 Rendering Equation。对于 Monte Carlo Estimation 来说，一个合适的采样方法可以极大提升收敛的速度，具体来说，对于以下积分及其 Estimator

$$ I = \int_D f(x) \mathrm dx \approx \dfrac{1}{N} \sum_{i = 1}^N \dfrac{f(X_i)}{p(X_i)} $$

$X_i$ 的最佳的采样分布应该满足 $p(X_i) \propto f(X_i)$。

然而对于 Rendering Equation 来说，这个条件难以满足，因为其被积函数包含了 cosine-weighted BSDF 和 radiance 两部分因子，后者更是需要递归求解的未知项，显然没有办法进行完美的采样。

$$ L_o(x, \omega_o) = L_e(x, \omega_o) + \int_{\Omega^+} f_s(x, \omega_o, \omega_i) L_i(x, \omega_i) (n \cdot \omega_i) \mathrm d\omega_i $$

一般情况下，我们只能选择让采样分布于其中一部分因子的形状近似，也就产生了两种采样——BSDF 采样（包括了余弦项）和光源采样（光源贡献的 radiance 应该比非直接的更大）。

无需宏为 Trait Objects 实现 Any

Mon, 17 Mar 2025 20:48:11 +0800

std::any::Any 是 Rust 在运行时进行类型擦除和转换的工具，所有 'static 类型都实现了 Any，因此装箱为 Box<dyn Any> 后可以借助 Any::type_id() 获取 TypeId，还可以通过 dyn Any 的 downcast_*() 等方法再转换回具体类型。

然而问题也出在 dyn Any 的 downcast_*() 方法。这些方法是 dyn Any 的方法，而不是 Any trait 中的方法，所以其他任何 dyn Trait 都不会拥有这些方法，即使有 Trait: Any。另一方面，由于 trait upcasting 直到最近才成为稳定特性，且还没进入 stable 版本，所以依赖语言支持的 trait upcasting 来转换为 dyn Any 对于较早版本的项目并不合适。

因此，本文则通过纯 Rust 语法来扩展 trait object，以实现 Any 的所有功能。这些实现都可以在 better-as-any 找到。

现有解决方案

`downcast`

downcast crate 通过宏来生成代码，直接为指定的 dyn Trait 添加 is()、downcast_*() 方法。这种做法在最终效果上与 dyn Any 完全一样，但是需要使用 impl_downcast!() 宏来实现。我个人则偏好能使用语言特性实现就不使用宏。

`as-any`

这个 crate 不使用宏实现了功能，其中的 AsAny 可以把任意类型的引用转换为对 dyn Any 的应用，即 trait upcasting。同时其有 Downcast trait 可以把引用向下转型为具体类型的引用。

anyerr 上下文中的类型体操

Thu, 27 Feb 2025 10:27:45 +0800

在对 Rust 错误处理的思考和 anyerr一文中，我介绍了 anyerr 这一个错误处理库，其可以携带上下文信息，且储存上下文的数据结构是可定制的。本文则聚焦 anyerr 是如何实现这样的特性的。

上下文的核心特性

基本结构和表示

在设计之前，首先我们要明确需求。什么样的上下文数据结构是我们所需要的？携带上下文是为了能够记录某些变量所保存的值，我们需要记录变量的名称和其中的值。上下文可以有很多种类，但所有的上下文都可以表示为一个键值映射表。

所以以下是我们对一个上下文储存的基本特性的定义：

pub trait AbstractContext: Default + Debug + Send + Sync + 'static {
    type Key;

    type Value;

    type Entry: Entry<Key = Self::Key, Value = Self::Value>;

    type Iter<'a>: Iter<'a, Entry = Self::Entry>
    where
        Self: 'a;

    fn iter(&self) -> Self::Iter<'_>;
}

这样的一个 trait 定义仅仅规定了一个上下文的键值对类型和迭代其中元素的方法，却没有插入或者其他查询的方法。这是因为一个上下文不一定需要真的携带有信息，如果不需要上下文，那么一个不带有任何信息的上下文就可以非常好地适用于这种场景，这也是为什么这个 trait 叫做 AbstractContext。anyerr 针对这样的情况有特殊的优化，这些后面再说。

上下文的元素

AbstractContext::Entry 规定了上下文中每一个元素的类型，其应当实现 Entry trait。以下则是 Entry 的定义：

pub trait Entry: Debug + Send + Sync + 'static {
    type Key: Borrow<Self::KeyBorrowed> + Debug + Send + Sync + 'static;

    type KeyBorrowed: Debug + Display + Eq + Hash + ?Sized + Send + Sync + 'static;

    type Value: Borrow<Self::ValueBorrowed> + Debug + Send + Sync + 'static;

    type ValueBorrowed: Debug + ?Sized + Send + Sync + 'static;

    fn new<Q, R>(key: Q, value: R) -> Self
    where
        Q: Into<Self::Key>,
        R: Into<Self::Value>;

    fn key(&self) -> &Self::KeyBorrowed;

    fn value(&self) -> &Self::ValueBorrowed;
}

Entry trait 具体规定了键和值的类型以及创建和访问的方法。在 AbstractContext 中，还要将 AbstractContext::Key、AbstractContext::Value 和 Entry::Key、Entry::Value 匹配。

对 Rust 错误处理的思考和 anyerr

Thu, 20 Feb 2025 11:08:21 +0800

错误处理是 Rust 中核心的一部分，从标准库中的 Result<T, E> 和 Error 到社区的 anyhow、thiserror、color-eyre、snafu 等 crates，可见其重要地位。但是在我看来，这些仅仅是错误处理机制的基础，而不是一个十分完备的框架，同时某些 crate 的设计，要么不能符合实际需要，要么使用起来很麻烦。本文将阐述我对 Rust 错误处理的理解和自己的实践 anyerr。

`std` 中的基础设施

在讨论我对错误处理的理解之前，有必要先回顾标准库中与错误处理相关的基础设施。

截至本文写作时间，Rust 的最新版本为 1.84.1，接下来将以此版本为基础进行讨论。

错误与结果

标准库中最广为人知的一个类型就是 Result<T, E>，用来表示一个可能成功或失败的结果。这是一个非常精妙的设计，主要体现其可以编码成功或失败中的一者，而不是将失败结果糅合进成功结果的值中。C 广泛采用后一种处理方式，导致 API 的混乱，当然这很大一部分是历史原因。在 Java 等以异常为主要错误处理机制的语言中，这一问题有了很大改善，但这又引入了隐式控制流的问题，Result<T, E> 则又避开了这个问题。所以，Result<T, E> 应该是一个很不错的机制。

尽管 Result<T, E> 中的 E 代表错误，但标准库对其具体应是什么类型没有什么限制。一般情况下，E 是一个实现了 Error trait 的类型，或者是其他可以间接地访问到内部的错误的类型，如 Box<dyn Error>。

错误类型的统一契约

若某类型实现了 Error，那么其就可以以一种标准的形式来被集成的错误处理的框架中。Error 规定了如何显示错误信息（通过 Display trait）和如何溯源错误（通过 <Self as Error>::source()）。

在 Rust 早期，并没有 Error，错误处理是处于一种野蛮生长的状态。直到 Error 的引入，Rust 才可以算是有了一套标准的错误处理机制。

错误的传播

Result<T, E> 虽好，但在深层函数调用中，一次次手动向上传播错误却很麻烦。? 运算符则有效解决了这个问题，实现了把错误方便的提前返回，传播给调用方。

? 的使用不要求被传播错误类型和接受的错误类型完全相同，只需要有 From 的联系，即如果 E1: From<E2>，那么对 Result<U, E2> 使用 ? 就可以把错误传播为 Result<T, E1>。

统一 Linux GUI 框架主题和外观

Wed, 31 Jul 2024 23:21:07 +0800

在 Linux 下，GUI 外观配置一直是一个复杂的话题。本文试图梳理 Qt 和 GTK 两种 GUI 框架的相关概念，并给出不同情况下的配置方案，实现外观的统一。

本文讨论的 Qt 包括 Qt 5 和 Qt 6，GTK 包括 GTK 2、GTK 3、GTK 4，并且将以 Qt 6 和 GTK 4 为重点。测试的 DE 和 WM 包括 GNOME 4.46、KDE Plamsa 6.1、Hyprland 0.41。

配置组成

基本概念

外观配置一般包括以下几个方面：

主题/Theme：这是一个比较广泛的概念，一般包括了样式、图标和鼠标指针等各配置项在内。
样式/Style：一般指程序窗口、面板、组件的外观。
图标/Icon
指针/Cursor
字体/Font
配色方案/Color Scheme：较细粒度的配置项，诸如主要颜色、强调颜色的配置都属于配置方案。
声音/Sound
……

这是一个比较广泛的定义，具体到各框架，又会产生一定的变化。

GTK

GTK 中可直接配置的部分相对较少，主要是：

主题/Theme：主要与一般定义中的样式/Style 对应。
图标/Icon Theme：与一般定义中的图标/Icon 相同。
指针/Cursor Theme：与一般定义中的指针/Cursor 相同。
字体/Font：与一般定义中的字体/Font 相同。

包括 GNOME 在内的基于 GTK 开发的 DE 基本上直接使用上述概念，利用这些 DE 的工具配置外观，基本上就是对 GTK 的配置直接修改。

用 NixOS 部署 Minecraft 服务器

Fri, 05 Jul 2024 15:42:09 +0800

紧张的考试周过后，终于有时间和朋友玩 Minecraft 了。为了方便进行多人游戏，我和 @whitepaperdog 决定购买一台云主机作为服务器。鉴于 NixOS 强大的 reproducibility 以及我这半年使用 NixOS 的优秀体验，我决定将服务器的系统更换为 NixOS，并在其之上部署 Minecraft 服务。

准备工作

NixOS 安装

这台服务器并不是用我的账号买的，所以我没有办法直接在控制台上传 NixOS 的镜像进行安装。等我拿到 root 密码后，系统就已经是 Ubuntu 了。在此情况下，我选择了使用 NixOS-infect。NixOS-infect 是一个 shell 脚本，其在服务器上安装 Nix，再用 Nix 构建出 NixOS，最后修改 bootloader 配置，添加 NixOS 的启动项并删除其他东西。

使用 NixOS-infect 前需要配置好访问 root 的 SSH 公钥，这是因为 NixOS-infect 并没有提供设置 root 密码的步骤，并且 NixOS 默认情况下将禁用 SSH 通过密码登录 root。NixOS-infect 脚本会将原有的 root 的公钥重新导入到新的 NixOS 里。

由于服务器在国内，所以访问 nixpkgs 的 cache 将会非常慢，在安装 NixOS 之前需要配置好 cache 镜像。编辑脚本，在完成 Nix 的安装后，配置镜像源：

infect() {
  # ...
  NIX_INSTALL_URL="${NIX_INSTALL_URL:-https://nixos.org/nix/install}"
  curl -L "${NIX_INSTALL_URL}" | sh -s -- --no-channel-add

  # 添加以下 3 行
  cat << EOF > /etc/nix/nix.conf
substituters = https://mirror.sjtu.edu.cn/nix-channels/store https://mirrors.ustc.edu.cn/nix-channels/store https://cache.nixos.org/
  EOF

  # shellcheck disable=SC1090
  source ~/.nix-profile/etc/profile.d/nix.sh
  # ...
}

随后就是运行脚本，等待 SSH 断开，安装完成。

体验 Helix 编辑器

Sat, 08 Apr 2023 21:49:01 +0800

最近发现了一个用 Rust 写的 Vim-like 编辑器 Helix，用有强大的性能和各种开箱即用的功能。经过短暂时间的体验，我认为 Helix 已经可以在大部分领域替代 Vim/Neovim/VS Code。

性能

作为一款用 Rust 写的编辑器，Helix 自然拥有优异的性能。得益于其丰富的内置功能，Helix 无需插件就可以完成许多 Vim 只能用插件做到的事，并且还通过 Rust 获得了性能上的优势。现在我的 Neovim 安装有 coc.nvim、vim-visual-multi 等插件，共十个，启动需要延迟近 0.5 秒，虽然已经显著快于 VS Code，但相比 Helix 的小于 0.1 秒，还是稍显逊色。（当然这可能与我现在用的是 Windows 有关）

虽然现在（2023年4月8日）Helix 还没有插件系统，但未来的插件系统大概率会用 WASM 实现，相比 Vim Script 以及 Neovim 用的 Lua 等脚本语言会更快。

编辑体验

整体思路

首先 Helix 和 Vim 一样都是模态编辑器，具有多种模式，最基本的操作思路是一样的，比如都使用 hjkl 进行移动，都使用 i、a 等进行插入，都使用 y，d、p 进行复制删除粘贴。但是 Helix 采用了 selection -> action 模式，比如向右删除 3 个字符需要按 3ld 而不是 d3l，先选择在操作，就我个人而言，这种方式确实更舒适。

另外，Helix 的命令有丰富的提示，而且还可以通过 <space> ? 打开命令面板查找命令，并带有相关键位提示，包括自定义的键位。

用 Rust 开发 Brainfuck 解释器

Thu, 26 Jan 2023 22:26:51 +0800

项目地址：https://github.com/StarryReverie/brainfuck-interpreter

Brainfuck 是什么就不具体介绍了，可以看这里。以下简称 bf。

这个解释器实现总体上是比较简单的，但是相比其他的大多数解释器还是有比较多的不同之处，具体如下：

更多的配置选项
- 内存的长度与地址范围：可配置为负数
- 单个内存单元的数据类型
- 数据溢出处理机制：wrap 或错误
- 读到 EOF 的处理机制：返回 0、EOF 本身或不改变
优化指令
采用类似编译为字节码的机制

这个项目可以算是学习 Rust 的练手项目，尝试着用了如 clap 这样的 crate。接下来就介绍一些技术细节。

使用方法

具体说明在项目 README.

编译、安装、执行全过程：

$ git clone https://github.com/StarryReverie/brainfuck-interpreter.git
$ cd brainfuck-interpreter
$ cargo install --path ./crates/bf-exec # The program will be installed to ~/.cargo/bin
$ bf-exec ./examples/helloworld.bf
Hello World!

./examples/helloworld.bf：

++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.

实现原理

目前，项目分为两个 crate：common 与 bf-exec，其中 common 实现了解释器的所有逻辑，而 bf-exec 是 common 的前端，负责处理输入和配置。

common 的模块树如下：

compiler：解析代码并转换为 IR (Intermediate Representation，中间表示)
- lexer：词法分析
- parser：语法分析并优化，生成 AST SyntaxTree
  - syntax：AST 生成
  - optimizer：AST 优化
- instruction：根据 AST 生成 IR，同时也是最终执行的指令
execution：IR 的执行与相关环境
- memory：按照 bf 的内存模型实现的可配置内存
  - strategy：基于策略模式实现的可配置组件
  - config：构建 Memory 的配置
- stream：bf 的 IO 实现
  - config：构建 InStream、OutStream 的配置
- context：Memory 与 InStream、OutStream 的组合
- processor：运行指令，并调用 Context

实现细节

代码优化

同质代码合并

首先最简单的就是这个优化，它是指把相邻的 + 与 -、< 与 > 合并到一起并加上一个重复次数。

Python 网络爬虫获取 SYZOJ AC 代码

Mon, 18 Apr 2022 15:23:12 +0800

写本文之前，我共有两百多道题目在校内 OJ 上通过，由于某些原因，想要保存这些代码，于是想到使用 Python 实现自动爬取代码。同时考虑到效率问题，决定使用 aiohttp 编写一个高性能异步爬虫。

实现目标分析

这个爬虫需要能够爬取所有的已通过题目的列表，并继续爬取这些已通过题目的代码，随后保存到文件中。

校内 OJ 基于 SYZOJ 搭建，该 OJ 的项目地址为 https://github.com/syzoj/syzoj，故接下来的代码都是基于其实现的。

由于这个 OJ 的外网域名的带宽很小，一个网页最坏情况下需要花费 2～3 秒的时间，所以必须采用异步实现。这里就使用 aiohttp 了。

由于直接从浏览器里获取的 Cookie 无法正常使用，传给服务器无法识别，猜测是编码问题，所以使用在爬虫运行时即时获取 Cookie 的办法。

分析 SYZOJ 的登陆页面源码，找到如下代码片段：

function login() {
    password = md5($("#password").val() + "syzoj2_xxx");
    $("#login").addClass("loading");
    $.ajax({
        url: "/api/login",
        type: 'POST',
        data: {
            "username": $("#username").val(),
            "password": password
        },
        async: true,
        success: function(data) {
            error_code = data.error_code;
            switch (error_code) {
                case 1001:
                    show_error("用户不存在");
                    break;
                case 1002:
                    show_error("密码错误");
                    break;
                case 1003:
                    show_error("您尚未设置密码，请通过下方「找回密码」来设置您的密码。");
                    break;
                case 1:
                    success(data.session_id);
                    return;
                default:
                    show_error("未知错误");
                    break;
            }
            $("#login").text("登录");
            $("#login").removeClass("loading");
        },
        error:  function(XMLHttpRequest, textStatus, errorThrown) {
            alert(XMLHttpRequest.responseText);
            show_error("未知错误");
            $("#login").text("登录");
        }
    });
}

可以发现，SYZOJ 通过 /api/login 这个 Web API 发送请求获取 Cookie，使用 POST 方法，数据为 username 和 password，分别为用户名和密码加上 syzoj2_xxx 这个 salt 的 MD5，所以可以使用以下 Python 代码获取 Cookie

MultiGenerator 使用文档

Mon, 04 Apr 2022 22:15:15 +0800

概述

MultiGenerator 作为早年我的试验项目，已不再适合于实际使用。如果想要生成数据，请使用性能更高且更简单的 Rust 实现：data-gen-rs。

MultiGenerator 是一个为 OI 而生的多线程并行数据生成库，基于 C++ 17，使用面向对象和泛型等 Morden C++ 高级特性，只需要添加最少的额外代码，就可以获得最高的性能。以下是一个能够指定数据范围的 A + B Problem 数据生成器的示例代码：

#include <random>
#include <MultiGenerator.hpp>

using MultiGenerator::DataConfig;
using MultiGenerator::GeneratingTask;
using MultiGenerator::SolutionTask;
using MultiGenerator::NormalTemplate;
using MultiGenerator::entry;
using MultiGenerator::testcase;

/** 指定数据生成器，仅需继承一个抽象类和实现一个成员函数 */
class AddGenerator : public GeneratingTask {
private:
    void generate(std::ostream &data, const DataConfig &config) override {
        /** DataConfig 为配置信息，可以用于储存数据范围等元信息 */
        auto minValue = std::stoi(config.get("minValue").value());
        auto maxValue = std::stoi(config.get("maxValue").value());

        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_int_distribution<> dist(minValue, maxValue);
        /** 像 cout 一样输出生成结果 */
        data << dist(gen) << " " << dist(gen) << std::endl;
    }
};

/** 指定数据求解器，也仅需继承一个抽象类和实现一个成员函数 */
class AddSolution : public SolutionTask {
private:
    /** 假如你有标程，仅需要把程序用这个类包装起来，再把 main() 改为这个成员函数即可 */
    void solve(std::istream &dataIn, std::ostream &dataOut, const DataConfig &) override {
        int a, b;
        /** 像 cin 一样读入数据 */
        dataIn >> a >> b;
        /** 像 cout 一样输出答案 */
        dataOut << a + b << std::endl;
    }
};

int main() {
    constexpr int MAX_THREAD_COUNT = 8;
    constexpr int MAX_TESTCASE_COUNT = 20;
    constexpr char PROBLEM_NAME[] = "add";
    /** 创建一个题目生成模板，指定数据文件名为 add#.in/add#.out，# 是测试点编号，可以含子任务编号 */
    MultiGenerator::NormalTemplate temp(PROBLEM_NAME);

    for (int i = 0; i < MAX_TESTCASE_COUNT; ++i) {
        /** 添加测试点配置，并指定生成器和求解器 */
        temp.add<AddGenerator, AddSolution>(testcase(i, {
            entry("minValue", i * 1000000),
            entry("maxValue", (i + 1) * 1000000)
        }));
    }
    /** 开始根据指定的线程数生成数据 */
    temp.execute(MAX_THREAD_COUNT);
    return 0;
}

要求

C++ 17 Compiler
C++ 基础知识，包括最基本的模板的使用（基本都可以满足）
能够认真阅读文档

安装

编译器支持

首先确保你有支持 C++ 17 的编译器，如果你已经有了，可以跳过这一步。

二分图匹配学习笔记

Tue, 22 Feb 2022 13:31:06 +0800

二分图

定义

如果一个图 $G=(V,E)$ 中的结点可以被分为两个部分，且两个部分之内的点互相没有连边，则称这种图为二分图。如果每个结点的度数相等且都为 $k$，则称这种二分图为 $k$ - 正则二分图。

判断

对图的结点进行黑白染色，相连的结点染不同的颜色，若最后满足每条边的两个端点颜色不相同，则这个图是二分图。树也是二分图。

染色

这里的染色不同于判断的染色，它指的是对边进行染色。若染 $k$ 种颜色，则称其为二分图的 $k$ 染色。

对于一个 $k$ - 正则二分图来说，它一定可以被 $k$ 染色，而对于一般的二分图，若其最大度数为 $k$，则它也可以被 $k$ 染色。

匹配

在二分图的边集中选出一个非空子集，且这个非空子集内没有两条边连接了一个相同的端点，则这个非空子集被称为二分图的一个匹配，同样对于一般图也有类似的概念。

若一个匹配的所含的边数最大，则称这个匹配为最大匹配。

若二分图两边的结点个数相同，且存在一个匹配满足其中的边连接了所有的点，则这个匹配被称为这个二分图的完美匹配或者完备匹配。

若每条边有边权，且一个匹配的所含的边的权值和最大，则这个匹配被称为这个二分图的最大权匹配。

匈牙利算法

交替路

假设在二分图最大匹配的过程中，已经找到了一些边作为一个匹配，则一条交替路就是一个匹配边和非匹配边交替连接组成的简单路径。

根据二分图的定义，假设一条交替路的起点在左边，且第一条边是匹配边，则这条交替路中的匹配边一定都是从左边到右边，而非匹配边一定是从右边到左边。

交替路上的结点最多连接一条匹配边和一条非匹配边，所以如果把交替路上的匹配边变为非匹配边，非匹配边变为匹配边，则仍然满足条件，也就是交替路边集的匹配边集的补集也可以是匹配。

增广路

匈牙利算法的核心就是找增广路，这条增广路是一条交替路。每次增广从左边开始，第一条边是非匹配边，最后一条边也是非匹配边，根据上文的描述，这样的路径的边数为奇数，非匹配边个数比匹配边个数多 $1$，若把匹配边与非匹配边反转，则反转后的边集仍然是一个合法的匹配，且比原来的匹配的边数多了 $1$。如果能找到一条这样的增广路，则此次增广成功。

具体来说，比如一个左边的结点 $x$ 找到了一个右边的结点 $y$，它没有与其他左边的结点匹配过，则 $e(x,y)$ 可以作为一个匹配边，反转边集前，有 $1$ 条匹配边，$0$ 条非匹配边，增广成功。

如果右边的结点 $y$ 已经有匹配了，那么就可以让原来 $y$ 的匹配 $x'$ 新找一个点 $y'$，如果能够找到这个 $y'$，那么 $e(x',y')$ 成为一个匹配边，$y$ 就无需和 $x'$ 匹配了，也就是说 $y$ 已经变为了一个没有匹配的点，$x$ 就可以与 $y$ 匹配了。如果 $x'$ 找不到 $y'$，那么 $x'$ 就要保持原样，和 $y$ 匹配，那么 $x$ 就不可以和 $y$ 匹配，只能继续寻找下一个可能的结点。

莫比乌斯反演学习笔记

Sun, 20 Feb 2022 11:23:07 +0800

莫比乌斯反演可以用于优化一类式子的计算。

莫比乌斯函数

定义

莫比乌斯函数的定义如下：

$$ \mu(n)= \begin{cases} 0 & \exists\ p^2 \mid n \wedge p>1\\\\ (-1)^k & n=\prod_{i=1}^{k} p_i \end{cases} $$

也就是说，如果 $n$ 含有平方约数，则 $\mu(n)=0$，否则 $\mu(n)=(-1)^k$，其中 $k$ 为 $n$ 中的本质不同的质约数个数。

性质

积性函数

$\mu(n)$ 为积性函数，证明如下：

设 $a,b$ 满足 $\gcd(a,b)=1$。

若 $a,b$ 其中一个数含有平方约数，则它们的乘积也一定含有平方约数，此时它们的莫比乌斯函数值都为 $0$，即 $\mu(ab)=\mu(a)\mu(b)=0$。
否则 $a,b$ 都不含有平方约数，则设它们的质约数个数分别为 $k_a,k_b$，则 $\mu(a)=(-1)^{k_a},\mu(b)=(-1)^{k_b}$，因为满足 $\gcd(a,b)=1$，故 $ab$ 的质约数个数为 $k_a+k_b$，$\mu(ab)=(-1)^{k_a+k_b}=(-1)^{k_a}(-1)^{k_b}=\mu(a)\mu(b)$。

Q.E.D.

与常数函数的卷积

这个性质十分重要，是反演的基础。这个性质可以写成 $I * \mu= \epsilon$，或者：

$$ \sum_{d\mid n}I(\frac{n}{d})\mu(d)=\epsilon(n) $$

经常简记为：

$$ \sum_{d\mid n} \mu(d) = [n=1] $$

$\epsilon$ 是 Dirchlet 卷积的单位元函数。

同余方程学习笔记

Sun, 13 Feb 2022 21:40:02 +0800

解各种同余方程是同余问题的一个重要部分，本文介绍各种同余方程的求解方法。

二元线性不定方程

形式

不定方程的范围很广泛，只要没有确定的解的方程都可以叫不定方程。本文主要讨论数论中的不定方程。

$$ ax+by=c\ (a,b,c,x,y\in \mathrm{Z}) $$

形如上面这种形式，满足各项的系数和解均为整数的方程就是数论中的不定方程。

求解

Theorem 1：$\forall a, b \in \mathrm{Z}$，一定存在 $x,y\in \mathrm{Z}$，使得 $ax+by=\gcd(a,b)$。

这个定理又叫做裴蜀定理，根据这个定理，可以得出不定方程 $ax+by=c$ 有解的充要条件就是 $\gcd(a,b)\mid c$。记 $d=\gcd(a,b)$，则我们可以先求出 $ax'+by'=d$ 的解，再令 $x=\frac{c}{d}x',y=\frac{c}{d}y'$，就得出原方程的一组解。

求 $x',y'$ 的过程可以用扩展欧几里得算法，即 exgcd 解决。

Theorem 2：若 $\gcd(a,b)=1$，且 $x_0,y_0$ 是方程 $ax+by=c$ 的一组解，则该方程的通解为 $x=x_0+kb,y=y_0-ka$，其中 $k\in \mathrm{Z}$。

换句话说，$x,y$ 这两个解是具有周期性的。根据这个定理，我们知道一定有一个 $x\in [0,b)$，而对于方程 $ax+by=c$，则一定有一个 $x\in [0,\frac{b}{\gcd(a,b)})$，由此可以求一个不定方程的一个元的最小非负整数解，具体地，假设知道了一个解 $x_0$，则最小非负整数 $x=(x_0 \bmod m + m) \bmod m$，其中 $m=\frac{b}{\gcd(a,b)}$。

总结一下，求解二元线性不定方程 $ax+by=c$ 的流程如下：

求出 $ax+by=\gcd(a,b)$ 的一组解 $x',y'$，并根据 $\gcd(a,b)\mid c$ 判断方程有无解
令 $x=\frac{c}{\gcd(a,b)}x',y=\frac{c}{\gcd(a,b)}y'$，$x,y$ 为 $ax+by=c$ 的一组解
若需要求 $x$ 的最小非负整数解，则将 $x=(x_0 \bmod m + m) \bmod m$ 作为最终的答案，其中 $m=\frac{b}{\gcd(a,b)}$

线性同余方程

形式

$$ ax \equiv c \pmod{p} $$

形如这样的方程，就被称线性同余方程。

Burnside 引理 & Pólya 定理学习笔记

Sat, 12 Feb 2022 19:14:24 +0800

Burnside 引理和 Pólya 定理主要用于解决计算本质不同方案数的计数问题。

群论

基本定义

群可以看成是一个由集合和某个二元运算组成的二元组 $(S,\cdot)$，这里的 $\cdot$ 就代表一个二元运算，这个二元运算需要满足结合律、存在单位元和逆元。群有很多的种类，比如置换群、循环群、矩阵群等，其中置换群就是我们接下来要介绍的。

性质

若一个二元组 $(S,\cdot)$ 是群，则它满足以下性质：

封闭性：$\forall x,y\in S$，若 $z=x\cdot y$，则 $z\in S$
结合律：$\forall x,y,z\in S$，$(x\cdot y)\cdot z=x\cdot (y \cdot z)$
单位元：存在唯一一个元素 $e \in S$ 满足 $\forall x \in S$，$e\cdot x=x$
逆元：$\forall x \in S$，都可以找到唯一一个元素 $x^{-1}$ 满足 $x \cdot x^{-1} = e$，这个元素称为 $x$ 的逆元

举一个简单的例子，$(\mathrm{Z},+)$ 就是一个群，无论取哪两个元素进行加法运算，结果仍然是整数；加法满足结合律；单位元 $e = 0$；任意一个元素 $x$ 的逆元 $x^{-1} = -x$。

置换与置换群

置换的基本定义

顾名思义，置换群就是置换组成的群。置换可以看成一个有限集合到自身的双射，具体一点，假设有两个长度相同的集合 $p,q$（这里假设集合可以有序），则置换 $f$ 作用于 $p$ 就是生成一个新的集合 $p'$，满足 $p'_i=p\_{q_i}$。

欧拉函数 & 欧拉定理学习笔记

Thu, 10 Feb 2022 08:37:50 +0800

欧拉函数 $\varphi(n)$ 是一个重要的数论函数，它表示 $[1, n]$ 中与 $n$ 互质的数的个数。

欧拉函数性质

积性函数

积性函数的定义是：如果一个函数 $f(n)$ 满足 $\gcd(a,b)=1$ 时 $f(ab)=f(a)f(b)$，则 $f(n)$ 为积性函数。若无需 $\gcd(a,b)=1$ 就有 $f(ab)=f(a)f(b)$，则它为完全积性函数。

$$ n = \prod p_i^{c_i}\\\\ f(n) = \prod f(p_i^{c_i}) $$

一般来说，各种积性函数都是可以使用欧拉筛计算出来的，尽管方法各不相同。

$\varphi(n)$ 也是积性函数，证明就省略了。

计算公式

因为 $\varphi(n)$ 是积性函数，所以我们可以先研究 $\varphi(p^k)$ 怎么计算。$p^k$ 的约数有 $1, p, p^2, \dots, p^k$，而 $p^2, \dots, p^k$ 都含有 $p$ 这个约数，如果一个数不与 $p^k$ 互质，则一点有 $p$ 这个约数，我们只有知道小于等于 $p^k$ 的数中 $p$ 的倍数有多少即可。由此得出 $\varphi(n) = p^k - \frac{p^k}{p} = p^k - p^{k-1}=p^k\frac{p-1}{p}$。

根据 $\varphi(n)$ 的积性函数性质，得出对于任意的 $n$：

拉格朗日插值学习笔记

Mon, 07 Feb 2022 23:53:43 +0800

拉格朗日插值是众多插值算法中的一种，插值是通过一些点来求出过这些点的多项式函数的过程。

算法思想

构造函数

给出 $n + 1$ 个点 $(x_1,y_1),(x_2,y_2),\dots,(x_n,y_n),(x_{n+1},y_{n+1})$，要求出过这些点的 $n$ 次多项式函数（也称该函数的度为 $n$），先考虑对每个点构造一个函数，第 $i$ 个点的函数为 $f_i(x)$，满足：

$$ f_i(x) = \begin{cases} y_i & x = x_i\\\\ 0 & x \ne x_i \end{cases} \ (x\in \\{x_1,x_2,\dots,x_n,x_{n+1}\\}) $$

最后将这些函数组合为最终的函数：

$$ f(x) = \sum_{i=1}^{n+1}f_i(x) $$

接下来就是找到一种合适的形式来表示 $f_i(x)$ 的分段规定，可以让 $f_i(x)$ 含有一些因式，满足 $x=x_j,j\ne i$ 时，其值为 $0$，$x=x_i$ 时，其值为 $y_i$。显然下面这种满足条件：

$$ f_i(x) = y_i \prod_{i\ne j} \frac{x-x_j}{x_i-x_j} $$

所以最终的 $f(x)$ 的解析式为：

$$ f(x) = \sum_{i=1}^{n + 1} y_i \prod_{i\ne j} \frac{x-x_j}{x_i-x_j} $$

求单个函数值的时间复杂度是 $\Theta(n^2)$。

高斯消元学习笔记

Sun, 06 Feb 2022 16:06:35 +0800

高斯消元主要用于求解线性方程组的解，同时可以解决某些有后效性的 DP 问题，

算法思想

增广矩阵

为了更方便地求解方程组，可以将系数和常数项放入矩阵，接下来就可以用一些矩阵的操作来消元了。

比如有一个方程组如下：

$$ \begin{cases} 3x+2y+3z=10\\\\ 3x+y+4z=12\\\\ x+y+z=4 \end{cases} $$

我们可以这么用矩阵表示:

$$ \begin{bmatrix} 2 & 2 & 3 \\\\ 3 & 1 & 4 \\\\ 1 & 1 & 1 \end{bmatrix} \begin{bmatrix} 10 \\\\ 12 \\\\ 1 \end{bmatrix} $$

在理论分析和实现代码时，为了方便，通常把两个矩阵拼在一起，这个矩阵就是增广矩阵：

$$ \begin{bmatrix} 2 & 2 & 3 & 10 \\\\ 3 & 1 & 4 & 12 \\\\ 1 & 1 & 1 & 1 \end{bmatrix} $$

增广矩阵的第 $i$ 行代笔第 $i$ 个方程，第 $i$ 列表示第 $i$ 个未知数的系数或常数项，接下来用 $x_i$ 表示第 $i$ 个未知数。

Posts on StarryReverie 繁星筑梦 星缀夜空

现代 Linux 桌面会话管理

桌面会话的生命周期

传统方式

基于 systemd 的现代方式

为 EndeavourOS 构建 Linux 内核

环境准备

获取内核源码

配置编译环境

结合 SPPM 的 Path Tracing

光子映射系列算法

光子映射

光子的发射

光线追踪中的 Multiple Importance Sampling

Multiple Importance Sampling

Monte Carlo Path Tracing

无需宏为 Trait Objects 实现 Any

现有解决方案

downcast

as-any

anyerr 上下文中的类型体操

上下文的核心特性

基本结构和表示

上下文的元素

对 Rust 错误处理的思考和 anyerr

std 中的基础设施

错误与结果

错误类型的统一契约

错误的传播

统一 Linux GUI 框架主题和外观

配置组成

基本概念

GTK

用 NixOS 部署 Minecraft 服务器

准备工作

NixOS 安装

体验 Helix 编辑器

性能

编辑体验

整体思路

用 Rust 开发 Brainfuck 解释器

使用方法

实现原理

实现细节

代码优化

同质代码合并

Python 网络爬虫获取 SYZOJ AC 代码

实现目标分析

获取 Cookie

MultiGenerator 使用文档

概述

要求

安装

编译器支持

二分图匹配学习笔记

二分图

定义

判断

染色

匹配

匈牙利算法

交替路

增广路

莫比乌斯反演学习笔记

莫比乌斯函数

定义

性质

积性函数

与常数函数的卷积

同余方程学习笔记

二元线性不定方程

形式

求解

线性同余方程

形式

Burnside 引理 & Pólya 定理学习笔记

群论

基本定义

性质

置换与置换群

Posts on StarryReverie 繁星筑梦星缀夜空

`downcast`

`as-any`

`std` 中的基础设施