鉴于本人长期使用ai写代码，手搓代码能力堪比成年草履虫，遂听从好友建议刷leetcode,然leetcode太难了QAQ，刷起来十分缓慢。今日写完jb物理实验报告打开leetcode 热题 100刷一下链表，发现了一道简单的链表题，即160.相交链表，然后便十分兴奋地打开开始做

题目

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

题目数据保证整个链式结构中不存在环。

注意，函数返回结果后，链表必须保持其原始结构。

自定义评测：

评测系统 的输入如下（你设计的程序不适用此输入）：

intersectVa· - 相交的起始节点的值。如果不存在相交节点，这一值为 0

listA - 第一个链表listB - 第二个链表skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数skipB - 在 listB 中（从头节点开始）跳到交叉节点的节点数评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被视作正确答案

我的想法

在经过一番苦思冥想之后，我也是写出了和官方一样的答案

就是遍历一遍链表headA，并将其存入哈希表中，然后遍历链表headB,对于遍历的每一个节点，判断该节点是否在哈希表内。

代码如下

struct ListNode {      int val;      ListNode *next;      ListNode(int x) : val(x), next(NULL) {} };class Solution {public:    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {        unordered_set<ListNode *> visit;        ListNode *temp=headA;        while(temp!=nullptr)        {            visit.insert(temp);            temp=temp->next;        }        temp=headB;        while(temp!=nullptr)        {            if(visit.count(temp))            {                return temp;            }            temp=temp->next;        }        return nullptr;            }};

双指针解法

习惯性看题解，突然发现一个高赞题解

160.相交链表（双指针，清晰图解）

<(O0O)>

题解这样说：

设「第一个公共节点」为 node ，「链表 headA」的节点数量为 a ，「链表 headB」的节点数量为 b ，「两链表的公共尾部」的节点数量为 c ，则有：

头节点 headA 到 node 前，共有 a−c 个节点；头节点 headB 到 node 前，共有 b−c 个节点；

考虑构建两个节点指针 A​ , B 分别指向两链表头节点 headA , headB ，做如下操作：

指针 A 先遍历完链表 headA ，再开始遍历链表 headB ，当走到 node 时，共走步数为：a+(b−c)指针 B 先遍历完链表 headB ，再开始遍历链表 headA ，当走到 node 时，共走步数为：b+(a−c)如下式所示，此时指针 A , B 重合，并有两种情况：

a+(b−c)=b+(a−c)若两链表 有 公共尾部 (即 c>0 ) ：指针 A , B 同时指向「第一个公共节点」node 。若两链表 无 公共尾部 (即 c=0 ) ：指针 A , B 同时指向 null 。因此返回 A 即可。

代码：

class Solution {public:    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {        ListNode *A = headA, *B = headB;        while (A != B) {            A = A != nullptr ? A->next : headB;            B = B != nullptr ? B->next : headA;        }        return A;    }};

<(O0O)>

不知道是学得太少还是脑子是摆设，总之我是傻逼。

欸欸，还有很大进步空间……

小学期的大作业（为什么暑假要上课），再也不想写这种令人心情不愉快的作业了口牙！

本文结合小规模示例介绍以下内容：

• 最小二乘线性回归
• 决策树回归
• 决策树分类
• K-Means 聚类与 K-Means++ 初始化

图形界面使用 EasyX 完成。EasyX 在项目中主要负责绘制散点、曲线、聚类中心和处理按钮点击，本文不对其接口展开介绍。

回归、分类和聚类有什么区别

机器学习任务可以先从“有没有标签”和“要预测什么”两个角度理解。

回归和分类都需要已知答案来训练，因此属于监督学习；聚类没有预先提供类别，因此属于无监督学习。

最小二乘线性回归

线性回归希望用一条直线描述输入 $x$ 与目标值 $y$ 之间的关系：

$$y=ax+b$$

其中，$a$ 是斜率，$b$ 是截距。最小二乘法会选择一组 $a$ 和 $b$，使所有样本的残差平方和尽可能小：

$$\sum_{i=1}^{n}\left[y_i-(ax_i+b)\right]^2$$

平方可以避免正误差和负误差相互抵消，同时会让较大的误差受到更明显的惩罚。

斜率和截距可以直接计算：

$$a=\frac{n\sum x_i y_i-\sum x_i\sum y_i}{n\sum x_i^2-(\sum x_i)^2}$$

$$b=\frac{\sum y_i-a\sum x_i}{n}$$

一个简单例子

假设有三个样本：

可以得到：

$$\sum x_i=6,\quad \sum y_i=10,\quad\sum x_i y_i=23,\quad \sum x_i^2=14$$

代入公式：

$$a=\frac{3\times23-6\times10}{3\times14-6^2}=1.5$$

$$b=\frac{10-1.5\times6}{3}=\frac{1}{3}$$

最终拟合直线约为：

$$y=1.5x+0.33$$

当输入 $x=4$ 时，模型预测：

$$y=1.5\times4+0.33=6.33$$

C++ 实现思路

程序只需遍历一次样本，累计四个统计量，再代入公式即可：

void LeastSquares(const std::vector<DataPoint>& points,                  double& a, double& b) {    if (points.empty()) {        a = b = 0.0;        return;    }    double sumX = 0.0;    double sumY = 0.0;    double sumXY = 0.0;    double sumX2 = 0.0;    for (const auto& point : points) {        sumX += point.x;        sumY += point.y;        sumXY += point.x * point.y;        sumX2 += point.x * point.x;    }    const double n = static_cast<double>(points.size());    const double denominator = n * sumX2 - sumX * sumX;    if (std::abs(denominator) < 1e-12) {        a = b = 0.0;        return;    }    a = (n * sumXY - sumX * sumY) / denominator;    b = (sumY - a * sumX) / n;}

该算法的时间复杂度为 $O(n)$，额外空间复杂度为 $O(1)$。如果所有样本的 $x$ 都相同，公式分母为零，此时无法求出唯一斜率，需要单独处理。

决策树回归

线性回归只能拟合一条直线。当数据关系不是线性的，可以使用决策树回归。

决策树回归会不断选择阈值，把数据分成左右两部分。例如：

x <= 3.5 进入左子树x > 3.5 进入右子树

每个叶节点保存该区域内所有目标值的平均值。预测时，从根节点出发，根据输入与阈值的关系向左或向右移动，最后返回叶节点的均值。

如何选择划分位置

回归树通常用均方误差衡量一组数据是否集中：

$$\operatorname{MSE}(D)=\frac{1}{|D|}\sum_{i=1}^{|D|}(y_i-\bar y)^2$$

对一个候选阈值，需要计算左右子集的加权误差：

$$L=\frac{|D_L|}{|D|}\operatorname{MSE}(D_L)+\frac{|D_R|}{|D|}\operatorname{MSE}(D_R)$$

算法选择 $L$ 最小的阈值。

一个简单例子

假设数据如下：

候选阈值可以取相邻 $x$ 的中点，即 $1.5$、$2.5$ 和 $3.5$。

如果按 $x=2.5$ 划分：

• 左侧目标值为 $\lbrace 2,2\rbrace$，均值为 $2$，MSE 为 $0$；
• 右侧目标值为 $\lbrace 8,8\rbrace$，均值为 $8$，MSE 为 $0$；
• 加权误差为 $0$。

因此，$2.5$ 是一个非常合适的阈值。模型得到的规则是：

x <= 2.5 时预测 2x > 2.5 时预测 8

这也解释了为什么回归树的预测图像通常是阶梯形：同一个叶节点对应的输入区间会得到相同预测值。

前缀和优化

如果每测试一个阈值都重新遍历左右数据，计算开销会比较大。项目在排序后建立 $y$ 和 $y^2$ 的前缀和。

对任意区间，可以快速得到：

$$\operatorname{MSE}=E[y^2]-E[y]^2$$

这样每个候选切分位置的误差可以在 $O(1)$ 时间内计算。单个节点中，排序复杂度为 $O(n\log n)$，扫描候选阈值为 $O(n)$。

树深对结果的影响

树的最大深度决定模型复杂度：

• 深度较小，划分次数少，曲线简单，可能欠拟合；
• 深度较大，模型可以描述更多局部变化，但可能过拟合；
• 设置最小分裂样本数，可以避免节点在样本很少时继续划分。

项目同时绘制浅层树和较深的树，可以直观看到预测曲线从粗略到细致的变化。

决策树分类

决策树分类与决策树回归的整体结构相似，区别主要在于：

• 回归树预测连续数值，叶节点保存平均值；
• 分类树预测离散类别，叶节点保存多数类别；
• 回归树可以用 MSE 选择阈值；
• 分类树可以用信息增益选择阈值。

项目使用 Iris 鸢尾花数据集。每个样本包含四个特征：

• 花萼长度
• 花萼宽度
• 花瓣长度
• 花瓣宽度

目标类别包括山鸢尾、变色鸢尾和维吉尼亚鸢尾。

信息熵

信息熵用于描述类别的混乱程度：

$$H(D)=-\sum_{k=1}^{K}p_k\log_2p_k$$

其中，$p_k$ 是第 $k$ 类样本所占比例。

如果节点中的样本全部属于同一类，熵为 $0$；如果各类别数量接近，数据更加混乱，熵会更大。

一个简单例子

假设某节点中有四个样本：

A, A, B, B

两类比例都为 $\frac{1}{2}$，因此：

$$H(D)=-\frac{1}{2}\log_2\frac{1}{2}-\frac{1}{2}\log_2\frac{1}{2}=1$$

现在用某个特征进行划分，得到：

左侧：A, A右侧：B, B

左右子集的熵都是 $0$。信息增益为：

$$Gain(D)=H(D)-\frac{|D_L|}{|D|}H(D_L)-\frac{|D_R|}{|D|}H(D_R)=1$$

这次划分完全分开了两个类别，因此效果很好。

建树过程

分类树的训练过程可以概括为：

• 遍历每个特征；
• 对特征值排序并去重；
• 将相邻特征值的中点作为候选阈值；
• 计算每个候选划分的信息增益；
• 选择信息增益最大的特征和阈值；
• 对左右子集递归执行相同操作。

当样本已经属于同一类别、达到最大深度或找不到有效划分时停止递归，并将当前节点设置为叶节点。

如何评价分类结果

最常用的基础指标是准确率：

$$Accuracy=\frac{\text{预测正确的样本数}}{\text{样本总数}}\times100%$$

项目先使用固定随机种子打乱 Iris 数据，再按照 $8:2$ 划分训练集和测试集。固定随机种子可以让每次运行得到相同的数据划分，方便比较和复现实验结果。

训练准确率很高并不一定代表模型效果好，还需要观察测试准确率。如果训练准确率明显高于测试准确率，模型可能出现了过拟合。

K-Means 聚类

K-Means 用于在没有标签的情况下，将数据自动分成 $K$ 个簇。它希望同一簇内的样本彼此接近，不同簇的中心尽量分开。

算法的基本过程是：

• 选择 $K$ 个初始聚类中心；
• 将每个样本分配给距离最近的中心；
• 对每个簇中的样本求平均，得到新中心；
• 重复分配和更新，直到中心几乎不再移动。

二维空间中常用欧几里得距离：

$$d(\mathbf{x},\boldsymbol{\mu})=\sqrt{\sum_{j=1}^{m}(x_j-\mu_j)^2}$$

一个简单例子

假设有六个二维点：

(1, 1), (1, 2), (2, 1)(8, 8), (8, 9), (9, 8)

设置 $K=2$，初始中心选择 $(1,1)$ 和 $(8,8)$。

第一次分配后，前三个点更接近 $(1,1)$，后三个点更接近 $(8,8)$。随后计算两个簇的新中心：

$$\boldsymbol{\mu}_1=\left(\frac{1+1+2}{3},\frac{1+2+1}{3}\right)=(1.33,1.33)$$

$$\boldsymbol{\mu}_2=\left(\frac{8+8+9}{3},\frac{8+9+8}{3}\right)=(8.33,8.33)$$

再次分配时，各点所属簇不会改变，中心也保持稳定，算法便可以停止。

为什么需要 K-Means++

普通 K-Means 如果随机选出的初始中心过于接近，可能需要更多次迭代，也可能得到较差结果。

K-Means++ 的初始化方式是：

• 随机选择第一个中心；
• 计算每个样本到最近已有中心的距离平方；
• 按距离平方作为权重选择下一个中心；
• 重复以上过程，直到得到 $K$ 个中心。

距离现有中心越远的点，被选为新中心的概率越大。因此，初始中心通常会分布得更分散。

需要注意，这里是“按概率选择”，而不是每次直接选择最远点。这样可以降低异常值被固定选中的风险。

收敛与空簇处理

项目计算新旧中心之间的位移。如果最大位移不超过容差，就认为算法已经收敛：

$$\max_k\left\lVert\boldsymbol{\mu}_k^{new}-\boldsymbol{\mu}_k^{old}\right\rVert\leq\varepsilon$$

如果某个簇没有分配到任何样本，就无法计算平均值。一个简单的处理方式是暂时保留该簇原来的中心。也可以重新选择距离其他中心较远的样本作为中心。

K-Means 的局限也比较明显：需要提前指定 $K$，对初始中心敏感，更适合近似球状、大小接近的簇，而且容易受到异常值影响。

可视化如何帮助理解算法

图形界面不改变算法本身，但能把抽象结果转换为更直观的图像：

• 在线性回归中，同时绘制原始散点和拟合直线；
• 在决策树回归中，用阶梯线展示分段常数预测；
• 在决策树分类中，用不同颜色表示不同类别；
• 在 K-Means 中，用颜色表示聚类标签，用特殊标记显示中心。

从数据坐标转换到屏幕坐标时，横坐标可以按比例映射：

$$x_s=x_{left}+\frac{x-x_{min}}{x_{max}-x_{min}}(x_{right}-x_{left})$$

由于屏幕纵坐标通常向下增大，纵坐标映射需要反向：

$$y_s=y_{bottom}-\frac{y-y_{min}}{y_{max}-y_{min}}(y_{bottom}-y_{top})$$

项目使用 EasyX 完成这些基础绘制和交互。对于理解算法而言，重点仍然是数据如何训练、模型如何预测以及结果为什么呈现出当前形态。

几种算法的对比

线性回归结构简单、计算速度快，但只能描述近似线性关系。决策树能够表达非线性规则，解释也比较直观，但树过深时容易过拟合。K-Means 不需要标签，实现简单，不过需要提前指定簇数，并且会受到数据分布和初始中心影响。

总结

通过手动实现这些基础算法，可以更清楚地看到机器学习的核心过程：

• 回归是在寻找输入到连续数值的映射；
• 分类是在学习区分不同类别的规则；
• 聚类是在没有标签时发现数据内部的分组；
• 损失函数或评价指标决定了算法如何选择更好的参数；
• 停止条件和边界处理决定了程序是否可靠。

相比只调用现成接口，小规模示例更适合观察每一步计算。把算法结果绘制出来后，拟合直线、树的阶梯预测和聚类中心都会变得容易理解，这也是该 C++ 可视化项目最主要的学习价值。

最近我复现了时间序列预测领域的一篇经典论文：

Are Transformers Effective for Time Series Forecasting?
AAAI 2023
对应代码仓库：LTSF-Linear

DLinear这篇论文提出了一个很有意思的问题：

在长序列时间序列预测任务中，复杂的 Transformer 模型真的一定比简单线性模型好吗？

论文的结论是：在很多长序列预测 benchmark 上，简单的线性模型反而可以取得非常有竞争力的结果，甚至超过一些 Transformer-based 方法。

这篇博客主要记录我本次复现实验的过程、结果和阶段性分析。相比单纯“跑通代码”，我更希望把这次复现整理成一个比较规范的实验过程，包括：

1. 跑哪些模型；
2. 跑哪些数据集；
3. 如何整理 MSE/MAE；
4. 如何比较 Linear 和 DLinear；
5. 如何分析多次运行稳定性；
6. 如何结合可视化结果进行解释；
7. 当前复现还缺什么。

论文和模型简介

LTSF-Linear 论文主要讨论的是 Long-term Time Series Forecasting，也就是长序列时间序列预测任务。

论文中提出了三个非常简单的线性模型：

其中，DLinear 是本文最核心的模型之一。

DLinear 的基本思想是：

原始序列 = 趋势项 trend + 季节/残差项 seasonal

然后模型分别对趋势项和季节项进行线性预测，最后将两部分结果相加得到最终预测。

这看起来很简单，但它在很多长预测任务上表现不错。

实验环境与结果来源

本次实验主要在 WSL 环境中运行，然后将结果同步到 Windows 上整理。

实验结果主要来自以下文件：

logs/LongForecasting/*.logresult.txttest_results/

其中：

由于 result.txt 中可能出现重复记录，所以最终分析时我主要以：

logs/LongForecasting/*.log

为准。

当前完成的实验

本阶段主要完成了以下实验。

ETTh1 数据集

在 ETTh1 数据集上，我完成了：

也就是说，ETTh1 上已经可以比较：

Linear vs DLinear

同时，DLinear 也有多次运行结果，可以做初步稳定性分析。

ETTm1 数据集

在 ETTm1 数据集上，我完成了：

这个实验主要用于观察 DLinear 在另一个 ETT 数据集上的预测长度变化趋势。

ETTh1：Linear 与 DLinear 对比

首先看 ETTh1 上 Linear 和 DLinear 的 MSE 对比。

这里 DLinear 使用多次运行的平均结果。

再看 MAE：

从结果可以看出：

1. 在短预测长度 96 和 192 下，Linear 和 DLinear 的表现非常接近；
2. 在更长预测长度 336 和 720 下，DLinear 开始明显优于 Linear；
3. 尤其是 pred_len=720 时，DLinear 相比 Linear 的 MSE 下降约 18.60%。

这个结果说明：

DLinear 的趋势/季节分解机制在长预测任务中更有优势。

这也符合论文中的直觉：当预测长度变长时，显式建模趋势和周期结构会更重要。

ETTh1：DLinear 多次运行稳定性分析

为了避免只看单次实验结果，我对 ETTh1 上的 DLinear 结果进行了多次运行整理。

当前有三组结果：

default/rerunseed2025seed2026

其中 default/rerun 是一次未单独标注 seed 的重跑记录，seed2025 和 seed2026 是两次带 seed 标记的实验。

MSE 结果

这里的 Std 是标准差，用于衡量多次运行结果的波动程度。

如何理解标准差

标准差越小，说明多次运行结果越接近，模型越稳定。

标准差越大，说明不同运行之间差异越大，模型对随机性或训练过程更敏感。

从上表可以看到：

• pred_len=96 的结果比较稳定；
• pred_len=336 的结果也相对稳定；
• pred_len=720 的波动较大；
• pred_len=192 中 default/rerun 明显高于 seed2025/2026，说明也存在一定训练波动。

这说明：

长预测任务本身更困难，模型结果更容易受到随机初始化、训练过程和 early stopping 的影响。

如果后续要写得更严谨，应该继续补充更多随机种子，例如：

seed2027seed2028

然后报告：

mean ± std

ETTm1：DLinear 预测长度趋势分析

接下来观察 ETTm1 上 DLinear 的结果。

这个结果非常符合长序列预测任务的一般规律：

预测长度越长，误差越大。

从 96 到 720：

• MSE 从 0.3012 增加到 0.4266；
• MAE 从 0.3446 增加到 0.4227。

这说明实验结果整体合理，没有出现明显异常。

可视化结果怎么看

除了 MSE 和 MAE，项目还会在 test_results/ 中保存预测曲线 PDF。

可视化图通常包含：

历史输入 + 真实未来曲线 + 模型预测曲线

看这些图时，我主要从以下几个角度分析。

预测曲线是否跟随真实曲线趋势

首先看预测曲线的大方向是否和真实曲线一致。

比如：

• 真实曲线整体上升，预测曲线是否也上升；
• 真实曲线整体下降，预测曲线是否也下降；
• 真实曲线有周期性波动，预测曲线是否也有类似波动。

如果趋势能跟上，说明模型捕捉到了主要变化规律。

如果趋势跟不上，说明模型可能只学到了平均水平，而没有学到时间变化结构。

长预测下是否出现过度平滑

长预测时，模型经常会出现一种现象：

预测曲线越来越平，波动越来越小。

也就是说：

• 真实曲线有明显峰谷；
• 但预测曲线像一条比较平滑的线；
• 模型预测不到尖峰、突变、快速下降或快速上升。

这说明模型对长期未来的不确定性处理不够好。

这个现象尤其应该在：

pred_len=720

中观察。

Linear 和 DLinear 在长预测下是否有差异

可以对比同一个数据集、同一个预测长度下的图。

例如：

ETTh1_336_720_Linear.../0.pdfETTh1_336_720_DLinear.../0.pdf

主要看：

1. 哪个模型预测曲线更接近真实曲线；
2. 哪个模型趋势更准；
3. 哪个模型更能保留波动；
4. 哪个模型在预测后半段偏移更严重。

如果 DLinear 图上更贴近真实曲线，同时 MSE/MAE 也更低，就可以说：

DLinear 不仅指标更好，可视化上也能更好地跟随长期趋势。

是否存在峰值预测失败的样本

峰值预测失败指的是：

真实曲线突然升高或降低，但预测曲线没有跟上。

常见表现包括：

• 真实值有尖峰，预测没有；
• 真实值有突然下降，预测还很平；
• 预测曲线滞后于真实曲线；
• 模型只预测出平均趋势，忽略极端变化。

这类图很适合放进汇报，因为它能说明：

模型虽然整体 MSE/MAE 不错，但对突发变化仍然不足。

这就是失败案例分析。

当前结果说明了什么

综合数值结果和可视化分析，本阶段可以得到几个结论。

简单 Linear 已经是很强的 baseline

ETTh1 上，在 pred_len=96 和 192 时，Linear 和 DLinear 的结果非常接近，甚至 Linear 略优。

这说明：

在一些短预测任务中，简单线性映射已经能捕捉主要模式。

这也是 LTSF-Linear 论文想强调的核心观点之一：不要盲目认为复杂模型一定更好。

DLinear 在长预测上更有优势

当预测长度增加到 336 和 720 时，DLinear 明显优于 Linear。

尤其在 pred_len=720 上：

Linear MSE = 0.6250DLinear Mean MSE = 0.5087

DLinear 的优势很明显。

这说明：

趋势/季节分解结构更适合长预测任务。

长预测任务稳定性更差

DLinear 在 pred_len=720 上的多次运行结果波动较大：

0.5042 / 0.5393 / 0.4827

这说明：

长预测任务不仅误差更大，而且结果稳定性也更差。

因此后续如果要做更规范的科研实验，需要更多 seed。

ETTm1 结果趋势合理

ETTm1 上 DLinear 的误差随预测长度增加而单调上升：

96 < 192 < 336 < 720

这符合长序列预测任务的基本规律，说明实验结果整体可信。

当前复现还缺什么

虽然目前已经完成了阶段性复现，但还不能说完整复现论文。

当前还缺：

1. NLinear 实验
   LTSF-Linear 包含 Linear、NLinear、DLinear 三个模型，目前还缺 NLinear。

2. Transformer baseline
   论文核心问题是“Transformer 是否适合长序列预测”，所以后续需要补 Transformer 或 Autoformer。

3. 更多数据集
   当前主要有 ETTh1 和 ETTm1，后续可以补 Weather、Exchange 等。

4. 更多随机种子
   尤其是 DLinear 在 pred_len=720 上波动较大，需要更多 seed 验证稳定性。

5. 更系统的可视化分析
   后续可以从 PDF 中挑选成功案例和失败案例，形成更完整的图表分析。

下一步计划

如果继续推进，我认为优先级应该是：

1. 补 ETTh1 + NLinear + pred_len=96/192/336/7202. 补 ETTh1 + DLinear + pred_len=720 + 更多 seed3. 补 Transformer 或 Autoformer baseline4. 整理典型可视化图5. 扩展到 Weather / Exchange 数据集

这样可以从“代码复现”进一步升级为“系统实验复现”。

总结

本次复现实验完成了 LTSF-Linear 的阶段性实验整理，主要包括：

• ETTh1 上 Linear 和 DLinear 的对比；
• ETTh1 上 DLinear 的多次运行稳定性分析；
• ETTm1 上 DLinear 的预测长度趋势分析；
• 基于 test_results 的可视化分析思路。

目前最重要的结论是：

在短预测长度下，Linear 和 DLinear 表现接近；但随着预测长度变长，DLinear 的优势逐渐明显，尤其在 pred_len=720 上明显优于 Linear。这说明 DLinear 的趋势/季节分解结构对长预测任务有帮助。

同时也观察到：

长预测任务下模型结果波动更大，因此后续需要更多随机种子和更多 baseline 来增强实验可信度。

这次复现让我认识到，科研中的“复现”不只是把代码跑通，更重要的是把结果整理成表格、做对比、分析趋势、解释可视化现象，并明确下一步还缺什么。

本文将深入解析一个基于 C 语言实现的图像旋转算法，核心函数为 Image *Rotation(Image *image)。该算法以灰度或彩色图像为输入，实现了逆时针 45 度旋转，并采用双线性插值保证旋转后图像的平滑性。代码结构清晰，适合学习图像处理基础与算法实现。

代码结构

包含如下核心部分：

• 图像结构体与操作函数（通过 proto.h 引入）
• 图像读取与保存：ReadPNMImage、SavePNMImage
• 图像旋转：Rotation
• 新图像创建：CreateNewImage
• 主流程：main、TestReadImage

核心函数：Image *Rotation(Image *image)

算法流程

1. 新图像创建
   调用 CreateNewImage，输出图像尺寸为原图的 1.5 倍，便于旋转后完整显示。

2. 中心坐标计算
   原图与输出图像分别计算中心点坐标，用于旋转变换。

3. 旋转参数计算
   旋转角度为 -45°（逆时针），计算对应的正弦、余弦值。

4. 逆向映射
   对输出图像每个像素，计算其对应原图位置（逆向旋转），避免空洞。

5. 双线性插值
   若映射点在原图范围内，采用双线性插值计算像素值，提升旋转后图像质量。

6. 边界处理
   映射点超出原图范围时，像素值设为 0（黑色）。

关键代码片段

double rad = -45.0 * 3.1415926 / 180.0;double cosA = cos(rad);double sinA = sin(rad);int inCx = inW / 2;int inCy = inH / 2;int outCx = outW / 2;int outCy = outH / 2;for(int y = 0; y < outH; y++) {    for(int x = 0; x < outW; x++) {        double tx = x - outCx;        double ty = y - outCy;        double srcX = tx * cosA - ty * sinA + inCx;        double srcY = tx * sinA + ty * cosA + inCy;        if(srcX >= 0 && srcX < inW - 1 && srcY >= 0 && srcY < inH - 1) {            // 双线性插值            int x1 = (int)floor(srcX);            int y1 = (int)floor(srcY);            int x2 = x1 + 1;            int y2 = y1 + 1;            double dx = srcX - x1;            double dy = srcY - y1;            int p1 = in[y1 * inW + x1];            int p2 = in[y1 * inW + x2];            int p3 = in[y2 * inW + x1];            int p4 = in[y2 * inW + x2];            double value = p1 * (1 - dx) * (1 - dy) +                           p2 * dx * (1 - dy) +                           p3 * (1 - dx) * dy +                           p4 * dx * dy;            out[y * outW + x] = (unsigned char)value;        } else {            out[y * outW + x] = 0;        }    }}

算法特点

• 逆向映射：避免旋转后像素空洞，保证每个输出像素都能找到原图对应点。
• 双线性插值：提升旋转后图像质量，减少锯齿和模糊。
• 中心化处理：以图像中心为旋转轴，旋转效果自然。

主流程与使用方法

主函数 main 调用 TestReadImage，流程如下：

1. 读取原图像（如 lena.pgm）
2. 调用 Rotation 进行旋转
3. 保存旋转后图像为 rotation.pgm

int main(int argc,char **argv){    const char *file_in="lena.pgm";    const char *file_out="";    TestReadImage(file_in,file_out);    return 0;}int TestReadImage(const char *file_in, const char *file_out){    Image *image;    Image  *rotation;    image = ReadPNMImage(file_in);    rotation = Rotation(image);    SavePNMImage(rotation, (char*)"rotation.pgm");    return(0);}

总结

本文以 Image *Rotation(Image *image) 为核心，解析了 C 语言实现的图像旋转算法。该算法采用逆向映射与双线性插值，保证旋转后图像的完整性与质量。适合图像处理初学者深入理解旋转算法原理与实现细节。

参考

• 数字图像处理基础
• 双线性插值算法
• 源代码：main.c

图像滤波本质上是：

利用某个像素周围邻域的信息，对当前像素进行重新计算。

常见用途：

• 去除噪声
• 平滑图像
• 提高图像质量
• 为后续边缘检测做准备

项目简介

1. 读取一个 PGM 灰度图像（P5 格式，如 lena.pgm）, 得到一个二维像素矩阵（实际存在一维数组里）。
2. 对图像分别应用 3×3 均值滤波 和 3×3 中值滤波。
3. 将滤波后的图像保存为新的 PGM 文件（lena_avg.pgm 和 lena_med.pgm）。

整个代码不依赖任何第三方图像库，完全使用标准 C 语言和自定义的 Image 结构体。

虽然整个项目包含多个函数，但真正的核心，其实是：AverageImage()和MedianImage

程序执行流程如下：

读取图像   ↓均值滤波   ↓中值滤波   ↓保存结果图像

对应主函数：

int main(int argc,char **argv){    const char *file_in= "lena.pgm";    const char *file_out= "";    TestReadImage(file_in,file_out);    return 0;}

真正的处理在TestReadImage中完成

int TestReadImage(const char *file_in,const char *file_out){    Image *image;    Image *outimage_average;    Image *outimage_median;    image=ReadPNMImage(file_in);        //读取图像    outimage_average=AverageImage(image) ; //均值滤波    outimage_median=MedianImage(image);   //中值滤波    SavePNMImage(outimage_average,"lena_avg.pgm");    SavePNMImage(outimage_median,"lena_med.pgm");    return 0;}

程序整体结构

整个项目中主要有几个函数：

void SavePNMImage(Image *,char *);Image *AverageImage(Image *);Image *MedianImage(Image *);Image *ReadPNMImage(char *);Image *CreateNewImage(Image *, char *comment);

• ReadPNMImage()负责把图像读取到内存。
• CreateNewImage()负责创建输出图像，避免修改原图。outimage->data可以单独保存结果，算法独立，即使得多种滤波可同时进行，方便对比效果，避免污染数据。
• SavePNMImage()负责将结果保存为新的 PGM 文件。

这些函数主要属于：图像输入输出模块

图像的储存

程序中的图像数据：unsigned char *data实际上是一维数组，但图像本质上是二维的，因此需要进行二维转一维：index = width * i + j

均值滤波（Average Filter）

算法

• 对图像中每个像素（除边缘外），用自身和周围8个像素（共 9 个）的平均值替换原像素值。
• 公式$$ Pixel(i,j)=\frac{1}{9}\sum_{x=1}^{1}\sum_{y=-1}^{1}origina(i+x,i+y) $$
• 边缘像素直接忽略（不处理）。

结果：对lena.pgm处理后，图像变平滑（模糊）。

特点

• 优点：实现简单，计算速度快，能有效抑制高斯噪声。
• 缺点：在去噪的同时会模糊图像的边缘和细节，使图像变得“朦胧”。

源代码

Image *AverageImage(Image *image){    unsigned char *tempin,*tempout;    Image *outimage;    int size;    outimage=CreateNewImage(image,(char*)"#testing Average Filter");        //保存滤波结果，不破坏原图    tempin=image->data;    tempout=outimage->data;    if(image->Type==GRAY)size=image->Width * image->Height;    else if(image->Type==COLOR)size=image->Width * image->Height * 3;    for(int i=1;i<image->Height-1;i++){        for(int j=1;j<image->Width-1;j++){            int sum=0;            for(int x=-1;x<=1;x++){                for(int y=-1;y<=1;y++){                    sum+=tempin[(image->Width)*(i+x)+(j+y)];                }            }            tempout[(image->Width)*i+j]=sum/9;        }    }    return(outimage);}

外层循环

for(int i=1;i<image->Height-1;i++)for(int j=1;j<image->Width-1;j++)

遍历图像中的每一个像素。

之所以从 1 开始，到 Height-1 结束：是为了避免访问越界。因为需要访问：

(i-1,j-1) (i+1,j+1)

边界像素无法完整获得 3×3 邻域。

均值滤波的问题

均值滤波虽然简单，但有一个非常明显的问题：会让图像变模糊

因为：它会把周围像素“平均化”，边缘细节会丢失。

中值滤波（Median Filter）

算法

• 与均值滤波类似，但替换为9个像素的中位数（中间值）。
• 实现方法：将 9 个像素值存入数组，用插入排序排序后取 array[4]作为中值。

特点

• 优点：对 椒盐噪声（随机出现的黑/白点）抑制效果极佳，同时能够 较好地保留边缘信息 。
• 缺点：对高斯噪声的去除能力不如均值滤波，且排序算法会增加计算量。

源代码

Image *MedianImage(Image *image){    unsigned char *tempin,*tempout,arr[9];    Image *outimage;    int size;    outimage=CreateNewImage(image,(char*)"#testing Average Filter");    tempin=image->data;    tempout=outimage->data;    if(image->Type == GRAY) size = image->Width * image->Height;    else if(image->Type == COLOR) size = image->Width * image->Height * 3;    for(int i=1;i<image->Height-1;i++){        for(int j=1;j<image->Width-1;j++){            int num=0;            for(int x=-1;x<=1;x++){                for(int y=-1;y<=1;y++){                    arr[num++]=tempin[(image->Width)*(i+x)+j+y];                }            }            //插值排序            for(int m=1;m<9;m++){                int currNum=arr[m];                int n=m;                while(n>=1&&arr[n-1]>currNum){                    arr[n]=arr[n-1];                    n--;                }                arr[n]=currNum;            }            tempout[(image->Width)*i+j]=arr[4];        }    }    return(outimage);}

插入排序

其核心思想是：每次取一个元素，插入到前面已经有序的序列中。

实验对比

我们使用标准的 Lena 灰度图像进行测试。因为下载到的是bpm和jpg格式，这里为了方便起见，我用ffmpeg将其转化成512×512的PGM格式

ffmpeg -i lena.bmp lena.pgm

分别应用均值滤波和中值滤波，得到以下结果。

原始图像：

均值滤波效果：

中值滤波效果：

总结

本文基于 C 语言实现了：

• PGM 图像读取
• 均值滤波
• 中值滤波
• 图像保存

后续还会有图像旋转（以参数标识旋转角度）以及X方向连续数字、Y方向连续数字、对角线方向连续数字等模式等对图像的几何变换处理。

在学习算法的过程中，广度优先搜索（BFS）是一个非常经典且实用的算法。今天我想分享一个使用C语言实现迷宫最短路径的例子，并附上完整代码。最好用循环队列，防止假溢出，这里先使用普通数组队列。

问题描述

假设我们有一个 n x n 的迷宫矩阵，矩阵中的 1 表示可走的路径，0 表示障碍。我们希望从起点 (0,0) 出发，找到终点 (n-1,n-1) 的最短路径，并打印出来。

示例迷宫：

1 0 0 0 01 1 1 0 00 0 1 0 01 1 1 1 00 0 0 1 1

BFS算法思路

BFS 的核心思想是 一层一层地扩展搜索，这样可以保证第一次到达终点时路径长度最短。实现步骤如下：

• 使用队列存储待访问的节点。
• 用visited数组标记访问过的节点。
• 使用parent数组记录每个节点的前驱节点。
• 当到达终点时，通过回溯parent数组打印完整路径。

代码结构拆解

我们的代码可以拆解成以下几个模块：

1. 全局变量和结构体定义
2. BFS函数实现
3. 路径回溯
4. 主函数初始化与调用

全局变量和结构体定义

#define MAX_VERTICES 100int visited[MAX_VERTICES];   // 标记节点是否已访问int queue[MAX_VERTICES];     // BFS队列int parent[MAX_VERTICES];    // 记录每个节点的前驱节点typedef struct {    int x, y;} Point; // 坐标结构体

• visited防止重复访问节点，保证BFS正确性。
• queue保存带访问节点、保证BFS的层次顺序。
• parent用于回溯路径。
• Point结构体让代码更清晰。

BFS函数实现

BFS核心代码如下

void BFS(int maze[][MAX_VERTICES],int n,Point start,Point end){    int front =0;   //    int rear =0;    queue[rear++]=start.x*n+start.y;    visited[start.x*n+start.y]=1;    parent[start.x*n+start.y]=-1;    while(front<rear){        int current=queue[front++];        if(current/n == end.x && current%n == end.y){            printf("Successfully find the road!\n");

节点编码为 index = x * n + y，方便存储在一维数组。

回溯路径

int path[MAX_VERTICES];            int step=0;            int temp = current;            while (temp != -1) {                path[step++] = temp;                temp = parent[temp];            }            printf("The road is:\n");            for(int i=step-1;i>=0;i--){                int px=path[i]/n;                int py=path[i]%n;                printf("(%d,%d)",px,py);                if(i>0)printf("->");            }            printf("\n");            return;        }

• 从终点开始，沿parent数组回溯到起点。
• 存储到path数组。
• 逆序打印

扩展邻居节点

int moves[4][2]={            {-1,0},            {1,0},            {0,-1},            {0,1}};        for(int i=0;i<4;i++){            int newX=current/n+moves[i][0];            int newY=current%n+moves[i][1];            if(newX>=0&&newY>=0&&newX<n&&newY<n&&!visited[newX*n+newY]&&maze[newX][newY]==0){                if(rear >= MAX_VERTICES){                    printf("Queue Overflow!\n");                    return;                }                queue[rear++]=newX*n+newY;                visited[newX*n+newY]=1;                parent[newX*n+newY] = current;            }        }

主函数

int main(){    int n=6;    int maze[MAX_VERTICES][MAX_VERTICES]={    {0, 1, 0, 0, 0, 0},    {0, 1, 0, 1, 1, 0},    {0, 0, 0, 1, 0, 0},    {1, 1, 0, 1, 0, 1},    {0, 0, 0, 0, 0, 0},    {0, 1, 1, 1, 1, 0},    };for(int i=0;i<n;i++){    for(int j=0;j<n;j++){        visited[i*n+j]=0;        parent[i*n+j] = -1;    }}BFS(maze,n,(Point){0,0},(Point){5,5});return 0;}

运行结果

Successfully find the road!The road is:(0,0)->(1,0)->(2,0)->(2,1)->(2,2)->(3,2)->(4,2)->(4,3)->(4,4)->(4,5)->(5,5)Running time:1.000 ms

总结

• BFS 是按层搜索，保证第一次到达终点就是最短路径
• queue 保证访问顺序，visited 防止重复访问。
• parent 用于路径回溯，是打印路径的关键。
• 节点编码 (x*n+y) 方便存储和回溯。
• 可以扩展八方向、障碍更多、迷宫更大，或者改成权重图使用 Dijkstra。

之后可能更新更多的东西（挖坑中）敬请期待……

封面、目录、每个方法（算法原理说明、代码、运行结果截图）以及收获体会。

打印运行时间

算法原理说明

栈

栈(stack) 是一种特殊的线性表,是一种只允许在表的一端进行插入或删除操作的线性表。表中允许进行插入和删除操作的一端称为栈顶,最下面的那一端称为栈底。栈顶是动态的,它由一个称为栈顶指针的位置指示器指示。当栈中没有数据元素时,称为空栈。

栈的主要特点是 “后进先出” ,即后进栈的元素先处理。因此栈又称为后进先出(LastInFirstOut,LIFO)表。

迷宫探路问题中的若干可通位置形成的通路构成了栈,对栈的运算主要有以下几种。

• 初始化栈initStack(&s)
• 入栈push(&s,Box)
• 出栈pop(&s)
• 读栈顶元素peek(&s)
• 判断栈满isFull
• 判断栈空isEmpty

DFS

深度优先搜索（DFS） 是一种用于遍历或搜索树或图的算法。在迷宫生成的上下文中，深度优先搜索可以用来探索从起点到终点的路径。其思想是从起点开始，向一个方向尽可能深入地走，直到无法继续为止（即到达死胡同），然后回溯到上一个岔路口，继续探索其他路径，直到所有的路径都已遍历。

深度优先搜索迷宫生成的特点是相对简单易实现，并且生成的迷宫通常具有长而窄的路径特征，适合于需要用户深思熟虑的迷宫游戏。

代码

迷宫的打印

先不谈具体算法，首先我们需要实现迷宫的物理存储，可以采用二维数组来存储一个二维平面地图，使用0表示是通路，1表示是墙这里我们先自己创建一个，之后再用递归等算法自动创建迷宫。

int maze[ROW+2][COL+2]={    {1,1,1,1,1,1,1,1},    {1,0, 1, 0, 0, 0, 0,1},    {1,0, 1, 0, 1, 1, 0,1},    {1,0, 0, 0, 1, 0, 0,1},    {1,1, 1, 0, 1, 0, 1,1},    {1,0, 0, 0, 0, 0, 0,1},    {1,0, 1, 1, 1, 1, 0,1},    {1,1,1,1,1,1,1,1}};

这里四周多出一圈1，是为了在每一个方向上都有四个方向可以选。

定义栈的结构

我们用一个结构体来封装栈：

#define MAX_STACK 100typedef struct {    int x;          // 行坐标    int y;          // 列坐标    int dir;        // 方向（0~3 或 -1 表示未尝试）} Box;              // 栈中存放的元素typedef struct {    Box data[MAX_STACK];    int top;        // 栈顶索引，-1 表示空栈} Stack;

栈的基本操作

//初始化栈void initStack(Stack *s){    s->top=-1;}//判空bool isEmpty(Stack *s){    return s->top==-1;}//判满bool isFull(Stack *s){    return s->top==MAX_STACK-1;}//压入void push(Stack *s,Box b){    if(!isFull(s))    {        s->top++;        s->data[s->top]=b;    }}//弹出并返回Box pop(Stack *s){    Box empty={-1,-1,-1};    if(isEmpty(s))return empty;    Box b=s->data[s->top];    s->top--;    return b;}

方向数组

用结构体存储方向向量，配合循环尝试四个方向：

typedef struct {    int incX;   // 行增量    int incY;   // 列增量} Direction;Direction direct[4] = {    {-1, 0},   // 上    { 1, 0},   // 下    { 0, -1},  // 左    { 0, 1}    // 右};

DFS寻路逻辑

• 将起点入栈，并标记为已访问（maze[x][y] = -1）。
• 循环直到栈空：
  1. 弹出栈顶元素作为当前考察点 (x, y)。
  2. 从 di 记录的下一个方向开始尝试（di = cur.di + 1）。
  3. 依次尝试四个方向：
     • 计算邻居坐标 (nx, ny)。
     • 若邻居可通（maze[nx][ny] == 0）：
       • 将当前点（更新方向索引为 di）压回栈，以便以后回溯。
       • 移动到邻居点，标记已访问。
       • 将邻居点（方向索引 -1）压入栈。
       • 若邻居是终点，则成功返回。
       • 否则跳出方向循环，下一次循环直接处理栈顶（邻居点）。
     • 若不可通，则 di++ 继续尝试下一个方向。
  4. 如果四个方向都试完仍无通路，则当前点被丢弃（未重新压回），自然实现回溯

代码：

//寻路函数bool findPath(int maze[ROW+2][COL+2],Direction direct[],Stack *s){    Box temp;    int x,y,di;    int line,col;//下一步的坐标    maze[1][1]=-1;    temp=(Box){1,1,-1};    push(s,temp);    while(!isEmpty(s))    {        temp=pop(s);        x=temp.x;        y=temp.y;        di=temp.di+1;        while(di<4)        {            line=x+direct[di].incX;            col=y+direct[di].incY;            if(maze[line][col]==0)            {                temp=(Box){x,y,di};                push(s,temp);                x=line;                y=col;                maze[x][y]=-1;                if(x==ROW&&y==COL){                    push(s,(Box){x,y,-1});                    return true;                }else {                        di=0;                    }            }else{                di++;            }        }    }     return false;    }

完整代码示例

//迷宫问题DFS#include<stdio.h>#include<stdbool.h>#include<time.h>#define ROW 6#define COL 6#define MAX_STACK 100//方向结构体，用于存储每个方向移动的值typedef struct{    int incX;    int incY;}Direction;//当前位置typedef struct{    int x;    int y;    int di;}Box;typedef struct{    Box data[MAX_STACK];    int top;                //固定数组+移动的top=动态的栈顶指针}Stack;//栈的基本操作//初始化栈void initStack(Stack *s){    s->top=-1;}//判空bool isEmpty(Stack *s){    return s->top==-1;}//判满bool isFull(Stack *s){    return s->top==MAX_STACK-1;}//压入void push(Stack *s,Box b){    if(!isFull(s))    {        s->top++;        s->data[s->top]=b;    }}//弹出并返回Box pop(Stack *s){    Box empty={-1,-1,-1};    if(isEmpty(s))return empty;    Box b=s->data[s->top];    s->top--;    return b;}//寻路函数bool findPath(int maze[ROW+2][COL+2],Direction direct[],Stack *s){    Box temp;    int x,y,di;    int line,col;//下一步的坐标    maze[1][1]=-1;    temp=(Box){1,1,-1};    push(s,temp);    while(!isEmpty(s))    {        temp=pop(s);        x=temp.x;        y=temp.y;        di=temp.di+1;        while(di<4)        {            line=x+direct[di].incX;            col=y+direct[di].incY;            if(maze[line][col]==0)            {                temp=(Box){x,y,di};                push(s,temp);                x=line;                y=col;                maze[x][y]=-1;                if(x==ROW&&y==COL){                    push(s,(Box){x,y,-1});                    return true;                }else {                        di=0;                    }            }else{                di++;            }        }    }     return false;    }   //打印输出路径void printPath(Stack *s){    if(isEmpty(s)){        printf("The path is empty.\n");        return;    }    printf("Path found (from start to end):\n");    for(int i=0;i<=s->top;i++)    {        printf("(%d,%d)",s->data[i].x,s->data[i].y);        if(i<s->top)printf("->");    }    printf("\n");}int main(){    clock_t start, end;    double cpu_time_used;    start = clock();   // 记录开始时刻    int maze[ROW+2][COL+2]={    {1,1,1,1,1,1,1,1},    {1,0, 1, 0, 0, 0, 0,1},    {1,0, 1, 0, 1, 1, 0,1},    {1,0, 0, 0, 1, 0, 0,1},    {1,1, 1, 0, 1, 0, 1,1},    {1,0, 0, 0, 0, 0, 0,1},    {1,0, 1, 1, 1, 1, 0,1},    {1,1,1,1,1,1,1,1}};Direction direct[4]={    {-1,0}, //上    {1,0},  //下    {0,-1}, //左    {0,1},  //右};Stack stack;initStack(&stack);if(findPath(maze,direct,&stack)){    printPath(&stack);}else{    printf("Path not found!\n");}end = clock();     // 记录结束时刻    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;    printf("The running time is: %f s\n", cpu_time_used);    return 0;}

运行结果与复杂度

时间复杂度 ：每个格子最多被访问一次，O(M*N)。

空间复杂度 ：栈对多存储一条路径上的格子，O(M+N)。

对于6*6迷宫，程序 瞬间 输出路径，例如：

Path found (from start to end):(1,1)->(2,1)->(3,1)->(3,2)->(3,3)->(2,3)->(1,3)->(1,4)->(1,5)->(1,6)->(2,6)->(3,6)->(3,5)->(4,5)->(5,5)->(5,6)->(6,6)The running time is: 0.000000 s

总结扩展

通过数组手写栈并实现非递归 DFS，我们不仅加深了对栈“后进先出”的理解，也掌握了一种经典的回溯算法实现方式。栈的运算虽然简单（push、pop、peek、isEmpty），但组合起来就能解决迷宫寻路、括号匹配、表达式求值等许多实际问题。

之后可以 用链表实现栈 ，动态分配节点，没有固定容量限制， 求最短路径 ，将栈改为队列，DFS改为BFS。

如果还有时间的话，会将迷宫可视化做出来。

来自 Tsoding 的视频《Graphics API is irrelevant》

Tsoding 的观点非常直白：如果你想做的只是把像素画到屏幕上，你根本不需要任何图形 API。CPU 可以直接计算出每个像素的颜色，然后以一种最简单的图像格式（比如 PPM）保存下来，再用任何图片查看器打开即可。

这就是“用 CPU 跑 Shader”的最原始形态：没有 GPU，没有着色器语言，只有 for 循环和 fputc。

PPM 格式：比 TXT 还简单的图像格式

• P6（二进制）：直接写入每个像素的 RGB 字节，文件更小，也更容易用代码生成。

我们要用的就是 P6 二进制格式。它的头部只有三行：P6、宽度 高度、255。

紧接着就是 宽度 × 高度 × 3 个字节，按 R, G, B, R, G, B, ... 顺序排列。

纯红色的 PPM

代码展示

#include <stdio.h>int main(){    FILE *f = fopen("output.ppm", "wb");    int w = 16 * 60;   // 960    int h = 9 * 60;    // 540    // PPM 头部（P6 二进制格式）    fprintf(f, "P6\n");    fprintf(f, "%d %d\n", w, h);    fprintf(f, "255\n");    // 像素数据：全部写成 R=255, G=0, B=0    for (int i = 0; i < h; i++) {        for (int j = 0; j < w; j++) {            fputc(0xFF, f);   // R            fputc(0x00, f);   // G            fputc(0x00, f);   // B        }    }    fclose(f);    return 0;}

编译

g++ ppm.c -o ppm.exe.\ppm.exe

运行之后会生成一个ppm文件，我用ffmpeg转成了jpg格式

ffmpeg -i output.ppm -pix_fmt yuvj420p output.jpg

只是一个纯红色的无聊图案（？

一个棋盘格

当然我们可以通过判断当前索引是奇数还是偶数，决定当前像素的颜色

if((i/60+j/60)%2){           fputc(0xFF,f);           fputc(0x00,f);           fputc(0x00,f);       }else{           fputc(0x00,f);           fputc(0x00,f);           fputc(0x00,f);        }

这样就可以得到一个黑红相间的棋盘格

一个棋盘格视频

我们还可以让棋盘格移动，只需要做这样的修改

if(((i+10)/60+(j+10)/60)%2)

编译运行之后的棋盘格就会在X和Y方向偏移

然后，我们可以重复60次，将上述过程从0-60进行迭代，每一次迭代我们都创建一个单独的帧文件，共生成60个，代码如下

#include<stdio.h>int main(){    char buf[256];   //在栈上分配生成的帧文件名    for(int k=0;k<60;k++){    snprintf(buf,sizeof(buf),"output-%02d.ppm",k);    const char *output_path=buf;    FILE *f=fopen(output_path,"wb");    int w=16*60;    int h=9*60;    fprintf(f,"P6\n");    fprintf(f,"%d %d\n",w,h);    fprintf(f,"255\n");        for(int i=0;i<h;i++){             for(int j=0;j<w;j++){                     if(((i+k)/60+(j+k)/60)%2){                     fputc(0xFF,f);                     fputc(0x00,f);                     fputc(0x00,f);                 }else{                    fputc(0x00,f);                    fputc(0x00,f);                    fputc(0x00,f);                }               }        }     fclose(f);    printf("Generated %s\n",output_path);    }    return 0;}

然后在终端进行编译

ffmpeg -framerate 30 -i output-%02d.ppm -c:v libx264 -pix_fmt yuv420p output.mp4

即可看见视频

纯红色到任意“CPU Shader”

生成纯红色当然没什么用，但你可以替换内层循环里的 fputc逻辑——比如根据 (i, j) 坐标计算渐变色、画圆、画棋盘格，甚至实现分形、噪声、光线步进（Ray Marching）……所有这些都不需要任何图形 API，纯粹是 CPU 上对每个像素执行一个数学函数。

同时更进一步的，如果要动画，可以在外层再加一维时间 t，每帧生成一个 PPM，然后用 FFmpeg 合成视频。

以上本人因时间问题还未实现（挖坑中）

这款打字小游戏会在终端中生成一个 4x6 的随机字母矩阵，你需要按照行优先的顺序依次输入正确的字母。每输入正确一个格子就会变成绿色，错误则变成红色并累积错误次数。当错误次数达到上限（默认 5 次）时游戏失败；全部正确输入后游戏胜利。

核心特性：

• 随机生成大写字母矩阵
• 彩色高亮显示当前输入位置（青色背景）、正确输入（绿色）、错误输入（红色）
• 实时错误计数，支持中途按 ESC 退出
• 跨平台支持 Windows / Linux / macOS

代码结构解析

跨平台无缓冲输入

为了实现“按下一个键立即响应而不需要回车”，代码分别处理了 Windows 和 Unix-like 系统：

#ifdef _WIN32      #include<conio.h>    #define GETCH _getch#else        // 使用 termios 关闭规范输入和回显    int GETCH() { ... }#endif

启用 Windows 终端 ANSI 色彩

Windows 10+ 的默认控制台支持 ANSI 转义序列，但需要手动启用。代码中定义了 enableAnsi() 函数：

void enableAnsi(){    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);    DWORD dwMode = 0;    GetConsoleMode(hOut, &dwMode);    dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;    SetConsoleMode(hOut, dwMode);}

这样在 Windows 下也能使用 \033[32m 这类颜色控制码。

游戏数据结构

• 字母矩阵：vector<vector<char>> letters(ROWS, vector<char>(COLS))
  每个位置存储一个随机大写字母（'A' + dis(engine)）。

• 状态矩阵：vector<vector<int>> status(ROWS, vector<int>(COLS, 0))
  0 = 未输入，1 = 正确，-1 = 错误。

• 当前指针：int currentRow, currentCol 表示下一个要输入的格子。

const int ROWS=4;const int COLS=6;const int MAX_ERRORS=5;int main(){   #ifdef _WIN32    SetConsoleOutputCP(CP_UTF8);              SetConsoleCP(CP_UTF8);                #endifenableAnsi();//开启ANSI转义码//用时间生成随机字母auto seed = std::chrono::steady_clock::now().time_since_epoch().count();std::mt19937 engine(seed);std::uniform_int_distribution<> dis(0, 25);//一个vector，每一个元素是另一个vector<char>，外层是行，内层是列//std::vector<char>(COLS)一个临时内层vector，作为每一行的初始值//临时对象本身是 vector<char>(COLS)，表示它创建一个大小为 COLS 的 vector<char>，即每一行有 COLS 个字符。std::vector<std::vector<char>> letters(ROWS, std::vector<char>(COLS));for(int r=0;r<ROWS;++r)    for(int c=0;c<COLS;++c)        letters[r][c]='A'+dis(engine);//记录每个位置的判定结果，0=为输入，1=正确，-1=错误std::vector<std::vector<int>>status(ROWS,std::vector<int>(COLS,0));int currentRow=0,currentCol=0;      //当前待输入位置int error=0;            //错误次数bool gameOver=false;bool victory=false;

游戏主循环

1. 清屏并重新绘制整个界面（使用 ANSI 码 \033[2J\033[H）。
2. 根据 status 和当前光标位置设定不同颜色：
   • 当前格子 → 青色背景、黑色文字
   • 正确格子 → 绿色文字
   • 错误格子 → 红色文字
   • 未输入格子 → 白色文字
3. 等待用户按键：
   • ESC → 退出游戏
   • 其他字母 → 与 letters[currentRow][currentCol] 比较
4. 判断正确/错误，更新状态、错误计数，并移动光标。
5. 当错误次数 ≥ MAX_ERRORS 或所有格子输入完毕时，结束主循环。

while (!gameOver){    //清屏并定位到左上角    std::cout<<"\033[2J\033[H";    //绘制矩阵    for(int r=0;r<ROWS;r++){        for(int c=0;c<COLS;c++){            if(r==currentRow&&c==currentCol){                std::cout<<"\033[46m\033[30m";            }            else if(status[r][c]==1){                std::cout<<"\033[32m";//正确输入绿色            }            else if(status[r][c]==-1){                std::cout<<"\033[31m";//错误输入红色            }            else{                std::cout<<"\033[37m";//带输入白色            }            std::cout<<' '<<letters[r][c]<<' ';            std::cout<<"\033[0m";        }        std::cout<<'\n';    }    //显示错误计数和提示    std::cout<<"\n错误次数："<<error<<"/"<<MAX_ERRORS            <<"\t输入字母（退出按ESC）：";    //读取一个键    int ch=GETCH();    if(ch==27){        gameOver=true;        break;    }    //转成大写    char inputChar=static_cast<char>(std::toupper(ch));    if(inputChar==letters[currentRow][currentCol]){        status[currentRow][currentCol]=1;    }else{        status[currentRow][currentCol]=-1;        ++error;        if(error>=MAX_ERRORS){            gameOver=true;            victory=false;            break;        }    }    //移动到下一个格子（行优先）    ++currentCol;    if(currentCol>=COLS){        currentCol=0;        ++currentRow;        if(currentRow>=ROWS){            //全部输入完毕            gameOver=true;            victory=true;        }    }}

结束画面

• 胜利时显示绿色祝贺信息，并附带“🎉恭喜喵”。
• 失败时显示红色错误信息，指出超出错误次数。
• 普通退出则显示提示。

最后调用 GETCH() 等待任意键退出，避免控制台窗口一闪而过。

std::cout<<"\033[2J\033[H";//清屏if(victory){    std::cout<<"\033[32m🎉恭喜喵\033[0m\n";}else if(error>=MAX_ERRORS){    std::cout<<"\033[31m💥错误达到"<<MAX_ERRORS<<",失败了喵\033[0m\n";}else{    std::cout<<"游戏已退出。\n";}//等待按键再退出std::cout<<"\n按任意键退出……";GETCH();return 0;

效果展示

在终端输入

g++ typing_game.cpp -o typing_game.exe.\typing_game.exe

扩展与改进

还在开发中……之后会作出一个GUI，然后再丰富玩法……

大一人工智能通识课（一个无用的水课？）上看到了一个深度学习项目，然后就想试一下这个经典项目——手写数字识别（MNIST）。选择了 LeNet-5 这个轻量级卷积神经网络，最终模型在测试集上达到了约 98.7% 的准确率，之后有时间还会完善（或许）。

项目背景

• 数据集：MNIST —— 6 万张 28×28 灰度训练图片，1 万张测试图片，共 10 个数字类别（0~9）。
• 模型：LeNet-5（1998 年 Yann LeCun 提出），专为手写数字识别设计。

环境搭建

我使用 Python 3.10 和虚拟环境（venv）管理依赖。核心库安装命令：

pip install torch torchvision matplotlib Pillow numpy

LeNet-5 模型详解

网络结构

代码实现

模型定义（lenet5.py）

import torch from torch import nn  import torch.nn.functional as F  

LeNet-5 网络模型类定义

class MyLeNet5(nn.Module):    def __init__(self):               super().__init__()  # 调用父类nn.Module的初始化方法                # ========== 第一组：卷积层 + 池化层 ==========        self.conv1 = nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5)#卷积层1 2d                self.maxpool1 = nn.MaxPool2d(kernel_size=2, stride=2)# 最大池化层1 2d                # ========== 第二组：卷积层 + 池化层 ==========        # 卷积层2：第二个卷积层，提取更高级的特征        self.conv2 = nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5)                # 最大池化层2：进一步降低特征图尺寸        self.maxpool2 = nn.MaxPool2d(kernel_size=2, stride=2)                # ========== 全连接层（全连接层用于分类） ==========        # 全连接层1：将卷积特征图展平后连接到全连接层        # Linear: 全连接层（线性层）        self.fc1 = nn.Linear(16*5*5, 120)                # 全连接层2：进一步压缩特征        self.fc2 = nn.Linear(120, 84)                # 全连接层3（输出层）：最终分类层        self.fc3 = nn.Linear(84, 10)

前向传播函数：定义数据在网络中的流动过程

def forward(self, x):        # ========== 第一组：卷积 + 激活 + 池化 ==========    x = self.conv1(x)        # ReLU激活函数：增加非线性，使网络能够学习复杂模式    # ReLU(x) = max(0, x)，将负值置为0，保留正值    x = F.relu(x)        # 最大池化层1：下采样，减少计算量    x = self.maxpool1(x)        # ========== 第二组：卷积 + 激活 + 池化 ==========    x = self.conv2(x)        # ReLU激活函数    x = F.relu(x)        # 最大池化层2：进一步下采样    x = self.maxpool2(x)        # ========== 展平操作：将多维特征图展平为一维向量 ==========    # view(-1, 16*5*5): 重塑张量形状    # -1 表示自动计算该维度的大小（通常是batch_size）    x = x.view(-1, 16*5*5)        # ========== 全连接层1 ==========    # 全连接层1 + ReLU激活    x = F.relu(self.fc1(x))        # ========== 全连接层2 ==========    # 全连接层2 + ReLU激活    x = F.relu(self.fc2(x))        # ========== 输出层 ==========    # 全连接层3（输出层）：不应用激活函数，输出原始分数（logits）    x = self.fc3(x)        # ========== 输出处理 ==========    # 使用log_softmax而不是softmax的原因：    #   1. 数值稳定性更好（避免溢出）    #   2. 与NLLLoss（负对数似然损失）配合使用更高效    # dim=1 表示在类别维度（第1维）上应用softmax    return nn.functional.log_softmax(x, dim=1)        # log_softmax: 对输出应用对数softmax函数

测试代码

if __name__ == "__main__":    x = torch.rand([1, 1, 32, 32])        # 模型实例化：创建MyLeNet5模型对象    model = MyLeNet5()        # 前向传播：将输入数据传入模型，得到输出    # 模型会自动调用forward()方法    y = model(x)        # 打印输出结果    # 输出形状：(1, 10)，包含10个类别的对数概率    print("模型输出形状：", y.shape)    print("模型输出（对数概率）：")    print(y)    print("\n说明：输出为对数概率，值越大表示该类别可能性越高")

训练脚本（train.py）

训练流程：

1. 数据预处理和加载
2. 模型初始化
3. 定义损失函数和优化器
4. 训练循环（前向传播 → 计算损失 → 反向传播 → 更新参数）
5. 验证模型性能
6. 保存最佳模型

import torch from torch import nn from lenet5 import MyLeNet5 from torch.optim import lr_schedulerfrom torchvision import datasets, transformsimport os  

定义数据预处理流程

data_transfrom_train = transforms.Compose([    transforms.RandomHorizontalFlip(),   # 随机水平翻转（数据增强，增加训练样本多样性）        transforms.Resize((32, 32)),    # Resize((32, 32))：将图片尺寸调整为32×32像素    transforms.ToTensor(),    transforms.Normalize((0.1307,), (0.3081,))  ])data_transfrom_test = transforms.Compose([    transforms.Resize((32, 32)),    transforms.ToTensor(),    transforms.Normalize((0.1307,), (0.3081,))])

加载MNIST数据集

train_dataset = datasets.MNIST(    root='./data',     train=True,     transform=data_transfrom_train,     download=True)# 创建训练集数据加载器（DataLoader）train_dataloader = torch.utils.data.DataLoader(    dataset=train_dataset,     batch_size=64,  # 可根据GPU显存调整    shuffle=True   test_dataset = datasets.MNIST(    root='./data',     train=False,     transform=data_transfrom_test,     download=True)test_dataloader = torch.utils.data.DataLoader(    dataset=test_dataset,     batch_size=32,     shuffle=True)

设置计算设备

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")print(f"使用设备：{device}")  # 打印当前使用的设备

初始化模型

model = MyLeNet5()model = model.to(device)

定义损失函数

# 交叉熵损失函数（CrossEntropyLoss）loss_fn = nn.CrossEntropyLoss()

定义优化器

# 随机梯度下降优化器（SGD with Momentum）optimizer = torch.optim.SGD(model.parameters(), lr=1e-3, momentum=0.9)

定义学习率调度器

# StepLR：阶梯式学习率调度器lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)

定义训练函数

def train(dataloader, model, loss_fn, optimizer):       loss = 0.0     current = 0.0     n = 0          model.train()        # 遍历数据加载器中的每个批次    for batch, (x, y) in enumerate(dataloader):        # ========== 前向传播 ==========        x, y = x.to(device), y.to(device)                # 前向传播：将输入数据传入模型，得到预测输出        output = model(x)                # 计算损失：比较预测输出和真实标签        cur_loss = loss_fn(output, y)                # ========== 计算准确率 ==========        # torch.max(input, dim): 在指定维度上找到最大值和对应的索引        _, pred = torch.max(output, dim=1)                # 计算当前批次的准确率        cur_acc = torch.sum(y == pred) / output.shape[0]                # ========== 反向传播 ==========        optimizer.zero_grad()        cur_loss.backward()        optimizer.step()                # ========== 累计统计 ==========        loss += cur_loss.item()        current += cur_acc.item()        n = n + 1        # 计算整个epoch的平均损失和准确率    train_loss = loss / n      train_acc = current / n          print(f'训练损失 (train_loss): {train_loss:.4f}')    print(f'训练准确率 (train_acc): {train_acc:.4f}')

定义验证函数

def val(dataloader, model, loss_fn):    model.eval()        # 初始化统计变量    loss = 0.0      current = 0.0      n = 0          with torch.no_grad():        # 遍历验证/测试集的每个批次        for batch, (x, y) in enumerate(dataloader):            x, y = x.to(device), y.to(device)                        # 前向传播            output = model(x)                          # 计算损失            cur_loss = loss_fn(output, y)                        # 获取预测结果            _, pred = torch.max(output, dim=1)             # 计算当前批次的准确率            cur_acc = torch.sum(y == pred) / output.shape[0]                        # 累计统计            loss += cur_loss.item()            current += cur_acc.item()            n = n + 1        # 计算整个验证集的平均损失和准确率    val_loss = loss / n    val_acc = current / n        print(f'验证损失 (val_loss): {val_loss:.4f}')    print(f'验证准确率 (val_acc): {val_acc:.4f}')        # 返回验证准确率，用于选择最佳模型    return val_acc

训练循环

epoch = 10  min_acc = 0# 开始训练循环for t in range(epoch):    print(f'\n{"="*50}')    print(f'Epoch {t+1}/{epoch}')    print(f'{"="*50}')        # ========== 训练阶段 ==========    train(train_dataloader, model, loss_fn, optimizer)        # ========== 验证阶段 ==========    val_acc = val(test_dataloader, model, loss_fn)        # ========== 更新学习率 ==========    lr_scheduler.step()    current_lr = optimizer.param_groups[0]['lr']    print(f'当前学习率: {current_lr:.6f}')        # ========== 保存最佳模型 ==========    if val_acc > min_acc:        # 设置模型保存目录        folder = 'save_model'                # 如果保存目录不存在，则创建它        if not os.path.exists(folder):            os.mkdir('save_model')            print(f'创建模型保存目录：{folder}')                min_acc = val_acc                # 保存模型权重        model_path = 'save_model/best_model.pth'        torch.save(model.state_dict(), model_path)        print(f'✓ 保存最佳模型 (准确率: {min_acc:.4f}) → {model_path}')    else:        print(f'当前模型准确率 ({val_acc:.4f}) 未超过最佳 ({min_acc:.4f})，不保存')# ==================== 训练完成 ====================print(f'\n{"="*50}')print('训练完成！')print(f'最佳验证准确率: {min_acc:.4f}')print(f'最佳模型已保存到: save_model/best_model.pth')print(f'{"="*50}')print('Done!')

训练日志

总结

很多用了ai辅助，核心代码和原理由自己完成，欢迎指正（未完善……