![\"300\"](\"D:%5CHexo-Blog%5Cmy-hexo-blog%5Csource_posts%5C2025-12-15-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%5CSVM-01.png\")
机器学习
\n\n
| 学习类型 | \n主要用途 | \n核心模型 / 算法 | \n常见应用场景 | \n
|---|---|---|---|
| 监督学习 | \n分类 (Classification) | \n1. 逻辑回归 (Logistic Regression, LR) | \n二分类问题，如邮件是否为垃圾邮件 | \n
| \n | \n | 2. 支持向量机 (Support Vector Machine, SVM) | \n小样本、高维度的分类问题 | \n
| \n | \n | 3. 决策树 (Decision Tree, DT) | \n可解释性要求高的分类和回归 | \n
| \n | \n | 4. K - 近邻算法 (K-Nearest Neighbors, KNN) | \n简单的分类和回归任务 | \n
| \n | \n | 5. 朴素贝叶斯 (Naive Bayes, NB) | \n文本分类、情感分析 | \n
| \n | 回归 (Regression) | \n1. 线性回归 (Linear Regression) | \n预测连续值，如房价预测 | \n
| \n | \n | 2. 多项式回归 (Polynomial Regression) | \n解决非线性关系回归问题 | \n
| 集成学习 (Ensemble) | \n分类 / 回归 | \n1. 随机森林 (Random Forest, RF) | \n防止过拟合、特征重要性分析 | \n
| \n | \n | 2. 梯度提升 (Gradient Boosting, GB) | \n常用：XGBoost、LightGBM、CatBoost | \n
| \n | \n | 3. Adaboost (Adaptive Boosting) | \n提升弱分类器的性能 | \n
| 无监督学习 | \n聚类 (Clustering) | \n1. K - 均值 (K-Means) | \n市场细分、图像分割 | \n
| \n | \n | 2. DBSCAN (Density-Based Spatial Clustering) | \n发现任意形状的簇、识别异常点 | \n
| \n | \n | 3. 层次聚类 (Hierarchical Clustering) | \n基因序列分析、构建分类树 | \n
| \n | 降维 (Dimensionality Reduction) | \n1. 主成分分析 (Principal Component Analysis, PCA) | \n数据可视化、数据预处理 | \n
| \n | \n | 2. T-SNE (T-distributed Stochastic Neighbor Embedding) | \n高维数据可视化 | \n
| \n | 关联规则 | \nApriori (先验算法) | \n购物篮分析、推荐系统 | \n
| 深度学习 | \n感知机 / 神经网络 | \n1. 多层感知机 (Multi-Layer Perceptron, MLP) | \n最基础的神经网络结构 | \n
| \n | 图像 / 视觉 | \n2. 卷积神经网络 (Convolutional Neural Network, CNN) | \n图像分类、目标检测、人脸识别 | \n
| \n | 序列 / 文本 | \n3. 循环神经网络 (Recurrent Neural Network, RNN) | \n文本生成、语音识别 | \n
| \n | \n | 4. 长短期记忆网络 (Long Short-Term Memory, LSTM) | \n解决 RNN 的梯度消失问题 | \n
| \n | \n | 5. Transformer/Attention 机制 | \nBERT, GPT 等大模型的基石，取代 RNN 成为主流 | \n
核心任务：预测一个连续值（例如：房价、气温、电池剩余寿命）。 它试图找到一条直线（或高维超平面）来拟合数据点。
\n模型假设输入特征 x 和输出 y 之间存在线性关系：
\ny=wTx+b
\n线性回归通常使用 均方误差 (Mean Squared Error, MSE)。目的是最小化预测值与真实值之间差值的平方和。
\nJ(w,b)=2m1i=1∑m(y(i)−y^(i))2
\n为什么用平方？ 因为平方可以消除正负误差的影响，并且是凸函数，方便求导和寻找全局最优解。
\n核心任务：虽然叫 “回归”，但它实际上是解决 二分类 问题（例如：是否患病、是否点击广告）。 它预测的是事件发生的概率（0 到 1 之间的值）。
\n它在线性回归的基础上，加了一个 激活函数 (Sigmoid Function)，把输出压缩到 (0,1) 之间。
\nhθ(x)=sigmoid(wTx+b)=1+e−(wTx+b)1
\n逻辑回归 不能 使用 MSE（均方误差），因为引入 Sigmoid 后，MSE 不再是凸函数，会导致梯度下降陷入局部最优解。
\n它使用对数损失 (Log Loss)，也叫 交叉熵损失 (Cross-Entropy Loss)：
\nJ(w)=−m1i=1∑m[y(i)log(y^(i))+(1−y(i))log(1−y^(i))]
\n这个公式的物理意义是：极大似然估计 (Maximum Likelihood Estimation)。
\n深度思考：常见的面试坑点
\n在逻辑回归中，只要能把两类分开的线都可以。但在 SVM 中，我们追求 **“最宽的街道”**。
\n我们想要最大化间隔。几何间隔的公式是 ∣∣w∣∣1。最大化 ∣∣w∣∣1 等价于 最小化 ∣∣w∣∣2。
\n所以，硬间隔（Hard Margin）SVM 的原始优化目标是：
\nw,bmin21∣∣w∣∣2
\ns.t.yi(wTxi+b)≥1,i=1,...,m
\n(这里的约束条件是：所有样本点都必须被正确分类，且都在间隔之外)
\n求解过程可以分为三个阶段：构造拉格朗日函数 → 转化为对偶问题 → 利用 SMO 算法求解。
\n我们的目标是最小化 w 的模长，同时保证分类正确：
\nw,bmin21∣∣w∣∣2
\ns.t.yi(wTxi+b)≥1,i=1,…,m
\n这是一个带约束的凸优化问题。为了消除约束，我们需要引入拉格朗日乘子 (Lagrange Multipliers) αi（其中 αi≥0）。
\n我们将约束条件融合到目标函数中：
\nL(w,b,α)=21∣∣w∣∣2−i=1∑mαi[yi(wTxi+b)−1]
\n原问题是 “极小极大” 问题（minw,bmaxαL）。对偶问题是它的交换形式，即 “极大极小” 问题（maxαminw,bL）。
\n我们需要先对 w 和 b 求偏导并令其为 0（求极小值），消掉这两个变量。
\n∂w∂L=w−i=1∑mαiyixi=0⇒w=i=1∑mαiyixi
\n∂b∂L=−i=1∑mαiyi=0⇒i=1∑mαiyi=0
\n\n\n关键点：第一个公式 w=∑αiyixi 告诉我们，权重向量 w 只是数据点 xi 的线性组合。而且只有支持向量的 αi>0，其他非支持向量的 αi=0，这意味着 w 只由少数支持向量决定。
\n
将上面求出的 w 代回 L(w,b,α) 中，经过化简（推导过程略去繁琐的代数运算），我们得到了只包含 α 的对偶目标函数：
\nαmax(i=1∑mαi−21i=1∑mj=1∑mαiαjyiyj(xiTxj))
\n![\"300\"](\"D:%5CHexo-Blog%5Cmy-hexo-blog%5Csource_posts%5C2025-12-15-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%5CSVM-02.png\")
![\"300\"](\"D:%5CHexo-Blog%5Cmy-hexo-blog%5Csource_posts%5C2025-12-15-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%5CSVM-03.png\")
![\"300\"](\"D:%5CHexo-Blog%5Cmy-hexo-blog%5Csource_posts%5C2025-12-15-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%5CSVM-04.png\")
KNN 没有显式的 “训练” 过程（它只是把数据存起来）。当来了一个新样本 xnew 需要预测时，它执行以下三步：
\n\n\n三个关键要素:
\n\n
\n- \n
\n距离度量
\n\n
\n- \n
\n欧氏距离 (Euclidean Distance)：最常用。即两点间的直线距离。
\nd(x,y)=i=1∑n(xi−yi)2
\n- \n
\n曼哈顿距离 (Manhattan Distance)：城市街区距离（走直角）。
\nd(x,y)=i=1∑n∣xi−yi∣
\n- \n
\n余弦相似度 (Cosine Similarity)：关注方向而非距离，常用于文本分类。
\n\n\n特征缩放 (Feature Scaling) KNN 对数据的量纲极度敏感！
\n\n
\n- 例如：特征 A 是 “身高 (米)”(1.7-1.9)，特征 B 是 “工资 (元)”(5000-50000)。
\n- 如果不归一化，工资的差值（几万）会完全掩盖身高的差值（零点几），导致 KNN 只看工资。
\n- 结论：用 KNN 前必须进行归一化 (Normalization) 或标准化 (Standardization)。
\n- \n
\nK 值的选择：
\n\n
\n- K 很小 (如 K=1) 模型极不稳定，容易受噪声点影响（如果最近的一个点是噪声，就预测错了）。决策边界非常曲折、破碎。低偏差，高方差 (Overfitting)
\n- K 很大 (如 K=N) 模型过于简单。无论输入什么，都预测为训练集中数量最多的那一类。决策边界过于平滑。高偏差，低方差 (Underfitting)
\n- \n
\n决策规则
\n\n
\n- \n
\n多数表决：默认规则。
\n- \n
\n距离加权 (Weighted KNN)：离得近的邻居权重更大。比如权重为 1/d。这样可以缓解 K 值较大时远距离点干扰决策的问题。
\n
\n\n如何加速 KNN？
\n答案：不要暴力搜索，使用索引结构。
\n\n
\n- KD-Tree (k-Dimensional Tree)：\n
\n\n
\n- 一种对 k 维空间进行划分的二叉树。
\n- 核心思想：把数据像切蛋糕一样切成一块块的。查找时，先判断目标点在哪一块，通过剪枝（Pruning）排除掉大部分不可能包含最近邻的区域。
\n- 缺点：当特征维度很高时（>20 维），KD-Tree 的效率会退化成线性扫描。
\n- Ball Tree：\n
\n\n
\n- 使用超球面来划分空间，在高维数据上比 KD-Tree 表现稍好。
\n
决策树学习的关键在于如何选择最优划分属性。一般而言，随着划分过程不断进行，我们希望决策树的分支结点所包含的样本尽可能属于同一类别，即结点的 “纯度”(purity) 越来越高。
\n物理意义：熵越大，数据越混乱；熵越小，数据越纯。
\n公式：
\nH(D)=−k=1∑Kpklog2pk
\n(其中 pk 是第 k 类样本所占的比例)
\n![\"300\"](\"D:%5CHexo-Blog%5Cmy-hexo-blog%5Csource_posts%5C2025-12-15-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%5C%E5%86%B3%E7%AD%96%E6%A0%91-01.png\")
Gain(D,A)=H(D)−v=1∑V∣D∣∣Dv∣H(Dv)
\n![\"300\"](\"D:%5CHexo-Blog%5Cmy-hexo-blog%5Csource_posts%5C2025-12-15-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%5C%E5%86%B3%E7%AD%96%E6%A0%91-02.png\")
import math | |
def Ent(a, b): | |
if a == 0 or b == 0: | |
return 0 | |
c = a + b | |
a, b = a / c, b / c | |
return -a * math.log2(a) - b * math.log2(b) | |
H_D = Ent(9, 5) | |
H_D_A1 = 5/14*Ent(2, 3) + 4/14*Ent(4, 0) + 5/14*Ent(2, 3) | |
Gain_A1 = H_D - H_D_A1 | |
print(f'{Gain_A1=}') |
为了修正 ID3 的偏见，C4.5 引入了惩罚项。它用 “信息增益” 除以该特征的 “固有熵”（Intrinsic Value）。
\nGain_Ratio(D,A)=IVA(A)Gain(D,A)
\n特征取值越多，IVA(A) 越大，分母变大，增益率就被压低了。
\n![\"300\"](\"D:%5CHexo-Blog%5Cmy-hexo-blog%5Csource_posts%5C2025-12-15-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%5C%E5%86%B3%E7%AD%96%E6%A0%91-03.png\")
![\"300\"](\"D:%5CHexo-Blog%5Cmy-hexo-blog%5Csource_posts%5C2025-12-15-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%5C%E5%86%B3%E7%AD%96%E6%A0%91-04.png\")
import math | |
def Ent(a, b): | |
if a == 0 or b == 0: | |
return 0 | |
c = a + b | |
a, b = a / c, b / c | |
return -a * math.log2(a) - b * math.log2(b) | |
H_D = Ent(9, 5) | |
H_D_A1 = 5/14*Ent(2, 3) + 4/14*Ent(4, 0) + 5/14*Ent(2, 3) | |
Gain_A1 = H_D - H_D_A1 | |
print(f'{Gain_A1=}') | |
IV_A1 = -5/14*math.log2(5/14) - 4/14*math.log2(4/14) - 5/14*math.log2(5/14) | |
Gain_Ratio_A1 = Gain_A1 / IV_A1 | |
print(f'{Gain_Ratio_A1=}') |
现在的工业界主流算法（如 XGBoost, sklearn 的默认树）都使用 CART (Classification and Regression Tree)。
\n物理意义：从集合中随机抽取两个样本，它们类别不一致的概率。
\n公式：
\nGini(p)=1−k=1∑Kpk2
\nGiniindex(D,a)=v=1∑V∣D∣∣Dv∣Gini(Dv)
\n决策逻辑：选择让分裂后基尼系数最小的特征。
\n![\"image-20251222110215402\"](\"D:%5CHexo-Blog%5Cmy-hexo-blog%5Csource_posts%5C2025-12-15-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%5C%E5%86%B3%E7%AD%96%E6%A0%91-05.png\")
\n\n💡 面试必问：为什么 CART 用 Gini 而不用熵？
\n\n
\n- 计算快：熵需要算 log，计算机算对数很慢；Gini 只需要算乘法和减法。
\n- 效果近似：在绝大多数情况下，Gini 和熵生成的树结构非常相似。
\n
在树生长过程中，提前停止。
\nmax_depth )。min_samples_leaf )。先让树长到最大，然后自底向上地剪掉那些不重要的枝叶。
\n随机森林属于 Bagging (Bootstrap Aggregating) 算法的代表。它的强大来自于两个 “随机”：
\nQ: 随机森林能处理缺失值吗？
\nAdaboost 通常使用最简单的 决策树桩 (Decision Stump) 作为基分类器（即只有一层深度的树，切一刀）。
\n最开始，所有 N 个训练样本的权重是平等的，都是 1/N。
\n在每一轮 t 中：
\n把这 T 个弱分类器线性组合起来，话语权大的说了算：
\nH(x)=sign(t=1∑Tαtht(x))
\n| 特性 | \n随机森林 (Random Forest) | \nAdaboost | \n
|---|---|---|
| 训练方式 | \n并行 (大家各干各的，互不干扰) | \n串行 (接力赛，后一个依赖前一个) | \n
| 样本权重 | \n始终相同 (通过 Bootstrap 随机抽样) | \n动态调整 (错题权重越来越大) | \n
| 基分类器权重 | \n平等 (1 人 1 票) | \n加权 (能力强的票权大) | \n
| 主要作用 | \n降低方差 (防止过拟合) | \n降低偏差 (提升准确率) | \n
| 对异常值 | \n不敏感 (抗噪能力强) | \n极度敏感 (因为异常值通常是难分样本，权重会被无限放大，带偏模型) | \n
Q: 对于无法接受带权样本的个体学习器，应该采样什么办法调整权重？
\n参考：躺懂 XGBoost，学不会来打我（doge）_哔哩哔哩_bilibili
\ny^(t)=y^(t−1)+ft(x)
\nXGBoost 显式地定义了正则化：
\nΩ(ft)=γT+21λj=1∑Twj2
\ni=1∑NL(yi,y^i(t))+j=1∑tΩ(fj)
\n前 t−1 棵树已经确定，仅需要优化第 t 棵树的值即可。
\n将 y^i(t) 展开，并去掉前 t−1 棵树的正则化项（因为它们已经是常数了），得到：
\nObj(t)=i=1∑nl(yi,y^i(t−1)+ft(xi))+γT+21λj=1∑Twj2
\n换成以叶子节点的形式遍历，
\nObj(t)=[j=1∑T[i∈Ij∑l(yi,y^i(t−1)+wj)]+21λwj2]+γT
\n\n\n这里如果确定损失函数为均方损失，可以利用贪心可以求解每个叶子节点内的最优值。但是不同任务损失函数不同，需要确立一种跨损失函数的通用方法。
\n\n
这是 XGBoost 最核心的数学魔法。GBDT 只用到一阶导，而 XGBoost 对损失函数进行了二阶泰勒展开。
\n回顾泰勒公式：f(x+Δx)≈f(x)+f′(x)Δx+21f′′(x)Δx2。
\n把 wj 看作 Δx，我们展开：
\nl(yi,y^i(t−1)+wj)≈l(yi,y^i(t−1))+l′(yi,y^i(t−1))wj+21l′′(yi,y^i(t−1))wj2
\n其中，第一项为常量，可删去，可表示为
\nl(yi,y^i(t−1)+wj)≈giwj+21hiwj2
\n其中，
\n因此，整体目标函数可写为：
\nObj(t)=j=1∑T[i∈Ij∑(giwj+21hiwj2)+21λwj2]+γT=j=1∑T[wji∈Ij∑gi+21wj2i∈Ij∑hi+21λwj2]+γT=j=1∑T[wji∈Ij∑gi+21wj2(i∈Ij∑hi+λ)]+γT
\n定义该叶子上所有样本的 梯度之和：
\n目标函数变形为：
\nObj(t)=j=1∑T[Gjwj+21(Hj+λ)wj2]+γT
\n现在，目标函数变成了关于 wj 的一元二次函数（抛物线）：
\nf(wj)=Awj2+Bwj+C
\n其中 A=21(Hj+λ)，B=Gj。
\n对于一元二次方程，极值点在 w=−B/2A 处取得。
\n所以，给定树结构的情况下，第 j 个叶子节点最优的叶子权重 wj∗ 为：
\nwj∗=−Hj+λGj
\n把 wj∗ 代回目标函数，得到这棵树的最小损失值（打分）：
\nObj∗=−21j=1∑THj+λGj2+γT
\n\n\n💡 物理意义：
\n\n
\n- Gj 代表这一堆样本的一阶梯度总和（想要移动的方向）。
\n- Hj 代表二阶曲率（移动的阻力）。
\n- λ 是正则化项，增加分母，让计算出的权重 wj∗ 不要太大（缩减）。
\n- Obj∗ 越小，说明这个树结构越好。
\n
我们要找一棵树，但不可能遍历所有可能的树结构。XGBoost 使用贪心算法，从根节点开始，尝试每一次分裂。
\n假设我们要把一个节点分裂成左子节点 (L) 和 右子节点 (R)。
\n我们要判断 “这一刀切下去值不值”。
\n\n\n注意：这里每个节点的 G 和 H 都是已知的
\n
增益公式 (Gain) = (切分后分数) - (切分前分数) - (引入新叶子的代价)：
\nGain=21[HL+λGL2+HR+λGR2−HL+HR+λ(GL+GR)2]−γ
\n\n\n如何优化特征值排序：
\n\n
\n
\n- \n
\n筛选特征：列采样：（1）按树随机：直接随机选择特征，不更改；（2）按层随机（灵活）：每层都重新随机选取特征。
\n- \n
\n筛选特征值：（1）分桶；（2）加权分位法：根据每个样本的hi 进行分桶。
\n\n
\n
\n\nXGBoost（Extreme Gradient Boosting）本质上是 GBDT（Gradient Boosting Decision Tree）的一种高效、并行的工程实现。
\n它的基本思想是 Boosting（提升） 策略，即通过串行地迭代训练多个弱学习器（通常是 CART 回归树），每棵树都在拟合上一轮模型的残差（或者更准确地说是负梯度），最后将所有树的预测值加权求和得到最终结果。
\n二阶泰勒展开（最核心的区别）
\n\n\n话术：
\n“传统的 GBDT 在优化目标函数时，通常只用到了一阶导数（梯度）。
\n而 XGBoost 对目标函数进行了 二阶泰勒展开。它同时利用了 一阶导数（gi） 和 二阶导数（hi, 海森矩阵） 来近似目标函数。
\n这样做的好处是：下降得更快，收敛更精确。这就好比牛顿法相比梯度下降法，收敛速度通常更快。”
\n正则化（防止过拟合）
\n\n\n话术：
\n“XGBoost 在目标函数中显式地加入了 正则化项（Regularization）。
\n它惩罚了叶子节点的个数（γT） 和 叶子节点权重的 L2 模平方（21λ∣∣w∣∣2）。
\n这一项在传统的 GBDT 中通常没有，这使得 XGBoost 学习出来的树更加简单，抗过拟合能力更强。”
\n面试官可能会追问：“那它和 LightGBM 有什么区别？” 或者 “为什么现在不用它了？” 你可以主动在大结局提到。
\n\n\n话术： “总结一下，XGBoost 相比于传统 GBDT，引入了二阶导数、正则化项和特征并行化，在精度和速度上都达到了很好的平衡。不过，随着数据量达到亿级，后来的 LightGBM 通过 GOSS（单边梯度采样）和 EFB（互斥特征捆绑）进一步提升了训练速度和内存效率。 但在中小规模的表格数据上，XGBoost 依然是目前最稳健的选择之一。”
\n
假设数据簇是球状的。我们先随机插 K 个旗子（质心），谁离旗子近就算谁的人；然后根据这些人的位置移动旗子，直到旗子不动为止。
\n最小化 簇内平方误差和 (Within-Cluster Sum of Squares, WCSS)：
\nJ=j=1∑Kx∈Cj∑∣∣x−μj∣∣2
\n也就是让簇内尽可能紧凑。
\nQ：K 怎么选？
\n肘部法则 (Elbow Method)：画出 K 值与 Loss 的曲线，找拐点（像手肘一样的位置）。
\n轮廓系数 (Silhouette Coefficient)：结合了 “簇内紧密度” 和 “簇间分离度”。值在 [−1,1] 之间，越接近 1 越好。
\nQ：初始点敏感吗？
\n非常敏感。如果运气不好，初始点选在一堆，可能陷入局部最优。
\n解法：使用 K-Means++。它的策略是 “让初始质心尽可能离得远”。
\nDBSCAN (Density-Based Spatial Clustering of Applications with Noise) 的算法流程其实非常像是在 “传染病毒” 或者 “发展下线”。
\n它的核心逻辑是：只要密度够大，就继续向外扩张，直到碰壁（密度不够）为止。
\n以下是详细的算法流程拆解：
\n在开始之前，必须定好两个参数（之前复习过的）：
\nDBSCAN 不需要预先指定 K 个簇，它从数据集中任意一个未访问的点开始。
\n我们有一个点集 D，开始遍历每一个点 P：
\n计算 P 在半径 ϵ 内的邻居数量（包括它自己）：
\n这是 DBSCAN 最关键的一步。一旦找到了一个核心点 P，我们就有了 “火种”，现在要让火烧起来。
\n回到第一步，继续找下一个未访问的点，直到所有点都被访问过。
\n假设我们有 N 个数据点。
\n| 维度 | \nK-Means (划分法) | \nDBSCAN (密度法) | \n层次聚类 (层次法) | \n
|---|---|---|---|
| 核心思想 | \n找质心，算距离，迭代优化 | \n找高密度区域，向外扩张 | \n自底向上合并，构建家谱 | \n
| 输入参数 | \n需要指定簇数量 K | \n需要指定半径 ϵ 和密度阈值 MinPts | \n不需要参数 (切分时需指定阈值或 K) | \n
| 簇的形状 | \n必须是凸形 / 球状 (Convex) | \n可以是任意形状 (非凸) | \n取决于 Linkage (通常较灵活) | \n
| 对异常值 | \n敏感 (会被拉偏质心) | \n鲁棒 (自动识别为噪声并丢弃) | \n较敏感 (取决于 Linkage) | \n
| 时间复杂度 | \n快 O(N⋅K⋅I) | \n中 O(NlogN) (带索引) | \n最慢 O(N3) 或 O(N2logN) | \n
| 适用数据量 | \n大规模数据 | \n中规模数据 | \n小规模数据 (<1 万) | \n
| 主要缺陷 | \n陷入局部最优、K 难定 | \n怕密度不均、高维失效 | \n计算太慢、不可撤销合并 | \n
假设我们有 m 个样本，每个样本有 n 个特征（数据矩阵 X 为 m×n）。
\n一句话总结：PCA 保留的是 “整体轮廓”（方差），t-SNE 保留的是 “局部邻里关系”。
\nt-SNE 的名字里有三个关键词：t - 分布、随机 (Stochastic)、邻域 (Neighbor)。
\n在高维空间里，我们要衡量两个点 xi 和 xj 有多像。
\nt-SNE 假设数据符合高斯分布（正态分布）。
\n我们在 2D 平面上随机撒一堆点 yi,yj。我们希望这些点之间的概率分布 qj∣i 能完美复刻高维空间里的 pj∣i。
\n现在我们有两套概率分布：P（真身）和 Q（替身）。
\n我们要让 Q 尽可能像 P。
\n这是 t-SNE 的灵魂所在。
\n拥挤问题 (The Crowding Problem)：
\n高维空间极其巨大，而低维空间（2D）非常拥挤。想象一下，一个球体在高维空间里，它的表面积是随着维度指数增长的，但在 2D 平面上只有一点点地方。
\n如果你强行把高维数据压到 2D，原本中等距离的点会被迫挤在一起，破坏聚类效果。
\nt - 分布的解决方案：t - 分布相比高斯分布，是一个 **“长尾巴” (Heavy Tailed)** 的分布。
\n对少样本进行过采样
\n对多样本进行降采样
\n阈值移动
\nLeetcode 刷题记录
\n\n
对于字符串 s 和 t ，只有在 s = t + t + t + ... + t + t （ t 自身连接 1 次或多次）时，我们才认定 “ t 能除尽 s ”。
给定两个字符串 str1 和 str2 。返回 最长字符串 x ，要求满足 x 能除尽 str1 且 x 能除尽 str2 。
若两个字符串是由同一个字符串 X 重复拼接而成，那么无论先拼哪个，结果应该相同。
\n如果 str1 + str2 != str2 +str1，说明不存在公共的重复因子，直接返回空串 ""。
\n如果两个字符串都是由同一个字符串 X 组成，那么 X 的长度必然是 str1.size () 和 str2.size () 的最大公约数。
class Solution: | |
def gcdOfStrings(self, str1: str, str2: str) -> str: | |
if not str1 + str2 == str2 + str1: | |
return \"\" | |
return str1[0:self.gcd(len(str1), len(str2))] | |
def gcd(self, a,b): | |
if b == 0: return a | |
else: return gcd(b, a%b) |
作者：Random
\n 链接：https://leetcode.cn/problems/greatest-common-divisor-of-strings/solutions/3749891/shu-xue-zui-da-gong-yue-shu-by-coder-ran-a88u/
假设有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花不能种植在相邻的地块上，它们会争夺水源，两者都会死去。
\n给你一个整数数组 flowerbed 表示花坛，由若干 0 和 1 组成，其中 0 表示没种植花， 1 表示种植了花。另有一个数 n ，能否在不打破种植规则的情况下种入 n 朵花？能则返回 true ，不能则返回 false 。
从左到右遍历数组，能种花就立刻种花。
\n如何判断能否种花？由于「花不能种植在相邻的地块上」，如果要在下标 i 处种花，需要满足 flowerbed [i−1],flowerbed [i],flowerbed [i+1] 均为 0。
\n每种一朵花，就把 n 减一。如果最后 n≤0，则返回 true，否则返回 false。
\n为了简化判断逻辑，可以在数组的开头和末尾各插入一个 0。
\nclass Solution: | |
def canPlaceFlowers(self, flowerbed: List[int], n: int) -> bool: | |
nums = len(flowerbed) | |
new_flowerbed = [0] + flowerbed + [0] | |
for i in range(1,len(new_flowerbed)-1): | |
if new_flowerbed[i-1] == 0 and new_flowerbed[i+1] == 0 and new_flowerbed[i] == 0: | |
new_flowerbed[i] = 1 | |
n -= 1 | |
return n <= 0 |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/can-place-flowers/solutions/2463018/ben-ti-zui-jian-dan-xie-fa-pythonjavacgo-6a6k/
给你一个整数数组 nums ，判断这个数组中是否存在长度为 3 的递增子序列。
如果存在这样的三元组下标 (i, j, k) 且满足 i < j < k ，使得 nums[i] < nums[j] < nums[k] ，返回 true ；否则，返回 false 。
核心想法：遍历一遍数组，希望遍历到的这个数 three，前面已经有一个比他小的数 two，再前面有一个比 two 小的数 one。
\n我们需要维护两个变量：one 和 two。代表递增子序列的第一个数和第二个数。
\n假设我们已经有了这两个数，那么 three 的大小有以下三种情况：
three 大于 two 此情况下：即找到了三元组，直接返回 true。
\n![](\"/2025/08/15/2025-08-15-Leetcode/334-01.png\")
three 介于 two 和 one 之间 此情况下：应更新 two，赋值为这个更小的值。这相当于帮我们扩大了 three 的可选择范围，当再次遇到一个比更新过的 two 大的数即可找到。
\n![](\"/2025/08/15/2025-08-15-Leetcode/334-02.png\")
![](\"/2025/08/15/2025-08-15-Leetcode/334-03.png\")
three 小于 one 此情况下：应更新 one，赋值为这个更小的值。而不需要动 two。这相当于帮我们扩大了之后出现的 two 的可选择范围。进而扩大了之后出现的 three 的可选择范围。
\n![](\"/2025/08/15/2025-08-15-Leetcode/334-04.png\")
![](\"/2025/08/15/2025-08-15-Leetcode/334-05.png\")
![](\"/2025/08/15/2025-08-15-Leetcode/334-06.png\")
需要注意的是，我们只更新 one，原先的 two 不需要更改，因为子序列是从前往后的，只有当之后再出现比 two 小的数的时候再按照第二步那样更改。
\n假设有如下示例：[2,5,1,6]，在遇到 1 之后更新了 one，后遇到 6，因为先判断是否大于 two，由于 6 大于 5，就直接返回 true 了。
\n![](\"/2025/08/15/2025-08-15-Leetcode/334-07.png\")
注意：two 附带隐含信息 —— 这之前有个数比 two 小
\n所以此时找到的递增子序列不是 one、two、three 的 1 5 6，而是 old one、two、three 的 2 5 6。
这里更新的 one 的意思是，为之后可能存在的更小的递增子序列打基础。
\n假设有如下示例：[2,5,1,2,6]，在遇到 1 之后更新了 one，后遇到 2，2 介于 1 和 5（two）之间，更新 two 为 2，后遇到 6，由于 6 大于 2，返回 true。
\n此时找到的递增子序列才是 one、two、three 的 1 2 6
最后考虑 one、two 的初值，容易想到设定为 Integer.MAX_VALUE 即可。
\n作者：Xzz
\n 链接：https://leetcode.cn/problems/increasing-triplet-subsequence/solutions/535725/pou-xi-ben-zhi-yi-wen-bang-ni-kan-qing-t-3ye2/
class Solution: | |
def increasingTriplet(self, nums: List[int]) -> bool: | |
one, two = inf, inf | |
for three in nums: | |
if three > two : return True | |
elif three <= one: one = three | |
else: two = three | |
return False |
1. 递增三元组的性质
\n假设数组中存在递增三元组 a < b < c ，它们的顺序在数组中是 前后顺序，我们只关心：
关键点：我们不需要知道三元组具体位置，只需要保证存在。
\n2. one 和 two 的作用
\n![\"image-20251222135513397\"](\"D:%5CHexo-Blog%5Cmy-hexo-blog%5Csource_posts%5C2025-12-15-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%5CXGBoost-01.png\")
![\"300\"](\"D:%5CHexo-Blog%5Cmy-hexo-blog%5Csource_posts%5C2025-12-15-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%5CXGBoost-02.png\")
![\"300\"](\"D:%5CHexo-Blog%5Cmy-hexo-blog%5Csource_posts%5C2025-12-15-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%5CXGBoost-04.png\")
![\"image-20251222145720637\"](\"D:%5CHexo-Blog%5Cmy-hexo-blog%5Csource_posts%5C2025-12-15-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%5CXGBoost-03.png\")
one ：当前找到的最小的候选第一个数two ：在 one 之后，找到的最小的候选第二个数核心思想：
\n换句话说：
\n3. 为什么不会漏掉任何情况
\n假设数组中有递增三元组 x < y < z ，为什么算法一定能找到它？
关键点：
\n常规解法
\n以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。
示例 1：
\n输入：intervals = [[1,3],[2,6],[8,10],[15,18]]\n输出：[[1,6],[8,10],[15,18]]\n解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].\n示例 2：
\n输入：intervals = [[1,4],[4,5]]\n输出：[[1,5]]\n解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。\n示例 3：
\n输入：intervals = [[4,7],[1,4]]\n输出：[[1,7]]\n解释：区间 [1,4] 和 [4,7] 可被视为重叠区间。\n重要定理：能够合并的区间都必然是连续的。
\nclass Solution: | |
def merge(self, intervals: List[List[int]]) -> List[List[int]]: | |
intervals.sort(key=lambda x:x[0]) | |
result = [] | |
for interval in intervals: | |
if not result or interval[0] > result[-1][-1]: | |
result.append(interval) | |
else: | |
result[-1][-1] = max(result[-1][-1], interval[-1]) | |
return result |
作者：力扣官方题解
\n链接：https://leetcode.cn/problems/merge-intervals/solutions/203562/he-bing-qu-jian-by-leetcode-solution/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
给定一个整数数组 nums ，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。
示例 1:
\n输入: nums = [1,2,3,4,5,6,7], k = 3\n输出: [5,6,7,1,2,3,4]\n解释:\n向右轮转 1 步: [7,1,2,3,4,5,6]\n向右轮转 2 步: [6,7,1,2,3,4,5]\n向右轮转 3 步: [5,6,7,1,2,3,4]\n示例 2:
\n输入：nums = [-1,-100,3,99], k = 2\n输出：[3,99,-1,-100]\n解释: \n向右轮转 1 步: [99,-1,-100,3]\n向右轮转 2 步: [3,99,-1,-100]\n这里假设 0≤k<n，对于 k≥n 的情况，可以转换成 0≤k<n 的情况（证明见后文）。
\n设 nums=A+B，其中 A 是 nums 的前 n−k 个数，B 是后 k 个数。在上例中，A=[1,2,3,4]，B=[5,6,7]。
\n题目要求把 A+B 变成 B+A，这可以用三次反转实现：
\n把 nums=A+B 反转，我们得到了 rev (B)+rev (A)，其中 rev (A) 表示数组 A 反转后的结果。在上例中，rev (B)+rev (A)=[7,6,5]+[4,3,2,1]。
\n单独反转 rev (B)，因为一个数组反转两次是不变的，所以 rev (rev (B))=B，我们得到了 B。
\n单独反转 rev (A)，得到 rev (rev (A))=A。
\n现在数组变成 B+A。在上例中，B+A=[5,6,7]+[1,2,3,4]，这正是我们想要的结果。
class Solution: | |
def rotate(self, nums: List[int], k: int) -> None: | |
\"\"\" | |
Do not return anything, modify nums in-place instead. | |
\"\"\" | |
def reverse(l,r): | |
while l < r: | |
nums[l], nums[r] = nums[r], nums[l] | |
l += 1 | |
r -= 1 | |
n = len(nums) | |
k = k % n | |
reverse(0,n-1) | |
reverse(0,k-1) | |
reverse(k,n-1) | |
return |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/rotate-array/solutions/2784427/tu-jie-yuan-di-zuo-fa-yi-tu-miao-dong-py-ryfv/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。
请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。
示例 1：
\n输入：nums = [1,2,0]\n输出：3\n解释：范围 [1,2] 中的数字都在数组中。\n示例 2：
\n输入：nums = [3,4,-1,1]\n输出：2\n解释：1 在数组中，但 2 没有。\n示例 3：
\n输入：nums = [7,8,9,11,12]\n输出：1\n解释：最小的正数 1 没有出现。\n由于我们只在意 [1,N] 中的数，因此我们可以先对数组进行遍历，把不在 [1,N] 范围内的数修改成任意一个大于 N 的数（例如 N+1）。这样一来，数组中的所有数就都是正数了，因此我们就可以将「标记」表示为「负号」。算法的流程如下：
\n我们将数组中所有小于等于 0 的数修改为 N+1；
\n我们遍历数组中的每一个数 x，它可能已经被打了标记，因此原本对应的数为 ∣x∣，其中 ∣∣ 为绝对值符号。如果 ∣x∣∈[1,N]，那么我们给数组中的第 ∣x∣−1 个位置的数添加一个负号。注意如果它已经有负号，不需要重复添加；
\n在遍历完成之后，如果数组中的每一个数都是负数，那么答案是 N+1，否则答案是第一个正数的位置加 1。
\nclass Solution: | |
def firstMissingPositive(self, nums: List[int]) -> int: | |
n = len(nums) | |
for i in range(n): | |
if nums[i] <= 0: | |
nums[i] = n+1 | |
for i in range(n): | |
num = abs(nums[i]) | |
if num <= n: | |
nums[num-1] = -abs(nums[num-1]) | |
for i in range(n): | |
if nums[i] > 0: | |
return i+1 | |
return n+1 |
作者：力扣官方题解
\n链接：https://leetcode.cn/problems/first-missing-positive/solutions/304743/que-shi-de-di-yi-ge-zheng-shu-by-leetcode-solution/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。
示例 1：
\n** 输入：**nums = [1,1,1,2,2,3], k = 2
\n输出：[1,2]
\n示例 2：
\n** 输入：**nums = [1], k = 1
\n输出：[1]
\n示例 3：
\n** 输入：**nums = [1,2,1,2,1,2,3,1,3,2], k = 2
\n输出：[1,2]
\n答案与元素的出现次数有关，我们首先用一个哈希表 cnt 统计每个元素的出现次数。哈希表的 key 是元素值，value 是 key 在数组中的出现次数。
\n此时问题变成：返回一个列表，包含前 k 大的出现次数对应的元素值。
\n设出现次数最大值为 maxCnt，由于 maxCnt≤n，我们可以用桶排序，把出现次数相同的元素，放到同一个桶中。
\n创建一个大小为 maxCnt+1 的列表 buckets，其中 buckets [c] 存储出现次数为 c 的元素。（每个 buckets [c] 都是一个列表）
\n遍历 cnt，把出现次数为 c 的元素 x 添加到 buckets [c] 中。
\n倒序遍历 buckets，把 buckets [c] 中的元素加到答案中。一旦答案的长度等于 k，就立刻返回答案。
\nclass Solution: | |
def topKFrequent(self, nums: List[int], k: int) -> List[int]: | |
cnt = Counter(nums) | |
max_cnt = max(cnt.values()) | |
pocket = [[] for _ in range(max_cnt+1)] | |
for i in cnt.keys(): | |
pocket[cnt[i]].append(i) | |
result = [] | |
print(pocket) | |
for i in range(max_cnt,-1,-1): | |
print(result,len(result),k) | |
if len(result) == k:return result | |
result+=pocket[i] |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/top-k-frequent-elements/solutions/3655287/tong-pai-xu-on-xian-xing-zuo-fa-pythonja-oqq2/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
:::
\n给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。
给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。
示例 1：
\n![](\"/2025/08/15/2025-08-15-Leetcode/54-01.png\")
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]\n输出：[1,2,3,6,9,8,7,4,5]\nclass Solution: | |
def spiralOrder(self, matrix: List[List[int]]) -> List[int]: | |
m, n = len(matrix), len(matrix[0]) | |
visited = [[0]*n for _ in range(m)] | |
count = m*n | |
directions = [[0,1],[1,0],[0,-1],[-1,0]] | |
x, y = 0, 0 | |
mode = 0 | |
result = [] | |
for i in range(count): | |
visited[x][y] = 1 | |
result.append(matrix[x][y]) | |
mode = mode % 4 | |
if 0 <= x + directions[mode][0] < m and 0 <= y + directions[mode][1] < n and visited[x + directions[mode][0]][y + directions[mode][1]]==0: | |
x += directions[mode][0] | |
y += directions[mode][1] | |
# print(visited) | |
else: | |
mode = (mode + 1)%4 | |
x += directions[mode][0] | |
y += directions[mode][1] | |
return result |
给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。
你必须在原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。
\n示例 1：
\n![](\"/2025/08/15/2025-08-15-Leetcode/48-01.png\")
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]\n输出：[[7,4,1],[8,5,2],[9,6,3]]\n先沿对角线翻转，后沿中轴线翻转。
\nclass Solution: | |
def rotate(self, matrix: List[List[int]]) -> None: | |
\"\"\" | |
Do not return anything, modify matrix in-place instead. | |
\"\"\" | |
m = len(matrix) | |
for i in range(m): | |
for j in range(i): | |
matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j] | |
for i in range(m): | |
for j in range(m//2): | |
matrix[i][j], matrix[i][m-1-j] = matrix[i][m-1-j], matrix[i][j] | |
return |
编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性：
分离出每行，在每行内执行二分查找。
\nclass Solution: | |
def searchMatrix(self, matrix: List[List[int]], target: int) -> bool: | |
def bi_sect(rows, left, right): | |
while left <= right: | |
mid = (left + right) // 2 | |
if target == rows[mid]: return True | |
elif target > rows[mid]: left = mid+1 | |
else:right = mid-1 | |
return False | |
n = len(matrix) | |
for i in range(n): | |
if bi_sect(matrix[i],0,len(matrix[i])-1):return True | |
return False |
给你两个长度相同的字符串， s 和 t 。
将 s 中的第 i 个字符变到 t 中的第 i 个字符需要 |s[i] - t[i]| 的开销（开销可能为 0），也就是两个字符的 ASCII 码值的差的绝对值。
用于变更字符串的最大预算是 maxCost 。在转化字符串时，总开销应当小于等于该预算，这也意味着字符串的转化可能是不完全的。
如果你可以将 s 的子字符串转化为它在 t 中对应的子字符串，则返回可以转化的最大长度。
如果 s 中没有子字符串可以转化成 t 中对应的子字符串，则返回 0 。
示例 1：
\n输入：s = "abcd", t = "bcdf", maxCost = 3\n输出：3\n解释：s 中的 "abc" 可以变为 "bcd"。开销为 3，所以最大长度为 3。\n示例 2：
\n输入：s = "abcd", t = "cdef", maxCost = 3\n输出：1\n解释：s 中的任一字符要想变成 t 中对应的字符，其开销都是 2。因此，最大长度为 1。\n示例 3：
\n输入：s = "abcd", t = "acde", maxCost = 0\n输出：1\n解释：a -> a, cost = 0，字符串未发生变化，所以最大长度为 1。\n两个长度相等字符串的 s 和 t ，把 i 位置的 s [i] 转成 t [i] 的开销是两者 ASCII 码之差的绝对值。题目给出了允许的最大预算 maxCost ，求不超过预算的情况下能够转换的最长子串。
\n比如，对于 s = "abcd", t = "bcdf", cost = 3 而言，我们使用 costs [i] 表示从 s [i] 转成 t [i] 的开销，那么 costs = [1, 1, 1, 2] 。由于 maxCost = 3， 所以最多允许其前面三个字符进行转换。
\n于是题目变成了：已知一个数组 costs ，求：和不超过 maxCost 时最长的子数组的长度。
\n![](\"/2025/08/15/2025-08-15-Leetcode/1208-01.png\")
class Solution: | |
def equalSubstring(self, s: str, t: str, maxCost: int) -> int: | |
n = len(s) | |
left, right = 0, 0 | |
result = 0 | |
cost = 0 | |
while right < n: | |
cost += abs(ord(s[right]) - ord(t[right])) | |
while cost > maxCost: | |
cost -= abs(ord(s[left]) - ord(t[left])) | |
left += 1 | |
result = max(result, right - left + 1) | |
right += 1 | |
return result |
《挑战程序设计竞赛》这本书中把滑动窗口叫做「虫取法」，我觉得非常生动形象。因为滑动窗口的两个指针移动的过程和虫子爬动的过程非常像：前脚不动，把后脚移动过来；后脚不动，把前脚向前移动。
\n我分享一个滑动窗口的模板，能解决大多数的滑动窗口问题（1004. 最大连续 1 的个数 III，424. 替换后的最长重复字符）：
\ndef findSubArray(nums): | |
N = len(nums) # 数组 / 字符串长度 | |
left, right = 0, 0 # 双指针，表示当前遍历的区间 [left, right]，闭区间 | |
sums = 0 # 用于统计 子数组 / 子区间 是否有效，根据题目可能会改成求和 / 计数 | |
res = 0 # 保存最大的满足题目要求的 子数组 / 子串 长度 | |
while right < N: # 当右边的指针没有搜索到 数组 / 字符串 的结尾 | |
sums += nums[right] # 增加当前右边指针的数字 / 字符的求和 / 计数 | |
while 区间[left, right]不符合题意：# 此时需要一直移动左指针，直至找到一个符合题意的区间 | |
sums -= nums[left] # 移动左指针前需要从 counter 中减少 left 位置字符的求和 / 计数 | |
left += 1 # 真正的移动左指针，注意不能跟上面一行代码写反 | |
# 到 while 结束时，我们找到了一个符合题意要求的 子数组 / 子串 | |
res = max(res, right - left + 1) # 需要更新结果 | |
right += 1 # 移动右指针，去探索新的区间 | |
return res |
滑动窗口中用到了左右两个指针，它们移动的思路是：以右指针作为驱动，拖着左指针向前走。右指针每次只移动一步，而左指针在内部 while 循环中每次可能移动多步。右指针是主动前移，探索未知的新区域；左指针是被迫移动，负责寻找满足题意的区间。
\n模板的整体思想是：
\n定义两个指针 left 和 right 分别指向区间的开头和结尾，注意是闭区间；定义 sums 用来统计该区间内的各个字符出现次数；
\n第一重 while 循环是为了判断 right 指针的位置是否超出了数组边界；当 right 每次到了新位置，需要增加 right 指针的求和 / 计数；
\n第二重 while 循环是让 left 指针向右移动到 [left, right] 区间符合题意的位置；当 left 每次移动到了新位置，需要减少 left 指针的求和 / 计数；
\n在第二重 while 循环之后，成功找到了一个符合题意的 [left, right] 区间，题目要求最大的区间长度，因此更新 res 为 max (res, 当前区间的长度) 。
\nright 指针每次向右移动一步，开始探索新的区间。
\n模板中的 sums 需要根据题目意思具体去修改，本题是求和题目因此把 sums 定义成整数用于求和；如果是计数题目，就需要改成字典用于计数。当左右指针发生变化的时候，都需要更新 sums 。
另外一个需要根据题目去修改的是内层 while 循环的判断条件，即： 区间 [left, right] 不符合题意 。对于本题而言，就是该区内的和 sums 超过了 maxCost 。
\n作者：负雪明烛
\n链接：https://leetcode.cn/problems/get-equal-substrings-within-budget/solutions/592354/fen-xiang-zhen-cang-de-hua-dong-chuang-k-e3rd/
给你一个字符串 s 和一个整数 k 。你可以选择字符串中的任一字符，并将其更改为任何其他大写英文字符。该操作最多可执行 k 次。
在执行上述操作后，返回 包含相同字母的最长子字符串的长度。
\n示例 1：
\n输入：s = "ABAB", k = 2\n输出：4\n解释：用两个'A'替换为两个'B',反之亦然。\n示例 2：
\n输入：s = "AABABBA", k = 1\n输出：4\n解释：\n将中间的一个'A'替换为'B',字符串变为 "AABBBBA"。\n子串 "BBBB" 有最长重复字母, 答案为 4。\n可能存在其他的方法来得到同样的结果。\n本题解根据常规的滑动窗口思路进行解题，不需要任何的技巧。
\n滑动窗口法是指通过 Left 以及 Right 指针来框定一个窗口，当在窗口内的字符串满足题目要求则记录下当前窗口长度并进一步扩张寻找更长的窗口，若不满足则进行窗口平移。
\n题目中给定的 K 值是让我们在选定有效窗口时的要求放宽了：
当 K=0 时，要求滑动窗口内部的所有字母都必须相同；
\n而当 K>0 时，要求滑动窗口内最多替换 K 次使得所有字母都必须相同。这里有一个关键点，即我们将当前滑动窗口内出现次数最多的字母作为基准字母（Benchmark），那么其他不一样的字母 (Others) 都选择替换操作即可以最小的代价转换为全部相同的字母。
\n因此，我们首先通过一个数组 (count) 记录所有字母在当前窗口出现的次数，通过 Max 函数选择窗口内的基准字母，然后其他字母出现的次数为 Sum (count)-Max (count)，通过与 K 进行比较，即可知道当前窗口是否有效，下一步是继续扩张还是位移。
class Solution: | |
def characterReplacement(self, s: str, k: int) -> int: | |
count = [0 for _ in range(26)] #记录当前窗口的字母出现次数 | |
left = 0 #滑动窗口左边界 | |
right = 0 #滑动窗口右边界 | |
retval = 0 #最长窗口长度 | |
while right < len(s): | |
count[ord(s[right])-ord('A')] += 1 | |
benchmark = max(count) #选择出现次数最多的字母为基准 | |
others = sum(count) - benchmark #则其他字母需要通过替换操作来变为基准 | |
if others <= k: #通过与 K 进行比较来判断窗口是进行扩张？ | |
right += 1 | |
retval = max(retval, right-left)#记录当前有效窗口长度 | |
else: #通过与 K 进行比较来判断窗口还是进行位移？ | |
count[ord(s[left])-ord('A')] -= 1 | |
left += 1 | |
right += 1 #这里注意：位移操作需要整个向右移，不仅仅只是 left 向右 | |
return retval #返回最长窗口长度 |
作者：Derrick.S
\n 链接：https://leetcode.cn/problems/longest-repeating-character-replacement/solutions/799013/hua-dong-chuang-kou-fa-jian-dan-yi-dong-3qwel/
给你一个整数数组 nums ，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
返回 滑动窗口中的最大值 。
\n示例 1：
\n输入：nums = [1,3,-1,-3,5,3,6,7], k = 3\n输出：[3,3,5,5,6,7]\n解释：\n滑动窗口的位置 最大值\n--------------- -----\n[1 3 -1] -3 5 3 6 7 3\n 1 [3 -1 -3] 5 3 6 7 3\n 1 3 [-1 -3 5] 3 6 7 5\n 1 3 -1 [-3 5 3] 6 7 5\n 1 3 -1 -3 [5 3 6] 7 6\n 1 3 -1 -3 5 [3 6 7] 7\n示例 2：
\n输入：nums = [1], k = 1\n输出：[1]\n回忆 最小栈 ，其使用 单调栈 实现了随意入栈、出栈情况下的 O (1) 时间获取 “栈内最小值” 。本题同理，不同点在于 “出栈操作” 删除的是 “列表尾部元素” ，而 “窗口滑动” 删除的是 “列表首部元素” 。
\n窗口对应的数据结构为 双端队列 ，本题使用 单调队列 即可解决以上问题。遍历数组时，每轮保证单调队列 deque ：
\n算法流程：
\n初始化： 双端队列 deque ，结果列表 res ，数组长度 n ；
\n滑动窗口： 左边界范围 i∈[1−k,n−k] ，右边界范围 j∈[0,n−1]
\n返回值： 返回结果列表 res ；
\ndef maxSlidingWindow(self, nums: List[int], k: int) -> List[int]: | |
n = len(nums) | |
# if n < k:return [] | |
# elif n == k :return [max(nums)] | |
deque = [] | |
result = [] | |
for right in range(n): | |
left = right - k + 1 | |
if left > 0 and deque[0] == nums[left-1]: | |
deque.pop(0) | |
while deque and deque[-1] < nums[right]: | |
deque.pop(-1) | |
deque.append(nums[right]) | |
if left >= 0: | |
result.append(deque[0]) | |
return result |
作者：Krahets
\n 链接：https://leetcode.cn/problems/sliding-window-maximum/solutions/2361228/239-hua-dong-chuang-kou-zui-da-zhi-dan-d-u6h0/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。
注意：
\nt 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。s 中存在这样的子串，我们保证它是唯一的答案。示例 1：
\n输入：s = "ADOBECODEBANC", t = "ABC"\n输出："BANC"\n解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。\n示例 2：
\n输入：s = "a", t = "a"\n输出："a"\n解释：整个字符串 s 是最小覆盖子串。\n示例 3:
\n输入: s = "a", t = "aa"\n输出: ""\n解释: t 中两个字符 'a' 均应包含在 s 的子串中，\n因此没有符合条件的子字符串，返回空字符串。\n代码实现时，可以把 cntS 和 cntT 合并成一个 cnt，定义
\ncnt[x]=cntT[x]−cntS[x]
\n如果 cnt [x]=0，就意味着窗口内字母 x 的出现次数和 t 的一样多。
\nclass Solution: | |
def minWindow(self, s: str, t: str) -> str: | |
cnt = collections.defaultdict(int) | |
for c in t: | |
cnt[c] += 1 | |
count = len(cnt) | |
res_left, res_right = -1, len(s) | |
left = 0 | |
for right, c in enumerate(s): | |
cnt[c] -= 1 | |
if cnt[c] == 0: | |
count -= 1 | |
while count == 0: | |
if right-left < res_right-res_left: | |
res_left, res_right = left, right | |
if cnt[s[left]] == 0: | |
count += 1 | |
cnt[s[left]] += 1 | |
left += 1 | |
return '' if res_left<0 else s[res_left: res_right+1] |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/minimum-window-substring/solutions/2713911/liang-chong-fang-fa-cong-o52mn-dao-omnfu-3ezz/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
给你一个整数数组 nums ，请计算数组的 中心下标 。
数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。
\n如果中心下标位于数组最左端，那么左侧数之和视为 0 ，因为在下标的左侧不存在元素。这一点对于中心下标位于数组最右端同样适用。
如果数组有多个中心下标，应该返回 最靠近左边 的那一个。如果数组不存在中心下标，返回 -1 。
示例 1：
\n输入：nums = [1, 7, 3, 6, 5, 6]\n输出：3\n解释：\n中心下标是 3 。\n左侧数之和 sum = nums[0] + nums[1] + nums[2] = 1 + 7 + 3 = 11 ，\n右侧数之和 sum = nums[4] + nums[5] = 5 + 6 = 11 ，二者相等。\n示例 2：
\n输入：nums = [1, 2, 3]\n输出：-1\n解释：\n数组中不存在满足此条件的中心下标。\n示例 3：
\n输入：nums = [2, 1, -1]\n输出：0\n解释：\n中心下标是 0 。\n左侧数之和 sum = 0 ，（下标 0 左侧不存在元素），\n右侧数之和 sum = nums[1] + nums[2] = 1 + -1 = 0 。\n设 nums 的元素之和为 s。
\n设中心下标为 i，其左侧元素和为 leftS=nums[0]+nums[1]+⋯+nums[i−1]，那么右侧元素和为 s−nums[i]−leftS。
\n由于左侧元素和等于右侧元素和，所以有
\nleftS=s−nums[i]−leftS
\n即
\n2⋅leftS=s−nums[i]
\n从左到右遍历数组，一边遍历，一边累加元素更新 leftS。每次累加前，检查是否满足上式，满足则返回 i。
\n如果不存在这样的 i，返回 −1。
\nclass Solution: | |
def pivotIndex(self, nums: List[int]) -> int: | |
s = sum(nums) | |
sum_left = 0 | |
for i, num in enumerate(nums): | |
if 2*sum_left == s - num: | |
return i | |
sum_left += num | |
return -1 |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/find-pivot-index/solutions/2834687/jian-ji-xie-fa-o1-e-wai-kong-jian-python-tz0p/
给你一个下标从 0 开始、大小为 n x n 的整数矩阵 grid ，返回满足 Ri 行和 Cj 列相等的行列对 (Ri, Cj) 的数目 *。*
如果行和列以相同的顺序包含相同的元素（即相等的数组），则认为二者是相等的。
\n用哈希表统计每行出现的次数，然后遍历列，累加哈希表中列出现的次数。
\n作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/equal-row-and-column-pairs/solutions/1694047/ha-xi-biao-python-liang-xing-by-endlessc-ljae/
class Solution: | |
def equalPairs(self, grid: List[List[int]]) -> int: | |
cnt = Counter(tuple(row) for row in grid) | |
return sum(cnt[col] for col in zip(*grid)) |
class Solution: | |
def equalPairs(self, grid: List[List[int]]) -> int: | |
n = len(grid) | |
count = {} | |
result = 0 | |
for i in range(n): | |
count[tuple(grid[i])] = count.get(tuple(grid[i]), 0) + 1 | |
print(count) | |
for j in zip(*grid): | |
print(j) | |
result += count.get(j,0) | |
# print(grid[:][j], grid[j][:]) | |
return result |
给你一个整数数组 nums 和一个整数 k ，请你统计并返回 该数组中和为 k 的子数组的个数 。
子数组是数组中元素的连续非空序列。
\n示例 1：
\n输入：nums = [1,1,1], k = 2\n输出：2\n示例 2：
\n输入：nums = [1,2,3], k = 3\n输出：2\n转化
\n回顾 303 题的前缀和的定义：s [0]=0, s [i]=nums [0]+nums [1]+⋯+nums [i−1]。注意 s 是一个长为 n+1 的数组，第一项一定是 0。
设 i<j，如果 nums [i] 到 nums [j−1] 的元素和等于 k，用前缀和表示，就是
\ns[j]−s[i]=k
\n问题转化为：
\n写成 s [j]+(−s [i])=k 就能看得更明白，这是梦开始的地方 ——1. 两数之和。不过那题只需找到一对下标，而本题需要计算所有满足条件的下标对的个数。
\n枚举右，维护左
\n以 nums=[1,1,−1,1,−1]，k=1 为例，其前缀和数组为 s=[0,1,2,1,2,1]。
如果用二重循环暴力枚举有多少个 s [j]−s [i]=k，时间复杂度是 O (n2)，太慢了。如何加速？
\n从两数之和中，我们可以学到什么？我们可以把 s [j]−s [i]=k 移项，得
\ns[i]=s[j]−k
\n遍历 s，一边枚举右边的 j，一边用哈希表统计左边有多少个 i 满足 i<j 且 s [i]=s [j]−k。
\n比如 s [j]=2，那么 s [i]=s [j]−k=2−1=1，我们要找的是 j 左边有多少个 s [i]=1。在上面的例子中，遍历到 s [4]=2 时，我们知道左边有 2 个 s [i]=1，所以新找到了 2 个和为 1 的子数组。
\ndef subarraySum(self, nums: List[int], k: int) -> int: | |
n = len(nums) | |
sums = 0 | |
ht = collections.defaultdict(int) | |
ht[0] = 1 | |
result = 0 | |
for i in range(n): | |
sums += nums[i] | |
cnt = sums - k | |
result += ht[cnt] | |
ht[sums] += 1 | |
return result |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/subarray-sum-equals-k/solutions/2781031/qian-zhui-he-ha-xi-biao-cong-liang-ci-bi-4mwr/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
给定一个整数数组 asteroids ，表示在同一行的小行星。数组中小行星的索引表示它们在空间中的相对位置。
对于数组中的每一个元素，其绝对值表示小行星的大小，正负表示小行星的移动方向（正表示向右移动，负表示向左移动）。每一颗小行星以相同的速度移动。
\n找出碰撞后剩下的所有小行星。碰撞规则：两个小行星相互碰撞，较小的小行星会爆炸。如果两颗小行星大小相同，则两颗小行星都会爆炸。两颗移动方向相同的小行星，永远不会发生碰撞。
\n示例 1：
\n输入：asteroids = [5,10,-5]\n输出：[5,10]\n解释：10 和 -5 碰撞后只剩下 10 。 5 和 10 永远不会发生碰撞。\n示例 2：
\n输入：asteroids = [8,-8]\n输出：[]\n解释：8 和 -8 碰撞后，两者都发生爆炸。\n示例 3：
\n输入：asteroids = [10,2,-5]\n输出：[10]\n解释：2 和 -5 发生碰撞后剩下 -5 。10 和 -5 发生碰撞后剩下 10 。\n这道栈的题目难点应该主要是在分析场景上了。
\n我们需要明确什么时候无脑入栈，什么时候需要判断，理解这两点就可以轻松解题了。
\n首先，循环每一个元素时，在什么情况下无脑入栈呢？
栈为空
\n栈顶元素为负数 (下一个为负数则一起向左，下一个为正数则分向两边)
\n 当前元素为正数（栈顶为正一起向右，栈顶为负分向两边）
\n下来，我们需要看碰撞的场景又细分为什么情况：
栈顶元素大于 abs (当前元素)，当前元素被撞毁
\n栈顶元素等于 abs (当前元素)，栈顶弹出和当前元素抵消
\n栈顶元素小于 abs (当前元素)，栈顶弹出，并与新栈顶完成上述判断
\n最终返回栈即可。
class Solution: | |
def asteroidCollision(self, asteroids: List[int]) -> List[int]: | |
stack, index = [], 0 | |
while index < len(asteroids): | |
ast = asteroids[index] | |
if ast > 0 or len(stack)==0 or stack[-1]<0: stack.append(ast) | |
elif stack[-1] <= - ast: | |
if stack.pop(-1) < - ast: | |
continue | |
index += 1 | |
return stack |
作者：清风 Python
\n 链接：https://leetcode.cn/problems/asteroid-collision/solutions/994100/735xing-xing-peng-zhuang-ji-yu-zhan-qu-f-xpd1/
给定一个经过编码的字符串，返回它解码后的字符串。
\n编码规则为: k[encoded_string] ，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。
你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。
\n此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。
测试用例保证输出的长度不会超过 105 。
示例 1：
\n输入：s = "3[a]2[bc]"\n输出："aaabcbc"\n示例 2：
\n输入：s = "3[a2[c]]"\n输出："accaccacc"\n示例 3：
\n输入：s = "2[abc]3[cd]ef"\n输出："abcabccdcdcdef"\n示例 4：
\n输入：s = "abc3[cd]xyz"\n输出："abccdcdcdxyz"\n本题难点在于括号内嵌套括号，需要从内向外生成与拼接字符串，这与栈的先入后出特性对应。
\n算法流程：
\n构建辅助栈 stack， 遍历字符串 s 中每个字符 c；
\n当 c 为数字时，将数字字符转化为数字 multi，用于后续倍数计算；
\n当 c 为字母时，在 res 尾部添加 c；
\n当 c 为 [ 时，将当前 multi 和 res 入栈，并分别置空置 0：
\n记录此 [前的临时结果 res 至栈，用于发现对应] 后的拼接操作；
\n记录此 [前的倍数 multi 至栈，用于发现对应] 后，获取 multi × [...] 字符串。
\n进入到新 [ 后，res 和 multi 重新记录。
当 c 为 ] 时，stack 出栈，拼接字符串 res = last_res + cur_multi * res，其中:
\n返回字符串 res。
\nclass Solution: | |
def decodeString(self, s: str) -> str: | |
result = '' | |
stack = [] | |
res, num = '', 0 | |
for c in s: | |
if c == '[': | |
stack.append((res, num)) | |
res, num = '', 0 | |
elif c == ']': | |
out_res, out_num = stack.pop() | |
res = out_res + out_num*res | |
elif '0'<= c <= '9': | |
num = num*10 + int(c) | |
else: | |
res += c | |
return res |
作者：Krahets
\n 链接：https://leetcode.cn/problems/decode-string/solutions/19447/decode-string-fu-zhu-zhan-fa-di-gui-fa-by-jyd/
Dota2 的世界里有两个阵营： Radiant （天辉）和 Dire （夜魇）
Dota2 参议院由来自两派的参议员组成。现在参议院希望对一个 Dota2 游戏里的改变作出决定。他们以一个基于轮为过程的投票进行。在每一轮中，每一位参议员都可以行使两项权利中的 一 项：
\n给你一个字符串 senate 代表每个参议员的阵营。字母 'R' 和 'D' 分别代表了 Radiant （天辉）和 Dire （夜魇）。然后，如果有 n 个参议员，给定字符串的大小将是 n 。
以轮为基础的过程从给定顺序的第一个参议员开始到最后一个参议员结束。这一过程将持续到投票结束。所有失去权利的参议员将在过程中被跳过。
\n假设每一位参议员都足够聪明，会为自己的政党做出最好的策略，你需要预测哪一方最终会宣布胜利并在 Dota2 游戏中决定改变。输出应该是 "Radiant" 或 "Dire" 。
示例 1：
\n输入：senate = "RD"\n输出："Radiant"\n解释：\n第 1 轮时，第一个参议员来自 Radiant 阵营，他可以使用第一项权利让第二个参议员失去所有权利。\n这一轮中，第二个参议员将会被跳过，因为他的权利被禁止了。\n第 2 轮时，第一个参议员可以宣布胜利，因为他是唯一一个有投票权的人。\n示例 2：
\n输入：senate = "RDD"\n输出："Dire"\n解释：\n第 1 轮时，第一个来自 Radiant 阵营的参议员可以使用第一项权利禁止第二个参议员的权利。\n这一轮中，第二个来自 Dire 阵营的参议员会将被跳过，因为他的权利被禁止了。\n这一轮中，第三个来自 Dire 阵营的参议员可以使用他的第一项权利禁止第一个参议员的权利。\n因此在第二轮只剩下第三个参议员拥有投票的权利,于是他可以宣布胜利\n这道题模拟了一个游戏过程，最终当有权利投票的参议员都是 同一个阵营的 ，这个阵营即获胜。
\n那么两个阵营的每个参议员为了获胜，当他拥有权力的时候，一定是会将自己之后首个对立阵营的参议员的权力禁止掉。【这就是每一位参议会为自己的政党做出最好的策略】。请注意：当之后没有对立阵营的参议员的时候，相当于将之前的参议员加到其之后。
\n![](\"/2025/08/15/2025-08-15-Leetcode/649-01.png\")
![](\"/2025/08/15/2025-08-15-Leetcode/649-02.png\")
![](\"/2025/08/15/2025-08-15-Leetcode/649-03.png\")
![](\"/2025/08/15/2025-08-15-Leetcode/649-04.png\")
![](\"/2025/08/15/2025-08-15-Leetcode/649-05.png\")
class Solution: | |
def predictPartyVictory(self, senate: str) -> str: | |
radiants, dires = [], [] | |
n = len(senate) | |
for i, se in enumerate(senate): | |
if se == 'R': radiants.append(i) | |
else: dires.append(i) | |
while radiants and dires: | |
if radiants[0] < dires[0]: | |
dires.pop(0) | |
radiants.append(radiants.pop(0) + n) | |
else: | |
radiants.pop(0) | |
dires.append(dires.pop(0) + n) | |
return \"Radiant\" if radiants else 'Dire' |
作者：画图小匠
\n链接：https://leetcode.cn/problems/dota2-senate/solutions/2862115/javapython3cdui-lie-mo-ni-jin-zhi-zhi-ho-l4pb/
给出一个字符串 s （仅含有小写英文字母和括号）。
请你按照从括号内到外的顺序，逐层反转每对匹配括号中的字符串，并返回最终的结果。
\n注意，您的结果中 不应 包含任何括号。
\n示例 1：
\n输入：s = "(abcd)"\n输出："dcba"\n示例 2：
\n输入：s = "(u(love)i)"\n输出："iloveu"\n解释：先反转子字符串 "love" ，然后反转整个字符串。\n示例 3：
\n输入：s = "(ed(et(oc))el)"\n输出："leetcode"\n解释：先反转子字符串 "oc" ，接着反转 "etco" ，然后反转整个字符串。\nclass Solution: | |
def reverseParentheses(self, s: str) -> str: | |
s_list = [] | |
for c in s: | |
if c == ')': | |
temp = [] | |
while s_list and s_list[-1] != '(': | |
temp.append(s_list.pop(-1)) | |
s_list.pop(-1) | |
s_list.extend(temp) | |
else: | |
s_list.append(c) | |
return ''.join(s_list) |
给定整数数组 nums 和整数 k ，请返回数组中第 **k** 个最大的元素。
请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。
示例 1:
\n输入: [3,2,1,5,6,4], k = 2\n输出: 5\n示例 2:
\n输入: [3,2,3,1,2,4,5,5,6], k = 4\n输出: 4\n快速选择
\n快速排序的核心包括 “哨兵划分” 和 “递归” 。
哨兵划分： 以数组某个元素（一般选取首元素）为基准数，将所有小于基准数的元素移动至其左边，大于基准数的元素移动至其右边。
\n递归： 对 左子数组 和 右子数组 递归执行 哨兵划分，直至子数组长度为 1 时终止递归，即可完成对整个数组的排序。
\n下图展示了数组 [2,4,1,0,3,5] 的快速排序流程。
「快速选择」：设 N 为数组长度。根据快速排序原理，如果某次哨兵划分后，基准数的索引正好是 N−k ，则意味着它就是第 k 大的数字 。此时就可以直接返回它，无需继续递归下去了。
\n然而，对于包含大量重复元素的数组，每轮的哨兵划分都可能将数组划分为长度为 1 和 n−1 的两个部分，这种情况下快速排序的时间复杂度会退化至 O (N^2)。
\n一种解决方案是使用「三路划分」，即每轮将数组划分为三个部分：小于、等于和大于基准数的所有元素。这样当发现第 k 大数字处在 “等于基准数” 的子数组中时，便可以直接返回该元素。
\n为了进一步提升算法的稳健性，我们采用随机选择的方式来选定基准数。
\nclass Solution: | |
def findKthLargest(self, nums: List[int], k: int) -> int: | |
# 快排 | |
def quick_sort(seq,k): | |
pivot = seq[len(seq)//2] | |
big, equ, small = [], [], [] | |
for i in seq: | |
if i > pivot: big.append(i) | |
elif i == pivot: equ.append(i) | |
else: small.append(i) | |
if k <= len(big): | |
return quick_sort(big, k) | |
if k > len(big) + len(equ): | |
return quick_sort(small, k-len(big)-len(equ)) | |
else: | |
return pivot | |
return quick_sort(nums, k) |
作者：Krahets
\n 链接：https://leetcode.cn/problems/kth-largest-element-in-an-array/solutions/2361969/215-shu-zu-zhong-de-di-k-ge-zui-da-yuan-d786p/
给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。
示例 1：
\n** 输入：**nums = [1,1,1,2,2,3], k = 2
\n输出：[1,2]
\n示例 2：
\n** 输入：**nums = [1], k = 1
\n输出：[1]
\n示例 3：
\n** 输入：**nums = [1,2,1,2,1,2,3,1,3,2], k = 2
\n输出：[1,2]
\n第一步
\n既然答案与元素的出现次数有关，那么先用一个哈希表 cnt 统计每个元素的出现次数。哈希表的 key 是元素值，value 是 key 在数组中的出现次数。
此时问题变成：
\n返回一个列表，包含前 k 大的出现次数对应的元素值。
\n第二步
\n把出现次数相同的元素，放到同一个桶中。同一个桶内的元素出现次数相同，无需对桶内元素排序。
设出现次数的最大值为 maxCnt。创建一个大小为 maxCnt+1 的列表 buckets，其中 buckets [c] 存储出现次数为 c 的元素。（每个 buckets [c] 都是一个列表）
\n注意 maxCnt≤n，这保证了时间复杂度是 O (n) 的。
\n遍历 cnt，把出现次数为 c 的元素 x 添加到 buckets [c] 中。
\n第三步
\n倒序遍历 buckets，把 buckets [c] 中的元素加到答案中。
一旦答案的长度等于 k，就立刻返回答案。
\nclass Solution: | |
def topKFrequent(self, nums: List[int], k: int) -> List[int]: | |
cnt = Counter(nums) | |
max_cnt = max(cnt.values()) | |
pockets = [[] for _ in range(max_cnt+1)] | |
for i in cnt.keys(): | |
pockets[cnt[i]].append(i) | |
result = [] | |
for i in range(max_cnt, -1, -1): | |
result+=pockets[i] | |
if len(result) == k: break | |
return result |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/top-k-frequent-elements/solutions/3655287/tong-pai-xu-on-xian-xing-zuo-fa-pythonja-oqq2/
中间值左侧：需要加一个 dummy 节点。
\ndummy = ListNode(0, head) | |
slow, fast = dummy, dummy | |
while fast and fast.next: | |
fast = fast.next.next | |
if not fast: break | |
slow = slow.next |
中间值右侧：直接从 head 开始
\nslow, fast = head, head | |
while fast and fast.next: | |
fast = fast.next.next | |
if not fast: break | |
slow = slow.next |
给你一个链表的头节点 head 。删除 链表的 中间节点 ，并返回修改后的链表的头节点 head 。
长度为 n 链表的中间节点是从头数起第 ⌊n / 2⌋ 个节点（下标从 0 开始），其中 ⌊x⌋ 表示小于或等于 x 的最大整数。
n = 1 、 2 、 3 、 4 和 5 的情况，中间节点的下标分别是 0 、 1 、 1 、 2 和 2 。本题可遍历计数先得到 n，再遍历一次删除指定节点即可，这很简单。本篇讲的是快慢指针这种方法。
\n我们令 fast 和 slow 这两个指针同时前进，fast 每次移动两格，slow 每次移动一格，在检测到 fast.next == null 或者 fast.next.next == null 时退出循环。
引入一个哑巴节点 dummy 便于处理，考虑循环停止时的场景。
\n为方便考虑，本篇题解认为原链表下标从 1 开始，需要删除第 ⌊2n⌋+1 个节点。
![](\"/2025/08/15/2025-08-15-Leetcode/2095-01.png\")
![](\"/2025/08/15/2025-08-15-Leetcode/2095-02.png\")
所以退出循环时 slow 一定停在 ⌊2n⌋ 个节点，令 slow.next = slow.next.next 即删除了 ⌊2n⌋+1 个节点。
# Definition for singly-linked list. | |
# class ListNode: | |
# def __init__(self, val=0, next=None): | |
# self.val = val | |
# self.next = next | |
class Solution: | |
def deleteMiddle(self, head: Optional[ListNode]) -> Optional[ListNode]: | |
zero = ListNode(0, head) | |
slow, fast = zero, zero | |
while fast and fast.next: | |
fast = fast.next.next | |
if not fast: break | |
slow = slow.next | |
slow.next = slow.next.next | |
return zero.next |
作者：Shawxing 精讲算法
\n链接：https://leetcode.cn/problems/delete-the-middle-node-of-a-linked-list/solutions/2844229/jian-ming-yan-jin-de-kuai-man-zhi-zhen-f-84sx/
给定单链表的头节点 head ，将所有索引为奇数的节点和索引为偶数的节点分别分组，保持它们原有的相对顺序，然后把偶数索引节点分组连接到奇数索引节点分组之后，返回重新排序的链表。
第一个节点的索引被认为是 奇数 ， 第二个节点的索引为 偶数 ，以此类推。
\n请注意，偶数组和奇数组内部的相对顺序应该与输入时保持一致。
\n你必须在 O(1) 的额外空间复杂度和 O(n) 的时间复杂度下解决这个问题。
如果链表为空，则直接返回链表。
\n对于原始链表，每个节点都是奇数节点或偶数节点。头节点是奇数节点，头节点的后一个节点是偶数节点，相邻节点的奇偶性不同。因此可以将奇数节点和偶数节点分离成奇数链表和偶数链表，然后将偶数链表连接在奇数链表之后，合并后的链表即为结果链表。
\n原始链表的头节点 head 也是奇数链表的头节点以及结果链表的头节点，head 的后一个节点是偶数链表的头节点。令 evenHead = head.next，则 evenHead 是偶数链表的头节点。
\n维护两个指针 odd 和 even 分别指向奇数节点和偶数节点，初始时 odd = head，even = evenHead。通过迭代的方式将奇数节点和偶数节点分离成两个链表，每一步首先更新奇数节点，然后更新偶数节点。
\n更新奇数节点时，奇数节点的后一个节点需要指向偶数节点的后一个节点，因此令 odd.next = even.next，然后令 odd = odd.next，此时 odd 变成 even 的后一个节点。
\n更新偶数节点时，偶数节点的后一个节点需要指向奇数节点的后一个节点，因此令 even.next = odd.next，然后令 even = even.next，此时 even 变成 odd 的后一个节点。
\n![](\"/2025/08/15/2025-08-15-Leetcode/328-01.png\")
![](\"/2025/08/15/2025-08-15-Leetcode/328-02.png\")
![](\"/2025/08/15/2025-08-15-Leetcode/328-03.png\")
![](\"/2025/08/15/2025-08-15-Leetcode/328-04.png\")
在上述操作之后，即完成了对一个奇数节点和一个偶数节点的分离。重复上述操作，直到全部节点分离完毕。全部节点分离完毕的条件是 even 为空节点或者 even.next 为空节点，此时 odd 指向最后一个奇数节点（即奇数链表的最后一个节点）。
\n最后令 odd.next = evenHead，将偶数链表连接在奇数链表之后，即完成了奇数链表和偶数链表的合并，结果链表的头节点仍然是 head。
\n# Definition for singly-linked list. | |
# class ListNode: | |
# def __init__(self, val=0, next=None): | |
# self.val = val | |
# self.next = next | |
class Solution: | |
def oddEvenList(self, head: Optional[ListNode]) -> Optional[ListNode]: | |
if not head: return head | |
even_head = head.next | |
odd, even = head, even_head | |
while even and even.next: | |
odd.next = even.next | |
odd = odd.next | |
even.next = odd.next | |
even = even.next | |
odd.next = even_head | |
return head |
作者：力扣官方题解
\n链接：https://leetcode.cn/problems/odd-even-linked-list/solutions/482737/qi-ou-lian-biao-by-leetcode-solution/
在一个大小为 n 且 n 为 偶数 的链表中，对于 0 <= i <= (n / 2) - 1 的 i ，第 i 个节点（下标从 0 开始）的孪生节点为第 (n-1-i) 个节点 。
n = 4 那么节点 0 是节点 3 的孪生节点，节点 1 是节点 2 的孪生节点。这是长度为 n = 4 的链表中所有的孪生节点。孪生和 定义为一个节点和它孪生节点两者值之和。
\n给你一个长度为偶数的链表的头节点 head ，请你返回链表的 最大孪生和 。
示例 1：
\n![](\"/2025/08/15/2025-08-15-Leetcode/2130-01.png\")
输入：head = [5,4,2,1]\n输出：6\n解释：\n节点 0 和节点 1 分别是节点 3 和 2 的孪生节点。孪生和都为 6 。\n链表中没有其他孪生节点。\n所以，链表的最大孪生和是 6 。\n示例 2：
\n![](\"/2025/08/15/2025-08-15-Leetcode/2130-02.png\")
输入：head = [4,2,2,3]\n输出：7\n解释：\n链表中的孪生节点为：\n- 节点 0 是节点 3 的孪生节点，孪生和为 4 + 3 = 7 。\n- 节点 1 是节点 2 的孪生节点，孪生和为 2 + 2 = 4 。\n所以，最大孪生和为 max(7, 4) = 7 。\n核心思想：寻找链表中间值
\n以下两种方法的快慢指针有所不同，参见链表。
\n# Definition for singly-linked list. | |
# class ListNode: | |
# def __init__(self, val=0, next=None): | |
# self.val = val | |
# self.next = next | |
class Solution: | |
def pairSum(self, head: Optional[ListNode]) -> int: | |
mid = self.middleNode(head) | |
head2 = self.reverseNode(mid) | |
result = -inf | |
while head2: | |
result = max(result, head.val + head2.val) | |
head = head.next | |
head2 = head2.next | |
return result | |
def reverseNode(self, head): | |
cur, pre = head, None | |
while cur: | |
nxt = cur.next | |
cur.next = pre | |
pre = cur | |
cur = nxt | |
return pre | |
def middleNode(self, head): | |
slow = fast = head | |
while fast and fast.next: | |
fast = fast.next.next | |
slow = slow.next | |
return slow |
# Definition for singly-linked list. | |
# class ListNode: | |
# def __init__(self, val=0, next=None): | |
# self.val = val | |
# self.next = next | |
class Solution: | |
def pairSum(self, head: Optional[ListNode]) -> int: | |
dummy = ListNode(next=head) | |
slow, fast = dummy, dummy | |
stack = [] | |
result = -inf | |
while fast and fast.next: | |
fast = fast.next.next | |
slow = slow.next | |
stack.append(slow.val) | |
print(slow.val) | |
while slow.next: | |
slow = slow.next | |
result = max(result, stack.pop(-1)+slow.val) | |
return result |
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。
图示两个链表在节点 c1 开始相交 **：**
![\"300\"](\"https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_statement.png\")
题目数据 保证 整个链式结构中不存在环。
\n注意，函数返回结果后，链表必须 保持其原始结构 。
\n![](\"/2025/08/15/2025-08-15-Leetcode/160-02.png\")
# Definition for singly-linked list. | |
# class ListNode: | |
# def __init__(self, x): | |
# self.val = x | |
# self.next = None | |
class Solution: | |
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]: | |
A, B = headA, headB | |
while A != B : | |
A = A.next if A else headB | |
B = B.next if B else headA | |
return B |
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例 1：
\n![](\"/2025/08/15/2025-08-15-Leetcode/206-01.png\")
输入：head = [1,2,3,4,5]\n输出：[5,4,3,2,1]\n示例 2：
\n![](\"/2025/08/15/2025-08-15-Leetcode/206-02.png\")
输入：head = [1,2]\n输出：[2,1]\n# Definition for singly-linked list. | |
# class ListNode: | |
# def __init__(self, val=0, next=None): | |
# self.val = val | |
# self.next = next | |
class Solution: | |
def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]: | |
cur_p, pre_p = head, None | |
while cur_p: | |
next_p = cur_p.next | |
cur_p.next = pre_p | |
pre_p = cur_p | |
cur_p = next_p | |
return pre_p |
给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。
构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。
例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random --> y 。
返回复制链表的头节点。
\n用一个由 n 个节点组成的链表来表示输入 / 输出中的链表。每个节点用一个 [val, random_index] 表示：
val ：一个表示 Node.val 的整数。random_index ：随机指针指向的节点索引（范围从 0 到 n-1 ）；如果不指向任何节点，则为 null 。你的代码 只 接受原链表的头节点 head 作为传入参数。
示例 1：
\n![](\"/2025/08/15/2025-08-15-Leetcode/138-01.png\")
输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]\n输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]\n给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。
示例 1：
\n![\"300\"](\"D:%5CHexo-Blog%5Cmy-hexo-blog%5Csource_posts%5C2025-08-15-Leetcode%5C148-01.png\")
输入：head = [4,2,1,3]\n输出：[1,2,3,4]\n示例 2：
\n![\"300\"](\"D:%5CHexo-Blog%5Cmy-hexo-blog%5Csource_posts%5C2025-08-15-Leetcode%5C148-02.png\")
输入：head = [-1,5,3,4,0]\n输出：[-1,0,3,4,5]\n示例 3：
\n输入：head = []\n输出：[]\n归并排序（递归法）
\n题目要求时间空间复杂度分别为 O (nlogn) 和 O (1)，根据时间复杂度我们自然想到二分法，从而联想到归并排序；
\n对数组做归并排序的空间复杂度为 O (n)，分别由新开辟数组 O (n) 和递归函数调用 O (logn) 组成，而根据链表特性：
\n通过递归实现链表归并排序，有以下两个环节：
\n# Definition for singly-linked list. | |
# class ListNode: | |
# def __init__(self, val=0, next=None): | |
# self.val = val | |
# self.next = next | |
class Solution: | |
def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]: | |
if not head or not head.next: return head | |
dummy = ListNode(next=head) | |
slow, fast = dummy, dummy | |
while fast and fast.next: | |
fast = fast.next.next | |
slow = slow.next | |
mid = slow.next | |
slow.next = None | |
left, right = self.sortList(head), self.sortList(mid) | |
h = ListNode() | |
point = h | |
while left and right: | |
if left.val < right.val: | |
point.next = left | |
left = left.next | |
else: | |
point.next = right | |
right = right.next | |
point = point.next | |
if left: point.next = left | |
if right: point.next = right | |
return h.next |
作者：Krahets
\n 链接：https://leetcode.cn/problems/sort-list/solutions/13728/sort-list-gui-bing-pai-xu-lian-biao-by-jyd/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
给你一个链表数组，每个链表都已经按升序排列。
\n请你将所有链表合并到一个升序链表中，返回合并后的链表。
\n示例 1：
\n输入：lists = [[1,4,5],[1,3,4],[2,6]]\n输出：[1,1,2,3,4,4,5,6]\n解释：链表数组如下：\n[\n 1->4->5,\n 1->3->4,\n 2->6\n]\n将它们合并到一个有序链表中得到。\n1->1->2->3->4->4->5->6\n示例 2：
\n输入：lists = []\n输出：[]\n示例 3：
\n输入：lists = [[]]\n输出：[]\n分治
\n暴力做法是，按照 21. 合并两个有序链表 的 题解思路，先合并前两个链表，再把得到的新链表和第三个链表合并，再和第四个链表合并，依此类推。
但是这种做法，平均每个节点会参与到 O (m) 次合并中（用 (1+2+⋯+m)/m 粗略估计），所以总的时间复杂度为 O (L⋅m)。
\n一个巧妙的思路是，把 lists 一分为二（尽量均分），先合并前一半的链表，再合并后一半的链表，然后把这两个链表合并成最终的链表。如何合并前一半的链表呢？我们可以继续一分为二。如此分下去直到只有一个链表，此时无需合并。
\n我们可以写一个递归来完成上述逻辑，如果你对递归头晕，请看【基础算法精讲 09】。
\n按照一分为二再合并的逻辑，递归像是在后序遍历一棵平衡二叉树。由于平衡树的高度是 O (logm)，所以每个链表节点只会出现在 O (logm) 次合并中！这样就做到了更快的 O (Llogm) 时间。
\nclass Solution: | |
def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]: | |
def merge(list1, list2): | |
dummy = ListNode() | |
point = dummy | |
while list1 and list2: | |
if list1.val < list2.val: | |
point.next = list1 | |
list1 = list1.next | |
else: | |
point.next = list2 | |
list2 = list2.next | |
point = point.next | |
point.next = list1 if list1 else list2 | |
return dummy.next | |
m = len(lists) | |
if m == 0:return None | |
if m == 1: return lists[0] | |
left = self.mergeKLists(lists[:m//2]) | |
right = self.mergeKLists(lists[m//2:]) | |
return merge(left, right) |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/merge-k-sorted-lists/solutions/2384305/liang-chong-fang-fa-zui-xiao-dui-fen-zhi-zbzx/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
示例 1：
\n![](\"/2025/08/15/2025-08-15-Leetcode/226-01.png\")
输入：root = [4,2,7,1,3,6,9]\n输出：[4,7,2,9,6,3,1]\n示例 2：
\n![](\"/2025/08/15/2025-08-15-Leetcode/226-02.png\")
输入：root = [2,1,3]\n输出：[2,3,1]\nclass Solution: | |
def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]: | |
if not root: | |
return root | |
left = self.invertTree(root.left) | |
right = self.invertTree(root.right) | |
root.left = right | |
root.right = left | |
return root |
给你一个二叉树的根节点 root ， 检查它是否轴对称。
示例 1：
\n![](\"/2025/08/15/2025-08-15-Leetcode/101-01.png\")
输入：root = [1,2,2,3,4,4,3]\n输出：true\n判断核心是从上到下，重点是判断出不符合对称的情况，如果符合就持续深层判断直到根节点。
\nclass Solution: | |
def isSymmetric(self, root: Optional[TreeNode]) -> bool: | |
if not root: return True | |
def dfs(left, right): | |
if not left and not right: | |
return True | |
elif not (left and right): | |
return False | |
else: | |
if left.val != right.val: | |
return False | |
return dfs(left.left, right.right) and dfs(left.right, right.left) | |
return dfs(root.left, root.right) |
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。
有效 二叉搜索树定义如下：
\n方法一：前序遍历
\ndfs 额外传入两个参数，分别表示从根到当前节点路径上的最小值和最大值。当前节点的值必须在最小值和最大值之间（不能等于）。
\nclass Solution: | |
def isValidBST(self, root: Optional[TreeNode], left = -inf, right = inf) -> bool: | |
if not root:return True | |
x = root.val | |
if x >= right or x <= left: return False | |
return self.isValidBST(root.left, left, x) and self.isValidBST(root.right, x, right) |
方法二：中序遍历
\n本题是二叉搜索树，中序遍历是自然的做法。
中序遍历时，可以把二叉搜索树看成一个有序数组。
\n怎么判断一个数组是有序数组？比较相邻元素的大小即可。
\nclass Solution: | |
pre = -inf | |
def isValidBST(self, root: Optional[TreeNode]) -> bool: | |
if root is None: | |
return True | |
if not self.isValidBST(root.left): # 左 | |
return False | |
if root.val <= self.pre: # 中 | |
return False | |
self.pre = root.val | |
return self.isValidBST(root.right) # 右 |
方法三：后序遍历
\ndfs 返回子树的最小值和最大值，供上面的节点判断是否为二叉搜索树。
\nclass Solution: | |
def isValidBST(self, root: Optional[TreeNode]) -> bool: | |
def dfs(node: Optional[TreeNode]) -> Tuple: | |
if node is None: | |
return inf, -inf | |
l_min, l_max = dfs(node.left) | |
r_min, r_max = dfs(node.right) | |
x = node.val | |
# 也可以在递归完左子树之后立刻判断，如果发现不是二叉搜索树，就不用递归右子树了 | |
if x <= l_max or x >= r_min: | |
return -inf, inf | |
return min(l_min, x), max(r_max, x) | |
return dfs(root)[1] != inf |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/validate-binary-search-tree/solutions/2020306/qian-xu-zhong-xu-hou-xu-san-chong-fang-f-yxvh/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
给你二叉树的根结点 root ，请你将它展开为一个单链表：
TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null 。示例 1：
\n![](\"/2025/08/15/2025-08-15-Leetcode/114-01.png\")
输入：root = [1,2,5,3,4,null,6]\n输出：[1,null,2,null,3,null,4,null,5,null,6]\nclass Solution: | |
head = None | |
def flatten(self, root: Optional[TreeNode]) -> None: | |
\"\"\" | |
Do not return anything, modify root in-place instead. | |
\"\"\" | |
if not root:return root | |
self.flatten(root.right) | |
self.flatten(root.left) | |
root.left = None | |
root.right = self.head | |
self.head = root |
给定一个二叉树的根节点 root ，和一个整数 targetSum ，求该二叉树里节点值之和等于 targetSum 的 路径 的数目。
路径 不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。
\n示例 1：
\n![](\"/2025/08/15/2025-08-15-Leetcode/437-01.png\")
输入：root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8\n输出：3\n解释：和等于 8 的路径有 3 条，如图所示。\n如果二叉树是一条链，本题就和 560. 和为 K 的子数组 完全一样了：统计有多少个非空连续子数组的元素和恰好等于 targetSum。所以你必须先弄明白 560 题（特殊情况），再来做本题（一般情况）。560 题的做法见 我的题解。
\n这两题的联系如下：
\n| 560 题 | \n本题 | \n
|---|---|
| 连续子数组 | \n方向向下的路径 | \n
| 前缀 | \n从根节点开始的路径 | \n
| 做法：枚举子数组右端点，统计有多少个左端点 | \n做法：枚举路径的终点，统计有多少个起点 <br/> 我们要解决的问题是：DFS 遍历这棵树，遍历到节点 node 时，假设 node 是路径的终点，那么有多少个起点，满足起点到终点 node 的路径总和恰好等于 targetSum？ | \n
和 560 题一样的套路：一边遍历二叉树，一边用哈希表 cnt 统计前缀和（从根节点开始的路径和）的出现次数。设从根到终点 node 的路径和为 s，那么起点的个数就是 cnt [s−targetSum]，加入答案。对比 560 题，我们在枚举子数组的右端点（终点），统计有多少个左端点（起点），做法完全一致。
\n# Definition for a binary tree node. | |
# class TreeNode: | |
# def __init__(self, val=0, left=None, right=None): | |
# self.val = val | |
# self.left = left | |
# self.right = right | |
class Solution: | |
def pathSum(self, root: Optional[TreeNode], targetSum: int) -> int: | |
ans = 0 | |
hp = collections.defaultdict(int) | |
hp[0] = 1 | |
def dfs(node, s): | |
if not node: return | |
nonlocal ans | |
s += node.val | |
ans += hp[s - targetSum] | |
hp[s] += 1 | |
dfs(node.left, s) | |
dfs(node.right, s) | |
hp[s] -= 1 | |
dfs(root, 0) | |
return ans |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/path-sum-iii/solutions/2784856/zuo-fa-he-560-ti-shi-yi-yang-de-pythonja-fmzo/
二叉树中的 路径 被定义为一条节点序列，序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不一定经过根节点。
\n路径和 是路径中各节点值的总和。
\n给你一个二叉树的根节点 root ，返回其 最大路径和 。
示例 1：
\n![](\"/2025/08/15/2025-08-15-Leetcode/124-02.png\")
输入：root = [1,2,3]\n输出：6\n解释：最优路径是 2 -> 1 -> 3 ，路径和为 2 + 1 + 3 = 6\n示例 2：
\n![](\"/2025/08/15/2025-08-15-Leetcode/124-01.png\")
输入：root = [-10,9,20,null,null,15,7]\n输出：42\n解释：最优路径是 15 -> 20 -> 7 ，路径和为 15 + 20 + 7 = 42\nclass Solution: | |
def maxPathSum(self, root: Optional[TreeNode]) -> int: | |
max_result = -inf | |
def max_(a,b,c): | |
d = max(a,b) | |
return max(d,c) | |
def dfs(root): | |
if not root: return 0 | |
left, right = dfs(root.left), dfs(root.right) | |
node_max = root.val | |
if left > 0: node_max += left | |
if right > 0: node_max += right | |
nonlocal max_result | |
max_result = max(max_result, node_max) | |
return root.val + max_(left, right, 0) | |
dfs(root) | |
return max_result |
给你一棵二叉树的根节点，返回该树的 直径 。
\n二叉树的 直径 是指树中任意两个节点之间最长路径的 长度 。这条路径可能经过也可能不经过根节点 root 。
两节点之间路径的 长度 由它们之间边数表示。
\n示例 1：
\n![](\"/2025/08/15/2025-08-15-Leetcode/124-03.png\")
输入：root = [1,2,3,4,5]\n输出：3\n解释：3 ，取路径 [4,2,1,3] 或 [5,2,1,3] 的长度。\nclass Solution: | |
def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int: | |
max_result = 0 | |
def dfs(root): | |
if not root: | |
return 0 | |
left, right = dfs(root.left), dfs(root.right) | |
result = left + right + 1 | |
nonlocal max_result | |
max_result = max(max_result, result) | |
return max(left, right) + 1 | |
dfs(root) | |
return max_result - 1 |
给你一棵以 root 为根的二叉树，二叉树中的交错路径定义如下：
交错路径的长度定义为：访问过的节点数目 - 1（单个节点的路径长度为 0 ）。
\n请你返回给定树中最长 交错路径 的长度。
\n示例 1：
\n![](\"/2025/08/15/2025-08-15-Leetcode/1372-01.png\")
输入：root = [1,null,1,1,1,null,null,1,1,null,1,null,null,null,1,null,1]\n输出：3\n解释：蓝色节点为树中最长交错路径（右 -> 左 -> 右）。\n示例 2：
\n![](\"/2025/08/15/2025-08-15-Leetcode/1372-02.png\")
输入：root = [1,1,1,null,1,null,null,1,1,null,1]\n输出：4\n解释：蓝色节点为树中最长交错路径（左 -> 右 -> 左 -> 右）。\n在 DFS 的过程中，每次我们都把当前点的 len 参数和答案 maxAns 打擂台，这样可以比出一个最大的。然后我们根据 dir 分类讨论。如果当前点应该向左且可以向左，那么就让他向左走一步，新的 len 是当前的 len 加一。如果的的点应该向左但是却没有左子树呢？很无奈那就只能向右了，这个时候 len 的值应该「重置」。
\n思考：「重置」为什么是把 len 变成 1 而不是 0？ 因为当前的点下传到它的子节点的时候已经走了一条长度为 1 的边。那么为什么 main 函数中传入的 len 值是 0 而不是 1 呢？ 因为 main 函数中的 root 是没有父亲节点的，所以当前已经走过的路为 0。
\n# Definition for a binary tree node. | |
# class TreeNode: | |
# def __init__(self, val=0, left=None, right=None): | |
# self.val = val | |
# self.left = left | |
# self.right = right | |
class Solution: | |
def longestZigZag(self, root: Optional[TreeNode]) -> int: | |
result = 0 | |
def search(node, mode, l): | |
if not node:return | |
nonlocal result | |
result = max(result, l) | |
if mode == 'left': | |
search(node.right, 'right',l+1) | |
search(node.left, 'left', 1) | |
elif mode == 'right': | |
search(node.left, 'left', l+1) | |
search(node.right, 'right', 1) | |
search(root,'left', 0) | |
search(root, 'right', 0) | |
return result |
作者：力扣官方题解
\n链接：https://leetcode.cn/problems/longest-zigzag-path-in-a-binary-tree/solutions/147425/er-cha-shu-zhong-de-zui-chang-jiao-cuo-lu-jing-b-2/
给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。
示例 1:
\n![](\"/2025/08/15/2025-08-15-Leetcode/105-01.png\")
输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]\n输出: [3,9,20,null,null,15,7]\n给定一个二叉树，找到该树中两个指定节点的最近公共祖先。
\n百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
\n示例 1：
\n![](\"/2025/08/15/2025-08-15-Leetcode/236-01.png\")
输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1\n输出：3\n解释：节点 5 和节点 1 的最近公共祖先是节点 3 。\n示例 2：
\n![](\"/2025/08/15/2025-08-15-Leetcode/236-02.png\")
输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4\n输出：5\n解释：节点 5 和节点 4 的最近公共祖先是节点 5 。因为根据定义最近公共祖先节点可以为节点本身。\n二叉树的最近公共祖先【基础算法精讲 12】_哔哩哔哩_bilibili
\n![](\"/2025/08/15/2025-08-15-Leetcode/236-03.png\")
# Definition for a binary tree node. | |
# class TreeNode: | |
# def __init__(self, x): | |
# self.val = x | |
# self.left = None | |
# self.right = None | |
class Solution: | |
def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode': | |
if root == None or root == p or root == q: | |
return root | |
left = self.lowestCommonAncestor(root.left, p, q) | |
right = self.lowestCommonAncestor(root.right, p, q) | |
if right and left: return root | |
return left or right |
基于灵神的题解，我加了一些自己的解释说明。
\n见 我的补充题解。
\n不好理解，是因为灵神代码复用了 lowestCommonAncestor 方法做递归。
\n但是从字面代码看，语义更接近于 find_p_or_q 才对。
\n改个名字，稍加注释后，似乎一切都说得通了。
在题目限制条件下（有解且唯一，且节点 unique），find_p_or_q 等价于 find_LCA，是关键所在。
\n改名 & 加注释后代码：
\nclass Solution: | |
def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode': | |
def find_p_or_q(_r, _p, _q) -> tuple[bool, bool]: | |
# (1) 因为有解且唯一，所以递归过程类似于寻找 p 或 q。 | |
if not _r: | |
return False | |
elif _r.val == _p.val or _r.val == _q.val: | |
# (2) 自顶向下查找，找到一个匹配的立即返回即可（因为题目一定有解） | |
return _r | |
else: | |
_lret = find_p_or_q(_r.left, _p, _q) | |
_rret = find_p_or_q(_r.right, _p, _q) | |
if _lret and _rret: | |
# (3) 都有的情况，应该是一左一右，所以父节点是 lca | |
return _r | |
else: | |
return _lret or _rret | |
return find_p_or_q(root, p, q) |
给定一个二叉树的 根节点 root ，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
示例 1：
\n输入： root = [1,2,3,null,5,null,4]
\n输出：[1,3,4]
\n解释：
\n![](\"/2025/08/15/2025-08-15-Leetcode/199-01.png\")
示例 2：
\n输入： root = [1,2,3,4,null,null,null,5]
\n输出：[1,3,4,5]
\n解释：
\n![](\"/2025/08/15/2025-08-15-Leetcode/199-02.png\")
示例 3：
\n输入： root = [1,null,3]
\n输出：[1,3]
\n视频讲解：【基础算法精讲 10】
\n思路：先递归右子树，再递归左子树，当某个深度首次到达时，对应的节点就在右视图中。
\n# Definition for a binary tree node. | |
# class TreeNode: | |
# def __init__(self, val=0, left=None, right=None): | |
# self.val = val | |
# self.left = left | |
# self.right = right | |
class Solution: | |
def rightSideView(self, root: Optional[TreeNode]) -> List[int]: | |
result = [] | |
def dfs(root, depth): | |
if not root: return | |
if depth == len(result): | |
result.append(root.val) | |
dfs(root.right, depth + 1) | |
dfs(root.left, depth + 1) | |
dfs(root, 0) | |
return result |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/binary-tree-right-side-view/solutions/2015061/ru-he-ling-huo-yun-yong-di-gui-lai-kan-s-r1nc/
思路：将每层的元素加入队列，从右到左依序遍历每层。
\n# Definition for a binary tree node. | |
# class TreeNode: | |
# def __init__(self, val=0, left=None, right=None): | |
# self.val = val | |
# self.left = left | |
# self.right = right | |
class Solution: | |
def rightSideView(self, root: Optional[TreeNode]) -> List[int]: | |
if not root: return [] | |
result = [] | |
que = [root] | |
while len(que) > 0: | |
result.append(que[0].val) | |
for _ in range(len(que)): | |
node = que.pop(0) | |
if node.right: que.append(node.right) | |
if node.left: que.append(node.left) | |
return result |
给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。
\n一般来说，删除节点可分为两个步骤：
\n示例 1:
\n![](\"/2025/08/15/2025-08-15-Leetcode/450-01.png\")
输入：root = [5,3,6,2,4,null,7], key = 3\n输出：[5,4,6,2,null,null,7]\n解释：给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。\n一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。\n另一个正确答案是 [5,2,6,null,4,null,7]。\n示例 2:
\n![](\"/2025/08/15/2025-08-15-Leetcode/450-02.png\")
输入: root = [5,3,6,2,4,null,7], key = 0\n输出: [5,3,6,2,4,null,7]\n解释: 二叉树不包含值为 0 的节点\n[视频解析](【LeetCode75】第四十二题 删除二叉搜索树中的节点_哔哩哔哩_bilibili)
\n二叉搜索树的题目往往可以用递归来解决。此题要求删除二叉树的节点，函数 deleteNode 的输入是二叉树的根节点 root 和一个整数 key，输出是删除值为 key 的节点后的二叉树，并保持二叉树的有序性。可以按照以下情况分类讨论：
\n# Definition for a binary tree node. | |
# class TreeNode: | |
# def __init__(self, val=0, left=None, right=None): | |
# self.val = val | |
# self.left = left | |
# self.right = right | |
class Solution: | |
def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]: | |
if not root: return | |
if root.val == key: | |
if not root.left and not root.right: return | |
elif not root.left: return root.right | |
elif not root.right: return root.left | |
else: | |
node = root.left | |
while node.right: node = node.right | |
node.right = root.right | |
root = root.left | |
elif root.val > key: root.left = self.deleteNode(root.left, key) | |
elif root.val < key: root.right = self.deleteNode(root.right, key) | |
return root |
作者：力扣官方题解
\n链接：https://leetcode.cn/problems/delete-node-in-a-bst/solutions/1529700/shan-chu-er-cha-sou-suo-shu-zhong-de-jie-n6vo/
给你一个由 '1' （陆地）和 '0' （水）组成的的二维网格，请你计算网格中岛屿的数量。
岛屿总是被水包围，并且每座岛屿只能由水平方向和 / 或竖直方向上相邻的陆地连接形成。
\n此外，你可以假设该网格的四条边均被水包围。
\n示例 1：
\n输入：grid = [\n ['1','1','1','1','0'],\n ['1','1','0','1','0'],\n ['1','1','0','0','0'],\n ['0','0','0','0','0']\n]\n输出：1\n示例 2：
\n输入：grid = [\n ['1','1','0','0','0'],\n ['1','1','0','0','0'],\n ['0','0','1','0','0'],\n ['0','0','0','1','1']\n]\n输出：3\n总体思路
\n看示例 2：
1 1 0 0 0
\n1 1 0 0 0
\n0 0 1 0 0
\n0 0 0 1 1
\n 假设你是哥伦布。先从左上角开始，把第一个岛全部插上旗子🚩，这里用 2 表示。插满旗子后，把答案（岛屿个数）加一。
⚠注意：在岛上，你只能左右上下走，不能斜方向走。
\n2 2 0 0 0
\n2 2 0 0 0
\n0 0 1 0 0
\n0 0 0 1 1
\n 继续遍历，寻找其他的岛屿，也就是 1。找到 1 意味着发现了一个新的岛，继续插上旗子🚩，把答案加一。
2 2 0 0 0
\n2 2 0 0 0
\n0 0 2 0 0
\n0 0 0 1 1
\n 继续遍历，寻找其他的岛屿。找到 1 意味着发现了一个新的岛，插满旗子🚩，把答案加一。
2 2 0 0 0
\n2 2 0 0 0
\n0 0 2 0 0
\n0 0 0 2 2
\n 如果没有 1 了，算法就结束了，返回答案（岛屿个数）。
如何实现？
\n一旦我们发现 (i,j) 是 1，就从 (i,j) 开始，DFS 这个岛。每一步可以往左右上下四个方向走，也就是 (i,j−1),(i,j+1),(i−1,j),(i+1,j) 这四个格子。
如果到达一块未发现的陆地格子，就插上旗子🚩，把 grid [i][j] 改成 2。
\n如果 (i,j) 出界，或者 (i,j) 是水，或者 (i,j) 已发现（已插上旗子🚩），就不再继续往下递归。
\n⚠注意：DFS 的过程中，最重要的是不能重复访问之前访问过的格子。
\n比如从左上角 (0,0) 向右移动到 (0,1)，然后从 (0,1) 又向左移动到 (0,0)，再从 (0,0) 向右移动到 (0,1)，如此往复，就无限递归下去了。
\n怎么避免重复访问？本题的做法是把访问过的格子都插上旗子🚩。例如从 (0,1) 往左走，发现 (0,0) 是插过旗子的格子，就不继续走了。
\nclass Solution: | |
def numIslands(self, grid: List[List[str]]) -> int: | |
m, n = len(grid), len(grid[0]) | |
visit = [[0] * m for _ in range(n)] | |
def dfs(x, y): | |
if x < 0 or x >= m or y < 0 or y >= n or grid[x][y] != '1': | |
return | |
grid[x][y] = '2' | |
dfs(x-1, y) | |
dfs(x+1, y) | |
dfs(x, y-1) | |
dfs(x, y+1) | |
result = 0 | |
for i in range(m): | |
for j in range(n): | |
if grid[i][j] == '1': | |
result += 1 | |
dfs(i, j) | |
return result |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/number-of-islands/solutions/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
在给定的 m x n 网格 grid 中，每个单元格可以有以下三个值之一：
0 代表空单元格；1 代表新鲜橘子；2 代表腐烂的橘子。每分钟，腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。
\n返回 直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1 。
示例 1：
\n![](\"/2025/08/15/2025-08-15-Leetcode/994-01.png\" "\\"img\\"")
输入：grid = [[2,1,1],[1,1,0],[0,1,1]]\n输出：4\n示例 2：
\n输入：grid = [[2,1,1],[0,1,1],[1,0,1]]\n输出：-1\n解释：左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个方向上。\n示例 3：
\n输入：grid = [[0,2]]\n输出：0\n解释：因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0 。\n看示例 1：
\n为了判断是否有永远不会腐烂的橘子（如示例 2），我们可以统计初始新鲜橘子的个数 fresh。在 BFS 中，每有一个新鲜橘子被腐烂，就把 fresh 减一，这样最后如果发现 fresh>0，就意味着有橘子永远不会腐烂，返回 −1。
\n代码实现时，在 BFS 中要将 grid [i][j]=1 的橘子修改成 2（或者其它不等于 1 的数），这可以保证每个橘子加入 q 中至多一次。如果不修改，我们就无法知道哪些橘子被腐烂过了，比如示例 1 中 (0,1) 去腐烂 (1,1)，而 (1,1) 在此之后又重新腐烂 (0,1)，如此反复，程序就会陷入死循环。读者可以注释掉下面代码中的 grid [i][j] = 2 这行代码试试。
\nclass Solution: | |
def orangesRotting(self, grid: List[List[int]]) -> int: | |
m , n = len(grid), len(grid[0]) | |
good = 0 | |
q = [] | |
for i in range(m): | |
for j in range(n): | |
if grid[i][j] == 1: good += 1 | |
elif grid[i][j] == 2 : q.append((i, j)) | |
result = 0 | |
while q and good: | |
result += 1 | |
temp = q | |
q = [] | |
for i, j in temp: | |
near = [(i-1, j), (i+1, j), (i, j-1), (i, j+1)] | |
for x, y in near: | |
if 0 <= x < m and 0 <= y < n and grid[x][y] == 1: | |
good -= 1 | |
grid[x][y] = 2 | |
q.append((x, y)) | |
return -1 if good else result |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/rotting-oranges/solutions/2773461/duo-yuan-bfsfu-ti-dan-pythonjavacgojsrus-yfmh/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。
在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。
[0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。
示例 1：
\n输入：numCourses = 2, prerequisites = [[1,0]]\n输出：true\n解释：总共有 2 门课程。学习课程 1 之前，你需要完成课程 0 。这是可能的。\n示例 2：
\n输入：numCourses = 2, prerequisites = [[1,0],[0,1]]\n输出：false\n解释：总共有 2 门课程。学习课程 1 之前，你需要先完成课程 0 ；并且学习课程 0 之前，你还应先完成课程 1 。这是不可能的。\n对于每个节点 x，都定义三种颜色值（状态值）：
\n0：节点 x 尚未被访问到。
\n1：节点 x 正在访问中，dfs (x) 尚未结束。
\n2：节点 x 已经完全访问完毕。注意这还说明从 x 出发无法找到环。所以当我们遇到状态值为 2 的节点 x 时，无需递归 x。
⚠误区：不能只用两种状态表示节点「没有访问过」和「访问过」。例如上图，我们先 dfs (0)，再 dfs (1)，此时 1 的邻居 0 已经访问过，但这并不能表示此时就找到了环。
\n算法流程：
\nclass Solution: | |
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool: | |
g = [[] for _ in range(numCourses)] | |
for a,b in prerequisites: | |
g[b].append(a) | |
colors = [0] * numCourses | |
def dfs(x): | |
colors[x] = 1 | |
for y in g[x]: | |
if colors[y] == 1 or colors[y] == 0 and dfs(y): | |
return True | |
colors[x] = 2 | |
return False | |
for i, c in enumerate(colors): | |
if c == 0 and dfs(i): | |
return False | |
return True |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/course-schedule/solutions/2992884/san-se-biao-ji-fa-pythonjavacgojsrust-by-pll7/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
left, right = -1, n-1 | |
while left + 1 < right: | |
mid = (left + right) // 2 | |
if nums[mid] > target: | |
right = mid | |
else: | |
left = mid | |
return right |
峰值元素是指其值严格大于左右相邻值的元素。
\n给你一个整数数组 nums ，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。
你可以假设 nums[-1] = nums[n] = -∞ 。
你必须实现时间复杂度为 O(log n) 的算法来解决此问题。
示例 1：
\n输入：nums = [1,2,3,1]\n输出：2\n解释：3 是峰值元素，你的函数应该返回其索引 2。\n示例 2：
\n输入：nums = [1,2,1,3,5,6,4]\n输出：1 或 5 \n解释：你的函数可以返回索引 1，其峰值元素为 2；\n 或者返回索引 5， 其峰值元素为 6。\n定理：如果 i<n−1 且 nums [i]<nums [i+1]，那么在下标 [i+1,n−1] 中一定存在峰值。
\n证明：反证法，假设下标 [i+1,n−1] 中没有峰值。
\n由于 i+1 不是峰值且 nums [i]<nums [i+1]，所以一定有 nums [i+1]<nums [i+2] 成立，否则 i+1 就是峰值了。注意题目保证相邻元素不同，不存在相邻元素相等的情况。
\n由于 i+2 不是峰值且 nums [i+1]<nums [i+2]，所以一定有 nums [i+2]<nums [i+3] 成立，否则 i+2 就是峰值了。
\n依此类推，得
\n nums [i]<nums [i+1]<nums [i+2]<⋯<nums [n−1]>nums [n]=−∞
\n这意味着 nums [n−1] 是峰值，矛盾，所以原命题成立。
\n同理可得，如果 i<n−1 且 nums [i]>nums [i+1]，那么在 [0,i] 中一定存在峰值。
所以，通过比较 nums [i] 和 nums [i+1] 的大小关系，不断地缩小存在峰值的范围，二分找到峰值。
\nclass Solution: | |
def findPeakElement(self, nums: List[int]) -> int: | |
left, right = -1, len(nums)-1 | |
while left + 1 < right: | |
mid = (left + right) // 2 | |
if nums[mid] < nums[mid+1]: | |
left = mid | |
else: | |
right = mid | |
return right |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/find-peak-element/solutions/1987497/by-endlesscheng-9ass/
整数数组 nums 按升序排列，数组中的值 互不相同 。
在传递给函数之前， nums 在预先未知的某个下标 k （ 0 <= k < nums.length ）上进行了 向左旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]] （下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 下标 3 上向左旋转后可能变为 [4,5,6,7,0,1,2] 。
给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。
你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。
示例 1：
\n输入：nums = [4,5,6,7,0,1,2], target = 0\n输出：4\n示例 2：
\n输入：nums = [4,5,6,7,0,1,2], target = 3\n输出：-1\n设 x=nums[mid] 是我们现在二分取到的数。
\n我们需要判断 x 和 target 的位置关系，谁在左边，谁在右边？
\n分类讨论：
\n下面代码用的开区间二分，用其他二分写法也是可以的。
\n二分的范围可以是 (−1,n−1)，也就是闭区间 [0,n−2]。
\n这是因为，如果 target=nums [n−1]，那么下面代码每次循环更新的都是 left，而 right 始终不变。循环结束后，答案自然就是 n−1 了。
\nclass Solution: | |
def search(self, nums: List[int], target: int) -> int: | |
n = len(nums) | |
left, right = -1, n-1 | |
while left+1 < right: | |
mid = (left + right) // 2 | |
if target <= nums[-1] and nums[mid] > nums[-1]: | |
left = mid | |
elif target > nums[-1] and nums[mid] <= nums[-1]: | |
right = mid | |
elif nums[mid] >= target: | |
right = mid | |
else: | |
left = mid | |
return right if nums[right] == target else -1 |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/search-in-rotated-sorted-array/solutions/1987503/by-endlesscheng-auuh/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
已知存在一个按非降序排列的整数数组 nums ，数组中的值不必互不相同。
在传递给函数之前， nums 在预先未知的某个下标 k （ 0 <= k < nums.length ）上进行了 旋转 ，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]] （下标 从 0 开始 计数）。例如， [0,1,2,4,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4] 。
给你 旋转后 的数组 nums 和一个整数 target ，请你编写一个函数来判断给定的目标值是否存在于数组中。如果 nums 中存在这个目标值 target ，则返回 true ，否则返回 false 。
你必须尽可能减少整个操作步骤。
\n示例 1：
\n输入：nums = [2,5,6,0,0,1,2], target = 0\n输出：true\n示例 2：
\n输入：nums = [2,5,6,0,0,1,2], target = 3\n输出：false\n本题与 33 题的区别是有相同元素，这会导致在二分查找时，可能会遇到恰好二分元素 nums [mid] 与数组末尾元素 nums [n−1] 相同的情况，此时无法确定答案在左半区间中还是右半区间中。
\n既然无法确定最小值所在区间，那么干脆去掉 nums 的最后一个数，继续二分。换句话说，此时问题变成了一个规模为 n−1 的子问题。
\nclass Solution: | |
def search(self, nums: List[int], target: int) -> bool: | |
n = len(nums) | |
left, right = -1, n-1 | |
while left+1 < right: | |
mid = (left + right) // 2 | |
if nums[mid] == nums[right]: right -= 1 ## ** 相较于 33 题，多了这一个判断 | |
elif target <= nums[right] and nums[mid] > nums[right]: | |
left = mid | |
elif target > nums[right] and nums[mid] <= nums[right]: | |
right = mid | |
elif nums[mid] >= target: | |
right = mid | |
else: | |
left = mid | |
return nums[right] == target |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/search-in-rotated-sorted-array-ii/solutions/3058425/ji-yu-33-ti-de-jian-ji-xie-fa-zhi-xu-zen-uayi/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：
4 次，则可以得到 [4,5,6,7,0,1,2]7 次，则可以得到 [0,1,2,4,5,6,7]注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。
给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。
示例 1：
\n输入：nums = [3,4,5,1,2]\n输出：1\n解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。\n示例 2：
\n输入：nums = [4,5,6,7,0,1,2]\n输出：0\n解释：原数组为 [0,1,2,4,5,6,7] ，旋转 4 次得到输入数组。\nclass Solution: | |
def findMin(self, nums: List[int]) -> int: | |
n = len(nums) | |
left, right = -1, n-1 | |
while left+1 < right: | |
mid = (left + right) // 2 | |
if nums[mid] > nums[-1]:left = mid | |
else: right = mid | |
return nums[right] |
已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,4,4,5,6,7] 在变化后可能得到：
4 次，则可以得到 [4,5,6,7,0,1,4]7 次，则可以得到 [0,1,4,4,5,6,7]注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。
给你一个可能存在 重复 元素值的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
你必须尽可能减少整个过程的操作步骤。
\n示例 1：
\n输入：nums = [1,3,5]\n输出：1\n示例 2：
\n输入：nums = [2,2,2,0,1]\n输出：0\nclass Solution: | |
def findMin(self, nums: List[int]) -> int: | |
n = len(nums) | |
left, right = -1, n-1 | |
while left+1 < right: | |
mid = (left + right) // 2 | |
if nums[mid] == nums[right]: right -= 1 | |
elif nums[mid] > nums[right]: left = mid | |
else: right = mid | |
return nums[right] |
给你一个按照非递减顺序排列的整数数组 nums ，和一个目标值 target 。请你找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target ，返回 [-1, -1] 。
你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。
示例 1：
\n输入：nums = [5,7,7,8,8,10], target = 8\n输出：[3,4]\n示例 2：
\n输入：nums = [5,7,7,8,8,10], target = 6\n输出：[-1,-1]\n示例 3：
\n输入：nums = [], target = 0\n输出：[-1,-1]\nclass Solution: | |
def searchRange(self, nums: List[int], target: int) -> List[int]: | |
def bi_search2(target): | |
left, right = -1, len(nums) | |
while left+1 < right: | |
mid = (left + right) // 2 | |
if nums[mid] >= target: | |
right = mid | |
else: | |
left = mid | |
return right | |
left = bi_search2(target) | |
if left == len(nums) or nums[left] != target:return [-1,-1] | |
right = bi_search2(target+1)-1 | |
return [left, right] |
给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2 。请你找出并返回这两个正序数组的 中位数 。
算法的时间复杂度应该为 O(log (m+n)) 。
示例 1：
\n输入：nums1 = [1,3], nums2 = [2]\n输出：2.00000\n解释：合并数组 = [1,2,3] ，中位数 2\n示例 2：
\n输入：nums1 = [1,2], nums2 = [3,4]\n输出：2.50000\n解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5\n![](\"/2025/08/15/2025-08-15-Leetcode/04-01.png\")
class Solution: | |
def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float: | |
if len(nums1) > len(nums2): | |
nums1, nums2 = nums2, nums1 | |
m, n = len(nums1), len(nums2) | |
nums1 = [-inf] + nums1 + [inf] | |
nums2 = [-inf] + nums2 + [inf] | |
i, j = 0, (m+n+1)//2 | |
while nums2[j] >= nums1[i+1]: | |
i += 1 | |
j -= 1 | |
if (m+n)%2 == 1: | |
return max(nums1[i], nums2[j]) | |
else: | |
return (max(nums1[i], nums2[j]) + min(nums1[i+1], nums2[j+1])) / 2 |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/median-of-two-sorted-arrays/solutions/2950686/tu-jie-xun-xu-jian-jin-cong-shuang-zhi-z-p2gd/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
冬季已经来临。 你的任务是设计一个有固定加热半径的供暖器向所有房屋供暖。
\n在加热器的加热半径范围内的每个房屋都可以获得供暖。
\n现在，给出位于一条水平线上的房屋 houses 和供暖器 heaters 的位置，请你找出并返回可以覆盖所有房屋的最小加热半径。
注意：所有供暖器 heaters 都遵循你的半径标准，加热的半径也一样。
示例 1:
\n输入: houses = [1,2,3], heaters = [2]\n输出: 1\n解释: 仅在位置 2 上有一个供暖器。如果我们将加热半径设为 1，那么所有房屋就都能得到供暖。\n示例 2:
\n输入: houses = [1,2,3,4], heaters = [1,4]\n输出: 1\n解释: 在位置 1, 4 上有两个供暖器。我们需要将加热半径设为 1，这样所有房屋就都能得到供暖。\n示例 3：
\n输入：houses = [1,5], heaters = [2]\n输出：3\n对于每个房屋，要么用前面的暖气，要么用后面的，二者取近的，得到距离。
\nclass Solution: | |
def findRadius(self, houses: List[int], heaters: List[int]) -> int: | |
result = 0 | |
houses.sort() | |
heaters.sort() | |
j = 0 | |
for i, house in enumerate(houses): | |
if house <= heaters[0]: dis = abs(house - heaters[0]) | |
elif house >= heaters[-1] : dis = abs(house - heaters[-1]) | |
else: | |
l, r = -1, len(heaters)-1 | |
while l+1 < r: | |
mid = (l+r) // 2 | |
if house < heaters[mid]: | |
r = mid | |
else: | |
l = mid | |
dis = min(abs(house-heaters[r]), abs(house-heaters[l])) | |
result = max(result, dis) | |
return result |
给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
示例 1：
\n输入：nums = [1,2,3]\n输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]\n示例 2：
\n输入：nums = [0,1]\n输出：[[0,1],[1,0]]\n对于一个长度为 n 的数组（假设元素互不重复），其排列方案数共有：
\nn×(n−1)×(n−2)…×2×1
\n 排列方案的生成：
根据数组排列的特点，考虑深度优先搜索所有排列方案。即通过元素交换，先固定第 1 位元素（ n 种情况）、再固定第 2 位元素（ n−1 种情况）、... 、最后固定第 n 位元素（ 1 种情况）。
\n![](\"/2025/08/15/2025-08-15-Leetcode/46-01.png\")
class Solution: | |
def permute(self, nums: List[int]) -> List[List[int]]: | |
result, n = [], len(nums) | |
def back(index): | |
if index == n-1: | |
result.append(nums[:]) | |
for i in range(index, n): | |
nums[i], nums[index] = nums[index], nums[i] | |
back(index+1) | |
nums[i],nums[index] = nums[index], nums[i] | |
back(0) | |
return result |
作者：Krahets
\n 链接：https://leetcode.cn/problems/permutations/solutions/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
我的解法
\nclass Solution: | |
def permute(self, nums: List[int]) -> List[List[int]]: | |
ans = [] | |
n = len(nums) | |
def back(index,visit): | |
if index == n: | |
ans.append(visit.copy()) | |
return | |
for i in range(n): | |
if nums[i] not in visit: | |
back(index+1, visit+[nums[i]]) | |
back(0, []) | |
return ans |
给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
\n示例 1：
\n输入：nums = [1,2,3]\n输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]\n示例 2：
\n输入：nums = [0]\n输出：[[],[0]]\nclass Solution: | |
def subsets(self, nums: List[int]) -> List[List[int]]: | |
result, n = [], len(nums) | |
def back(index, temp): | |
result.append(temp) | |
for i in range(index, n): | |
back(i+1, temp+[nums[i]]) | |
back(0, []) | |
return result |
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
\n![](\"/2025/08/15/2025-08-15-Leetcode/17-01.png\")
示例 1：
\n输入：digits = "23"\n输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]\nclass Solution: | |
def letterCombinations(self, digits: str) -> List[str]: | |
n = len(digits) | |
if n == 0: return [] | |
coder = {\"2\":'abc',\"3\":'def',\"4\":'ghi',\"5\":'jkl',\"6\":'mno',\"7\":'pqrs',\"8\":'tuv',\"9\":'wxyz'} | |
result = [] | |
def back(index, s): | |
if index == n: | |
result.append(s) | |
return | |
for c in coder[digits[index]]: | |
back(index+1, s+c) | |
back(0, '') | |
return result |
给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。
candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。
对于给定的输入，保证和为 target 的不同组合数少于 150 个。
示例 1：
\n输入：candidates = [2,3,6,7], target = 7\n输出：[[2,2,3],[7]]\n解释：\n2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。\n7 也是一个候选， 7 = 7 。\n仅有这两种组合。\nclass Solution: | |
def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]: | |
result, n = [], len(candidates) | |
def back(s, temp, index): | |
if s == target: | |
result.append(temp) | |
return | |
elif s > target: return | |
for i in range(index, n): | |
back(s + candidates[i], temp+[candidates[i]], i) | |
back(0,[],0) | |
return result |
数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
示例 1：
\n输入：n = 3\n输出：["((()))","(()())","(())()","()(())","()()()"]\n示例 2：
\n输入：n = 1\n输出：["()"]\nclass Solution: | |
def generateParenthesis(self, n: int) -> List[str]: | |
result = [] | |
def back(temp, left, right): | |
print(temp) | |
if left + right == n*2: | |
result.append(temp) | |
return | |
if right < left and right < n: | |
back(temp+')', left, right+1) | |
if left<n: | |
back(temp+'(', left+1, right) | |
back('', 0, 0) | |
return result |
给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。
单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中 “相邻” 单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
\n示例 1：
\n![](\"/2025/08/15/2025-08-15-Leetcode/79-01.png\")
输入：board = [['A','B','C','E'],['S','F','C','S'],['A','D','E','E']], word = "ABCCED"\n输出：true\nclass Solution: | |
def exist(self, board: List[List[str]], word: str) -> bool: | |
m, n = len(board), len(board[0]) | |
visited = [[0]*n for _ in range(m)] | |
diections = [[1,0], [0,1], [-1,0], [0,-1]] | |
flag = False | |
num_word = len(word) | |
def back(index, x, y): | |
print(x,y) | |
if board[x][y] != word[index]: return | |
if index == num_word - 1: | |
nonlocal flag | |
flag = True | |
return | |
visited[x][y] = 1 | |
for diection in diections: | |
if 0 <= x+diection[0] <m and 0<=y+diection[1]<n and visited[x+diection[0]][y+diection[1]] == 0: | |
back(index + 1, x+diection[0], y+diection[1]) | |
for i in range(m): | |
for j in range(n): | |
if board[i][j] == word[0]: | |
back(0, i, j) | |
return flag |
给你一个字符串 s ，请你将 s 分割成一些 子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。
示例 1：
\n输入：s = "aab"\n输出：[["a","a","b"],["aa","b"]]\n示例 2：
\n输入：s = "a"\n输出：[["a"]]\nclass Solution: | |
def partition(self, s: str) -> List[List[str]]: | |
result, n = [], len(s) | |
def back(index, temp): | |
if index == n: | |
result.append(temp) | |
return | |
for i in range(index, n): | |
s_temp = s[index:i+1] | |
if s_temp == s_temp[::-1]: | |
back(i+1, temp+[s_temp]) | |
back(0, []) | |
return result |
按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。
\nn 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。
每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。
示例 1：
\n![\"img\"](\"https://assets.leetcode.com/uploads/2020/11/13/queens.jpg\")
输入：n = 4\n输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]\n解释：如上图所示，4 皇后问题存在两个不同的解法。\n与 46. 全排列类似
\n问题转换为 [1,2,...,n] 的排列中符合皇后不攻击的条件。
\nclass Solution: | |
def solveNQueens(self, n: int) -> List[List[str]]: | |
ans = [] | |
def isable(row, vis): | |
if row == 0: return True | |
new_r, new_c = row, vis[-1] | |
for i in range(row): | |
if vis[i] + i == new_c + new_r or vis[i] - i == new_c - new_r: | |
return False | |
return True | |
def dfs(row, vis): | |
if row == n: | |
ans.append(['.'*i+'Q'+'.'*(n-1-i) for i in vis]) | |
return | |
for i in range(n): | |
if i not in vis and isable(row, vis+[i]): | |
dfs(row+1, vis+[i]) | |
dfs(0, []) | |
return ans |
给你一个非负整数数组 nums ，你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个下标，如果可以，返回 true ；否则，返回 false 。
示例 1：
\n输入：nums = [2,3,1,1,4]\n输出：true\n解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。\n示例 2：
\n输入：nums = [3,2,1,0,4]\n输出：false\n解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。\nclass Solution: | |
def canJump(self, nums: List[int]) -> bool: | |
now, right = 0, 0 | |
n = len(nums) | |
for i in range(n): | |
if right < i: return False | |
right = max(right, i+nums[i]) | |
return right >= n-1 |
给定一个长度为 n 的 0 索引整数数组 nums 。初始位置在下标 0。
每个元素 nums[i] 表示从索引 i 向后跳转的最大长度。换句话说，如果你在索引 i 处，你可以跳转到任意 (i + j) 处：
0 <= j <= nums[i] 且i + j < n返回到达 n - 1 的最小跳跃次数。测试用例保证可以到达 n - 1 。
示例 1:
\n输入: nums = [2,3,1,1,4]\n输出: 2\n解释: 跳到最后一个位置的最小跳跃数是 2。\n 从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。\n示例 2:
\n输入: nums = [2,3,0,1,4]\n输出: 2\n![](\"/2025/08/15/2025-08-15-Leetcode/45-01.png\")
⚠注意：不是在无路可走的那个位置造桥，而是当发现无路可走的时候，时光倒流到能跳到最远点的那个位置造桥。换句话说，在无路可走之前，我们只是在默默地收集信息，没有实际造桥。当发现无路可走的时候，才从收集到的信息中，选择最远点造桥。所建造的这座桥的左端点（起跳位置）在我们当前走的这座桥的中间，而不是桥的末尾。
\nclass Solution: | |
def jump(self, nums: List[int]) -> int: | |
result = 0 | |
cur_distance = 0 | |
next_distance = 0 | |
for i in range(len(nums)-1): | |
next_distance = max(next_distance, i + nums[i]) | |
if i == cur_distance: | |
cur_distance = next_distance | |
result += 1 | |
return result |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/jump-game-ii/solutions/2926993/tu-jie-yi-zhang-tu-miao-dong-tiao-yue-yo-h2d4/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
给你一个字符串 s 。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。例如，字符串 "ababcc" 能够被分为 ["abab", "cc"] ，但类似 ["aba", "bcc"] 或 ["ab", "ab", "cc"] 的划分是非法的。
注意，划分结果需要满足：将所有划分结果按顺序连接，得到的字符串仍然是 s 。
返回一个表示每个字符串片段的长度的列表。
\n示例 1：
\n输入：s = "ababcbacadefegdehijhklij"\n输出：[9,7,8]\n解释：\n划分结果为 "ababcbaca"、"defegde"、"hijhklij" 。\n每个字母最多出现在一个片段中。\n像 "ababcbacadefegde", "hijhklij" 这样的划分是错误的，因为划分的片段数较少。 \n示例 2：
\n输入：s = "eccbbbbdec"\n输出：[10]\n其实思路很简单，
\n1， 首先看第一个字母，找到它在串里最后的一个位置，记作 last 或一段的最后位置。
\n2， 在从 0~last 这个范围里，挨个查其他字母，看他们的最后位置是不是比刚才的 last 或一段的最后位置大。
\n如果没有刚才的 last 或一段的最后位置大，无视它继续往后找。
\n如果比刚才的大，说明这一段的分隔位置必须往后移动，所以我们把 last 或一段的最后位置更新为当前的字母的最后位置。
\n3，肯定到有一个时间，这个 last 就更新不了了，那么这个时候这个位置就是我们的分隔位置。
\n注意题目要分隔后的长度，我们就用 last - startindex + 1。
\n4，找到一个分割位，更新一下起始位置，同理搜索就行了。
class Solution: | |
def partitionLabels(self, s: str) -> List[int]: | |
dic = {} | |
for i, c in enumerate(s): | |
dic[c] = i | |
n = len(s) | |
num, result = 0, [] | |
last = dic[s[0]] | |
for i in range(n): | |
num += 1 | |
if dic[s[i]] > last: | |
last = dic[s[i]] | |
if i == last: | |
result.append(num) | |
num = 0 | |
return result |
作者：Flying_Du
\n 链接：https://leetcode.cn/problems/partition-labels/solutions/455898/python-jiu-zhe-quan-guo-zui-cai-you-hua-dai-ma-by-/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
\n给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
\n示例 1：
\n输入：[1,2,3,1]\n输出：4\n解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。\n 偷窃到的最高金额 = 1 + 3 = 4 。\n示例 2：
\n输入：[2,7,9,3,1]\n输出：12\n解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。\n 偷窃到的最高金额 = 2 + 9 + 1 = 12 。\nclass Solution: | |
def rob(self, nums: List[int]) -> int: | |
n = len(nums) | |
if n == 0:return 0 | |
if n == 1:return nums[0] | |
if n == 2:return max(nums[0], nums[1]) | |
dp = [0]*n | |
dp[0], dp[1] = nums[0], max(nums[0], nums[1]) | |
for i in range(2,n): | |
dp[i] = max(dp[i-1], dp[i-2] + nums[i]) | |
return max(dp[-1], dp[-2]) |
给你一个整数 n ，返回 和为 n 的完全平方数的最少数量 。
完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如， 1 、 4 、 9 和 16 都是完全平方数，而 3 和 11 不是。
示例 1：
\n输入：n = 12\n输出：3 \n解释：12 = 4 + 4 + 4\n示例 2：
\n输入：n = 13\n输出：2\n解释：13 = 4 + 9\n把 1,4,9,16,⋯ 这些完全平方数视作物品体积，物品价值都是 1。由于每个数（物品）选的次数没有限制，所以本题是一道标准的完全背包问题。
\n按照视频中的做法，定义 dfs (i,j) 表示从前 i 个完全平方数中选一些数（可以重复选），满足元素和恰好等于 j，最少要选的数字个数。
\n考虑第 i 个完全平方数 i^2 选或不选：
\n不选：问题变成从前 i−1 个完全平方数中选一些数（可以重复选），满足元素和恰好等于 j，最少要选的数字个数，即
\ndfs(i,j)=dfs(i−1,j)
\n选：前提是 j≥i^2。问题变成从前 i 个完全平方数中选一些数（可以重复选），满足元素和恰好等于 j−i^2 ，最少要选的数字个数，即 。注意这里是 i 而不是 i−1，因为我们可以继续选第 i 个完全平方数。
\n这两种情况取最小值，就得到了 dfs (i,j)，即
![](\"/2025/08/15/2025-08-15-Leetcode/279-01.png\")
递归边界：dfs (0,0)=0，因为没有数可以选了，且要得到的数等于 0，那么答案为 0。如果 j>0，那么 dfs (0,j)=∞，这里用 ∞ 表示不合法的状态，从而保证上式中的 min 取到合法的状态。注意本题是一定有解的，因为 1 是完全平方数。
\n| \n | 0 | \n1 | \n2 | \n3 | \n4 | \n5 | \n... | \nn | \n
|---|---|---|---|---|---|---|---|---|
| 0 | \n0 | \ninf | \ninf | \ninf | \ninf | \ninf | \n... | \ninf | \n
| 1 | \n\n | \n | \n | \n | \n | \n | \n | \n |
| 2 | \n\n | \n | \n | \n | \n | \n | \n | \n |
| 3 | \n\n | \n | \n | \n | \n | \n | \n | \n |
| ... | \n\n | \n | \n | \n | \n | \n | \n | \n |
| m | \n\n | \n | \n | \n | \n | \n | \n | \n |
class Solution: | |
def numSquares(self, n: int) -> int: | |
m = isqrt(n) | |
f = [[0]*(n+1) for _ in range(m+1)] | |
f[0] = [0] + [inf] * n | |
for i in range(1,m+1): | |
for j in range(n+1): | |
if j < i*i: | |
f[i][j] = f[i-1][j] | |
else: | |
f[i][j] = min(f[i][j-i*i]+1, f[i-1][j]) | |
return f[m][n] |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/perfect-squares/solutions/2830762/dong-tai-gui-hua-cong-ji-yi-hua-sou-suo-3kz1g/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。
计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。
你可以认为每种硬币的数量是无限的。
\n示例 1：
\n输入：coins = [1, 2, 5], amount = 11\n输出：3 \n解释：11 = 5 + 5 + 1\n示例 2：
\n输入：coins = [2], amount = 3\n输出：-1\n示例 3：
\n输入：coins = [1], amount = 0\n输出：0\nclass Solution: | |
def coinChange(self, coins: List[int], amount: int) -> int: | |
m, n = len(coins), amount | |
f = [[0]*(amount+1) for _ in range(m+1)] | |
f[0] = [0] + [inf]*amount | |
for i in range(1,m+1): | |
for j in range(n+1): | |
if j < coins[i-1]: | |
f[i][j] = f[i-1][j] | |
else: | |
f[i][j] = min(f[i-1][j], f[i][j-coins[i-1]]+1) | |
return f[-1][-1] if f[-1][-1] < inf else -1 |
给你一个字符串 s 和一个字符串列表 wordDict 作为字典。如果可以利用字典中出现的一个或多个单词拼接出 s 则返回 true 。
** 注意：** 不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。
\n示例 1：
\n输入: s = "leetcode", wordDict = ["leet", "code"]\n输出: true\n解释: 返回 true 因为 "leetcode" 可以由 "leet" 和 "code" 拼接成。\n示例 2：
\n输入: s = "applepenapple", wordDict = ["apple", "pen"]\n输出: true\n解释: 返回 true 因为 "applepenapple" 可以由 "apple" "pen" "apple" 拼接成。\n 注意，你可以重复使用字典中的单词。\n示例 3：
\n输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]\n输出: false\n枚举 j=i−1,i−2,i−3,…,max (i−maxLen,0)，只要其中一个 j 满足 s [j:i] 在 wordDict 中且 f [j]=true，那么 f [i] 就是 true。
\n初始值 f [0]=true，翻译自递归边界 dfs (0)=true。
\nclass Solution: | |
def wordBreak(self, s: str, wordDict: List[str]) -> bool: | |
n = len(s) | |
dp = [False] * (n+1) | |
dp[0] = True | |
for i in range(1, n+1): | |
for j in range(i): | |
if s[j:i] in wordDict and dp[j]: | |
dp[i] = True | |
return dp[-1] |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/word-break/solutions/2968135/jiao-ni-yi-bu-bu-si-kao-dpcong-ji-yi-hua-chrs/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。
子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如， [3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。
示例 1：
\n输入：nums = [10,9,2,5,3,7,101,18]\n输出：4\n解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。\n示例 2：
\n输入：nums = [0,1,0,3,2,3]\n输出：4\n示例 3：
\n输入：nums = [7,7,7,7,7,7,7]\n输出：1\ndfs (i) 表示以 nums [i] 结尾的最长递增子序列（LIS）的长度。
\n枚举子序列的倒数第二个数的下标是 j，如果 nums [j]<nums [i]，那么有 dfs (i)=dfs (j)+1，取最大值。
\nclass Solution: | |
def lengthOfLIS(self, nums: List[int]) -> int: | |
n = len(nums) | |
dp = [1] * n | |
for i in range(1, n): | |
max_len = 0 | |
for j in range(i): | |
if nums[i] > nums[j]: | |
max_len = max(max_len, dp[j]) | |
dp[i] = max_len + 1 | |
return max(dp) |
给你一个整数数组 nums ，请你找出数组中乘积最大的非空连续 子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。
测试用例的答案是一个 32 - 位 整数。
\n请注意，一个只包含一个元素的数组的乘积是这个元素的值。
\n示例 1:
\n输入: nums = [2,3,-2,4]\n输出: 6\n解释: 子数组 [2,3] 有最大乘积 6。\n示例 2:
\n输入: nums = [-2,0,-1]\n输出: 0\n解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。\nclass Solution: | |
def maxProduct(self, nums: List[int]) -> int: | |
n = len(nums) | |
min_val, max_val = 1, 1 | |
result = nums[0] | |
print(result) | |
for i, num in enumerate(nums): | |
new_min_val = min(min_val*num, max_val*num, num) | |
new_max_val = max(min_val*num, max_val*num, num) | |
result = max(result, new_max_val) | |
max_val = new_max_val | |
min_val = new_min_val | |
return result |
给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。
示例 1：
\n输入：nums = [1,5,11,5]\n输出：true\n解释：数组可以分割成 [1, 5, 5] 和 [11] 。\n示例 2：
\n输入：nums = [1,2,3,5]\n输出：false\n解释：数组不能分割成两个元素和相等的子集。\n![](\"/2025/08/15/2025-08-15-Leetcode/416-01.png\")
| \n | 0 | \n1 | \n2 | \n3 | \n4 | \n5 | \n... | \ntarget | \n
|---|---|---|---|---|---|---|---|---|
| 1 | \n1 | \n1 | \n0 | \n0 | \n0 | \n0 | \n0 | \n0 | \n
| 5 | \n1 | \n1 | \n0 | \n0 | \n0 | \n1 | \n\n | \n |
| 11 | \n\n | \n | \n | \n | \n | \n | \n | \n |
| 5 | \n\n | \n | \n | \n | \n | \n | \n | \n |
| \n | \n | \n | \n | \n | \n | \n | \n | \n |
| \n | \n | \n | \n | \n | \n | \n | \n | \n |
class Solution: | |
def canPartition(self, nums: List[int]) -> bool: | |
s = sum(nums) | |
n = len(nums) | |
if s % 2: return False | |
target = s // 2 | |
if max(nums) > target: return False | |
dp = [[0]*(target+1) for _ in range(n)] | |
dp[0][0], dp[0][nums[0]] = 1, 1 | |
for i in range(1, n): | |
for j in range(target+1): | |
if nums[i] > j: dp[i][j] = dp[i-1][j] | |
else: | |
dp[i][j] = 1 if dp[i-1][j] or dp[i-1][j-nums[i]] else 0 | |
return bool(dp[-1][-1]) |
给你一个只包含 '(' 和 ')' 的字符串，找出最长有效（格式正确且连续）括号 子串 的长度。
左右括号匹配，即每个左括号都有对应的右括号将其闭合的字符串是格式正确的，比如 "(()())" 。
示例 1：
\n输入：s = "(()"\n输出：2\n解释：最长有效括号子串是 "()"\n示例 2：
\n输入：s = ")()())"\n输出：4\n解释：最长有效括号子串是 "()()"\n示例 3：
\n输入：s = ""\n输出：0\nclass Solution: | |
def longestValidParentheses(self, s: str) -> int: | |
if not s: return 0 | |
n = len(s) | |
dp = [0] * n | |
for i in range(1,n): | |
c = s[i] | |
if c == '(': continue | |
if s[i-1] =='(': | |
dp[i] = 2 | |
if i-1 - 1 >= 0: dp[i] += dp[i-2] | |
else: | |
if i-1-dp[i-1] >= 0 and s[i-1-dp[i-1]] == '(': | |
dp[i] = dp[i-1] + 2 | |
if i-1-dp[i-1] - 1 >= 0: | |
dp[i] += dp[i-1-dp[i-1]-1] | |
print(dp) | |
return max(dp) |
给你一个字符串 s ，找到 s 中最长的 回文 子串。
示例 1：
\n输入：s = "babad"\n输出："bab"\n解释："aba" 同样是符合题意的答案。\n示例 2：
\n输入：s = "cbbd"\n输出："bb"\n![](\"/2025/08/15/2025-08-15-Leetcode/05-01.png\")
class Solution: | |
def longestPalindrome(self, s: str) -> str: | |
n = len(s) | |
result_left, result_right = 0, 0 | |
for i in range(2*n-1): | |
left, right = i // 2, (i+1)//2 | |
while left >= 0 and right < n and s[left] == s[right]: | |
right += 1 | |
left -= 1 | |
if right- left > result_right - result_left: | |
result_left, result_right = left, right | |
return s[result_left+1: result_right] |
给定两个字符串 text1 和 text2 ，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。
一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
\n"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。
\n示例 1：
\n输入：text1 = "abcde", text2 = "ace" \n输出：3 \n解释：最长公共子序列是 "ace" ，它的长度为 3 。\n示例 2：
\n输入：text1 = "abc", text2 = "abc"\n输出：3\n解释：最长公共子序列是 "abc" ，它的长度为 3 。\n示例 3：
\n输入：text1 = "abc", text2 = "def"\n输出：0\n解释：两个字符串没有公共子序列，返回 0 。\n![](\"/2025/08/15/2025-08-15-Leetcode/1143-01.png\")
![](\"/2025/08/15/2025-08-15-Leetcode/1143-02.png\")
![](\"/2025/08/15/2025-08-15-Leetcode/1143-03.png\")
class Solution: | |
def longestCommonSubsequence(self, text1: str, text2: str) -> int: | |
m, n = len(text2), len(text1) | |
dp = [[0]*(n+1) for _ in range(m+1)] | |
for i in range(1,m+1): | |
for j in range(1,n+1): | |
if text1[j-1] == text2[i-1]: | |
dp[i][j] = dp[i-1][j-1] + 1 | |
else: | |
dp[i][j] = max(dp[i-1][j], dp[i][j-1]) | |
return dp[-1][-1] |
给你两个单词 word1 和 word2 ， 请返回将 word1 转换成 word2 所使用的最少操作数 。
你可以对一个单词进行如下三种操作：
\n示例 1：
\n输入：word1 = "horse", word2 = "ros"\n输出：3\n解释：\nhorse -> rorse (将 'h' 替换为 'r')\nrorse -> rose (删除 'r')\nrose -> ros (删除 'e')\n示例 2：
\n输入：word1 = "intention", word2 = "execution"\n输出：5\n解释：\nintention -> inention (删除 't')\ninention -> enention (将 'i' 替换为 'e')\nenention -> exention (将 'n' 替换为 'x')\nexention -> exection (将 'n' 替换为 'c')\nexection -> execution (插入 'u')\n| \n | 0 | \nh | \no | \nu | \ns | \ne | \n
|---|---|---|---|---|---|---|
| 0 | \n0 | \n1 | \n2 | \n3 | \n4 | \n5 | \n
| r | \n1 | \n1 | \n2 | \n2 | \n3 | \n4 | \n
| o | \n2 | \n2 | \n1 | \n2 | \n3 | \n4 | \n
| s | \n3 | \n3 | \n2 | \n2 | \n2 | \n3 | \n
class Solution: | |
def minDistance(self, word1: str, word2: str) -> int: | |
m, n = len(word1), len(word2) | |
dp = [[i]*(n+1) for i in range(m+1)] | |
for i in range(1,n+1): | |
dp[0][i] = i | |
for i in range(1, m+1): | |
for j in range(1, n+1): | |
if word1[i-1] == word2[j-1]: | |
dp[i][j] = dp[i-1][j-1] | |
else: | |
dp[i][j] = min(dp[i-1][j-1], dp[i][j-1], dp[i-1][j]) + 1 | |
return dp[-1][-1] |
给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。
在每一天，你可以决定是否购买和 / 或出售股票。你在任何时候 最多 只能持有 一股 股票。然而，你可以在 同一天 多次买卖该股票，但要确保你持有的股票不超过一股。
\n返回 你能获得的 最大 利润 。
\n示例 1：
\n输入：prices = [7,1,5,3,6,4]\n输出：7\n解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。\n随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3。\n最大总利润为 4 + 3 = 7 。\n示例 2：
\n输入：prices = [1,2,3,4,5]\n输出：4\n解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。\n最大总利润为 4 。\n示例 3：
\n输入：prices = [7,6,4,3,1]\n输出：0\n解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0。\n\n\n方法 1：
\n定义两个状态：
\ndp [i][0]：第 i 天结束时，不持有股票的最大利润
\ndp [i][1]：第 i 天结束时，持有股票的最大利润
\n状态转移方程：
\ndp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
\n（昨天不持有，或昨天持有今天卖出）
\ndp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i])
\n（昨天持有，或昨天不持有今天买入）
\n\n\n
\n\n \n\n\n\n 0 \n1 \n\n \n7 \n0 \n-7 \n\n \n1 \nmax(0, -7+1) = 0 \nmax(-1, -7) = -1 \n\n \n5 \nmax(0, -1+5) = 4 \nmax(-5, -1) = -1 \n\n \n\n3 \n\n \n 122. 买卖股票的最佳时机 II - 力扣（LeetCode）
\n
class Solution: | |
def maxProfit(self, prices: List[int]) -> int: | |
n = len(prices) | |
dp = [[0]*2 for _ in range(n)] | |
dp[0][1] = -prices[0] | |
for i in range(1,n): | |
dp[i][0] = max(dp[i-1][0], dp[i-1][1]+prices[i]) | |
dp[i][1] = max(dp[i-1][0]-prices[i], dp[i-1][1]) | |
return dp[-1][0] |
\n\n方法 2：贪心
\n122. 买卖股票的最佳时机 II - 力扣（LeetCode）
\n
return result
给你一个 非空 整数数组 nums ，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使用常量额外空间。
\n示例 1 ：
\n输入：nums = [2,2,1]\n输出：1\n示例 2 ：
\n输入：nums = [4,1,2,1,2]\n输出：4\n示例 3 ：
\n输入：nums = [1]\n输出：1\nclass Solution: | |
def singleNumber(self, nums: List[int]) -> int: | |
count = Counter(nums) | |
for k in count.keys(): | |
if count[k] == 1: | |
return k | |
return 0 |
利用异或运算 a⊕a=0 的性质，我们可以用异或来「消除」所有出现了两次的元素，最后剩下的一定是只出现一次的元素。
\n例如 nums=[4,1,2,1,2]，把所有元素异或：
\n4⊕1⊕2⊕1⊕2
\n=4⊕(1⊕1)⊕(2⊕2)
\n=4⊕0⊕0
\n=4
\n其中用到了异或运算的交换律 a⊕b=b⊕a，以及结合律 (a⊕b)⊕c=a⊕(b⊕c)（类比加法）。
\n代码中，初始化 ans=0 是因为 0⊕a=a，相当于我们从第一个数开始，和其它数异或。
\nclass Solution: | |
def singleNumber(self, nums: List[int]) -> int: | |
return reduce(xor, nums) |
reduce 函数的基本用法
\n在 Python 3 中，reduce 函数已经被移到 functools 模块中，因此在使用之前需要先导入这个模块。reduce 的基本语法如下：
\nfrom functools import reduce | |
def add(x, y): | |
\treturn x + y | |
result = reduce(add, [1, 2, 3, 4, 5]) | |
print(result) # 输出: 15 |
xor 函数为异或函数（^）
\n作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/single-number/solutions/2481594/li-yong-yi-huo-de-xing-zhi-fu-ti-dan-pyt-oizc/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。
\n示例 1：
\n输入：nums = [3,2,3]\n输出：3\n示例 2：
\n输入：nums = [2,2,1,1,1,2,2]\n输出：2\n用「擂台赛」打比方：
\nclass Solution: | |
def majorityElement(self, nums: List[int]) -> int: | |
count = 1 | |
n, c = len(nums), nums[0] | |
for i in range(1,n): | |
if nums[i] == c: count += 1 | |
else: | |
count -= 1 | |
if count < 0: count, c = 1, nums[i] | |
return c |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/majority-element/solutions/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
整数数组的一个 排列 就是将其所有成员以序列或线性顺序排列。
\narr = [1,2,3] ，以下这些都可以视作 arr 的排列： [1,2,3] 、 [1,3,2] 、 [3,1,2] 、 [2,3,1] 。整数数组的 下一个排列 是指其整数的下一个字典序更大的排列。更正式地，如果数组的所有排列根据其字典顺序从小到大排列在一个容器中，那么数组的 下一个排列 就是在这个有序容器中排在它后面的那个排列。如果不存在下一个更大的排列，那么这个数组必须重排为字典序最小的排列（即，其元素按升序排列）。
\narr = [1,2,3] 的下一个排列是 [1,3,2] 。arr = [2,3,1] 的下一个排列是 [3,1,2] 。arr = [3,2,1] 的下一个排列是 [1,2,3] ，因为 [3,2,1] 不存在一个字典序更大的排列。给你一个整数数组 nums ，找出 nums 的下一个排列。
必须 ** 原地 ** 修改，只允许使用额外常数空间。
\n示例 1：
\n输入：nums = [1,2,3]\n输出：[1,3,2]\n示例 2：
\n输入：nums = [3,2,1]\n输出：[1,2,3]\n示例 3：
\n输入：nums = [1,1,5]\n输出：[1,5,1]\n排列 [1,3,5,4,2] 的下一个排列是什么？
\n总结流程：
\nclass Solution: | |
def nextPermutation(self, nums: List[int]) -> None: | |
\"\"\" | |
Do not return anything, modify nums in-place instead. | |
\"\"\" | |
n = len(nums) | |
point = n-2 | |
while point>=0 and nums[point] >= nums[point+1]: | |
point -= 1 | |
print(point) | |
if point >= 0: | |
right = n-1 | |
while right > point and nums[right] <= nums[point]: | |
right -= 1 | |
nums[point], nums[right] = nums[right], nums[point] | |
print(point,right) | |
left, right = point+1, n-1 | |
while left < right: | |
nums[left], nums[right] = nums[right], nums[left] | |
left+=1 | |
right-=1 | |
return |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/next-permutation/solutions/3621022/jiao-ni-cong-ling-kai-shi-si-kao-zhe-ti-9qfrq/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
给定一个包含红色、白色和蓝色、共 n 个元素的数组 nums ，原地 对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。
我们使用整数 0 、 1 和 2 分别表示红色、白色和蓝色。
必须在不使用库内置的 sort 函数的情况下解决这个问题。
\n示例 1：
\n输入：nums = [2,0,2,1,1,0]\n输出：[0,0,1,1,2,2]\n示例 2：
\n输入：nums = [2,0,1]\n输出：[0,1,2]\n假设现在有一个有序数组 a=[0,0,1,1,2,2]。在 a 中插入一个 0，同时保证 a 是有序的，你会怎么做？
\n最暴力的想法是，把 0 插在数组的最左边，原来的元素全体右移一位，得到 [0,0,0,1,1,2,2]。这样做是 O (n) 的。
\n对比一下插入前后：
\n竖着看，其实只有三个位置上的数变了：
\n怎么知道这些位置？
\n如果 a 中没有 2 呢？上面第三步就错了。
\n比如 a=[1]，插入一个 0，结果为 [0,1]。但如果按照上面三步走，第三步把 a [1] 改成 2，得到的是错误的 [0,2]。
\n要用很多 if-else 特判这些特殊情况吗？
\n不需要，我们可以倒过来算：先把 a [1] 改成 2，再把 a [1] 改成 1（覆盖），最后 a [0] 改成 0，得到 [0,1]。这种「覆盖」等价于「没有 2 的时候不改成 2」。
\n如果插入的是 1 呢？
\n跳过「把 a [p0] 改成 0」这一步。
\n如果插入的是 2 呢？
\n只需要把 a [i] 改成 2。
\nclass Solution: | |
def sortColors(self, nums: List[int]) -> None: | |
\"\"\" | |
Do not return anything, modify nums in-place instead. | |
\"\"\" | |
p0, p1 = 0, 0 | |
for i, num in enumerate(nums): | |
nums[i] = 2 | |
if num == 0: | |
nums[p1] = 1 | |
nums[p0] = 0 | |
p0 += 1 | |
p1 += 1 | |
elif num == 1: | |
nums[p1] = 1 | |
p1 += 1 | |
# nums[i] = 2 | |
return |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/sort-colors/solutions/3679069/on-cha-ru-pai-xu-jian-ji-xie-fa-pythonja-zk60/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
给定一个包含 n + 1 个整数的数组 nums ，其数字都在 [1, n] 范围内（包括 1 和 n ），可知至少存在一个重复的整数。
假设 nums 只有 一个重复的整数 ，返回 这个重复的数 。
你设计的解决方案必须 不修改 数组 nums 且只用常量级 O(1) 的额外空间。
示例 1：
\n输入：nums = [1,3,4,2,2]\n输出：2\n示例 2：
\n输入：nums = [3,1,3,4,2]\n输出：3\n示例 3 :
\n输入：nums = [3,3,3,3,3]\n输出：3\n想象有一个 n+1 个节点的图，节点编号从 0 到 n。
\n对 i=0,1,2,…,n，连一条从 i 到 nums [i] 的有向边，可以得到一个有向图。
\n![](\"/2025/08/15/2025-08-15-Leetcode/287-01.png\")
每个节点的入度，就是这个节点在 nums 中的出现次数。重复元素的入度大于 1。上图中的节点 2 的入度为 2，所以 2 是重复元素。
\n如何找到入度大于 1 的节点？
\n在每个节点的出度都是 1 的情况下，n+1 个点 n+1 条边的有向图，又叫内向基环森林，每个连通块都恰好有一个环。
\n由于 nums [i]≥1，所以节点 0 的入度是 0，不在环上。从节点 0 出发，进入基环，基环的入环口，就是入度大于 1 的节点。
\n⚠注意：如果从非 0 节点出发，可能无法找到答案。如下图，如果从节点 3 出发，无法找到入度大于 1 的节点。
\n![](\"/2025/08/15/2025-08-15-Leetcode/287-02.png\")
class Solution: | |
def findDuplicate(self, nums: List[int]) -> int: | |
n = len(nums) | |
slow, fast = 0, 0 | |
while True: | |
slow = nums[slow] | |
fast = nums[nums[fast]] | |
if slow == fast: break | |
p = 0 | |
while p != slow: | |
p = nums[p] | |
slow = nums[slow] | |
return p |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/find-the-duplicate-number/solutions/3797843/yong-ji-huan-shu-li-jie-zuo-fa-tong-142-tkoc2/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
给定一组非负整数 nums ，重新排列每个数的顺序（每个数不可拆分）使之组成一个最大的整数。
** 注意：** 输出结果可能非常大，所以你需要返回一个字符串而不是整数。
\n示例 1：
\n输入：nums = [10,2]\n输出："210"\n示例 2：
\n输入：nums = [3,30,34,5,9]\n输出："9534330"\n此题求拼接起来的最大数字。设数组 nums 中任意两数字的字符串为 x 和 y ，则规定 贪心策略：
\n若拼接字符串 x+y>y+x ，则 x “大于” y 。
\n反之，若 x+y<y+x ，则 x “小于” y 。
\nx “小于” y 代表：排序完成后，数组中 x 应在 y 左边；“大于” 则反之。
根据以上规则，套用任何排序方法对 nums 执行排序即可。
\nclass Solution: | |
def largestNumber(self, nums: List[int]) -> str: | |
def quick_sort(l, r): | |
if l >= r: return | |
i, j = l, r | |
while i < j: | |
while strs[j]+strs[l] >= strs[l]+strs[j] and i<j: j -= 1 | |
while strs[i]+strs[l] <= strs[l]+strs[i] and i<j: i += 1 | |
strs[i], strs[j] = strs[j], strs[i] | |
strs[i], strs[l] = strs[l], strs[i] | |
quick_sort(l,i-1) | |
quick_sort(i+1,r) | |
strs = [str(i) for i in nums] | |
quick_sort(0, len(strs)-1) | |
if strs[-1] == '0':return '0' | |
return ''.join(strs[::-1]) |
作者：Krahets
\n 链接：https://leetcode.cn/problems/largest-number/solutions/2361893/179-zui-da-shu-tan-xin-qing-xi-tu-jie-by-wboz/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
给你一个用字符数组 tasks 表示的 CPU 需要执行的任务列表，用字母 A 到 Z 表示，以及一个冷却时间 n 。每个周期或时间间隔允许完成一项任务。任务可以按任何顺序完成，但有一个限制：两个 相同种类 的任务之间必须有长度为 n 的冷却时间。
返回完成所有任务所需要的 最短时间间隔 。
\n示例 1：
\n输入：tasks = ["A","A","A","B","B","B"], n = 2\n输出：8\n解释：\n在完成任务 A 之后，你必须等待两个间隔。对任务 B 来说也是一样。在第 3 个间隔，A 和 B 都不能完成，所以你需要待命。在第 4 个间隔，由于已经经过了 2 个间隔，你可以再次执行 A 任务。\n示例 2：
\n输入：tasks = ["A","C","A","B","D","B"], n = 1\n输出：6\n解释：一种可能的序列是：A -> B -> C -> D -> A -> B。\n由于冷却间隔为 1，你可以在完成另一个任务后重复执行这个任务。\n本题核心问题就是冷却时间 n 意味着 CPU 可能必须要待命，实际完成任务时间 = len (tasks)+ 待命 > len (tasks);
\n 如果不需要待命，实际完成任务时间 = len (tasks)
假设需要 待命，由数量最大的任务种类来决定 完成任务时间:
\n 假设 A 有 3 个 (maxCt = 3), n = 2, 需要 待命 说明 'x' 的位置都填不满，实际完成任务时间 = (maxCt-1)*(n+1)+1 > len (tasks)
\nA x x
\nA x x
\nA
如果 'x' 的位置能填满的话，实际完成任务时间 = len (tasks) > (maxCt-1)*(n+1)+1, e.g.
\nA B C D
\nA B C
\nA
另外要注意的是数量最大的任务可能有好几个，比如 A 有 3 个 (maxCt = 3), B 也有 3 个，eleMaxCt = 2,
\nA B x
\nA B x
\nA B
\n 那么最后一行的个数就不是 1, 而是 eleMaxCt,
\n 综上，实际完成任务时间 = max ((maxCt-1)*(n+1)+eleMaxCt , len (tasks))
class Solution: | |
def leastInterval(self, tasks: List[str], n: int) -> int: | |
count = list(Counter(tasks).values()) | |
max_ct = max(count) | |
num_max = count.count(max_ct) | |
return max(len(tasks), (max_ct-1)*(n+1)+num_max) |
作者：MingZhang
\n 链接：https://leetcode.cn/problems/task-scheduler/solutions/954985/pythonsi-xing-dai-ma-chao-jian-ji-si-lu-eopmo/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
给你一个字符串 s ，请你去除字符串中重复的字母，使得每个字母只出现一次。需保证 返回结果的字典序最小（要求不能打乱其他字符的相对位置）。
示例 1：
\n输入：s = "bcabc"\n输出："abc"\n示例 2：
\n输入：s = "cbacdcbc"\n输出："acdb"\n具体算法如下：
\nclass Solution: | |
def removeDuplicateLetters(self, s: str) -> str: | |
result = [] | |
count = Counter(s) | |
for c in s: | |
count[c] -= 1 | |
if c in result: | |
continue | |
while result and c < result[-1] and count[result[-1]] >= 1: | |
result.pop(-1) | |
result.append(c) | |
return ''.join(result) |
作者：灵茶山艾府
\n链接：https://leetcode.cn/problems/remove-duplicate-letters/solutions/2381483/gen-zhao-wo-guo-yi-bian-shi-li-2ni-jiu-m-zd6u/
\n 来源：力扣（LeetCode）
\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
在一个由 '0' 和 '1' 组成的二维矩阵内，找到只包含 '1' 的最大正方形，并返回其面积。
示例 1：
\n![\"300\"](\"D:%5CHexo-Blog%5Cmy-hexo-blog%5Csource_posts%5C2025-08-15-Leetcode%5C221-01.png\")
输入：matrix = [["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]\n输出：4\n![\"300\"](\"D:%5CHexo-Blog%5Cmy-hexo-blog%5Csource_posts%5C2025-08-15-Leetcode%5C221-02.png\")
class Solution: | |
def maximalSquare(self, matrix: List[List[str]]) -> int: | |
m, n = len(matrix), len(matrix[0]) | |
visited = [[0]*(n+1) for _ in range(m+1)] | |
result = 0 | |
for i in range(m): | |
for j in range(n): | |
if matrix[i][j] == '0': visited[i+1][j+1] = 0 | |
else: | |
visited[i+1][j+1] = min(visited[i+1][j], visited[i][j+1], visited[i][j]) + 1 | |
result = max(visited[i+1][j+1], result) | |
return result ** 2 |
Tucker 分解
\n\n
Tucker 分解是 张量（tensor）分解 的一种，是矩阵 SVD（奇异值分解）在更高阶上的推广。
\n它的核心思想是：
\n\n\n用一个小的 核心张量 G，以及几个矩阵将一个大的原始张量表示出来，达到降维、压缩、解耦的效果。
\n
给定三阶张量 X∈RI×J×K，和矩阵 U∈RL×I，那么：
\nY=X×1U∈RL×J×K
\n这表示对第一个维度（mode-1）做矩阵变换。其本质是：
\n\n\n把张量的第 1 个维度的每个 “切片” 乘以 U
\n
设有一个三阶张量：
\nX∈RI×J×K
\nTucker 分解将其表示为：
\nX≈G×1A×2B×3C
\n其中：
\n\n\n总结一句话：Tucker 分解就是：
\n“把高维张量压缩成小的核心张量 + 每一维的线性变换矩阵”
\n
Tucker Decomposition\n ┌───────────────┐\n │ Tensor X │ 原始张量 X ∈ ℝ^{I×J×K}\n └────┬──────────┘\n ↓ Tucker分解\n ┌────────┴────────┐\n ↓ ↓ ↓\n Matrix A Matrix B Matrix C 模式矩阵（每一维的降维）\n (I×R1) (J×R2) (K×R3)\n ↓ ↓ ↓\n Core tensor G 核心张量 ∈ ℝ^{R1×R2×R3}\nTucker 分解可以：
\n降低维度 / 压缩张量：原始张量参数量为 I×J×K，而 Tucker 分解后是：
\nI⋅R1+J⋅R2+K⋅R3+R1⋅R2⋅R3
\n通常远小于原始张量。
\n捕捉模态之间的交互关系：核心张量 G 建模了压缩后表示之间的高阶交互。
\n在多模态场景中用于融合：比如图像、文本输入，分别编码后送入 Tucker 融合模块。
\n设有张量 X∈R4×3×2，我们用 Tucker 分解它：
\n合成的张量为：
\nX≈G×1A×2B×3C∈R4×3×2
\n| 方法 | \n类型 | \n适用场景 | \n特点 | \n
|---|---|---|---|
| Tucker | \n多模态张量分解 | \n多模态融合 | \n保留交互，参数可控 | \n
| CP (CANDECOMP/PARAFAC) | \n张量秩分解 | \n分解张量为秩 1 分量之和 | \n更简单但可解释性低 | \n
| PCA | \n矩阵分解 | \n降维 | \n相当于 SVD 的特例 | \n
| SVD | \n矩阵分解 | \n特征提取 | \n二阶张量特例 | \n
如在视觉问答中，将图像向量 vv 和文本向量 qq 融合，用 Tucker 分解实现有效的高阶交互建模。
\n可以用 Tucker 分解对 CNN 卷积核或 Transformer 权重张量进行压缩。
\n可以用共享核心张量，同时用不同模式矩阵适配不同任务。
\n# 简化版 Tucker 融合（v: image, q: text） | |
v_proj = U_v(v) # [B, r1] | |
q_proj = U_q(q) # [B, r2] | |
outer = torch.einsum(\"bi,bj->bij\", v_proj, q_proj) # [B, r1, r2] | |
fused = torch.einsum(\"bij,ijk->bk\", outer, core) # [B, r3] | |
out = U_o(fused) # [B, d_out] |
其他工具 ——Office 卸载
\n\n
起因是想下载 Visio 套件，因此需要通过官方下载整体 Office 包，但是下载后一直显示还是原来的 Office 教育版。
\nWin + R，输入 “control”，回车，在卸载程序中找到 Office 软件，右键卸载。
\nWin + R，输入 “regedit”，回车。
\n检查以下两项是否存在，若存在可以手动删除。
\n如果提示没有删除权限，请在对应的键上，右键 “权限”→选中当前登录账号，高级→勾选左下角 “使用可从此对象继承的权限项目替换所有子对象的权限项目”→应用，确定。然后尝试再次删除就可以删除掉了。
\nAA-CrossViT—— 模型搭建
\n\n
本文模型采用基于轴向分块和交叉注意力融合策略的双分支视觉 Transformer 作为锂离子电池早期寿命预测模型。具体而言，分别基于图形特征的电压轴向和周期轴向进行分块，而后利用卷积层将各分块编码到向量空间，随后添加反映分块信息和位置的可学习参数矩阵分类 token xcls 和位置编码矩阵 Xpe 。Transformer 编码层用以提取特征和捕捉分块间的依赖关系，随后提取双流分支的分类 token 和分块 token 输出作为交叉注意力机制的输入，以融合双轴向分支的信息。
\n导入相关依赖库。
\nimport torch | |
import torch.nn as nn | |
from torch import Tensor | |
from einops.layers.torch import Rearrange, Reduce | |
from einops import repeat, rearrange | |
from torchsummary import summary |
Rearrange/Reduce 和 rearrange/reduce 的区别：前者是网络层，后者是数据处理函数。
\n本文输入为锂离子电池的图形特征输入，尺寸为3×100×100。
\nx = torch.randn(3,100,100) # 单样本尺寸为 3*100*100 | |
print(x.shape) # (3,100,100) | |
x_batch = torch.randn(16,3,100,100) # 单个 batch 尺寸为 16*3*100*100 | |
print(x_batch.shape) |
视觉 Transformer 模型的第一步需要将图片划分为多个分块（Patches），并且将其映射到向量。具体而言，处于效率考虑，先利用卷积层将每个分块映射到向量空间维度dk，卷积核的大小与步长均为 patch 的尺寸，卷积核个数等于编码维度dk，而后利用 Rearrange 函数改变维度顺序。
in_channels, patch_size = 3, (1,100) | |
projection = nn.Sequential( | |
nn.Conv2d(in_channels=in_channels, out_channels=emb_size, kernel_size=patch_size, stride=(1,1)), | |
Rearrange(\"b e h w -> b (h w) e\"), | |
) |
Rearrange/Reduce 参数解析：输入参数格式为字符串
class PatchEmbedding(nn.Module): | |
def __init__(self, input_size:int=100, in_channels:int=3, patch_size:tuple=(1,100), emb_size:int=100): | |
super().__init__() | |
self.projection = nn.Sequential( | |
nn.Conv2d(in_channels=in_channels, out_channels=emb_size, kernel_size=patch_size, stride=(1,1)), | |
Rearrange(\"b e h w -> b (h w) e\"), | |
) | |
self.cls_token = nn.Parameter(torch.randn(1,1,emb_size)/emb_size) | |
self.positions = nn.Parameter(torch.randn((input_size**2 // (patch_size[0]*patch_size[1]) + 1,emb_size)) / emb_size) | |
def forward(self,x:Tensor): | |
b, c, h, w = x.shape | |
x = self.projection(x) | |
cls_tokens = repeat(self.cls_token,\"() n e -> b n e\",b=b) | |
x = torch.cat([cls_tokens, x], dim=1) | |
x += self.positions # 这里区别于 class token 直接用广播机制相加，原因是位置编码应该在 batch 内的不同样本也保持一致 | |
# print(x.shape) | |
return x |
基于动态自编码网络的电池故障检测
\n\n
Article link: Realistic fault detection of li-ion battery via dynamical deep learning (nature.com)
\nlocal link: [Realistic fault detection of li-ion battery via dynamical deep learning](/downloads/2024-12-01_Life prediction model for lithium-ion battery via a 3D convolutional network enhanced by channel attention considering charging and discharging process.pdf)
\nDate: 2024-12-01
\n对于多路测量参数（温度、电压、电流等），已有研究大多将它们直接连接，忽视了其中的耦合关系，导致了在映射到潜在特征空间时出现解耦。这种数据交互不足阻碍了模型的性能。
\n在模型层面：（1）许多方法仅关注充电或放电单一过程；（2）CNN 在处理时序性数据时性能不佳，且缺乏不同充电策略下的泛化能力。
\n从放电过程中的 IC 曲线和电压曲线中提取 HI，与充电特征进行融合；
\n通过 RP 技术将充电过程中的 VIT 数据转换为多维数据；
\n提出了一种深度可分离的通道注意力 3DCNN，用以解决权重数量多喝数据缺乏耦合计算的问题；
\n提出了一种同时预测不同充电协议下的寿命预测方法。
\n数据集采用 MIT 的两套锂离子退化数据集，分别包含了 124 和 45 个电池样本，两套数据集的采用不同的充电策略。
\nRP 技术：
\n矩阵论 ——01 矩阵的相似变换
\n\n
{x˙=Ax+Buy=Cx+Du(1)
\n其中，u=Rr 为输入向量；y=Rm 为输出向量；x∈Rn 为状态向量。A,B,C,D 为系数矩阵。
\n{x˙=A(t)x+B(t)uy=C(t)x+D(t)u(2)
\n{x(k+1)=A(k)x(k)+B(k)u(k)y(k)=C(k)x(k)+D(k)u(k)(3)
\n对于一个状态方程{x˙=Ax+Buy=Cx，选择非奇异矩阵P∈Rn×n 作为变换阵，有x=Px，那么此时状态方程可表示为：
\nx˙=P−1x˙=P−1[Ax+Bu]=P−1APx+P−1Bu=Ax+Bu(4)
\ny=Cx=CPx=Cx(5)
\n其中，A=P−1AP,B=P−1B,C=CP。
\n因此当状态变量 x 改变时，一定存在变换矩阵 P 使得状态方程发生变化。
\n公式（1）是线性时不变系统状态空间表达式的一般形式。其系统方框图可表示如下：
\n\n设有三阶系统状态空间表达式如下，试绘制其状态变量图。
\n⎩⎪⎪⎪⎨⎪⎪⎪⎧x˙1=x2x˙2=x3x˙3=−6x1−3x2−2x3+uy=x1+x2
\n其状态变量图可绘制如下：
\n\n对于单输入单输出系统{x˙=Ax+Buy=Cx+Du，在零初始条件下其传递函数可表示为：
\ng(s)=U(s)Y(s)=C(sI−A)−1B+D(6)
\n在系统{x˙=Ax+Buy=Cx+Du 中，在零初始条件下取拉氏变换有：{sX(s)=AX(s)+BU(s)Y(s)=CX(s)+DU(s)，整理得到{X(s)=(sI−A)−1BU(s)Y(s)=C(sI−A)−1BU(s)+DU(s)，故g(s)=U(s)Y(s)=C(sI−A)−1B+D
\n在 D=0 时，g(s)=U(s)Y(s)=C(sI−A)−1B=∣sI−A∣Cadj(sI−A)B，其中adj(sI−A) 表示矩阵sI−A 的伴随矩阵。
\n对比自控原理中传递函数的表达式：g(s)=sn+a1sn−1+⋯+an−1s+anb0sn+b1sn−1+⋯+bn−1s+bn，可知：
\n对于同一系统，选择两个不同的状态向量 x∈Rn 和 x∈Rn 分别得到不同的状态空间描述：
\n{x˙=Ax+Buy=Cx+Du{x˙=Ax+Buy=Cx+Du
\n两种状态变量一定存在着可逆变化关系：x=Px，故：
\n{x˙=Ax+Buy=Cx+Du⇒{Px˙=APx+Buy=CPx+Du⇒{x˙=P−1APx+P−1Buy=CPx+Du
\n故 A=P−1AP，所以矩阵 A 与矩阵 A 相似，故特征值相同。
\n相似矩阵具体相同的特征值
\n对于多输入多输出系统，输入向量u=[u1⋯up]T，输出向量y=[y1…yq]T。我们把第i 个输出yi 和第j 个输入uj 间的传递函数定义为：gij(s)=Uj(s)Yi(s)。故系统的输入输出关系可表示为：
\n⎣⎢⎢⎢⎢⎡Y1(s)Y2(s)⋮Yq(s)⎦⎥⎥⎥⎥⎤=⎣⎢⎢⎢⎢⎡g11(s)g21(s)⋮gq1(s)g12(s)g22(s)⋮gq2(s)⋯⋯⋱⋯g1p(s)g2p(s)⋮gqp(s)⎦⎥⎥⎥⎥⎤⎣⎢⎢⎢⎢⎡U1(s)U2(s)⋮Uq(s)⎦⎥⎥⎥⎥⎤
\n以矩阵的形式表示：Y(s)=G(s)U(s)，其中 G(s) 称为传递函数矩阵。
\n对于多输入多输出系统{x˙=Ax+Buy=Cx+Du，同样传递函数矩阵为：
\nG(s)=C(sI−A)−1B+D=∣sI−A∣Cadj(sI−A)B+D∣sI−A∣
\n已知系统动态方程为[x˙1x˙2]=[001−2][x1x2]+[1001][u1u2]，[y1y2]=[1001][x1x2]，试求系统的传递函数矩阵。
\n由题，G(s)=C(sI−A)−1B+D=[1001][s10s(s+2)1s+21][1001]=[s10s(s+2)1s+21]。
\n在单输入单输出线性时不变系统中，系统的输出与输入的关系可用如下高阶微分方程描述：
\ny(n)+a1y(n−1)+⋯+an−1y˙+any=b0u(m)+b1u(m−1)+⋯+bm−1u˙+bmu(7)
\n其中，m≤n。根据微分方程右侧是否含有输入函数的导数（即m 是否等于 0）分两种情况讨论。
\n若常微分方程中不含有输入函数的导数，即：y(n)+a1y(n−1)+⋯+an−1y˙+any=bmu。
\n那么可以选取状态变量：
\nx1=bm1y,x2=bm1y˙,⋯xn=bm1y(n−1)(8)
\n那么就可以得到状态方程（前n−1 条通过求导获得，最后一条通过原微分方程获得）：
\n⎩⎪⎪⎪⎪⎨⎪⎪⎪⎪⎧x˙1=x2x˙2=x3⋮x˙n=y(n)=−anx1−an−1x2−⋯−a1xn+u
\n输出方程为：y=bmx1。
\n以矩阵的形式可表示为：
\nx˙=⎣⎢⎢⎢⎢⎡0⋮0−an1⋮0−an−1⋯⋱⋯⋯0⋮1−a1⎦⎥⎥⎥⎥⎤x+⎣⎢⎢⎢⎢⎡00⋮1⎦⎥⎥⎥⎥⎤u(9)
\ny=[10⋯0]x(10)
\n形如公式（9）的状态空间模型称为能控标准型。即A 与b 可用以下形式表示：
\nA=⎣⎢⎢⎢⎢⎡0⋮0−an1⋮0−an−1⋯⋱⋯⋯0⋮1−a1⎦⎥⎥⎥⎥⎤,b=⎣⎢⎢⎢⎢⎡00⋮1⎦⎥⎥⎥⎥⎤
\n设系统的运动方程为：y(3)+5y¨+8y˙+6y=3u，试求其状态空间表达式。
\n选取状态变量x1=y,x2=y˙,x3=y¨，则有状态方程：
\n⎩⎪⎨⎪⎧x˙1=x2x˙2=x3x˙3=y(3)=−6x1−8x2−5x3+3u
\n输出方程为y=x1。
\n故状态空间表达式为：
\nx˙=⎣⎢⎡00−610−801−5⎦⎥⎤x+⎣⎢⎡003⎦⎥⎤u
\ny=[100]x
\n若常微分方程中含有输入函数的导数，即：y(n)+a1y(n−1)+⋯+an−1y˙+any=b0u(m)+b1u(m−1)+⋯+bm−1u˙+bmu。
\n选择状态变量：
\n⎩⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎧x1=y−β0ux2=x˙1−β1u=y˙−β0u˙−β1ux3=x˙2−β2u=y¨−β0u¨−β1u˙−β2u⋮xn=x˙n−1−βn−1u=y(n)−β0u(n−1)−β1u(n−2)−⋯−βn−2u˙−βn−1u(11)
\n其中参数β0,β1,⋯,βn 由下式决定：
\n⎣⎢⎢⎢⎢⎢⎢⎡β0β1β2⋮βn⎦⎥⎥⎥⎥⎥⎥⎤=⎣⎢⎢⎢⎢⎢⎢⎡1a1⋮an−1an01⋮an−2an−1⋯⋯⋱⋯⋯00⋮1a100⋮01⎦⎥⎥⎥⎥⎥⎥⎤⎣⎢⎢⎢⎢⎢⎢⎡b0b1b2⋮bn⎦⎥⎥⎥⎥⎥⎥⎤(12)
\n由（11）可得到状态方程：⎩⎪⎪⎪⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎪⎪⎪⎧x˙1=x2+β1ux˙2=x3+β2u⋮x˙n−1=xn+βn−1ux˙n=y(n)−β0u(u)−β1u(n−1)−⋯−βn−2u¨−βn−1u˙=−anx1−an−1x2−⋯−a1xn+βnu。
\n因此，状态空间表达式为：
\nx˙=⎣⎢⎢⎢⎢⎢⎢⎡00⋮0−an10⋮0−an−101⋮0−an−2⋯⋯⋱⋯⋯00⋮1−a1⎦⎥⎥⎥⎥⎥⎥⎤x+⎣⎢⎢⎢⎢⎢⎢⎡β0β1⋮βn−1βn⎦⎥⎥⎥⎥⎥⎥⎤u(13)
\ny=[10⋯0]x+β0u
\n后续的方法我们讨论的传递函数的分子多项式次数均小于分母多项式次数。因为对于实际系统，分子多项式次数总是小于或等于分母多项式次数，在次数相等时可以通过化简的方法转化为分子多项式次数小于分母多项式次数。
\n若传递函数的分子多项式次数等于分母多项式次数，即
\ng(s)=sn+a1sn−1+⋯+an−1s+anb0sm+b1sm−1+⋯+bm−1s+bm,m=n
\n它总是可以化简为：
\ng(s)=sn+a1sn−1+⋯+an−1s+anb1sm−1+⋯+bm−1s+bm=g(s)+b0,m=n
\n其中 g(s) 为分子多项式次数小于分母多项式次数的传递函数，b0 为常数，整体视为两者的并联结构。
\n对于n 阶传递函数：g(s)=U(s)Y(s)=sn+a1sn−1+⋯+an−1s+anb1sn−1+⋯+bn−1s+bn。
\n同时除以sn 有：Y(s)=U(s)1+a1s−1+⋯+an−1s−(n−1)+ans−nb1s−1+⋯+bn−1s−(n−1)+bns−n。
\n令中间变量E(s)=U(s)1+a1s−1+⋯+an−1s−(n−1)+ans−n1，即E(s)=U(s)−a1s−1E(s)−⋯−an−1s−(n−1)E(s)−ans−nE(s)。
\n则输入U(s)、中间变量E(s) 和输出Y(s) 的关系流程图如下：
\n\n则Y(s)=b1s−1E(s)+b2s−2E(s)+⋯+bn−1s−(n−1)E(s)+bns−nE(s)。
\n令xn,xn−1,⋯,x1 为s−1E(s),s−2E(s),⋯,s−nE(s) 的拉氏逆变换，那么就可以绘制状态变量图并得到系统的状态空间表达式（能控标准型）。
\n\nx˙=⎣⎢⎢⎢⎢⎡0⋮0−an1⋮0−an−1⋯⋱⋯⋯0⋮1−a1⎦⎥⎥⎥⎥⎤x+⎣⎢⎢⎢⎢⎡0⋮01⎦⎥⎥⎥⎥⎤u(14)
\ny=[bnbn−1⋯b1]x
\n如果该n 阶系统传递函数的分子多项式次数等于分母多项式次数（在通过传递函数建立状态空间描述中讨论过该情况）即 g(s)=sn+a1sn−1+⋯+an−1s+anb1sm−1+⋯+bm−1s+bm=g(s)+b0,m=n，那么先算出 g(s) 后在输入到输出之间直接连接一个比例环节即可。
\n该方法适用于传递函数可分解为因式相乘的形式，即g(s)=(s−p1)(s−p2)…(s−pn)b1(s−z1)(s−z2)⋯(s−zn−1)。
\n以一个三阶系统进行说明：g(s)=(s−p1)(s−p2)(s−p3)b1(s−z1)(s−z2)。
\n上式中可分为两种：s−p1=1−s1ps1，s−ps−z=1+s−pp−z=1+(p−z)1−s1ps1。
\n因此系统可视为三个一阶系统串联而成，结构图如下：
\n\n取每个积分器的输出为状态变量，那么可以得到状态空间表达式如下：
\n⎩⎪⎪⎪⎨⎪⎪⎪⎧x˙1=p1x1+b1ux˙2=x1+p2x2x˙3=x1+(p2−z2)x2+p3x3y=x1+(p2−z2)x2+(p3−z3)x3
\n写成向量的形式为：
\nx˙=⎣⎢⎡p1110p2p2−z200p3⎦⎥⎤x+⎣⎢⎡b100⎦⎥⎤u(15)
\ny=[1p2−z2p3−z3]x
\n传递函数极点两两相异，则g(s)=(s−p1)(s−p2)…(s−pn)N(s)=s−p1c1+s−p2c2+⋯+s−pncn，其中ci=lims→pi(s−pi)g(s)。
\n选取状态变量 xi(s)=s−pi1U(s)，即 sxi(s)=pixi(s)+u(s)，做拉氏逆变换有：
\nx˙i(t)=pixi(t)+u(t)
\n输出 y(s)=g(s)u(s)=∑i=1ns−piciui(s)=∑i=1ncixi(s)，做拉氏逆变换有：
\ny(t)=i=1∑ncixi(t)
\n写成向量的形式为：
\nx˙=⎣⎢⎢⎢⎢⎡p10⋮00p2⋮0⋯⋯⋱⋯000pn⎦⎥⎥⎥⎥⎤x+⎣⎢⎢⎢⎢⎡11⋮1⎦⎥⎥⎥⎥⎤u(16)
\ny=[c1c2⋯cn]x
\n对于系统 {x˙=Ax+Buy=Cx ，若A 为对角阵且各元素为传递函数的极点，B 为全 1 矩阵，C 内各元素为对应极点的留数，那么称该矩阵表达式为对角标准型。
\n先考虑只有一个重极点和若干个单极点，重数为r，g(s)=(s−p1)rc11+(s−p1)r−1c12+⋯+(s−p1)c1r+s−pr+1cr+1+⋯+s−pncn，其中对于单极点仍有：ci=lims→pi(s−pi)g(s)，而对于重极点则有：c1j=(j−1)!1lims→p1dsj−1dj−1[(s−p1)g(s)],j=1,2,⋯,r。
\n选取状态变量，化简求拉氏逆变换得到状态方程：
\n⎩⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎧x1(s)=(s−p1)rU(s)x2(s)=(s−p1)r−1U(s)⋮xr(s)=(s−p1)U(s)xr+1(s)=s−pr+1U(s)⋮x1(s)=s−pnU(s)⇒⎩⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎧x1(s)=s−p11x2(s)x2(s)=s−p11x3(s)⋮xr(s)=s−p11U(s)xr+1(s)=s−pr+11U(s)⋮xn(s)=s−pn1U(s)⇒L−1⎩⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎧x˙1(t)=p1x1+x2x˙2(t)=p1x2+x3⋮x˙r(t)=p1xr+ux˙r+1(t)=pr+1xx+1+u⋮x˙n(t)=pnxn+u
\n输出方程的拉氏变换为：
\nY(s)=c11x1(s)+c12x2(s)+⋯+c1rxr(s)+cr+1xr+1(s)+⋯+cnxn(s)
\n求拉氏逆变换有：
\ny(t)=c11x1(t)+c12x2(t)+⋯+c1rxr(t)+cr+1xr+1(t)+⋯+cnxn(t)
\n得到状态空间表达式为：
\n⎣⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎡x1˙x2˙⋮xr˙xr+1˙⋮xn˙⎦⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎤=⎣⎢⎢⎢⎢⎢⎢⎢⎢⎢⎡p11p10⋱⋱1p1pr+10⋱pn⎦⎥⎥⎥⎥⎥⎥⎥⎥⎥⎤⎣⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎡x1x2⋮xrxr+1⋮xn⎦⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎤+⎣⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎡00⋮11⋮1⎦⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎤u(17)
\ny=[c11c12⋯c1rcr+1⋯cn]⎣⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎡x1x2⋮xrxr+1⋮xn⎦⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎤
\n对于重根部分，矩阵A 中对应的是若尔当块，B 中为一个只有末行是 1 其余行为 0 的矩阵，C 中对应元素为r 重极点对应的留数。而对于其中的单极点部分，形式与无重根时一致。
\n拓展到具有多个重极点的情况。矩阵A 中在对角上补充对应的若尔当块，B 中对应补充只有末行是 1 其余行为 0 的矩阵，C 中补充对应元素为r 重极点对应的留数。
\n在n 个子系统并联的并联系统中，组合系统的传递函数矩阵等于子系统传递函数矩阵的和。
\nG(s)=G1(s)+G2(s)+⋯+Gn(s)(18)
\n在n 个子系统串联的串联系统中，组合系统的传递函数矩阵等于子系统传递函数矩阵的积。
\nG(s)=Gn(s)⋯G2(s)G1(s)(19)
\n注：子系统传递函数矩阵的积遵循左乘原则。
\n对于系统 G1(s)，若添加反馈环节（动态反馈G2(s) 或常数反馈H），则可得到组合系统的传递函数矩阵：
\n组合系统的传递函数矩阵为：
\nG(s)=[I+G2(s)G1(s)]−1G1(s)(20)
\n组合系统的传递函数矩阵为：
\nG(s)=[I+HG1(s)]−1G1(s)(21)
\n对于一个状态方程{x˙=Ax+Buy=Cx+Du，选择非奇异矩阵P∈Rn×n 作为变换阵，有x=Px，那么此时状态方程可表示为：
\nx˙=P−1x˙=P−1[Ax+Bu]=P−1APx+P−1Bu=Ax+Bu(22)
\ny=Cx=CPx=Cx(23)
\n其中，A=P−1AP,B=P−1B,C=CP,D=D。
\n该方法通常用于将非对角阵A 转化为对角阵A，从而实现状态变量的解耦。
\n线性定常系统的系统矩阵 A 的特征值是表征系统的动力学特性的重要参量。系统的状态方程可通过适当的线性非奇异变换化为由特征值表征的标准形，对分析系统的结构特性非常直观。
\n现代控制理论 ——06 状态反馈和状态观测器
\n\n
状态反馈的公式可表示为：
\nu=Lv−Kx(1)
\n定常系统{x˙y=Ax+Bu=Cx 表示为 {x˙y=(A−BK)x+BLv=Cx 。
\n引入状态反馈并不影响系统的能控性，但有可能影响系统的能观测性。
\n给定系统 Σ:{x˙y=Ax+Bu=Cx+Du 通过状态反馈 u=Lv−Kx 能使闭环极点位于预先任意指定位置上的充要条件是该系统 Σ 完全能控。
\n充分性：
\n必要性：
\n求 1×n 的实向量 K，使得矩阵 (A−bK) 的特征值为给定的复共轭成对出现的 λ1∗,λ2∗,…,λn∗。
\n计算前先判断系统是否完全可控，即判断 rank(Uc)=n 。具体原因见极点配置定理
\n给定系统的状态空间表达式 x˙=⎣⎢⎡0100−1100−1⎦⎥⎤x+⎣⎢⎡100⎦⎥⎤u，求状态反馈矩阵 K 使得反馈后闭环特征值为 λ1∗=−2,λ2,3∗=−1±j3。
\n由于 rank(Uc)=rank([bAbA2b])=rank⎣⎢⎡1000100−11⎦⎥⎤=3，故系统完全可控。
\n给定系统的状态空间表达式 x˙=⎣⎢⎡0100−1100−1⎦⎥⎤x+⎣⎢⎡100⎦⎥⎤u，求状态反馈矩阵 K 使得反馈后闭环特征值为 λ1∗=−2,λ2,3∗=−1±j3。
\n由于 rank(Uc)=rank([bAbA2b])=rank⎣⎢⎡1000100−11⎦⎥⎤=3，故系统完全可控。
\na(s)=det(sI−A+bK)=det⎩⎪⎨⎪⎧⎣⎢⎡s000s000s⎦⎥⎤−⎣⎢⎡0100−1100−1⎦⎥⎤+⎣⎢⎡100⎦⎥⎤[k1k2k3]⎭⎪⎬⎪⎫=s3+(2+k1)s2+(2k1+k2+1)s+(k1+k2+k3)
\n给定定常系统 Σ:{x˙y=Ax+Bu=Cx ，若状态完全能观测，则状态向量 x 能够由输入 x 和输出 y 表示。
\n由于 ⎩⎪⎪⎪⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎪⎪⎪⎧yy˙y(n)y(n−1)=Cx=Cx˙=CAx+CBu=CAx˙+CBu˙=CA2x+CABu+CBu˙⋮=CAn−1x+CAn−2Bu+⋯+CBu(n−2) ，则
\n⎣⎢⎢⎢⎢⎢⎢⎡yy˙−CBuy(n)−CABu−CBu˙⋮y(n−1)−CAn−2Bu−⋯−CBu(n−2)⎦⎥⎥⎥⎥⎥⎥⎤=⎣⎢⎢⎢⎢⎢⎢⎡CCACA2⋮CAn−1⎦⎥⎥⎥⎥⎥⎥⎤x=Nx
\n当且仅当 rank(N)=n 时，上述 x 有唯一解。N 即是能观性矩阵。
\n现代控制理论 ——05 控制系统的李雅普诺夫稳定性分析
\n\n
何为平衡状态？对于一个系统 x˙=f(x,t)，若果存在状态 xe 满足 x˙e≡0，那么该状态即为平衡状态。
\n![\"\"](\"https://s1.imagehub.cc/images/2023/12/15/0dfa81a886d2cba99a38d05364f57ecd.png\")
\n![\"\"](\"https://s1.imagehub.cc/images/2023/12/15/8d8829ffb7da9bc162c4e91874a019f9.png\")
\n![\"\"](\"https://s1.imagehub.cc/images/2023/12/15/f84bc555ea80a021158a0f6dab2b292b.png\")
大范围渐进稳定：从状态空间中所有初始点出发的轨迹都具有渐进稳定性，那么状态 xe 为大范围渐进稳定。
\n正定函数：对于函数 V(x)，在区域 S 内的所有 x 都有：① V(x) 中的各分量的偏导均存在；②V(0)=0 ；③当 x=0 时， V(x)>0(V(x)≥0) 。则称该函数是正定 (半正定) 的。
\n李雅普诺夫稳定的充要条件：系统矩阵 A 的全部特征值实部大于 0，即位于复平面左半部。
\n对于非线性系统 x˙=f(x)，讨论其在可能平衡状态 xe 的稳定性。引入新向量 y=x−xe，那么系统的状态方程转换为 y˙=Ay+G(y)y，其中 A 为雅克比矩阵。
\n......
\n对于状态方程为 x˙=f(x,t),f(0,t)=0 的系统，存在一个具有连续偏导的标量函数 V(x,t)，满足
\nV(x,t) 正定，V˙(x,t) 半正定，则系统在原点一致稳定；在此基础上，若对于任意 t0 和 x0=0，在 t≥t0 时不恒等于 0，则系统在原点渐进稳定；在此基础上，若随着 ∣∣x∣∣→∞，V(x,t)→∞，则系统在原点大范围渐进稳定。
\nV(x,t) 正定，V˙(x,t) 正定，则系统在原点不稳定；
\n用李雅普诺夫第二方法判断以下系统的稳定性。
\nx˙1=−(x1+x2)−x22x˙2=−(x1+x2)+x1x2
\n系统存在的唯一可能平衡状态为 x1=0,x2=0，取标量函数 V(x)=x12+x22，显然 V(x) 正定，求导有
\nV˙(x)=2x1x˙1+2x2x˙2=−2(x1+x2)2
\n负定。除原点外有 x1=−x2 使得 V˙(x)=0，但是系统状态仍在转移中，故 V˙(x) 不会恒定等于 0。且随着 ∣∣x∣∣→∞，V(x)→∞，故系统在原点大范围渐进稳定。
\n:::
\n在连续系统 x˙=Ax 中，在平衡状态 x=0 处是大范围渐进稳定的充要条件：对于给定的正定对称实矩阵 Q，存在一个正定实对称矩阵 P ，满足 ATP+PA=−Q。（其中 xTPx 就是李雅普诺夫函数 ）
\n在离散系统 x(k+1)=Gx(k)，在平衡状态 x=0 处是渐进稳定的充要条件：对于给定的正定对称实矩阵 Q，存在一个正定实对称矩阵 P ，满足 GTPG−P=−Q。（其中 xTPx 就是李雅普诺夫函数 ）
\n以下系统的平衡状态在坐标原点，判断其渐进稳定性。
\nx˙=[0−11−1]x
\n设 P=[p11p12p12p22]，由 ATP+PA=−I 有，[01−1−1][p11p12p12p22]+[p11p12p12p22][0−11−1]=[−100−1]，则 ⎩⎪⎪⎨⎪⎪⎧−2p12=−1p11−p12−p22=02p12−2p22=−1→⎩⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎧p11=23p12=1p22=21，得到 P=[2321211]，验证各阶主子行列式是否大于 0：P11=23>0，P22=det[p11p12p12p22]=45>0，故矩阵 P 正定。故系统在原点大范围渐进稳定。
\n以下系统的平衡状态在坐标原点，判断其渐进稳定性。
\n[x1(k+1)x2(k+1)]=[0−0.50.5−1][x1(k)x2(k)]
\n设 P=[p11p12p12p22]，由 GTPG−P=−I 有，[00.5−0.5−1][p11p12p12p22][0−0.50.5−1]−[p11p12p12p22]=[−100−1]，得到 P=[27522740274027100]，验证各阶主子行列式均大于 0，故矩阵 P 正定。故系统在原点大范围渐进稳定。
\n关于 Md 文件使用 Shoka 主题渲染的关键技巧 / 基础
\n\n
![](https://s1.imagehub.cc/images/2023/11/16/b60b630ac478d2911b6c682866cf5d09.jpeg \"芙宁娜\") |
![\"\"](\"https://s1.imagehub.cc/images/2023/11/16/b60b630ac478d2911b6c682866cf5d09.jpeg\" "\\"芙宁娜\\"")
![](https://s1.imagehub.cc/images/2023/11/16/b60b630ac478d2911b6c682866cf5d09.jpeg \"芙宁娜200*300\"){height=\"200px\" width=\"300px\"} |
在 _posts 路径下创建一个与 md 文件同名（不带文件尾缀）的文件夹，将图片放在该文件夹下，调用图片时使用相对路径调用。以本文件为例，文件名为 2023-12-14_md+shoka使用技巧.md ，在文件同级目录下创建文件夹 2023-12-14_md+shoka使用技巧 ，内含图片 芙宁娜.jpg 。图片引用小括号内填写（格式问题，就不用代码块了）： 2023-12-14_md+shoka使用技巧/芙宁娜.jpg
使用相册图案列表（注意图片之间不用换行，我这里为了方便看所以分行了）
\n | |
 | |
 | |
 {.gallery} |
![\"\"](\"https://s1.imagehub.cc/images/2023/11/16/49ada8b3e781b287ee31af3cc75393fd.jpeg\")
![\"\"](\"https://s1.imagehub.cc/images/2023/11/16/ec096dea8315c4068cd0e2aac4ac628f.jpeg\")
![\"\"](\"https://s1.imagehub.cc/images/2023/11/16/dbb87c34a09e2edb4e2324cb8f8cf42c.jpeg\")
设置每行高度：data-height，默认为 220。
\n | |
 | |
 | |
 {.gallery data-height=\"100\"} |
填入基本格式： [language] [title] [url] [link text] [mark] [command]
language ：语言类型（raw 表示空显示代码块）。 title ：标题内容。 url ：链接。 link text ：链接显示内容。 mark ：行高亮显示，用法为： mark:2,4,5-8,9 。 command ：命令行提示符，用法为： command:(">> root$":1,4||">> host$":6,7)
python 示例代码 https://hening25.gitee.io 链接 mark:1,3-4 | |
import math | |
import numpy as np | |
import torch | |
array = np.arrary ([1,2,3]) |
import math | |
import numpy as np | |
import torch | |
array = np.arrary([1,2,3]) |
bash 命令行 https://hening25.gitee.io 链接 command:("(base) PS D:\\>":1,2,6||"(base) PS D:\\Github>":7) | |
ls | |
pwd | |
Path | |
---- | |
D:\\ | |
cd Github | |
pwd | |
Path | |
---- | |
D:\\Github |
| \"> | ls | |
| \"> | pwd | |
Path | ||
---- | ||
D:\\ | ||
| \"> | cd Github | |
| \"> | pwd | |
Path | ||
---- | ||
D:\\Github |
{% pdf file_path 600 1000%}\n- [ ] 叉叉 | |
- [x] 勾勾 | |
{.danger} | |
- [ ] 叉叉 | |
- [x] 勾勾 | |
{.danger} | |
- [ ] 叉叉 | |
- [x] 默认颜色 |
该模式需要在 Front Matter 中添加 quiz: true 。
| 标签 | \n含义 | \n
|---|---|
{.quiz} | \n选择题 | \n
{.quiz .multi} | \n多选题 | \n
{.quiz .true} | \n正确的判断题 | \n
{.quiz .false} | \n错误的判断题 | \n
{.quiz .fill} | \n填空题 | \n
[]{.gap} | \n空白下划线 | \n
[答案内容]{.gap} | \n答案内容下划线 | \n
{.options} | \n选择题的选项 | \n
{.correct} | \n选择题的正确选项 | \n
> | \n答案解析 | \n
[8.2]{.mistake} | \n错题备注 | \n
1. 下列定义中合法的是 []{.gap}。{.quiz .multi} | |
\t- `shor _a=1-.1e-1;` {.correct} | |
\t- `double b=1+5e2.5;` | |
\t- `long do=0xfdaL;` | |
\t- `float end_=0.1;` {.correct} | |
\t{.options} | |
\t> - :heavy_check_mark: 正确 | |
\t> - :x: 错误 | |
\t> - :x: 错误 | |
\t> - :heavy_check_mark: 正确 | |
2. -8 在内存中的存储形式是 []{.gap}。{.quiz} | |
\t- `11111111 11111000` {.correct} | |
\t- `10000000 00001000` | |
\t- `00000000 00001000` | |
\t- `11111111 11110111` | |
\t{.options} | |
3. 已知 int x=6; 则执行 x+=x-=x*x 语句后，x 的值是 [-60]{.gap}。{.quiz .fill} |
下列定义中合法的是。
\n\n\n\n\n
-8 在内存中的存储形式是。
\n\n已知 int x=6; 则执行 x+=x-=x*x 语句后，x 的值是 - 60。
\n卷积神经网络各层特征图的可视化
\n\n
代码链接：https://github.com/Hny1216/FeatureMapVisualization
\n速食可直接跳转引用方法
\n理解特征图（Feature Map）就需要先理解卷积神经网络（Convolutional Neural Network，CNN）是如何工作的。
\n卷积神经网络大体可以分为特征提取层和特征映射层。特征提取层主要由若干卷积层、激活层和池化层组成，特征映射层主要是多层全连接层。在卷积层中，使用不同的卷积核从局部感受野中提取各种特征，每个核生成自己的特征图，多个卷积核得到的特征图在深度方向堆叠得到输出特征图（Feature Maps）。
\n以 Alexnet 为例，其网络结构如下图。其输入图像的大小为 224×224×3 ，第一个卷积层中卷积核的大小是5×5，共有 96 个卷积核（分为两批），每个卷积核与输入进行卷积运算得到一张特征图，因此可以得到 96 张特征图（图中为何是 48 个特征图？Alexnet 设计网络时运算能力不足，因此将网络分为了两批，每一批都是 48，因此总特征图就是 48*2=96 张）。
\n![](\"/2023/12/06/2023-12-06_%E7%89%B9%E5%BE%81%E5%9B%BE%E5%8F%AF%E8%A7%86%E5%8C%96/01-Alexnet%E7%BD%91%E7%BB%9C%E7%BB%93%E6%9E%84.png\")
特征图的激活可视化本质就是可视化特征图，通过观察特征图中被激活的像素位置，从而借此理解卷积神经网络关注输入的那一部分数据信息，进而对卷积神经网络进行解释。
\n同样以 Alexnet 网络的第一层卷积层为例，输入选择一张标签为 “balloon”，大小为 705×705×3 的图像。输入的三通道图像如下：
\n![](\"/2023/12/06/2023-12-06_%E7%89%B9%E5%BE%81%E5%9B%BE%E5%8F%AF%E8%A7%86%E5%8C%96/02-%E8%BE%93%E5%85%A5%E5%9B%BE%E5%83%8F.png\")
我们可视化浅层网络（Relu1）和深层网络（Relu4，Relu5），来观察网络各层激活了哪些特征（选取了前 18 个通道）。浅层网络激活的特征信息较多，且与原始数据较为相似，越深层网络所提取到的特征就越抽象，更加注重输入的纹理细节信息。
\n![](\"/2023/12/06/2023-12-06_%E7%89%B9%E5%BE%81%E5%9B%BE%E5%8F%AF%E8%A7%86%E5%8C%96/03-Relu1.png\")
![](\"/2023/12/06/2023-12-06_%E7%89%B9%E5%BE%81%E5%9B%BE%E5%8F%AF%E8%A7%86%E5%8C%96/04-Relu4.png\")
![](\"/2023/12/06/2023-12-06_%E7%89%B9%E5%BE%81%E5%9B%BE%E5%8F%AF%E8%A7%86%E5%8C%96/05-Relu5.png\")
本方法实现了一个特征图可视化类，提供了 Matlab 和 Python 两种语言的版本，以下根据需要使用合适的语言自行使用。
\n下载链接如下：https://github.com/Hny1216/FeatureMapVisualization
\n确保特征图可视化类与运行脚本文件在一个路径即可。
\na = alexnet; | |
Fmv = FeatureMapVisualization(a,isShow=true); |
import FeatureMapVisualization as Fmv | |
model = models.alexnet(pretrained=True) | |
modelLayer = list(model.children()) | |
modelVisualization = Fmv.FeatureMapVisualization(modelLayer) |
现代控制理论 ——04 线性系统的能控性和能观测性
\n\n
能控性的简单理解为输入能够控制系统的状态变量 x(t) 和输出变量 y(t)）。
\n以下图结构图系统为例，输入 u 只能影响 x1 而不能影响 x2 ，因此可以说该系统中 x2 不可控， x1 可控，系统整体不可控。
\n![](\"/2023/12/06/2023-12-06-%E7%BA%BF%E6%80%A7%E7%B3%BB%E7%BB%9F%E7%9A%84%E8%83%BD%E6%8E%A7%E6%80%A7%E5%92%8C%E8%83%BD%E8%A7%82%E6%B5%8B%E6%80%A7/01%E8%83%BD%E6%8E%A7%E6%80%A7%E4%BE%8B%E5%AD%90.png\")
对于线性定常系统：
\nx˙=Ax+Bu(1)
\n如果存在输入控制 u(t) 在有限的时间 [t0,t1] 内能将系统从初始状态 x(t0) 转移到任意的状态 x(t1) 。
\nUc=[BAB⋯An−1B](2)
\n的秩为 n ，即 rankUc=n。
\nA = [1,2,1;0,1,0;1,0,3]; % A 矩阵必须为 n*n 矩阵 | |
B = [1,0;0,1;0,0]; % B 矩阵必须为 n*k 矩阵 | |
[n, ~] = size(A); % 获取状态变量维数 | |
Uc = [B]; temp = B; | |
for i = 1:n-1 | |
temp = A*temp; | |
Uc = [Uc,temp]; % 能控矩阵 | |
end | |
disp(rank(Uc)==n); % 判断状态变量维数是否与能控矩阵的秩一致 |
考察以下系统的能控性。
\n⎣⎢⎡x˙1x˙2x˙3⎦⎥⎤=⎣⎢⎡101210103⎦⎥⎤⎣⎢⎡x1x2x3⎦⎥⎤+⎣⎢⎡100010⎦⎥⎤[u1u2]
\n由题 B=⎣⎢⎡100010⎦⎥⎤， AB=⎣⎢⎡101210103⎦⎥⎤⎣⎢⎡100010⎦⎥⎤=⎣⎢⎡101210⎦⎥⎤，A2B=⎣⎢⎡101210103⎦⎥⎤⎣⎢⎡101210⎦⎥⎤=⎣⎢⎡204412⎦⎥⎤。
\n故 Uc=⎣⎢⎡100010101210204412⎦⎥⎤，其秩为 3，故该系统可控。
\n我们把上述的对角标准型状态方程 x^˙=⎣⎢⎡λ10⋱0λn⎦⎥⎤x^+B^u 展开：
\n⎩⎪⎪⎪⎪⎨⎪⎪⎪⎪⎧x^˙1=λ1x^1+b^11u1+b^12u2+⋯+b^1pupx^˙2=λ2x^2+b^21u1+b^22u2+⋯+b^2pup⋮x^˙n=λnx^n+b^n1u1+b^n2u2+⋯+b^npup
\n从中可以看出状态变量间是解耦的，状态变量间是没有联系的。若 B^ 中存在一行全为 0，那么该行对应的状态变量将不受输入的控制，故系统不可控。
\n判断以下系统的可控性。
\n⎣⎢⎡x˙1x˙2x˙3⎦⎥⎤=⎣⎢⎡3000−1000−2⎦⎥⎤⎣⎢⎡x1x2x3⎦⎥⎤+⎣⎢⎡210⎦⎥⎤u
\n该系统不可控，因为状态变量 x3 不可控。
\n判断以下系统的可控性。
\n⎣⎢⎡x˙1x˙2x˙3⎦⎥⎤=⎣⎢⎡−7000−5000−1⎦⎥⎤⎣⎢⎡x1x2x3⎦⎥⎤+⎣⎢⎡047105⎦⎥⎤[u1u2]
\n该系统可控。
\n该判据的优点是能够容易判断出能控性，并且能够直接看出不可控的部分，但缺点在于需要等价变换。
\n注意，上述判据 2 存在不适用情况：
\n对于系统 x˙=[1001]x+[11]u，矩阵 B 中虽然没有全零行，但是矩阵 A 为对角阵且含有相同元素，故该系统不可控。
\n对于系统 x˙=⎣⎢⎡−1001−4000−4⎦⎥⎤x+⎣⎢⎡012⎦⎥⎤u，虽然所有若尔当块的最后一行均没有全零行，但是矩阵 A 为若尔当标准型且存在两个若尔当块的特征值相同，故该系统不可控。
\n若系统矩阵 A 具有重特征值 λ1(m1重),λ2(m2重),⋯,λk(mk重) 且每个重特征值只有一个若尔当块时时，则系统状态可控的充要条件是，系统经过线性非奇异变换后，系统转换为若尔当标准型，状态方程为 x^˙=⎣⎢⎢⎢⎢⎡J10⋮00J2⋮0⋯⋯⋱⋯00⋮Jn⎦⎥⎥⎥⎥⎤x^+B^u，其中 B^ 中与每个若尔当块 Ji 最后一行对应的行中各元素不全为 0。
\n判断以下系统的可控性。
\n⎣⎢⎡x˙1x˙2x˙3⎦⎥⎤=⎣⎢⎡−3001−30001⎦⎥⎤⎣⎢⎡x1x2x3⎦⎥⎤+⎣⎢⎡0200−13⎦⎥⎤[u1u2]
\n该系统可控。
\n判断以下系统的可控性。
\n⎣⎢⎡x˙1x˙2x˙3⎦⎥⎤=⎣⎢⎡40014000−2⎦⎥⎤⎣⎢⎡x1x2x3⎦⎥⎤+⎣⎢⎡403200⎦⎥⎤[u1u2]
\n该系统不可控。
\n很多情况下，被控制量往往是系统的输出而非状态变量，因此还需分析输出能控性。
\nA = [-4,1;2,-3]; % A 矩阵必须为 n*n 矩阵 | |
B = [1;2]; % B 矩阵必须为 n*k 矩阵 | |
C = [1,0]; % C 矩阵必须为 p*n 矩阵 | |
[n, ~] = size(A); % 获取状态变量维数 | |
[p, ~] = size(C); % 获取输出维数 | |
Uc = [C*B]; temp = eye(n,n); | |
for i = 1:n-1 | |
temp = temp*A; | |
Uc = [Uc,C*temp*B]; | |
end | |
disp(rank(Uc)==p); |
判断以下系统的状态能控性和输出能控性。
\n[x˙1x˙2]=[−421−3][x1x2]+[12]uy=[10][x1x2]
\n系统的状态能控性矩阵：[BAB]=[12−2−4]，秩为 1，故系统状态不可控。
\n系统的输出能控性矩阵：[CBCAB]=[1−2]，秩为 1，故系统输出可控。
\n能观测性是指通过对输出的测量来确定系统的状态变量，反映了从系统外部观测系统内部的能力。
\n在前面状态方程的解方面的内容中，我们知道线性时不变系统动态方程（取初态时间 t0=0）的解为：
\nx(t)=eA(t)x(0)+∫0teA(t−τ)Bu(τ)dτ,t≥0(3)
\n上式中，系统矩阵 A,B 以及控制输入 u(t) 已知，因此只需要关注初态 x(0) 即可得到 x(t)。
\n对于线性定常系统：
\n{x˙y=Ax+Bu=Cx(4)
\n如果在任意给定的输入 u(t) 下，根据输出 y(t) 在有限的时间 [t0,t1] 内的测量值唯一确定初始状态 x(t0) ，则称系统在 t0 时刻可观测。若在任意时刻都可观测，则该系统是状态完全可观测的。
\nUo=⎣⎢⎢⎢⎢⎡CCA⋮CAn−1⎦⎥⎥⎥⎥⎤(5)
\n的秩为 n ，即 rankUo=n。
\nA = [2,-1;1,-3]; % A 矩阵必须为 n*n 矩阵 | |
B = [-1;1]; % B 矩阵必须为 n*k 矩阵 | |
C = [1,0;-1,0]; % C 矩阵必须为 p*n 矩阵 | |
[n, ~] = size(A); % 获取状态变量维数 | |
[p, ~] = size(C); % 获取输出维数 | |
Uo = [C]; %temp = eye(n,n); | |
for i = 1:n-1 | |
Uo = [Uo;Uo(end-p+1:end,:)*A]; | |
end | |
disp(rank(Uo)==p); |
判断以下系统的能观测性
\n[x1˙x2˙][y1y2]=[21−1−3][x1x2]+[−11]u=[1−100][x1x2]
\n系统的能观性矩阵 Uo=[CCA]=⎣⎢⎢⎢⎡1−12−200−11⎦⎥⎥⎥⎤ 的秩为 2，故该系统能观测。
\n若系统矩阵 A 具有重特征值 λ1(m1重),λ2(m2重),⋯,λk(mk重) 且每个重特征值只有一个若尔当块时时，则系统状态可控的充要条件是，系统经过线性非奇异变换后，系统转换为若尔当标准型，状态方程为 ⎩⎪⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎪⎧x^˙y=⎣⎢⎢⎢⎢⎡J10⋮00J2⋮0⋯⋯⋱⋯00⋮Jn⎦⎥⎥⎥⎥⎤x^=C^x^，其中 C^ 中与每个若尔当块 Ji 第一列对应的行中各元素不全为 0。
\n判断以下系统的能观测性
\nx˙y=[−2005]x=[13]x
\n该系统为对角标准型，不含全为 0 的列，故系统完全可观测。
\n判断以下系统的能观测性
\nx˙y=⎣⎢⎢⎢⎡2000120000300013⎦⎥⎥⎥⎤x=[00111101]x
\n该系统为若尔当标准型，第一个若尔当块第一列全为 0，故系统不可观测。
\n判断以下系统的能观测性
\nx˙y=⎣⎢⎡−3001−30001⎦⎥⎤x=[10000−1]x
\n该系统为若尔当标准型，所有若尔当块的第一列不全为 0，故系统可观测。
\n对于两个系统 Σ1:{x˙y=Ax+Bu=Cx ， Σ2:{z˙w=ATz+CTv=BTz，其中 x 与 z 的维度相同，u 与 v 的维度相同，y 与 w 的维度相同，这两个系统即是对偶系统。
\n![](\"/2023/12/06/2023-12-06-%E7%BA%BF%E6%80%A7%E7%B3%BB%E7%BB%9F%E7%9A%84%E8%83%BD%E6%8E%A7%E6%80%A7%E5%92%8C%E8%83%BD%E8%A7%82%E6%B5%8B%E6%80%A7/02%E5%AF%B9%E5%81%B6%E7%B3%BB%E7%BB%9F.png\")
对于上述两个系统 Σ1,Σ2，Σ1 能观 ⇔ Σ2 能控，Σ1 能控 ⇔ Σ2 能观。
\n证明 Σ1 的能观性矩阵与 Σ2 的能控性矩阵一致， Σ1 的能控性矩阵与 Σ2 的能观性矩阵一致。
\n进一步分析对偶系统的传递函数可知：GΣ1(s)=[GΣ2(s)]T
\n结构分解就是将系统的可控（可观）和不可控（不可观）的部分分离开，进而理解系统的内部。
\n对于系统 {x˙y=Ax+Bu=Cx，以下将进行能控性分解、能观性分解和标准分解。
\n假设系统不完全可控，即能控性矩阵的秩为 n1<n。存在非奇异矩阵 Tc 进行状态变换 x=Tcx~ ，使得系统的状态空间方程变换为：{x~˙y=A~x~+B~u=C~x，其中 A~=Tc−1ATc=[A~110A~12A~22]，B~=Tc−1B=[B~10]，C~=CTc=[C~1C~2]，其中 A~11,A~12,A~22 均为分块矩阵，各自的维数为 n1×n1,n1×(n−n1),(n−n1)×(n−n1)，B~1 为 n1×p 的分块矩阵，C~1,C~2 为 q×n1,q×(n−n1) 的分块矩阵。
\n那么系统的 n1 维能控部分可表示为：x~˙=A~11x~1+A~12x~2+B~1u，n−n1 维不可控部分可表示为：x~2=A~22x~2 。
\n那么变换矩阵 Tc 如何获取呢？
\n对下列系统进行能控性分解。
\nx˙y=⎣⎢⎡010001−1−3−3⎦⎥⎤x+⎣⎢⎡110⎦⎥⎤u=[01−2]x
\n故可控部分为：⎩⎪⎪⎨⎪⎪⎧x~˙1=[01−1−2]x~1+[10]uy=[1−1]x~1。
\n假设系统不完全能观，即能观性矩阵的秩为 n2<n。存在非奇异矩阵 To 进行状态变换 x=Tox~ ，使得系统的状态空间方程变换为：{x~˙y=A~x~+B~u=C~x，其中 A~=To−1ATo=[A~11A~210A~22]，B~=To−1B=[B~1B~2]，C~=CTo=[C~10]，其中 A~11,A~12,A~22 均为分块矩阵，各自的维数为 n2×n2,(n−n2)×n2,(n−n2)×(n−n2)，B~1,B~2 为 n2×p,(n−n2)×p 的分块矩阵，C~1 为 q×n2 的分块矩阵。
\n那么系统的 n2 维能观部分可表示为：{x~˙=A~11x~1+B~1uy1=C~1x~1，n−n2 维不可观部分可表示为：x~2=A~21x~1+A~22x~2+B~2u 。
\n能观子系统的传递函数矩阵与原系统的传递函数矩阵相同，因为不能观测的部分不能出现在传递函数矩阵中。
\n同样关键是变换矩阵 To 如何获取。
\n对下列系统进行能观性分解。
\nx˙y=⎣⎢⎡010001−1−3−3⎦⎥⎤x+⎣⎢⎡110⎦⎥⎤u=[01−2]x
\n故可观部分为：⎩⎪⎪⎨⎪⎪⎧x~˙1=[0−1−1−2]x~1+[1−1]uy=[10]x~1。
\n在单输入单输出系统中，系统能控能观的充要条件是传递函数中没有零极点相消的现象。
\n推论
\n在单输入单输出系统（x˙=Ax+bu），若系统矩阵 A 和控制矩阵 b 表示如下，那么其为状态空间表达式的能控标准型。
\nA=⎣⎢⎢⎢⎢⎢⎢⎡00⋮0−an10⋮0−an−101⋮0−an−2⋯⋯⋱⋯⋯00⋮0−a1⎦⎥⎥⎥⎥⎥⎥⎤,b=⎣⎢⎢⎢⎢⎢⎢⎡00⋮01⎦⎥⎥⎥⎥⎥⎥⎤
\n对于线性定常系统 x˙=Ax+bu，若其能控，那么必定存在非奇异变换 x~=Px 将该系统转换为能控标准型 x~˙=Acx~+bcu（Ac,bc 符合上述能控标准型）。非奇异变换 P=⎣⎢⎢⎢⎢⎡p1P1A⋮p1An−1⎦⎥⎥⎥⎥⎤，其中 p1 由 p1=[000⋯01][bAbA2b⋯An−1b]−1 确定。
\n将下列线性定常系统化为能控标准型。
\nx˙=[11−10]x+[11]u
\n系统的能控性矩阵为：Uc=[bAb]=[1101]，求逆得到 Uc−1=[1−101]，进而计算 p1=[−11]。则变换矩阵P=[p1p1A]=[−1011]，求逆得到 P−1=[−1011]。
\n则 Ac=PAP−1=[0−111],bc=Pb=[01]，则能控标准型表示为：x~˙=[0−111]x~+[01]u。
\n在单输入单输出系统（{x˙=Ax+buy=cx），若系统矩阵 A 和控制矩阵 b 表示如下，那么其为状态空间表达式的能控标准型。
\nA=⎣⎢⎢⎢⎢⎢⎢⎡010⋮0001⋮0⋯⋯⋯⋱⋯000⋮0−an−an−1−an−2⋮−a1⎦⎥⎥⎥⎥⎥⎥⎤,c=[00⋯01]
\n对于线性定常系统 {x˙=Ax+buy=cx，若其能观，那么必定存在非奇异变换 x=Tx~ 将该系统转换为能控标准型 {x~˙=Aox~+bouy=cox~（Ao,co 符合上述能观标准型）。非奇异变换 T=[T1AT1⋯An−1T1]，其中 T1 由 T1=⎣⎢⎢⎢⎢⎢⎢⎡ccAcA2⋮cAn−1⎦⎥⎥⎥⎥⎥⎥⎤−1⎣⎢⎢⎢⎢⎢⎢⎡00⋮01⎦⎥⎥⎥⎥⎥⎥⎤ 确定。
\n将下列线性定常系统化为能观标准型。
\nx˙y=[10−12]x=[−1−21]x
\n系统的能观性矩阵为：Uo=[ccA]=[−1−1−210]，则 T1=[ccA]−1[01]=[−12]。则变换矩阵T=[T1AT1]=[−12−34]。
\n则能观标准型表示为：⎩⎪⎪⎨⎪⎪⎧x~˙=T−1ATx~=[01−23]x~y=cTx~=[01]x~。
\n现代控制理论 ——03 状态方程的解
\n\n
test
\neAt=I+At+2!1A2t2+⋯
\n=⎣⎢⎢⎢⎢⎡10⋮001⋮0⋯⋯⋱⋯00⋮1⎦⎥⎥⎥⎥⎤+⎣⎢⎢⎢⎢⎡λ10⋮00λ2⋮0⋯⋯⋱⋯00⋮λn⎦⎥⎥⎥⎥⎤t+2!1⎣⎢⎢⎢⎢⎡λ120⋮00λ22⋮0⋯⋯⋱⋯00⋮λn2⎦⎥⎥⎥⎥⎤t2+⋯
\n=⎣⎢⎢⎢⎢⎡∑n=0+∞n!1λ1ntn0⋮00∑n=0+∞n!1λ2ntn⋮0⋯⋯⋱⋯00⋮∑n=0+∞n!1λnntn⎦⎥⎥⎥⎥⎤=⎣⎢⎢⎢⎢⎡eλ1t0⋮00eλ2t⋮0⋯⋯⋱⋯00⋮eλnt⎦⎥⎥⎥⎥⎤。
\n形如⎣⎢⎢⎢⎢⎢⎢⎡λ0⋮001λ⋮0001λ⋯⋯⋯⋯⋱λ000⋮1λ⎦⎥⎥⎥⎥⎥⎥⎤m×m 为m 阶若尔当矩阵，1 阶若尔当矩阵为λ。
\n已知A=[0−110]，求eAt。
\n由定义，
\neAt=I+At+2!1+⋯=[1001]+[0−tt0]+2!1[−t200−t2]+⋯=[1−2!t2+⋯−t+3!t3−⋯t−3!t3+⋯1−2!t2+⋯]=[cost−sintsintcost].
\n设线性时不变齐次状态方程为 x˙=Ax(t)，x(0)=x0，t≥t0。
\n作拉氏变换有 sX(s)−x(0)=AX(s)，即 (sI−A)X(s)=x(0)，那么
\nX(s)=(sI−A)−1x(0)
\n取拉氏逆变换有 x(0)=L−1[(sI−A)−1x(0)]=L−1[(sI−A)−1]x(0)，因此
\neAt=L−1[(sI−A)−1](2)
\n计算矩阵 A=[0−21−3] 的矩阵指数。
\n由拉氏变换法，(sI−A)=[s2−1s+3]，则(sI−A)−1=[(s+1)(s+2)s+3(s+1)(s+2)−2(s+1)(s+2)1(s+1)(s+2)s]，
\n则 eAt=L−1[(s+1)(s+2)s+3(s+1)(s+2)−2(s+1)(s+2)1(s+1)(s+2)s]=[2e−t−2e−t+2e−2te−t−e−2t−e−t+2e−2t]。
\n若A=⎣⎢⎢⎢⎢⎡λ10⋮00λ2⋮0⋯⋯⋱⋯00⋮λn⎦⎥⎥⎥⎥⎤ 为对角矩阵，则eAt 也为对角矩阵（性质 8），即eAt=⎣⎢⎢⎢⎢⎡eλ1t0⋮00eλ2t⋮0⋯⋯⋱⋯00⋮eλnt⎦⎥⎥⎥⎥⎤。
\n（1）当矩阵A 的 n 个特征值 λ1,λ2…λn 均两两互异时，则可确定变换阵 P 及其逆矩阵 P−1 ，使得矩阵A 对角化：A=P⎣⎢⎢⎢⎢⎡λ10⋮00λ2⋮0⋯⋯⋱⋯00⋮λn⎦⎥⎥⎥⎥⎤P−1，则有
\neAt=P⎣⎢⎢⎢⎢⎡eλ1t0⋮00eλ2t⋮0⋯⋯⋱⋯00⋮eλnt⎦⎥⎥⎥⎥⎤P−1(3)
\n试用化为对角标准型法求解矩阵A=[0−21−3] 的矩阵指数 eAt。
\n求解特征值∣λI−A∣=∣∣∣∣∣λ2−1λ+3∣∣∣∣∣=(λ+1)(λ+2)，得到特征值为λ1=−1，λ2=−2。继而求解特征向量p1=[1−1]，p2=[1−2]。
\n故变换矩阵 P=[1−11−2]，求逆有 P−1=[2−11−1]。
\n则矩阵指数为 eAt=P[e−t00e−2t]P−1=[2e−t−e−2t−2e−t+2e−2te−t−e−2t−e−t+2e−2t]。
\n试用化为对角标准型法求解矩阵A=⎣⎢⎡0−6−61−11−11−165⎦⎥⎤ 的矩阵指数 eAt。
\n求解特征值∣λI−A∣=∣∣∣∣∣∣∣λ66−1λ+11111−6λ−5∣∣∣∣∣∣∣=(λ+1)(λ+2)(λ+3)，得到特征值为λ1=−1，λ2=−2，λ3=−3。继而求解特征向量p1=⎣⎢⎡101⎦⎥⎤，p2=⎣⎢⎡124⎦⎥⎤，p3=⎣⎢⎡169⎦⎥⎤。
\n故变换矩阵 P=⎣⎢⎡101124169⎦⎥⎤，求逆有 P−1=⎣⎢⎡3−3125−423−23−1⎦⎥⎤。
\n则矩阵指数为
\neAt=P⎣⎢⎡e−t000e−2t000e−3t⎦⎥⎤P−1=⎣⎢⎡101124169⎦⎥⎤⎣⎢⎡e−t000e−2t000e−3t⎦⎥⎤⎣⎢⎡3−3125−423−23−1⎦⎥⎤=⎣⎢⎡3e−t−3e−2t+e−3t−6e−t+6e−3t3e−t−12e−2t+9e−3t25e−t−4e−2t+23e−3t−8e−2t+9e−3t25e−t−16e−2t+227e−3t−2e−t+3e−2t−e−3t6e−2t−6e−3t−2e−t+12e−2t−9e−3t⎦⎥⎤。
\n（2）当 n×n 矩阵A 有n 重特征根时，存在线性非奇异变换 P 及其逆矩阵 P−1 ，将矩阵 A 转化为若尔当标准型：A=P⎣⎢⎢⎢⎢⎡λ0⋮01λ⋮0⋯⋯⋱⋯001λ⎦⎥⎥⎥⎥⎤n×nP−1，则有
\neAt=Peλt⎣⎢⎢⎢⎢⎢⎢⎢⎡10⋮00t1⋮002!t2t⋮00⋯⋯⋱⋯⋯(n−1)!tn−1(n−2)!tn−2⋮t1⎦⎥⎥⎥⎥⎥⎥⎥⎤n×nP−1(4)
\n拓展到一般情况，矩阵A 同时存在重特征根和单特征根时，以有三重根λ1、两重根λ2 和单根λ3 的矩阵A 为例，若存在变换阵 P 及其逆矩阵 P−1 ，将矩阵 A 转化为若尔当标准型：A=P⎣⎢⎢⎢⎢⎢⎢⎢⎡λ101λ11λ1λ21λ20λ1⎦⎥⎥⎥⎥⎥⎥⎥⎤P−1，则有
\neAt=P⎣⎢⎢⎢⎢⎢⎢⎢⎡eλ1t00000teλ1teλ1t000021t2eλ1tteλ1teλ1t000000eλ2t00000teλ2teλ2t000000eλ3t⎦⎥⎥⎥⎥⎥⎥⎥⎤P−1(5)
\n试求矩阵A=⎣⎢⎡013602−524⎦⎥⎤ 的矩阵指数。
\n求解特征值∣λI−A∣=∣∣∣∣∣∣∣λ−1−3−6λ−25−2λ−4∣∣∣∣∣∣∣=(λ−1)2(λ−2)，得到特征值为λ1=λ2=1，λ3=2。继而求解特征向量和广义特征向量p1=⎣⎢⎡1−73−75⎦⎥⎤，p2=⎣⎢⎡1−4922−4946⎦⎥⎤，p3=⎣⎢⎡2−1−2⎦⎥⎤。
\n故变换矩阵 P=⎣⎢⎡1−73−751−4922−49462−1−2⎦⎥⎤，求逆有 P−1=⎣⎢⎡27−4−628−115−71⎦⎥⎤。
\n则矩阵指数为
\neAt=P⎣⎢⎡e−t00te−tet000e2t⎦⎥⎤P−1=⎣⎢⎡9et+7tet−8e2t−4et−3tet+4e2t−8et−5tet+8e2t22et+28tet+−22e2t−10et−12tet+11e2t−22et−20tet−22e2t−2et−7tet+2e2tet+3tet−e2t3et+5tet−2e2t⎦⎥⎤。
\n该方法将矩阵指数表示为eAt=a0(t)I+a1(t)A+⋯+an−1An−1。
\n当特征值两两互异时，
\n⎣⎢⎢⎢⎢⎡a0(t)a1(t)⋮an−1(t)⎦⎥⎥⎥⎥⎤=⎣⎢⎢⎢⎢⎡11⋮1λ1λ2⋮λn⋯⋯⋱⋯λ1n−1λ2n−1⋮λnn−1⎦⎥⎥⎥⎥⎤−1⎣⎢⎢⎢⎢⎡eλ1teλ2t⋮eλnt⎦⎥⎥⎥⎥⎤(6)
\n当存在重特征值时（以三重根λ1 和二重根λ2，其余根为单根为例），
\n⎣⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎡a0(t)a1(t)a2(t)a3(t)a4(t)a5(t)⋮an−1(t)⎦⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎤=⎣⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎡001011⋮101λ11λ2λ3⋮λn12λ1λ122λ2λ22λ32⋮λn23λ13λ12λ133λ22λ23λ33⋮λn3⋯⋯⋯⋯⋯⋯⋱⋯2!(n−1)(n−2)λ1n−31!(n−1)λ1n−2λ1n−11!(n−1)λ2n−2λ2n−1λ3n−1⋮λnn−1⎦⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎤−1⎣⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎡2!1t2eλ1t1!1teλ1teλ1t1!1teλ2teλ2teλ3t⋮eλn−3t⎦⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎤(7)
\n求解系统矩阵A 的特征值 λ1,λ2…λn 。
\n求解有限项，根据特征值的互异性分情况分析：
\neλit=a0(t)+a1(t)λi+⋯+an−1(t)λin−1
\n而对于k 重根部分在列写方程eλit=a0(t)+a1(t)λi+⋯+ak−1(t)λik−1 外还需要补充方程：
\n⎩⎪⎪⎪⎪⎨⎪⎪⎪⎪⎧teλit=a1(t)+2a2(t)λi+⋯+(k−1)ak−1(t)λik−2t2eλit=2a2(t)+6a3(t)λi+⋯+(k−1)(k−2)ak−1(t)λik−3⋮tk−1eλit=(k−1)!ak−1(t)
\n联立n 条方程求解有限项
\neAt=a0(t)I+a1(t)A+⋯+an−1An−1
\n试求矩阵A=⎣⎢⎡002103010⎦⎥⎤ 的矩阵指数，利用化为有限项法求解。
\n求解特征值∣λI−A∣=∣∣∣∣∣∣∣λ0−2−1λ−30−1λ∣∣∣∣∣∣∣=(λ+1)2(λ−2)，得到特征值为λ1,2=−1，λ3=2。
\n对于单根 λ3=2，有 e2t=a0(t)+2a1(t)+4a2(t)，
\n对于二重根λ1,2=−1，有 e−t=a0(t)−a1(t)+a2(t)，还需要补充方程：
\nte−t=a1(t)−2a2(t)
\n联立三组方程解得：
\n⎩⎪⎨⎪⎧a0(t)=91(e2t+8e−t+6te−t)a1(t)=91(2e2t−2e−t+3te−t)a3(t)=91(e2t−e−t−3te−t)
\neAt=a0(t)I+a1(t)A+⋯+an−1An−1=91⎣⎢⎡e2t+(8+6t)e−t2e2t−(2+6t)e−t4e2t+(6−4t)e−te2t−(2−3t)e−t4e2t+(5−3t)e−t8e2t+(3−8t)e−te2t−(1+3t)e−t2e2t−(2−3t)e−t4e2t+(5−3t)e−t⎦⎥⎤
\n动态系统在控制的作用下的运动称为受控运动。线性时不变系统非齐次状态方程的解即为线性时不变系统的受控运动。考虑系统 x˙(t)=Ax(t)+Bu(t),x(0),t≥0，其动态响应形式为：
\nx(t)=eA(t−t0)x(t0)+∫t0teA(t−τ)Bu(τ)dτ,t≥0(8)
\n可理解为由两部分组成：一部分是由初始状态引起的系统自由运动，即零输入响应；另外一部分是由控制输入所产生的受控运动，即零状态响应。
\n对于系统x˙(t)=Ax(t)+Bu(t),x(0),t≥0，左乘e−At 后求导可得：
\ndtd[e−Atx(t)]=e−At[x˙(t)−Ax(t)]=e−AtBu(t)
\n两边积分得：
\n∫0t{dtd[e−Atx(t)]}dτ=∫0te−AtBu(t)dτ
\ne−Atx(t)−x(0)I=∫0te−AtBu(t)dτ
\nx(t)=eA(t−t0)x(t0)+∫t0teA(t−τ)Bu(τ)dτ,t≥0
\n在线性时不变系统解 x(t)=eA(t−t0)x(t0)+∫t0teA(t−τ)Bu(τ)dτ,t≥0 中，定义状态转移矩阵Φ(t,t0)=eA(t−t0)。
\n对于线性连续系统的状态方程：x˙(t)=A(t)x(t)+B(t)u(t),x(t0)=x0,A(t)∈Rn×n，那么称满足以下矩阵方程的解Φ(t,t0) 为系统的状态转移矩阵。
\nΦ˙(t,t0)=A(t)Φ(t,t0),Φ(t0,t0)=I,t≥t0(9)
\n线性连续系统的时间离散化问题本质上就是在一定的采样方式和保持方式下，由系统的连续时间状态空间描述来得到对应的离散时间状态空间描述，并建立两者的系数矩阵间的关系式。
\n考虑以下线性时变系统：x˙(t)=A(t)x(t)+B(t)u(t)，当采样周期T 较小且精度要求不高时，可将其离散化为：
\nx˙(kT)≈T1[x((k+1)T)−x(kT)](10)
\n令t=kT，有
\nT1[x((k+1)T)−x(kT)]=A(kT)x(kT)+B(kT)u(kT)
\nx[(k+1)T]=[I+TA(kT)]x(kT)+TB(kT)u(kT)=G(kT)x(kT)+H(kT)u(kT)
\n其中，G(kT)=I+TA(kT)，H(kT)=TB(kT)。
\n注：一般而言，当采样周期为系统最小时间系数的101 左右，近似度已经足够。
\n系统的状态方程为x˙(t)=A(t)x(t)+B(t)u(t)，其中A(t)=[005(1−e−5t)5(e−5t−1)]，B(t)=[505e−5t5(1−e−5t)]。试求采样周期为T=0.2s 时的离散状态方程。
\n直接代入公式有：
\nG(kT)=I+TA(kT)=[101−e−ke−k]
\nH(kT)=TB(kT)=[10e−k1−e−k]
\n那么，离散状态方程为：x[(k+1)T]=G(kT)x(kT)+H(kT)u(kT)
\n将状态方程x˙=[0−21−3]x+[01]u 近似离散化，T=0.2s。
\n由题：G=I+TA=[1001]+0.2[0−21−3]=[1−0.40.20.4]，H=0.2[01]=[00.2]。
\n故离散状态方程为：
\n$x[0.2(k+1)]=\\begin{bmatrix}1&0.2\\\\-0.4&0.4\\end{bmatrix}x(0.2k)+\\begin{bmatrix}0\\\\0.2\\end{bmatrix}u(0.2k)$\n\n在线性时不变系统中，x˙(t)=A(x)+B(u)，其时间离散化状态方程为：
\nx[(k+1)T]=Gx(kT)+Hu(kT)(11)
\n其中G=eAT，H=(∫0TeATdt)B。假设条件为：(1) 等采样周期T；(2)u(t)≡u(kT),kT≤t≤(k+1)T。
\n对于线性时不变系统 x˙(t)=A(x)+B(u)，其状态方程的解为：
\nx(t)=eA(t−t0)x(t0)+∫eA(t−τ)Bu(τ)dτ(12)
\n假设：(1) 等采样周期T；(2)x(k)=[x(t)]t=kT，u(k)=[u(t)]_
\n那么令 t=(k+1)T，t0=kT，有：
\nx[(k+1)T]=eATx(kT)+∫kT(k+1)TeA[(k+1)T−τ]Bu(τ)dτ=eATx(kT)+∫kT(k+1)TeA[(k+1)T−τ]Bdτ⋅u(kT)
\n令 t=(k+1)T−τ，dτ=−dt，有：
\nx[(k+1)T]=eATx(kT)+∫0τeA(t)Bdt⋅u(kT)=eATx(kT)+∫0τeA(t)dt⋅Bu(kT)
\n令G=eAT，H=(∫0TeATdt)B，有线性时不变系统的离散状态方程为：
\nx[(k+1)T]=Gx(kT)+Hu(kT)
\n将状态方程x˙=[001−2]x+[01]u 离散化，T=0.1s。
\n利用拉氏变换法求解矩阵指数函数。取拉氏变换有：
\n[sI−A]−1=[s0−1s+2]−1=[s10s(s+2)1s+21]
\n取拉氏逆变换得到矩阵指数函数：
\neAt=L−1[sI−A]−1=[100.5(1−e−2T)e−2T]
\n进而求解系数矩阵：
\nG=eAT=[100.5(1−e−2T)e−2T]=[100.0910.819]
\nH=(∫0TeATdt)B=[∫0T[100.5(1−e−2T)e−2T]dt][01]=[T00.5T+0.25e−2T−0.25−0.5e−2T+0.5][01]=[0.0050.091]
\n故时间离散化状态方程为：
\nx[0.1(k+1)]=[100.0910.819]x(0.1k)+[0.0050.091]u(0.1k)
\n离散系统的差分方程形状态方程有两种解法：递推法和 z 变换法。其中递推法在时变系统和时不变系统中都适用，而 z 变换法只适用于时不变系统。
\n⎩⎪⎪⎪⎪⎨⎪⎪⎪⎪⎧x(1)=G(0)x(0)+H(0)u(0)x(2)=G(1)x(1)+H(1)u(1)x(3)=G(2)x(2)+H(2)u(2)⋮
\n给定初始条件x(0) 和输入序列u(0),u(1),⋯ 后即可求解x(k)。
\nx(k)=Gkx(0)+i=0∑k−1Gk−1−iHu(i)(13)
\n上式称为线性时不变离散系统的状态转移方程，其中Φ(k)=Gk 称为线性时不变离散系统的状态转移矩阵。
\n状态转移矩阵的性质：
\n考虑时不变离散系统：x(k+1)=Gx(k)+Hu(k)，取 z 变换有：
\nzx(z)−zx(0)=Gx(z)+Hu(z)
\nz(z)=(zI−G)−1zx(0)+(zI−G)−1Hu(z)(14)
\n取 z 逆变换有：
\nx(k)=z−1[(zI−G)−1z]x(0)+z−1[(zI−G)−1Hu(z)](15)
\n对比公式（13）和公式（15），由解的唯一性可知，
\nz−1[(zI−G)−1z]=Gk(16)
\nz−1[(zI−G)−1Hu(z)]=i=0∑k−1Gk−1−iHu(i)(17)
\n考虑离散系统：x(k+1)=Gx(k)+Hu(k)，其中G=[0−0.161−1]，H=[11]，初始条件为x(0)=[1−1]，试求当u(k)=1 时状态方程的解。
\n用 z 变换法求解，先计算(zI−G)−1，有
\n(zI−G)−1=[z0.16−1z+1]−1=(z+0.2)(z+0.8)1[z+1−0.161z]=[34×z+0.21−31×z+0.81−30.8×z+0.21+30.8×z+0.8135×z+0.21−35×z+0.81−31×z+0.21+34×z+0.81]
\n由于u(k)=1，则u(z)=z−1z，故zx(0)+Hu(z)=[z−z]+[z−1zz−1z]=[z−1z2z−1−z2+2z]。
\n那么代入公式（15）有：
\nx(z)=(zI−G)−1[zx(0)+Hu(z)]=[−617×z+0.2z+922×z+0.8z+1825×z−1z63.4×z+0.2z−917.6×z+0.8z+187×z−1z]
\n求 z 逆变换有：
\nx(k)=[−617(−0.2)k+922(−0.8)k+182563.4(−0.2)k−917.6(−0.2)k+187]
\n现代控制理论 ——03 状态方程的解
\n\n
对于n 维线性时不变系统状态方程：x˙=Ax(t)+Bu(t)，系统状态方程的解即为系统的运动。当控制输入为0 时对应的齐次状态方程 x˙=Ax(t) 的解为系统的自由运动。
\n对于标量一阶微分方程的齐次方程 x˙=ax(t)，若初始时刻为t0，则方程的解为x(t)=ea(t−t0)x(t0)，其中指数函数展开为无穷级数：ea(t−t0)=∑n=0+∞n!1an(t−t0)n。
\n拓展到矢量一阶微分方程的齐次方程 x˙=Ax(t) ，解可以表示为
\nx(t)=eA(t−t0)x(t0)(1)
\n其中eA(t−t0)=∑n=0+∞n!1An(t−t0)n，称为矩阵指数。
\n矩阵指数函数表示为：eA(t)=∑n=0+∞n!1An(t)n，即输入为0 时的解（零输入响应）。
\n矩阵指数的导数：dtdeAt=AeAt=eAtA。
\n对于n×n 阶方阵A 和B，若AB=BA，则e(A+B)t=eAteBt。
\n若t1 与t2 为独立的自变量，则eA(t1+t2)=eAt1eAt2。
\neA∗0=I。
\neAte−At=I。
\neP−1AP=P−1eAP。
\nlimt→0eAt=I。
\n若A 为对角矩阵，即A=⎣⎢⎢⎢⎢⎡λ10⋮00λ2⋮0⋯⋯⋱⋯00⋮λn⎦⎥⎥⎥⎥⎤，则eAt=⎣⎢⎢⎢⎢⎡eλ1t0⋮00eλ2t⋮0⋯⋯⋱⋯00⋮eλnt⎦⎥⎥⎥⎥⎤。
\neAt=I+At+2!1A2t2+⋯
\n=⎣⎢⎢⎢⎢⎡10⋮001⋮0⋯⋯⋱⋯00⋮1⎦⎥⎥⎥⎥⎤+⎣⎢⎢⎢⎢⎡λ10⋮00λ2⋮0⋯⋯⋱⋯00⋮λn⎦⎥⎥⎥⎥⎤t+2!1⎣⎢⎢⎢⎢⎡λ120⋮00λ22⋮0⋯⋯⋱⋯00⋮λn2⎦⎥⎥⎥⎥⎤t2+⋯
\n=⎣⎢⎢⎢⎢⎡∑n=0+∞n!1λ1ntn0⋮00∑n=0+∞n!1λ2ntn⋮0⋯⋯⋱⋯00⋮∑n=0+∞n!1λnntn⎦⎥⎥⎥⎥⎤=⎣⎢⎢⎢⎢⎡eλ1t0⋮00eλ2t⋮0⋯⋯⋱⋯00⋮eλnt⎦⎥⎥⎥⎥⎤。
\n形如⎣⎢⎢⎢⎢⎢⎢⎡λ0⋮001λ⋮0001λ⋯⋯⋯⋯⋱λ000⋮1λ⎦⎥⎥⎥⎥⎥⎥⎤m×m 为m 阶若尔当矩阵，1 阶若尔当矩阵为λ。
\n已知A=[0−110]，求eAt。
\n由定义，
\neAt=I+At+2!1+⋯=[1001]+[0−tt0]+2!1[−t200−t2]+⋯=[1−2!t2+⋯−t+3!t3−⋯t−3!t3+⋯1−2!t2+⋯]=[cost−sintsintcost].
\n设线性时不变齐次状态方程为 x˙=Ax(t)，x(0)=x0，t≥t0。
\n作拉氏变换有 sX(s)−x(0)=AX(s)，即 (sI−A)X(s)=x(0)，那么
\nX(s)=(sI−A)−1x(0)
\n取拉氏逆变换有 x(0)=L−1[(sI−A)−1x(0)]=L−1[(sI−A)−1]x(0)，因此
\neAt=L−1[(sI−A)−1](2)
\n计算矩阵 A=[0−21−3] 的矩阵指数。
\n由拉氏变换法，(sI−A)=[s2−1s+3]，则(sI−A)−1=[(s+1)(s+2)s+3(s+1)(s+2)−2(s+1)(s+2)1(s+1)(s+2)s]，
\n则 eAt=L−1[(s+1)(s+2)s+3(s+1)(s+2)−2(s+1)(s+2)1(s+1)(s+2)s]=[2e−t−2e−t+2e−2te−t−e−2t−e−t+2e−2t]。
\n若A=⎣⎢⎢⎢⎢⎡λ10⋮00λ2⋮0⋯⋯⋱⋯00⋮λn⎦⎥⎥⎥⎥⎤ 为对角矩阵，则eAt 也为对角矩阵（性质 8），即eAt=⎣⎢⎢⎢⎢⎡eλ1t0⋮00eλ2t⋮0⋯⋯⋱⋯00⋮eλnt⎦⎥⎥⎥⎥⎤。
\n（1）当矩阵A 的 n 个特征值 λ1,λ2…λn 均两两互异时，则可确定变换阵 P 及其逆矩阵 P−1 ，使得矩阵A 对角化：A=P⎣⎢⎢⎢⎢⎡λ10⋮00λ2⋮0⋯⋯⋱⋯00⋮λn⎦⎥⎥⎥⎥⎤P−1，则有
\neAt=P⎣⎢⎢⎢⎢⎡eλ1t0⋮00eλ2t⋮0⋯⋯⋱⋯00⋮eλnt⎦⎥⎥⎥⎥⎤P−1(3)
\n试用化为对角标准型法求解矩阵A=[0−21−3] 的矩阵指数 eAt。
\n求解特征值∣λI−A∣=∣∣∣∣∣λ2−1λ+3∣∣∣∣∣=(λ+1)(λ+2)，得到特征值为λ1=−1，λ2=−2。继而求解特征向量p1=[1−1]，p2=[1−2]。
\n故变换矩阵 P=[1−11−2]，求逆有 P−1=[2−11−1]。
\n则矩阵指数为 eAt=P[e−t00e−2t]P−1=[2e−t−e−2t−2e−t+2e−2te−t−e−2t−e−t+2e−2t]。
\n试用化为对角标准型法求解矩阵A=⎣⎢⎡0−6−61−11−11−165⎦⎥⎤ 的矩阵指数 eAt。
\n求解特征值∣λI−A∣=∣∣∣∣∣∣∣λ66−1λ+11111−6λ−5∣∣∣∣∣∣∣=(λ+1)(λ+2)(λ+3)，得到特征值为λ1=−1，λ2=−2，λ3=−3。继而求解特征向量p1=⎣⎢⎡101⎦⎥⎤，p2=⎣⎢⎡124⎦⎥⎤，p3=⎣⎢⎡169⎦⎥⎤。
\n故变换矩阵 P=⎣⎢⎡101124169⎦⎥⎤，求逆有 P−1=⎣⎢⎡3−3125−423−23−1⎦⎥⎤。
\n则矩阵指数为
\neAt=P⎣⎢⎡e−t000e−2t000e−3t⎦⎥⎤P−1=⎣⎢⎡101124169⎦⎥⎤⎣⎢⎡e−t000e−2t000e−3t⎦⎥⎤⎣⎢⎡3−3125−423−23−1⎦⎥⎤=⎣⎢⎡3e−t−3e−2t+e−3t−6e−t+6e−3t3e−t−12e−2t+9e−3t25e−t−4e−2t+23e−3t−8e−2t+9e−3t25e−t−16e−2t+227e−3t−2e−t+3e−2t−e−3t6e−2t−6e−3t−2e−t+12e−2t−9e−3t⎦⎥⎤。
\n（2）当 n×n 矩阵A 有n 重特征根时，存在线性非奇异变换 P 及其逆矩阵 P−1 ，将矩阵 A 转化为若尔当标准型：A=P⎣⎢⎢⎢⎢⎡λ0⋮01λ⋮0⋯⋯⋱⋯001λ⎦⎥⎥⎥⎥⎤n×nP−1，则有
\neAt=Peλt⎣⎢⎢⎢⎢⎢⎢⎢⎡10⋮00t1⋮002!t2t⋮00⋯⋯⋱⋯⋯(n−1)!tn−1(n−2)!tn−2⋮t1⎦⎥⎥⎥⎥⎥⎥⎥⎤n×nP−1(4)
\n拓展到一般情况，矩阵A 同时存在重特征根和单特征根时，以有三重根λ1、两重根λ2 和单根λ3 的矩阵A 为例，若存在变换阵 P 及其逆矩阵 P−1 ，将矩阵 A 转化为若尔当标准型：A=P⎣⎢⎢⎢⎢⎢⎢⎢⎡λ101λ11λ1λ21λ20λ1⎦⎥⎥⎥⎥⎥⎥⎥⎤P−1，则有
\neAt=P⎣⎢⎢⎢⎢⎢⎢⎢⎡eλ1t00000teλ1teλ1t000021t2eλ1tteλ1teλ1t000000eλ2t00000teλ2teλ2t000000eλ3t⎦⎥⎥⎥⎥⎥⎥⎥⎤P−1(5)
\n试求矩阵A=⎣⎢⎡013602−524⎦⎥⎤ 的矩阵指数。
\n求解特征值∣λI−A∣=∣∣∣∣∣∣∣λ−1−3−6λ−25−2λ−4∣∣∣∣∣∣∣=(λ−1)2(λ−2)，得到特征值为λ1=λ2=1，λ3=2。继而求解特征向量和广义特征向量p1=⎣⎢⎡1−73−75⎦⎥⎤，p2=⎣⎢⎡1−4922−4946⎦⎥⎤，p3=⎣⎢⎡2−1−2⎦⎥⎤。
\n故变换矩阵 P=⎣⎢⎡1−73−751−4922−49462−1−2⎦⎥⎤，求逆有 P−1=⎣⎢⎡27−4−628−115−71⎦⎥⎤。
\n则矩阵指数为
\neAt=P⎣⎢⎡e−t00te−tet000e2t⎦⎥⎤P−1=⎣⎢⎡9et+7tet−8e2t−4et−3tet+4e2t−8et−5tet+8e2t22et+28tet+−22e2t−10et−12tet+11e2t−22et−20tet−22e2t−2et−7tet+2e2tet+3tet−e2t3et+5tet−2e2t⎦⎥⎤。
\n该方法将矩阵指数表示为eAt=a0(t)I+a1(t)A+⋯+an−1An−1。
\n当特征值两两互异时，
\n⎣⎢⎢⎢⎢⎡a0(t)a1(t)⋮an−1(t)⎦⎥⎥⎥⎥⎤=⎣⎢⎢⎢⎢⎡11⋮1λ1λ2⋮λn⋯⋯⋱⋯λ1n−1λ2n−1⋮λnn−1⎦⎥⎥⎥⎥⎤−1⎣⎢⎢⎢⎢⎡eλ1teλ2t⋮eλnt⎦⎥⎥⎥⎥⎤(6)
\n当存在重特征值时（以三重根λ1 和二重根λ2，其余根为单根为例），
\n⎣⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎡a0(t)a1(t)a2(t)a3(t)a4(t)a5(t)⋮an−1(t)⎦⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎤=⎣⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎡001011⋮101λ11λ2λ3⋮λn12λ1λ122λ2λ22λ32⋮λn23λ13λ12λ133λ22λ23λ33⋮λn3⋯⋯⋯⋯⋯⋯⋱⋯2!(n−1)(n−2)λ1n−31!(n−1)λ1n−2λ1n−11!(n−1)λ2n−2λ2n−1λ3n−1⋮λnn−1⎦⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎤−1⎣⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎡2!1t2eλ1t1!1teλ1teλ1t1!1teλ2teλ2teλ3t⋮eλn−3t⎦⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎤(7)
\n求解系统矩阵A 的特征值 λ1,λ2…λn 。
\n求解有限项，根据特征值的互异性分情况分析：
\neλit=a0(t)+a1(t)λi+⋯+an−1(t)λin−1
\n而对于k 重根部分在列写方程eλit=a0(t)+a1(t)λi+⋯+ak−1(t)λik−1 外还需要补充方程：
\n⎩⎪⎪⎪⎪⎨⎪⎪⎪⎪⎧teλit=a1(t)+2a2(t)λi+⋯+(k−1)ak−1(t)λik−2t2eλit=2a2(t)+6a3(t)λi+⋯+(k−1)(k−2)ak−1(t)λik−3⋮tk−1eλit=(k−1)!ak−1(t)
\n联立n 条方程求解有限项
\neAt=a0(t)I+a1(t)A+⋯+an−1An−1
\n试求矩阵A=⎣⎢⎡002103010⎦⎥⎤ 的矩阵指数，利用化为有限项法求解。
\n求解特征值∣λI−A∣=∣∣∣∣∣∣∣λ0−2−1λ−30−1λ∣∣∣∣∣∣∣=(λ+1)2(λ−2)，得到特征值为λ1,2=−1，λ3=2。
\n对于单根 λ3=2，有 e2t=a0(t)+2a1(t)+4a2(t)，
\n对于二重根λ1,2=−1，有 e−t=a0(t)−a1(t)+a2(t)，还需要补充方程：
\nte−t=a1(t)−2a2(t)
\n联立三组方程解得：
\n⎩⎪⎨⎪⎧a0(t)=91(e2t+8e−t+6te−t)a1(t)=91(2e2t−2e−t+3te−t)a3(t)=91(e2t−e−t−3te−t)
\neAt=a0(t)I+a1(t)A+⋯+an−1An−1=91⎣⎢⎡e2t+(8+6t)e−t2e2t−(2+6t)e−t4e2t+(6−4t)e−te2t−(2−3t)e−t4e2t+(5−3t)e−t8e2t+(3−8t)e−te2t−(1+3t)e−t2e2t−(2−3t)e−t4e2t+(5−3t)e−t⎦⎥⎤
\n动态系统在控制的作用下的运动称为受控运动。线性时不变系统非齐次状态方程的解即为线性时不变系统的受控运动。考虑系统 x˙(t)=Ax(t)+Bu(t),x(0),t≥0，其动态响应形式为：
\nx(t)=eA(t−t0)x(t0)+∫t0teA(t−τ)Bu(τ)dτ,t≥0(8)
\n可理解为由两部分组成：一部分是由初始状态引起的系统自由运动，即零输入响应；另外一部分是由控制输入所产生的受控运动，即零状态响应。
\n对于系统x˙(t)=Ax(t)+Bu(t),x(0),t≥0，左乘e−At 后求导可得：
\ndtd[e−Atx(t)]=e−At[x˙(t)−Ax(t)]=e−AtBu(t)
\n两边积分得：
\n∫0t{dtd[e−Atx(t)]}dτ=∫0te−AtBu(t)dτ
\ne−Atx(t)−x(0)I=∫0te−AtBu(t)dτ
\nx(t)=eA(t−t0)x(t0)+∫t0teA(t−τ)Bu(τ)dτ,t≥0
\n在线性时不变系统解 x(t)=eA(t−t0)x(t0)+∫t0teA(t−τ)Bu(τ)dτ,t≥0 中，定义状态转移矩阵Φ(t,t0)=eA(t−t0)。
\n对于线性连续系统的状态方程：x˙(t)=A(t)x(t)+B(t)u(t),x(t0)=x0,A(t)∈Rn×n，那么称满足以下矩阵方程的解Φ(t,t0) 为系统的状态转移矩阵。
\nΦ˙(t,t0)=A(t)Φ(t,t0),Φ(t0,t0)=I,t≥t0(9)
\n线性连续系统的时间离散化问题本质上就是在一定的采样方式和保持方式下，由系统的连续时间状态空间描述来得到对应的离散时间状态空间描述，并建立两者的系数矩阵间的关系式。
\n考虑以下线性时变系统：x˙(t)=A(t)x(t)+B(t)u(t)，当采样周期T 较小且精度要求不高时，可将其离散化为：
\nx˙(kT)≈T1[x((k+1)T)−x(kT)](10)
\n令t=kT，有
\nT1[x((k+1)T)−x(kT)]=A(kT)x(kT)+B(kT)u(kT)
\nx[(k+1)T]=[I+TA(kT)]x(kT)+TB(kT)u(kT)=G(kT)x(kT)+H(kT)u(kT)
\n其中，G(kT)=I+TA(kT)，H(kT)=TB(kT)。
\n注：一般而言，当采样周期为系统最小时间系数的101 左右，近似度已经足够。
\n系统的状态方程为x˙(t)=A(t)x(t)+B(t)u(t)，其中A(t)=[005(1−e−5t)5(e−5t−1)]，B(t)=[505e−5t5(1−e−5t)]。试求采样周期为T=0.2s 时的离散状态方程。
\n直接代入公式有：
\nG(kT)=I+TA(kT)=[101−e−ke−k]
\nH(kT)=TB(kT)=[10e−k1−e−k]
\n那么，离散状态方程为：x[(k+1)T]=G(kT)x(kT)+H(kT)u(kT)
\n将状态方程x˙=[0−21−3]x+[01]u 近似离散化，T=0.2s。
\n由题：G=I+TA=[1001]+0.2[0−21−3]=[1−0.40.20.4]，H=0.2[01]=[00.2]。
\n故离散状态方程为：
\n$x[0.2(k+1)]=\\begin{bmatrix}1&0.2\\\\-0.4&0.4\\end{bmatrix}x(0.2k)+\\begin{bmatrix}0\\\\0.2\\end{bmatrix}u(0.2k)$\n\n在线性时不变系统中，x˙(t)=A(x)+B(u)，其时间离散化状态方程为：
\nx[(k+1)T]=Gx(kT)+Hu(kT)(11)
\n其中G=eAT，H=(∫0TeATdt)B。假设条件为：(1) 等采样周期T；(2)u(t)≡u(kT),kT≤t≤(k+1)T。
\n对于线性时不变系统 x˙(t)=A(x)+B(u)，其状态方程的解为：
\nx(t)=eA(t−t0)x(t0)+∫eA(t−τ)Bu(τ)dτ(12)
\n假设：(1) 等采样周期T；(2)x(k)=[x(t)]t=kT，u(k)=[u(t)]_
\n那么令 t=(k+1)T，t0=kT，有：
\nx[(k+1)T]=eATx(kT)+∫kT(k+1)TeA[(k+1)T−τ]Bu(τ)dτ=eATx(kT)+∫kT(k+1)TeA[(k+1)T−τ]Bdτ⋅u(kT)
\n令 t=(k+1)T−τ，dτ=−dt，有：
\nx[(k+1)T]=eATx(kT)+∫0τeA(t)Bdt⋅u(kT)=eATx(kT)+∫0τeA(t)dt⋅Bu(kT)
\n令G=eAT，H=(∫0TeATdt)B，有线性时不变系统的离散状态方程为：
\nx[(k+1)T]=Gx(kT)+Hu(kT)
\n将状态方程x˙=[001−2]x+[01]u 离散化，T=0.1s。
\n利用拉氏变换法求解矩阵指数函数。取拉氏变换有：
\n[sI−A]−1=[s0−1s+2]−1=[s10s(s+2)1s+21]
\n取拉氏逆变换得到矩阵指数函数：
\neAt=L−1[sI−A]−1=[100.5(1−e−2T)e−2T]
\n进而求解系数矩阵：
\nG=eAT=[100.5(1−e−2T)e−2T]=[100.0910.819]
\nH=(∫0TeATdt)B=[∫0T[100.5(1−e−2T)e−2T]dt][01]=[T00.5T+0.25e−2T−0.25−0.5e−2T+0.5][01]=[0.0050.091]
\n故时间离散化状态方程为：
\nx[0.1(k+1)]=[100.0910.819]x(0.1k)+[0.0050.091]u(0.1k)
\n离散系统的差分方程形状态方程有两种解法：递推法和 z 变换法。其中递推法在时变系统和时不变系统中都适用，而 z 变换法只适用于时不变系统。
\n⎩⎪⎪⎪⎪⎨⎪⎪⎪⎪⎧x(1)=G(0)x(0)+H(0)u(0)x(2)=G(1)x(1)+H(1)u(1)x(3)=G(2)x(2)+H(2)u(2)⋮
\n给定初始条件x(0) 和输入序列u(0),u(1),⋯ 后即可求解x(k)。
\nx(k)=Gkx(0)+i=0∑k−1Gk−1−iHu(i)(13)
\n上式称为线性时不变离散系统的状态转移方程，其中Φ(k)=Gk 称为线性时不变离散系统的状态转移矩阵。
\n状态转移矩阵的性质：
\n考虑时不变离散系统：x(k+1)=Gx(k)+Hu(k)，取 z 变换有：
\nzx(z)−zx(0)=Gx(z)+Hu(z)
\nz(z)=(zI−G)−1zx(0)+(zI−G)−1Hu(z)(14)
\n取 z 逆变换有：
\nx(k)=z−1[(zI−G)−1z]x(0)+z−1[(zI−G)−1Hu(z)](15)
\n对比公式（13）和公式（15），由解的唯一性可知，
\nz−1[(zI−G)−1z]=Gk(16)
\nz−1[(zI−G)−1Hu(z)]=i=0∑k−1Gk−1−iHu(i)(17)
\n考虑离散系统：x(k+1)=Gx(k)+Hu(k)，其中G=[0−0.161−1]，H=[11]，初始条件为x(0)=[1−1]，试求当u(k)=1 时状态方程的解。
\n用 z 变换法求解，先计算(zI−G)−1，有
\n(zI−G)−1=[z0.16−1z+1]−1=(z+0.2)(z+0.8)1[z+1−0.161z]=[34×z+0.21−31×z+0.81−30.8×z+0.21+30.8×z+0.8135×z+0.21−35×z+0.81−31×z+0.21+34×z+0.81]
\n由于u(k)=1，则u(z)=z−1z，故zx(0)+Hu(z)=[z−z]+[z−1zz−1z]=[z−1z2z−1−z2+2z]。
\n那么代入公式（15）有：
\nx(z)=(zI−G)−1[zx(0)+Hu(z)]=[−617×z+0.2z+922×z+0.8z+1825×z−1z63.4×z+0.2z−917.6×z+0.8z+187×z−1z]
\n求 z 逆变换有：
\nx(k)=[−617(−0.2)k+922(−0.8)k+182563.4(−0.2)k−917.6(−0.2)k+187]
\n基于动态自编码网络的电池故障检测
\n\n
Article link: Realistic fault detection of li-ion battery via dynamical deep learning (nature.com)
\nlocal link: Realistic fault detection of li-ion battery via dynamical deep learning
\nDate: 2023-10-09
\n\t文章针对当前电池动力电池数据的隐私以及成本问题，提出了一种现实可应用的深度学习框架模型（动态自编码异常检测，Dynamical autoencoder for Anomaly Detection, DyAD ），并且公布了 347 个电动汽车的 690000 个锂电池充电片段数据。
\n\t此前研究面临的问题主要有：（1）传统的数据使用方法（温度、电压的方差等）难以辨认异常与正常汽车，数据关联性表现较弱，ROC 在 0.5 左右；（2）数据直接上传容易泄露，用户隐私难以保护；为此，文章提出了一种可大规模使用的定制深度学习框架。
\n\t不直接上传用户的各项直接数据，而是将用户数据分为系统输入（电流，SOC）和系统响应（电压，温度）两部分，而后在充电站部署编码器，编码器学习系统输入到系统响应的映射关系，编码后的数据上传到云端经过解码后对电动汽车的异常是否做出检测。通过编码 - 解码架构避免了用户的隐私和厂商的模型细节泄露。
\n\t问题 1：传统的深度学习方法通过研究数据分布来检测异常，对不常见的数据表现出较差的检测效果（如恒流充电数据，可能会被误判为正常电池）。
\n\t解决方法：在自编码 - 解码器中，编码器保持不变，编码器学习系统输入和系统响应的映射关系后得到潜在变量；而解码器不再仅仅利用潜在变量进行解码，而是通过潜在变量以及系统输入进行解码。具体理解如下：编码器学习到系统输入与系统响应的映射关系，那么可以用y=f(x) 来表示这一过程，其中y 是系统响应，x 是系统输入，而编码器正是通过x 和y 学习到映射函数f。传统方法便是将f 得到的潜在变量直接做出检测。然而本文构造了一个解码器f1 来模型物理系统，通过系统输入x 重构了系统响应y1=f1(x), 对比真实响应y 和重构响应y1 得到重构误差损失。其次通过里程进行弱监督从而引入辅助损失，引入 KL 正则化防止过拟合。三个损失函数共同影响模型的训练过程以及样本的异常情况。
\n\t模型包含了三组参数，分别是编码器参数θ，解码器参数ζ 和多感知机头部参数ξ，前两组参数均通过图卷积神经网络参数化得到。三个损失函数分别定义为：lrecon.，lreg.，lmileage。
\n数据集以及代码的连接如下：Code with datasets
\n数据可视化处理过程代码下载链接。
\n从代码角度来看，这个代码写的太牛辣。那我们就来好好欣赏一下这优雅的代码吧。
\n", "tags": [ "论文文献阅读" ] }, { "id": "https://hny1216.github.io/2023/10/21/2023-10-21-%E6%8E%A7%E5%88%B6%E7%B3%BB%E7%BB%9F%E7%9A%84%E7%8A%B6%E6%80%81%E7%A9%BA%E9%97%B4%E6%8F%8F%E8%BF%B0/", "url": "https://hny1216.github.io/2023/10/21/2023-10-21-%E6%8E%A7%E5%88%B6%E7%B3%BB%E7%BB%9F%E7%9A%84%E7%8A%B6%E6%80%81%E7%A9%BA%E9%97%B4%E6%8F%8F%E8%BF%B0/", "title": "02 控制系统的状态空间描述", "date_published": "2023-10-20T16:00:00.000Z", "content_html": "现代控制理论 ——02 控制系统的状态空间描述
\n\n
{x˙=Ax+Buy=Cx+Du(1)
\n其中，u=Rr 为输入向量；y=Rm 为输出向量；x∈Rn 为状态向量。A,B,C,D 为系数矩阵。
\n{x˙=A(t)x+B(t)uy=C(t)x+D(t)u(2)
\n{x(k+1)=A(k)x(k)+B(k)u(k)y(k)=C(k)x(k)+D(k)u(k)(3)
\n对于一个状态方程{x˙=Ax+Buy=Cx，选择非奇异矩阵P∈Rn×n 作为变换阵，有x=Px，那么此时状态方程可表示为：
\nx˙=P−1x˙=P−1[Ax+Bu]=P−1APx+P−1Bu=Ax+Bu(4)
\ny=Cx=CP\\overline{x}=\\overline{C}\\overline{x} \\tag{5}$$、】\n\n\n\n4\n\n其中，$\\overline{A}=P^{-1}AP,\\overline{B}=P^{-1}B,\\overline{C}=CP$。\n\n因此当状态变量 $x$ 改变时，一定存在变换矩阵 $P$ 使得状态方程发生变化。\n\n\n公式（1）是线性时不变系统状态空间表达式的一般形式。其系统方框图可表示如下：
\n![](\"/2023/10/21/2023-10-21-%E6%8E%A7%E5%88%B6%E7%B3%BB%E7%BB%9F%E7%9A%84%E7%8A%B6%E6%80%81%E7%A9%BA%E9%97%B4%E6%8F%8F%E8%BF%B0/01%E7%8A%B6%E6%80%81%E7%A9%BA%E9%97%B4%E7%B3%BB%E7%BB%9F%E6%A1%86%E5%9B%BE.png\")
![](\"/2023/10/21/2023-10-21-%E6%8E%A7%E5%88%B6%E7%B3%BB%E7%BB%9F%E7%9A%84%E7%8A%B6%E6%80%81%E7%A9%BA%E9%97%B4%E6%8F%8F%E8%BF%B0/02%E7%8A%B6%E6%80%81%E7%A9%BA%E9%97%B4%E5%8F%98%E9%87%8F%E5%9B%BE.png\")
设有三阶系统状态空间表达式如下，试绘制其状态变量图。
\n⎩⎪⎪⎪⎨⎪⎪⎪⎧x˙1=x2x˙2=x3x˙3=−6x1−3x2−2x3+uy=x1+x2
\n其状态变量图可绘制如下：
\n![](\"/2023/10/21/2023-10-21-%E6%8E%A7%E5%88%B6%E7%B3%BB%E7%BB%9F%E7%9A%84%E7%8A%B6%E6%80%81%E7%A9%BA%E9%97%B4%E6%8F%8F%E8%BF%B0/03%E7%8A%B6%E6%80%81%E7%A9%BA%E9%97%B4%E5%8F%98%E9%87%8F%E5%9B%BE.png\")
对于单输入单输出系统{x˙=Ax+Buy=Cx+Du，在零初始条件下其传递函数可表示为：
\ng(s)=U(s)Y(s)=C(sI−A)−1B+D(6)
\n在系统{x˙=Ax+Buy=Cx+Du 中，在零初始条件下取拉氏变换有：{sX(s)=AX(s)+BU(s)Y(s)=CX(s)+DU(s)，整理得到{X(s)=(sI−A)−1BU(s)Y(s)=C(sI−A)−1BU(s)+DU(s)，故g(s)=U(s)Y(s)=C(sI−A)−1B+D
\n在 D=0 时，g(s)=U(s)Y(s)=C(sI−A)−1B=∣sI−A∣Cadj(sI−A)B，其中adj(sI−A) 表示矩阵sI−A 的伴随矩阵。
\n对比自控原理中传递函数的表达式：g(s)=sn+a1sn−1+⋯+an−1s+anb0sn+b1sn−1+⋯+bn−1s+bn，可知：
\n对于同一系统，选择两个不同的状态向量 x∈Rn 和 x∈Rn 分别得到不同的状态空间描述：
\n{x˙=Ax+Buy=Cx+Du{x˙=Ax+Buy=Cx+Du
\n两种状态变量一定存在着可逆变化关系：x=Px，故：
\n{x˙=Ax+Buy=Cx+Du⇒{Px˙=APx+Buy=CPx+Du⇒{x˙=P−1APx+P−1Buy=CPx+Du
\n故 A=P−1AP，所以矩阵 A 与矩阵 A 相似，故特征值相同。
\n相似矩阵具体相同的特征值
\n对于多输入多输出系统，输入向量u=[u1⋯up]T，输出向量y=[y1…yq]T。我们把第i 个输出yi 和第j 个输入uj 间的传递函数定义为：gij(s)=Uj(s)Yi(s)。故系统的输入输出关系可表示为：
\n⎣⎢⎢⎢⎢⎡Y1(s)Y2(s)⋮Yq(s)⎦⎥⎥⎥⎥⎤=⎣⎢⎢⎢⎢⎡g11(s)g21(s)⋮gq1(s)g12(s)g22(s)⋮gq2(s)⋯⋯⋱⋯g1p(s)g2p(s)⋮gqp(s)⎦⎥⎥⎥⎥⎤⎣⎢⎢⎢⎢⎡U1(s)U2(s)⋮Uq(s)⎦⎥⎥⎥⎥⎤
\n以矩阵的形式表示：Y(s)=G(s)U(s)，其中 G(s) 称为传递函数矩阵。
\n对于多输入多输出系统{x˙=Ax+Buy=Cx+Du，同样传递函数矩阵为：
\nG(s)=C(sI−A)−1B+D=∣sI−A∣Cadj(sI−A)B+D∣sI−A∣
\n已知系统动态方程为[x˙1x˙2]=[001−2][x1x2]+[1001][u1u2]，[y1y2]=[1001][x1x2]，试求系统的传递函数矩阵。
\n由题，G(s)=C(sI−A)−1B+D=[1001][s10s(s+2)1s+21][1001]=[s10s(s+2)1s+21]。
\n在单输入单输出线性时不变系统中，系统的输出与输入的关系可用如下高阶微分方程描述：
\ny(n)+a1y(n−1)+⋯+an−1y˙+any=b0u(m)+b1u(m−1)+⋯+bm−1u˙+bmu(7)
\n其中，m≤n。根据微分方程右侧是否含有输入函数的导数（即m 是否等于 0）分两种情况讨论。
\n若常微分方程中不含有输入函数的导数，即：y(n)+a1y(n−1)+⋯+an−1y˙+any=bmu。
\n那么可以选取状态变量：
\nx1=bm1y,x2=bm1y˙,⋯xn=bm1y(n−1)(8)
\n那么就可以得到状态方程（前n−1 条通过求导获得，最后一条通过原微分方程获得）：
\n⎩⎪⎪⎪⎪⎨⎪⎪⎪⎪⎧x˙1=x2x˙2=x3⋮x˙n=y(n)=−anx1−an−1x2−⋯−a1xn+u
\n输出方程为：y=bmx1。
\n以矩阵的形式可表示为：
\nx˙=⎣⎢⎢⎢⎢⎡0⋮0−an1⋮0−an−1⋯⋱⋯⋯0⋮1−a1⎦⎥⎥⎥⎥⎤x+⎣⎢⎢⎢⎢⎡00⋮1⎦⎥⎥⎥⎥⎤u(9)
\ny=[10⋯0]x(10)
\n形如公式（9）的状态空间模型称为能控标准型。即A 与b 可用以下形式表示：
\nA=⎣⎢⎢⎢⎢⎡0⋮0−an1⋮0−an−1⋯⋱⋯⋯0⋮1−a1⎦⎥⎥⎥⎥⎤,b=⎣⎢⎢⎢⎢⎡00⋮1⎦⎥⎥⎥⎥⎤
\n设系统的运动方程为：y(3)+5y¨+8y˙+6y=3u，试求其状态空间表达式。
\n选取状态变量x1=y,x2=y˙,x3=y¨，则有状态方程：
\n⎩⎪⎨⎪⎧x˙1=x2x˙2=x3x˙3=y(3)=−6x1−8x2−5x3+3u
\n输出方程为y=x1。
\n故状态空间表达式为：
\nx˙=⎣⎢⎡00−610−801−5⎦⎥⎤x+⎣⎢⎡003⎦⎥⎤u
\ny=[100]x
\n若常微分方程中含有输入函数的导数，即：y(n)+a1y(n−1)+⋯+an−1y˙+any=b0u(m)+b1u(m−1)+⋯+bm−1u˙+bmu。
\n选择状态变量：
\n⎩⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎧x1=y−β0ux2=x˙1−β1u=y˙−β0u˙−β1ux3=x˙2−β2u=y¨−β0u¨−β1u˙−β2u⋮xn=x˙n−1−βn−1u=y(n)−β0u(n−1)−β1u(n−2)−⋯−βn−2u˙−βn−1u(11)
\n其中参数β0,β1,⋯,βn 由下式决定：
\n⎣⎢⎢⎢⎢⎢⎢⎡β0β1β2⋮βn⎦⎥⎥⎥⎥⎥⎥⎤=⎣⎢⎢⎢⎢⎢⎢⎡1a1⋮an−1an01⋮an−2an−1⋯⋯⋱⋯⋯00⋮1a100⋮01⎦⎥⎥⎥⎥⎥⎥⎤⎣⎢⎢⎢⎢⎢⎢⎡b0b1b2⋮bn⎦⎥⎥⎥⎥⎥⎥⎤(12)
\n由（11）可得到状态方程：⎩⎪⎪⎪⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎪⎪⎪⎧x˙1=x2+β1ux˙2=x3+β2u⋮x˙n−1=xn+βn−1ux˙n=y(n)−β0u(u)−β1u(n−1)−⋯−βn−2u¨−βn−1u˙=−anx1−an−1x2−⋯−a1xn+βnu。
\n因此，状态空间表达式为：
\nx˙=⎣⎢⎢⎢⎢⎢⎢⎡00⋮0−an10⋮0−an−101⋮0−an−2⋯⋯⋱⋯⋯00⋮1−a1⎦⎥⎥⎥⎥⎥⎥⎤x+⎣⎢⎢⎢⎢⎢⎢⎡β0β1⋮βn−1βn⎦⎥⎥⎥⎥⎥⎥⎤u(13)
\ny=[10⋯0]x+β0u
\n后续的方法我们讨论的传递函数的分子多项式次数均小于分母多项式次数。因为对于实际系统，分子多项式次数总是小于或等于分母多项式次数，在次数相等时可以通过化简的方法转化为分子多项式次数小于分母多项式次数。
\n若传递函数的分子多项式次数等于分母多项式次数，即
\ng(s)=sn+a1sn−1+⋯+an−1s+anb0sm+b1sm−1+⋯+bm−1s+bm,m=n
\n它总是可以化简为：
\ng(s)=sn+a1sn−1+⋯+an−1s+anb1sm−1+⋯+bm−1s+bm=g(s)+b0,m=n
\n其中 g(s) 为分子多项式次数小于分母多项式次数的传递函数，b0 为常数，整体视为两者的并联结构。
\n对于n 阶传递函数：g(s)=U(s)Y(s)=sn+a1sn−1+⋯+an−1s+anb1sn−1+⋯+bn−1s+bn。
\n同时除以sn 有：Y(s)=U(s)1+a1s−1+⋯+an−1s−(n−1)+ans−nb1s−1+⋯+bn−1s−(n−1)+bns−n。
\n令中间变量E(s)=U(s)1+a1s−1+⋯+an−1s−(n−1)+ans−n1，即E(s)=U(s)−a1s−1E(s)−⋯−an−1s−(n−1)E(s)−ans−nE(s)。
\n则输入U(s)、中间变量E(s) 和输出Y(s) 的关系流程图如下：
\n\n则Y(s)=b1s−1E(s)+b2s−2E(s)+⋯+bn−1s−(n−1)E(s)+bns−nE(s)。
\n令xn,xn−1,⋯,x1 为s−1E(s),s−2E(s),⋯,s−nE(s) 的拉氏逆变换，那么就可以绘制状态变量图并得到系统的状态空间表达式（能控标准型）。
\n\nx˙=⎣⎢⎢⎢⎢⎡0⋮0−an1⋮0−an−1⋯⋱⋯⋯0⋮1−a1⎦⎥⎥⎥⎥⎤x+⎣⎢⎢⎢⎢⎡0⋮01⎦⎥⎥⎥⎥⎤u(14)
\ny=[bnbn−1⋯b1]x
\n如果该n 阶系统传递函数的分子多项式次数等于分母多项式次数（在通过传递函数建立状态空间描述中讨论过该情况）即 g(s)=sn+a1sn−1+⋯+an−1s+anb1sm−1+⋯+bm−1s+bm=g(s)+b0,m=n，那么先算出 g(s) 后在输入到输出之间直接连接一个比例环节即可。
\n该方法适用于传递函数可分解为因式相乘的形式，即g(s)=(s−p1)(s−p2)…(s−pn)b1(s−z1)(s−z2)⋯(s−zn−1)。
\n以一个三阶系统进行说明：g(s)=(s−p1)(s−p2)(s−p3)b1(s−z1)(s−z2)。
\n上式中可分为两种：s−p1=1−s1ps1，s−ps−z=1+s−pp−z=1+(p−z)1−s1ps1。
\n因此系统可视为三个一阶系统串联而成，结构图如下：
\n\n取每个积分器的输出为状态变量，那么可以得到状态空间表达式如下：
\n⎩⎪⎪⎪⎨⎪⎪⎪⎧x˙1=p1x1+b1ux˙2=x1+p2x2x˙3=x1+(p2−z2)x2+p3x3y=x1+(p2−z2)x2+(p3−z3)x3
\n写成向量的形式为：
\nx˙=⎣⎢⎡p1110p2p2−z200p3⎦⎥⎤x+⎣⎢⎡b100⎦⎥⎤u(15)
\ny=[1p2−z2p3−z3]x
\n传递函数极点两两相异，则g(s)=(s−p1)(s−p2)…(s−pn)N(s)=s−p1c1+s−p2c2+⋯+s−pncn，其中ci=lims→pi(s−pi)g(s)。
\n选取状态变量 xi(s)=s−pi1U(s)，即 sxi(s)=pixi(s)+u(s)，做拉氏逆变换有：
\nx˙i(t)=pixi(t)+u(t)
\n输出 y(s)=g(s)u(s)=∑i=1ns−piciui(s)=∑i=1ncixi(s)，做拉氏逆变换有：
\ny(t)=i=1∑ncixi(t)
\n写成向量的形式为：
\nx˙=⎣⎢⎢⎢⎢⎡p10⋮00p2⋮0⋯⋯⋱⋯000pn⎦⎥⎥⎥⎥⎤x+⎣⎢⎢⎢⎢⎡11⋮1⎦⎥⎥⎥⎥⎤u(16)
\ny=[c1c2⋯cn]x
\n对于系统 {x˙=Ax+Buy=Cx ，若A 为对角阵且各元素为传递函数的极点，B 为全 1 矩阵，C 内各元素为对应极点的留数，那么称该矩阵表达式为对角标准型。
\n先考虑只有一个重极点和若干个单极点，重数为r，g(s)=(s−p1)rc11+(s−p1)r−1c12+⋯+(s−p1)c1r+s−pr+1cr+1+⋯+s−pncn，其中对于单极点仍有：ci=lims→pi(s−pi)g(s)，而对于重极点则有：c1j=(j−1)!1lims→p1dsj−1dj−1[(s−p1)g(s)],j=1,2,⋯,r。
\n选取状态变量，化简求拉氏逆变换得到状态方程：
\n⎩⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎧x1(s)=(s−p1)rU(s)x2(s)=(s−p1)r−1U(s)⋮xr(s)=(s−p1)U(s)xr+1(s)=s−pr+1U(s)⋮x1(s)=s−pnU(s)⇒⎩⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎧x1(s)=s−p11x2(s)x2(s)=s−p11x3(s)⋮xr(s)=s−p11U(s)xr+1(s)=s−pr+11U(s)⋮xn(s)=s−pn1U(s)⇒L−1⎩⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎧x˙1(t)=p1x1+x2x˙2(t)=p1x2+x3⋮x˙r(t)=p1xr+ux˙r+1(t)=pr+1xx+1+u⋮x˙n(t)=pnxn+u
\n输出方程的拉氏变换为：
\nY(s)=c11x1(s)+c12x2(s)+⋯+c1rxr(s)+cr+1xr+1(s)+⋯+cnxn(s)
\n求拉氏逆变换有：
\ny(t)=c11x1(t)+c12x2(t)+⋯+c1rxr(t)+cr+1xr+1(t)+⋯+cnxn(t)
\n得到状态空间表达式为：
\n⎣⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎡x1˙x2˙⋮xr˙xr+1˙⋮xn˙⎦⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎤=⎣⎢⎢⎢⎢⎢⎢⎢⎢⎢⎡p11p10⋱⋱1p1pr+10⋱pn⎦⎥⎥⎥⎥⎥⎥⎥⎥⎥⎤⎣⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎡x1x2⋮xrxr+1⋮xn⎦⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎤+⎣⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎡00⋮11⋮1⎦⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎤u(17)
\ny=[c11c12⋯c1rcr+1⋯cn]⎣⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎡x1x2⋮xrxr+1⋮xn⎦⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎤
\n对于重根部分，矩阵A 中对应的是若尔当块，B 中为一个只有末行是 1 其余行为 0 的矩阵，C 中对应元素为r 重极点对应的留数。而对于其中的单极点部分，形式与无重根时一致。
\n拓展到具有多个重极点的情况。矩阵A 中在对角上补充对应的若尔当块，B 中对应补充只有末行是 1 其余行为 0 的矩阵，C 中补充对应元素为r 重极点对应的留数。
\n在n 个子系统并联的并联系统中，组合系统的传递函数矩阵等于子系统传递函数矩阵的和。
\nG(s)=G1(s)+G2(s)+⋯+Gn(s)(18)
\n在n 个子系统串联的串联系统中，组合系统的传递函数矩阵等于子系统传递函数矩阵的积。
\nG(s)=Gn(s)⋯G2(s)G1(s)(19)
\n注：子系统传递函数矩阵的积遵循左乘原则。
\n对于系统 G1(s)，若添加反馈环节（动态反馈G2(s) 或常数反馈H），则可得到组合系统的传递函数矩阵：
\n组合系统的传递函数矩阵为：
\nG(s)=[I+G2(s)G1(s)]−1G1(s)(20)
\n组合系统的传递函数矩阵为：
\nG(s)=[I+HG1(s)]−1G1(s)(21)
\n对于一个状态方程{x˙=Ax+Buy=Cx+Du，选择非奇异矩阵P∈Rn×n 作为变换阵，有x=Px，那么此时状态方程可表示为：
\nx˙=P−1x˙=P−1[Ax+Bu]=P−1APx+P−1Bu=Ax+Bu(22)
\ny=Cx=CPx=Cx(23)
\n其中，A=P−1AP,B=P−1B,C=CP,D=D。
\n该方法通常用于将非对角阵A 转化为对角阵A，从而实现状态变量的解耦。
\n线性定常系统的系统矩阵 A 的特征值是表征系统的动力学特性的重要参量。系统的状态方程可通过适当的线性非奇异变换化为由特征值表征的标准形，对分析系统的结构特性非常直观。
\n