Dytchem Hexo https://hexo.dytchem.cn/ All rights reserved 2026, Dytchem Dycthem的个人博客 - 数学·物理·计算机科学 Dycthem's Blog 2026-07-18T12:12:38.392Z Dytchem https://hexo.dytchem.cn/2025/03/22/test004/ 2025-03-22T02:22:52.000Z test004 2026-07-18T12:12:38.392Z Dytchem 标量衍射理论—— 相干光场在自由空间中传播衍射的数值计算（FFT）

其他渠道查看此页

  • 创新点

本项目实现了更一般情况下的快速离散傅里叶变换（DFT），

\[Y_q=\sum_{p=0}^{n-1}{X_p\mathrm{e}^{-\mathrm{i}2\pi kpq}}\,\,\left( k\in\mathbb{R} \right)\]

跳转到DFT计算

进而实现了更方便易用的连续傅里叶变换（FT）积分数值计算算法。

该算法不用限制原函数与像函数的网格尺寸，实现了针对任意区域任意精度的目标像函数计算。

（详见myFFT1.m和myFFT2.m）

四种衍射积分形式

  • 基尔霍夫衍射初步近似（简单离散积分）

\[U\left( x,y \right) =\frac{1}{\mathrm{j}\lambdaz}\iint_{-\infty}^{+\infty}{U_0\left( x_0,y_0 \right)\mathrm{e}^{\mathrm{j}k\sqrt{z^2+\left( x-x_0 \right) ^2+\left( y-y_0\right) ^2}}\mathrm{d}x_0\mathrm{d}y_0}\]

  • 菲涅尔衍射（简单离散积分 or 快速傅里叶变换快速卷积）

\[U\left( x,y \right) =\frac{\mathrm{e}^{\mathrm{j}kz}}{\mathrm{j}\lambdaz}\iint_{-\infty}^{+\infty}{U_0\left( x_0,y_0 \right)\mathrm{e}^{\mathrm{j}k\frac{\left( x-x_0 \right) ^2+\left( y-y_0\right) ^2}{2z}}\mathrm{d}x_0\mathrm{d}y_0}\]

  • 夫琅禾费衍射（简单离散积分 or 快速傅里叶变换快速卷积）

\[U\left( x,y \right) =\frac{\mathrm{e}^{\mathrm{j}kz}}{\mathrm{j}\lambdaz}e^{\mathrm{j}\frac{k}{2z}\left( x^2+y^2\right)}\iint_{-\infty}^{+\infty}{U_0\left( x_0,y_0 \right)\mathrm{e}^{-\mathrm{j}\frac{k}{z}\left( x_0x+y_0y\right)}\mathrm{d}x_0\mathrm{d}y_0}\]

  • 角谱传播公式（快速傅里叶变换快速卷积）

\[\left\{ \begin{aligned}A_0\left( \xi ,\eta \right) &=\iint_{-\infty}^{+\infty}{U_0\left(x_0,y_0 \right) \mathrm{e}^{-\mathrm{j}2\pi \left( \xi x_0+\eta y_0\right)}\mathrm{d}x_0\mathrm{d}y_0}\\A\left( \xi ,\eta \right) &=A_0\left( \xi _0,\eta _0 \right)e^{\mathrm{j}kz\sqrt{1-\left( \lambda \xi \right) ^2-\left( \lambda \eta\right) ^2}}\\U\left( x,y \right) &=\iint_{-\infty}^{+\infty}{A\left( \xi ,\eta\right) \mathrm{e}^{\mathrm{j}2\pi \left( \xi x+\eta y\right)}\mathrm{d}\xi \mathrm{d}\eta}\\\end{aligned} \right.\]

两种积分运算方式

  • 简单离散积分

时间复杂度\(O(N^2)\)

  • 快速傅里叶变换快速卷积

\[\begin{cases}F\left( x \right)\\=\int_{-\infty}^{+\infty}{f\left( x_0 \right)\mathrm{e}^{-\mathrm{j}2\pi x_0x}\mathrm{d}x_0}\\=\frac{x_{\max}-x_{\min}}{m-1}\sum_{i=0}^{m-1}{f\left(\frac{x_{\max}-x_{\min}}{m-1}i+x_{\min} \right)\mathrm{e}^{-\mathrm{j}2\pi \left(\frac{x_{\max}-x_{\min}}{m-1}i+x_{\min} \right) \left(\frac{X_{\max}-X_{\min}}{M-1}I+X_{\min} \right)}}\\=A\sum_i^{m-1}{f\left( Ai+x_{\min} \right) \mathrm{e}^{-\mathrm{j}2\pi\left( BiI+Ci+DI+E \right)}}\\=A\left\{ \sum_i^{m-1}{\left[ f\left( Ai+x_{\min} \right)\mathrm{e}^{-\mathrm{j}2\pi Ci} \right] \mathrm{e}^{-\mathrm{j}2\piBiI}} \right\} \mathrm{e}^{-\mathrm{j}2\pi \left( DI+E \right)}\\=...\\\end{cases}\]

最后，一般情况下的离散傅里叶变换（DFT）计算如下：

\[\begin{cases}Y_q=\sum_{p=0}^{n-1}{X_p\mathrm{e}^{-\mathrm{i}2\pi kpq}}\,\,\left( k\in\mathbb{R} \right)\\=\sum_{p=0}^{n-1}{X_p\mathrm{e}^{\mathrm{i}\pi k\left[ \left( p-q\right) ^2-p^2-q^2 \right]}}\\=\left[ \sum_{p=0}^{n-1}{X_p\mathrm{e}^{-\mathrm{i}\pikp^2}\mathrm{e}^{\mathrm{i}\pi k\left( p-q \right) ^2}} \right]\mathrm{e}^{-\mathrm{i}\pi kq^2}\\=\left( X_p\mathrm{e}^{-\mathrm{i}\pi kp^2}*\mathrm{e}^{\mathrm{i}\pikp^2} \right) \mathrm{e}^{-\mathrm{i}\pi kq^2}\\=\mathscr{F} ^{-1}\left\{ \mathscr{F} \left\{X_p\mathrm{e}^{-\mathrm{i}\pi kp^2}*\mathrm{e}^{\mathrm{i}\pi kp^2}\right\} \right\} \mathrm{e}^{-\mathrm{i}\pi kq^2}\\=\mathscr{F} ^{-1}\left\{ \mathscr{F} \left\{X_p\mathrm{e}^{-\mathrm{i}\pi kp^2} \right\} \mathscr{F} \left\{\mathrm{e}^{\mathrm{i}\pi kp^2} \right\} \right\}\mathrm{e}^{-\mathrm{i}\pi kq^2}\\\end{cases}\]

时间复杂度\(Nlog(N)\)，显著优于简单离散积分

代码请见 myFFT1.m 和 myFFT2.m

效率对比

32*32
128*128

衍射样例

双缝干涉初始光场

振幅型余弦光栅初始光场

泊松亮斑初始光场

$ l = 5$

高斯拉盖尔光束初始光场

理论 - 数值 验证

理论 数值

理论 数值

]]> https://hexo.dytchem.cn/2025/03/22/Diffraction-Calculation/ 2025-03-22T02:01:46.000Z 标量衍射理论 ——]]> Diffraction-Calculation 2026-07-18T12:12:38.383Z Dytchem 0625 我在吐露什么

1018 我在痛苦什么

0705 我在窃喜什么

1206 我在挽回什么

0611 我在坦白什么

0728 我在追求什么

……

致敬那份从未消逝的喜欢❤️

]]> https://hexo.dytchem.cn/2024/08/26/love001/ 2024-08-26T08:33:39.000Z 0625 我在吐露什么

1018 我在痛苦什么

0705 我在窃喜什么

1206 我在挽回什么

0611 我在坦白什么

0728]]>

致敬那份从未消逝的喜欢 2026-07-18T12:12:38.386Z Dytchem 定理与证明

定理（幂序不等式）. 设 \(k_i>0,\;x_i>0\) 且 \(x_i\neq1\;(i=1,\dots,n)\)，定义函数

\[f(t)=\sum_{i=1}^n k_i x_i^t\]

则 \(f(t)\) 在 \(\mathbb R\) 上是严格凸函数。因此 \(f\)要么单调，要么先减后增——恰有一个极小值点。

具体而言，任取 \(a<b<c<d\)，有：

  1. 若 \(f(a)\le f(c)\)，则 \(f(b)\le f(c)\le f(d)\)；
  2. 若 \(f(b)\ge f(d)\)，则 \(f(a)\ge f(b)\ge f(c)\)。

证明. 记 \(\alpha_i=\lnx_i\)，则 \(x_i^t=e^{\alpha_it}\)。计算一、二阶导数：

\[f'(t)=\sum k_i\alpha_i e^{\alpha_i t},\qquadf''(t)=\sum k_i\alpha_i^2 e^{\alpha_i t}\]

因 \(k_i>0\)、\(e^{\alpha_i t}>0\) 且至少有一个 \(x_i\neq1\)（即 \(\alpha_i\neq0\)），故 \(f''(t)>0\) 恒成立，\(f\)严格凸。以上两条结论均为凸性的直接推论。\(\square\)

注. 若所有 \(x_i>1\)，则 \(f\) 严格递增；若所有 \(x_i<1\)，则 \(f\) 严格递减；若兼而有之，则 \(f\) 先减后增。

不等式证明

划分思想

以幂平均不等式的证明为例，说明如何利用幂序不等式。

幂序不等式断言：形如 \(f(t)=\sum k_ix_i^t\) 的函数是严格凸的。若再满足 \(f(0)=f(s)\)，则 \(f\) 在 \(0\) 与 \(s\) 处取值相等，由凸性可知——对于 \(0<r<s\) 有 \(f(r)\le f(0)=f(s)\)；对于 \(r<0\) 有 \(f(r)\ge f(0)=f(s)\)。

若要证明 \(M_r\le M_s\)，可尝试构造\(f(t)=\sum k_i x_i^t\) 使其满足 \(f(0)=f(s)\)，然后将 \(f(r)\) 与 \(M_r\)、\(M_s\) 相关联。一旦建立这种关联，凸性给出的\(f(r)\) 与端点值的大小关系便可转化为\(M_r\) 与 \(M_s\) 的大小关系。

因此核心问题在于：如何选择 \(k_i\) 和 \(x_i\)，使 \(f(0)=f(s)\) 成立，同时 \(f(r)\) 能表达 \(M_r\)？下面通过三个尝试来探索。

尝试一. 取 \(k_i=1/n\)、\(x_i=a_i\)，则 \(f(t)=\frac1n\sum a_i^t\)。此时 \(f(0)=1\)，而 \(f(s)=M_s^s\neq1\)（除非 \(M_s=1\)），不满足条件。

尝试二. 保留 \(x_i=a_i\)，调整 \(k_i\)。条件 \(f(0)=f(s)\) 给出 \(\sum k_i=\sum k_i a_i^s\)，即 \(\sum k_i(1-a_i^s)=0\)。这需针对 \(a_i\) 解出 \(k_i\)，运算繁琐。

尝试三. 取 \(k_i=1/n\)，调整 \(x_i\)。设 \(x_i=a_i/M\)，则 \(f(t)=\frac1n\sum (a_i/M)^t\)。此时

\[f(0)=\frac1n\sum 1=1,\qquadf(s)=\frac1n\sum\left(\frac{a_i}{M}\right)^{\!s}\]

条件 \(f(0)=f(s)\) 给出 \(\frac1n\sum(a_i/M)^s=1\)，即 \(M^s=\frac1n\sum a_i^s\)。记 \(C=\frac1n\sum a_i^s\)，则 \(M=C^{1/s}\)——正是 \(M_s\)。

至此得到正确的构造：\(f(t)=\frac1n\sum(a_i/M_s)^t\)。注意 \(M_s\)是推导的结果，而非前提。下面直接用此形式证明。

一、幂平均不等式

幂平均不等式（Power Mean Inequality）. 对正实数\(a_1,\dots,a_n\) 及实数 \(r<s\)，有

\[M_r\le M_s,\qquadM_t=\left(\frac1n\sum_{i=1}^n a_i^{\,t}\right)^{\!1/t}\;(t\neq0),\quad M_0=\Bigl(\prod_{i=1}^n a_i\Bigr)^{\!1/n}\]

即幂平均函数 \(t\mapsto M_t\) 关于\(t\) 单调递增。

证明. 不妨设 \(s>0\)（\(s<0\) 的情形同理）。以 \(M_s\) 为基准，引入规范化辅助函数

\[f(t)=\frac1n\sum_{i=1}^n\left(\frac{a_i}{M_s}\right)^{\!t}\]

直接验证 \(f(0)=f(s)=1\)。\(f\) 具有幂序不等式的标准形式（\(k_i=1/n\)，\(x_i=a_i/M_s\)），故 \(f\) 在 \(\mathbbR\) 上严格凸。

将 \(M_r\) 用 \(f(r)\) 表示：

\[M_r=\left(\frac1n\sum a_i^r\right)^{\!1/r}=M_s\cdot\left(\frac1n\sum\left(\frac{a_i}{M_s}\right)^{\!r}\right)^{\!1/r}=M_s\cdot f(r)^{1/r}\]

于是 \(M_r\le M_s\) 等价于 \(f(r)^{1/r}\le1\)。由 \(f\) 的严格凸性及 \(f(0)=f(s)\) 可得：

  • 若 \(0<r<s\)，则 \(f(r)\le1\)，又 \(1/r>0\)，故 \(f(r)^{1/r}\le1\)；
  • 若 \(r<0\)，则 \(f(r)\ge1\)，但 \(1/r<0\)，故 \(f(r)^{1/r}\le1\)。

两种情形均有 \(f(r)^{1/r}\le1\)，即\(M_r\le M_s\)。等号成立当且仅当诸\(a_i\) 全相等。\(\square\)

二、加权幂平均不等式

加权幂平均不等式（Weighted Power Mean Inequality）.设 \(w_1,\dots,w_n>0\) 且 \(\sum w_i=1\)，则对 \(r<s\) 有

\[M_r\le M_s,\qquad M_t=\Bigl(\sum w_i a_i^{\,t}\Bigr)^{\!1/t}\]

证明. 以 \(M_s\)为基准，引入规范化辅助函数

\[f(t)=\sum w_i\left(\frac{a_i}{M_s}\right)^{\!t}\]

则 \(f(0)=\sum w_i=1\)，\(f(s)=\displaystyle\sumw_i\frac{a_i^s}{M_s^s}=1\)。\(f\) 具有幂序不等式的标准形式（\(k_i=w_i\)，\(x_i=a_i/M_s\)），故严格凸。

将 \(M_r\) 用 \(f(r)\) 表示：

\[M_r=\Bigl(\sum w_i a_i^r\Bigr)^{\!1/r}=M_s\cdot\Bigl(\sumw_i\Bigl(\frac{a_i}{M_s}\Bigr)^{\!r}\Bigr)^{\!1/r}=M_s\cdot f(r)^{1/r}\]

由 \(f(0)=f(s)\) 及 \(f\) 的严格凸性：

  • 若 \(0<r<s\)，则 \(f(r)\le1\)，又 \(1/r>0\)，故 \(f(r)^{1/r}\le1\)；
  • 若 \(r<0\)，则 \(f(r)\ge1\)，但 \(1/r<0\)，故 \(f(r)^{1/r}\le1\)。

因此总有 \(M_r\leM_s\)。等号成立当且仅当诸 \(a_i\) 全相等。\(\square\)

注. 当 \(w_i=1/n\)时退化为经典的幂平均不等式。

三、赫尔德不等式

赫尔德不等式（Hölder Inequality）. 设 \(p,q>1\)，\(\dfrac1p+\dfrac1q=1\)，则

\[\sum_{i=1}^n |x_i y_i|\le\Bigl(\sum_{i=1}^n|x_i|^p\Bigr)^{\!1/p}\Bigl(\sum_{i=1}^n |y_i|^q\Bigr)^{\!1/q}\]

证明. 令 \(A=\sum|x_i|^p\)、\(B=\sum|y_i|^q\)，构造辅助函数

\[f(t)=\sum_{i=1}^n\left(\frac{|x_i|^p}{A}\right)^{\!t}\left(\frac{|y_i|^q}{B}\right)^{\!1-t}\]

易得

\[f(0)=\sum\frac{|y_i|^q}{B}=1,\qquad f(1)=\sum\frac{|x_i|^p}{A}=1\]

将 \(f(t)\)改写为幂序不等式的标准形式：

\[f(t)=\sum_{i=1}^n\frac{|y_i|^q}{B}\cdot\left(\frac{|x_i|^pB}{|y_i|^qA}\right)^{\!t}\]

即 \(k_i=|y_i|^q/B\)、\(x_i=|x_i|^pB/|y_i|^qA\)。由幂序不等式知\(f\) 在 \(\mathbb R\) 上严格凸。

对满足 \(f(0)=f(1)=1\)的严格凸函数，在区间 \([0,1]\) 上恒有\(f(t)\le1\)。特别地，取 \(t=1/p\) 得

\[f\!\left(\frac1p\right)=\sum\left(\frac{|x_i|^p}{A}\right)^{\!1/p}\left(\frac{|y_i|^q}{B}\right)^{\!1/q}\le1\]

即

\[\sum|x_i y_i|\le A^{1/p}B^{1/q}=\Bigl(\sum|x_i|^p\Bigr)^{\!1/p}\Bigl(\sum|y_i|^q\Bigr)^{\!1/q}\]

\(\square\)

总结

幂序不等式的核心洞察是：形如 \(\sumk_i x_i^t\)的函数具有严格凸性，因此其单调行为至多只有一个极小值点。利用此性质，构造满足 \(f(0)=f(s)\)的辅助函数，即可统一证明如下经典不等式。

不等式辅助函数 \(f(t)\)条件 \(f(0)=f(s)\)
幂平均不等式\(\displaystyle\frac1n\sum\bigl(\frac{a_i}{M_s}\bigr)^t\)\(f(0)=f(s)=1\)
加权幂平均不等式\(\displaystyle\sumw_i\bigl(\frac{a_i}{M_s}\bigr)^t\)\(f(0)=f(s)=1\)
赫尔德不等式\(\displaystyle\sum\bigl(\frac{|x_i|^p}{A}\bigr)^t\bigl(\frac{|y_i|^q}{B}\bigr)^{1-t}\)\(f(0)=f(1)=1\)

这一方法的步骤是：

  1. 构造函数 \(f(t)=\sum k_ix_i^t\)，使其具有幂序不等式的标准形式；
  2. 施加条件 \(f(0)=f(s)\)，确定 \(k_i\) 与 \(x_i\) 的关系；
  3. 利用凸性，由 \(f(0)=f(s)\) 推导 \(f(r)\) 与端点值的大小关系——\(0<r<s\) 时 \(f(r)\le f(0)\)，\(r<0\) 时 \(f(r)\ge f(0)\)；
  4. 联系原不等式，将 \(f(r)\) 翻译为 \(M_r\) 与 \(M_s\) 的关系，即得所欲证的不等式。

这套框架不仅给出了简洁的证明，更揭示了幂平均、赫尔德等不等式之间内在的统一性。

]]> https://hexo.dytchem.cn/2024/08/26/mixubudengshi/ 2024-08-26T08:13:12.000Z 定理与证明

定理（幂序不等式）. 设 \(k_i>0,\;x_i>0\) 且

代码与编译

编译选项

编译时加入以下命令：

1
-DONLINE_JUDGE -fno-tree-ch -O0 -Wall -std=c++11

文件头

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define Inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
// #define int long long
template <typename T>
inline T& read(T& a) {  // 快读
    a = 0;
    bool f = false;
    char c = getchar();
    while (!isdigit(c)) {
        f |= c == '-';
        c = getchar();
    }
    while (isdigit(c)) {
        a = (a << 1) + (a << 3) + (c ^ 48);
        c = getchar();
    }
    if (f) a = -a;
    return a;
}

基础算法

模拟

枚举

贪心

排序

二分

二分答案

三分法

倍增

构造

CDQ分治

1
2
3
4
5
6
7
8
9
10
11
12
13
int f(int l, int r) {  // 区间对问题
    if (l == r) return 0;  // 最小问题
    int m = l + r >> 1;
    int re = max(f(l, m), f(m + 1, r));  // 递归
    unordered_map<int, int> mp;
    for (int i = m, s = 0; i >= l; --i) {  // 建桶
        mp[s += a[i]] = m + 1 - i;
    }
    for (int i = m + 1, s = 0; i <= r; ++i) {  // 用桶
        re = max(re, mp[s -= a[i]] + i - m);
    }
    return re;
}

也可以是基于归并排序的CDQ分治 ***

数据结构

栈

队列

链表

哈希表

堆

单调栈

单调队列

前缀和

差分

树状数组

这里的功能是维护前缀最大值：

1
2
3
4
5
6
7
8
9
10
11
12
13
int bt[N];

inline void add(int p, int k){
    for (; p < N; p += p & -p)
        bt[p] = max(bt[p], k);
}

inline int qry(int p){
    int re = 0;
    for (; p; p -= p & -p)
        re = max(re, bt[p]);
    return re;
}

并查集 （简单版本）

一定要初始化fa[i] = i，否则合并会出问题！！！

1
2
3
4
5
6
7
8
// 寻找祖先
int find(int x) {
    return fa[x] == x ? x : fa[x] = find(fa[x]);
}
// （非启发式）合并
void hb(int x, int y) {
    fa[find(x)] = find(y);
}

线段树

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
int n;
ll a[N];
ll tr[N << 2], lz[N << 2]; // 注意开大数组！！！！

ll init(int l = 1, int r = n, int p = 1) {
    if (l == r) return tr[p] = a[l];
    int m = l + r >> 1, ps = p << 1;
    return tr[p] = init(l, m, ps) + init(m + 1, r, ps | 1);
}

void pd(int l, int r, int p) {
    if (l == r || lz[p] == 0) return;
    int m = l + r >> 1, ps = p << 1;
    lz[ps] += lz[p];
    lz[ps | 1] += lz[p];
    tr[ps] += lz[p] * (m - l + 1);
    tr[ps | 1] += lz[p] * (r - m);
    lz[p] = 0;
}

void add(int s, int t, int k, int l = 1, int r = n, int p = 1) {
    if (s == l && t == r) {
        tr[p] += k * (t - s + 1);
        lz[p] += k;
        return;
    }
    pd(l, r, p);
    int m = l + r >> 1, ps = p << 1;
    if (s <= m) add(s, min(t, m), k, l, m, ps);
    if (t > m) add(max(s, m + 1), t, k, m + 1, r, ps | 1);
    tr[p] = tr[ps] + tr[ps | 1];
}

ll qry(int s, int t, int l = 1, int r = n, int p = 1) {
    if (s == l && t == r) return tr[p];
    pd(l, r, p);
    int m = l + r >> 1, ps = p << 1;
    ll re = 0;
    if (s <= m) re += qry(s, min(t, m), l, m, ps);
    if (t > m) re += qry(max(s, m + 1), t, m + 1, r, ps | 1);
    return re;
}

链式前向星

树链剖分

重链剖分

LCA

树链剖分线段树

[[重链剖分.png]] 已知一棵包含 NN个结点的树（连通且无环），每个节点上包含一个数值，需要支持以下操作：

  • 1 x y z，表示将树从x到y结点最短路径上所有节点的值都加上z

  • 2 x y，表示求树从x到y结点最短路径上所有节点的值之和

  • 3 x z，表示将以x为根节点的子树内所有节点值都加上z

  • 4 x，表示求以x为根节点的子树内所有节点值之和

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define Inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
// #define int long long
template <typename T>
inline T& read(T& a) {  // 快读
    a = 0;
    bool f = false;
    char c = getchar();
    while (!isdigit(c)) {
        f |= c == '-';
        c = getchar();
    }
    while (isdigit(c)) {
        a = (a << 1) + (a << 3) + (c ^ 48);
        c = getchar();
    }
    if (f) a = -a;
    return a;
}

const int N = 100005;
int n, m, r;
ll P;
ll w[N];
int hed[N], to[N << 1], nxt[N << 1], p = 1;

inline void add(int u, int v) {
    nxt[++p] = hed[u];
    hed[u] = p;
    to[p] = v;
}

int fa[N], dep[N], siz[N], hs[N];
void dfs1(int o = r) {
    siz[o] = 1;
    for (int i = hed[o]; i; i = nxt[i]) {
        int t = to[i];
        if (t == fa[o]) continue;
        fa[t] = o;
        dep[t] = dep[o] + 1;
        dfs1(t);
        siz[o] += siz[t];
        if (siz[hs[o]] < siz[t]) hs[o] = t;
    }
}

int dfn[N], rnk[N], pos = 0, top[N];
void dfs2(int o = r) {
    rnk[dfn[o] = ++pos] = o;
    if (hs[o]) {
        top[hs[o]] = top[o];
        dfs2(hs[o]);
        for (int i = hed[o]; i; i = nxt[i]) {
            int t = to[i];
            if (t == fa[o] || t == hs[o]) continue;
            top[t] = t;
            dfs2(t);
        }
    }
}

inline int lca(int x, int y) {
    while (top[x] != top[y]) {
        if (dep[top[x]] > dep[top[y]])
            x = fa[top[x]];
        else
            y = fa[top[y]];
    }
    if (dep[x] < dep[y])
        return x;
    else
        return y;
}

// 以结点的dfn排序建立线段树，可以通过rnk反求结点编号
ll sum[N << 2], laz[N << 2];
ll build(int l = 1, int r = n, int p = 1) {
    if (l == r) return sum[p] = w[rnk[l]];
    int m = l + r >> 1, ps = p << 1;
    return sum[p] = build(l, m, ps) + build(m + 1, r, ps | 1);
}

inline void pd(int l, int r, int p) {
    if (laz[p] == 0 || l == r) return;
    int m = l + r >> 1, ps = p << 1;
    sum[ps] += laz[p] * (m - l + 1);
    laz[ps] += laz[p];
    sum[ps | 1] += laz[p] * (r - m);
    laz[ps | 1] += laz[p];
    laz[p] = 0;
}

void chg(int s, int t, ll k, int l = 1, int r = n, int p = 1) {
    if (s > t) swap(s, t);  // 重要！！！
    if (s == l && t == r) {
        sum[p] += k * (r - l + 1);
        laz[p] += k;
        return;
    }
    pd(l, r, p);  // 重要！！！
    int m = l + r >> 1, ps = p << 1;
    if (s <= m) chg(s, min(t, m), k, l, m, ps);
    if (t > m) chg(max(s, m + 1), t, k, m + 1, r, ps | 1);
    sum[p] = sum[ps] + sum[ps | 1];
}

ll qry(int s, int t, int l = 1, int r = n, int p = 1) {
    if (s > t) swap(s, t);  // 重要！！！
    if (s == l && t == r) return sum[p];
    pd(l, r, p);  // 重要！！！
    int m = l + r >> 1, ps = p << 1;
    ll re = 0;
    if (s <= m) re += qry(s, min(t, m), l, m, ps);
    if (t > m) re += qry(max(s, m + 1), t, m + 1, r, ps | 1);
    return re;
}

inline void init() {
    dep[r] = 1;
    dfs1();
    top[r] = r;
    dfs2();
    build();
}

inline void case1() {
    int x, y, z;
    read(x), read(y), read(z);
    int L = lca(x, y);
    while (top[x] != top[L]) {
        chg(dfn[x], dfn[top[x]], z);
        x = fa[top[x]];
    }
    chg(dfn[x], dfn[L], z);
    while (top[y] != top[L]) {
        chg(dfn[y], dfn[top[y]], z);
        y = fa[top[y]];
    }
    chg(dfn[y], dfn[L], z);
    chg(dfn[L], dfn[L], -z);
}

inline void case2() {
    int x, y;
    read(x), read(y);
    int L = lca(x, y);
    ll ans = 0;
    while (top[x] != top[L]) {
        ans += qry(dfn[x], dfn[top[x]]);
        x = fa[top[x]];
    }
    ans += qry(dfn[x], dfn[L]);
    while (top[y] != top[L]) {
        ans += qry(dfn[y], dfn[top[y]]);
        y = fa[top[y]];
    }
    ans += qry(dfn[y], dfn[L]);
    ans -= qry(dfn[L], dfn[L]);
    printf("%lld\n", ans % P);
}

inline void case3() {
    int x, z;
    read(x), read(z);
    chg(dfn[x], dfn[x] + siz[x] - 1, z);
}

inline void case4() {
    int x;
    read(x);
    ll ans = qry(dfn[x], dfn[x] + siz[x] - 1);
    printf("%lld\n", ans % P);
}

signed main() {
    cin >> n >> m >> r >> P;
    for (int i = 1; i <= n; ++i)
        read(w[i]);
    for (int i = 1, x, y; i < n; ++i) {
        read(x), read(y);
        add(x, y), add(y, x);
    }
    init();
    for (int i = 1, op; i <= m; ++i) {
        read(op);
        switch (op) {
            case 1: case1(); break;
            case 2: case2(); break;
            case 3: case3(); break;
            case 4: case4(); break;
        }
    }

    return 0;
}

ST表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
const int L = 22;
int Log[N], ma[N][L];
inline void init() {
    Log[1] = 0;
    for (int i = 2; i < N; ++i)
        Log[i] = Log[i >> 1] + 1;

    for (int i = 1; i <= n; ++i) ma[i][0] = a[i];
    for (int j = 1; j <= L; ++j)
        for (int i = 1; i + (1 << j) - 1 <= n; ++i)
            ma[i][j] = max(ma[i][j - 1], ma[i + (1 << j - 1)][j - 1]);
}

inline int qry_max(int l, int r) {
    int q = Log[r - l + 1];
    return max(ma[l][q], ma[r - (1 << q) + 1][q]);
}

二叉搜索树

平衡树

AVL树

Splay树

可持久化数据结构

数论

线性筛

欧拉函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int ps[N], phi[N], tot = 0;
bool vis[N];
inline void init() {
    for (int i = 2; i < N; ++i) {
        if (!vis[i])
            ps[++tot] = i, phi[i] = i - 1;
        for (int j = 1; j <= tot; ++j) {
            int p = ps[j], t = i * p;
            if (t >= N) break;
            vis[t] = true;
            if (i % p)
                phi[t] = phi[i] * phi[p];
            else {
                phi[t] = phi[i] * p;
                break;
            }
        }
    }
}

若要求\(\varphi(x)\)（\(x\)很大），则需要对\(x\)进行质因数分解，然后利用\(\varphi(x)\)的积性来计算，其中需要\(N>\sqrt{x}\)

快速幂

1
2
3
4
5
6
7
8
9
10
ll qpow(ll a, ll n) {
    a %= P;
    ll re = 1;
    while (n) {
        if (n & 1) re = re * a % P;
        a = a * a % P;
        n >>= 1;
    }
    return re;
}

EXGCD

求\(ax+by=\gcd(a,b)\)的一组可行解

1
2
3
4
5
6
7
8
9
10
11
12
int Exgcd(int a, int b, int& x, int& y) {
    if (!b) {
        x = 1;
        y = 0;
        return a;
    }
    int d = Exgcd(b, a % b, x, y);
    int t = x;
    x = y;
    y = t - (a / b) * y;
    return d;
}

函数返回的值为\(\gcd\)，在这个过程中计算\(x,y\)即可 ***

图论

树上问题

最短路

Floyd

1
2
3
4
5
6
7
for (k = 1; k <= n; k++) {
  for (x = 1; x <= n; x++) {
    for (y = 1; y <= n; y++) {
      f[x][y] = min(f[x][y], f[x][k] + f[k][y]);
    }
  }
}

Dijkstra

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
struct edge {
  int v, w;
};

struct node {
  int dis, u;

  bool operator>(const node& a) const { return dis > a.dis; }
};

vector<edge> e[maxn];
int dis[maxn], vis[maxn];
priority_queue<node, vector<node>, greater<node> > q;

void dijkstra(int n, int s) {
  memset(dis, 63, sizeof(dis));
  dis[s] = 0;
  q.push({0, s});
  while (!q.empty()) {
    int u = q.top().u;
    q.pop();
    if (vis[u]) continue;
    vis[u] = 1;
    for (auto ed : e[u]) {
      int v = ed.v, w = ed.w;
      if (dis[v] > dis[u] + w) {
        dis[v] = dis[u] + w;
        q.push({dis[v], v});
      }
    }
  }
}

分层图

欧拉回路

网络流

动态规划

背包DP

01背包

\[f_{i,j}=\max\{f_{i-1,j},f_{i-1,j-w_i}+v_i\}\]滚动数组优化： \[f_j=\max\{f_j,f_{j-w_i}+v_i\}\]需要j从大到小遍历

1
2
3
for (int i = 1; i <= n; i++)
    for (int j = W; j >= w[i]; j--)
        f[j] = max(f[j], f[j - w[i]] + v[i]);

完全背包

\[f_{i,j}=\max_{k=0}^{+\infty}\{f_{i-1,j-k\cdotw_i}+k\cdot v_i\}\]同样采用滚动数组优化，j从小到大遍历

1
2
3
for (int i = 1; i <= n; i++)
    for (int j = w[i]; j <= W; j++)
        if (f[j - w[i]] + v[i] > f[j]) f[j] = f[j - w[i]] + v[i];

区间DP

DAG上的DP

树形DP

状压dp

数位dp

插头DP

计数DP

字符串

字典树

Trie

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
struct trie {
    int nex[100000][26], cnt;
    bool exist[100000];  // 该结点结尾的字符串是否存在

    void insert(char* s, int l) {  // 插入字符串
        int p = 0;
        for (int i = 0; i < l; i++) {
            int c = s[i] - 'a';
            if (!nex[p][c]) nex[p][c] = ++cnt;  // 如果没有，就添加结点
            p = nex[p][c];
        }
        exist[p] = 1;
    }

    bool find(char* s, int l) {  // 查找字符串
        int p = 0;
        for (int i = 0; i < l; i++) {
            int c = s[i] - 'a';
            if (!nex[p][c]) return 0;
            p = nex[p][c];
        }
        return exist[p];
    }
};

前缀数组

\[\pi[i]=\max_{k=0,...,i}\{\ k\ |\s[0..k-1]=s[i-k+1..i]\ \}\]

1
2
3
4
5
6
7
8
9
10
11
vector<int> prefix_function(string s) {
    int n = (int)s.length();
    vector<int> pi(n);
    for (int i = 1; i < n; i++) {
        int j = pi[i - 1];
        while (j > 0 && s[i] != s[j]) j = pi[j - 1];
        if (s[i] == s[j]) j++;
        pi[i] = j;
    }
    return pi;
}

KMP算法

1
2
3
4
5
6
7
8
9
10
vector<int> find_occurrences(string text, string pattern) {
    string cur = pattern + '#' + text;
    int sz1 = text.size(), sz2 = pattern.size();
    vector<int> v;
    vector<int> lps = prefix_function(cur);
    for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
        if (lps[i] == sz2) v.push_back(i - 2 * sz2);
    }
    return v;
}

AC自动机

后缀数组

sa[i]表示将所有后缀排序后第i小的后缀的编号rk[i]表示后缀i的排名，即sa[rk[i]] = rk[sa[i]] = i[[后缀数组.png]]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;

const int N = 1000010;

char s[N];
// key1[i] = rk[id[i]]（作为基数排序的第一关键字数组）
int n, sa[N], rk[N], oldrk[N << 1], id[N], key1[N], cnt[N];

bool cmp(int x, int y, int w) {
    return oldrk[x] == oldrk[y] && oldrk[x + w] == oldrk[y + w];
}

int main() {
    int i, m = 127, p, w;

    scanf("%s", s + 1);
    n = strlen(s + 1);
    for (i = 1; i <= n; ++i)
        ++cnt[rk[i] = s[i]];
    for (i = 1; i <= m; ++i)
        cnt[i] += cnt[i - 1];
    for (i = n; i >= 1; --i)
        sa[cnt[rk[i]]--] = i;

    for (w = 1;; w <<= 1, m = p) {  // m=p 就是优化计数排序值域
        for (p = 0, i = n; i > n - w; --i)
            id[++p] = i;
        for (i = 1; i <= n; ++i)
            if (sa[i] > w) id[++p] = sa[i] - w;

        memset(cnt, 0, sizeof(cnt));
        for (i = 1; i <= n; ++i)
            ++cnt[key1[i] = rk[id[i]]];
        // 注意这里px[i] != i，因为rk没有更新，是上一轮的排名数组

        for (i = 1; i <= m; ++i)
            cnt[i] += cnt[i - 1];
        for (i = n; i >= 1; --i)
            sa[cnt[key1[i]]--] = id[i];
        memcpy(oldrk + 1, rk + 1, n * sizeof(int));
        for (p = 0, i = 1; i <= n; ++i)
            rk[sa[i]] = cmp(sa[i], sa[i - 1], w) ? p : ++p;
        if (p == n) {
            break;
        }
    }

    for (i = 1; i <= n; ++i)
        printf("%d ", sa[i]);

    return 0;
}

后缀自动机

计算几何

平面最近点对

遍历方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <bits/stdc++.h>
using namespace std;
typedef pair<double, double> pdd;

const int N = 100005;
int n;
pdd a[N];
struct cmp {
    bool operator()(const pdd& p1, const pdd& p2) const {
        return p1.second < p2.second;
    }
};
multiset<pdd, cmp> ms;

inline double d(const pdd& p1, const pdd& p2) {
    return sqrt((p1.first - p2.first) * (p1.first - p2.first) + (p1.second - p2.second) * (p1.second - p2.second));
}

signed main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> n;
    for (int i = 0; i < n; ++i) {
        cin >> a[i].first >> a[i].second;
    }
    sort(a, a + n);
    double ans = 1e10;
    for (int i = 0, j = 0; i < n; ++i) {
        for (; j < i && a[i].first - a[j].first >= ans; ++j) ms.erase(ms.find(a[j]));
        for (multiset<pdd, cmp>::iterator it = ms.lower_bound(make_pair(0, a[i].second - ans));
             it != ms.end() && it->second - a[i].second < ans; ++it) {
            ans = min(ans, d(*it, a[i]));
        }
        ms.insert(a[i]);
    }

    cout << fixed << setprecision(4) << ans;

    return 0;
}

扫描线

杂项

逆波兰式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define Inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
// #define int long long

int pri[128];
inline void init() {
    pri['+'] = pri['-'] = 1;
    pri['*'] = pri['/'] = 2;
    pri['^'] = 3;
}

inline ll qpow(ll a, ll n) {
    ll re = 1;
    while (n) {
        if (n & 1) re *= a;
        a *= a;
        n >>= 1;
    }
    return re;
}

inline ll cal(ll a, ll b, char op) {
    switch (op) {
        case '+': return a + b;
        case '-': return a - b;
        case '*': return a * b;
        case '/': return a / b;
        case '^': return qpow(a, b);
    }
    return 0;
}

list<ll> dfs(int pre = 0) { // pre代表在最前面添加"("的个数
    list<ll> re;
    if (pre > 0) re.splice(re.end(), dfs(pre - 1));
    stack<char> op;
    char c;
    while (cin >> c) {
    begin:
        if (c == '(') re.splice(re.end(), dfs());
        else if (c == ')') break;
        else if (pri[c]) {
            while (!op.empty() && pri[op.top()] >= pri[c]) {
                re.push_back(op.top() + INF);
                op.pop();
            }
            op.push(c);
        }
        else {
            ll a = c - '0';
            while (cin >> c) {
                if (!isdigit(c)) {
                    re.push_back(a);
                    goto begin;
                }
                a = a * 10 + c - '0';
            }
            re.push_back(a);
        }
    }
    while (!op.empty()) {
        re.push_back(op.top() + INF);
        op.pop();
    }
    return re;
}

inline void show(list<ll>& a) {
    for (ll& i : a) {
        if (i > INF) cout << char(i - INF) << ' ';
        else cout << i << ' ';
    }
    cout << '\n';
}

inline void work(list<ll>& a) {
    // show(a);
    for (auto it = a.begin(); it != a.end(); ++it) {
        if (*it < INF) continue;
        char op = char(*it - INF);
        ll p = *prev(prev(it)), q = *prev(it);
        *it = cal(p, q, op);
        a.erase(prev(it));
        a.erase(prev(it));
        // show(a);
    }
}

signed main() {
    init();
    list<ll> a = dfs(30);
    // show(a);
    work(a);
    if (a.empty()) cout << 0;
    else show(a);

    return 0;
}

/*

5+6)*7^8)

*/

双指针

离散化

]]> https://hexo.dytchem.cn/2024/08/20/test003/ 2024-08-20T04:51:19.000Z

代码与编译

编译选项

编译时加入以下命令：

我的ACM板子 2026-07-18T12:12:38.390Z Dytchem

注意： 1. 本文相关教材：电路（慕课版 支持AR+H5交互）邹建龙 著人民邮电出版社 2. 本文为纯干货，建议配合课本复习，并辅以实战练习 3.本文无图，如有图片需求，请到课本对应章节查看 4.本文为了使某些内容更容易被理解和记忆，特地转换了表述 5.本文或许存在一些纰漏，读者应当仔细甄别、理性对待

第1章 电路概论

已学内容全部为：线性电路、集总参数电路

==第一篇电路基本概念和分析基础==

第2章 电路基本概念

标定电压、电流方向：参考方向 √ 真实方向 ×

#关联参考方向 电流从电压正极流入 功率：\(p=ui\) 关联参考方向下：\(p>0\)，实际吸收功率；\(p<0\)，实际发出功率。非关联反之。

#电路基本元件 （以下全为关联参考方向） * 电阻：\(u=Ri\)，\(p=ui=i^2 R=\frac{u^2}{R}\) * 电容：\(i=C\frac{\mathrm{d}u}{\mathrm{d}t}\) *电感：\(u=L\frac{\mathrm{d}i}{\mathrm{d}t}\) *独立电压源、独立电流源、电压/电流控制电压/电流源

#电路拓扑 支路\(b\)，节点\(n\)，网孔\(m=b-n+1\) 串联、并联、其他

第3章 电路基本定理

#基尔霍夫定律 * 电流定律（KCL）：节点电流代数和为\(0\) → \(n-1\)个独立方程 *电压定律（KVL）：回路电压代数和为\(0\)→ \(m\)个独立方程

第4章 电路基本分析方法

#等效变换 对外等效、对内不等效 + 电阻等效 + 串联：\(R_\mathrm{eq}=\sum\limits_{i}{R_i}\) +并联：\(\frac{1}{R_\mathrm{eq}}=\sum\limits_{i}{\frac{1}{R_i}}\)+ △形→Y形：\(R_{ij}=R_i R_j\sum\limits_{k}{\frac{1}{R_k}}\) + Y形→△形：\(R_i=\frac{R_{ij}R_{ik}}{R_{ij}+R_{ik}+R_{jk}}\) * 电源等效 + 电压源串联\(u_{\mathrm{s}}\)相加，电流源并联\(i_{\mathrm{s}}\)相加 * 电源、电阻混合等效 +等效模型：电压源\(u_\mathrm{s}\)与电阻\(R_u\)并联 ⇆ 电流源\(i_\mathrm{s}\)与电阻\(R_i\)串联 + \(R_u=R_i\)，\(i_\mathrm{s}=\frac{u_\mathrm{s}}{R_u}\)，\(u_\mathrm{s}=i_\mathrm{s} R_i\)

#节点电压法 \(n-1\)个方程：自导项 -互导项 = 电源产生电流项

#回路电流法 \(m\)个方程：自阻项 -互阻项 = 电源产生电压项

以上内容建议实操练习，在实战中总结更多技巧

第5章 电路定理

#线性定理 （用\(x\)表示待求电压/电流，\(s_i\)表示第\(i\)个独立电压/电流源） * 叠加定理：\[x=f(s_1,s_2,\ldots,s_n)\Rightarrowx=\sum\limits_{i}f(\delta_{i1}s_1,\delta_{i2}s_2,\ldots,\delta_{in}s_n)\]* 齐性定理：（\(k\)为常数）\[x=f(k s_i)\Rightarrow x=kf(s_i)\] *二者结合：\[x=f(k_1 s_1,k_2 s_2,\ldots,k_ns_n)\Rightarrow x=\sum\limits_{i}k_if(\delta_{i1}s_1,\delta_{i2}s_2,\ldots,\delta_{in}s_n)\]

#替代定理 参量为\(u、i\)的支路可被替换为电压源\(u_\mathrm{s}=u\)，或电流源\(i_\mathrm{s}=i\)，或电阻\(R=\frac{u}{i}\)

#戴维南定理线性含源一端口网络可以用一个电压源和一个电阻串联来等效，该电压源的电压为一端口网络的端口开路电压\(u_{\mathrm{oc}}\)，该电阻的阻值为一端口网络内独立电源置零后的端口等效电阻\(R_{\mathrm{eq}}\) 一步法：给端口接一个\(u_\mathrm{s}、i_\mathrm{s}\)（非关联）的电源，最后可求得：\(u_\mathrm{s}=u_{\mathrm{oc}}+R_{\mathrm{eq}}i_\mathrm{s}\)

#诺顿定理 戴维南等效的“电流源版本”

最大功率传输：当\(R=R_{\mathrm{eq}}\)时，\(P_{\max}=\frac{u_{\mathrm{oc}}^2}{4R_{\mathrm{eq}}}\)

#特勒根定理 * 定理一：关联参考方向下，\[\sum\limits_{k=1}^{b}{u_k i_k}=0\] *定理二：两对应电路（规定见课本），\[\sum\limits_{k=1}^{b}{u_k\hat{i}_k}=\sum\limits_{k=1}^{b}{\hat{u}_k i_k}=0\] *定理二的推论：两对应电路，除线性电阻网络外，\[\sum\limits_{k=1}^{r}{u_k\hat{i}_k}=\sum\limits_{k=1}^{r}{\hat{u}_k i_k}\]

#互易定理 对二端口网络的两端分别施加激励，\[\frac{激励1}{响应1}=\frac{激励2}{响应2}\]

#对偶原理 有兴趣请见课本

==第二篇 动态电路的时域分析==

第6章动态电路的动态元件和微分方程

#电容 VCR：\(i=C\frac{\mathrm{d}u}{\mathrm{d}t}\) 或\(u(t)=u(t_0)+\frac{1}{C}\int_{t_0}^{t}i(\xi)\mathrm{d}\xi\)能量：\(w=\frac{1}{2}Cu^2\)等效变换：（与电阻相反） * 串联：\(\frac{1}{C_\mathrm{eq}}=\sum\limits_{i}{\frac{1}{C_i}}\)* 并联：\(C_\mathrm{eq}=\sum\limits_{i}{C_i}\)平行板电容器：\(C=\varepsilon\frac{S}{d}\)

#电感 VCR：\(u=C\frac{\mathrm{d}i}{\mathrm{d}t}\) 或\(i(t)=i(t_0)+\frac{1}{L}\int_{t_0}^{t}u(\xi)\mathrm{d}\xi\)能量：\(w=\frac{1}{2}Li^2\)等效变换：（与电阻相反） * 串联：\(L_\mathrm{eq}=\sum\limits_{i}{L_i}\) *并联：\(\frac{1}{L_\mathrm{eq}}=\sum\limits_{i}{\frac{1}{L_i}}\)

#动态电路的定解问题 * 微分方程：KVL + KCL + VCR 方程组联立 →关于电流/电压的\(n\)阶常系数线性微分方程 * 初始条件：\(u_C(0_+)=u_C(0_-)\) 以及 \(i_L(0_+)=i_L(0_-)\) + 以上方程组 →关于电流/电压的\(n\)阶常系数线性微分方程的\(n\)个初始条件 * 特殊情况：\(u_C(t)\)或\(i_L(t)\)在\(t=0\)时刻发生突变，此时应对某个方程进行\(t=0_-\)到\(t=0_+\)的积分，才能求出\(u_C(0_+)\) 或 \(i_L(0_+)\)。(详见课本\(P_{135}\)的例子）

第7章 一阶动态电路

电容、电感的充、放电方程见课本

#三要素公式 电容电压： \[u_C(t)=u_C(\infty)+[u_C(0_+)-u_C(\infty)]\mathrm{e}^{-\frac{t}{\tau}}\]其中： \[\tau=CR_{\mathrm{eq}}\]电感电流： \[i_L(t)=i_L(\infty)+[i_L(0_+)-i_L(\infty)]\mathrm{e}^{-\frac{t}{\tau}}\]其中： \[\tau=\frac{L}{R_{\mathrm{eq}}}\]

#一阶电路的响应 由叠加定理得， \[全响应=零状态响应+零输入响应\] 阶跃函数：\[\varepsilon \left( t \right) =\begin{cases} 0,t<0\\ 1,t>0\\\end{cases}\] 冲激函数： \[\delta(t)=\frac{\mathrm{d}}{\mathrm{d}t}\varepsilon(t)\]求解阶跃响应只需先求各组分阶跃函数的响应，再由叠加定理叠加便可得最终解。求解冲激响应只需先求解对应的阶跃响应，然后对阶跃响应求导便可得冲激响应。

第8章 二阶动态电路

定解问题为二阶微分方程

求解二阶微分方程： 特征方程 → 特征根\(\lambda_1,\lambda_2\) → 齐次通解： \[\lambda_1=\lambda_2 \Rightarrowy=(A+Bt)\mathrm{e}^{\lambda t}\] \[\lambda_1\ne\lambda_2 \Rightarrowy=\mathrm{Re}(A\mathrm{e}^{\lambda_1 t}+B\mathrm{e}^{\lambda_2t})\]（这里是为了方便记忆，出现复指数则用欧拉公式展开成三角函数表示）

（如果是非齐次方程：凑出非齐次特解 → 原方程通解为：齐次通解 +非齐次特解）

最后：待定系数，由初始条件定解

#RLC串联电路的工作状态 * 过阻尼：\(R>2\sqrt{\frac{L}{C}}\) → 单调衰减 *临界阻尼：\(R=2\sqrt{\frac{L}{C}}\) →单调衰减，但衰减相比于过阻尼更快 * 欠阻尼：\(0<R<2\sqrt{\frac{L}{C}}\) → 震荡衰减* 零阻尼：\(R=0\) →等幅振荡，不衰减

其他二阶电路，见课本

==第三篇 正弦交流电路==

第9章 正弦交流电路分析基础

正弦量： \[f(t)=F_\mathrm{m}\cos(\omegat+\varphi)=\mathrm{Re}[F_\mathrm{m}\mathrm{e}^{\mathrm{j}(\omegat+\varphi)}]\] 振幅相量：（以电流为例） \[\dot{I}_\mathrm{m}=I_\mathrm{m}\mathrm{e}^{\mathrm{j}\varphi}\]#有效值相量 \[\dot{I}=I\mathrm{e}^{\mathrm{j}\varphi}=I\angle\varphi\]其中： \[I=\frac{1}{T}\sqrt{\int_0^Ti^2(t)\mathrm{d}t}\] 在正弦交流电路中，有： \[I=\frac{I_\mathrm{m}}{\sqrt{2}}\]

#相量域中的VCR \[\begin{array}{c} \dot{U}_R=R\dot{I}_R\\ \dot{U}_L=\mathrm{j}\omega L\dot{I}_L\\ \dot{I}_C=\mathrm{j}\omega C\dot{U}_C\\\end{array}\]

#阻抗 \[Z=\frac{\dot{U}}{\dot{I}}=R+\mathrm{j}X=|Z|\angle{\varphi_Z}=\frac{U}{I}\angle(\varphi_{u}-\varphi_{i})\]对基本元件，有： \[\begin{array}{c} Z_R=R\\ Z_L=\mathrm{j}\omega L\\ Z_C=\frac{1}{\mathrm{j}\omega C}\\\end{array}\]

#导纳 \[Y=\frac{1}{Z}=\frac{\dot{I}}{\dot{U}}=G+\mathrm{j}B\]

第10章正弦交流电路的相量分析法

#代数方法 具体方法同第一篇内容，只是变量从实数域变到了复数域

将时域正弦量转换为相量 → 用电路定理求解 → 将相量转换回正弦量

#相量图实际上是电路方程通过复数的几何意义映射到复平面中的首尾相接矢量多边形

列写方程 → 确定参考相量 → 依次绘制其他相量 →构成多边形，找几何关系，求解

重要关系： * 电阻电压与电流同相位，即：\(\varphi_{u}-\varphi_{i}=0\degree\) *电感电压超前电流\(90\degree\)，即：\(\varphi_{u}-\varphi_{i}=90\degree\) *电容电压滞后电流\(90\degree\)，即：\(\varphi_{u}-\varphi_{i}=-90\degree\)

以上内容建议实操练习，在实战中总结更多技巧

第11章 正弦交流电路的功率

#瞬时功率 \[p(t)=u(t)i(t)\]

#复功率 \[\bar{S}=P+\mathrm{j}Q=UI\mathrm{e}^{\mathrm{j}(\varphi_{u}-\varphi_{i})}=\dot{U}\dot{I}^*=I^2Z=\frac{U^2}{Z^*}\]（代入VCR即可推出电阻、电感、电容的复功率表达式，不建议死记）

#有功功率\[P=\mathrm{Re}(\bar{S})=UI\cos(\varphi_{u}-\varphi_{i})\]#最大有功功率传输 可变负载幅角和模值：当 \(Z=Z_\mathrm{eq}^*\) 时，\(P_\max=\frac{U_\mathrm{oc}^2}{4R_\mathrm{eq}}\)仅可变负载模值：当 \(|Z|=|Z_\mathrm{eq}|\) 时，\(P_\max=\ldots\)

#无功功率\[Q=\mathrm{Im}(\bar{S})=UI\sin(\varphi_{u}-\varphi_{i})\]

#视在功率 \[S=|S|=UI\]

#功率因数 \[\cos\varphi=\cos(\varphi_{u}-\varphi_{i})=\frac{P}{S}\]

#功率守恒 \(\bar{S}\)守恒（对所有电路元件的代数和为\(0\)），即 \(P,Q\) 守恒 \(S\) 不一定守恒

==第四篇 电路应用与拓展==

第12章 三相电路

#三相 （正序，顺时针） \[\dot{U}_\mathrm{A}=U\angle0\degree,\;\dot{U}_\mathrm{B}=U\angle-120\degree,\;\dot{U}_\mathrm{C}=U\angle120\degree\]有： \[\dot{U}_\mathrm{A}+\dot{U}_\mathrm{B}+\dot{U}_\mathrm{C}=0\]相量图：略

注意区分：（详见书） * 相电压、相电流、线电压、线电流 *电压源/负载的Y形/△形接法

#对称三相电路 将△形变换为Y形 → 所有中性点\(\dot{U}_\mathrm{N'}=0\)，等效变换化简 →求解

#不对称三相电路 回归到一般的相量法求解

#功率表 读数：\(P=\mathrm{Re}(\dot{U}\dot{I}^*)\)（注意：这里的 \(\dot{U}\) 和 \(\dot{I}\)不一定恰好是同一支路的，只有是同一支路\(P\)才表示有功功率）

二瓦计法： \[P_1+P_2=\mathrm{Re}(\dot{U}_\mathrm{AB}\dot{I}_\mathrm{A}^*)+\mathrm{Re}(\dot{U}_\mathrm{CB}\dot{I}_\mathrm{C}^*)=P_\mathrm{A}+P_\mathrm{B}+P_\mathrm{C}\]详细的接法见课本

第13章 磁耦合电路

#同名端 同名端流入电流产生的磁场相互增强

#互感电压 电流、电压为关联参考方向，电流从同名端流入时： 时域： \[\begin{cases} u_1=L_1\frac{\mathrm{d}i_1}{\mathrm{d}t}+M\frac{\mathrm{d}i_2}{\mathrm{d}t}\\ u_2=L_2\frac{\mathrm{d}i_2}{\mathrm{d}t}+M\frac{\mathrm{d}i_1}{\mathrm{d}t}\\\end{cases}\] 相量域： \[\begin{cases} \dot{U}_1=\mathrm{j}\omega L_1\dot{I}_1+\mathrm{j}\omegaM\dot{I}_2\\ \dot{U}_2=\mathrm{j}\omega L_2\dot{I}_2+\mathrm{j}\omegaM\dot{I}_1\\\end{cases}\]

其他情况，应 #判断互感电压的极性 ：自己线圈流入电流的端子对应对方线圈的同名端上的互感电压极性为\(+\)。

#去耦等效 互感系数可以叠加到两个电感上（耦合同方向串联为\(+\)，反之为\(-\)），并在中间支路上叠加一个与前面的叠加项相反的电感。（详见课本）

#变压器 耦合系数： \[k=\frac{M}{\sqrt{L_1L_2}}\] 全耦合：\(k=1\)

#阻抗变换 输入阻抗： \[Z_\mathrm{in}=\mathrm{j}\omega L_1+\frac{(\omegaM)^2}{Z_2+\mathrm{j}\omega L_2}\] 输出阻抗： \[Z_\mathrm{out}=\mathrm{j}\omega L_2+\frac{(\omegaM)^2}{Z_1+\mathrm{j}\omega L_1}\]（死记不到，建议现推）

去耦等效：连接变压器下方的两个端子，即可用上述方法进行去耦等效

#理想变压器 定义：无损耗、全耦合、\(L_1,L_2,M\rightarrow \infty\)性质：（电流、电压为关联参考方向，电流从同名端流入时；如果不是，请添\(-\)号来转换） * \(\frac{u_1}{u_2}=\frac{\dot{U}_1}{\dot{U}_2}=\frac{N_1}{N_2}=n\)* \(\frac{i_1}{i_2}=\frac{\dot{I}_1}{\dot{I}_2}=-\frac{N_2}{N_1}=-\frac{1}{n}\)* 输入功率等于输出功率 * 阻抗变换：\(Z_\mathrm{in}=\frac{N_1^2}{N_2^2}Z_2=n^2Z_2\)

第14章 滤波器和谐振电路

#传递函数 \[H(\mathrm{j}\omega)=\frac{输入信号相量}{输出信号相量}\]

#滤波器 分类：低通、高通、带通 截止角频率\(\omega_\mathrm{c}\)：\(|H(\mathrm{j}\omega_\mathrm{c})|=\frac{1}{\sqrt{2}}\)幅频特性曲线：\(|H(\mathrm{j}\omega)|-\omega\) 图像

#谐振 定义：\(\mathrm{Im}(Z_\mathrm{eq})=0\) 分类： *串联谐振 * \(Z=R+\mathrm{j}(\omegaL-\frac{1}{\omega C})=R\) * \(\omega=\frac{1}{\sqrt{LC}}\) *LC整体相当于短路 * 并联谐振 * \(Y=\frac{1}{R}+\mathrm{j}(\omega C-\frac{1}{\omegaL})=\frac{1}{R}\) * \(\omega=\frac{1}{\sqrt{LC}}\) *LC整体相当于开路

#品质因数 \[Q=2\pi\frac{最大耗能}{一个周期储能}=\frac{U_L}{U_\mathrm{s}}或\frac{U_C}{U_\mathrm{s}}\]\(Q\)越大，带宽越窄，幅频特性曲线越陡，频率选择性越高

串联谐振： \[Q=\frac{\omegaL}{R}=\frac{1}{R\omega C}\] 并联谐振： \[Q=\frac{R}{\omega L}=R\omega C\]

第15章 非正弦周期电路

傅里叶级数，详见课本

求解：先求各分量的响应，在运用叠加原理即可

#非正弦周期电路的有效值 \[\begin{array}{c} U=\sqrt{U_{0}^{2}+\sum\limits_{n=1}^r{U_{n}^{2}}}\\ I=\sqrt{I_{0}^{2}+\sum\limits_{n=1}^r{I_{n}^{2}}}\\\end{array}\]

#非正弦周期电路的平均功率 \[P=P_{0}+\sum\limits_{n=1}^rP_{n}=I^2R=\frac{U^2}{R}\]

第16章 二端口网络

二端口网络的定义：\(i_1=i'_1,\;i_2=i'_2\)

#阻抗参数 \[\left[ \begin{array}{c} \dot{U}_1\\ \dot{U}_2\\\end{array} \right] =\boldsymbol{Z}\left[ \begin{array}{c} \dot{I}_1\\ \dot{I}_2\\\end{array} \right]\] #导纳参数 \[\left[ \begin{array}{c} \dot{I}_1\\ \dot{I}_2\\\end{array} \right] =\boldsymbol{Y}\left[ \begin{array}{c} \dot{U}_1\\ \dot{U}_2\\\end{array} \right]\] #混合参数 \[\left[ \begin{array}{c} \dot{U}_1\\ \dot{I}_2\\\end{array} \right] =\boldsymbol{H}\left[ \begin{array}{c} \dot{I}_1\\ \dot{U}_2\\\end{array} \right]\] #传输参数 \[\left[ \begin{array}{c} \dot{U}_1\\ \dot{I}_1\\\end{array} \right] =\boldsymbol{T}\left[ \begin{array}{c} \dot{U}_2\\ -\dot{I}_2\\\end{array} \right]\]

性质： \[\begin{array}{c} Z_{12}=Z_{21}\\ Y_{12}=Y_{21}\\ H_{12}=-H_{21}\\ T_{11}T_{12}-T_{21}T_{12}=1\\\end{array}\]

等效电路：T形、Π形

连接方式：级联（\(\boldsymbol{T}=\boldsymbol{T}_1\boldsymbol{T}_2\)）、串联、并联

第17章 含有运算放大器的电路

#特性 对输入端： * 虚断：\(i_+=i_-\approx0\) * 虚短：\(u_+\approx u_-\)

#含运放电路的求解 1. 完整标记虚短、虚断 2. 输入端列写KCL 3. 求解

这部分简单而易错，容易会列出错误的关系式，应当时刻小心。

要注意以下两点： * 运放是含源元件，不要在连接运放的回路上乱列KVL *运放输出端电流不满足虚断，不要在输出端乱列KCL

具体的电路实例详见课本

作者：黄得清 笔记软件：Obsidian 时间：2024/1/11字数：[[电路文件信息.png]]

]]> https://hexo.dytchem.cn/2024/08/20/test002/ 2024-08-20T04:33:14.000Z

注意： 1. 本文相关教材：电路（慕课版 支持AR+H5交互）邹建龙 著 人民邮电出版社 2. 本文为纯干货，建议配合课本复习，并辅以实战练习 3. 本文无图，如有图片需求，请到课本对应章节查看 4. 本文为了使某些内容更容易被理解和记忆，特地转换了表述]]>

电路知识点速记 2026-07-18T12:12:38.389Z Dytchem \[\left( \frac{1}{2}+\sum_{n=1}^{\infty}{\frac{1}{4n^2+1}} \right) \left(\frac{1}{2}+\sum_{n=1}^{\infty}{\frac{1}{4n^4+1}} \right) =\frac{\pi^2}{16}\]

]]> https://hexo.dytchem.cn/2024/08/20/test001/ 2024-08-20T00:00:00.000Z \[ \left( \frac{1}{2}+\sum_{n=1}^{\infty}{\frac{1}{4n^2+1}} \right)]]> 圆周率的一种无穷级数 2026-07-18T12:12:38.388Z Dytchem

Welcome to Hexo! This is your veryfirst post. Check documentation formore info. If you get any problems when using Hexo, you can find theanswer in troubleshooting oryou can ask me on GitHub.

]]> https://hexo.dytchem.cn/2024/08/19/hello-world/ 2024-08-19T00:00:00.000Z

Welcome to Hexo! This is your very first post. Check

Hello World 2026-07-18T12:12:38.385Z