有监督学习任务：找到一个最优的模型函数。使其在训练数据集上最小化一个给定的损失函数。\[\text { 最优模型 }=\arg_{\text { 模型 }} \mathbb{E}_{\text {(特征,标签)}\sim \text{数据分布 }}[\text { 损失函数 }(\text { 标签, 模型}(\text { 特征 }))]\]强化学习任务：最大化智能体策略在和动态环境交互过程中的价值。根据1.5节的分析，策略的价值可以等价转换成奖励函数在策略的占用度量上的期望，即:\[\text { 最优策略 }=\arg \max _{\text {策略 }} \mathbb{E}_{\text{(状态。动作) 策略的占用度量 }}[\text { 奖励函数 }(\text { 状态, 动作)]}\]

• 二者优化的途径是不同的，有监督学习直接通过优化模型对于数据特征的输出来优化目标，即修改目标函数而数据分布不变；强化学习则通过改变策略来调整智能体和环境交互数据的分布，进而优化目标，即修改数据分布而目标函数不变。

MAB - 多臂老虎机

多臂老虎机问题可以表示为一个元组 \(\langle\mathcal{A}, \mathcal{R}\rangle\),其中: - \(\mathcal{A}\)为动作集合，其中一个动作表示拉动一个拉杆。若多臂老虎机一共有 \(K\) 根拉杆，那动作空间就是集合 \(\left\{a_1, \ldots, a_K\right\}\)，我们用\(a_t \in \mathcal{A}\)表示任意一个动作; - \(\mathcal{R}\)为奖励概率分布，拉动每一根拉杆的动作 \(a\) 都对应一个奖励概率分布 \(\mathcal{R}(r \mid a)\),不同拉杆的奖励分布通常是不同的。

假设每个时间步只能拉动一个拉杆，多臂老虎机的目标为最大化一段时间步\(T\) 内累积的奖励: \(\max \sum_{t=1}^T r_t, r_t \sim\mathcal{R}\left(\cdot \mid a_t\right)\) 。其中 \(a_t\) 表示在第 \(t\) 时间步拉动某一拉杆的动作, \(r_t\) 表示动作 \(a_t\) 获得的奖励。

探索和利用两者之间的平衡

• \(\epsilon\)贪心算法：\(a_t= \begin{cases}\arg\max _{a \in \mathcal{A}} \hat{Q}(a), & \text { 采样概率: }1-\epsilon \\ \text { 从 } \mathcal{A} \text { 中随机选择, } & \text{ 采样概率: } \epsilon\end{cases}\)
• 上置信界算法：给定一个概率 \(p=e^{-2 N_t(a) U_t(a)^2}\Longrightarrow\hat{U}_t(a)=\sqrt{\dfrac{-\log p}{2N_t(a)}}\)，根据霍夫丁不等式，\(Q_t(a)<\hat{Q}_t(a)+\hat{U}_t(a)\)至少以概率 \(1-p\)成立，在每次拉杆前计算奖励期望的上界
• 汤普森采样算法：例如对二项分布的老虎机，其参数的概率分布为beta 分布

马尔科夫

马尔科夫过程

用元组 \(\langle\mathcal{S},\mathcal{P}\rangle\) 描述一个马尔可夫过程，其中\(\mathcal{S}\)是有限数量的状态集合，\(\mathcal{P}\)是状态转移矩阵（state transition matrix）。假设一共有 \(n\) 个状态，此时 \(\mathcal{S}=\left\{s_1, s_2, \ldots,s_n\right\}\)。状态转移矩阵 \(\mathcal{P}\)定义了所有状态对之间的转移概率 \[\mathcal{P}=\left[\begin{array}{ccc}P\left(s_1 | s_1\right) & \cdots & P\left(s_n | s_1\right) \\\vdots & \ddots & \vdots \\P\left(s_1 | s_n\right) & \cdots & P\left(s_n | s_n\right)\end{array}\right]\] 当前状态是未来的充分统计量

MRP - 马尔科夫奖励过程

由 \(\langle\mathcal{S}, \mathcal{P}, r,\gamma\rangle\) 构成： - \(\mathcal{S}\) - 有限状态 - \(\mathcal{P}\) - 状态转移矩阵。 - \(r\) - 奖励函数，某个状态 \(s\) 的奖励 \(r(s)\) 指转移到该状态时可以获得奖励的期望。- \(\gamma\) 是折扣因子 (discountfactor) , \(\gamma\) 的取值范围为 \([0,1)\) 。远期利益有一定不确定性

定义回报如下 \[G_t=R_t+\gamma R_{t+1}+\gamma^2 R_{t+2}+\cdots=\sum_{k=0}^{\infty}\gamma^k R_{t+k}\] 定义价值函数 \(V(s)=\mathbb{E}\left[G_t \midS_t=s\right]\)，迭代法推出 \(V(s)=r(s)+\gamma \sum_{s^{\prime} \in S}p\left(s^{\prime} \mid s\right)V\left(s^{\prime}\right)\)，为贝尔曼方程，记\[ \mathcal{V}=\left[V\left(s_1\right),V\left(s_2\right), \ldots, V\left(s_n\right)\right]^T,\mathcal{R}=\left[r\left(s_1\right), r\left(s_2\right), \ldots,r\left(s_n\right)\right]^T\] 矩阵形式以及解，该解法复杂度为 \(\mathcal{O}(n^3)\) \[\begin{aligned} \mathcal{V} & =\mathcal{R}+\gamma \mathcal{P}\mathcal{V} \\ \mathcal{V} & =(I-\gamma \mathcal{P})^{-1}\mathcal{R}\end{aligned}\]

MDP - 马尔科夫决策过程

由 \(\langle\mathcal{S},\mathcal{A},\gamma,r(s,a),P\rangle\)构成：

• \(\mathcal{S}\) - 状态集合
• \(\mathcal{A}\) - 动作集合
• \(\gamma\) -折扣因子（大多数情况下介于 0.95 和 0.99 之间）
• \(r(s, a)\) -奖励函数，此时奖励可以同时取决于状态 \(s\) 和动作 \(a\)
• \(P\left(s^{\prime} | s, a\right)\)- 状态转移函数，表示在状态 \(s\)执行动作 \(a\) 之后到达状态 \(s^{\prime}\)的概率（为三维数组或者连续的）

定义策略，可以有确定性策略和随机性策略（根据概率分布）\[\pi(a | s)=P\left(A_t=a | S_t=s\right)\] 定义状态价值函数，代表基于某种策略 \(\pi\) 下从状态 \(s\) 出发的期望回报 \[V^\pi(s)=\mathbb{E}_\pi\left[G_t | S_t=s\right]\] 定义动作价值函数，代表基于某种策略 \(\pi\) 下从状态 \(s\) 执行动作 \(a\) 的期望回报 \[Q^\pi(s, a)=\mathbb{E}_\pi\left[G_t | S_t=s, A_t=a\right]\] 全概率公式得到 \[V^\pi(s)=\sum_{a \in A} \pi(a | s) Q^\pi(s, a)\] 类似 MRP，在给定当前状态 \(s\) 和执行动作 \(a\) 下 \[\begin{aligned} Q^\pi(s, a) & =\mathbb{E}_\pi\left[R_t+\gammaQ^\pi\left(S_{t+1}, A_{t+1}\right) \mid S_t=s, A_t=a\right] \\ &=r(s, a)+\gamma \sum_{s^{\prime} \in S} p\left(s^{\prime} \mid s,a\right) \sum_{a^{\prime} \in A} \pi\left(a^{\prime} \mids^{\prime}\right) Q^\pi\left(s^{\prime}, a^{\prime}\right)\end{aligned}\]最优状态价值是选择使最优动作价值最大的那个动作得到的状态价值\[V^*(s)=\max _{a \in \mathcal{A}} Q^*(s, a)\] 于是得到贝尔曼最优方程 \[\begin{aligned} V^*(s) & =\max _{a \in \mathcal{A}}\left\{r(s,a)+\gamma \sum_{s^{\prime} \in \mathcal{S}} p\left(s^{\prime} \mid s,a\right) V^*\left(s^{\prime}\right)\right\} \\ Q^*(s, a) & =r(s,a)+\gamma \sum_{s^{\prime} \in \mathcal{S}} p\left(s^{\prime} \mid s,a\right) \max _{a^{\prime} \in \mathcal{A}} Q^*\left(s^{\prime},a^{\prime}\right)\end{aligned}\] ## 动态规划算法

价值策略迭代

随便初始化一个 \(V_0 \equiv0\)，在最优贝尔曼方程上迭代，此时 \(V_{+\infty}=V^{\star}\) \[V_{k+1}(s) \leftarrow \max _{a \in \mathcal{A}}\left[\sum_{s^{\prime}\in \mathcal{S}} \mathbb{P}_{\mathcal{E}}\left(s^{\prime} \mid s,a\right)\left[r\left(s, a, s^{\prime}\right)+\gammaV_k\left(s^{\prime}\right)\right]\right]\]

策略提升

得知状态价值函数的基础上优化策略，有完全贪心策略，只选择价值最大的那一个动作\[\pi(a \mid s):= \begin{cases}1 & a=\operatorname{argmax}_{a^{\prime}\in \mathcal{A}} Q\left(s, a^{\prime}\right) \\ 0 & \text {otherwise }\end{cases}\]

时序差分算法

无模型的强化学习：环境的奖励函数和状态转移函数是未知的，只有不断地交互采样得到数据才能学习

Sarsa 算法（在线策略）

\(\epsilon\)-贪心策略，有 \(1-\epsilon\)的概率采用动作价值最大的那个动作，\(\epsilon\) 概率从动作空间中随机采取一个动作\[\pi(a \mid s)= \begin{cases}\epsilon /|\mathcal{A}|+1-\epsilon &\text{ 如果 } a=\arg \max _{a^{\prime}} Q\left(s, a^{\prime}\right) \\\epsilon /|\mathcal{A}| & \text { 其他动作 }\end{cases}\] 蒙特卡洛方法直接拿到奖励然后更新，SARSA算法考虑下一个状态的价值估计，其中使用 \(\epsilon\)-贪心策略估计动作函数 \[Q\left(s_t, a_t\right) \leftarrow Q\left(s_t,a_t\right)+\alpha\left[r_t+\gamma Q\left(s_{t+1},a_{t+1}\right)-Q\left(s_t, a_t\right)\right]\] 其中 \(r_t+\gammaV(s_{t+1})-V(s_t)\) 被称为时序差分（temporaldifference, TD），也可以多走几步，为多步 Sarsa 算法\[Q\left(s_t, a_t\right) \leftarrow Q\left(s_t,a_t\right)+\alpha\left[r_t+\gamma r_{t+1}+\cdots+\gamma^nQ\left(s_{t+n}, a_{t+n}\right)-Q\left(s_t, a_t\right)\right]\]

Q-learning 算法（离线策略）

更新方式变为 \[Q\left(s_t, a_t\right) \leftarrow Q\left(s_t,a_t\right)+\alpha\left[R_t+\gamma \max _a Q\left(s_{t+1},a\right)-Q\left(s_t, a_t\right)\right]\] 本质上 Sarsa 算法是有了下一个状态后用当前策略（这里是 \(\epsilon\)-贪心策略）去找到下一个或者多个状态的动作，从而更新相应的动作状态价值，Q-learning算法有了下一个状态后不用当前策略，而是选取最好的那个状态动作，这是由贝尔曼最优方程保证的

采样数据的策略为行为策略，利用这些数据来更新的策略为目标策略，两者一样是在线策略，两者不一样是离线策略，

Dyna-Q 算法

每次选取一个曾经访问过的状态 \(s\)，采取曾经在该状态下执行过的动作 \(a\)，通过模型得到转移后的状态 \(s^{\prime}\) 以及奖励 \(r\)，并根据这个模拟数据 \((s,a,r,s^{\prime})\) 用 Q-learning的方式来更新动作价值函数。

DQN 算法（深度 Q 网络）

原始算法

Q-learning 的更新规则 \[Q(s, a) \leftarrow Q(s, a)+\alpha\left[r+\gamma \max _{a^{\prime} \in\mathcal{A}} Q\left(s^{\prime}, a^{\prime}\right)-Q(s, a)\right]\] 神经网络参数 \(\omega\)，\(Q_{\omega}(s,a)\) 表征 \(Q\) 值，将 Q网络的损失函数构造为均方误差的形式 \[\omega^*=\arg \min _\omega \frac{1}{2 N}\sum_{i=1}^N\left[Q_\omega\left(s_i, a_i\right)-\left(r_i+\gamma \max_{a^{\prime}} Q_\omega\left(s_i^{\prime},a^{\prime}\right)\right)\right]^2\] 实际训练中使用 Buffer 池中抽样尽量使数据同分布，使用固定的target 模型更新原始模型，一定时间间隔之后将 target模型更新为原始模型。

Double DQN

训练过程中高估 \(Q\) 值，改写为\[r+\gamma Q_{\omega^{-}}\left(s^{\prime}, \underset{a^{\prime}}{\arg \max} Q_\omega\left(s^{\prime}, a^{\prime}\right)\right)\]即不选取目标网络中最大价值动作，而是选择原始网络中的最大价值动作，这样某些不可能超过\(0\) 的 \(Q\) 值高估数量减少

Dueling DQN

价值函数 \(Q\) 减去状态价值函数\(V\)的结果定义为优势函数 \(A\), 即 \(A(s,a)=Q(s, a)-V(s)\) 。在同一个状态下, 所有动作的优势值之和为0。因为所有动作的动作价值的期望就是这个状态的状态价值。在 Dueling \(D Q N\) 中，\(Q\) 网络被建模为 \[Q_{\eta, \alpha, \beta}(s, a)=V_{\eta, \alpha}(s)+A_{\eta, \beta}(s, a)\] 由于这样对于相同的 \(Q\)值，两者的值可以你增我减，可以固定最优动作的优势函数为 \(0\) \[Q_{\eta, \alpha, \beta}(s, a)=V_{\eta, \alpha}(s)+A_{\eta, \beta}(s,a)-\max _{a^{\prime}} A_{\eta, \beta}\left(s, a^{\prime}\right)\] 也可以优势之和固定为 \(0\)\[Q_{\eta, \alpha, \beta}(s, a)=V_{\eta, \alpha}(s)+A_{\eta, \beta}(s,a)-\frac{1}{|\mathcal{A}|} \sum_{a^{\prime}} A_{\eta, \beta}\left(s,a^{\prime}\right)\] 这样更加稳定

策略梯度算法

假设策略是关于参数 \(\theta\)处处可微的函数，定义策略学习的目标函数为 \[J(\theta)=\mathbb{E}_{s_0}\left[V^{\pi_\theta}\left(s_0\right)\right]\] 代表所有状态下以 \(\pi_{\theta}\) 策略获得价值的期望，可以推导\[\begin{aligned}\nabla J(\theta)&=\sum_{s\in\mathcal{S}}\nu^{\pi_{\theta}}(s)\sum_{a\in\mathcal{A}}\nabla_{\theta}\pi_{\theta}(a|s)Q^{^{\pi_{\theta}}}(s,a)\\&=\sum_{s\in \mathcal{S}}\nu^{\pi_{\theta}(s)}\sum_{a\in\mathcal{A}}\pi_{\theta}(a|s)Q^{\pi_{\theta}}(s,a)\nabla_{\theta}\log\pi_{\theta}(a|s)\\&=\mathbb{E}_{\pi_{\theta}}\left[Q^{\pi_{\theta}}(s,a)\nabla_{\theta}\log\pi_{\theta}(a|s)\right]\end{aligned}\] Reinforce算法：有限步数环境下采样轨迹计算相应的价值，这是通过蒙特卡洛采样，估计是无偏的，对每个时间\(t\)往后采样序列得到轨迹并计算回报并求和乘以策略对数的梯度 \[\nabla_\thetaJ(\theta)=\mathbb{E}_{\pi_\theta}\left[\sum_{t=0}^T\left(\sum_{t^{\prime}=t}^T\gamma^{t^{\prime}-t} r_{t^{\prime}}\right) \nabla_\theta \log\pi_\theta\left(a_t \mid s_t\right)\right]\]

使用当前策略采样，计算当前轨迹每个时刻 \(t\) 往后的回报，记为 \(\psi_t\)，然后梯度上升 \[\theta\leftarrow \theta+\alpha \sum_{t}^{T}\psi_t\nabla_{\theta}\log\pi_{\theta}(a_t|s_t)\]

[!NOTE]

如果定义深度神经网络的所有操作为 \(F:I\rightarrow O\)​，DQN 算法本质是用 \(F(s)[a]\)​ 去拟合 \(Q(s,a)\)​ ，与 Q-learning 的 \(Q^{*}\)​两者的平方误差均值作损失函数，然后梯度下降；策略梯度算法本质是用 \(\text{Softmax}(F(s))[a]\)​ 去拟合 \(\pi(a|s)\)​​，梯度用公式推导，使用采样的样本梯度上升。

Actor-Critic 算法

一个既学习价值函数，又学习策略函数的方法

• Actor 学习策略，使用策略梯度算法更新策略 \[\theta_{\text{act}}=\theta_{\text{act}}+\alpha_\theta \sum_t \delta_t\nabla_\theta \log \pi_\theta\left(a_t \mid s_t\right)\]

• Critic 学习价值函数，类似 DQN，把下一个时刻的目标 \(r+\gamma V_{\omega}(s_{t+1})\) 作为target，优化损失函数，梯度更新只有 \(V_{\omega}(s_{t})\) 原始价值函数更新 \[\mathcal{L}(\omega)=\dfrac{1}{2}(r+\gammaV_{\omega}(s_{t+1})-V_{\omega}(s_{t}))^2\\\nabla \mathcal{L}(\omega)=-(r+\gammaV_{\omega}(s_{t+1})-V_{\omega})\nabla V_{\omega}(s_{t})\]

TRPO 算法

如何更新策略

新旧策略之间的差距为 \[\begin{aligned}J(\theta^{\prime})-J(\theta)&=\mathbb{E}_{\pi_{\theta}^{\prime}}\left[\sum_{t=0}^{\infty}\gamma^{t}[r(s_t,a_t)+\gammaV^{\pi_{\theta}}(s_{t+1})-V^{\pi_{\theta}}(s_t))]\right]\\&:=\mathbb{E}_{\pi_{\theta^{\prime}}}\left[\sum_{t=0}^{\infty}\gamma^{t}A^{\pi_{\theta}}(s_t,a_t)\right]\\&=\frac{1}{1-\gamma} \mathbb{E}_{s \sim \nu^\pi\pi_{\theta^{\prime}}} \mathbb{E}_{a \sim \pi_{\theta^{\prime}}\cdot(\cdot \mid s)}\left[A^{\pi_\theta}(s, a)\right]\end{aligned}\] 其中 \(A^{\pi_{\prime}}(s_t,a_t)\)为优势函数，\(\nu^{\pi}(s)=(1-\gamma)\sum_{t=0}^{\infty}\gamma^{t}P_{t}^{\pi}(s)\)为状态访问分布，保证对所有的 \(s\)求和为 \(1\)。

• 假设1：相邻两策略之间的状态访问分布变化不大，第一个期望不变
• 假设2：相邻两策略之间的 KL 散度相近，信任区域为策略空间的一个球

则需要优化的策略目标为 \[\dfrac{\pi_{\theta^{\prime}}(a\mid s)}{\pi_{\theta}(a\mids)}A^{\pi_{\theta_k}}(s,a)\] 同时还要保证优化后的策略尽可能与原来相近

在 \(\theta_{k}\)​​附近一阶近似和二阶近似 \[\begin{gathered}\mathbb{E}_{s \sim \nu^{\pi_\theta}} \mathbb{E}_{a \sim\pi_{\theta_k}(\cdot \mid s)}\left[\frac{\pi_{\theta^{\prime}}(a \mids)}{\pi_{\theta_k}(a \mid s)} A^{\pi_{\theta_k}}(s, a)\right] \approxg^T\left(\theta^{\prime}-\theta_k\right) \\\mathbb{E}_{s \sim \nu^{\pi_{\theta_k}}}\left[D_{KL}\left(\pi_{\theta_k}(\cdot \mid s), \pi_{\theta^{\prime}}(\cdot \mids)\right)\right] \approx\frac{1}{2}\left(\theta^{\prime}-\theta_k\right)^TH\left(\theta^{\prime}-\theta_k\right)\end{gathered}\] 转换为优化问题 \[\theta_{k+1}=\underset{\theta^{\prime}}{\arg \max }g^T\left(\theta^{\prime}-\theta_k\right) \quad \text { s.t. } \quad\frac{1}{2}\left(\theta^{\prime}-\theta_k\right)^TH\left(\theta^{\prime}-\theta_k\right) \leq \delta\] KKT 条件，构造拉格朗日函数 \(L\left(\theta^{\prime},\lambda\right)=g^T\left(\theta^{\prime}-\theta_k\right)+\lambda\left(\delta-\dfrac{1}{2}\left(\theta^{\prime}-\theta_k\right)^TH\left(\theta^{\prime}-\theta_k\right)\right)\)

1. 定长方程式

\[\begin{aligned}& \nabla_{\theta^{\prime}} L\left(\theta^{\prime},\lambda\right)=g-\lambda H\left(\theta^{\prime}-\theta_k\right)=0 \\& \Rightarrow \theta^{\prime}=\theta_k+\frac{1}{\lambda} H^{-1} g\end{aligned}\] 2. 原始可行性

\[\frac{1}{2}\left(\theta^{\prime}-\theta_k\right)^TH\left(\theta^{\prime}-\theta_k\right) \leq \delta\] 3. 对偶可行性

\[\lambda \geq 0\] 4. 互补松弛型 \[ \lambda\left(\delta-\frac{1}{2}\left(\theta^{\prime}-\theta_k\right)^TH\left(\theta^{\prime}-\theta_k\right)\right)=0 \]

可以解得 \[\theta_{k+1}=\theta_{k}+\sqrt{\dfrac{2\delta}{g^{T}H^{-1}g}}H^{-1}g\] 使用共轭梯度法求解 \(x=H^{-1}g\)，代入 \[\Delta\theta=\sqrt{\dfrac{2\delta}{x^{T}Hx}}x\] 线性搜索，找到最小的非负整数 \(i\)，其中 \(\alpha\in(0,1)\) \[\theta_{k+1}=\theta_k+\alpha^i \sqrt{\frac{2 \delta}{x^T H x}} x\] 使得新的 \(\theta_{k+1}\)满足策略目标

广义优势估计（GAE）

定义多步时序差分 \[A_{t}^{(i)}=\sum_{j=0}^{i}\gamma^{j}\delta_{t+j}\\\delta_t=-V(s_t)+r_t+\gammaV(s_{t+1})\] 使用数学归纳法可证明 \[A_{t}^{(k)}=-V(s_t)+\sum_{i=0}^{k-1}\gamma^{i}r_{t+i}+\gamma^{k}V(s_{t+k})\] 使用指数加权平均，有 \((1-\lambda)\sum_{i=0}^{\infty}\lambda^i=1\)\[\begin{aligned}A_{t}^{GAE}&=(1-\lambda)(A_t^{(1)}+\lambda A_{t}^{(2)}+\lambda^2A_{t}^{(3)}+\cdots)\\& =(1-\lambda)\left(\delta_t \frac{1}{1-\lambda}+\gamma \delta_{t+1}\frac{\lambda}{1-\lambda}+\gamma^2 \delta_{t+2}\frac{\lambda^2}{1-\lambda}+\cdots\right) \\ &=\sum_{l=0}^{\infty}(\gamma \lambda)^l \delta_{t+l}\end{aligned}\] 当 \(\lambda=0\)时，为第一个差分 \(A_{t,\lambda=0}^{GAE}=\delta_t\)，当 \(\lambda=1\) 时，\(A_t^{G A E}=\sum_{l=0}^{\infty} \gamma^l\delta_{t+l}=\sum_{l=0}^{\infty} \gamma^lr_{t+l}-V\left(s_t\right)\)

PPO 算法

使用拉格朗日乘子法将 KL 散度前面的系数也放进目标函数中，定义如下\[\underset{\theta}{\arg \max } \mathbb{E}_{s \sim \nu^{\pi_{\theta_k}}}\mathbb{E}_{a \sim \pi_{\theta_k}(\cdot \mids)}\left[\dfrac{\pi_{\theta}(s|a)}{\pi_{\theta_k}(s|a)}A^{\pi_{\theta}}(s,a)-\betaD_{KL}[\pi_{\theta_k}(\cdot|s),\pi_{\theta}(\cdot|s)]\right]\]

PPO-惩罚

令 \(d_k=D_{KL}^{\nu^{\pi_{\theta_k}}}(\pi_{\theta_k},\pi_\theta)\)，\(\beta\)​ 更新如下 \[\beta_{k+1}= \begin{cases}\frac{\beta_k}{2}, & \text { 如果 }d_k<\frac{\delta}{1.5} \\ \beta_k \times 2, & \text { 如果 }d_k>\delta \times 1.5 \\ \beta_k, & \text { 否则 }\end{cases}\] 也就是散度太大的话权重调大，散度太低的话权重调小

PPO-截断

根据优势函数在 \([1-\epsilon,1+\epsilon]\) 前后截断 \[\underset{\theta}{\arg \max } \mathbb{E}_{s \sim \nu}{}^{\pi_{\theta_k}} \mathbb{E}_{a \sim \pi_{\theta_k}(\cdot \mids)}\left[\min \left(\frac{\pi_\theta(a \mid s)}{\pi_{\theta_k}(a \mids)} A^{\pi_{\theta_k}}(s, a),\operatorname{clip}\left(\frac{\pi_\theta(a \mid s)}{\pi_{\theta_k}(a\mid s)}, 1-\epsilon, 1+\epsilon\right) A^{\pi_{\hat{\sigma}_k}}(s,a)\right)\right.\] 如果 \(A>0\) 两者之比被\(1+\epsilon\) 截断，如果 \(A<0\)，则被 \(1-\epsilon\) 截断，为语言模型主流算法。

大三老狗了，已经对学业厌倦了，不过还是先康康这学期学了些啥

数值分析，数学系 bcl老师的，老师人非常好，课间经常到座位上一个一个问我们上课情况，每章留一次作业，还有两次写代码的大作业，分别是解线性方程组和插值，都不算很难。期末复习的时候把《数值分析基础》整本书刷完，其实书上讲得蛮详细的，看完的话问题也不是很大，期末最难的一道使用拉格朗日插值证明恒等式的题目也就是书后的练习题。

期末复习的时候发现 GPT-4-All-Tools基本能解决大部分问题，这里写了一份数值分析笔记以及往年题解析。据说这是老师第一次开课时的卷子，平均分惨不忍睹，但GPT-4 十拿九稳，说明这门课就应该取消，LLM能办的事情就不用人来操心了，这次期末考完回来用 GPT-4验算的时候发现自己还算错一道题。。。

计算机组成原理，软院 yz老师的，老师人也非常好，喜欢对同一个知识点过很多epoch，属于慢热型，上课内容和作业参考CSAPP，主要讲了信息是怎么编码在计算机中的、编译器是如何操纵运行代码的，Y86指令架构是如何设计并运行的、高速缓存机制是什么、如何优化代码增加运行速度这几方面。

这课的确是原理课，上课过程中回想起大一大二犯的一些错误：

• 程序设计基础：编译大作业最终代码的时候一直不懂报一百多个有关vector size() 的warning，现在才知道这是一个 unsigned_int类型，和其余 int 作用时会全部转为unsigned_int，编译器会警告这类转换
• 数据结构：写 kd 树以 \(\mathcal{O}(\sqrt{n})\)返回所在区间，判断两个 int 变量大小关系写成return (a - b) >= 0，没有考虑到溢出的情况，在最后一次提交十成测试时才发现修改过来
• 算法分析与设计基础：在编写各种字符串匹配算法，如KMP、BM 算法时，加入 不同 -O1优化等级能出现完全不同的测试结果，编译器还是很聪明的

课程有几次小作业，以及三个 CSAPP的大作业，分别涉及位级编码运算、Buflab、Y-86 框架实现，Y-86的框架比较老了，环境配置还挺麻烦，不过作业都还算好写。

统计推断，数理基础课组中的课，如果不上这门课的话，就只能上泛函分析、微分几何、数理方程这些硬课，不是课程上不起，而是科研更有性价比。不过这课还是挺有趣的，介绍了充分统计量、完全统计量，学会了如何估计一个点，估计区间，以及使用各种检验接受或者拒绝原假设。课程还是非常有应用价值，之前有个验证GPT-4变懒的文章就用了假设检验，以及孟德尔🫛实验数据也可以检验性状比是否符合\(9:3:3:1\)。

英语进阶读写，phm 老师的课程，老师人非常nice，考核对我这种英语不好的比较友好，虽然到期末背的比较多，体验还不错，老师上课喜欢讲许多其他领域的知识，很有趣。或许是之前发生过什么事吧，老师上课有点过于谨慎了哈哈。

软件工程探索与实践(1)，书院专属课程，软件学院四个研究所每个所出一个老师介绍自己的研究方向，这学期是zxb 老师和 wjl 老师。

前半学期学习网络安全，在模拟平台上复现一句话木马、系统漏洞、中间人攻击等等，还是很有趣的。期中拿着其余同学攻击的数据进行分析，不得不说手工分析还是很难的，日志文件太多了而且相互之间联系紧密，其实到最后就直接搜索可疑指令还原攻击场景了hh，向那些防守or溯源的“红客”们致敬！所以当黑客还是难，想干点坏事还是挺容易的，但干了坏事不留痕迹难如登天。

后半学期学习物联网，讨论了目前网络编码信息、发送信息、解码信息中间的技术细节，有关傅立叶变换、正交复用、卷积等内容，以及老师上课讲了降噪耳机的原理，非常妙！期末大作业是写一组程序把一个长度为50 的随机字符串编码成音频，用手机播放，在距离 1m处的电脑接受音频并解码对。调试的过程非常曲折，如果所有声音的振幅一样，那么由于噪声就很难精准定位第一个比特对应的位置，并且只要错位1个比特整个字符串就崩溃了。开始想使用纠错码，但发现错位后根本无法纠错，因为0 1 概率几乎是随机的，之后想到使用不同的振幅并切分batch，每次相当于前后“夹击”定位中间的信息片段，经过不断地调试，最终发送并解码字符串匹配率\(100\%\)。

科研

欢迎关注我们在 2023 年暑假期间的工作 AgentTuning～😊（以下是朋友圈原文）

欢迎关注 star ⭐️ 我们最新的 Agent 方向工作 AgentTuning

现有 Agent 系统大多基于 GPT-3.5/4 开发，开源模型即便是 Llama2-70b也几乎无法胜任大多数 Agent 任务。

AgentTuning 旨在提升 LLM 的 Agent 能力，通过结合 6 个 Agent任务的高质量交互轨迹和通用指令数据对 Llama 2 进行微调，我们得到 AgentLM系列模型。AgentLM 展现出强大的泛化性，AgentLM-70B 在分布外 Agent任务可与 GPT-3.5-turbo 媲美（+176% vsLlama2-70b），同时依然保留通用对话能力。我们开源所有数据和模型，希望AgentLM 能成为 Agent 任务开发的有力开源替代。

网站：https://thudm.github.io/AgentTuning

论文：https://arxiv.org/abs/2310.12823

代码：https://github.com/THUDM/AgentTuning

模型：https://huggingface.co/THUDM/agentlm-70b

数据：https://huggingface.co/datasets/THUDM/AgentInstruct

社工

本学期末开始负责软件学院科协相关工作，希望为学院创造更加良好的科研、科创、技术交流的环境，也辛苦各部门履行职责分好来自各个地方的锅！

志愿

继续在答疑坊干活，答疑坊最近在搞 AI &大模型，帮忙整理/提供了一些数据

网络桥接

docker使用网络桥接（bridge）来通信容器与宿主机进行通信，docker0是默认网络桥，其 IP 地址通常是172.17.0.1，可以在命令行中输入以下命令显示

1
2
3
4
5

$ ip addr show docker0
13: docker0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
......
    inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
......

网络检测

检查端口是否开放并能够访问，nc 是 netcat的缩写，-z 只扫描端口，-v 工作在冗余模式

1
2
3

$ nc -zv 127.0.0.1 4000
Connection to 127.0.0.1 port 4000 [tcp/terabase] succeeded!
# 代表可以连接该端口

检测集群上的网络状况，安装 nethogs

1
2
3

$ sudo apt install nethogs
$ sudo nethogs
# 显示当前网路状况

NCCL

NCCL：在多机多卡训练过程中，作为面向GPU提供的集合通信库，能有效提高训练速度。

DMA(Direct MemoryAccess)：允许外部设备直接访问计算机内存，无需通过 CPU进行数据传输，减少 CPU 负担。

RDMA(Remote Direct MemoryAccess)：允许计算机在网络中从另一台计算机内存中读取或写入数据，而不需要远程系统的CPU 干预，这样能减少网络通信延迟和 CPU 负担。

InfiniBand：一个高性能、低延迟的网络通信架构，常用于高性能计算集群，支持RDMA 技术，

显示当前 InfiniBand 网路设备状态工具，其中state 中的 ACTIVE 代表可以进行通信，而DOWN 代表不活动。

400Gb/sec 中的 b 代表bit，其等于 50GB/sec。

Ethernet代表以太网，与日常网络相同，在大模型训练过程中速度很慢。

简介

Docker 的吉祥物是 Moby Dock，最初是 dotCloud 公司的内部项目，在 2013年 3 月以 Apache 2.0 协议开源，开放容器联盟 OCl (Open ContainerInitiative)。

其使用 Go 语言实现，基于 Linux 内核的 cgroup、namespace 以 及 UnionFS等技术实现对进程的封装隔离，最初基于 LXC (LinuxContainers)，后来转向自行开发的 libcontainer

环境

检查 Linux 系统版本

1

$ uname -a

列出本地 Docker 环境中所有的 Docker 镜像

1

$ docker images

列出当前正在运行的 Docker 容器，ps = process status，加上 -a则列出所有 Docker 容器

1

$ docker ps

Docker 入门

交互式容器

1
2
3
4

# 运行容器
$ docker run -it ubuntu bash
# 进入类似 Ubuntu 的”新环境“
root@f7cbdac22a02:/# 

-i 保证 STDIN 是开启的，持久的标准输入是shell 的半边天，-t 则是另外一个半边天，让docker 将容器“打”到一个伪 tty 终端（该例子为bash。这里没有给定名字，docker会创建一个随机名，例如 gray_cat，加上名字的方法为--name [NAME]。

创建之后如同在新的 bash 环境下交互，输入exit 或者 Ctrl+D 退出。输入docker start 加上名字或者容器 ID启动已经停止的容器，如要重新启动为docker restart，但这都只是“启动”容器，要重新回到交互界面需要输入docker attach。

守护式容器

交互式容器适合运行应用程序和服务，例如

1
2

# -d 代表放置在后台运行
$ docker run --name hello_world -d ubuntu bash -c "while true: do echo hello world; sleep 1; done"

该容器则没有 shell 会话可供交互。以下命令查看日志，其中-f 与 tail -f 中的 -f相似，用来监控日志的变化，而 -t表示显示时间戳，可以看到如下输出

1
2
3
4

$ docker logs -ft hello_world
2023-07-29T15:03:44.879386240Z hello world
2023-07-29T15:03:45.880515741Z hello world
2023-07-29T15:03:46.882173546Z hello world

时间间隔不是严格 1s 因素：系统调度、写入日志、获取时间耗时等。

容器信息

查看容器进程、显示一个或者多个容器状态信息（整理为 markdown格式）

1

$ docker top hello_world

1
2

# 显示所有正在运行容器，-q 代表显示容器 ID
$ docker stats 'docker ps -a -q'

输入如下命令则可以停止容器，但容器仍在 docker ps -a里，要想彻底删除，输入 docker rm [NAME_OR_ID]

1
2

# 使用名称或者容器 ID
$ docker stop hello_world

自动重启容器加入 --restart=always参数，深入查看容器信息命令 docker inspect hello_world，加入--format 得到想要的指令

1
2

# 获取容器的 IP 地址
$ docker inspect --format '{{ .NetworkSettings.IPAddress}}' hello_world

删除所有名为 <none> 的镜像

1

docker rmi $(docker images -f "dangling=true" -q)

镜像构建

列出存在宿主机某个 /docker 目录下的镜像docker images；拉取镜像docker pull 用户名:仓库名，Docker Hub中有两类仓库，用户仓库和顶层仓库，后者是 Docker公司选定的优质基础镜像；查找镜像 docker search；

可以在镜像与 bash 交互的时候对镜像更改，退出之后docker commit 容器ID，但这样做会导致镜像到最后臃肿，不推荐这样做，采用DockerFile 编写构建脚本，例如在 docker中换源且安装

注意 COPY 指令只能在当前 DockerFile目录以及子目录下进行，因为其描述的是一个可重复构建的、独立于任何特定主机的过程

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

# 使用 NVIDIA PyTorch镜像作为基础镜像，这是一个基于PyTorch（一个流行的深度学习库）的镜像
FROM nvcr.io/nvidia/pytorch:23.06-py3

# 更改 apt 的源为清华大学的镜像源，可以加快下载速度
RUN sed -i 's/archive.ubuntu.com/mirrors.tuna.tsinghua.edu.cn/g' /etc/apt/sources.list

# 更新 apt 的软件源列表
RUN apt-get update

# 设置 SHELL 为 bash
SHELL [ "/bin/bash", "-c" ]

# 安装一些实用工具和开发工具
RUN DEBIAN_FRONTEND=noninteractive apt-get -y install \
        gcc \   # GCC编译器
        g++ \   # G++编译器
        zlib1g-dev \  # zlib库和头文件，用于文件压缩
        # ...（省略部分注释）
        software-properties-common   # 一个用于管理软件源的工具

# 更改 pip 的源为中国科技大学的镜像源，可以加快下载速度
RUN pip config set global.index-url https://mirrors.ustc.edu.cn/pypi/web/simple
RUN pip config set global.extra-index-url https://mirrors.ustc.edu.cn/pypi/web/simple
RUN pip config set global.trusted-host mirrors.ustc.edu.cn

# 更新 pip 至最新版本
RUN pip install --upgrade pip

# 将当前目录（即包含这个Dockerfile的目录）下的所有文件和文件夹复制到容器的 /workspace 目录下
COPY . /workspace

# 设置容器中的当前工作目录为 /workspace
WORKDIR /workspace

# 安装 /workspace 目录下的 Python 包，"-e" 选项表示以"可编辑"模式安装，即在开发环境下安装
RUN pip install -e .

Docker compose

Docker Compose 可以在单个主机上定义和运行多个 docker的工具，使用 YAML 文件来配置应用程序的服务

基本结构

创建 docker compose.yml 如下所示

1
2
3
4
5
6
7
8

version: '3'
services:
  web:
    build: .
    ports:
     - "5000:5000"
  redis:
    image: "redis:alpine"

这个文件定义了两个服务：web 和 redis。web 服务将当前目录构建为 Docker镜像，并绑定宿主机和容器的 5000 端口。redis 服务使用 Docker Hub 上的公共Redis 镜像。

常见命令

• docker compose up：根据 compose.yml文件启动服务。

• docker compose down：停止并删除由 up命令启动的所有容器。

• docker compose build：构建服务镜像。

• docker compose ps：列出由 up命令启动的所有容器。

• docker compose logs：显示服务的日志。

Docker Compose 的使用实例

下面是一个使用 Flask 和 Redis 的简单应用的示例。

首先，创建一个 app.py 文件，内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13

from flask import Flask
from redis import Redis

app = Flask(__name__)
redis = Redis(host='redis', port=6379)

@app.route('/')
def hello():
    count = redis.incr('hits')
    return f"""Hello World! This page is checked by {count} times"""

if __name__ == "__main__":
    app.run(host="0.0.0.0", debug=True)

创建一个 requirements.txt 文件，内容如下：

1
2

flask
redis

创建一个 Dockerfile 文件，内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 使用官方 Python 运行时作为父镜像
FROM python:3.7-slim

# 将工作目录设置为 /app
WORKDIR /app

# 将当前目录内容复制到容器的 /app 中
ADD . /app

# 安装 requirements.txt 中指定的所有必需软件
RUN pip install --no-cache-dir -r requirements.txt

# 让 80 端口可以让外界访问
EXPOSE 5000

# 定义环境变量
ENV NAME World

# 在容器启动时运行 app.py
CMD ["python", "app.py"]

在 docker-compose.yml 文件的 web服务中，使用了 build: . 来指定使用当前目录下的 Dockerfile构建镜像，依次执行以下指令

1
2
3
4
5

$ docker compose build
$ docker compose up
 ✔ Network docker_instruction_default    Created           0.1s 
 ✔ Container docker_instruction-redis-1  Created           0.0s 
 ✔ Container docker_instruction-web-1    Created           0.0s     

在浏览器中看到应用程序，每次刷新页面，页面上的数字都会增加。

注意如果想修改代码，必须先 build 后再起(up)。

实战要点

添加环境变量，用于设置 OpenAI API 相关参数

1

$ docker run -e MY_VARIABLE=my_value -e ANOTHER_VARIABLE=another_value

这学期按照培养方案按部就班地学习课程

毛泽东思想和中国特色社会主义，马院 fwz老师的，老师在寒假就发了课程作业，是个很敬业的老头，经常凌晨在微信群发消息，上课感觉比之前的思政课有趣一些。作业有课程十问、读书报告、课程总结三个部分。课程十问主要是介绍自己和简历，之前一直维护着简历，还算比较轻松；读书报告看了《邓小平时代》，问了一下父母对那个年代的记忆，感叹没有那个年代的改革开放，老一辈可能没法活下来，某种意义上小平同志也是我的恩人；课程总结就结合上课讲的内容阐释了一下。

习近平新时代中国特色社会主义，也是 fwz老师的，由于是同一个老师，后八周好多课内容跟之前相似。作业是思考题、读书报告、课程总结，读书报告阅读了《习近平的七年知青岁月》，总书记的人生也不是完美的，他在前途未卜时没有消极应对，而是磨砺内心，这种面对逆境的人生态度值得我们学习。

fwz老师不延期作业截止时间，结果自己申请提交成绩缓录。不过想来他一学期要上毛概、习概、中国式现代化，每门课有两个班次，课程过于繁重，期末批作业合计要看两三千篇文章（按照他的说法他会一篇一篇地看并批注）。毛概成绩是7 月 3 日凌晨四点提交的，习概是 7 月 4日下午四点提交的，实在是辛苦了。

基础物理学(3)，选的pyk，一学期照着赵凯华的《电磁学》和《热学》讲，而且也有很多有趣的内容没有涉及，总之一学期下来不怎么花时间。平时挑出课件问题或者是写自己思考都可以加分，就连课程建议也能加分，但期末比较忙也不想写这些没有意义的东西，差不多是微积分cjl 老师的翻版了。

期末期间由于赶习概论文时间比较紧迫，没怎么复习，期末考试考得一般。不过这也是本科最后一门物理课了，想来除了物理当中的一些思想，之后也不会做和物理相关的事情，无论多好的白月光都会在现实世界的冲击下消散……

离散数学(2)，软院 cl 和 lsx老师合开的计算机基础课，前四分之三是图论，后四分之一是代数结构，图论知识还是蛮有趣的，知乎上相关问题也挺有意思的，很多技巧比较烧脑，从图变换层面有极长回路、路径扩散、对偶转化，从方法论层面有数学归纳法、反证法、重合法，从算法层面介绍了Dijkstra、Warshall、Ford、匈牙利等一些经典算法，还讲了旅行商问题的近似解法，和算法分析课中的部分内容重合。群论讲了判定群的口诀“凤姐咬你”（封闭、结合律、幺元、逆元），然后简要介绍了置换群、左右陪集、正规子群，但没有抽象代数那么深入。

平时作业比较难，好多题不能直接想出来，只好参考祖传答案。还有一些上机作业，主要是基本算法的实现，也不难。期末考试不难，解答题基本都能做，填空题有些不太确定，不过分值不大。总之，这门课强化了一些计算机基础知识，很多问题也可以用图论的方式去建模，方便计算机离散处理。

操作系统，软院 wlj开设的核心专业课，课堂没那么吸引人，到后面出勤率只有 \(50\%\)。授课内容基本按照谌卫军《操作系统》一书，有进程调度、死锁、存储管理、I/O设备管理、文件系统这些内容。学完这些显然我造不了一个操作系统，不过让我对电脑进程调度有进一步的认识，一个很显著的改观是我尽可能减少了同时打开的进程，之前实在是不懂事亏待了自己的电脑。

这门课还穿插软院经典私货——Petri网，具体来说就是用两种状态类型描述系统资源的调度情况，可以形式化为一种自动机，还可以证明着色Petri 网和 Petri网表达能力是等价的。不过除了理论漂亮之外没啥可用之处，用来绘制着色Petri 网的软件只支持 Windows，最新版还是 \(2013\)年的，这个领域可以说被全世界淘汰了。。

期末考试听学长说只用看谌卫军《操作系统》这本书就问题不大，结果今年大改，完全没涉及这本书上哪怕任何一句话，还好平时有几节课去听了，每道\(18\)分的三道大题都磕磕绊绊地求解出来了，最后拿了 \(89\) 分。考试之后是大作业，在教学操作系统xv6-riscv 上实现新的文件系统，组队 \(4\) 人，我负责哈希表用来检索文件和 md5信息摘要算法。 期末展示前学习了用 \(\LaTeX\) 编写 thu 主题的beamer，整体答辩效果不错，助教直接给我们整个组满分。

形式语言与自动机，之前是 lgm 老师开设课程，今年由 gy老师第一次接替授课，相比之前增加手写实现正则表达式的大作业。实验倒是让我深刻理解正则表达式的运行流程，这可是数据清洗的重要技术。不过对每种情况逐一构建非确定自动机是真的会写吐，还要考虑各种边界情况，有de 不完的 bug，最后隐藏样例评测也没能全过，可想而知 regex.h库和 python 的 re库都是相当有水平的，不是我能驾驭的，我还是安安心心调包吧……

和离散数学 (2)一样，平时作业也有好多不太能独立解答，参考了许多资料。期末考试不是很理想，大题考了AC 自动机、PDA构造、带约束图灵机，不是很会。这门课主要教会了我如何去形式化一些“自然语言”，以及看Turing如何秀翻理论计算机领域，要说用处的话估计就是会一些正则表达式的编写规则吧。

算法分析与设计基础，软院 wb老师的，整体内容非常丰富，的确能学到很多东西，对应《算法导论》基础知识、排序与次序统计量、动态规划、贪心算法、摊还分析、字符串匹配、NP完全性、近似算法、多线程算法，老师人很好，讲课也清晰。既有数学层面的分析，也有很多算法实验，每年都有经典作业——seam-curving。这门课平时作业任务量是真的重，感觉不像是一门两学分的课。不过《算法导论》这本书是写得好，通俗易懂，零基础也能理解。

• 主定理的证明非常严谨
• 之前不太能理解动规和贪心，这本书从抽象的角度分析了这两种高级技术背后的逻辑，前者是重叠子问题和最优子结构，后者则是拟阵这一数学结构。
• NP 完全问题从规约的角度展示了 \(7\)个经典的 NP 完全问题
• 多线程的调度突然让我回忆起 Transformer 中 \(d=1024\)的用意，矩阵加速运算需要二分，当有无限多的资源时，两个 \(n\times n\) 的矩阵乘法能优化到 \(\Theta(\log n)\) 的时间复杂度

二年级男生手球，体育部 lyb老师的，老师年事已高，腿部还受了伤，不能像之前那样跟我们一起打手球比赛了。这学期难点是引体向上，从第十二周起，每隔一天在紫荆东侧单杠处练习，两只手的虎口全都磨破了，有段时间敲键盘特别痛。破茧成蝶，出了血结疤之后，结合腹部力量推动重心上移法，引体向上终于能稳定输出。十五周考核做了\(14\)个，对我来说很满意了。手球专项给分也不差，最后拿到自己满意的成绩。

实习

商汤公司，NLP见习算法实习生（语言模型设计方向），去工业界看看，的确大开眼界。很难想象能在企业做科研，而且使用的是世界最前沿的技术。

• 工作地点在中关村，骑车三四十分钟，不过打车可以企业报销，一般选择打车过去，公司能从窗户向外看到北京大学的博雅塔，每周去三到四天（一般是周末和平常一两天的晚上）

• 公司资源非常丰富，只要是从研究的角度出发，基本想有什么就有什么

• 公司的算力是海量的，对我而言，可以随时调用 \(2^7\) 张 A100并行训练几百亿参数语言模型

• 发布会之旅

  • 4 月 8日：到达上海商汤科技人工智能计算中心，也是商汤科技算力之源，旁边就是特斯拉工厂

  • 4 月 9日：接连几天在计算中心调参刷分，发布会展示的八个项目当中有两个项目和我们组相关

  • 4 月 10日：发布会现场演示我们训练好的语言模型，还跟许多投资人交流一些技术细节，当晚打车到外滩，遇到好多热情的上海人帮我们拍照，直到凌晨两点才找到企业能预定的酒店

  • 4 月 11 日：发布会很成功，股价大涨，mentor带着我们组在上海外滩附近坐游轮，吃了好几顿正宗上海菜，期间在出租车上听荷塘雨课堂，晚上飞回北京返校

科研

这学期主要是把之前软件学院 SSRT的项目结题，报名参加今年的挑战杯，由于没什么亮点，就按照一些既有的压缩算法汇报展示，今年校科协提交材料特别早，导致很多内容特别仓促，最后“挑战杯”拿了三等奖。

社工

校科协，“挑战杯“展览现场工作人员，在各个展区到处转，软院的展区实在是比较冷清，lfh的特奖项目是一个软体机器爪，很有意思。今年行健书院的挑战杯项目质量特别高，遇到了高中陪我一块学物理竞赛的qyy 学长，他们做了一个轮椅。

总览全场，我至少找到三个项目在整体框架上雷同，不过应该是各书院和原院系重合的原因。在展览过程中，我在公司老板的老板还来了，他是自动化系的三字班学长，人称“鼎爷”（CEO也这样叫他），跟他聊了一会儿科创经历，不过他一个月之后从公司离职了，想必他有自己的想法。

软院科协负责 ReadMe项目，开学期间写了一个征集推送，号召软院的同学多投稿，分享学习经验，接着熟悉了一下mkdocs 框架，往仓库里更新了一些投稿内容。

志愿

答疑坊，本学期继续在答疑坊工作，进入答疑坊队委，协助管理答疑坊。原本每两周去一次，由于周二其余队委都没空，改到每周二晚上都在答疑坊值班。

“温故而知新”，我在给别人讲授的时候也对知识有更新的理解，比如克罗内可内积、几何平均矩阵、刚体转动动能合成方法、世界线与狭义相对论、oop工程细节 debug、配置 vscode编译环境等等，每次走出答疑坊，相信和各位来答疑的同学一样，我也收获不少。

这学期学生发展中心也积极组织和各位基础学科授课教师开展座谈会

• 微积分教学组那帮老师尤其是 wxf语出惊人，对教育界指点江山，不过目前来看高中和大学之间教育的脱节一时半会儿也不太好解决
• 线性代数教学组老师都很好的，许多线代中文教材的编者出席，他们对整个线性代数课程的设计颇有研究
• 大学物理教学组比较抽象，在问卷“希望了解什么情况”一栏里面填写的“任何情况”。物理是一门实验科学，有个物理老师利用详实的“签到组”和“非签到组”实验数据，最后论证出“物理课的学习还是需要依靠自身”的结论，懂了，学得不好跟老师无关……

Model bias & Optimazitionissue

训练过程中，先对 training data 的 loss进行判定，如果大，则考虑两种情况

• 模型不够弹性（Model bias）
• 优化器做得不够好（Optimization）

搜索范围不够广还是优化器不能达到全局最优（SVM）？

如果发生下述情况，则说明优化器做得不够好 \[\begin{array}{|c|c|c|c|c|c|}\hline & \text { 1 layer } & \text { 2 layer } & \text { 3layer } & \text { 4 layer } & \text { 5 layer } \\\hline 2017-2020 & 0.28 \mathrm{k} & 0.18 \mathrm{k} & 0.14\mathrm{k} & 0.10 \mathrm{k} & 0.34 \mathrm{k} \\\hline\end{array}\]

优化过程中 Loss 趋于不变，\(\nabla f\to 0\)，可能在Local minima 或者saddle point，区别方法：Hesse matrix分别正定、既不正定也不负定 \[L(\theta) \approxL\left(\theta^{\prime}\right)+\frac{1}{2}\left(\theta-\theta^{\prime}\right)^TH\left(\theta-\theta^{\prime}\right)\]

在鞍点处往 \(\lambda<0\) 对应的特征向量方向 \(\vec{u}\) 优化，\(H\vec{u}=\lambda \vec{u}\LongrightarrowL(\theta^{\prime})<L(\theta)\)，但实际中涉及二阶导和求解矩阵特征值运算，几乎不用。

维度高代表参数空间有更多的路可以走，实验给出，Hesse matrix中特征值大于 \(0\) 的比例大多数集中在\(0.5\) 附近，即多数情况下是卡在saddle point。

Critical point

Batch

不用所有的训练资料计算梯度，随机混合分组，每组 Batch更新同一组参数，能够节约时间，虽然噪声影响大，但轮数多。（Batch大不一定计算梯度时间长，现代硬件有平行运算能力）

大的 Batch-size 往往得到比较差的模型，在 Training data 和 Test data上正确率都比较低，这是 Optimize 问题，因为不同的 Batch形成的噪声能更好地跨过 saddle point。小的 Batch-size 在Test data 上也表现好（一种解释是 Small batch 更容易进入“平原”）

Momentum

在原始梯度下降（Vanilla）中加入惯性，引入 \(m^{i}\) 为每次改变中的质量，\(g^i\) 为每次计算的梯度 \[\begin{aligned}m^2&=\lambda m^1-\eta g^1\\\theta^2&=\theta^1+m^2\end{aligned}\] 容易跨过鞍点

Learning_rate

Adam means Adaptive momentum.

Root Mean Square(Adagrad)

在一个等高线椭圆狭长的优化问题上优化

更新参数 \[\theta_i^{t+1} \leftarrow \theta_i^{t}-\frac{\eta}{\sigma_i^t}g_i^{t}\] 对每个参数 \(i\)，使用前面梯度的方均根给参数 \(\sigma_i^t\)，如下 \[\theta_i^{t+1} \leftarrow \theta_i^{t}-\frac{\eta}{\sigma_i^t} g_i^{t}\quad \sigma_i^t=\sqrt{\frac{1}{t+1}\sum_{i=0}^t\left(g_{\dot{i}}^{t}\right)^2}\] 即如果当前更新速度一直很慢的话可调大学习率，否则降低学习率

RMSProp

Google 使用的优化器

上述要求梯度基本一样，加入超参数 \(\alpha\) 表征前者调整的比例 \[\theta_i^{t+1} \leftarrow \theta_i^{t}-\frac{\eta}{\sigma_i^t} g_i^{t}\quad\sigma_i^t=\sqrt{\alpha\left(\sigma_i^{t-1}\right)^2+(1-\alpha)\left(g_i^{t}\right)^2}\] Adam：RMSProp + Momentum

Learning Rate Scheduling

随着训练进行，将学习率本身不断减小

Warm-up 黑科技，在训练初期逐渐增加Learning_rate，代表初期探索

Overfitting

上述过程均检测正常，即 training data 中loss 较小，但 testing data 中loss 较大，一个极端的例子是

Training data: \(\left\{\left(x^1,\hat{y}^1\right),\left(x^2, \hat{y}^2\right), \ldots,\left(x^N,\hat{y}^N\right)\right\}\) \[f(x)=\left\{\begin{array}{cl}\hat{y}^i & \exists x^i=x \\\text { random } & \text { otherwise }\end{array} \quad\right.\] model 越大，overfitting 的概率越大（另一种为mismatch，就算有更多的资料，训练集和测试集的分布不一样）

解决办法：

• Data augmentation，将图片水平翻转或者放大让训练集变大

• Constrain，让模型限制在某些函数上

• 共用参数，限制参数 \[\text{CNN}\in \text{Fully-Connected model}\]

• N-fold Cross Validation，提高 private-data 准确率

L2 正则化和 weight decay 是一样的，L2 正则就是权重衰减。

还是照例谈谈这学期的学业情况，大二上学期一共上了 \(12\) 门课程，共 \(31\)学分（按课序号排序，不分先后），记了两门 \(PF\)，一门多音，一门马原，实际只有 \(25\) 学分。

Matlab与科学计算，一门随便报的任选课，主要是想学一下Matlab，期末写了一个随机游走的模拟程序并对曲线进行模拟，曲线形状=为反比例函数，查找了很多资料提到平均自由场理论，但由于时间原因，没能深入了解。交了报告之后助教批改了，私聊之后助教说我大作业写得不错。这门课平常主要是对Matlab的各种功能加以介绍，开课老师是航院的，非常典型的工科院系了，说来惭愧，一学期只去听了第一节课，后面基本就是面向作业学习，不过还是学到Matlab 很多东西，之后也用 Matlab 处理实验报告，也算是有一定收获吧。

多元文化中的音乐现象，听说是艺术课组中非常好的课了，任选要砸一志愿，而我当时砸的刘慧凝老师的沟通表达与基础，结果掉了，白给。秋季开学的时候跟lrf 一起手选，结果有半天的时间差吧，导致只有我手选上了，lrf比较遗憾没有选上。后来上课遇到 qqc 和lfh，之后课堂展示的时候就跟他们组了队，算是一种比较特殊的组队方式了，一般都是随机分配。我们以jazz为载体，结合疫情放开编了一个小话剧。线上播放提前录制的视频效果欠佳，还好有lzc 公子哥打了个圆场，总体印象应该不错。期间我跟 qqc由于对艺术一窍不通，就主要负责联系淘宝商家剪辑视频，给视频当中的画面加上微信发送信息。

前八周的时候罗老师讲卡农的时候还是比较有感触，加上忙的时候自己平常也喜欢听古典音乐集中精力，就以罗老师结尾“你眼中的卡农”为题，写了一篇报告。由于上学期被诗词这种偏艺术创作的课程背刺，这学期疫情可以有两门课程记PF ，我就把这门课记了PF。结果前几天上树洞发现可以在网络学堂已批改作业里面查看分数，原来罗老师设置了不公布分数，其实在HTML 里面就是加了一句style='display:none'，内容还是可以在网页源代码里面看到，结果就看到自己拿了\(97\)分，有点小遗憾吧。写报告的时候我已经记了PF，也许就是比较真诚的心里话打动了罗老师吧，后来她又调整为 \(93\)分，不知道是计算了课堂展示，还是单纯的调分，反正 P 了一个 4.0……

复变函数，物理系 lys老师开设的前八周课程，老师上课挺幽默的，最后几节课还给我们透露了期末考题方向，半期考试相当于就是这门课的期末考试，五个大题，回忆版在此。考试的时候还是有一点小慌，毕竟题量小、分值大，稍不注意容易翻车。当时留数定理第二个题差点没有考虑到挖去两个点，不过总体还行。考完期末之后还可以提交小论文加分，听说之前疫情期间松神挂过将近三分之一的同学，还是比较恐怖。

这门课学到的知识倒是基本快忘了，毕竟计算居多，不过松神教会我们如何使用Mathematica 软件，这确实是工科专业必备软件了，djl 他们大一上费曼物理学(1)就要用这个数学专业软件，还是挺有趣的。关于松神还有一些人物轶事，可以看看这篇新闻。他还教大学物理、分析力学、数理方程、基础物理学(3)，是个比较顶的老师，江湖有“四大松学"之说。他的研究方向为粒子物理和量子计算，算是理想中真正搞物理的大佬了。

基础物理实验(2)，未央专属课程，老师跟基物实验 (1)一样，总之大家都是怨声载道的。有了上学期 \(\LaTeX\) 经验，这学期找 gha 要了 typora的仿论文样式，写实验报告快了很多，加上这学期有一定的 Matlab知识，绘图什么的不在话下。前半学期最忙的时候可以当天做完实验当天交实验报告，报告均在\(90\)分以上。塞曼效应那次实验遇到环境学院的lhgg，挺好说话的助教，在跟他交流了有关磁场和电流的变化特性之后，他提示我往磁化曲线方向去考虑，由此实验报告有了亮点，第一次在基础物理实验中取得\(95+\) 的成绩。这门课也罕见地拿到了\(A\) 的等级，也很欣慰。

基础物理实验(3)，未央电的专属课程，当时看自己还有学分就顺便上了，这个实验主要是电磁学相关，老师是gxb。老师给分超好，次次 \(95+\)，最后一次实验报告由于涉及计算机编程模拟同轴光子晶体，给了$100 $ 分，报告详细内容可以看这篇，最后当然顺利拿到\(A\)，这学期两门基物实验课双开，从第四周开始几乎每周都有实验，尤其是中午一点半的实验真的犯困，在巨大的压力之下还是顶住了，本科物理实验就此结束咧。

二年级男生乒乓球，wx老师的的乒乓球课，由于自己从小学到乒乓球打到现在，对弧圈、左右旋、上下旋有一定概念，对我来说还算比较轻松。不过还是有些大佬，他们发球我需要一定时间才能破解。之后疫情转为线上授课了，之后的比赛就取消了，转为录制乒乓操视频。这学期要测试\(3\text{km}\)以及立定跳远，成绩没有去年好了，主要是今年学业压力太重了。。

量子力学(1)，cx老师的，主要是看到培养方案大三下这门课必修，就提前学习，反正如果半期考试考差了就退课，结果半期考试巨简单，考了\(99\)，就还是继续撑下来。量子力学说实话国内没有讲得很好的教材，这门课用的曾谨言《量子力学教程》，书如作者其名，写得跟数学书有得一拼，用公理-引理-定理-例题书写逻辑，门槛很高，不过认真读下来还是有很多收获。

不过赵凯华的《量子物理》简直就是玄学，各种描述性的文字，我们学习量子力学又不是去调用量子力学API，而是学习背后的逻辑，整本书甚至都称不上量子力学的说明文档，连调用层级都是乱的，总之这本书骂声一片。赵凯华的《热学》那更是玄学，个人觉得热学的公理化不是很能让人信服，热学是更偏向唯象的一门学科，不过深入到统计部分后会好一些。扯远了，总之国内的教材一言难尽，还是多参考国外的教材吧。

前半期主要是涉及薛定谔方程以及相关算符的计算，半期考试难度上甚至达不到基物。后半期收获很多，本质上是物理学家绞尽脑汁去求解薛定谔方程，有氢原子能级、朗道规范、\(J-S\)耦合，思想上有表象变换和微扰论两种很深受启发的处理技术，按照老师上课的说法，表象变换就是“换皮肤”，确实很形象，对应线代里面的相似型。微扰论本质上是物理学家常用技能了，江湖称“放小量”，跟机器学习用线性函数模拟任何函数有点类似。期末考试跟半期一样，\(7\)个大题，开始前两个题没有思路，还好考试前听助教习题课说可能涉及上半学期知识，没想到两个题的最终落点都是在不确定性关系，还是顺利解答，期末\(J-S\) 变换没理解题意，拿了 \(93\) 分。

寒假期间向老师提交了关于束缚态量子数可数性质的证明，主要是结合离散数学(1)中的无穷基数，陈老师赞许了我的工作，并提出量子力学目前仍待完善的观点。的确，总感觉量子力学没有出现一种像分析力学那样对整个经典力学系统比较系统的描述，当然也有可能我学得不够深入，量子场论对这方面应该有更加抽象的叙述。原意是想申请\(A+\)，但陈老师貌似没有正面回答这个问题。

基础物理学(2)，csm老师的，讲授内容是光学和量子物理，第四周有个challenge-test，就报名参加了，当时跟初等概率论和奖学金评定三天连着考，还是比较麻。challenge-test还考察了上学期相对论的相关内容，当时对不确定关系还没有深入理解，脑子里只有\(\Delta p\cdot \Delta x\geq\dfrac{\hbar}{2}\) 这一个公式。challenge-test 考过了，直接给\(A\) 的成绩。半期的时候 zcy让我去开一个半期小班辅导，对自己的 reputation 有益，当时编写的讲义在这里，使用\(\text{Q-book}\) \(\LaTeX\) 框架，现场到了 \(20\) 余人，加上线上有 \(50\) 来人，还算是比较令人满意。

不得不吐槽一下基础物理学的上课逻辑：力学-光学-量子力学-电磁学-热学，请问这是物理学的发展逻辑吗？学量子力学的时候使用部分分析力学的知识暂且不提，涉及到粒子在电场磁场中咋办？例如氢原子磁矩如何解释？真的为教学质量担忧，学生其实最后就只学到了如何调用物理的API，跟高中学习导体棒切割磁场一样，学生根本不知道来龙去脉，物理学成为了公式学。。

离散数学(1)，软院 lsx老师开的，内容是数理逻辑和集合论，前面数理逻辑学了一堆感觉翻来覆去还不如真值表快，期末考试唯一需要列真值表的题目结果没看到用字典序，后面集合论学了很多定义，有自反、反自反、对称、反对称、传递，以及满足一些条件下的逆序、偏序、全序等关系，还学了集合论的公理化系统，在量子力学中有关能级分离的证明中发挥了重要作用，期末考试寄了，客观题错太多题了，还希望sxjj 捞捞我[可怜]。

这门课 sxjj捞得厉害，期末考试客观题做得比较急，主观题反而做得好一些。客观题犯了很多低级错误，实在是不应该。下学期开始对计算机相关的专业课要走心了，不然容易酿成惨剧……

数据结构，软院 dgg老师开的，学习了各种数据结构基础知识，有平常小作业、oj作业和期末考试，oj 最难写的就是 kd-tree，用完了所有次数（共 \(5\)次）才过，耗费了好几天时间，平常小作业感觉无理取闹，没啥意思，但是总是犯些低级错误，每次要被扣许多分。

期末考试个跟考研中的数据结构题目差不多，这里有一份数据结构复习笔记，主要还是理解各种逻辑结构、存储结构以及相应的数据操作。考完之后第二天跟大师对了一波，客观题问题不大，代码填空题没能很好理解题意，有几个空不对，后面大题就比较放水了，就是些归并排序、插入排序、最小生成树、拓扑排序比较基本的内容。

初等概率论，统计学中心 dwl老师开设的前八周课，课程前期讲了一些很偏分析的内容，比如 \(\sigma-\)代数、Boral 集合，后期就是一些经典的期望、期望、协方差、大数定律以及结合各种分布下的应用。考试有期中和期末，最难的还是概念判断，毕竟我们这种学工科的各种近似放到嗨起的比不过理科人的严谨，错了几个判断题。半期考得还行\(94\)，期末不知道咋样，dwl老师说不透露，的确，如果提前让我们知道自己情况，课程替代对于其他同学不公平。期末自我感觉还行，没有完全不会的题，后半期课程替代原培养方案中“概率论”一门课，最后顺利过关。

马克思主义原理，马原院长 zad老师的，任务量比较重，但挺适合我这种不怎么懂政治的。有慕课、小班讨论、线下上课、读书报告、期末论文。zad老师还是我们四川乐山人，在仕途上很不错了。他上课还给我们讲怎么写好读书报告和期末论文，多写一些人生经历和个人感悟，少一些空话套话。读书报告看了《共产党宣言》和《帝国主义论》，对马克思主义萌芽初期的历史和发展有一定了解。期末报告写了一下全球形势，自己感觉也没分析啥出来。。最后反正也\(P\) 了。

志愿

软院迎新，暑假的时候报名成为软院迎新志愿者，在新生报道现场负责给新生登记学籍档案，顺便认识认识软院学生会的一帮人。有肯德基早饭，忙了一上午，当天太阳还比较毒辣，还吃了好几个雪糕，看着各种活蹦乱跳的吉祥物，青涩的学弟学妹们，还是很高兴的。

答疑坊，这是大学以来最走心的志愿，开学初期答疑坊招新面试通过，从第四周开始双周坐班，这个志愿充分体现“费曼学习法”的好处，来答疑的主要是微积分A(1)和线性代数的知识，把自己“学会”的知识重新给别人讲一遍之后的收获是不一样的、在答疑过程中，我经常对知识有更加新奇的认知。当时学这门课的时候毕竟也是抱着通过考试的想法，有些知识没有深入消化，尤其是线性代数，这门大一的公共基础课内容是真的丰富。答疑坊这个地方真的是高手云集，在志愿者群里面问问题基本都有人能求解。

期中的时候收到来自学姐、学妹、学弟的喜报，大四学姐微积分 C 半期80、大一学妹线性代数半期很不错、大一学弟微积分 A(1) 半期99、幸甚至哉。他们分享的喜悦让我在匆忙的期中周也很开心。

后半期我拓宽了疆域，开始接离散数学、数据结构等计算机方向订单。不得不说，在答疑坊这个地方，我能够即时地了解到各大院系培养方案的差别，比如电子系大杂烩离散数学，经管学院各种错误代码满天飞的数据结构，计算机系程序设计基础跟数据结构难度有的一拼的算法部分。成外几个学弟学妹也经常问我程设的问题，他们像极了当年的我，代码风格脏乱差，代码习惯还得从小培养。

科研

这学期 SRT 报龙明盛的课题，结果被拒绝了，主要是报的同学都太强了。不是129奖学金就是国家奖学金，我一个非软院血统的排不上号，不过也有可能有其他因素吧，进龙组还是比较难的。

然后听 zcy 的建议选个贵系的SRT，然后就报了关于因果推断的，这学期下来熟悉了一下知识图谱和 PC算法，做的主要内容是 AI forScience，还有个医学院的哥们儿，有很多的生物医学名词搞不太懂。不过这方向上的paper 发表在机器学习会议上，最重要的还是 AI的设计，说大点叫机器学习领域的落地，说小点叫医药蹭蹭 AI 的热度。

不过我们只有三个人，大家都太忙了，毕竟没有target，也不知道这个项目最后会以什么方式呈现结果。

社工

校科协这学期貌似没干啥。

贵系科协组织了一次见面会，大家相互介绍了一下，高老板阐述了相关工作，之后开展了几次AI 学习小组，不过在预料之中，这个项目自然而然地烂尾了，讨论 AI最后变成讨论作业。

软院科协负责 ReadMe项目，传了很多大一下学期记的电子版笔记，志愿工时真的丰厚，知识就是力量。这学期每隔几周就举办技术部例会这种形式还很好的，大家聊聊最近学习中遇到的问题，吐槽一下，顺便分享一些trick，学习到很多 mac terminal 相关插件，直接一个brew install 就装好了，至今也还很有用。

这种举办方式能让组员凝聚起来，大家唠唠嗑挺好的，毕竟大家课业都很繁重，这种方式既能放松心情，也能学习到更新的技术，一举两得。

之所以写这个大一学年总结，是因为看到很多学 CS的前辈们都喜欢在稍微放松的节点总结一下。之前高中的时候没有这个习惯，感觉时间过了就过了，忙完这件事情总有下一件事情要忙，权当写一个像样的大一总结吧，也希望看到这些的你有所启发。

暑假

高考，也许上天还是看得起我的努力（如果之后有时间我可以详细叙述一下我高中的破防时光，不过现在觉得也是一笔财富），高考成绩误打误撞地考上了华子的（半个？）CS，有欣喜，也有忐忑，不知道在这条全新的道路上自己究竟会发展成什么样子。

学车，高考完后几天在一个露天坝花了一上午的时间学会骑自行车（手动捂脸），接着暑假先是和绝大多数毕业生一样报名学车，在闷热的夏天里每天重复着同样的动作，个人觉得还没有在华子脱靶骑自行车好玩，学车就和几个在县城读书的高三毕业生一起学，之间也很少有交流，教练也经常刷短视频，不得不再次评价短视频推荐算法的厉害，反正感觉好多时间就在这种无聊透顶的驾驶中消逝。科一科二顺利一把过，但暑假后期由于开学比较早，科三没预约成功，就只有等着寒假再说。

游泳，八月份联系上教育园区的游泳班，想的是毕竟在华子毕业游泳不过不行啊，就去学了个蛙泳，小学的时候我还有好几次去游泳馆被水呛到发烧的经历，心理上不是很能放松。跟一堆5、6岁的小孩一起学游泳，真的是搞不懂，明明我都知道阿基米德原理，结果自己的平均密度很容易变高，老是减少排水量，那些小朋友在水里面都开始到处耍了我还不得要领……反正前半期还学得比较难受，后面掌握到技巧后慢慢的就会了，后面几次就在1.4m的水池游来游去，反正至少淹不死了……游泳的话前面由于刚学会骑自行车比较兴奋，每天骑一个小时到郊区学游泳，后面发现晒黑了，就改乘公交车。

编程，在母亲大人认识到的一位从业者的建议下，开始啃《C++primerplus》。虽然现在看来这种入门方式非常不友好，并且当时啥也不知道，拿着破windows 电脑（其实在后面我的调教下还蛮不错的），安装 Vs6.0，画风如下图。真的搞不懂，那个时候我自己的鲁棒性堪称极高，在这样的界面以及各种过时C语言规范折磨下，我还能把那本将近七百页的书看个八九不离十，做完大部分现在看起来几乎没什么意思的习题，虽然大部分忘了……然后我承认是看到python 语言各种天花乱坠的宣传，也搞了一点点 python，主要也就是熟悉python 语法。

夏令营，严格来说不算是一个夏令营，就是一个线上的讲座吧，主讲人是华子宣传片《追光少年》里面的角色原型，研究立方卫星的，主要是讲他们实验室的工作，反正也听不懂就报了名。最终有两个作业，一个是弄一个单片机，一个是用matplotlib结合数据绘制卫星的轨迹图。当时觉得前面那个挺有趣的，就买了个单片机，配置了一堆硬件软件，最后把硬件语言烧在芯片上，大概跟zcy 的数字电路实验比较相似，只不过我们这个是超级低配版的。好在有 C语言基础，照着 PPT上的代码结合网上的参考资料，还把进阶内容也做了出来（呼吸闪光灯），感觉效果还行。

暑假大概就这样，当然免不了毕业典礼、宴席、经验分享以及杂七杂八之类的，主要大部分时间生活在县城，同学之间来往很少，就这样，在教练车的兜兜转转中，在阳光下聒噪的蝉鸣中，在跳来跳去的黑框框，暑假就这样过去了。

其实现在想来，那个暑假有点封闭，跟之后寒假生活亦或是今年的暑假相比，感觉自己懵懵懂懂，也没跟外界或者是其他人有交集。

秋季

初高中那时幻想大学的生活会很丰富，但是上了华子之后，还是真的感觉事多。学业上写沟微积分线性代数程设每门课都比较硬，每周都要花很多时间，尤其是那个时候乖到所有课都到教室，所有习题课都去听，所有作业都独立认真完成。

学业

秋季学习一共上了 \(8\) 门课程，共\(24\) 学分。

军事理论，考前认真复习了，主要是成外学长们有齐全的资料，感想提前写在参考资料上，感谢这些资料让我大学开局\(A-\)。

写作与沟通，主题是数字化生存，其实现在看起来这个主题还蛮适合的，至少我的博客是这样的。ZYY人美心善，是个宝藏老师，让这门课的痛苦减轻了不少。短文写了一个贴吧现象，自认为比较烂，长文总体框架选择得比较好，从媒介发展视角探讨了微信“拍一拍”流行的原因。虽然这些传媒学方面的知识之后应该是用不到了，但至少学到的文献查找以及一些写作技巧还是很有帮助的。

微积分A(1)，WXF 的课对我来说真的nice，他从数的起源开始讲起，自然数、有理数、实数、良序关系、绝对值、指数对数、三角函数，一切被中学数学公式化（或者说功利化）的符号在几条公理的基础上就能建立起来。

最有印象的是 WXF第一次开放线下答疑，同学们“蜂拥而至”，当时好像是用阿基米德公理证明选择公理什么的，我们思考了好久都解不出来，WXF直接口述证明过程，赞叹不已。前几次作业，每次作业花上十个小时都不过分，有的open question 想不出来，还让我不得不去看实分析教材……

但是不足的是，从功利的角度，WXF上课对考试帮助不大，毕竟平常都深入数学的深刻本质去了，哪有时间讲怎么算对考试的那些题……好在当时维持了高中刷题的好习惯，提前做了一些往年题，保持考试手感，这门课至少没寄掉……按照WXF 的说法，期末解答出附加题的同学且总评 \(\in[90,100]\) 的同学总评是 \(A+\)，当时发下试卷看了一下附加题，好像是用一个积分中值第二定理再处理一下就能证明，就先做了附加题，最后拿到人生第一个\(A+\) 。（手动狗头）

线性代数，JY 姐姐的课，比较 nice，讲课 ppt非常数学，满篇都是公式，不像 WXF 还放点 Geogebra作的图，但思路确实比较清晰，至少对于我这种代数基础比较薄弱的很友好。还有JY 每次作业都有些补充题需要多动一些脑筋，而且他们作业都是手批，比 WXF的助教认真多了（ WXF 助教基本到期末才改平常的作业） ，可见如果是 JY的助教工作量是有多大。

比较有印象的一节课，她讲到正定二次型的时候，举了一个薯片形状为马鞍面抗压能力大的例子，还挺有趣的，JY姐姐难得在课堂上笑了一次。虽然有时候下雨的冬天坐在五教会犯困，甚至有次把笔记本落在教室了，还好一位日新的好心人帮忙送还，但是JY 的课也很推荐，至少学到了很多东西。

程序设计基础，软院 LYS老师的大硬课，这门课来年春天的时候被评为优秀课堂。其实个人觉得这种课其实上课啥的都不重要，最重要的是动手实践。经常在LYS 老师课上写 JY 的线代作业，然后 LYS老师讲到他在美国读书什么什么的就认真听一下……

每周四都要上机，在东配楼，机房电脑上全是灰尘，随着课程的进行，后面和链表相关的题真的让人头疼，感觉用数组做呢，感觉过不去，用链表呢，链表要手写，太麻烦……然后当时助教让我当组长，结果就成了PPT 制作者 + PPT 报告者……虽然增加了工作量，不过也能锻炼自己。

然后临近期末就是头疼的大作业了，助教给了一个大约 800 行用 WIN32编写的框架，要求实现一个横版闯关游戏，那段时间是真的肝，而且当时一点模块化思想都没有，一个文件写到底，一旦调不出来直接塞到全局变量去，到后面加个按钮都非常炸裂。当时的启蒙书是毛星云的《逐梦旅程：Windows游戏编程之从零开始》，哎，没想到浅墨竟然就在我大作业交后两天辞别人世，我一直记得《逐梦旅程》中的一句话：

谨以此书献给所有怀揣游戏开发梦想的人们，因为，你们不是一个人在战斗。

愿浅墨在天堂实现他的梦想，逝者安息。

期末考试五个题，一堆码农题，写起来还挺难受的，当时不知道一些技巧，有个题要讨论八个方向，直接复制粘贴改数据八次……然后最后一个算法题，还以为自己没法做出来，但当时还有将近两个小时的时间（手动狗头），就拿出纸笔开始写思路，当时想测一下穷举法能过几个，然后写了一堆for，提交，结果就神奇般的过了，对，除了处理初始数据有个优化之外，其他啥都没优化，直接就给过了，然后三小时考试一个半小时提前交卷……LYS老师是图形所的，之后还会提到他。

体育(1)，WJH老师，是一个和蔼的老头，经常口出一些顺口溜，“祖国好，清华好，无体育，不清华，全面发展我最好”，清华的3000米是真的难受，对于我这种初高中跑1km都难受得要死的体育差生简直是五雷轰顶。不过跟着清华阳光长跑的氛围，经常在紫荆操场上跑步，逐渐在耐力方面有所提升，长跑项目还是可以练的嘛，贵在坚持。反正最后体育成绩也算可以接受。

思想道德与法律，ZXM老师，这门课任务量挺大的，分组小组展示。个人其实很讨厌这种小组活动，感觉跟生产队一样，分组也全看运气，如果分到摆烂组是真的难受。当时还选了一个组长，结果我实在看不下去，好多事情被我一个人包办了……

然后不得不说，有次上课一个同班好朋友拉我翘课去写微积分作业，结果那堂课就签到了……也没有怪罪好朋友的意思，当时我自己也没有定力，思修教室人很多很闷，特别难受，觉是睡过好几次了，课也没听进去几个字，思修群倒是特别热闹，好像老师也不怎么管，都让大家畅所欲言，唯一的收获是一堆表情包……就这样咯，本来对这种从小到大都不感冒的课程无所谓。

英语听说讨论，Matthew的课，一个新聘请的外教老师，本来对华子的英语课抱有希望拯救我这垃圾英语，没想到还是失望了……前面几节课认真听讲，后面结果摆烂，上英语课的时候当天程设小作业就放出来了，于是在英语课堂上写代码，然后个人presentation 还行，结果又是 group presentation随机分组难受，一堆人摆烂，好多事情都是我做的，结果最后展示的时候组员忘词是真的无语了好吧……反正跟zcy 学长说的一样，华子英语课上是学不到东西的……

未央工程导论，究极大屑课，跟贵系的信息技术科学概论有的一拼，未央十二个专业方向“百饼齐放”。而且这课还要签到，签到学号十分随机，时序数据预测很难。有次讲座是副校长，直接让半个未央的同学全来签到，还记得那次室友在群里一发，我们宿舍剩下三个人马上骑车飞奔到现场，真的是有惊无险。好在那堂课讲课还行，用一个动画展现了排队中的统筹策略，授课比较风趣。不过这门课是真的难受，还要写两篇报告，照着PPT 修修补补，总算弄完了这个烂摊子。

SRT

未央工程导论中间有几堂课是导师引领相关研究方向，然后 SEY老师开始画大饼大法把我们一半的同学骗到 SRT项目中（包括我），项目题目叫二次曲线曲面函数求交库，是关于数学方面很底层的求交算法实现，前期对git 命令不是很熟悉，以及对整个 SRT项目抱有太多期待，投入了过量的时间……总之，顺着 GEMS 项目迁移了许多函数到GMT中，得到相应的测试，但感觉浪费了不少时间……不过，大一需要尝试，也算是一个经历吧……

寒假

高中助教，年前回了趟成外当一个培训机构的助教，顺便和lsq在成外附近把好吃的又都吃了一遍，新开那家翘脚牛肉店味道不错，反正每顿饭都可以报销，就还算吃得痛快。还有一次吃了简阳羊肉汤，之前我家楼下有一家羊肉汤店，烟囱直上，出口基本就我们家窗户附近（我们家顶楼），每天中午都可以闻到非常浓郁的羊肉汤味道，可能开始觉得有点腥，后来闻惯了真觉得这是独特的家乡味道。确实吃着比较爽，还记得当时为了报销，把票分成了两次。

“给我卷”，期间给 zcy说了目前的成绩，他特别兴奋，直接打来一个电话，我记得当时这个电话打完，我绕着成外不知道走了多少圈，他对我很是一番鼓励，还专门拉了一个群，跟罗哥一起提前卷卷下学期的课程。也算是那次真正认识了zcy吧，之前高一的时候跟他一起在东五楼学竞赛，现在他确实混得风生水起，本来刚刚开始大学生活比较迷茫，他算是让我少走了好多弯路。

约饭，时期间还约了高中的英语老师在猫爱上鱼这家店吃烤鱼，她送了我一个笔记本，然后互相聊了聊近况，高中低迷期间她经常鼓励我，我还是很感激她。在四处逛教室的时候还见到了高二期间的高中班主任，我们在外面吃富顺豆花，他疯狂安利上海这座城市的好，他也感觉是个有趣的人，每天乐呵呵的。心态确实好，当年被各种竞赛教练“围攻”，还是安心教书，跟学生关系也挺不错的，对其他老师都没有怨言，我们也聊得开，高考前经常找他聊天，也很感激他。

说起来，高中过去小半年了，怀念的还是最纯真的那些老师，而不是各种以功利为导向、用奖金刺激、搞特殊化的竞赛老师。也有可能与竞赛上的失利有关吧，或者说是另一种形式上的PUA？总感觉竞赛这段岁月很不真实，很难想起那些年中存在温情的时候了，倒是留在普通班各位老师同学的鼓励让我觉得自己经历过高中的青春岁月。有次晚上考试监考还碰见了现任副校长的物理竞赛教练，他问我回来想干嘛，我直接回怼了一句“挣钱”，直接结束话题，后来他也就没来问我了。

过年期间，当年还是要享受过年的气氛，虽然还是到处都有疫情，大年初一乐山大佛一日游，大年初六青城山一日游，还是感谢老爸，都是当天去当天回来，路上我基本都在睡觉，而我爸不仅跟我们走了全程（微信步数20000 步+），还开了往返的车。

中间几天就是到各种亲戚家串门，各种吃吃吃、耍耍耍，老屋里那个平板上的植物大战僵尸2从来都是过年的时候我推进进度，寒假期间貌似又通了两个地图，这种塔防游戏设计确实有意思，尤其是能量豆的合理使用，增加了非常多的不确定性。

之后就是 SRT那边推进度，主要问题还是有一大半的人摆烂，基本就三个人在做事情，推进过程中也耗费了不少时间。间有次去考科目三，结果两次都是最后靠边停车没到位，还是有点气，不过也没法。最后跟ly 一起从简阳坐飞机回到北京，开始大一下的生活。

春季

学业

春季学习一共上了 \(16\) 门课程，共\(26\) 学分（不算 PF 的）。

微积分A(2)，一如既往地选择了wxf，前半学期听课出勤率挺高的，能有 50-60%吧，后半期大多时候就没怎么听了。前半期 wxf依然是一如既往地天马行空，讲了许多数学上比较抽象的概念，比如范数、凸集、双线性、梯度下降法、勒让德变换、Gamma函数等一系列知识，不完全统计的话涉及到高等代数、泛函分析、机器学习数学部分、数学物理方程等各种课程。

一如既往地，认为讲的这些和期中考试没有半毛钱关系，结果挺难的，印象中压轴题是平常一次作业题，结果没做出来，就没上90分，还挺亏的。后半期就基本没怎么听了，讲的都是些电磁学里面基本都会用到的东西，主要熟悉了一下数学意义上的缠绕数，没记错的话后半期几乎就没听过课。

作业的话每次都使用的 markdown格式，跟大师学的，各种数学方程式的排版技巧基本都掌握了，作业以及全套 pdf链接可以点击此处，也算是为之后的论文排版提供一定基础？这门课还开设了周末“高等习题课”，上来就讲了一堆实变函数的东西，根本听不懂，后来去了几次也就开摆了。期末的时候想到可以合影留恋就去听了一下，讲的常微分方程幂级数解法，也属于数学物理方程范畴吧，这部分内容听着还行，毕竟氢原子波函数就是靠这解出来的。

期末的时候在计算机开放实验室考的，最后总排班上第三（第一还是成外的巨神zjk ，信息集训队预科班恐怖如斯），加了些周天习题课的证据。又获得了一个\(A+\)，这样的话对我来说 wxf在给分方面还行（再次狗头）。

基础物理实验(1)，这是我上大学以来最无语的课了，实验内容跟玩具一样，只要会认字就能做完实验拿到实验数据，然后评分仅仅只看实验报告，简直没有比这更sb 的课了。然后就想着怎么卷报告呗， 好家伙在 windows 上 \(\LaTeX\)就配置了一天，然后各种拼接模板，关键是编译花的时间太长了，一篇报告基本要花好几天。学了python 用来画图，结果时间上还是消耗得比较多，就应该用 excel水水，没必要事事都做得特别精细。而且无论报告写得多精致，基本就在 88-92之间徘徊，最后拿了 \(A-\)，属于是大一唯一 \(A-\)的理科了。以后吸取了教训，这种课就不应该花过多时间。

大学化学(B)，让人不理解的课，但未央大半部分都要学这个，想想也就算了，之后还要学生物导论，是真的理综都被打牢了。选的cc 老师的课，期中巨水，可以带 A4纸，就在一个比较小的教室考，基本可以看周围同学的，反正也只占一次作业分。期中考完之后北京就爆发疫情了，本来可以查卷，结果试卷送不进来，到了期末的时候才能查卷。

我一般很少查卷的，那天可能期末周比较闲，就去何添楼查卷，结果助教就说了一句很可疑的话，查卷的时候不能询问正确答案，我就觉得很奇怪。然后就把半期试卷上的内容基本都背了下来，我还记得我坐在楼梯上打开电脑开始敲markdown，果不其然，期末就考了好几道一样的题，好在通过百度我已经提前得到了标准答案，最后还意外地拿了\(A\)，比较对得起自己的努力。

中国近代史纲要，选课经历海淀区最大赌场选上了sw，据说按照字数线性给分，快到截止日期的时候跟 yyj 到清华学堂 rush期末论文，在 zcy 的建议下写了觉醒年代的观后感，水了 1.4w字，期末考试的时候抄 ppt手都抄麻了，尤其是中间有个题，连着十几页貌似都是答案，抄到后面实在是抄不完了，就偷工减料了一些，问题不大。第一次在政治课上拿\(A\)，最离谱的还是 sw经常在群聊以及朋友圈里转发各种公众号，然后每次点击去都是违规无法访问，也没什么，课水给分好的老师也不多了。。

形式与政策，lzd后八周，赶上疫情，有几次线上，中途校长来上了一次课，开始听着还有意思，后面就比较无聊了。期末写了一篇有关乡村振兴的论文，3k字也还行，也拿了 \(A\)。

诗词格律与创作，最无语的一门课了，老师上课照着自己提前写好的word文档念，后面去的人越来越少，然后这个外校聘请的老师不知道清华的打分制度，我交了几首高中期间写的一些诗词，格律方面也都查过了。可能是不符合老师的口味吧，然后吃了一个\(B-\)，是真的难受。最难绷的是本来有 PF机会的，结果问了助教，他说问题不大，然后就这样了。。开校的时候老的师可能也有点内疚吧，希望给我们申请成绩复议，结果人文学院的教务就一直通不过，我了解到有\(4\) 位同学吃 3.0，我也有同学拿了4.0，不过也就这样咯，这位老师应该也只有这一次失误了，相信后面的同学也都会好些吧。

体育(2)，zsl老师，他其实算是半个体育老师，搞数据分析的，自己说 python 和 R语言玩得贼溜，依据统计模型给运动员提供科学策略。的确，现代的体育项目都是在玩高科技，专业团队和运动员都是相辅相成的。zsl老师人特好，当时引体向上我们班好多男生都菜（包括我），他专门单独教我们怎么练习，然后有次模拟测试的时候我从单杠上摔下来了，虎口磨破了皮，他就把花名册给我让我代替原来的班长。之后疫情教职工不能进来，然后我就成了组织者，笑死，自己三步篮都悬还组织大家考试，反正考试应水尽水，数据也是我在统计，除了有位同学记了PF，其余基本都 4.0 吧，拿了 \(A\)，百分制98，应该是担任临时班长加了些分。

游泳测试，十二周左右吧，游 50m就合格，旁边站着若干个拿着竹竿准备物理意义上的捞人，蛙泳过去的，比较慢，我记得还被后面一位同学反超了，还被狠狠地踢了一脚，最后上岸的时候我大口地喘气，有惊无险地\(P\) 过了。还记得测完试去东主楼听 rls将如何科学上网，整个教室窗帘紧闭，周围好几个贵系的老师看守，阴森恐怖，也教了怎么搭建博客，hexo那一套，也算见识了大佬。

英语阅读写作(B)，zzp老师的，这门课是真的任务量大，每周都要写预习作业，然后写短文长文。那个老师长得还真像我爸，语气态度什么的都很温和，上课都很死气沉沉，感觉大家都很水。期末考试可以使用各种电子词典，最后混了个\(A-\)，貌似啥也没学到，自己的英语水平实在是堪忧。

科技与人文研讨课，属于是未央的专属课程了，两个学期一共\(1\) 学分，期间写了 \(6\)篇读书报告。主要是选择的文章可读性比较差，那些田野调查和事实相比不能说有理有据吧，只能说毫无关系。上学期和这学期一共汇报过两次，一次是菊儿胡同，吴良镛工匠的杰作，不过现在都成为商业街泯然于南锣鼓巷了……另一次则是有关大厂的田野调查，汇报完之后，班主任对这本书的各种细节利用事实狠狠地反驳了一番。的确，一个针对大厂的社会学研究听着就不像是反映真实情况的。当然薪资不想书中反映的那么少，只不过996的情况确实比较普遍。班主任说我们这个行业一般三种途径，国内大厂、外资企业和体制内，对应三种不同的生活方式，主要看个人的喜好。最后，他还给我们展示了他们组SRT 的成果，发了一篇 CCFA（实际是还没正式登刊），作者是他的博士生 xjz还有软院大一学生 hyx。他还向我们推荐了cs-Rank，也算是让我们提前了解一些目前科研的现状。由于我们班代表 ljf上学期展示得分最高，助教也认可我们读书报告的美观，拿了 \(A\)。

基础物理学(1)，wsy老师，内容涵盖力学和相对论，没啥难的，只不过每周都有作业，期中还考得不理想，一去查卷发现自己真的想当然了，期末就认真准备，心想还是混个\(A-\)吧，没想到期末异常简单，好几道跟作业一模一样的题，最后 \(A\)。有意思的是，期末做了 js 老师之前的两套往年题，结果他们更水，可以带A4 纸，稳定的 \(2-3\)道作业原题，还有加上这学期一共连着考了 \(3\) 次的题。题目是关于 16年那次震惊世界的引力波探测实验，数据都不改是认真的嘛。。当然也跟当时的疫情有关，据说物理教学组的说法也是应水尽水。

面向对象程序设计基础，yjh老师，软院图形学所长，知乎上评价蛮高的，也许是年轻的时候太刻苦了没注意身体，这门课一直是录播，就听着广播音。后来大家都没去了，课程作业也很无聊，给一个话题代码、测试、报告啥都自己写。我评价自己的作业质量是单调递减，结果还一直是100 分，是真的离谱。期间 yyj 问过我很多贵系的 oop作业，感觉他们内容非常丰富，主要是有oj，各种题目涵盖调试技巧、STL、数据结构、现代 C++体系，蛮有意思的，只不过他们期末考试貌似 oj 系统挂了。。

说回来，期末写了个大作业，写了个函数绘图器，我在 github 上找了一个用qt写的，我还征求了作者的同意，魔改了一波，现在看来中缀表达式处理得不是优雅，当时用的很慢的regex 正则表达式库，应该用栈和运算符优先级来转换的，或者 python 里面自带eval()，不过当时不太懂，还是年少无知。。最后提交到算法挑战平台上可以加分，最后拿了\(A+\)。

计算机系统研讨，很水的一门自带 PF的课程，作业有一些杂七杂八关于体系结构的 task，顺便练习 wsl各种操作，反正作业交了都是 \(P\)，算是混了个科学课组的学分。

初等数论，跟着室友一起报的，他之前学数竞，这些内容对他不算难，作业只占\(20\%\)，半期的时候担心寄，就记了任选的PF。期末还算比较认真，考场上只有最后一个题的第二种情况没想出来，后来发现思路没跳回到前面。结果总评\(94\)，得了一个 \(P\)。虽然有点小遗憾，不过倒也没啥，毕竟也学到了很多知识，掌握了孙子定理、剩余系、原根、勒让德符号这些概念，在数论层面至少也算是入了门吧，之后学习散列表的时候发现还挺有用处的。

高等代数选讲(英)，杨 SIr的课，课上得比较好，属于是基本旁听下来的一门课，主要是跟 yyj一起讨论，学到了很多代数方面上的知识。不过感觉数学的提升是永无止境的，现在就算再学一遍线性代数都有不一样的收获，之后有空我也多复习一下这方面的内容，尤其是关于张量那一块，据说研究上经常用得到，毕竟杨Sir 也说过万物都是 Tensor。

SRT

大学生研究训练项目(SRT)，期中周准备挑战杯答辩，熬夜赶进度，我去参观了其中一个信息赛道专场的全过程，挑战杯真的可以叫做PPT杯，内容各种天花乱坠，只有一个超声波定点传声有实物展示，挑战杯不让说院系也是有道理的，毕竟很难从一个6分钟汇报能区分各种项目的优劣。最后我们项目获得了信息赛道二等奖，还是对得起期中周之前好几天的熬夜付出。最后应该是挑战杯获奖的原因吧，这门课拿了\(A+\)，虽然不知道评分写个 \(96\) 是什么意思。。

竞赛

期中周的时候去参加了一下求真书院举办的新生数理基础大赛，具体经历可以看这里，考试的时候有“无限量”的士力架，题目和食物都不错，体验感很好，亚赛风格。当天晚上就出了成绩，大师拿了第一92，我第二 88，笑死，比微积分半期还高。可以报销 400 元，不亏。

5月份跟大师他们组队参加清华大学人工智能大赛（Thuai），大师一波操作，指出赛事方平台shit代码中的各种通讯问题，不得不佩服大师对代码的理解能力。比赛主要比拼的是“英雄”和策略的选择，大师码力一个顶仨，不过中期因为比较忙大家比较摆，DDL前其余队都隐匿实力，结果我们中招了，想了一个策略看着还行就提交上去了，结果被暴虐，混了个三等奖。

社工

在室友的邀请下，进入校科协活动策划部，这学期的主要工作是筹办第四十届挑战杯学生课外科技作品展，担任工作人员，在展览区里待了一天，看到了很多有趣的玩意儿。比如贵系有个根据盲打显示单词的，估计是用的隐马尔科夫模型训练了一些样本，本质上跟拼音输入法也差不多。还有生命学院用VR眼睛可视化他们的生物大分子成果，挺逼真的。航院还是什么具体忘了，下载一个软件来控制无人机飞行，然后照了一张照片。现场也有Thuai的解说，整个展览吸引了很多同学，很棒的一次体验，说是工作人员，倒不如说也是参观人员。

总之，这学期在学业方面也算是学到了更多的东西，逐渐适应了大学生活，也许有一些成绩上的小遗憾，不过长远来看到也没啥。生活也需要留一点遗憾嘛，这学期圈子也扩展了一些，相比之下，还是心满意足了。

小学期

学业

小学期一共上了 \(4\) 门课程，共\(9\)学分，一路上下来我自己也感到震惊。

程序设计实训，这门课是培养方案里面的课程，软院的 xf老师上的，讲课确实挺不错的，跟之前的课形成鲜明对比，不过 PPT内容其实比较单一，基本就是照着 more effective C++讲的，感觉好多东西也不怎么用。当然也有可能是我 C++学得不够深入。。期间写 24点属实伤了一些脑筋，后来才发现可以用递归的方式写，当时硬刚了一个递推的写法，其余都是些Qt的练习。大作业是写一个视频剪辑软件，知道消息之后提早写了一个出来，后来发现与需求有点出入，不得不评价助教还是有点摆，md需求文档不是很清晰，文档最后一句话还缺少宾语。。在二教答辩，期间还出了一个bug，后来联系助教说没事，顺利拿下 \(A\)。

程序设计训练，这门课是贵系的 hwt 老师开的，在 zcy的建议下软院贵系双开，同时推进两个大作业，h 老师 Rust语言的设计理念讲得挺不错的，这儿有一份笔记。Oj上的作业也蛮有意思的，还记得有一个二叉搜索树的题目，感觉贵系的风格就是你不会，总有人会。还好Copilot 基本都会（狗头），不会的就写注释”询问“它。不过 Rust编译器是真的智能，各种容易触发安全问题的代码片段全都提示出来，基本扫光所有error 和 warning 之后，代码能出的问题就只有运行逻辑问题了。Rust的生态圈也很友好，虽然赶不上python，不过应对需求应该也够了，况且其速度优势不再话下。后来也许是跟贵系另外一门爬虫小学期相比，Rust这门课的任务量实在是太大了，取消了两次小作业，的确，只有经历小学期的人才能体会到什么是真正的工程。这门课有个课程贡献加分，我就把课程笔记传了上去，之前帮助教过了一遍环境配置，加了一些分，也拿下了\(A\)。

量子计算研讨课，贵系 yms 教授开的，zcy让我跟他一起上，没想到这门课对全校学生开放。不过这门课的门槛是真的太高了，上来就从希尔伯特空间、量子力学五大公设的数学表述开始讲起，属实有些劝退，后来是jzf教授讲授的关于量子算法、量子电路相关部分。他自己也提到，许多做量子计算方向的博士生也难以掌握Shor算法，的确，非常前沿的课题是相当困难的，量子计算目前最难以跨越的还是物理实现，各种算法、理论已经满天飞，也许跟早年计算机模型的提出差不多吧，还是希望这棵令人无限遐想的科技树被点亮。

考核方式是论文调研，去年是读书报告。和 hsh、zcy组队，写了一篇关于量子纠错编码的综述论文，工作量比较大吧，答辩的时候 jsf教授只提了一个关于子空间编码的问题，hsh还在机场，刚好我可以回答，也算是比较幸运的。答辩结束的时候，jsf教授也很感慨，最初 70 多人，到最后只有 20多人参加答辩，的确这门课对于本科生来说难度过高。极为不友好。最后给了\(A-\)，也算是比较中肯的评价了，毕竟本科生也很难在量子计算领域提出新的想法。

毛泽东思想和中国特色社会主义概论(2)，自带 PF的实践课，主要是希望大家参与清华实践中。暑假 7月末去了趟武汉调研物流行业的情况，各种物流企业各有所长，顺丰主要针对中高端用户，中国邮政国营企业dddd，中通比较牛马，老总还非常得意地说解决许多就业问题，山农绿产品背后有供销社，也算是半个国营企业，京东非常神秘，还不让进工厂，害怕科技资料泄露吧，九州通专注于医疗产品，科技创新方面也是走在世界前列。前面几天都在繁忙地访谈记录整理，最后一天去了趟长江大桥附近，吹了一下江边的晚风，可惜没有白天登黄鹤楼，不过时间也不等人，还是踏上了高铁回到了家乡。这门课给分还有个小插曲，开始lzd 老师以为不是 PF 属性，结果我还吃了一个 \(B+\)，后来还是改成了 \(P\)。

科研

参与班主任数据压缩相关工作，主要是参与一个江苏省太湖实验室举办的比赛，组队队员有之前提到的xjz、hyx、yyj，初赛当时有个编码一直没能破解，后来帮他们手写了 (51, 63)BCH编码的算法实现，大幅提高了压缩率，反正前三十名都进入决赛，最终以第三名的成绩进入决赛。

决赛是针对一个庞大的张量进行压缩，现在想来，我们当时一直走偏了方向，一直按照论文中比较传统的编码+压缩方式对数据进行压缩，最后直接细分到每种文件采用不同的方式进行压缩，后来发现应该基于预测的方式进行压缩，比如可以通过数据的一个子集来推断整个数据集，如果预测得当的话残差就很小，这样就能提高压缩比率。还记得中秋节在软院402绞尽脑汁，我们队反应过来的时候已经很晚了，只能说长一个教训。当然中途出现了sizeof() 和 strlen()不分的低级错误，我也犯了不少错，最后决赛没能入围答辩，还是得进一步提升自己的实力。

回想大一，大一上主要在适应，大一下在学业方面还是找到了方法，暑假三门硬课的磨炼也提升了我的能力，会永远热爱生活，热爱学习。

绪论

数据结构三元素：逻辑结构、存储结构、数据在运算上的实现。

逻辑结构：集合、线性、树、图

存储结构：顺序、链式、索引、散列

Note.逻辑结构为树但存储结构可以为顺序，例如使用数组存储一棵完全二叉树。

向量与列表

二分查找

性质1：折半查找判定树是平衡二叉树，其高度差要么为 \(0,1\)，要么为 \(0,-1\)。

Prof.当前序列为奇数个时，一定能保证两侧数量相同；当前序列为偶数个时，要么为\(\left\lceil\dfrac{l+r}{2}\right\rceil\)，要么为\(\left\lfloor\dfrac{l+r}{2}\right\rfloor\)，对应高度差为\(1\) 和 \(-1\)，递归调用时一般不会更改中位数的选取，从而高度差要么非负、要么非正。

性质2：二分查找次数形成的树高为 \(\left\lceil\log _{2}(n+1)\right\rceil\)

Prof. \(2^0+\dots+2^{h-1}\leqn\leq2^0+\dots+2^{h}\Longrightarrow h\in[\log _2(n+1)-1,\log_{2}(n+1)]\)

栈与队列

（括号）匹配操作需要借助栈。

栈模拟队列

使用两个栈模拟队列，记“大小栈”容量为 \(M,N(M>N)\)，能够模拟的队列最大容量为\(2N+1\)。

Prof. \(1,\cdots,N\)入大栈，依次弹出进入小栈，大栈加入 \(N+1,\cdots,2N+1\)，因为还可以保留一个。输出队列时，小栈先依次弹出为\(1,\cdots,N\)，大栈弹出 \(2N+1,\cdots N+2\) 进入小栈，剩下一个 \(N+1\)，先弹出 \(N+1\)，再弹出小栈中的元素，恰好形成一个队列。

表达式求值

前后缀表达式求值仅需维护一个数字栈。

后缀表达式：从左往右依次数字入栈，遇到操作符将栈顶的两个元素计算后结果入栈。

前缀表达式：从右往左依次数字入栈，遇到操作符将栈顶的两个元素计算后结果入栈。

Note. 如果有括号将内部计算均做完后左右括号出栈。

性质1：将表达式转换为二叉🌲，前缀、中缀、后缀表达式依次对应二叉树的前序、中序、后序遍历。

Note. 在构建时 \(\neg\neg P\) 前序为\(\neg\neg P\)，后序则为 \(P\neg\neg\)。

树的结构

以下讨论皆规定根节点🌲高为 \(1\)，\(V\)为🌲的节点个数，度为 \(i\) 的数目为\(n_i\)，🌲的度 \(d\) 定义为所有节点度的最大值，度为 \(d\) 且有左右树之分的树称作 \(d\) 叉🌲，满足 \[\begin{equation}V=\sum_{i=0}^{d} n_i\end{equation}\]

基本特性

对任何🌲 可以看成最小连通图，顶点的数目比度的总数多 \(1\)，即 \[\begin{equation}1+\sum_{i=1}^{d} in_i=V\end{equation}\] 给定一棵树的部分 \(n_i\)，使用公式 (1)(2)可以获取许多信息。

二叉树

对一棵二叉树度为 \(2\) 的点有 \(n_2\) 个，叶节点（度为 \(0\)）的点有 \(n_0\)，则 \[\begin{equation}n_0=n_2+1\end{equation}\]

Prof. 二叉树代入公式(1) \(1+0\cdotn_0+1\cdot n_1+2\cdot n_2=n_0+n_1+n_2\) 即证。

具有 \(n\)个节点的二叉树的最小深度为 \(\log_2(n+1)\)。

二叉树遍历方式

1. 广度优先遍历（层次遍历，使用队列模拟，记所有层中数量最大的为\(F\)，队列最大容量为 \(F\) 中的节点数）

2. 深度优先遍历

   先序遍历根左右（可以看成绕🌲外围一圈，图的深度优先遍历来源）

   

   中序遍历左根右（可以看成顺次掉落，其为有序的，无论平衡与否）

   

   后序遍历左右根（可以看成从左往右依次剪葡萄）

   

使用递推的方式遍历二叉树需要栈

性质1：完全确定二叉树至少需要中序遍历以及另外一种遍历，先序遍历和后序遍历不能完全确定一棵二叉树，除非保证每个节点的度为偶数。

Prof.中序遍历为左根右，前序或者后序遍历能给出根节点，从而能够区分出左右子树节点集合，对左右子树递归操作，能构建完整树。而先序和后序当存在度为\(1\)的节点时叶节点可左可右，当每个节点的度为偶数时保证可重建二叉树。

性质2：若一棵二叉树的前序遍历和后序遍历相反，则该二叉树为链状。

Prof. 反证法，若有个节点有左右子树，则前序和后序遍历不互为逆序。

据此可求出已知前序遍历和后序遍历（记作 \(A\) 和 \(B\)）条件下构建二叉树的方法：\(A\) 的第一位和 \(B\)的最后一位均为根节点，去掉这两位，判断剩下 \(A\) 首位和 \(B\)的末尾是否相同，若相同，则该位与根节点形成“链表”，依此类推，若不同，则分别为左右子树的根节点，以两者的位置分别确定每棵子树的集合。剩下子树同样按照上述流程，同理，只要存在逆序字符串，该字符串对应的拓扑结构一定为链状。

性质3：若一个🍃为二叉树中序遍历最后一个节点，则该节点也为前序遍历最后一个节点，反之不成立。

Prof.中序遍历为左根右，最后一个节点为🍃，则该叶子一定在右子树，依次递推下去，该叶子一定为若干个右子树最后的叶子，在前序遍历时一定作为最后一个节点。反之，若🍃节点为前序遍历最后一个节点，其可以为左子树的🍃，此时中序遍历最后一个节点可以为根节点，即反过来不成立。在🍃时成立中序最后\(\Longrightarrow\) 前序最后。

子集树：\(n\)个元素集合的子集可以看成是一颗叶子节点数为 \(2^{n}\)的满二叉树，左和右分别代表选择或者不选。

二叉排序树：左子树所有元素值小于根节点，右子树所有元素值大于根节点。（二叉树不要求平衡）

性质4：二叉排序树插入节点的复杂度为 \(O(n)\)。

Prof. 最坏情况退化成链表，复杂度为 \(O(n)\)。

性质5：若排列组合随机，二叉树高度为 \(O(\log n)\)；若形状随机，高度则为 \(O(\sqrt{n})\)。

Prof.前者证明参考算法导论二叉搜索树最后一节，后者证明参考论文，过于复杂，

完全二叉树

定义：除了最后一层外，其他各层全是满的，并且最后一层的节点尽可能往左靠。

性质6：总点数为 \(n\)的完全二叉树的非叶子节点如下 \[\begin{equation}完全二叉树,\sum _{叶子节点}1=\lceil \dfrac{n}{2}\rceil\end{equation}\]

Prof. 完全二叉树只有最后一层度为 \(1\) 的点为 \(0,1\)，即 \(n_1=0,1\)，代入 \(n_0=n_2+1,n=n_0+n_1+n_2\)，解得 \(n_0=\dfrac{n}{2},\dfrac{n+1}{2}=\lceil\dfrac{n}{2}\rceil\)。

性质7：🍃节点数为 \(n\)的完全二叉树节点总数为 \(2n-1,2n\)，共\(2\) 种。

Prof. 注意完全二叉树度为 \(1\)的节点个数为 \(n_1=0,1\)，有两种情况。

完全二叉树的🍃可能在最后一层，可能在倒数第二层，对应两种情况。例如一棵高度为\(h\) 的完全二叉树第 \(i\) 层有 \(x\)个叶子，计算完全二叉树的节点数需要考虑该层为倒数第二层或者倒数第一层。

性质8：完全二叉树从 \(1\)开始顺次标号，则标为 \(n\)的节点左右节点为 \(2n\) 和 \(2n+1\)。

Note. 一般的二叉树没有这样的性质，其放在数组中有许多元素为空。

平衡二叉树

定义：\(\forall\节点,|h_{l}-h_{r}|\leq 1\)，即任意节点左右子树的高度差不大于\(1\)。

性质9：令数列 \(\text{Fib}(n)\) 满足\(\text{Fib(1)}=\text{Fib(2)}=1,\text{Fib(n+2)}=\text{Fib(n+1)}+\text{Fib(n)}\)，则总高度为\(h\) 的平衡二叉树节点数量满足\[\begin{equation}V_h \in\left[\operatorname{Fib}(h+2)-1,2^h-1\right]\end{equation}\]

Prof. 对树高为 \(h\)平衡二叉树，构造左右子树分别为 \(h-1\)和 \(h-2\)对应的最少平衡二叉树，满足平衡二叉树条件，且任意少一个节点要么让树高小于\(h\)，要么不平衡，该构造为充分必要的，从而\(V_{\min}(h)=V_{\min}(h-1)+V_{\min}(h-2)+1\)，则左边得证。右边为满二叉树情形\(2^0+2^1+\cdots+2^{h-1}=2^h-1\)。

真二叉树

定义：所有节点的度为 \(0\)或 \(2\)的二叉树，如哈夫曼树。

树的应用

森林转换

有序树定义为兄弟节点有次序的树。

有序树转换为二叉树：先将每棵多叉树转换为二叉树，每个节点而言，“左孩子右兄弟”，即初始左孩子仍为其左孩子，初始（右侧）兄弟转换为右孩子。

二叉树转换为有序树：作为上述过程的逆过程，将右孩子变为兄弟即可。

性质1：一棵森林中树的数目等于总节点数减去总边数。

性质2：有序树的遍历仅有前序和后序，分别等于转换后二叉树的前序和中序。

Prof. 构造基本有序树 \(\begin{gathered}b\\newline/\quad \backslash\\a\quad\ \c\end{gathered}\)，其转换为二叉树 \(\begin{gathered}b\ \\/\quad \newlinea\longrightarrowc\end{gathered}\)，满足前者前序序列等于后者前序序列 \(bac\)，前者后序序列等于后者中序序列 \(acb\)。

性质3：给定有序树的前序和后序遍历能完全确定该有序树。

Prof. 由性质2和重构二叉树的性质即证。

森林转换为二叉树：先将每棵多叉树转换为二叉树，然后将所有二叉树根看成兄弟（假定有隐藏根节点），转换为一棵二叉树。

性质4：原森林中叶节点数量等于二叉树中无左孩子节点数量。

Prof.原森林叶节点可能有兄弟导致在二叉树中有右孩子，但由于其没有孩子，其在二叉树中一定没有左孩子，两者一一映射，数量相同。

性质5：一棵树非🍃节点有 \(m\) 个，其转换为二叉树后无右孩子的节点有\(m+1\) 个。

Prof. \(m\)也为有孩子的节点数量，每个有孩子的节点，其有唯一的最右孩子，该孩子转换为二叉树之后无右孩子，其余孩子由于有右边的兄弟则有右孩子。还要加上根节点，其无兄弟，转换后无右孩子。

二叉树转换为森林：左孩子不变，把右孩子转换为自己的兄弟，然后从根节点开始，最长右孩子序列每个元素对应森林中每棵🌲的根。

哈夫曼树

哈夫曼树（也叫最优编码树）：每个🍃带权，使得带权路径长度最小的二叉树，构建方法：森林\(F\) 初始化为 \(n\) 个权值的节点，重复下述操作直到 \(F\) 仅含一棵二叉🌲：

1. 在 \(F\)中选取两棵根节点的权值最小的树作为左右子树构造一个新的二叉树，且置新的二叉树的根节点的权值为左右子树上根节点的权值之和；
2. 在 \(F\)中删除这两棵树，同时将新得到的二叉树加入 \(F\) 中。

对二叉🌲，每个🍃标定“路线”（例如：\(\{0110,10,1110,1111,110,00,0111,010\}\)），保证不是前缀码，为最优编码。

最小带权路径长度（WPL）：构建的哈夫曼树对每个🍃节点以及路径长度加权求和，满足等于使用二进制编码字符串的最小长度。

性质6： \(n\)个节点的哈夫曼树对应 \(\dfrac{n+1}{2}\)个叶子节点。

Prof. 由 \(n_0+n_2=n,n_0=n_2+1\)即得。

性质7：出现次数最多和最少的字符哈夫曼编码中位数一定为最短和最长。

Prof. 使用反证法易证。

多叉树的带权最短路径：要求严格 \(m\) 叉树，通过 \(mn_{m}+1=n_0+n_{m}=n\) 补若干个 \(0\) （即不影响权的情况下适当增加 \(n\)）使得上述方程有整数解，之后仿造哈夫曼编码的方式，每次选择\(m\) 棵树进行合并。

AVL 树

保证搜索树平衡，防止其退化为链式树。

选择 \(g, p, v\)：\(g\)为最小失衡子树根节点 ，\(p\) 和 \(v\) 分别为 \(g\) 和 \(p\) 孩子中的较高者。

调整：从左往右依次为 \(\text{zig-zig,zag-zag,zag-zig,zig-zag}\)四种旋转方式。

例如顺次加入 \(7, 6, 4, 10, 8, 11\)六个节点，形成的 AVL 树如下

性质8：AVL🌲插入结点之后若不平衡，则调整之后与插入之前的🌲高相同。

Prof.如果添加之后发生旋转，一定能让多出的一层通过旋转减少，AVL🌲仅有不旋转的时候“增高”。

删除：如果删除的节点 \(P\) 在根节点上，用 \(P\) 的中序直接前驱 \(O\) 替代，进而替代删除 \(O\)，由此进行递归删除

高级搜索树

B 树

\(m\) 阶B🌲又称 \(\left(\left\lceil\dfrac{m}{2}\right\rceil,m\right)\)🌲，代表其分支数的取值范围，满足以下几种约束

1. 🍃的深度相同，根节点度数 \(\in[2,m]\)；

2. 非根节点度数 \(\in \left[\left\lceil\dfrac{m}{2}\right\rceil,m\right]\)；

3. 非🍃节点度数比关键码多 \(1\)。

性质1：B🌲下层与上层分支数之差等于本层关键码数，令\(L_{h}\) 为第 \(h\) 层下层分支数，\(L_{h-1}\) 为第 \(h\) 层上层分支数，\(N_{h}\) 为第 \(h\) 层关键码数，则有 \[\begin{equation}L_{h-1}+N_h=L_h\end{equation}\]

Prof. 对上一层的每个分支，假设关键码有 \(n_i\) 个，其下一层假设有 \(l_i\) 个分支，由约束(2)，可知 \(1+n_i=l_i\)，对上层每个分支求和即得。

该性质可以结合边界条件 \(L_{-1}=1\)得 \[\begin{equation}L_h=1+\sum_{i=1}^h N_i\end{equation}\] 性质2：\(m\) 阶 B🌲总高度满足\[\begin{equation}\log _m(N+1) \leq h \leq \log_{\left\lceil\frac{m}{2}\right\rceil}\left\lfloor\frac{N+1}{2}\right\rfloor+1\end{equation}\]

Prof. 由约束(2)(3)可知度数满足条件 \(d_{i}\in\left[\lceil\dfrac{m}{2}\rceil,m\right]\)，🌲最矮的情况对应每个节点都填满\(m-1\) 个值，有 \((m-1)\cdot(1+m+\cdots+m^{h-1})=m^{h}-1=N\)，左边得证；🌲最高的情况对应根节点度数为\(2\)，每个节点填满 \(\lceil \dfrac{m}{2}\rceil-1\) 个值，第\(i\) 层有 \(2\cdot \left( \left\lceil\dfrac{m}{2}\right\rceil\right)^{i}\) 组，\(1+\left(\lceil\dfrac{m}{2}\rceil-1\right)\cdot2\cdot\left[ \left( \left\lceil\dfrac{m}{2}\right\rceil\right)+\cdots+ \left( \left\lceil\dfrac{m}{2}\right\rceil\right)^{h-1}\right]=1+2\left[\left( \left\lceil\dfrac{m}{2}\right\rceil\right)^{h-1}-1\right]=N\)，右边得证。

另一种写法为，给定总高度 \(h\)，\(m\)阶 B🌲总节点数的取值范围为 \[\begin{equation}\left[2 \cdot\left(\left\lceil\frac{m}{2}\right\rceil\right)^{h-1}-1,m^h-1\right]\end{equation}\]

Note. B🌲总节点数和关键码数不同，后者可能不考虑叶子节点，对应 \(h\) 减 \(1\)。

插入节点：

①根据性质查找插入的位置，如果overflow，就在中间关键码处split（这就是每节点的分支数大于\(m/2\)的原因），即：把中间关键码放到它的父亲节点中，并把它原本的左右键值看成它的左右孩子。（找medieum 之后上溢）

② 如果父亲节点此时也overflow，就不断分裂上溢。

③ 如果一直 split到根节点，就为根节点创造一个新的root。（允许根节点最少只有两个分支，仅有这种方法能长高，有爸求爸，没爸造爸）

删除节点：

①找到要删的节点，如果不是叶子，交换其与后继的位置，转换为删除其后继，直到删除节点为叶子。

② 删除叶子之后如果underflow，先看左右兄弟是否能“借”它一个节点。如果可以，就通过三角债的方式从父节点处rotate。

③如果不可以，也就是说它和它的兄弟都恰好到下确界，就把它和它的右兄弟以及它们的父亲合并成一个孩子节点。这会导致父亲节点数-1.如果这样，父亲需要重复上述操作。如果已经到了根节点，就意味着树的高度减\(1\)。（对树高的改变，和Insert一样，是很少出现的）

性质3：如果某个非🍃节点中所有关键码都存在直接后继，则这些后继都是🍃。

Prof. 观察下面这棵B-树，第一层的关键码的直接后继需要迭代两层才能找到，仅有倒数第二层的关键码存在直接后继，后继均为🍃。

KD 树

对于搜索范围 \(R\)的每条边，每个节点的 \(4\)个孙子中不超过 \(2\)个会与它相交，这意味着递归，如下图 (c) 中粗线最多只能交出 \(2\) 条线，则 \[Q(n) = 2 + 2Q(n/4), Q(1) = O(1) \Longrightarrow Q(n) = O(\sqrt{n})\]

卡特兰数

定义：\(n\)个节点可构造的不同二叉树数目，显然其满足递推式 \[\begin{equation}H_n=\sum_{i=0}^{n-1} H_i H_{n-i-1} \quad(n \geq 2)\end{equation}\]

Prof. \(n\) 个节点的二叉树根节点有\(1\) 个，左右分别为 \(i\) 个和 \(n-i-1\) 个节点，两者相乘并求和为 \(H_n\)。

性质1：\(H_n=\dfrac{(2n)!}{n!(n+1)!}=\dfrac{\begin{pmatrix}2n\\n\end{pmatrix}}{n+1}=1,1,2,5,14,42\cdots\\\!\)其渐进于\(\sim\dfrac{4^n}{\sqrt{\pi}n^{3/2}}\)

Prof. 令生成函数 \(H(x)=\displaystyle\sum_{n \geq 0} H_nx^n\)，由边界条件 \(H(0)=H(1)=1\)，由递推式\(H(x)=1+\displaystyle\sum_{n\geq1}\sum_{i=0}^{n-1}H_{i}H_{n-i-1}x^n=1+x\sum_{n\geq1}\sum_{i=0}^{n-1}H_ix^{i}H_{n-i-1}x^{n-i-1}\)，更换求和顺序，先对\(i\) 求和有 \(\displaystyle\sum_{n\geq1}\sum_{i=0}^{n-1}H_ix^{i}H_{n-i-1}x^{n-i-1}=\sum_{i=0}^{+\infty}H_ix^i\sum_{j=0}^{+\infty}H_{j}x^{j}=H(x)^2\)，则该函数满足方程\(H(x)=1+xH(x)^2,H(0)=1\)，取极限下\(H(x)=\dfrac{1-\sqrt{1-4x}}{2x}\)，由二项式定理 \(H(x)=\dfrac{1-\left(1+\displaystyle\sum_{n=1}^{+\infty}\begin{pmatrix}1/2\\n\end{pmatrix}(-4x)^{n}\right)}{2x},\begin{pmatrix}1/2\\n\end{pmatrix}=(-1)^{n-1}\dfrac{(2n-3)!!}{2^nn!}=\dfrac{(-1)^{n-1}(2n-2)!}{2^{2n-1}n!(n-1)!}\)代入得\(H(x)=\dfrac{\displaystyle\sum_{n=1}^{+\infty}\dfrac{2(2n-2)!}{n!(n-1)!}x^n}{2x}=\displaystyle\sum_{n=1}^{\infty}\dfrac{(2n-2)!}{n!(n-1)!}x^{n-1}=\sum_{n=0}^{\infty}\dfrac{(2n)!}{n!(n+1)!}x^{n}\)，得证。

性质2：\(n\)个元素的栈混洗个数有 \(H_n\)个。

Prof. 考虑最后一个出栈元素，设其为 \(k\)，其必须满足前面 \(k-1\) 个元素入栈且出栈以及原序列中后面\(n-k\)个元素入栈且出栈，当两个过程全部完成 \(k\) 最后出栈，求和得\(\displaystyle \sum h(k-1)\cdoth(n-k)\)，不重不漏且满足递推式。

性质3：给定长度为 \(n\)的前序遍历，中序遍历数量为 \(H_n\)。

Prof. 由性质1给出 \(H_n\)种二叉树的形态，按照这些形态“输入”前序遍历获得完整的二叉树，每棵二叉树的中序遍历均不同，因为如果相同，由前序遍历和中序遍历完全确定一棵二叉树从而矛盾，故在前序遍历确定的情况下，每个二叉树形态与每个中序遍历一一对应。

性质4：一个凸 \(n+2\)边形，用直线连接若干对顶点使之分成多个三角形，要求每条直线不能相交，共有\(H_n\) 种划分方案。

Prof. 任意选取其中一条边以及连接中间第 \(k\) 和 \(k+1\) 个顶点，满足递推关系。

性质5：律师每天从 \(A\) 到\(B\) 走 \(2n\)个街区上班，要求不能穿越（但可以碰到）从家到办公室的对角线（只能经过绿色点），一共有\(H_n\) 条可能路线。

Prof. 每一次向上走看作入栈，向左走看作出栈，则等价于 \(n\) 元素的栈混洗个数。

堆

堆排序

Floyd堆合并算法，将所有非叶子节点下滤，由公式(5)，筛选次数为 \(\sim\dfrac{n}{2}\)。

性质1：建堆时比较次数为 \(O(n)\)

Prof. 设高度为 \(h\)（ \(1\) 个节点高度为 \(0\)）相较之前的逐个插入法 \[\sum _{i=0}^{h}i2^i\Longrightarrow\sum _{i=0}^{h}(h-i)2^i\\(h-1)2^{h+1}+2=O(n\log n)\Longrightarrow2^{h+1}-h-2=n-\log _2(n+1)=O(n)\]

性质2：代码实现上从序列末尾开始向前遍历，比如从倒数第二层的最后一个节点开始上滤，但同层节点的下滤次序对算法的正确性和效率都没有影响，其互不相干。

性质3：合并两个一般堆与建堆的时间复杂度相同，时间为\(O(n)\)。

Prof. 两个一般堆的合并使用 Floyd 算法目前为最快的 \(O(n)\)，使用左式堆可以降到 \(O(\log n)\)。

程序中的堆是自己生成自己回收，栈是操作系统来分配。

性质4：堆排序时间复杂度为 \(O(n\logn)\)，其中建堆次数共 \(n\)次

Prof. 建堆时间 \(O(n)\)，之后每次移去最值并下滤，操作时间为\(O(n\cdot \log n)\)。初始 \(1\) 次，之后仅用下滤并取极值 \(n-1\) 次，共 \(n\) 次。

图

基本性质

无向图中描述两顶点之间的关系可以用(v1, v2) 来表示。

有向图中描述两顶点的单向关系用<v1,v2> 来表示。

简单路径：经过的点互相不重复的路径。（回路不是简单路径）

连通分量：无向图中，若 \(v_i\) 到 \(v_j\) 有路径，则称 \(v_i\) 和 \(v_j\)是连通的，无向图极大连通子图的集合为连通分量。

强连通分量：有向图中，若从 \(v_i\) 到 \(v_j\) 以及从 \(v_j\) 到 \(v_i\) 有路径，则称 \(v_i\) 和 \(v_j\)是连通的，有向图极大强连通子图的集合为强连通分量。

平面图：可以画在平面上且不同的边互不交叠的图，判定\(V-E+F=C+1\)，分别对应顶点、边、面、连通数目，满足\(e \leq 3 \times v-6=O(v) \ll v^2\)。

有 \(e\)条边的无向图，在邻接表中共有 \(n+e\cdot2=n+2e\) 个节点（注意对称性）。

邻接表的空间复杂度为 \(O(n+e)\)，邻接矩阵的空间复杂度为 \(O(n^2)\)

性质1：无向图的邻接矩阵为对称矩阵 \(A=A^{T}\)，点为 \(i\) 的度为 \(\displaystyle \sum_{j=1}^n A[i, j]=\sum_{i=1}^nA[i, j]\)。

Prof. 对无向图中的一个点而言，其入度等于出度，

性质2：\(n\)节点的连通无向图至少有 \(n-1\)条边（邻接矩阵有 \(2(n-1)\)个元素），连通有向图至少有 \(n\)条边。

Prof. 对无向图而言，\(n-2\)条边无法连接所有顶点，顺次连接 \(n\)个点最少只需要 \(n-1\)条边；对有向图形成一个大环为最少的边数。

性质3：要保证在任意连接方式下都能连通 \(n\) 个点，至少需要 \(\dfrac{n(n-1)}{2}+1\) 个点。

Prof. 最坏情况为 \(n-1\)个点构成完全图，最后连接剩下 \(1\)个点。

性质4：深度优先搜索生成的序列与图是否有向密切相关。

E.g. 对边集 \(E={<v_0,v_1>,<v_0,v_2>, <v_0,v_3>, <v_1,v_3>}\) 从 \(v_0\) 开始的深度优先搜索一共有 \(5\) 种，其中 \(v_0\rightarrow v_3\rightarrow v_2\rightarrowv_1\) 容易遗漏。

拓扑排序

步骤：每次选择入度为 \(0\)的点入队，剪去出队元素的所有边，重复操作，出队序列为拓扑序列。（拓扑排序得到的序列不唯一）

性质5：如果一个有向图的邻接矩阵对角线以下的元素非 \(0\)，则该图存在拓扑排序。

Prof. 说明任意边 \(v_{i}\longrightarrowv_j\) 中 \(i<j\)，若存在环\(v_i,v_j,v_k\)，则满足 \(i<j,j<k,k<i\)矛盾，从而该有向图无环，存在拓扑排序。

最小生成树算法

图的深度优先搜索能给出图的一棵支撑树，对应二叉树的先序遍历。

生成树：连通图 \(G\) 的某个子图是一颗包含 \(G\) 所有顶点的树。

Cayley 公式：\(n\)个顶点的完全图的生成树总数为 \(n^{n-2}\)。

Prof. 设结果为 \(T(n)\)，考虑生成树序列的个数算两次，第一种计算方式为每棵树的排列为\(T(n)\cdot n!\)，第二种方式为考虑第\(k\) 次加入的边，当前有 \((n-k+1)\)棵树，边的一端任选，另一端不能为前者所在的树，每次有 \(n\cdot (n-k+1-1)=n(n-k)\) 种选法，求积为\(\displaystyle\prod_{k=1}^{n-1}n(n-k)=n^{n-1}\cdot (n-1)!\)，两者相等 \(T(n)n!=n^{n-1}\cdot (n-1)!\LongrightarrowT(n)=n^{n-2}\)。

性质1：\(n\) 个顶点、\(n\) 条边的连通图至少有 \(3\) 棵生成树。

Prof. 连通图一定有 \(n-1\)条边的生成树，多一条边一定能通过其共同祖先形成环，该环至少有 \(3\) 条边，任一去掉一条边均为生成树，至少\(3\) 棵生成树，

最小生成树（MST）：所有生成树中权值之和最小的树，最小生成树有两种算法。

Kruskal 算法

算法流程：按权值递增顺序依次选取 \(n-1\)条边，始终保证不构成回路。

设图的边数量为 \(e\)，前者需要排序\(O(e\log e)=O(e\log v)\)，判断是否属于同一个树的时间为 \(O((v+e)\cdot\alpha(v))\)，其中 \(\alpha(v)\)为阿克曼函数，对目前规模数据 \(\alpha(v)\leq4\)，从而总的复杂度为 \(O(e\logv)\) ，适用于稀疏图。

Prim 算法

算法流程：重复加入当前节点与剩余节点距离最近的边，即一棵树以极短跨边生长。

使用优先级队列取出最小边以及加入当前可跨边进行下滤和上滤操作，判定边是否使用可以使用一组布尔变量\(O(1)\) 时间内判定，则消耗时间 \(O(e+(v+e)\log v)=O(e\log v)\)。

可以看出，两种算法在渐进时间复杂度上是相同的。

Note. 上述两种算法更改选择方式可以得到“最大生成树”。

带权连通图的任意一个环中包含的边的权值均不相同时，其MST是唯一的（充分条件）

最短路径算法

Dijkstra 算法

求解权值非负单源最短路径问题。

算法流程：每次考虑当前点集的最短路径对应点的邻边，对所有点集的最短路径更新最短路径以及前驱，层层遍历，得到所有最短路径。

算法共三组与顶点一一对应的数组，空间复杂度为 \(O(v)\)。

时间复杂度，时间主要消耗在寻找当前点集的最短路径，次数为\(O(1+\cdots+(v-1)+e)\)，由于 \(O(e)=O(v^2)\)，则不加优化为 \(O(v^2)\)。

使用优先级队列在每次加入当前遇到的顶点时上滤，取出最小值之后下滤，每次操作\(O(\log v)\)，共计 \(O(v+e)\) 次操作，故可以优化为 \(O((v+e)\logv)\)，可以看出对稀疏图较好，对稠密图反而不好。

Bellman-Ford 算法

求解权值任意单源最短路径问题

算法流程：设源点为 \(u\)，构造 \(\text{dist}^{k}[v]\) 代表源点最多经过 \(k\) 次到 \(v\)点的最短路径，记遍历当前有效点的邻边求最小值更新 \(\text{dist}\) 数组为一次操作，重复操作\(v\) 次。

Prof. 正确性，如果没有负环，每条最短路径最多只需要 \(n-1\) 次便能确定，前 \(n-1\)次计算最短路径，最后一次如果还有更新，则代表有负环，不存在最短路径。

算法时间复杂度为 \(O(ve)\)，共进行\(v\)次循环，每次循坏最大可能遍历所有边。

Floyd-Warshall 算法

求解权值任意多源最短路径：标定 \(\text{dist}[u][v]\) 为从 \(u\) 到 \(v\) 的最短路径，对所有边进行初始化，对\(k:0\to v\)，遍历 \(u\) 和 \(v\)，通过 \(\text{dist}[u][k]\) 和 \(\text{dist}[u][k]\) 对 \(\text{dist}[u][v]\) 松弛。

时间复杂度 \(O(v^3)\)，空间复杂度为\(O(v^2)\)。

散列

评判一个散列函数的四个维度

1. 确定：同一关键码总是被映射到同一地址
2. 快速：计算时间复杂度为 \(O(1)\)
3. 满射：尽可能充分地覆盖整个散列空间
4. 均匀：映射到各位置的概率尽量接近，避免聚集

散列函数

1. 直接寻址法，直接取关键字的某个线性映射
2. MAD ( Multiply-Add-Divide )法，防止相邻关键码依然相邻

\[\text{Hash}(\text {key})=(\mathbf{a} \times \mathbf{k e y}+\mathbf{b})\% \mathbf{M}\]

2. 数字分析法，例如手机后四位

3. 平方取中法，例如f(1234)=1522756=227

4. 折叠法，取若干位数相同的部分求和

5. 伪随机数法，\(\text{Rand(A)}\)

散列冲突解决方法

1. 多槽位法，预先几个槽

2. 独立链法，链表

3. 公共溢出法，冲突元素放置在单独一个地方

4. 线性试探法，冲突之后顺次放置，第 \(k\) 次试探地址 \(\left(\text{hash}(\text{key})+{k}\right) \%M\)，使用 lazyRemoval 防止删除之后断链

5. 平方试探法，第 \(k\) 次试探地址\(\left(\text{hash}(\text{key})+{k^2}\right)\%M\)，能够更快地跳出聚集区

6. 双向平方试探法，第 \(k\)次试探地址 \(\left(\text{hash}(\text{key})+{(-1)^{k-1}\left\lceil\dfrac{k}{2}\right\rceil^2}\right)\% M\)。

性质1：若表长为素数 \(p\equiv3\pmod{4}\) ，使用双向平方试探法前 \(\text{p}\) 次试探能遍历所有桶。

Prof. 反证若两次试探 \(k_1,k_2\)同时属于偶数、奇数集合 \(\{2,4,\cdots,p-1\},\{1,3,\cdots,p\}\)中的某个，则\(k_1^2\equivk_2^2\pmod{p},(k_1+k_2)(k_1-k_2)\equiv 0\pmod{p}\)\(\Longleftrightarrow p\mid k_1+k_2,k_1-k_2\)，后者均不能满足（之和为偶数）。则必须属于不同集合，此时\(k_1^2+k_2^2\equiv0\pmod{p}\)，而二平方和问题只能为 \(4k+1\) 型素数或者 \(2\)，这是因为 \(2\nmid x\Longrightarrow x\equiv1\pmod{4}\)。则对任何情况均无解，不存在冲突，能够在 \(p\) 次试探中遍历所有桶。

Note. 当 \(M=2^s,s\in \mathbb{Z}\)，第 \(k\) 次试探地址为 \(\left(\text{hash}(\text{key})+\dfrac{k(k+1)}{2}\right)\% M\) 时也能遍历所有桶。

线性探测失败和成功问题：成功查找次数等于线性探测加入\(\text{Hash}\) 值时移动次数加 \(1\) 的累加。

性质2：在线性探测策略下，当插入节点的数量小于总数量时，对给定的节点序列，无论插入顺序如何，最后平均成功查找次数相同。

Prof.

组合索引：多个指标时“拼接”在一起计算哈希值。

串

KMP 算法

改进前：\(\text{Next}(P, j)=\{0 \leq t<j\mid P[0, t)=P[j-t, j)\}\)

改进后：\(\text{Next}(P, j)=\{0 \leq t<j\mid P[0, t)=P[j-t, j)\wedge P(t) \neq P(j)\}\)

算法复杂度为 \(O(m+n)\)，在最坏情况下依然是该复杂度。

排序

直接插入排序需要挪位置。

性质1：共 \(4\)种不稳定排序，“快些选堆”（快速排序、希尔排序、选择排序、堆排序）

Prof.快速排序轴点的选择影响相同值元素的先后顺序；希尔排序由于间隔的存在，相同值元素可能在不同间隔序列中打乱；选择排序将\(\text{rank(i)}\) 的元素与第 \(i\)个元素交换，交换的元素可能与后面某元素相同，顺序打乱；堆排序在不同分支的维护堆操作顺序可能发生改变。

基数排序

算法：关键码由多个字段组成，可按照优先级从低到高进行桶排序，低位字段优先策略\[\begin{array}{|c|c|c|c|c|c|c|c|}\hline \text { 输入序列 } & 441 & 276 & 320 & 214 &698 & 280 & 112 \\\hline \text { 以个位排序 } & 32{0} & 28{0} & 44{1} &11{2} & 21{4} & 27{6} & 69{8} \\\hline \text { 以十位排序 } & 1{1}2 & 2{1}4 & 3{2}0 &4{4}1 & 2{7}6 & 2{8}0 & 6{9}8 \\\hline \text { 以百位排序 } & {1}12 & {2}14 & {2}76 &{2}80 & {3}20 & {4}41 & {6}98 \\\hline\end{array}\]

Prof. 正确性由数学归纳法给出，假设 \(i-1\) 趟后前 \(i-1\) 次序的数字排好序，第 \(i\) 趟如果第 \(i\)优先级不同，则按照该优先级排序，如果相同，前面工作保证排好序，则总能排好序。

复杂度： 各字段取值范围 \(\left[0, M_i\right), i<=t\)，令 \(M=\max \left(M_i\right)\) \[O\left(n+M_1\right)+O\left(n+M_2\right)+\cdots+O\left(n+M_t\right)=O\left(t\cdot(n+M)\right)\]

Note. 基数排序需要的操作次数为定值，桶排序可以看成是基数为 \(1\) 的基数排序。

快速排序

性质2：快速排序的平均时间复杂度为 \(O(1.386\cdot n\log n)\) \[T(n)=(n-1)+\frac{1}{n} \cdot\sum_{k=0}^{n-1}[T(k)+T(n-k-1)]=(n-1)+\frac{2}{n} \cdot \sum_{k=0}^{n-1}T(k)\] \(\begin{cases} n \cdot T(n)-(n-1)\cdot T(n-1)=2 \cdot(n-1)+2 \times T(n-1) \\n \cdot T(n)-(n+1) \cdotT(n-1)=2 \cdot(n-1)\end{cases}\Longrightarrow\dfrac{T(n)}{n+1}-\dfrac{T(n-1)}{n}=\dfrac{4}{n+1}-\dfrac{2}{n}\)

解得 \(T(n)=(n+1)\cdot\left(2 \displaystyle\cdot \sum_{k=1}^{n+1} \frac{1}{k}+\frac{2}{n+1}-4\right)\approx 2\ln2\cdot n\log n\)

实验仪器

信号发生器、示波器、测试电缆（约 \(1\text{m}\) 长）、同轴电缆（约 \(5\text{m}\) 长）、三通接头、\(50\Omega\) 电阻。

实验原理

同轴电缆电学参数

对于两种特征阻抗的同轴电览交替连接构成的同轴光子晶体，当两种电缆的特征阻抗之比\(Z_{0 H} / Z_{0 L}\)越大、连接的电缆的数量越多，电磁带隙特性以及快慢光效应越明显。

常用同轴电缆的特征阻抗为 \(75\Omega\) 和 \(50 \Omega\)。使用这两种电缆的话阻抗比偏小，且两种电缆内外导体间介质的介电常数 \(\varepsilon_r\)通不同，对应的半波长以及电缆长度也不同。

本实验只使用一种特征阻抗的同轴电缆。通过并联两根电缆的方法获得另一特征阻抗以及更高的阻抗比。

同轴电缆的等效电路如图 \(5\)所示，其中 \(R,L,G\)分别为单位长度同轴电缆的电阻、电感、电容，且结合电磁学知识可知 \[\begin{equation}\begin{cases}C & =\dfrac{2 \pi \varepsilon_0 \varepsilon_r}{\ln (b / a)} \\L & =\dfrac{\mu_0 \mu_r}{2 \pi} \ln \dfrac{b}{a}\end{cases}\end{equation}\] 其中 \(a,b\)为同轴电缆的内外径，\(\epsilon_r,\mu_r\)分别为同轴电缆内外的相对介电常数以及相对磁导率，沿同轴电缆方向共有两个方向叠加，对应通解为\[\begin{equation}\begin{aligned}& v=v^{+}(x)+v^{-}(x)=V_0^{+} e^{-\gamma x}+V_0^{-} e^{\gamma x} \\& i=i^{+}(x)+i^{-}(x)=\frac{1}{Z_0}\left(V_0^{+} e^{-\gammax}-V_0^{-} e^{\gamma x}\right)\end{aligned}\end{equation}\] 对应电压波，其中 \(\gamma=\alpha+j\beta\) 为电缆的传播常数，其表达式如下 \[\begin{equation}\alpha+j \beta=\sqrt{(R+j \omega L)\left(G+j \omega C\right)}\end{equation}\] 且定义特征阻抗 \[\begin{equation}Z_0=\sqrt{\dfrac{R+j \omega L}{G+j \omega C}}\end{equation}\] 本实验中，电缆的损耗很小，有 \(R\ll\omega L,G\ll\omega C\)，做近似有 \[\begin{equation}\left\{\begin{array}{l}Z_0=\sqrt{\dfrac{L}{C}}=\dfrac{\ln (b / a)}{2 \pi} \sqrt{\dfrac{\mu_0\mu_r}{\epsilon_0 \epsilon_r}} \\\beta=\omega \sqrt{L C}=\omega \sqrt{\epsilon_0 \mu_0 \epsilon_r \mu_r}\end{array}\right.\end{equation}\]

透射与反射

对于半无限长的同轴电缆，信号从同轴电缆始端输入后，只有沿 \(+\)方向传输的行波。实际同轴电缆都是有限长的，此时需考虑同轴电缆末端对信号的影响。

两根特征阻抗分别为 \(Z_0\) 和 \(Z_1\)的同轴电缆连接在一起，两根同轴电缆之间的连接线很短，远小于信号波长和传输线长度。输入信号通过阻抗为\(Z_0\) 的同轴电缆到达连接处的电压为\(V_i\)，透射信号在连接处的电压为 \(V_t\) ，反射信号在连接处的电压为 \(V_r\) ，满足如下方程 \[\begin{equation}\left\{\begin{array}{l}V_i+V_r=V_t \\V_i / Z_0=V_r / Z_0+V_t / Z_1\end{array}\right.\end{equation}\]

测量同轴光子晶体特性

由群速度公式 \[\begin{equation}v_g=\dfrac{c} {n+\omega \dfrac{d n}{d \omega}}\end{equation}\]

可测得某一频率下示波器 \(\mathrm{Ch}2\) 相对于 \(\mathrm{Ch} 1\)的相位差 \(\varphi\)，投输入待测电路的信号为 \(\cos \omega t\)，初始相位为 0。输出信号为\(\cos (\omega t+\varphi)\)，相位变化为\(\varphi\) \[\begin{equation}\cos (\omega t+\varphi)=\cos \omega\left(t-t_p\right) \Rightarrow\varphi=-\omega t_p\end{equation}\] 将同轴光子晶体效为一根折射率为 \(n\) 的均匀同轴电线，则延时 \(t_p\) 与等效折射率 \(n\) 的关系为 \[\begin{equation}t_p=\dfrac{Ln}{c}\end{equation}\] 公式 (10)(11) 联立计算得到 \[\begin{equation}n=-\frac{\varphi c}{\omega L}=-\frac{\varphi c}{2 \pi f L}\end{equation}\]

电学参数理论计算\((\,\mathbf{A}\,\)部分\()\)

衰减系数和幅度

由电压幅度值每米减少 \(\mathbf{0.571\%}\ll1\)，从而由衰减幅度公式\[\begin{equation}V(x)=V_0 e^{-\alpha x}\end{equation}\] 取近似 \(V_0e^{-\alpha x}\approxV_0(1-\alpha x)\)，故 \(\alpha \approx0.00571\)，或者严格计算有 \[\alpha =-\ln (1-0.571\%)=0.0057264\text{m}^{-1}\] 代入公式 (1) 计算 \(10\text{m},20\text{m},30\text{m}\)处的幅度列表如下（保留三位小数）

电缆并联

由图 1 可知，记每一小段 \(\Delta x\)对应的复阻抗为 \(\Delta Z\)，总复阻抗为\(N\DeltaZ\)，则始末并联和每一小段处并联是等效的 \[\sum_{i}\dfrac{\Delta Z\cdot \Delta Z}{\Delta Z+\DeltaZ}=\dfrac{1}{2}\sum_{i}\Delta Z=\dfrac{\displaystyle \sum_{i}\DeltaZ\cdot \displaystyle \sum_{i}\Delta Z}{\displaystyle \sum_{i}\DeltaZ+\displaystyle \sum_{i}\Delta Z}\] 由并联性质 \[R^{\prime}=\dfrac{R}{2},L^{\prime}=\dfrac{L}{2},G^{\prime}=2G,C^{\prime}=2C\] 代入公式 (5)(6) 得 \[\begin{equation}Z_0^{\prime}=\frac{1}{2} Z_0, \alpha^{\prime}=\alpha,\beta^{\prime}=\beta\end{equation}\]一种更简便的想法是电压相同时，电流变成原来的两倍，从而复阻抗折半，而每个电缆上的电流衰减幅度以及相位变化与原来相同，总比例也不变，从而传播系数不变。

高低阻抗交替连接

由上问可知，高特征阻抗使用单根电缆，低特征阻抗使用并联电缆，且有\[\begin{equation}\frac{Z_{0 H}}{Z_{0 L}}=2\end{equation}\] 可以通过多次并联的方法得到更高的阻抗比。

频率计算

由电磁波公式 \[\begin{equation}f=\frac{v}{\lambda}=\frac{c}{\sqrt{\epsilon_r \mu_r} \lambda}\end{equation}\] 代入计算得 \[f_0=\frac{c}{\sqrt{\epsilon_r \mu_r} \lambda} \approx \frac{299792458\mathrm{~m} / s}{\sqrt{2.354} \cdot 10 \mathrm{~m}}=19.540\mathrm{~}\mathrm{MHz},\dfrac{1}{2}f_0=9.770 \mathrm{~}\mathrm{MHz}\]

间接测量色散关系\((\,\mathbf{B}\,\)部分\()\)

正常光子晶体

测量数据

以 \(1 \mathrm{MHz}\) 为间隔，在\(1 \mathrm{MHz}\) 至 \(20 \mathrm{MHz}\)范围内改变频率，观察示波器 \(\mathrm{Ch}1\) 和 \(\mathrm{Ch} 2\)的峰峰值及其变化情况，测试电路图如下

测量数据整理如下

传输效率和等效折射率

同轴晶体未接入、阻抗匹配状态下 \(50\Omega\) 电阻上消耗的功率为 \(𝑃_1\)，接入同轴光子晶体、阻抗匹配状态下\(50\Omega\) 电阻上消耗的有功功率为\(P_2\)，故计算公式如下 \[\begin{equation}P_i=\frac{V_i^2}{R_0} \quad i=1,2\end{equation}\] 则传输效率 \[\begin{equation}\eta=\frac{P_2}{P_1}=\left(\frac{V_2}{V_1}\right)^2\end{equation}\] 代入公式 (18)(12)计算效率以及折射率，其中相位差相对小频率来说需要减去 \(360^{\circ}\)的整数倍，保证相位差是单调递减的，计算以及列表如下

其效率和频率关系如下

等效折射率与频率的变化如下

由图表可得 \(f=1,2,3,4,5,13,14,15,16,17,18,19,20\mathrm{MHz}\) 为通带, \(f=8,9,10,11\mathrm{MHz}\) 为带隙，在 \(f=7,8,9,10,11 M H Z\) 出现反常色散。

群速度

代入公式 (9) ，其中离散化处理 \(\dfrac{dn}{d\omega}\approx\dfrac{n_{k+1}-n_k}{\omega_{k+1}-\omega_{k}},k=1,\cdots,19\)，列表如下（取\(\dfrac{v_g}{c}\) 为纵坐标）

将群速度和频率作图如下

可以在处于反常色散频率时群速度可能超光速（对应 \(f=8 ,9 ,10\text{MHz}\)）。

缺陷光子晶体

测量数据

在同轴光子晶体中增加一根同轴电缆，形成有缺陷的同轴电缆，按照4.1 节内容测量数据结果如下

传输效率和等效折射率

同理代入公式 (16)(12) 列表如下

其效率和频率关系如下，其中透射峰使用 \(\textcolor{red}{\swarrow}\)标出，两侧由于多项式拟合的边界效应其峰可以排除

计算表 6和表3计算的传输效率之比，列表如下

将两者的传输效率之比绘图如下

可以看出在 \(f=9,10,11\text{MHz}\)处的效率提升非常显著，其余基本在 \(1\)附近波动。

群速度

同理离散化代入公式 (9) 计算群速度，列表如下

其群速度和频率的曲线绘制如下

由图像可知，在 \(f=9\text{MHz}\)处出现强正常色散，该处的 \(v_g\)显著小于 \(c\)，为慢光速现象。

色散关系直接测量\((\,\mathbf{C}\,\)部分\()\)

特征频率

在 50 kHz 至 150 kHz范围内改变信号发生器频率，观察脉冲信号的波形、幅度和延时变化情况。从上到下分别为\(114、130、160 \text{ kHz}\)时的波形，前两者为幅度最小的两个频率，后者为频率之间信号幅度最大且延时最长的频率。

群速度计算

对图片截图计算中心波腹的延迟像素与示波器背景单位格点像素比例，例如对第一张图两者像素为333 和 543，故其延迟时间为 \[t_1=\frac{333 \mathrm{~pix}}{543 \mathrm{~pix}} \cdot 500\mathrm{~ns}=306.6\text{~ns}\] 同理对三幅图片处理列表如下，其中由于设置 \(100T\)脉冲波形，高频正弦波信号的频率为原始频率的 \(100\) 倍，使用 \(\text{MHz}\) 单位方便统一

由群速度代表波包的运动，\(v_{g}=\dfrac{l}{\Delta t}\)，计算 \(\dfrac{v_g}{c}=\dfrac{l}{c\Delta t}\)列表如下

将该结果标注在图5中如下，其中 \(\textcolor{red}{\bullet}\) 代表测量点

可以发现，除中间点外，测量结果基本符合预期。

传输特性理论计算\((\,\mathbf{D.1-D.4}\,\)部分\()\)

叠加电压求解

由公式 (6) 的两个方程反解得 \[\begin{equation}\begin{cases}V_0^{+} =\dfrac{1}{2}\left(v_2+Z_0 i_2\right) e^{\gamma l} \\V_0^{-} =\dfrac{1}{2}\left(v_2-Z_0 i_2\right) e^{-\gamma l}\end{cases}\end{equation}\]

传递矩阵计算

取 \(x=0\) 的点对应 \(v_1,i_1\) \[\begin{equation}\begin{cases}v_1=v^{+}(0)+v^{-}(0)=V_0^{+}+V_0^{-} \\i_1=i^{+}(0)+i^{-}(0)=\dfrac{1}{Z_0}\left(V_0^{+}-V_0^{-}\right)\end{cases}\end{equation}\] 代入公式 (17) 得 \[\begin{equation}\begin{aligned}v_1 & =\frac{1}{2}\left(v_2+Z_0 i_2\right) e^{\gammal}+\frac{1}{2}\left(v_2-Z_0 i_2\right) e^{-\gamma l} \\i_1 & =\frac{1}{Z_0}\left(\frac{1}{2}\left(v_2+Z_0 i_2\right)e^{\gamma l}-\frac{1}{2}\left(v_2-Z_0 i_2\right) e^{-\gamma l}\right)\end{aligned}\end{equation}\] 写成矩阵的形式如下 \[\begin{equation}\left[\begin{array}{l}v_1 \\i_1\end{array}\right]=\left[\begin{array}{cl}\cosh (\gamma l) & Z_0 \sinh (\gamma l) \\\dfrac{1}{Z_0} \sinh (\gamma l) & \cosh (\gamma l)\end{array}\right] \cdot\left[\begin{array}{l}v_2 \\i_2\end{array}\right]\end{equation}\] 则其中 \(\left[\begin{array}{cl}\cosh (\gamma l) & Z_0 \sinh (\gamma l) \\\dfrac{1}{Z_0} \sinh (\gamma l) & \cosh (\gamma l)\end{array}\right]\) 为传递矩阵。

传递矩阵性质

将两个同轴电缆串联连接如下

由上节传递矩阵的性质 \[\begin{equation}\left[\begin{array}{l}v_1 \\i_1\end{array}\right]=A_1\left[\begin{array}{l}v_2 \\i_2\end{array}\right],\left[\begin{array}{l}v_2 \\i_2\end{array}\right]=A_2\left[\begin{array}{l}v_3 \\i_3\end{array}\right]\end{equation}\] 后者代入前者可得 \[\begin{equation}\left[\begin{array}{l}v_1 \\i_1\end{array}\right]=A_1 A_2\left[\begin{array}{l}v_3 \\i_3\end{array}\right]\end{equation}\] 故总的传递矩阵为 \(A=A_1A_2\)，从而通过传递矩阵相乘的方法可以得到若干个同轴光子晶体连接形成的等效传递矩阵。

负载电压表达式

令总传递矩阵 \(A_T=\left[\begin{array}{cc}A& B \\ C & D\end{array}\right]\)，信号源电动势 \(e\) 与内阻 \(Z_0\)，联立方程 \[\begin{equation}\left\{\begin{array}{l}{\left[\begin{array}{l}v_1 \\i_1\end{array}\right]=\left[\begin{array}{cc}A & B \\ C &D\end{array}\right]\cdot\left[\begin{array}{l}v_L \\i_L\end{array}\right]} \\v_L=i_L \cdot Z_0 \\e=v_1+i_1 \cdot Z_0\end{array}\right.\end{equation}\] 解得负载电压的表达式 \[\begin{equation}V_L=\frac{e}{A+\dfrac{1}{Z_0} B+Z_0 C+D}\end{equation}\]

编程计算\((\,\mathbf{D.5}\,\)部分\()\)

使用 matlab 对给定数据进行模拟，已知单根同轴电缆的特征阻抗 \(Z_0=50 \Omega\)，介质参数 \(\varepsilon_r=2.354 、 \mu_r \approx1\)，衰减系数 \(\alpha=\) \(1.810 \times 10^{-6} \sqrt{f}m^{-1}\)，其中 \(f\) 的单位为\(\mathrm{Hz}\)。

由连接图可知，令 \(A_1\)为原始同轴电缆，\(A_2\)为并联之后的同轴电缆，其总传递矩阵如下 \[\begin{equation}A_T=A_2 A_1 A_2 A_1 A_2 A_1 A_2\end{equation}\]

程序设计

将转移矩阵对应的元素设计在函数中，例如第一个元素获取函数A1() 如下

1
2
3
4
5
6
7

function [a] = A1(f)
    A1=[cosh(ga(f)*5) 50*sinh(ga(f)*5);1/50*sinh(ga(f)*5) cosh(ga(f)*5)];
    A2=[cosh(ga(f)*5) 25*sinh(ga(f)*5);1/25*sinh(ga(f)*5) cosh(ga(f)*5)];
    % A=A2*A1*A2*A1*A2*A1*A2; % 缺陷光子晶体
    A=A2*A2*A2*A1*A2*A1*A2;   % 正常光子晶体
    a=A(1,1) ;
end

主函数针对传输效率、等效折射率、群速度计算，纵坐标标注不同结果

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

f = 0:0.1:80;
x = f;
angs = f;
% 计算效率
for i=1:801
    x(i) = eta(f(i) * 1e6);
end
% 计算相位差以及使用 unwrap() 函数
for i=1:801
   angs(i) = ang(f(i)*1e6);
end
angs = unwrap(angs);
% 计算等效等效折射率
for i=1:801
   x(i) = n(f(i)*1e6, angs(i));
end
% 计算群速度
vg = x(1:800);
for i=1:800
   vg(i) = 1 / (x(i) + f(i)/0.1*(x(i+1)-x(i)));
end
% 对不同情况绘制图像，选定不同的 y 轴标注
% plot(f, x);
plot(f(1:800), vg);
xlabel('$f/MHz$', 'interpreter', 'latex', 'FontSize', 15);
% ylabel('$\eta$', 'interpreter', 'latex', 'FontSize', 20);
% ylabel('$n$', 'interpreter', 'latex', 'FontSize', 20);
ylabel('$\frac{v_g}{c}$', 'interpreter', 'latex', 'FontSize', 20);

其中使用 unwrap()函数对相位差有跃变的情况加以处理，自动增加 \(n\pi\)。

正常光子晶体

取定 \(f\in [0,8]\text{~MHz}\)步长为 \(0.1\text{~MHZ}\)进行程序模拟，绘制图像如下

传输效率

从左往右依次为通带、带隙、通带交替产生，并且随着频率地增加，多次反射和透射产生的损耗增加，从而引起效率极值点下降。

等效折射率

可以看出在频率逐渐增大的过程中存在多个反常色散区域，这与反常色散曲线吻合。

群速度

可以看出在反常色散区域群速度超过光速 \(c\)，与预期吻合。

缺陷光子晶体

假定增加的电缆位于左侧，其总传递矩阵更改为 \[\begin{equation}A_T^{\prime}=A_2 A_2 A_2 A_1 A_2 A_1 A_2\end{equation}\]

传输效率

仅仅更改矩阵，其余代码不变，传输效率关系图如下

与图6对比，在每个通带和带隙之间增加了若干个透射峰（确切来说有 \(4\) 个），与实测结论完全相符。

等效折射率

群速度

有缺陷的情形均与实际情况吻合，同时符合能带理论。

原始数据

语言特性

高效：Python 解释器，java 虚拟机，而 rust没有运行时，在 bare metal（裸机）上运行。

安卓基于 java，苹果 swift，有相应的垃圾回收机制，易卡顿，而 rust没有垃圾收集机制。

可靠：用类型系统和所有权模型来确保内存安全性和线程安全性，在编译时消除各种潜在的问题。

好用：文档丰富，编译器（提供更改方法）。

Rust 语言应用

• Servo 浏览器引擎，Redox 操作系统，Linux操作系统驱动和模块的支持

• 清华大学：操作系统教学 rCore，性能所 MadFS 文件系统，IO 500遥遥领先

• Cargo 能够大规模添加依赖（第三方库），不需要像 C++花时间去寻找并下载源码

rust 基础语法

C++ cin cout 读取失败时，将流转换为非法，而 rust则会显式地处理异常

1
2
3
4

io::stdin()
  .read_line(&mut guess)
  .expect("Failed to read line");
println!("You guessed: {guess}");

猜数获取数字以及猜测语句

1
2
3
4

// (1..=100) 代表 1-100 左闭右闭
let secret_number = rand::thread_rng().gen_range(1..=100);
// trim()前后处理空格，parse() 解析（转换类型）
let guess: u32 = guess.trim().parse().expect("Please type a number!");

变量绑定

1
2
3
4
5
6

let x = 17; // 变量绑定，且隐式推断类型
let x: i16 = 17; // 显式绑定类型
let x = 5;
x += 1; // error: re-assignment of immutable variable x
let mut y = 5;
y += 1; // OK!

变量类型

• 布尔 bool：两个值 true/false。
• 字符 char：用单引号，例如 'R'、' 计', 是 Unicode 的。
• 数值：分为整数和浮点数，有不同的大小和符号属性。
  • i8、i16、i32、i64、isize
  • u8、u16、u32、u64、usize
  • f32、f64
• 其中 isize 和 usize是指针大小的整数，因此它们的大小与机器架构相关。
• 字面值 (literals) 写为 10i8、10u16、10.0f32、10usize 等。
• 字面值如果不指定类型，则默认整数为 i32，浮点数为 f64。
• 数组 (arrays)、切片 (slices)、str 字符串 (strings)、元组(tuples)。

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

// 数组
let arr1 = [1, 2, 3]; // (array of 3 elements)
let arr2 = [2; 32]; // (array of 32 `2`s)
// 切片
let arr = [0, 1, 2, 3, 4, 5];
let total_slice = &arr; // Slice all of `arr`
let total_slice = &arr[..]; // Same, but more explicit
let partial_slice = &arr[2..5]; // [2, 3, 4]
// 字符 String 和 &str，可以分别当做 C++ 中的 string 和 const char*
let s: &str = "galaxy";
let s2: String = "galaxy".to_string();
let s3: String = String::from("galaxy");
let s4: &str = &s3;
// 向量
// Explicit typing
let v0: Vec<i32> = Vec::new();
// v1 and v2 are equal
let mut v1 = Vec::new();
v1.push(1);
v1.push(2);
v1.push(3);
let v2 = vec![1, 2, 3];
// v3 and v4 are equal
let v3 = vec![0; 4];
let v4 = vec![0, 0, 0, 0];
// 输出向量中的所有元素
println!("Task 10: The array is {:?}", v2);

类型转换

1
2
3
4

// 使用 as 进行类型转换 (cast)
let x: i32 = 100;
let y: u32 = x as u32;
// 一般来说只能在可以安全转换的类型之间进行转换操作

引用

• 在类型前面写 & 表示引用类型： &i32。
• 用 & 来取引用（和 C++ 类似）。
• 用 * 来解引用（和 C++ 类似）。
• rust 中引用和一般意义的指针是不一样的。

条件语句

1
2
3
4
5
6
7
8

if x > 0 {
10
} else if x == 0 {
0
} else {
println!("Not greater than zero!");
-10
}

循环语句，三种循环 \(\begin{cases}\text{while}\\\text{loop = while true} \\\text{for}\end{cases}\)

迭代器

• n..m 创建一个从 n 到 m 半闭半开区间的迭代器。
• n..=m 创建一个从 n 到 m 闭区间的迭代器。
• 很多数据结构可以当做迭代器来使用，比如数组、切片，还有向量 Vec等等。

1
2
3
4
5

let xs = [0, 1, 2, 3, 4];
// Loop through elements in a slice of `xs`.
for x in &xs {
println!("{}", x);
}

匹配语句，其中 _ 匹配所有情况

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// 单变量版本
let x = 3;
match x {
  1 => println!("one fish"), // <- comma required
  2 => {
    println!("two fish");
    println!("two fish");
  }, // <- comma optional when using braces
  _ => println!("no fish for you"), // "otherwise" case
}
// 元组版本
let x = 3;
let y = -3;
match (x, y) {
  (1, 1) => println!("one"),
  (2, j) => println!("two, {}", j),
  (_, 3) => println!("three"),
  (i, j) if i > 5 && j < 0 => println!("On guard!"),
  (_, _) => println!(":<"),
}

模式绑定

1

let (a, b) = ("foo", 12);

函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// 函数头
fn foo(x: T, y: U, z: V) -> T {
// ...
}
// T 类型参数 x ，U 类型参数 y ，V 类型参数 z，返回 T 类型
// Rust 必须显式定义函数的参数和返回值的类型。
// 实际上编译器是可以推断函数的参数和返回值的类型的，但是 Rust 的设计者认为显式指定更好

// 函数返回
// 函数最后一个表达式是其返回值，可以使用 return 提前返回
fn square(n: i32) -> i32 {
n * n
}
fn squareish(n: i32) -> i32 {
if n < 5 { return n; }
n * n
}

print! 和 println!

1
2
3
4
5
6
7
8
9

let x = "foo";
print!("{}, {}, {}", x, 3, true);
// => foo, 3, true
println!("{:?}, {:?}", x, [1, 2, 3]);
// => "foo", [1, 2, 3]
let y = 1;
println!("{0}, {y}, {0}", x);
// => foo, 1, foo

format!

1
2

let fmted = format!("{}, {:x}, {:?}", 12, 155, Some("Hello"));
// fmted == "12, 9b, Some("Hello")"

panic! 处理错误的方式，并不优雅

1
2
3

if x < 0 {
panic!("Kaboom!");
}

assert! 和 assert_eq!

• 如果条件 condition 不成立， assert!(condition)会导致恐慌。
• 如果 left != right， assert_eq!(left, right)会导致恐慌。

unreachable!用于表达不会达到的分支，如果达到就会导致恐慌

unimplemented! 标注没有实现的功能，panic!("not yet implemented")的简写

lecture 2

Rust 语言最 core 的语法，语言 = 核心语法 + 标准库

所有权

• 资源管理的需求：内存使用的安全和性能

  内存资源：\(\begin{cases}全局对象：事先分配的内存空间段，启动时分配，结束时回收\\局部对象：分配在栈上，进入函数时分配，退出函数时回收\\动态对象：分配在堆上，需要时分配，不需要时回收\end{cases}\)

• 对于小型程序，new 之后不 delete无所谓，程序结束之后会自动删除；但是对于大型 24h网络服务端程序，容易出现问题，总有分配内存失败的时候

• 内存管理方式，用户指定和垃圾回收，前者要求编写者的严谨，后者分为小回收和大回收，

  安卓手机卡的原因：处于大回收状态，逻辑不明确，性能差

• C艹 将构造和分配集成在一起：

  • 拷贝构造：在语义上实现一个对象变两个对象（二进制串的拷贝）。

  • 移动构造：在语义上实现将一个对象的资源转移给另一个对象。

• 空指针、悬垂指针（指针所指对象被释放，但指针没有做修改）、双重释放（两个对象的指针指向同一块内存空间，两个对象均释放）等问题导致运行时错误。

计算机技术本质上是实现一个 Trade-off

• Rust 中的每个值都有所有者 (owner)。

• 同一时刻只有一个所有者。

• 当所有者失效，值也将被丢弃。

这是

一份数据只有一个所有者，如果超出作用域，其绑定数据自动释放

1
2
3
4
5
6
7
8
9

fn foo() {
  // Creates a Vec object.
  // Gives ownership of the Vec object to v1.
  let mut v1 = vec![1, 2, 3];
  v1.pop();
  v1.push(4);
  // At the end of the scope, v1 goes out of scope.
  // v1 still owns the Vec object, so it can be cleaned up.
}

以下代码在编译过程中出错，所有权的转移

1
2
3
4
5
6
7
8
9
10
11
12
13
14

  let v1 = vec![1, 2, 3];
  // Ownership of the Vec object moves to v2.
  let v2 = v1;
  println!("{}", v1[2]); // error: use of moved value `v1`
----------------------Compile Error-----------------------
error[E0382]: borrow of moved value: `v1`
  |
2 |     let v1 = vec![1, 2, 3];
  |         -- move occurs because `v1` has type `Vec<i32>`, which does not implement the `Copy` trait
3 |     // Ownership of the Vec object moves to v2.
4 |     let v2 = v1;
  |              -- value moved here
5 |     println!("{}", v1[2]); // error: use of moved value `v1`
  |                    ^^ value borrowed here after move

在函数调用的时候，如果传入参数过多，还要将所有权还回去，比较麻烦

使用借用，所有权本身没有变化，相当于是借用一下数据

1
2
3
4
5
6
7
8

let v = vec![1, 2, 3];
// v_ref is a reference to v.
let v_ref = &v;
// Moving ownership to v_new would invalidate v_ref.
// error: cannot move out of `v` because it is borrowed
let v_new = v;
// Cancel the effect of NLL (non-lexical lifetime)
println!("{:?}", v_ref);

rust语言是一门面向编译器语言，可以认为写不出运行有问题的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// 借用与函数
fn length(vec_ref: &Vec<i32>) -> usize {
  // vec_ref is auto-dereferenced when you call methods on it.
  vec_ref.len()
}
// 可变借用
fn push(vec_ref: &mut Vec<i32>, x: i32) {
vec_ref.push(x);
}
// Copy (特型)
// i32、f64、char、bool 可以拷贝
// 生命周期检查
let y: &i32;
{
  let x = 5;
  y = &x; // error: `x` does not live long enough
}
println!("{}", *y);

向量的三种迭代方式，不可变借用 &V、可变借用&mut V、所有权 V

1
2
3
4
5
6
7
8
9
10
11
12
13
14

let mut vs = vec![0,1,2,3,4,5,6];
// Borrow immutably
for v in &vs { // Can also write `for v in vs.iter()`
  println!("I'm borrowing {}.", v);
}
// Borrow mutably
for v in &mut vs { // Can also write `for v in vs.iter_mut()`
  *v = *v + 1;
  println!("I'm mutably borrowing {}.", v);
}
// Take ownership of the whole vector
for v in vs { // Can also write `for v in vs.into_iter()`
  println!("I now own {}! AHAHAHAHA!", v);
}

切片是一种特殊的引用，代表序列中的一个指定片段

1
2

let a = [1, 2, 3, 4, 5];
let slice = &a[1..3];

结构化数据

有两种 struct 和 enum，mod 相当于 C艹 中的 namespace

结构体用 CamelCase 命名方式，里面的域用 snake_case 命名方式。

语法糖，对别的方法进行一种实现，写起来简便

1
2
3
4
5

struct Foo { a: i32, b: i32, c: i32, d: i32, e: i32 }
let mut x = Foo { a: 1, b: 1, c: 2, d: 2, e: 3 };
let x2 = Foo { e: 4, .. x };
// Useful to update multiple fields of the same struct:
x = Foo { a: 2, b: 2, e: 2, .. x };

Rust的枚举要强很多，是和类型，用来表示多选一的数据（代数数据类型，如笛卡尔坐标系）

变体 \(无数据、有命名的数据域(结构体)、无命名的数据域(元组变体)\)，如

1
2
3
4
5
6
7
8
9
10
11
12
13
14

enum Resultish {
  Ok,
  Warning { code: i32, message: String },
  Err(String)
}
// 使用 Resultish::each 来访问并匹配数据
match make_request() {
  Resultish::Ok =>
  println!("Success!"),
  Resultish::Warning { code, message } =>
  println!("Warning: {}!", message),
  Resultish::Err(s) =>
  println!("Failed with error: {}", s),
}

枚举类型还可以递归

1
2
3
4
5
6
7
8
9
10

enum List {
Nil,
Cons(i32, List),
}
// 但上述枚举类型会报错，会趋于无穷大，使用 Box 加以限制
let boxed_five = Box::new(5);
enum List {
  Nil,
  Cons(i32, Box<List>), // OK!
}

方法与所有权

方法的第一个参数（名字为self）决定这个方法需要的所有权种类，分类更加细致：

• &self：方法借用对象的值。 一般情况下尽量使用这种方式，类似于 C++中的常成员函数。
• &mut self：方法可变地借用对象的值。在方法需要修改对象时使用，类似于 C++ 中的普通成员函数。
• self：方法获得对象的所有权。方法会消耗掉对象，同时可以返回其他的值。

1
2
3
4
5
6
7
8
9
10
11
12
13

impl Point {
  fn distance(&self, other: Point) -> f32 {
    let (dx, dy) = (self.x - other.x, self.y - other.y);
    ((dx.pow(2) + dy.pow(2)) as f32).sqrt()
  }
  fn translate(&mut self, x: i32, y: i32) {
    self.x += x;
    self.y += y;
  }
  fn mirror_y(self) -> Point {
    Point { x: -self.x, y: self.y }
  }
}

• 一般会创建一个名为 new 的关联函数起到构造函数的作用。

  Rust 没有内置的构造函数语法，也不会自动构造。

• 方法、关联函数不能重载、方法不能继承

模式匹配

对结构体进行解构

1
2
3
4
5
6
7

pub struct Point {
  x: i32,
  y: i32,
}
match p {
  Point { x, y } => println!("({}, {})", x, y)
}

使用引用的方式匹配

1
2
3
4
5
6
7

let x = 17;
// 打印数值或者修改值
let mut x = 17;
match x {
  ref r if x == 5 => println!("{}", r),
  ref mut r => *r = 5
}

内部绑定（使用 @ ）

模式匹配的穷尽性，否则会报错（使用 _ 表示其他情况）

for 循环的模式匹配

1
2
3
4
5

let v = vec![1, 2, 3];
for (i, x) in v.iter().enumerate() {
  print!("v[{i}] = {x} ");
}
// v[0] = 1 v[1] = 2 v[2] = 3 

lecture 3（标准库）

编码

C艹 语言 11 比 98 增加 unordered_map

C 里面的 string 为 \0 操作，即使是访问字符串长度也需要\(O(n)\) 的空间

而 C艹 使用 std::string更加方法，对负数进行补码操作，便于加法

• Rust 的字符串处理机制比较复杂。
  • 主要是用 UTF-8 编码的 Unicode 字符序列。
  • 不是空字符 '\0' 结尾的 C 风格字符串，可以包含空字符。
• 主要有两大类： &str 和 String。

字符的标识，与信息论有关：

模拟电路（信号是连续变化的，模拟类型更多，但不抗干扰，教室里的钟表）

数字电路（低电位和高电位，0V 和 5V，能抗干扰，数字手表）

ASCII 码 0 是 48，A 是 65，a 是 97

• 编码：字符在计算机内部的表示方式

• 早期： ASCII 码，以英文字符为主， 7 位二进制

• 中文： GB 2312-1980《信息交换用汉字编码字符集》， 6,763个汉字，两个字节

  • GB 18030-2005《信息技术中文编码字符集》， 70,244个汉字，两个字节或四个字节

• Unicode：试图把全世界的文字都纳入进来，收集了 144,697个字符，四个字节

  • 常用 UTF-8 的形式来表示，变长一到四个字节，rust便使用这种编码

• 会出现乱码问题

Unicode 中文乱码速查表

&str 和 String

&str

• &str 是字符串切片，是切片的一种。
• 形如 "string literals" 的字符串字面值是 &str 类型的1。
• &str 是静态分配空间的，且固定大小。
• 不能用方括号来做形如 some_str[i] 的索引，因为每个 Unicode字符可能有多个字节。
• 正确的做法是在 chars() 中迭代：
  • for c in "1234".chars() { ... }

String

• String 是分配在堆上的，可以动态增长。
  • 和 Vec 类似，实际上就是在 Vec<u8> 外面包了一层。
• 也不能用下标来索引。
  • 可以通过 s.nth(i) 来访问某个字符。
• 通过取引用的方式可以获得 &str。

Option 枚举类型

1
2
3
4

enum Option<T> {
  None,
  Some(T),
}

• Option 是一个枚举类型，同时也是泛型类型。
• 为某种已有类型提供了表示没有或者空值的概念。
• 在 Rust 中，在需要返回空值时，推荐使用 Option。
  • 而不是返回诸如 NaN、 -1、 null 等特殊的值。
• 类型 T 可以是任何类型，没有限制。

一个处理除数为 0 的情况：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

fn divide(numerator: f64, denominator: f64) -> Option<f64> {
if denominator == 0.0 {
    None
  } else {
    Some(numerator / denominator)
  }
}
// The return value of the function is an option
let result = divide(2.0, 3.0);
// Pattern match to retrieve the value
match result {
  // The division was valid
  Some(x) => println!("Result: {x}"),
  // The division was invalid
  None => println!("Cannot divide by 0"),
}

典型用途：

初始值（求列表最大值）、函数定义域不是全集、表示简单的错误情况（未定义）、结构体的可选域或者可拿走的域、可选的函数参数、空指针

错误处理

• 对于不可恢复的错误，使用恐慌 panic!。
  • 数组越界、栈越界、算术运算溢出……
• 对于可恢复的错误，使用 Result。
  • 文件操作、网络操作、字符串解析……

1
2
3
4

enum Result<T, E> {
  Ok(T),
  Err(E)
}

• Result 与 Option 类似，除了正常结果外，还可以表示错误状态。
• 也定义了 unwrap 和 expect 等方法。
• 可以通过 ok 或 err 等方法转换成 Option。
  • 把 Ok 或者 Err 的值作为 Some，另一种变成 None。
• 也可以进行类似 Option 的操作。
  • and、 or……

其处理原则，对返回值为 Result 的函数，一定要显式地处理（否则编译器报warning ）

1
2

use std::io::Error;
type Result<T> = Result<T, Error>;

?操作符

配合 Result 类型

1
2
3
4
5

fn read_username_from_file() -> Result<String, io::Error> {
  let mut username = String::new();
  File::open("hello.txt")?.read_to_string(&mut username)?;
  Ok(username)
}

配合 Opition 类型

1
2
3

fn last_char_of_first_line(text: &str) -> Option<char> {
  text.lines().next()?.chars().last()
}

相当于可以提前传播错误，对上述两种类型对于 Err 和None 就可以提前返回

究竟是恐慌还是不恐慌？就看能否给调用代码恢复的机会。

unwrap/expect的场合：作为原型代码中的错误处理占位符

容器

Vec<T>：连续空间、可增长的序列，末尾可以高效增删、会发生增长和收缩

VecDeque<T>：双端向量，两端可以高效增删，用环状缓冲区

LinkedList<T>：双向链表，不能随机索引

HashMap<K, V> / BTreeMap<K,V>：字典（映射）类型，一般使用 HashMap<K,V>，需要满足 K: Hash + Eq，需要有序的时候用BTreeMap<K, V> ，需要满足 K: Ord

两者访问复杂度分别为 \(O(1)\) 和\(O(\log n)\) ，哈希表的使用举例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

use std::collections::HashMap;
let mut scores = HashMap::new();
// 添加元素
scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);
// 访问字典
let team_name = String::from("Blue");
let score = scores.get(&team_name);
// 遍历元素
for (key, value) in &scores {
println!("{}: {}", key, value);
}
// 用于统计字母出现次数
let mut count: BTreeMap<char, usize> = BTreeMap::new();
for ch in "abcbcddef".chars() {
  // {'a': 1, 'b': 2, 'c': 2, 'd': 2, 'e': 1, 'f': 1}
  count.entry(ch).and_modify(|e| *e += 1).or_insert(1);
}

collect() 的使用

1
2
3
4
5
6
7
8
9
10

// 将数据从列表转化为 BTreeSet
let mut data = vec![0, 1, 2, 3, 0];
let set: BTreeSet = data.iter().collect();
// 将数据中每个数乘以原来的两倍
let input = vec![1, 2, 3];
let result: Vec<i32> = input.iter().map(|x| x * 2).collect();
// 使用 zip() 将两个数据叠加
let a = vec![1, 2, 3];
let b = vec![2, 3, 4];
let result: Vec<i32> = a.iter().zip(b.iter()).map(|(x, y)| x + y).collect();

early，向量 lazy

B树外存，二叉树内存

迭代器

对序列的一种抽象

1
2
3
4
5

pub trait Iterator {
  type Item;
  fn next(&mut self) -> Option<Self::Item>;
  // More fields omitted
}

大数据方法 map revuse

自动测试

软件工程：回归测试（列出对所有的情况，每次开发判断能否通过）

评测系统是独立于程序的系统，用于测试；单元测试嵌入程序当中，在内部进行测试

cargo 提供了相应测试 test，在函数前面加上 #[test]以标注这是一个测试函数

1
2
3
4
5

#[test]
fn it_works() {
  let result = 2 + 2;
  assert_eq!(result, 4);
}

习惯每写一个函数，就在文件后面实现对它的单元测试，也可以调换过来，测试驱动编程

1
2
3
4
5
6
7

fn vector_length(data: &Vec<i32>) -> usize {
  vector_length.len()
}
#[test]
fn test_vector_length() {
  assert_eq!(vector_length(&vec![1, 2, 3]), 3);
}

持续集成，CICD，每次 push 一次就会自动跑脚本，判断测试是否失败

Tutorial

习题评讲

• 使用元组实现相当于解包压包

• 使用 a.inter().map(|x| x * 2).collect() 等价于

  1 2 3 4

  let ret - vec![]; for x in &a{ rec.push(x * 2); }

• 随机数的选取，如果不希望抽重，使用随机种子打乱然后顺序取

• json是传输数据格式中非常重要的格式：字符串、字典、数字，标准中没有注释，最后没有逗号。

• general 的工作一定有人写，合并命令行参数第三方库merge

• f64 没有实现偏序关系 Ord ，这是因为 NaN 不满足全序关系，从而 NaN与所有数比较都是 false

OJ 相关知识

请求和响应，前端属于客户端，不涉及跨主机访问

HTTP 请求

例子：https://www/baidu.com/

GET:

HOST: www.baidu.com

Content-Type: html

HTTP 响应

一个例子：

HTTP 200 OK

Content-Type: application

json 序列化与反序列化

#[derive: deserialize]

result 转成 json 文件

互斥锁

yse std::sync::{Arc, Mutex};

保证数据只能被一个线程加以修改，但要防止死锁（情况如下）

1
2

let lock_a = A.luck().unwrap();
let lock_b = B.luck().unwrap();

在上锁的时候，所有错误不要出现恐慌

不同提交隔离

一个小段子：C艹中的 中分配内存出错时，没有出现内存错误的异常

Lecture 4

泛型

C 语言中没有泛型，如 quicksort() bisearch()没有对数据类型进行泛化，而是交给程序员进行处理（手动传入compare() 函数）

Rust 中第一个泛型，将类型作为参数，变成泛型枚举类型

1
2
3
4

enum Result<T, E> {
  Ok(T),
  Err(E),
}

python 不需要泛型，其有底层 Object类型，并且是动态语言

对上述泛型枚举类型，在实现相应方法的时候其函数返回值也是<T, E>，其也可以使用参数作为传入

1
2
3

fn foo<T, U>(x: T, y: U){
  // ...
}

特型(trait)

一定程度上对应面向对象编程的多态性，对于下一段美观打印、同时比较多个参数结构体实现代码：

1
2
3
4
5
6
7
8
9
10
11
12

struct Point { 
  x: i32, 
  y: i32, 
}
impl Point {
fn format(&self) -> String {
format!("({}, {})", self.x, self.y)
}
fn equals(&self, other: Point) -> bool {
self.x == other.x && self.y == other.y
  }
}

可以抽象出共同特点(trait)，相当于 C艹 中的虚函数

1
2
3
4
5
6
7
8
9
10

// write trait
trait PrettyPrint {
  fn format(&self) -> String;
}
// write actual function
impl PrettyPoint for Point {
  fn format(&self) -> String {
    format!("({}, {})", self.x, self.y)
  }
}

C++ 中标准库由快速排序和插入排序混合版实现

python java 使用 Tim-Sort 归并排序

C++ 背上了很大的历史包袱，每次遇到问题都需要加入新的概念

特型约束的泛型类型示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

enum Result<T, E> {
Ok(T),
Err(E), 
}
trait PrettyPrint {
fn format(&self) -> String; 
}
impl<T: PrettyPrint, E: PrettyPrint> PrettyPrint for Result<T, E> {
fn format(&self) -> String {
    match *self {
      Ok(t) => format!("Ok({})", t.format()),
      Err(e) => format!("Err({})", e.format()), 
    }
  }
}

特型可以拿到其“子特型”的方法

1
2
3
4
5
6
7
8
9
10

trait Parent {
  fn foo(&self) {
    // ...
  }
}
trait Child: Parent {
  fn bar(&self) {
    self.foo();
  }
}

#[derive(Debug)]能够让对应的数据结构获得相应实现，不用重新编写，共有以下自动核心特性

1
2

Clone, Copy, Debug, Default, Eq
Hash, Ord, PatialEq, PartialOrd

特型的自动获得需要满足其所有成员都能自动获得指定的特型，如 Eq不能在包含 f32 的结构体类型上自动获得，因为 f32 不是 Eq 的（浮点数中的NAN与任意数比较都是错误的，不满足全序关系中的自反性）

Debug 特型用于输出调试信息，如

1
2
3
4

#[derive(Debug)]
struct Point { x: i32, y: i32, }
let origin = Point { x: 0, y: 0 };
// println!("The origin is: {:?}", origin);

Default 特型用于定义一个默认值，如 0 或者 ""

Eq 和 PartialEq等价关系和部分等价关系，都有对称性和传递性，前者还有自反性

Hash 表示可哈希的类型，H类型是抽象的哈希状态，可以计算哈希值，而如果同时出现了 Eq特型，需要满足以下重要性质

x == y -> hash(x) == hash(y)

PartialOrd 和 Ord表示偏序和全序，都有反对称性和传递性，前者还要满足完全性（对所有的 a 和b，有 a <= b 或者 b <= a 成立），后者可以按照字典序排序

关联类型的需求：例如，图的表示：邻接矩阵/链表

Sized 和 ?Sized前者表示在编译时固定大小，后者大小是动态的（如 [T],str），一般跟指针相关的泛型才会出现后者（如 Box）

特型甚至可以为所有类型写，如 i32，但不推荐。为了写一个特型实现的 impl代码段，要么拥有该特性，要么拥有该类型。

Drop 表示可以销毁的特型，但一般情况下不需要手动实现Drop

特型对象

考虑以下特型和实现

静态分发：在编译的时候给定了相应特性的函数

动态分发：在运行的时候决定相应特性的函数，但只有运行之后才能使用，其他情况只能当成一个特型来使用，编译器不知道对应的类型信息（已经被抹去）

对象安全性，需要满足一定条件，关联函数要求除接收方之外，其他地方都不能出现Self 类型（否则获取到对应的类型），不能以 Sized为超特型，接收方是引用或者指针形式的类型（Self, Box<Self>）

课件上问题：不可变的引用是可以 Clone 的。

生命周期

考虑以下情况：

1. 获取了一项资源。
2. 乙方通过引用借用了甲方的这项资源。
3. 甲方对这项资源使用完毕，对它进行释放。
4. 乙方还保留着对这项资源的引用，并开始使用它。
5. 乙方挂了……

如何保证第 3 步和第 4步的顺序关系？一般情况下，引用具有隐式的生命周期，不需要额外关注，但也可以显式地指定生命周期

1
2
3

fn bar<'a>(x: &'a i32) {
// ...
}

fn borrow_x_or_y<'a>(x: &'a str, y: &'a str) -> &'a str;保证引用 x 和 y的生命周期至少会和返回的引用生命周期一样长，若只需要前者和返回值的生命周期一样长，则可以分开为'a 与 'bfn borrow_p<'a, 'b>(p: &'a str, q: &'b str) -> &'a str;，如以下编译期间会报错

1
2
3
4
5
6
7
8
9
10
11