-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathatom.xml
241 lines (121 loc) · 312 KB
/
atom.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
<title>Cy</title>
<link href="https://cyccyyycyc.github.io/atom.xml" rel="self"/>
<link href="https://cyccyyycyc.github.io/"/>
<updated>2022-11-01T08:22:59.665Z</updated>
<id>https://cyccyyycyc.github.io/</id>
<author>
<name>Cy</name>
</author>
<generator uri="https://hexo.io/">Hexo</generator>
<entry>
<title>可信人脸识别分析by邓伟洪</title>
<link href="https://cyccyyycyc.github.io/2022/11/01/%E5%8F%AF%E4%BF%A1%E4%BA%BA%E8%84%B8%E8%AF%86%E5%88%AB%E5%88%86%E6%9E%90by%E9%82%93%E4%BC%9F%E6%B4%AA/"/>
<id>https://cyccyyycyc.github.io/2022/11/01/%E5%8F%AF%E4%BF%A1%E4%BA%BA%E8%84%B8%E8%AF%86%E5%88%AB%E5%88%86%E6%9E%90by%E9%82%93%E4%BC%9F%E6%B4%AA/</id>
<published>2022-11-01T06:41:23.000Z</published>
<updated>2022-11-01T08:22:59.665Z</updated>
<content type="html"><![CDATA[<p>Source:</p><p><a href="http://scl.sribd.cn/seminar/index.html">论坛网站</a>The 7th Lecture</p><h1 id="可信人脸识别分析"><a href="#可信人脸识别分析" class="headerlink" title="可信人脸识别分析"></a>可信人脸识别分析</h1><h2 id="引入"><a href="#引入" class="headerlink" title="引入"></a>引入</h2><h3 id="发展历程"><a href="#发展历程" class="headerlink" title="发展历程"></a>发展历程</h3><p>邓教授将人脸识别技术发展分为以下四个阶段：</p><ol><li>第一阶段是以PCA、LDA等为代表的全局性学习方法。把人脸图像视为特征向量，对变换后的特征向量进行模式分类。</li><li>第二阶段针对图像特点手工设计局部滤波器去学习与光线无关的局部特征，比前一类方法更鲁棒，但是无法应对光影明暗的变化。代表方法是LBP。</li><li>第三阶段引入机器学习来设计滤波器，所获得的特征不再是手工设计的，而是由机器自动学习出的具有辨别力的特征。</li><li>第四阶段将深度学习引入到人脸识别领域，性能大幅提升。其中，深度网络提取特征的过程与人类识别人脸的过程相似。早期的block提取图像的边缘信息，随着网络深度的增加，后期的block提取人脸中更高级的特征属性。</li></ol><h3 id="概述"><a href="#概述" class="headerlink" title="概述"></a>概述</h3><p>人脸识别作为一个经典问题，在现代生活中应用场景十分广泛。</p><ol><li>1:1身份认证</li><li>1:n比对排查</li></ol><p>人脸识别是一个特殊的分类问题。因为每个人就是一个类，地球上人口众多，对应类别也很多，所以常常采用0样本学习的方法，在小数据上学习人脸的特征，然后迁移到更大的数据场景下应用。</p><p>人的脸部可以包含两种信息:</p><ol><li>（表）身份identity</li><li>（里）表情、情绪、内心</li></ol><p>之前对于表情的研究，更多把表情视为离散而独立的6个类。而后来发现，表情特征是一个连续空间上的变化。</p><h2 id="精准性"><a href="#精准性" class="headerlink" title="精准性"></a>精准性</h2><p>良好的准确性是可信可靠的基础。在海量的人脸数据下，要想提高识别的精确度，面临两个问题：</p><ol><li>噪声的处理和过滤（很多图片的质量比较低）</li><li>实现无监督的学习（有许多无标注的数据）</li></ol><h3 id="噪声处理"><a href="#噪声处理" class="headerlink" title="噪声处理"></a>噪声处理</h3><h4 id="Long-tailed-learning"><a href="#Long-tailed-learning" class="headerlink" title="Long tailed learning"></a>Long tailed learning</h4><p>将数据分为head data和tail data，不同质量的数据，采用不同的处理方法，完成一个双流的训练过程</p><ol><li>对于head data，正常用来训练模型，提高模型性能。</li><li>tail data 数据量小且包含噪声。对于长尾、噪声数据，为其设计特殊的训练损失函数（基于度量学习），降噪以提高鲁棒性。</li></ol><h4 id="SFace-Method"><a href="#SFace-Method" class="headerlink" title="SFace-Method"></a>SFace-Method</h4><p>实验表明，若不特殊降噪处理，有时去掉tail data反而模型性能会上升。原因之一是模型overfit噪声导致性能下降，因此特别处理噪声数据，调整损失函数，利用sigmoid对梯度进行加权，屏蔽小梯度，提高模型鲁棒性。</p><h4 id="Dynamic-Training-Data-Dropout"><a href="#Dynamic-Training-Data-Dropout" class="headerlink" title="Dynamic Training Data Dropout"></a>Dynamic Training Data Dropout</h4><p>正常数据和噪声数据（标签错误）在训练过程中往往表现出不同的状态。噪声大往往优化慢，数据特征和标签之间的余弦相似度更小。由此可以从整个训练过程来观察，动态剔除拖慢训练的噪声数据。</p><h3 id="数据增广"><a href="#数据增广" class="headerlink" title="数据增广"></a>数据增广</h3><p>神经网络的训练实际上是拟合现在的数据分布，如果数据集不够庞大多样，那么再好的训练方法也只是拟合一个“错误”的分布，不能很好地提高模型性能。而人工标注的数据代价又十分高昂（拼不过企业），则考虑自动化收集和标注数据，自动进行数据增强。</p><h4 id="Close-loop-of-data-labeling-and-model-training"><a href="#Close-loop-of-data-labeling-and-model-training" class="headerlink" title="Close loop of data labeling and model training"></a>Close loop of data labeling and model training</h4><p><img src="/2022/11/01/%E5%8F%AF%E4%BF%A1%E4%BA%BA%E8%84%B8%E8%AF%86%E5%88%AB%E5%88%86%E6%9E%90by%E9%82%93%E4%BC%9F%E6%B4%AA/1.png" alt="1"></p><ol><li>使用少量已标记数据集预训练出一个基本的特征模型</li><li>让GCN学习到同类图像的特征之间的关系</li><li>将大量无标注数据输入到GCN，GCN可以自动判断这些数据的标签。</li></ol><p>GCN相当于一个过滤器，massive data经过GCN后成为labeled data。</p><p>前提：初始状态好（机器效果已经和人差不多了），经过迭代之后更强。</p><h2 id="鲁棒性"><a href="#鲁棒性" class="headerlink" title="鲁棒性"></a>鲁棒性</h2><p>negative pairs: similar looking</p><p>positive pairs: cross-aging, cross-poses…</p><h4 id="归一"><a href="#归一" class="headerlink" title="归一"></a>归一</h4><p>针对姿态变化的图像，设计归一化网络，归一化为正面图像（也可以归一化不同角度，借此来进行数据增强…）</p><h4 id="低分辨率"><a href="#低分辨率" class="headerlink" title="低分辨率"></a>低分辨率</h4><p>对于低分辨率的数据集，一种思路是利用SR超分辨率解决方法，提高数据集，但过高的分辨率往往会导致overfit。他们的实验表明，在人脸识别中，直接学习低分辨率的图片反而分类效果会更好。</p><ol><li>设计MR-GAN生成低分辨率图像，用于模拟监控所拍摄到的低分辨率图像。</li><li>运用跨步迁移，让高分辨和低分辨图像的特征分别靠近中间域，最终可以得到融合后的特征。</li></ol><h2 id="安全性"><a href="#安全性" class="headerlink" title="安全性"></a>安全性</h2><p>物理：硅胶面具（教授说还没解决，有时候这个连人都能骗过。但他自己的一篇工作rPPG“人脸的心跳”感觉可以解决一点？）</p><p>如果我们只基于现在的数据，那就只能预防过去的攻击，自然而然想到进行数据增广，提高泛化能力（学到未来的造假方式）</p><h4 id="Representative-Forgery-Mining-For-Fake-Face-Detection"><a href="#Representative-Forgery-Mining-For-Fake-Face-Detection" class="headerlink" title="Representative Forgery Mining For Fake Face Detection"></a>Representative Forgery Mining For Fake Face Detection</h4><p>根据注意力机制可以了解机器关注的fake face特征，利用随机遮挡把这个特征去掉，可以迫使机器寻找更多假脸特征，而不是只找到一个假脸原因就摆烂。</p><h4 id="rPPG"><a href="#rPPG" class="headerlink" title="rPPG"></a>rPPG</h4><p>一点生物学知识，部分光线会透过皮肤到达血管，血管会有反射信号，则视频中呈现的人脸有“心跳”信号。而假脸则无，由此可以借助真脸与假脸关于rPPG信号的差别来构造网络。</p><p>问题：</p><ol><li>缺少数据</li><li>攻击知道这个特征后，也可以人为构造有rPPG信号的假脸。</li></ol><h4 id="迁移攻击"><a href="#迁移攻击" class="headerlink" title="迁移攻击"></a>迁移攻击</h4><p>迁移攻击场景下，代理模型和远端模型越相似，则攻击成功率也一般相应越高。一个思路是，对本地模型多次使用dropout，模拟不同模型架构，根据本地模型构建一个具有更高泛化能力的对抗样本。</p><p>这样构建出的对抗样本往往具备更好的迁移性和泛化性，还可以用来做数据增强，进行对抗训练。</p><h4 id="防"><a href="#防" class="headerlink" title="防"></a>防</h4><p>对于对抗攻击，比较好的防御方法（目前相对）是对抗训练。</p><p>局限：</p><ol><li>滞后性。先有攻后有防。</li><li>对于小模型小数据，对抗训练会降低准确率。</li></ol><h2 id="公平性"><a href="#公平性" class="headerlink" title="公平性"></a>公平性</h2><p>公平性是个容易引发争议的伦理问题，但是对于公平性缺乏完善的评价指标。</p><h4 id="数据偏见"><a href="#数据偏见" class="headerlink" title="数据偏见"></a>数据偏见</h4><p>不同数据集，人种、地域占比数量不同。对比度低往往容易受到噪声的影响，所以肤色不同客观上会导致一些结构不同。</p><p>但是他们经过实验，公平的数据集不一定可以获得好的结果，说明公平性还有其它影响因素。</p><h4 id="算法偏见"><a href="#算法偏见" class="headerlink" title="算法偏见"></a>算法偏见</h4><p>神经网络设计目标函数（损失函数）是为了提高精确性、鲁棒性等。如果往其中加入公平性的约束，可以取得比较好的效果。在实际的工作中，他们给不同的人种应用不同的参数，最终模型呈现出一个良好的公平性结果。</p><p>邓教授分别利用强化学习、元学习、迁移学习等消除bias</p><h5 id="迁移学习"><a href="#迁移学习" class="headerlink" title="迁移学习"></a>迁移学习</h5><p>不同数据集之间存在bias，有时分辨图片来自哪个数据集的准确率甚至高于图片本身的分类结果。一个思路是采用迁移学习实现原域到目标域的转换。</p><h2 id="Q-amp-A"><a href="#Q-amp-A" class="headerlink" title="Q&A"></a>Q&A</h2><h3 id="人脸识别上的对抗攻防"><a href="#人脸识别上的对抗攻防" class="headerlink" title="人脸识别上的对抗攻防"></a>人脸识别上的对抗攻防</h3><ol><li>对抗防御没有好方法，只有对抗训练</li><li>对抗攻击在人脸上研究不多，因为人脸是一个零样本问题，而非分类问题。</li></ol><h3 id="表情"><a href="#表情" class="headerlink" title="表情"></a>表情</h3><p>问题：</p><ol><li>没有好的数据集</li><li>主观性强</li><li>相对来说效果有待提高</li></ol>]]></content>
<summary type="html"><p>Source:</p>
<p><a href="http://scl.sribd.cn/seminar/index.html">论坛网站</a>The 7th Lecture</p>
<h1 id="可信人脸识别分析"><a href="#可信人脸识别分析" class="</summary>
<category term="AISP" scheme="https://cyccyyycyc.github.io/categories/AISP/"/>
</entry>
<entry>
<title>LeetCode-0</title>
<link href="https://cyccyyycyc.github.io/2022/10/27/LeetCode-0/"/>
<id>https://cyccyyycyc.github.io/2022/10/27/LeetCode-0/</id>
<published>2022-10-27T11:52:43.000Z</published>
<updated>2022-11-11T11:37:43.339Z</updated>
<content type="html"><![CDATA[<p>简单题</p><h1 id="two-sum"><a href="#two-sum" class="headerlink" title="two-sum"></a><a href="https://leetcode.cn/problems/two-sum/">two-sum</a></h1><p>给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。</p><p>你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。</p><p>你可以按任意顺序返回答案。</p><p>例如：</p><p>输入：nums = [2,7,11,15], target = 9<br>输出：[0,1]<br>解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。</p><h2 id="遍历"><a href="#遍历" class="headerlink" title="遍历"></a>遍历</h2><p>空间复杂度O(n)<br>时间复杂度O(n)</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">twoSum</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>], target: <span class="built_in">int</span></span>) -> <span class="type">List</span>[<span class="built_in">int</span>]:</span><br><span class="line"> <span class="built_in">dict</span> = {}</span><br><span class="line"> <span class="keyword">for</span> i, n <span class="keyword">in</span> <span class="built_in">enumerate</span>(nums):</span><br><span class="line"> x = target - n</span><br><span class="line"> <span class="keyword">if</span> x <span class="keyword">in</span> <span class="built_in">dict</span>:</span><br><span class="line"> <span class="keyword">return</span> [<span class="built_in">dict</span>[x], i]</span><br><span class="line"> <span class="keyword">else</span>:</span><br><span class="line"> <span class="built_in">dict</span>[n] = i</span><br></pre></td></tr></table></figure><h2 id="暴力"><a href="#暴力" class="headerlink" title="暴力"></a>暴力</h2><p>两层循环，时间复杂度O(n^2)<br>注意：不能考虑重复元素</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">twoSum</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>], target: <span class="built_in">int</span></span>) -> <span class="type">List</span>[<span class="built_in">int</span>]:</span><br><span class="line"> l = <span class="built_in">len</span>(nums)</span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(l):</span><br><span class="line"> <span class="keyword">for</span> j <span class="keyword">in</span> <span class="built_in">range</span>(i+<span class="number">1</span>, l, <span class="number">1</span>):</span><br><span class="line"> <span class="keyword">if</span> nums[i] + nums[j] == target:</span><br><span class="line"> <span class="keyword">return</span> [i, j]</span><br></pre></td></tr></table></figure><h1 id="删除元素"><a href="#删除元素" class="headerlink" title="删除元素"></a><a href="https://leetcode.cn/problems/remove-element/">删除元素</a></h1><p>给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。</p><p>不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。</p><p>元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。</p><h2 id="反向遍历POP"><a href="#反向遍历POP" class="headerlink" title="反向遍历POP"></a>反向遍历POP</h2><p>注意索引</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">removeElement</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>], val: <span class="built_in">int</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="built_in">len</span>(nums)-<span class="number">1</span>, -<span class="number">1</span>, -<span class="number">1</span>):</span><br><span class="line"> <span class="keyword">if</span>(nums[i] == val):</span><br><span class="line"> nums.pop(i)</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">len</span>(nums)</span><br></pre></td></tr></table></figure><h2 id="2"><a href="#2" class="headerlink" title="2"></a>2</h2><p>记录val值个数，一次循环，元素前移</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">removeElement</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>], val: <span class="built_in">int</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> k = <span class="number">0</span></span><br><span class="line"> l = <span class="built_in">len</span>(nums)</span><br><span class="line"> <span class="keyword">for</span> i, n <span class="keyword">in</span> <span class="built_in">enumerate</span>(nums):</span><br><span class="line"> nums[i-k] = nums[i]</span><br><span class="line"> <span class="keyword">if</span>(n==val):</span><br><span class="line"> k = k+<span class="number">1</span></span><br><span class="line"> <span class="keyword">return</span> l-k</span><br><span class="line"></span><br></pre></td></tr></table></figure><h2 id="双指针"><a href="#双指针" class="headerlink" title="双指针"></a>双指针</h2><p>l为新数组索引，r为原数组索引。</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">removeElement</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>], val: <span class="built_in">int</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> l = <span class="number">0</span></span><br><span class="line"> r = <span class="number">0</span></span><br><span class="line"> <span class="keyword">for</span> r <span class="keyword">in</span> <span class="built_in">range</span>(<span class="built_in">len</span>(nums)):</span><br><span class="line"> <span class="keyword">if</span>(nums[r]!=val):</span><br><span class="line"> nums[l]=nums[r]</span><br><span class="line"> l = l+<span class="number">1</span></span><br><span class="line"> <span class="keyword">return</span> l</span><br></pre></td></tr></table></figure><h2 id="count-amp-remove"><a href="#count-amp-remove" class="headerlink" title="count & remove"></a>count & remove</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">removeElement</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>], val: <span class="built_in">int</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> a = nums.count(val) <span class="comment"># 计算数组nums中val值的个数</span></span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(a):</span><br><span class="line"> nums.remove(val)</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">len</span>(nums)</span><br></pre></td></tr></table></figure><h2 id="index-amp-del"><a href="#index-amp-del" class="headerlink" title="index & del"></a>index & del</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">removeElement</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>], val: <span class="built_in">int</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">while</span> val <span class="keyword">in</span> nums:</span><br><span class="line"> <span class="keyword">del</span> nums[nums.index(val)]</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">len</span>(nums)</span><br></pre></td></tr></table></figure><h1 id="存在重复元素"><a href="#存在重复元素" class="headerlink" title="存在重复元素"></a><a href="https://leetcode.cn/problems/contains-duplicate/">存在重复元素</a></h1><p>给你一个整数数组 <code>nums</code> 。如果任一值在数组中出现 <strong>至少两次</strong> ，返回 <code>true</code> ；如果数组中每个元素互不相同，返回 <code>false</code> 。</p><h2 id="set"><a href="#set" class="headerlink" title="set()"></a>set()</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">containsDuplicate</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="built_in">bool</span>:</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">len</span>(nums)!=<span class="built_in">len</span>(<span class="built_in">set</span>(nums))</span><br></pre></td></tr></table></figure><h1 id="删除有序数组中的重复项"><a href="#删除有序数组中的重复项" class="headerlink" title="删除有序数组中的重复项"></a><a href="https://leetcode.cn/problems/remove-duplicates-from-sorted-array">删除有序数组中的重复项</a></h1><p>删除有序数组中的重复项</p><p>给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。</p><p>由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。</p><p>将最终结果插入 nums 的前 k 个位置后返回 k 。</p><p>不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。</p><h2 id="倒序POP"><a href="#倒序POP" class="headerlink" title="倒序POP"></a>倒序POP</h2><p>注意索引</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">removeDuplicates</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="built_in">len</span>(nums)-<span class="number">1</span>, <span class="number">0</span>, -<span class="number">1</span>):</span><br><span class="line"> <span class="keyword">if</span> (nums[i] == nums[i-<span class="number">1</span>]):</span><br><span class="line"> nums.pop(i)</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">len</span>(nums)</span><br></pre></td></tr></table></figure><h2 id="快慢指针"><a href="#快慢指针" class="headerlink" title="快慢指针"></a>快慢指针</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">removeDuplicates</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> fast = <span class="number">1</span></span><br><span class="line"> slow = <span class="number">0</span></span><br><span class="line"> <span class="keyword">while</span>(fast < <span class="built_in">len</span>(nums)):</span><br><span class="line"> <span class="keyword">if</span>(nums[fast] != nums[slow]):</span><br><span class="line"> slow = slow + <span class="number">1</span></span><br><span class="line"> nums[slow] = nums[fast]</span><br><span class="line"> fast = fast + <span class="number">1</span></span><br><span class="line"> <span class="keyword">return</span> slow+<span class="number">1</span></span><br></pre></td></tr></table></figure><h1 id="数组中的重复数字"><a href="#数组中的重复数字" class="headerlink" title="数组中的重复数字"></a><a href="https://leetcode.cn/problems/shu-zu-zhong-zhong-fu-de-shu-zi-lcof/">数组中的重复数字</a></h1><p>找出数组中重复的数字。</p><p>在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。</p><h2 id="哈希字典"><a href="#哈希字典" class="headerlink" title="哈希字典"></a>哈希字典</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">findRepeatNumber</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> dic = <span class="built_in">set</span>() </span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">0</span>, <span class="built_in">len</span>(nums), <span class="number">1</span>):</span><br><span class="line"> <span class="keyword">if</span> nums[i] <span class="keyword">in</span> dic:</span><br><span class="line"> <span class="keyword">return</span> nums[i]</span><br><span class="line"> <span class="keyword">else</span>:</span><br><span class="line"> dic.add(nums[i])</span><br><span class="line"> <span class="keyword">return</span> -<span class="number">1</span></span><br></pre></td></tr></table></figure><h2 id="原地交换"><a href="#原地交换" class="headerlink" title="原地交换"></a>原地交换</h2><p>数组长度为n，数字范围在[0, n-1]，且有数字重复。所以可以调整索引数值一一对应，当发生冲突则返回。</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">findRepeatNumber</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> i = <span class="number">0</span></span><br><span class="line"> <span class="keyword">while</span> i < <span class="built_in">len</span>(nums):</span><br><span class="line"> <span class="keyword">if</span> nums[i] != i:</span><br><span class="line"> <span class="keyword">if</span> nums[nums[i]] == nums[i]:</span><br><span class="line"> <span class="keyword">return</span> nums[i]</span><br><span class="line"> nums[nums[i]], nums[i] = nums[i], nums[nums[i]]</span><br><span class="line"> <span class="keyword">else</span>:</span><br><span class="line"> i += <span class="number">1</span></span><br><span class="line"> <span class="keyword">return</span> -<span class="number">1</span></span><br></pre></td></tr></table></figure><h1 id="独苗"><a href="#独苗" class="headerlink" title="独苗"></a><a href="https://leetcode.cn/problems/single-number/">独苗</a></h1><p>给定一个<strong>非空</strong>整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。</p><h2 id="异或"><a href="#异或" class="headerlink" title="异或"></a>异或</h2><ol><li>任何数和 0 做异或运算，结果仍然是原来的数，即 a⊕0=a。</li><li>任何数和其自身做异或运算，结果是 0，即a⊕a=0。</li><li>异或运算满足交换律。</li></ol><p>因此，把所有数值做异或运算即可得到结果。</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">singleNumber</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> ans = <span class="number">0</span></span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="built_in">len</span>(nums)):</span><br><span class="line"> ans = ans ^ nums[i]</span><br><span class="line"> <span class="keyword">return</span> ans</span><br></pre></td></tr></table></figure><h1 id="查找目标值"><a href="#查找目标值" class="headerlink" title="查找目标值"></a><a href="https://leetcode.cn/problems/binary-search/">查找目标值</a></h1><p>给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。</p><h2 id="二分"><a href="#二分" class="headerlink" title="二分"></a>二分</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">search</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>], target: <span class="built_in">int</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> l, r = <span class="number">0</span>, <span class="built_in">len</span>(nums)-<span class="number">1</span></span><br><span class="line"> <span class="keyword">while</span> l <= r:</span><br><span class="line"> m = (l+r)//<span class="number">2</span></span><br><span class="line"> <span class="keyword">if</span> target == nums[m]:</span><br><span class="line"> <span class="keyword">return</span> m</span><br><span class="line"> <span class="keyword">elif</span> target>nums[m]:</span><br><span class="line"> l = m + <span class="number">1</span></span><br><span class="line"> <span class="keyword">else</span>:</span><br><span class="line"> r = m - <span class="number">1</span></span><br><span class="line"> <span class="keyword">return</span> -<span class="number">1</span></span><br></pre></td></tr></table></figure><h2 id="List-index"><a href="#List-index" class="headerlink" title="List.index()"></a>List.index()</h2><p>这个耗时还少，赢麻了</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">search</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>], target: <span class="built_in">int</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">try</span>:</span><br><span class="line"> <span class="keyword">return</span> nums.index(target)</span><br><span class="line"> <span class="keyword">except</span> ValueError:</span><br><span class="line"> <span class="keyword">return</span> -<span class="number">1</span></span><br></pre></td></tr></table></figure><h1 id="下一个更大"><a href="#下一个更大" class="headerlink" title="下一个更大"></a><a href="https://leetcode.cn/problems/next-greater-element-i/">下一个更大</a></h1><p>nums1 中数字 x 的 下一个更大元素 是指 x 在 nums2 中对应位置 右侧 的 第一个 比 x 大的元素。</p><p>给你两个 没有重复元素 的数组 nums1 和 nums2 ，下标从 0 开始计数，其中nums1 是 nums2 的子集。</p><p>对于每个 0 <= i < nums1.length ，找出满足 nums1[i] == nums2[j] 的下标 j ，并且在 nums2 确定 nums2[j] 的 下一个更大元素 。如果不存在下一个更大元素，那么本次查询的答案是 -1 。</p><p>返回一个长度为 nums1.length 的数组 ans 作为答案，满足 ans[i] 是如上所述的 下一个更大元素 。</p><h2 id="暴力-1"><a href="#暴力-1" class="headerlink" title="暴力"></a>暴力</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">nextGreaterElement</span>(<span class="params">self, nums1: <span class="type">List</span>[<span class="built_in">int</span>], nums2: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="type">List</span>[<span class="built_in">int</span>]:</span><br><span class="line"> ans = []</span><br><span class="line"> <span class="keyword">for</span> n <span class="keyword">in</span> nums1:</span><br><span class="line"> i = nums2.index(n)</span><br><span class="line"> <span class="keyword">for</span> j <span class="keyword">in</span> <span class="built_in">range</span>(i, <span class="built_in">len</span>(nums2)):</span><br><span class="line"> <span class="keyword">if</span> nums2[j] > n:</span><br><span class="line"> ans.append(nums2[j])</span><br><span class="line"> <span class="keyword">break</span></span><br><span class="line"> <span class="keyword">if</span> j == <span class="built_in">len</span>(nums2)-<span class="number">1</span>:</span><br><span class="line"> ans.append(-<span class="number">1</span>)</span><br><span class="line"> <span class="keyword">return</span> ans</span><br></pre></td></tr></table></figure><h2 id="单调栈"><a href="#单调栈" class="headerlink" title="单调栈"></a>单调栈</h2><p>从后往前遍历nums2，当栈顶元素比当前值小则出栈，保证栈顶为最近的大元素。</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">nextGreaterElement</span>(<span class="params">self, nums1: <span class="type">List</span>[<span class="built_in">int</span>], nums2: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="type">List</span>[<span class="built_in">int</span>]:</span><br><span class="line"> res = {}</span><br><span class="line"> st = []</span><br><span class="line"> <span class="keyword">for</span> num <span class="keyword">in</span> <span class="built_in">reversed</span>(nums2):</span><br><span class="line"> <span class="keyword">while</span> st <span class="keyword">and</span> num >= st[-<span class="number">1</span>]:</span><br><span class="line"> st.pop()</span><br><span class="line"> res[num] = st[-<span class="number">1</span>] <span class="keyword">if</span> st <span class="keyword">else</span> -<span class="number">1</span></span><br><span class="line"> st.append(num)</span><br><span class="line"> <span class="keyword">return</span> [res[num] <span class="keyword">for</span> num <span class="keyword">in</span> nums1]</span><br></pre></td></tr></table></figure><h1 id="消失的数字"><a href="#消失的数字" class="headerlink" title="消失的数字"></a><a href="https://leetcode.cn/problems/que-shi-de-shu-zi-lcof/">消失的数字</a></h1><p>一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。</p><h2 id="暴力-2"><a href="#暴力-2" class="headerlink" title="暴力"></a>暴力</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">missingNumber</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="built_in">len</span>(nums)):</span><br><span class="line"> <span class="keyword">if</span> i != nums[i]:</span><br><span class="line"> <span class="keyword">return</span> i</span><br><span class="line"> <span class="keyword">return</span> i + <span class="number">1</span></span><br></pre></td></tr></table></figure><h2 id="计算"><a href="#计算" class="headerlink" title="计算"></a>计算</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">missingNumber</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">sum</span>(<span class="built_in">range</span>(<span class="built_in">len</span>(nums) + <span class="number">1</span>)) - <span class="built_in">sum</span>(nums)</span><br></pre></td></tr></table></figure><h1 id="插入的位置"><a href="#插入的位置" class="headerlink" title="插入的位置"></a><a href="https://leetcode.cn/problems/search-insert-position">插入的位置</a></h1><p>给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。</p><p>请必须使用时间复杂度为 O(log n) 的算法。</p><h2 id="顺序查找"><a href="#顺序查找" class="headerlink" title="顺序查找"></a>顺序查找</h2><p>时间复杂度O(n)</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">searchInsert</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>], target: <span class="built_in">int</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">for</span> i, n <span class="keyword">in</span> <span class="built_in">enumerate</span>(nums):</span><br><span class="line"> <span class="keyword">if</span>(target <= n):</span><br><span class="line"> <span class="keyword">return</span> i</span><br><span class="line"> <span class="keyword">return</span> i+<span class="number">1</span></span><br></pre></td></tr></table></figure><h2 id="二分查找"><a href="#二分查找" class="headerlink" title="二分查找"></a>二分查找</h2><p>时间复杂度为 O(log n) </p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">searchInsert</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>], target: <span class="built_in">int</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> l, r = <span class="number">0</span>, <span class="built_in">len</span>(nums) - <span class="number">1</span></span><br><span class="line"> <span class="keyword">while</span>(l <= r):</span><br><span class="line"> mid = (l+r)//<span class="number">2</span></span><br><span class="line"> <span class="keyword">if</span>(nums[mid]>target):</span><br><span class="line"> r = mid - <span class="number">1</span></span><br><span class="line"> <span class="keyword">elif</span> (nums[mid]<target):</span><br><span class="line"> l = mid + <span class="number">1</span></span><br><span class="line"> <span class="keyword">else</span>:</span><br><span class="line"> <span class="keyword">return</span> mid</span><br><span class="line"> <span class="keyword">return</span> l</span><br></pre></td></tr></table></figure><h1 id="最小的k个数"><a href="#最小的k个数" class="headerlink" title="最小的k个数"></a><a href="https://leetcode.cn/problems/zui-xiao-de-kge-shu-lcof/">最小的k个数</a></h1><p>输入整数数组 <code>arr</code> ，找出其中最小的 <code>k</code> 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。</p><h2 id="sorted"><a href="#sorted" class="headerlink" title="sorted()"></a>sorted()</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">getLeastNumbers</span>(<span class="params">self, arr: <span class="type">List</span>[<span class="built_in">int</span>], k: <span class="built_in">int</span></span>) -> <span class="type">List</span>[<span class="built_in">int</span>]:</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">sorted</span>(arr)[:k]</span><br></pre></td></tr></table></figure><h2 id="heap"><a href="#heap" class="headerlink" title="heap"></a>heap</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">getLeastNumbers</span>(<span class="params">self, arr: <span class="type">List</span>[<span class="built_in">int</span>], k: <span class="built_in">int</span></span>) -> <span class="type">List</span>[<span class="built_in">int</span>]:</span><br><span class="line"> heapq.heapify(arr)</span><br><span class="line"> ans = []</span><br><span class="line"> <span class="keyword">while</span> k:</span><br><span class="line"> ans.append(arr[<span class="number">0</span>])</span><br><span class="line"> heapq.heappop(arr)</span><br><span class="line"> k -= <span class="number">1</span></span><br><span class="line"> <span class="keyword">return</span> ans</span><br></pre></td></tr></table></figure><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">getLeastNumbers</span>(<span class="params">self, arr: <span class="type">List</span>[<span class="built_in">int</span>], k: <span class="built_in">int</span></span>) -> <span class="type">List</span>[<span class="built_in">int</span>]:</span><br><span class="line"> <span class="keyword">return</span> heapq.nsmallest(k,arr)</span><br><span class="line"></span><br></pre></td></tr></table></figure><h1 id="旋转数组的最小数字"><a href="#旋转数组的最小数字" class="headerlink" title="旋转数组的最小数字"></a><a href="https://leetcode.cn/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof/">旋转数组的最小数字</a></h1><p>把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。</p><p>给你一个可能存在 重复 元素值的数组 numbers ，它原来是一个升序排列的数组，并按上述情形进行了一次旋转。请返回旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一次旋转，该数组的最小值为 1。 </p><p>注意，数组 [a[0], a[1], a[2], …, a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], …, a[n-2]] 。</p><h2 id="min"><a href="#min" class="headerlink" title="min()"></a>min()</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">minArray</span>(<span class="params">self, numbers: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">min</span>(numbers)</span><br></pre></td></tr></table></figure><h2 id="倒序遍历查找"><a href="#倒序遍历查找" class="headerlink" title="倒序遍历查找"></a>倒序遍历查找</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">minArray</span>(<span class="params">self, numbers: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> ans = numbers[-<span class="number">1</span>]</span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="built_in">len</span>(numbers)-<span class="number">1</span>, -<span class="number">1</span>, -<span class="number">1</span>):</span><br><span class="line"> <span class="keyword">if</span> ans >= numbers[i]:</span><br><span class="line"> ans = numbers[i]</span><br><span class="line"> <span class="keyword">else</span>:</span><br><span class="line"> <span class="keyword">return</span> ans</span><br><span class="line"> <span class="keyword">return</span> ans</span><br></pre></td></tr></table></figure><h2 id="二分-1"><a href="#二分-1" class="headerlink" title="二分"></a>二分</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">minArray</span>(<span class="params">self, numbers: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> l, r = <span class="number">0</span>, <span class="built_in">len</span>(numbers) - <span class="number">1</span></span><br><span class="line"> <span class="keyword">while</span> l < r:</span><br><span class="line"> m = (l + r) // <span class="number">2</span></span><br><span class="line"> <span class="keyword">if</span> numbers[m] < numbers[r] <span class="keyword">or</span> numbers[m] < numbers[l]:</span><br><span class="line"> r = m</span><br><span class="line"> <span class="keyword">elif</span> numbers[m] > numbers[r]:</span><br><span class="line"> l = m + <span class="number">1</span></span><br><span class="line"> <span class="keyword">else</span>:</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">min</span>(numbers[l:r])</span><br><span class="line"> <span class="keyword">return</span> numbers[l]</span><br></pre></td></tr></table></figure><h1 id="和为s的连续正数序列"><a href="#和为s的连续正数序列" class="headerlink" title="和为s的连续正数序列"></a><a href="https://leetcode.cn/problems/he-wei-sde-lian-xu-zheng-shu-xu-lie-lcof/">和为s的连续正数序列</a></h1><p>输入一个正整数 target ，输出所有和为 target 的连续正整数序列（至少含有两个数）。</p><p>序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。</p><h2 id="暴力-3"><a href="#暴力-3" class="headerlink" title="暴力"></a>暴力</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">findContinuousSequence</span>(<span class="params">self, target: <span class="built_in">int</span></span>) -> <span class="type">List</span>[<span class="type">List</span>[<span class="built_in">int</span>]]:</span><br><span class="line"> res = []</span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">1</span>, target//<span class="number">2</span> + <span class="number">1</span>):</span><br><span class="line"> s = <span class="number">0</span></span><br><span class="line"> <span class="keyword">for</span> j <span class="keyword">in</span> <span class="built_in">range</span>(i, target):</span><br><span class="line"> <span class="keyword">if</span> s == target <span class="keyword">and</span> j - i > <span class="number">1</span>:</span><br><span class="line"> res.append(<span class="built_in">list</span>(<span class="built_in">range</span>(i, j)))</span><br><span class="line"> <span class="keyword">elif</span> s > target:</span><br><span class="line"> <span class="keyword">break</span> </span><br><span class="line"> s += j </span><br><span class="line"> <span class="keyword">return</span> res</span><br></pre></td></tr></table></figure><h2 id="双指针-1"><a href="#双指针-1" class="headerlink" title="双指针"></a>双指针</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">findContinuousSequence</span>(<span class="params">self, target: <span class="built_in">int</span></span>) -> <span class="type">List</span>[<span class="type">List</span>[<span class="built_in">int</span>]]:</span><br><span class="line"> l, r, s = <span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span></span><br><span class="line"> res = []</span><br><span class="line"> <span class="keyword">while</span> l < r:</span><br><span class="line"> <span class="keyword">if</span> s == target:</span><br><span class="line"> res.append(<span class="built_in">list</span>(<span class="built_in">range</span>(l, r + <span class="number">1</span>)))</span><br><span class="line"> <span class="keyword">if</span> s >= target:</span><br><span class="line"> s -= l</span><br><span class="line"> l += <span class="number">1</span></span><br><span class="line"> <span class="keyword">else</span>:</span><br><span class="line"> r += <span class="number">1</span></span><br><span class="line"> s += r</span><br><span class="line"> <span class="keyword">return</span> res</span><br></pre></td></tr></table></figure><h1 id="连续子数组和的最大值"><a href="#连续子数组和的最大值" class="headerlink" title="连续子数组和的最大值"></a><a href="https://leetcode.cn/problems/lian-xu-zi-shu-zu-de-zui-da-he-lcof/">连续子数组和的最大值</a></h1><p>输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。</p><p>要求时间复杂度为O(n)。</p><h2 id="dp"><a href="#dp" class="headerlink" title="dp"></a>dp</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">maxSubArray</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> f = <span class="built_in">len</span>(nums) * [<span class="number">0</span>]</span><br><span class="line"> ms = f[<span class="number">0</span>] = nums[<span class="number">0</span>]</span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">1</span>, <span class="built_in">len</span>(nums)):</span><br><span class="line"> f[i] = f[i-<span class="number">1</span>] + nums[i] <span class="keyword">if</span> f[i-<span class="number">1</span>]><span class="number">0</span> <span class="keyword">else</span> nums[i]</span><br><span class="line"> ms = ms <span class="keyword">if</span> ms >= f[i] <span class="keyword">else</span> f[i]</span><br><span class="line"> <span class="keyword">return</span> ms</span><br></pre></td></tr></table></figure><h1 id="区域和检索-数组不可变"><a href="#区域和检索-数组不可变" class="headerlink" title="区域和检索-数组不可变"></a><a href="https://leetcode.cn/problems/range-sum-query-immutable/">区域和检索-数组不可变</a></h1><p>给定一个整数数组 nums，处理以下类型的多个查询:</p><p>计算索引 left 和 right （包含 left 和 right）之间的 nums 元素的 和 ，其中 left <= right<br>实现 NumArray 类：</p><p>NumArray(int[] nums) 使用数组 nums 初始化对象<br>int sumRange(int i, int j) 返回数组 nums 中索引 left 和 right 之间的元素的 总和 ，包含 left 和 right 两点（也就是 nums[left] + nums[left + 1] + … + nums[right] )</p><h2 id="前缀和"><a href="#前缀和" class="headerlink" title="前缀和"></a>前缀和</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">NumArray</span>:</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">__init__</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>]</span>):</span><br><span class="line"> self.pre = [<span class="number">0</span>] * (<span class="built_in">len</span>(nums) + <span class="number">1</span>)</span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="built_in">len</span>(nums)):</span><br><span class="line"> self.pre[i+<span class="number">1</span>] = self.pre[i] + nums[i]</span><br><span class="line"></span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">sumRange</span>(<span class="params">self, left: <span class="built_in">int</span>, right: <span class="built_in">int</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">return</span> self.pre[right+<span class="number">1</span>] - self.pre[left]</span><br><span class="line"></span><br><span class="line"></span><br><span class="line"><span class="comment"># Your NumArray object will be instantiated and called as such:</span></span><br><span class="line"><span class="comment"># obj = NumArray(nums)</span></span><br><span class="line"><span class="comment"># param_1 = obj.sumRange(left,right)</span></span><br></pre></td></tr></table></figure><h1 id="最长公共前缀"><a href="#最长公共前缀" class="headerlink" title="最长公共前缀"></a><a href="https://leetcode.cn/problems/longest-common-prefix/">最长公共前缀</a></h1><p>编写一个函数来查找字符串数组中的最长公共前缀。</p><p>如果不存在公共前缀，返回空字符串 <code>""</code>。</p><h2 id="暴力解法"><a href="#暴力解法" class="headerlink" title="暴力解法"></a>暴力解法</h2><p>逐次遍历，两两找最长前缀。</p><p>注意每次拿前缀和新的字符串比较时，用切片保证前缀长度比新字符串小。</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">longestCommonPrefix</span>(<span class="params">self, strs: <span class="type">List</span>[<span class="built_in">str</span>]</span>) -> <span class="built_in">str</span>:</span><br><span class="line"> prefix = <span class="string">""</span></span><br><span class="line"> <span class="keyword">if</span> <span class="keyword">not</span> strs:</span><br><span class="line"> <span class="keyword">return</span> prefix</span><br><span class="line"> <span class="keyword">else</span>:</span><br><span class="line"> prefix = strs[<span class="number">0</span>]</span><br><span class="line"> <span class="keyword">for</span> str0 <span class="keyword">in</span> strs:</span><br><span class="line"> <span class="comment"># 前缀长度一定是最小的</span></span><br><span class="line"> <span class="keyword">if</span> <span class="built_in">len</span>(str0) < <span class="built_in">len</span>(prefix):</span><br><span class="line"> prefix = prefix[<span class="number">0</span>: <span class="built_in">len</span>(str0)]</span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="built_in">min</span>(<span class="built_in">len</span>(str0), <span class="built_in">len</span>(prefix))):</span><br><span class="line"> <span class="keyword">if</span> prefix[i]!= str0[i]:</span><br><span class="line"> prefix = prefix[<span class="number">0</span>:i]</span><br><span class="line"> <span class="keyword">break</span></span><br><span class="line"> <span class="keyword">return</span> prefix</span><br></pre></td></tr></table></figure><h2 id="字典排序"><a href="#字典排序" class="headerlink" title="字典排序"></a>字典排序</h2><p>用min和max获得字典排序的最小串和最大串，直接找两者最大前缀</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">longestCommonPrefix</span>(<span class="params">self, strs: <span class="type">List</span>[<span class="built_in">str</span>]</span>) -> <span class="built_in">str</span>:</span><br><span class="line"> <span class="keyword">if</span> <span class="keyword">not</span> strs:</span><br><span class="line"> <span class="keyword">return</span> <span class="string">""</span></span><br><span class="line"> str0, str1 = <span class="built_in">min</span>(strs), <span class="built_in">max</span>(strs)</span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="built_in">len</span>(str0)):</span><br><span class="line"> <span class="keyword">if</span> str0[i]!=str1[i]:</span><br><span class="line"> <span class="keyword">return</span> str0[:i]</span><br><span class="line"> <span class="keyword">return</span> str0</span><br></pre></td></tr></table></figure><h2 id="压缩"><a href="#压缩" class="headerlink" title="压缩"></a>压缩</h2><p>set函数生成集合，集合中不能有相同元素，可以用集合长度确定strs相同位置的元素是否相同。</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">longestCommonPrefix</span>(<span class="params">self, strs: <span class="type">List</span>[<span class="built_in">str</span>]</span>) -> <span class="built_in">str</span>:</span><br><span class="line"> prefix = <span class="string">""</span></span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">list</span>(<span class="built_in">zip</span>(*strs)):</span><br><span class="line"> <span class="keyword">if</span> <span class="built_in">len</span>(<span class="built_in">set</span>(i))==<span class="number">1</span>:</span><br><span class="line"> prefix += i[<span class="number">0</span>]</span><br><span class="line"> <span class="keyword">else</span>:</span><br><span class="line"> <span class="keyword">break</span></span><br><span class="line"> <span class="keyword">return</span> prefix</span><br></pre></td></tr></table></figure><h1 id="合并有序数组"><a href="#合并有序数组" class="headerlink" title="合并有序数组"></a><a href="https://leetcode.cn/problems/merge-sorted-array/">合并有序数组</a></h1><p>给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。</p><p>请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。</p><p>注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。</p><h2 id="sort"><a href="#sort" class="headerlink" title="sort"></a>sort</h2><p>哈哈哈哈哈</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">merge</span>(<span class="params">self, nums1: <span class="type">List</span>[<span class="built_in">int</span>], m: <span class="built_in">int</span>, nums2: <span class="type">List</span>[<span class="built_in">int</span>], n: <span class="built_in">int</span></span>) -> <span class="literal">None</span>:</span><br><span class="line"> <span class="string">"""</span></span><br><span class="line"><span class="string"> Do not return anything, modify nums1 in-place instead.</span></span><br><span class="line"><span class="string"> """</span></span><br><span class="line"> nums1[m:] = nums2</span><br><span class="line"> nums1.sort()</span><br></pre></td></tr></table></figure><h2 id="倒序遍历"><a href="#倒序遍历" class="headerlink" title="倒序遍历"></a>倒序遍历</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">merge</span>(<span class="params">self, nums1: <span class="type">List</span>[<span class="built_in">int</span>], m: <span class="built_in">int</span>, nums2: <span class="type">List</span>[<span class="built_in">int</span>], n: <span class="built_in">int</span></span>) -> <span class="literal">None</span>:</span><br><span class="line"> <span class="string">"""</span></span><br><span class="line"><span class="string"> Do not return anything, modify nums1 in-place instead.</span></span><br><span class="line"><span class="string"> """</span></span><br><span class="line"> p1, p2, p3 = m-<span class="number">1</span>, n-<span class="number">1</span>, n+m-<span class="number">1</span></span><br><span class="line"> <span class="keyword">while</span> p1>=<span class="number">0</span> <span class="keyword">and</span> p2>=<span class="number">0</span>:</span><br><span class="line"> <span class="keyword">if</span>(nums1[p1] > nums2[p2]):</span><br><span class="line"> nums1[p3] = nums1[p1]</span><br><span class="line"> p1 -= <span class="number">1</span></span><br><span class="line"> <span class="keyword">else</span>:</span><br><span class="line"> nums1[p3] = nums2[p2]</span><br><span class="line"> p2 -= <span class="number">1</span></span><br><span class="line"> p3 -= <span class="number">1</span></span><br><span class="line"> <span class="keyword">while</span> p2>=<span class="number">0</span> <span class="keyword">and</span> p3>=<span class="number">0</span>:</span><br><span class="line"> nums1[p3] = nums2[p2]</span><br><span class="line"> p2 -= <span class="number">1</span></span><br><span class="line"> p3 -= <span class="number">1</span></span><br></pre></td></tr></table></figure><h1 id="加1"><a href="#加1" class="headerlink" title="加1"></a><a href="https://leetcode.cn/problems/plus-one/">加1</a></h1><p>给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。</p><p>最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。</p><p>你可以假设除了整数 0 之外，这个整数不会以零开头。</p><h2 id="反向遍历"><a href="#反向遍历" class="headerlink" title="反向遍历"></a>反向遍历</h2><p>从后往前找，9则置0，找到第一个不为9的+1返回。若全为9则在0位插入一个1。</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">plusOne</span>(<span class="params">self, digits: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="type">List</span>[<span class="built_in">int</span>]:</span><br><span class="line"> l = <span class="built_in">len</span>(digits)</span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(l-<span class="number">1</span>, -<span class="number">1</span>, -<span class="number">1</span>):</span><br><span class="line"> <span class="keyword">if</span> digits[i] <span class="keyword">is</span> <span class="number">9</span>:</span><br><span class="line"> digits[i] = <span class="number">0</span></span><br><span class="line"> <span class="keyword">if</span> <span class="keyword">not</span> i:</span><br><span class="line"> digits.insert(<span class="number">0</span>, <span class="number">1</span>)</span><br><span class="line"> <span class="keyword">else</span>:</span><br><span class="line"> digits[i] += <span class="number">1</span></span><br><span class="line"> <span class="keyword">break</span></span><br><span class="line"> <span class="keyword">return</span> digits</span><br></pre></td></tr></table></figure><h1 id="移0"><a href="#移0" class="headerlink" title="移0"></a><a href="https://leetcode.cn/problems/move-zeroes/">移0</a></h1><p>给定一个数组 <code>nums</code>，编写一个函数将所有 <code>0</code> 移动到数组的末尾，同时保持非零元素的相对顺序。</p><p><strong>请注意</strong> ，必须在不复制数组的情况下原地对数组进行操作。</p><h2 id="快慢指针-1"><a href="#快慢指针-1" class="headerlink" title="快慢指针"></a>快慢指针</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">moveZeroes</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="literal">None</span>:</span><br><span class="line"> <span class="string">"""</span></span><br><span class="line"><span class="string"> Do not return anything, modify nums in-place instead.</span></span><br><span class="line"><span class="string"> """</span></span><br><span class="line"> slow = fast = <span class="number">0</span></span><br><span class="line"> <span class="keyword">for</span> num <span class="keyword">in</span> nums:</span><br><span class="line"> <span class="keyword">if</span> num != <span class="number">0</span>:</span><br><span class="line"> nums[slow] = nums[fast]</span><br><span class="line"> slow += <span class="number">1</span></span><br><span class="line"> fast += <span class="number">1</span></span><br><span class="line"> <span class="comment"># 尾部置零</span></span><br><span class="line"> <span class="keyword">while</span>(slow < fast):</span><br><span class="line"> nums[slow] = <span class="number">0</span></span><br><span class="line"> slow += <span class="number">1</span></span><br></pre></td></tr></table></figure><h2 id="move-amp-append"><a href="#move-amp-append" class="headerlink" title="move & append"></a>move & append</h2><p>这个相对来说慢很多</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">moveZeroes</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="literal">None</span>:</span><br><span class="line"> <span class="string">"""</span></span><br><span class="line"><span class="string"> Do not return anything, modify nums in-place instead.</span></span><br><span class="line"><span class="string"> """</span></span><br><span class="line"> cnt = <span class="number">0</span></span><br><span class="line"> <span class="keyword">while</span> <span class="number">0</span> <span class="keyword">in</span> nums:</span><br><span class="line"> nums.remove(<span class="number">0</span>)</span><br><span class="line"> cnt += <span class="number">1</span></span><br><span class="line"> <span class="keyword">while</span> (cnt):</span><br><span class="line"> nums.append(<span class="number">0</span>)</span><br><span class="line"> cnt -= <span class="number">1</span></span><br></pre></td></tr></table></figure><h1 id="两个数组交集"><a href="#两个数组交集" class="headerlink" title="两个数组交集"></a><a href="https://leetcode.cn/problems/intersection-of-two-arrays/">两个数组交集</a></h1><p>给定两个数组 <code>nums1</code> 和 <code>nums2</code> ，返回 <em>它们的交集</em> 。输出结果中的每个元素一定是 <strong>唯一</strong> 的。我们可以 <strong>不考虑输出结果的顺序</strong> 。</p><h2 id="set-intersection"><a href="#set-intersection" class="headerlink" title="set.intersection()"></a>set.intersection()</h2><p>求两个集合的交集。</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">intersection</span>(<span class="params">self, nums1: <span class="type">List</span>[<span class="built_in">int</span>], nums2: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="type">List</span>[<span class="built_in">int</span>]:</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">list</span>(<span class="built_in">set</span>.intersection(<span class="built_in">set</span>(nums1), <span class="built_in">set</span>(nums2)))</span><br></pre></td></tr></table></figure><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">intersection</span>(<span class="params">self, nums1: <span class="type">List</span>[<span class="built_in">int</span>], nums2: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="type">List</span>[<span class="built_in">int</span>]:</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">list</span>(<span class="built_in">set</span>(nums1).intersection(<span class="built_in">set</span>(nums2)))</span><br></pre></td></tr></table></figure><h2 id="amp"><a href="#amp" class="headerlink" title="&"></a>&</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">intersection</span>(<span class="params">self, nums1: <span class="type">List</span>[<span class="built_in">int</span>], nums2: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="type">List</span>[<span class="built_in">int</span>]:</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">list</span>(<span class="built_in">set</span>(nums1) & <span class="built_in">set</span>(nums2))</span><br></pre></td></tr></table></figure><h1 id="两个数组交集ii"><a href="#两个数组交集ii" class="headerlink" title="两个数组交集ii"></a><a href="https://leetcode.cn/problems/intersection-of-two-arrays-ii/">两个数组交集ii</a></h1><p>给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。</p><h2 id="Counter-amp"><a href="#Counter-amp" class="headerlink" title="Counter &"></a>Counter &</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">intersect</span>(<span class="params">self, nums1: <span class="type">List</span>[<span class="built_in">int</span>], nums2: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="type">List</span>[<span class="built_in">int</span>]:</span><br><span class="line"> dic = (Counter(nums1) & Counter(nums2))</span><br><span class="line"> res = []</span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> dic.keys():</span><br><span class="line"> res += dic[i]*[i]</span><br><span class="line"> <span class="keyword">return</span> res</span><br></pre></td></tr></table></figure><h1 id="最后的单词"><a href="#最后的单词" class="headerlink" title="最后的单词"></a><a href="https://leetcode.cn/problems/length-of-last-word/">最后的单词</a></h1><p>给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。</p><p>单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。</p><h2 id="反向遍历查找"><a href="#反向遍历查找" class="headerlink" title="反向遍历查找"></a>反向遍历查找</h2><p>反向找第一个字母，找到则记录tail word的长度</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">lengthOfLastWord</span>(<span class="params">self, s: <span class="built_in">str</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> tail = <span class="number">0</span></span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="built_in">len</span>(s)-<span class="number">1</span>, -<span class="number">1</span>, -<span class="number">1</span>):</span><br><span class="line"> <span class="keyword">if</span> s[i]!=<span class="string">' '</span>:</span><br><span class="line"> <span class="keyword">while</span> i > -<span class="number">1</span> <span class="keyword">and</span> s[i] != <span class="string">' '</span>:</span><br><span class="line"> tail += <span class="number">1</span></span><br><span class="line"> i -= <span class="number">1</span></span><br><span class="line"> <span class="keyword">return</span> tail</span><br></pre></td></tr></table></figure><h2 id="str-split"><a href="#str-split" class="headerlink" title="str.split()"></a>str.split()</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">lengthOfLastWord</span>(<span class="params">self, s: <span class="built_in">str</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">len</span>(s.split()[-<span class="number">1</span>])</span><br></pre></td></tr></table></figure><h1 id="替换空格"><a href="#替换空格" class="headerlink" title="替换空格"></a><a href="https://leetcode.cn/problems/ti-huan-kong-ge-lcof/">替换空格</a></h1><p>请实现一个函数，把字符串 <code>s</code> 中的每个空格替换成”%20”。</p><h2 id="str-replace"><a href="#str-replace" class="headerlink" title="str.replace()"></a>str.replace()</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">replaceSpace</span>(<span class="params">self, s: <span class="built_in">str</span></span>) -> <span class="built_in">str</span>:</span><br><span class="line"> <span class="keyword">return</span> s.replace(<span class="string">' '</span>, <span class="string">'%20'</span>)</span><br></pre></td></tr></table></figure><h2 id="str-split-and-str-join"><a href="#str-split-and-str-join" class="headerlink" title="str.split() and str.join()"></a>str.split() and str.join()</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">replaceSpace</span>(<span class="params">self, s: <span class="built_in">str</span></span>) -> <span class="built_in">str</span>:</span><br><span class="line"> <span class="keyword">return</span> <span class="string">'%20'</span>.join(s.split(<span class="string">' '</span>))</span><br></pre></td></tr></table></figure><h1 id="替换解析"><a href="#替换解析" class="headerlink" title="替换解析"></a><a href="https://leetcode.cn/problems/goal-parser-interpretation/">替换解析</a></h1><p>请你设计一个可以解释字符串 command 的 Goal 解析器 。command 由 “G”、”()” 和/或 “(al)” 按某种顺序组成。Goal 解析器会将 “G” 解释为字符串 “G”、”()” 解释为字符串 “o” ，”(al)” 解释为字符串 “al” 。然后，按原顺序将经解释得到的字符串连接成一个字符串。</p><p>给你字符串 command ，返回 Goal 解析器 对 command 的解释结果。</p><h2 id="str-replace-1"><a href="#str-replace-1" class="headerlink" title="str.replace()"></a>str.replace()</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">interpret</span>(<span class="params">self, command: <span class="built_in">str</span></span>) -> <span class="built_in">str</span>:</span><br><span class="line"> <span class="keyword">return</span> command.replace(<span class="string">'()'</span>, <span class="string">'o'</span>).replace(<span class="string">'(al)'</span>, <span class="string">'al'</span>)</span><br></pre></td></tr></table></figure><h1 id="反转字符串"><a href="#反转字符串" class="headerlink" title="反转字符串"></a><a href="https://leetcode.cn/problems/reverse-string/">反转字符串</a></h1><p>编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。</p><p>不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。</p><h2 id="str-reverse"><a href="#str-reverse" class="headerlink" title="str.reverse()"></a>str.reverse()</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">reverseString</span>(<span class="params">self, s: <span class="type">List</span>[<span class="built_in">str</span>]</span>) -> <span class="literal">None</span>:</span><br><span class="line"> <span class="string">"""</span></span><br><span class="line"><span class="string"> Do not return anything, modify s in-place instead.</span></span><br><span class="line"><span class="string"> """</span></span><br><span class="line"> s.reverse()</span><br></pre></td></tr></table></figure><h2 id="切片"><a href="#切片" class="headerlink" title="切片"></a>切片</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">reverseString</span>(<span class="params">self, s: <span class="type">List</span>[<span class="built_in">str</span>]</span>) -> <span class="literal">None</span>:</span><br><span class="line"> <span class="string">"""</span></span><br><span class="line"><span class="string"> Do not return anything, modify s in-place instead.</span></span><br><span class="line"><span class="string"> """</span></span><br><span class="line"> s[:] = s[::-<span class="number">1</span>]</span><br></pre></td></tr></table></figure><h2 id="双指针-2"><a href="#双指针-2" class="headerlink" title="双指针"></a>双指针</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">reverseString</span>(<span class="params">self, s: <span class="type">List</span>[<span class="built_in">str</span>]</span>) -> <span class="literal">None</span>:</span><br><span class="line"> <span class="string">"""</span></span><br><span class="line"><span class="string"> Do not return anything, modify s in-place instead.</span></span><br><span class="line"><span class="string"> """</span></span><br><span class="line"> l = <span class="number">0</span></span><br><span class="line"> r = <span class="built_in">len</span>(s)-<span class="number">1</span></span><br><span class="line"> <span class="keyword">while</span> l<r:</span><br><span class="line"> s[l], s[r] = s[r], s[l]</span><br><span class="line"> l += <span class="number">1</span></span><br><span class="line"> r -= <span class="number">1</span></span><br></pre></td></tr></table></figure><h1 id="有效的字母异位词"><a href="#有效的字母异位词" class="headerlink" title="有效的字母异位词"></a><a href="https://leetcode.cn/problems/valid-anagram/">有效的字母异位词</a></h1><p>给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。</p><p>注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。</p><h2 id="Counter"><a href="#Counter" class="headerlink" title="Counter"></a>Counter</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">isAnagram</span>(<span class="params">self, s: <span class="built_in">str</span>, t: <span class="built_in">str</span></span>) -> <span class="built_in">bool</span>:</span><br><span class="line"> <span class="keyword">return</span> Counter(s)==Counter(t)</span><br></pre></td></tr></table></figure><h1 id="左旋转字符串"><a href="#左旋转字符串" class="headerlink" title="左旋转字符串"></a><a href="https://leetcode.cn/problems/zuo-xuan-zhuan-zi-fu-chuan-lcof/">左旋转字符串</a></h1><p>字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串”abcdefg”和数字2，该函数将返回左旋转两位得到的结果”cdefgab”。</p><h2 id="切片-1"><a href="#切片-1" class="headerlink" title="切片"></a>切片</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">reverseLeftWords</span>(<span class="params">self, s: <span class="built_in">str</span>, n: <span class="built_in">int</span></span>) -> <span class="built_in">str</span>:</span><br><span class="line"> <span class="keyword">return</span> s[n:] + s[:n]</span><br></pre></td></tr></table></figure><h2 id="list"><a href="#list" class="headerlink" title="list"></a>list</h2><p>字符串不能直接用下标赋值，通过list实现转换。</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">reverseLeftWords</span>(<span class="params">self, s: <span class="built_in">str</span>, n: <span class="built_in">int</span></span>) -> <span class="built_in">str</span>:</span><br><span class="line"> st = []</span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(n, <span class="built_in">len</span>(s)):</span><br><span class="line"> st.append(s[i])</span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">0</span>, n):</span><br><span class="line"> st.append(s[i])</span><br><span class="line"> <span class="keyword">return</span> <span class="string">''</span>.join(st)</span><br></pre></td></tr></table></figure><p>用求余运算简化代码</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">reverseLeftWords</span>(<span class="params">self, s: <span class="built_in">str</span>, n: <span class="built_in">int</span></span>) -> <span class="built_in">str</span>:</span><br><span class="line"> st = []</span><br><span class="line"> l = <span class="built_in">len</span>(s)</span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(n, l + n):</span><br><span class="line"> st.append(s[i % l])</span><br><span class="line"> <span class="keyword">return</span> <span class="string">''</span>.join(st)</span><br></pre></td></tr></table></figure><h1 id="二进制求和"><a href="#二进制求和" class="headerlink" title="二进制求和"></a><a href="https://leetcode.cn/problems/add-binary/submissions/">二进制求和</a></h1><p>给你两个二进制字符串 <code>a</code> 和 <code>b</code> ，以二进制字符串的形式返回它们的和。</p><h2 id="bin"><a href="#bin" class="headerlink" title="bin()"></a>bin()</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">addBinary</span>(<span class="params">self, a: <span class="built_in">str</span>, b: <span class="built_in">str</span></span>) -> <span class="built_in">str</span>:</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">bin</span>(<span class="built_in">int</span>(a, <span class="number">2</span>) + <span class="built_in">int</span>(b, <span class="number">2</span>))[<span class="number">2</span>:]</span><br></pre></td></tr></table></figure><h1 id="最大重复子字符串"><a href="#最大重复子字符串" class="headerlink" title="最大重复子字符串"></a><a href="https://leetcode.cn/problems/maximum-repeating-substring/">最大重复子字符串</a></h1><p>给你一个字符串 sequence ，如果字符串 word 连续重复 k 次形成的字符串是 sequence 的一个子字符串，那么单词 word 的 重复值为 k 。单词 word 的 最大重复值 是单词 word 在 sequence 中最大的重复值。如果 word 不是 sequence 的子串，那么重复值 k 为 0 。</p><p>给你一个字符串 sequence 和 word ，请你返回 最大重复值 k 。</p><h2 id="str-find"><a href="#str-find" class="headerlink" title="str.find()"></a>str.find()</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">maxRepeating</span>(<span class="params">self, sequence: <span class="built_in">str</span>, word: <span class="built_in">str</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> res = <span class="built_in">len</span>(sequence)//<span class="built_in">len</span>(word)</span><br><span class="line"> <span class="keyword">while</span> res:</span><br><span class="line"> <span class="keyword">if</span> sequence.find(word * res) >= <span class="number">0</span>:</span><br><span class="line"> <span class="keyword">return</span> res</span><br><span class="line"> res -= <span class="number">1</span></span><br><span class="line"> <span class="keyword">return</span> res</span><br></pre></td></tr></table></figure><h2 id="暴力-4"><a href="#暴力-4" class="headerlink" title="暴力"></a>暴力</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">maxRepeating</span>(<span class="params">self, sequence: <span class="built_in">str</span>, word: <span class="built_in">str</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> lw = <span class="built_in">len</span>(word)</span><br><span class="line"> ls = <span class="built_in">len</span>(sequence)</span><br><span class="line"> maxk = <span class="number">0</span></span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(ls):</span><br><span class="line"> k = <span class="number">0</span></span><br><span class="line"> <span class="keyword">while</span> i+lw <= ls <span class="keyword">and</span> sequence[i:i+lw] == word:</span><br><span class="line"> k += <span class="number">1</span></span><br><span class="line"> i += lw</span><br><span class="line"> <span class="keyword">if</span> k > maxk:</span><br><span class="line"> maxk = k</span><br><span class="line"> <span class="keyword">return</span> maxk</span><br></pre></td></tr></table></figure><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">maxRepeating</span>(<span class="params">self, sequence: <span class="built_in">str</span>, word: <span class="built_in">str</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> res = <span class="number">0</span></span><br><span class="line"> tmp = word</span><br><span class="line"> <span class="keyword">while</span> tmp <span class="keyword">in</span> sequence:</span><br><span class="line"> tmp += word</span><br><span class="line"> res += <span class="number">1</span></span><br><span class="line"> <span class="keyword">return</span> res</span><br></pre></td></tr></table></figure><h1 id="字符重排判定"><a href="#字符重排判定" class="headerlink" title="字符重排判定"></a><a href="https://leetcode.cn/problems/check-permutation-lcci/">字符重排判定</a></h1><p>给定两个由小写字母组成的字符串 <code>s1</code> 和 <code>s2</code>，请编写一个程序，确定其中一个字符串的字符重新排列后，能否变成另一个字符串。</p><h2 id="哈希字典-1"><a href="#哈希字典-1" class="headerlink" title="哈希字典"></a>哈希字典</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">CheckPermutation</span>(<span class="params">self, s1: <span class="built_in">str</span>, s2: <span class="built_in">str</span></span>) -> <span class="built_in">bool</span>:</span><br><span class="line"> <span class="keyword">return</span> Counter(s1)==Counter(s2)</span><br></pre></td></tr></table></figure><h1 id="判断子序列"><a href="#判断子序列" class="headerlink" title="判断子序列"></a><a href="https://leetcode.cn/problems/is-subsequence/">判断子序列</a></h1><p>给定字符串 s 和 t ，判断 s 是否为 t 的子序列。</p><p>字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，”ace”是”abcde”的一个子序列，而”aec”不是）。</p><p>进阶：</p><p>如果有大量输入的 S，称作 S1, S2, … , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？</p><p>注意看清：s是目标串，t是原串。</p><h2 id="双指针-3"><a href="#双指针-3" class="headerlink" title="双指针"></a>双指针</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">isSubsequence</span>(<span class="params">self, s: <span class="built_in">str</span>, t: <span class="built_in">str</span></span>) -> <span class="built_in">bool</span>:</span><br><span class="line"> <span class="keyword">if</span> <span class="keyword">not</span> s:</span><br><span class="line"> <span class="keyword">return</span> <span class="literal">True</span> </span><br><span class="line"> p = <span class="number">0</span></span><br><span class="line"> <span class="keyword">for</span> w <span class="keyword">in</span> t:</span><br><span class="line"> <span class="keyword">if</span> w == s[p]:</span><br><span class="line"> p += <span class="number">1</span></span><br><span class="line"> <span class="keyword">if</span> p == <span class="built_in">len</span>(s):</span><br><span class="line"> <span class="keyword">return</span> <span class="literal">True</span></span><br><span class="line"> <span class="keyword">return</span> <span class="literal">False</span></span><br></pre></td></tr></table></figure><h2 id="str-find-1"><a href="#str-find-1" class="headerlink" title="str.find()"></a>str.find()</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">isSubsequence</span>(<span class="params">self, s: <span class="built_in">str</span>, t: <span class="built_in">str</span></span>) -> <span class="built_in">bool</span>:</span><br><span class="line"> i = <span class="number">0</span></span><br><span class="line"> <span class="keyword">for</span> w <span class="keyword">in</span> s:</span><br><span class="line"> i = t.find(w, i)</span><br><span class="line"> <span class="keyword">if</span> i == -<span class="number">1</span>:</span><br><span class="line"> <span class="keyword">return</span> <span class="literal">False</span></span><br><span class="line"> i += <span class="number">1</span></span><br><span class="line"> <span class="keyword">return</span> <span class="literal">True</span></span><br></pre></td></tr></table></figure><h1 id="合并有序链表"><a href="#合并有序链表" class="headerlink" title="合并有序链表"></a><a href="https://leetcode.cn/problems/merge-two-sorted-lists/">合并有序链表</a></h1><p>将两个升序链表合并为一个新的 <strong>升序</strong> 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 </p><h2 id="递归"><a href="#递归" class="headerlink" title="递归"></a>递归</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for singly-linked list.</span></span><br><span class="line"><span class="comment"># class ListNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, val=0, next=None):</span></span><br><span class="line"><span class="comment"># self.val = val</span></span><br><span class="line"><span class="comment"># self.next = next</span></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">mergeTwoLists</span>(<span class="params">self, list1: <span class="type">Optional</span>[ListNode], list2: <span class="type">Optional</span>[ListNode]</span>) -> <span class="type">Optional</span>[ListNode]:</span><br><span class="line"> <span class="keyword">if</span> list1 <span class="keyword">and</span> list2:</span><br><span class="line"> <span class="keyword">if</span> list1.val > list2.val:</span><br><span class="line"> list1, list2 = list2, list1</span><br><span class="line"> list1.<span class="built_in">next</span> = self.mergeTwoLists(list1.<span class="built_in">next</span>, list2)</span><br><span class="line"> <span class="keyword">return</span> list1 <span class="keyword">or</span> list2</span><br></pre></td></tr></table></figure><h2 id="迭代"><a href="#迭代" class="headerlink" title="迭代"></a>迭代</h2><p>用带头节点的单链表统一操作</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for singly-linked list.</span></span><br><span class="line"><span class="comment"># class ListNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, val=0, next=None):</span></span><br><span class="line"><span class="comment"># self.val = val</span></span><br><span class="line"><span class="comment"># self.next = next</span></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">mergeTwoLists</span>(<span class="params">self, list1: <span class="type">Optional</span>[ListNode], list2: <span class="type">Optional</span>[ListNode]</span>) -> <span class="type">Optional</span>[ListNode]:</span><br><span class="line"> tmp = cur = ListNode(-<span class="number">1</span>) <span class="comment"># Head Node</span></span><br><span class="line"> <span class="keyword">while</span> list1 <span class="keyword">and</span> list2:</span><br><span class="line"> <span class="keyword">if</span> list1.val > list2.val:</span><br><span class="line"> cur.<span class="built_in">next</span>, list2 = list2, list2.<span class="built_in">next</span></span><br><span class="line"> <span class="keyword">else</span>:</span><br><span class="line"> cur.<span class="built_in">next</span>, list1 = list1, list1.<span class="built_in">next</span></span><br><span class="line"> cur = cur.<span class="built_in">next</span></span><br><span class="line"> cur.<span class="built_in">next</span> = list1 <span class="keyword">if</span> list1 <span class="keyword">else</span> list2</span><br><span class="line"> <span class="keyword">return</span> tmp.<span class="built_in">next</span></span><br></pre></td></tr></table></figure><h1 id="反转链表"><a href="#反转链表" class="headerlink" title="反转链表"></a><a href="https://leetcode.cn/problems/reverse-linked-list/">反转链表</a></h1><p>给你单链表的头节点 <code>head</code> ，请你反转链表，并返回反转后的链表。</p><h2 id="迭代-1"><a href="#迭代-1" class="headerlink" title="迭代"></a>迭代</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for singly-linked list.</span></span><br><span class="line"><span class="comment"># class ListNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, val=0, next=None):</span></span><br><span class="line"><span class="comment"># self.val = val</span></span><br><span class="line"><span class="comment"># self.next = next</span></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">reverseList</span>(<span class="params">self, head: <span class="type">Optional</span>[ListNode]</span>) -> <span class="type">Optional</span>[ListNode]:</span><br><span class="line"> ans = <span class="literal">None</span></span><br><span class="line"> <span class="keyword">while</span> head <span class="keyword">is</span> <span class="keyword">not</span> <span class="literal">None</span>:</span><br><span class="line"> p = head.<span class="built_in">next</span></span><br><span class="line"> head.<span class="built_in">next</span> = ans</span><br><span class="line"> ans = head</span><br><span class="line"> head = p</span><br><span class="line"> <span class="keyword">return</span> ans</span><br></pre></td></tr></table></figure><h2 id="递归-1"><a href="#递归-1" class="headerlink" title="递归"></a>递归</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for singly-linked list.</span></span><br><span class="line"><span class="comment"># class ListNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, val=0, next=None):</span></span><br><span class="line"><span class="comment"># self.val = val</span></span><br><span class="line"><span class="comment"># self.next = next</span></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">reverseList</span>(<span class="params">self, head: <span class="type">Optional</span>[ListNode]</span>) -> <span class="type">Optional</span>[ListNode]:</span><br><span class="line"> <span class="keyword">if</span> <span class="keyword">not</span> head <span class="keyword">or</span> <span class="keyword">not</span> head.<span class="built_in">next</span>:</span><br><span class="line"> <span class="keyword">return</span> head</span><br><span class="line"> last = self.reverseList(head.<span class="built_in">next</span>)</span><br><span class="line"> head.<span class="built_in">next</span>.<span class="built_in">next</span> = head</span><br><span class="line"> head.<span class="built_in">next</span> = <span class="literal">None</span></span><br><span class="line"> <span class="keyword">return</span> last</span><br></pre></td></tr></table></figure><h1 id="环形链表"><a href="#环形链表" class="headerlink" title="环形链表"></a><a href="https://leetcode.cn/problems/linked-list-cycle/">环形链表</a></h1><p>给你一个链表的头节点 head ，判断链表中是否有环。</p><p>如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。</p><p>如果链表中存在环 ，则返回 true 。 否则，返回 false 。</p><h2 id="哈希表"><a href="#哈希表" class="headerlink" title="哈希表"></a>哈希表</h2><p>用一个集合来存储已经访问过的结点（不是val），遍历访问时，判断当前结点是否已经访问过。</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for singly-linked list.</span></span><br><span class="line"><span class="comment"># class ListNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, x):</span></span><br><span class="line"><span class="comment"># self.val = x</span></span><br><span class="line"><span class="comment"># self.next = None</span></span><br><span class="line"></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">hasCycle</span>(<span class="params">self, head: <span class="type">Optional</span>[ListNode]</span>) -> <span class="built_in">bool</span>:</span><br><span class="line"> seen = <span class="built_in">set</span>()</span><br><span class="line"> <span class="keyword">while</span> head:</span><br><span class="line"> <span class="keyword">if</span> head <span class="keyword">in</span> seen:</span><br><span class="line"> <span class="keyword">return</span> <span class="literal">True</span></span><br><span class="line"> seen.add(head)</span><br><span class="line"> head = head.<span class="built_in">next</span></span><br><span class="line"> <span class="keyword">return</span> <span class="literal">False</span></span><br></pre></td></tr></table></figure><h2 id="快慢指针-2"><a href="#快慢指针-2" class="headerlink" title="快慢指针"></a>快慢指针</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for singly-linked list.</span></span><br><span class="line"><span class="comment"># class ListNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, x):</span></span><br><span class="line"><span class="comment"># self.val = x</span></span><br><span class="line"><span class="comment"># self.next = None</span></span><br><span class="line"></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">hasCycle</span>(<span class="params">self, head: <span class="type">Optional</span>[ListNode]</span>) -> <span class="built_in">bool</span>:</span><br><span class="line"> <span class="keyword">if</span> head:</span><br><span class="line"> slow = fast = head</span><br><span class="line"> <span class="keyword">while</span> fast <span class="keyword">and</span> fast.<span class="built_in">next</span>:</span><br><span class="line"> slow = slow.<span class="built_in">next</span></span><br><span class="line"> fast = fast.<span class="built_in">next</span>.<span class="built_in">next</span></span><br><span class="line"> <span class="keyword">if</span> slow == fast:</span><br><span class="line"> <span class="keyword">return</span> <span class="literal">True</span></span><br><span class="line"> <span class="keyword">return</span> <span class="literal">False</span></span><br></pre></td></tr></table></figure><h1 id="链表中倒数第k个结点"><a href="#链表中倒数第k个结点" class="headerlink" title="链表中倒数第k个结点"></a><a href="https://leetcode.cn/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/">链表中倒数第k个结点</a></h1><p>输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。</p><p>例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。</p><h2 id="快慢指针-3"><a href="#快慢指针-3" class="headerlink" title="快慢指针"></a>快慢指针</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for singly-linked list.</span></span><br><span class="line"><span class="comment"># class ListNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, x):</span></span><br><span class="line"><span class="comment"># self.val = x</span></span><br><span class="line"><span class="comment"># self.next = None</span></span><br><span class="line"></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">getKthFromEnd</span>(<span class="params">self, head: ListNode, k: <span class="built_in">int</span></span>) -> ListNode:</span><br><span class="line"> slow = fast = head</span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(k):</span><br><span class="line"> fast = fast.<span class="built_in">next</span></span><br><span class="line"> <span class="keyword">while</span> fast:</span><br><span class="line"> slow = slow.<span class="built_in">next</span></span><br><span class="line"> fast = fast.<span class="built_in">next</span></span><br><span class="line"> <span class="keyword">return</span> slow</span><br></pre></td></tr></table></figure><h1 id="相交链表"><a href="#相交链表" class="headerlink" title="相交链表"></a><a href="https://leetcode.cn/problems/intersection-of-two-linked-lists/">相交链表</a></h1><p>给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。</p><p>图示两个链表在节点 c1 开始相交：</p><p>题目数据 保证 整个链式结构中不存在环。</p><p>注意，函数返回结果后，链表必须 保持其原始结构 。</p><h2 id="哈希字典-2"><a href="#哈希字典-2" class="headerlink" title="哈希字典"></a>哈希字典</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for singly-linked list.</span></span><br><span class="line"><span class="comment"># class ListNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, x):</span></span><br><span class="line"><span class="comment"># self.val = x</span></span><br><span class="line"><span class="comment"># self.next = None</span></span><br><span class="line"></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">getIntersectionNode</span>(<span class="params">self, headA: ListNode, headB: ListNode</span>) -> <span class="type">Optional</span>[ListNode]:</span><br><span class="line"> dic = <span class="built_in">set</span>()</span><br><span class="line"> p = headA</span><br><span class="line"> <span class="keyword">while</span> p:</span><br><span class="line"> dic.add(p)</span><br><span class="line"> p = p.<span class="built_in">next</span></span><br><span class="line"> </span><br><span class="line"> p = headB</span><br><span class="line"> <span class="keyword">while</span> p:</span><br><span class="line"> <span class="keyword">if</span> p <span class="keyword">in</span> dic:</span><br><span class="line"> <span class="keyword">return</span> p</span><br><span class="line"> p = p.<span class="built_in">next</span></span><br><span class="line"> <span class="keyword">return</span> p</span><br></pre></td></tr></table></figure><h2 id="双指针-4"><a href="#双指针-4" class="headerlink" title="双指针"></a>双指针</h2><p>$$<br>a+(b-c)=b+(a-c)=a+b-c<br>$$</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for singly-linked list.</span></span><br><span class="line"><span class="comment"># class ListNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, x):</span></span><br><span class="line"><span class="comment"># self.val = x</span></span><br><span class="line"><span class="comment"># self.next = None</span></span><br><span class="line"></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">getIntersectionNode</span>(<span class="params">self, headA: ListNode, headB: ListNode</span>) -> <span class="type">Optional</span>[ListNode]:</span><br><span class="line"> p, q = headA, headB</span><br><span class="line"> <span class="keyword">while</span> q != p:</span><br><span class="line"> p = p.<span class="built_in">next</span> <span class="keyword">if</span> p <span class="keyword">else</span> headB</span><br><span class="line"> q = q.<span class="built_in">next</span> <span class="keyword">if</span> q <span class="keyword">else</span> headA</span><br><span class="line"> <span class="keyword">return</span> q</span><br></pre></td></tr></table></figure><h2 id="去尾"><a href="#去尾" class="headerlink" title="去尾"></a>去尾</h2><p>对两个链表，裁剪最大相同长度的尾部，同时遍历。</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for singly-linked list.</span></span><br><span class="line"><span class="comment"># class ListNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, x):</span></span><br><span class="line"><span class="comment"># self.val = x</span></span><br><span class="line"><span class="comment"># self.next = None</span></span><br><span class="line"></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">getIntersectionNode</span>(<span class="params">self, headA: ListNode, headB: ListNode</span>) -> <span class="type">Optional</span>[ListNode]:</span><br><span class="line"> p, q = headA, headB</span><br><span class="line"> la, lb = <span class="number">0</span>, <span class="number">0</span></span><br><span class="line"> <span class="comment"># 计算链表A长度</span></span><br><span class="line"> <span class="keyword">while</span> p:</span><br><span class="line"> la += <span class="number">1</span></span><br><span class="line"> p = p.<span class="built_in">next</span></span><br><span class="line"> <span class="comment"># 计算链表B长度</span></span><br><span class="line"> <span class="keyword">while</span> q:</span><br><span class="line"> lb +=<span class="number">1</span></span><br><span class="line"> q = q.<span class="built_in">next</span></span><br><span class="line"> <span class="comment"># 裁剪去头</span></span><br><span class="line"> <span class="keyword">while</span> la > lb:</span><br><span class="line"> headA = headA.<span class="built_in">next</span></span><br><span class="line"> la -= <span class="number">1</span></span><br><span class="line"> <span class="keyword">while</span> lb > la:</span><br><span class="line"> headB = headB.<span class="built_in">next</span></span><br><span class="line"> lb -= <span class="number">1</span></span><br><span class="line"> <span class="comment"># 此时la==lb</span></span><br><span class="line"> p, q = headA, headB</span><br><span class="line"> <span class="keyword">while</span> p <span class="keyword">and</span> q:</span><br><span class="line"> <span class="keyword">if</span> p==q:</span><br><span class="line"> <span class="keyword">return</span> p</span><br><span class="line"> p = p.<span class="built_in">next</span></span><br><span class="line"> q = q.<span class="built_in">next</span></span><br><span class="line"> <span class="keyword">return</span> <span class="literal">None</span></span><br></pre></td></tr></table></figure><h1 id="从尾到头打印链表"><a href="#从尾到头打印链表" class="headerlink" title="从尾到头打印链表"></a><a href="https://leetcode.cn/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/">从尾到头打印链表</a></h1><p>输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。</p><h2 id="递归-2"><a href="#递归-2" class="headerlink" title="递归"></a>递归</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for singly-linked list.</span></span><br><span class="line"><span class="comment"># class ListNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, x):</span></span><br><span class="line"><span class="comment"># self.val = x</span></span><br><span class="line"><span class="comment"># self.next = None</span></span><br><span class="line"></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">reversePrint</span>(<span class="params">self, head: ListNode</span>) -> <span class="type">List</span>[<span class="built_in">int</span>]:</span><br><span class="line"> re = []</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">fun</span>(<span class="params">p</span>):</span><br><span class="line"> <span class="keyword">if</span> p:</span><br><span class="line"> fun(p.<span class="built_in">next</span>)</span><br><span class="line"> re.append(p.val)</span><br><span class="line"> fun(head)</span><br><span class="line"> <span class="keyword">return</span> re</span><br></pre></td></tr></table></figure><h2 id="正向遍历后翻转"><a href="#正向遍历后翻转" class="headerlink" title="正向遍历后翻转"></a>正向遍历后翻转</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for singly-linked list.</span></span><br><span class="line"><span class="comment"># class ListNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, x):</span></span><br><span class="line"><span class="comment"># self.val = x</span></span><br><span class="line"><span class="comment"># self.next = None</span></span><br><span class="line"></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">reversePrint</span>(<span class="params">self, head: ListNode</span>) -> <span class="type">List</span>[<span class="built_in">int</span>]:</span><br><span class="line"> res = []</span><br><span class="line"> <span class="keyword">while</span> head:</span><br><span class="line"> res.append(head.val)</span><br><span class="line"> head = head.<span class="built_in">next</span></span><br><span class="line"> <span class="keyword">return</span> res[::-<span class="number">1</span>]</span><br></pre></td></tr></table></figure><h1 id="删除链表中的重复元素"><a href="#删除链表中的重复元素" class="headerlink" title="删除链表中的重复元素"></a><a href="https://leetcode.cn/problems/remove-duplicates-from-sorted-list/">删除链表中的重复元素</a></h1><p>给定一个已排序的链表的头 <code>head</code> ， <em>删除所有重复的元素，使每个元素只出现一次</em> 。返回 <em>已排序的链表</em> 。</p><h2 id="遍历一次"><a href="#遍历一次" class="headerlink" title="遍历一次"></a>遍历一次</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for singly-linked list.</span></span><br><span class="line"><span class="comment"># class ListNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, val=0, next=None):</span></span><br><span class="line"><span class="comment"># self.val = val</span></span><br><span class="line"><span class="comment"># self.next = next</span></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">deleteDuplicates</span>(<span class="params">self, head: <span class="type">Optional</span>[ListNode]</span>) -> <span class="type">Optional</span>[ListNode]:</span><br><span class="line"> p = head</span><br><span class="line"> <span class="keyword">while</span> p <span class="keyword">and</span> p.<span class="built_in">next</span>:</span><br><span class="line"> <span class="keyword">if</span> p.val == p.<span class="built_in">next</span>.val:</span><br><span class="line"> p.<span class="built_in">next</span> = p.<span class="built_in">next</span>.<span class="built_in">next</span></span><br><span class="line"> <span class="keyword">else</span>:</span><br><span class="line"> p = p.<span class="built_in">next</span></span><br><span class="line"> <span class="keyword">return</span> head</span><br></pre></td></tr></table></figure><h1 id="回文链表"><a href="#回文链表" class="headerlink" title="回文链表"></a><a href="https://leetcode.cn/problems/palindrome-linked-list/">回文链表</a></h1><p>给你一个单链表的头节点 <code>head</code> ，请你判断该链表是否为回文链表。如果是，返回 <code>true</code> ；否则，返回 <code>false</code> 。</p><h2 id="快慢指针-4"><a href="#快慢指针-4" class="headerlink" title="快慢指针"></a>快慢指针</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for singly-linked list.</span></span><br><span class="line"><span class="comment"># class ListNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, val=0, next=None):</span></span><br><span class="line"><span class="comment"># self.val = val</span></span><br><span class="line"><span class="comment"># self.next = next</span></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">isPalindrome</span>(<span class="params">self, head: <span class="type">Optional</span>[ListNode]</span>) -> <span class="built_in">bool</span>:</span><br><span class="line"> st = []</span><br><span class="line"> fast, slow = head, head</span><br><span class="line"> <span class="keyword">while</span> fast <span class="keyword">and</span> fast.<span class="built_in">next</span>:</span><br><span class="line"> fast, slow = fast.<span class="built_in">next</span>.<span class="built_in">next</span>, slow.<span class="built_in">next</span></span><br><span class="line"> <span class="keyword">while</span> slow:</span><br><span class="line"> st.append(slow.val)</span><br><span class="line"> slow = slow.<span class="built_in">next</span></span><br><span class="line"> p = head</span><br><span class="line"> <span class="keyword">while</span> st:</span><br><span class="line"> <span class="keyword">if</span> st.pop()!=p.val:</span><br><span class="line"> <span class="keyword">return</span> <span class="literal">False</span></span><br><span class="line"> p = p.<span class="built_in">next</span></span><br><span class="line"> <span class="keyword">return</span> <span class="literal">True</span></span><br></pre></td></tr></table></figure><h2 id="翻转"><a href="#翻转" class="headerlink" title="翻转"></a>翻转</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for singly-linked list.</span></span><br><span class="line"><span class="comment"># class ListNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, val=0, next=None):</span></span><br><span class="line"><span class="comment"># self.val = val</span></span><br><span class="line"><span class="comment"># self.next = next</span></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">isPalindrome</span>(<span class="params">self, head: <span class="type">Optional</span>[ListNode]</span>) -> <span class="built_in">bool</span>:</span><br><span class="line"> st = []</span><br><span class="line"> p = head</span><br><span class="line"> <span class="keyword">while</span> p:</span><br><span class="line"> st.append(p.val)</span><br><span class="line"> p = p.<span class="built_in">next</span></span><br><span class="line"> <span class="keyword">return</span> st[::<span class="number">1</span>]==st[::-<span class="number">1</span>]</span><br></pre></td></tr></table></figure><h1 id="二叉树最大深度"><a href="#二叉树最大深度" class="headerlink" title="二叉树最大深度"></a><a href="https://leetcode.cn/problems/maximum-depth-of-binary-tree/">二叉树最大深度</a></h1><p>给定一个二叉树，找出其最大深度。</p><p>二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。</p><p><strong>说明:</strong> 叶子节点是指没有子节点的节点。</p><h2 id="DFS"><a href="#DFS" class="headerlink" title="DFS"></a>DFS</h2><p>递归</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for a binary tree node.</span></span><br><span class="line"><span class="comment"># class TreeNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, val=0, left=None, right=None):</span></span><br><span class="line"><span class="comment"># self.val = val</span></span><br><span class="line"><span class="comment"># self.left = left</span></span><br><span class="line"><span class="comment"># self.right = right</span></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">maxDepth</span>(<span class="params">self, root: <span class="type">Optional</span>[TreeNode]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">if</span> <span class="keyword">not</span> root:</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span></span><br><span class="line"> <span class="keyword">return</span> <span class="number">1</span> + <span class="built_in">max</span>(self.maxDepth(root.left), self.maxDepth(root.right))</span><br></pre></td></tr></table></figure><h2 id="BFS"><a href="#BFS" class="headerlink" title="BFS"></a>BFS</h2><p>模拟队列实现层次遍历</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for a binary tree node.</span></span><br><span class="line"><span class="comment"># class TreeNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, val=0, left=None, right=None):</span></span><br><span class="line"><span class="comment"># self.val = val</span></span><br><span class="line"><span class="comment"># self.left = left</span></span><br><span class="line"><span class="comment"># self.right = right</span></span><br><span class="line"></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">maxDepth</span>(<span class="params">self, root: <span class="type">Optional</span>[TreeNode]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> depth = <span class="number">0</span></span><br><span class="line"> <span class="keyword">if</span> root:</span><br><span class="line"> q = collections.deque()</span><br><span class="line"> q.append(root)</span><br><span class="line"> <span class="keyword">while</span> <span class="built_in">len</span>(q):</span><br><span class="line"> depth += <span class="number">1</span></span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="built_in">len</span>(q)):</span><br><span class="line"> tmp = q.popleft()</span><br><span class="line"> <span class="keyword">if</span> tmp.left:</span><br><span class="line"> q.append(tmp.left)</span><br><span class="line"> <span class="keyword">if</span> tmp.right:</span><br><span class="line"> q.append(tmp.right)</span><br><span class="line"> <span class="keyword">return</span> depth</span><br></pre></td></tr></table></figure><h1 id="二叉树最小深度"><a href="#二叉树最小深度" class="headerlink" title="二叉树最小深度"></a><a href="https://leetcode.cn/problems/minimum-depth-of-binary-tree/">二叉树最小深度</a></h1><p>给定一个二叉树，找出其最小深度。</p><p>最小深度是从根节点到<strong>最近叶子节点</strong>的最短路径上的节点数量。</p><p><strong>说明：</strong>叶子节点是指没有子节点的节点。</p><h2 id="递归-3"><a href="#递归-3" class="headerlink" title="递归"></a>递归</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for a binary tree node.</span></span><br><span class="line"><span class="comment"># class TreeNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, val=0, left=None, right=None):</span></span><br><span class="line"><span class="comment"># self.val = val</span></span><br><span class="line"><span class="comment"># self.left = left</span></span><br><span class="line"><span class="comment"># self.right = right</span></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">minDepth</span>(<span class="params">self, root: <span class="type">Optional</span>[TreeNode]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">if</span> root:</span><br><span class="line"> <span class="keyword">if</span> root.right <span class="keyword">and</span> root.left:</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">min</span>(self.minDepth(root.left), self.minDepth(root.right)) + <span class="number">1</span></span><br><span class="line"> <span class="keyword">if</span> root.right:</span><br><span class="line"> <span class="keyword">return</span> self.minDepth(root.right) + <span class="number">1</span></span><br><span class="line"> <span class="keyword">if</span> root.left:</span><br><span class="line"> <span class="keyword">return</span> self.minDepth(root.left) + <span class="number">1</span></span><br><span class="line"> <span class="comment"># 遇到叶子结点则返回</span></span><br><span class="line"> <span class="keyword">return</span> <span class="number">1</span></span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span></span><br></pre></td></tr></table></figure><h2 id="BFS-1"><a href="#BFS-1" class="headerlink" title="BFS"></a>BFS</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for a binary tree node.</span></span><br><span class="line"><span class="comment"># class TreeNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, val=0, left=None, right=None):</span></span><br><span class="line"><span class="comment"># self.val = val</span></span><br><span class="line"><span class="comment"># self.left = left</span></span><br><span class="line"><span class="comment"># self.right = right</span></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">minDepth</span>(<span class="params">self, root: <span class="type">Optional</span>[TreeNode]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> depth = <span class="number">0</span></span><br><span class="line"> <span class="keyword">if</span> root:</span><br><span class="line"> q = [root]</span><br><span class="line"> <span class="keyword">while</span> q:</span><br><span class="line"> depth += <span class="number">1</span></span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="built_in">len</span>(q)):</span><br><span class="line"> tmp = q[<span class="number">0</span>]</span><br><span class="line"> <span class="keyword">del</span> q[<span class="number">0</span>]</span><br><span class="line"> <span class="keyword">if</span> tmp.left:</span><br><span class="line"> q.append(tmp.left)</span><br><span class="line"> <span class="keyword">if</span> tmp.right:</span><br><span class="line"> q.append(tmp.right)</span><br><span class="line"> <span class="comment"># 遇到叶子结点则返回深度</span></span><br><span class="line"> <span class="keyword">if</span> <span class="keyword">not</span> tmp.right <span class="keyword">and</span> <span class="keyword">not</span> tmp.left:</span><br><span class="line"> <span class="keyword">return</span> depth</span><br><span class="line"> <span class="keyword">return</span> depth</span><br></pre></td></tr></table></figure><h1 id="二叉树的深度"><a href="#二叉树的深度" class="headerlink" title="二叉树的深度"></a><a href="https://leetcode.cn/problems/er-cha-shu-de-shen-du-lcof/">二叉树的深度</a></h1><p>输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。</p><h2 id="dfs"><a href="#dfs" class="headerlink" title="dfs"></a>dfs</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for a binary tree node.</span></span><br><span class="line"><span class="comment"># class TreeNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, x):</span></span><br><span class="line"><span class="comment"># self.val = x</span></span><br><span class="line"><span class="comment"># self.left = None</span></span><br><span class="line"><span class="comment"># self.right = None</span></span><br><span class="line"></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">maxDepth</span>(<span class="params">self, root: TreeNode</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">dfs</span>(<span class="params">r</span>):</span><br><span class="line"> <span class="keyword">if</span> r:</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">max</span>(dfs(r.right), dfs(r.left)) + <span class="number">1</span></span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span></span><br><span class="line"> <span class="keyword">return</span> dfs(root)</span><br></pre></td></tr></table></figure><h1 id="翻转二叉树"><a href="#翻转二叉树" class="headerlink" title="翻转二叉树"></a><a href="https://leetcode.cn/problems/invert-binary-tree/">翻转二叉树</a></h1><p>给你一棵二叉树的根节点 <code>root</code> ，翻转这棵二叉树，并返回其根节点。</p><h2 id="递归-4"><a href="#递归-4" class="headerlink" title="递归"></a>递归</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for a binary tree node.</span></span><br><span class="line"><span class="comment"># class TreeNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, val=0, left=None, right=None):</span></span><br><span class="line"><span class="comment"># self.val = val</span></span><br><span class="line"><span class="comment"># self.left = left</span></span><br><span class="line"><span class="comment"># self.right = right</span></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">invertTree</span>(<span class="params">self, root: <span class="type">Optional</span>[TreeNode]</span>) -> <span class="type">Optional</span>[TreeNode]:</span><br><span class="line"> <span class="keyword">if</span> root:</span><br><span class="line"> <span class="comment"># 三条语句顺序无影响</span></span><br><span class="line"> root.left, root.right = root.right, root.left</span><br><span class="line"> self.invertTree(root.left)</span><br><span class="line"> self.invertTree(root.right)</span><br><span class="line"> <span class="keyword">return</span> root</span><br></pre></td></tr></table></figure><h1 id="对称树"><a href="#对称树" class="headerlink" title="对称树"></a><a href="https://leetcode.cn/problems/symmetric-tree/">对称树</a></h1><p>给你一个二叉树的根节点 <code>root</code> ， 检查它是否轴对称。</p><h2 id="递归-5"><a href="#递归-5" class="headerlink" title="递归"></a>递归</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for a binary tree node.</span></span><br><span class="line"><span class="comment"># class TreeNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, val=0, left=None, right=None):</span></span><br><span class="line"><span class="comment"># self.val = val</span></span><br><span class="line"><span class="comment"># self.left = left</span></span><br><span class="line"><span class="comment"># self.right = right</span></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">isSymmetric</span>(<span class="params">self, root: <span class="type">Optional</span>[TreeNode]</span>) -> <span class="built_in">bool</span>:</span><br><span class="line"> <span class="keyword">if</span> <span class="keyword">not</span> root:</span><br><span class="line"> <span class="keyword">return</span> <span class="literal">True</span></span><br><span class="line"> <span class="comment"># 送入镜像结点</span></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">dfs</span>(<span class="params">left, right</span>):</span><br><span class="line"> <span class="comment"># 左右结点为空</span></span><br><span class="line"> <span class="keyword">if</span> <span class="keyword">not</span> (left <span class="keyword">or</span> right):</span><br><span class="line"> <span class="keyword">return</span> <span class="literal">True</span></span><br><span class="line"> <span class="comment"># 单边结点为空</span></span><br><span class="line"> <span class="keyword">if</span> <span class="keyword">not</span> (left <span class="keyword">and</span> right):</span><br><span class="line"> <span class="keyword">return</span> <span class="literal">False</span></span><br><span class="line"> <span class="comment"># 左右结点不为空</span></span><br><span class="line"> <span class="comment"># 当值不等，返回0</span></span><br><span class="line"> <span class="keyword">if</span> left.val != right.val:</span><br><span class="line"> <span class="keyword">return</span> <span class="literal">False</span></span><br><span class="line"> <span class="comment"># 当值相等</span></span><br><span class="line"> <span class="comment"># 右结点的右子树和左结点的左子树比较</span></span><br><span class="line"> <span class="comment"># 右结点的左子树和左结点的右子树比较</span></span><br><span class="line"> <span class="keyword">return</span> dfs(left.left, right.right) <span class="keyword">and</span> dfs(left.right, right.left)</span><br><span class="line"> <span class="keyword">return</span> dfs(root.left, root.right)</span><br></pre></td></tr></table></figure><h1 id="路径总和"><a href="#路径总和" class="headerlink" title="路径总和"></a><a href="https://leetcode.cn/problems/path-sum/">路径总和</a></h1><p>给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。</p><p>叶子节点 是指没有子节点的节点。</p><h2 id="递归-6"><a href="#递归-6" class="headerlink" title="递归"></a>递归</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for a binary tree node.</span></span><br><span class="line"><span class="comment"># class TreeNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, val=0, left=None, right=None):</span></span><br><span class="line"><span class="comment"># self.val = val</span></span><br><span class="line"><span class="comment"># self.left = left</span></span><br><span class="line"><span class="comment"># self.right = right</span></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">hasPathSum</span>(<span class="params">self, root: <span class="type">Optional</span>[TreeNode], targetSum: <span class="built_in">int</span></span>) -> <span class="built_in">bool</span>:</span><br><span class="line"> <span class="keyword">if</span> root:</span><br><span class="line"> <span class="comment"># 若无左右结点，则为叶子结点</span></span><br><span class="line"> <span class="keyword">if</span> <span class="keyword">not</span> root.left <span class="keyword">and</span> <span class="keyword">not</span> root.right:</span><br><span class="line"> <span class="keyword">return</span> <span class="literal">True</span> <span class="keyword">if</span> targetSum==root.val <span class="keyword">else</span> <span class="literal">False</span></span><br><span class="line"> </span><br><span class="line"> <span class="keyword">return</span> self.hasPathSum(root.left, targetSum-root.val) <span class="keyword">or</span> self.hasPathSum(root.right, targetSum-root.val)</span><br><span class="line"> </span><br><span class="line"> <span class="comment"># root为none则返回False</span></span><br><span class="line"> <span class="keyword">return</span> <span class="literal">False</span></span><br></pre></td></tr></table></figure><h1 id="二叉树中序遍历"><a href="#二叉树中序遍历" class="headerlink" title="二叉树中序遍历"></a><a href="https://leetcode.cn/problems/binary-tree-inorder-traversal/">二叉树中序遍历</a></h1><p>给定一个二叉树的根节点 <code>root</code> ，返回 <em>它的 <strong>中序</strong> 遍历</em> 。</p><h2 id="递归-7"><a href="#递归-7" class="headerlink" title="递归"></a>递归</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for a binary tree node.</span></span><br><span class="line"><span class="comment"># class TreeNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, val=0, left=None, right=None):</span></span><br><span class="line"><span class="comment"># self.val = val</span></span><br><span class="line"><span class="comment"># self.left = left</span></span><br><span class="line"><span class="comment"># self.right = right</span></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">inorderTraversal</span>(<span class="params">self, root: <span class="type">Optional</span>[TreeNode]</span>) -> <span class="type">List</span>[<span class="built_in">int</span>]:</span><br><span class="line"> trl = []</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">inorder</span>(<span class="params">r</span>):</span><br><span class="line"> <span class="keyword">if</span> r:</span><br><span class="line"> inorder(r.left)</span><br><span class="line"> trl.append(r.val)</span><br><span class="line"> inorder(r.right)</span><br><span class="line"> inorder(root)</span><br><span class="line"> <span class="keyword">return</span> trl</span><br></pre></td></tr></table></figure><h1 id="二叉搜索树第k大结点"><a href="#二叉搜索树第k大结点" class="headerlink" title="二叉搜索树第k大结点"></a><a href="https://leetcode.cn/problems/er-cha-sou-suo-shu-de-di-kda-jie-dian-lcof/">二叉搜索树第k大结点</a></h1><p>给定一棵二叉搜索树，请找出其中第 <code>k</code> 大的节点的值。</p><h2 id="中序遍历"><a href="#中序遍历" class="headerlink" title="中序遍历"></a>中序遍历</h2><p>二叉搜索树的中序遍历（左中右）为递增序列， 右中左为递减序列</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for a binary tree node.</span></span><br><span class="line"><span class="comment"># class TreeNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, x):</span></span><br><span class="line"><span class="comment"># self.val = x</span></span><br><span class="line"><span class="comment"># self.left = None</span></span><br><span class="line"><span class="comment"># self.right = None</span></span><br><span class="line"></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">kthLargest</span>(<span class="params">self, root: TreeNode, k: <span class="built_in">int</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">dfs</span>(<span class="params">r</span>):</span><br><span class="line"> <span class="keyword">if</span> r <span class="keyword">and</span> k > <span class="number">0</span>:</span><br><span class="line"> dfs(r.right)</span><br><span class="line"> self.k -= <span class="number">1</span></span><br><span class="line"> <span class="keyword">if</span> self.k==<span class="number">0</span>:</span><br><span class="line"> self.res = r.val</span><br><span class="line"> <span class="keyword">return</span> </span><br><span class="line"> dfs(r.left)</span><br><span class="line"> self.k = k </span><br><span class="line"> dfs(root) </span><br><span class="line"> <span class="keyword">return</span> self.res</span><br></pre></td></tr></table></figure><h1 id="层次遍历"><a href="#层次遍历" class="headerlink" title="层次遍历"></a><a href="https://leetcode.cn/problems/cong-shang-dao-xia-da-yin-er-cha-shu-ii-lcof/">层次遍历</a></h1><p>从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。</p><h2 id="队列"><a href="#队列" class="headerlink" title="队列"></a>队列</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># Definition for a binary tree node.</span></span><br><span class="line"><span class="comment"># class TreeNode:</span></span><br><span class="line"><span class="comment"># def __init__(self, x):</span></span><br><span class="line"><span class="comment"># self.val = x</span></span><br><span class="line"><span class="comment"># self.left = None</span></span><br><span class="line"><span class="comment"># self.right = None</span></span><br><span class="line"></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">levelOrder</span>(<span class="params">self, root: TreeNode</span>) -> <span class="type">List</span>[<span class="type">List</span>[<span class="built_in">int</span>]]:</span><br><span class="line"> res = []</span><br><span class="line"> <span class="keyword">if</span> root:</span><br><span class="line"> que = collections.deque()</span><br><span class="line"> que.append(root)</span><br><span class="line"> <span class="keyword">while</span> que:</span><br><span class="line"> lay = []</span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="built_in">len</span>(que)):</span><br><span class="line"> p = que.popleft()</span><br><span class="line"> lay.append(p.val)</span><br><span class="line"> <span class="keyword">if</span> p.left:</span><br><span class="line"> que.append(p.left)</span><br><span class="line"> <span class="keyword">if</span> p.right:</span><br><span class="line"> que.append(p.right)</span><br><span class="line"> res.append(lay)</span><br><span class="line"> <span class="keyword">return</span> res</span><br><span class="line"> <span class="keyword">return</span> res</span><br></pre></td></tr></table></figure><h1 id="罗马数字"><a href="#罗马数字" class="headerlink" title="罗马数字"></a><a href="https://leetcode.cn/problems/roman-to-integer/">罗马数字</a></h1><p>罗马数字包含以下七种字符: <code>I</code>， <code>V</code>， <code>X</code>， <code>L</code>，<code>C</code>，<code>D</code> 和 <code>M</code>。</p><p>字符 数值<br>I 1<br>V 5<br>X 10<br>L 50<br>C 100<br>D 500<br>M 1000</p><p>例如， 罗马数字 2 写做 II ，即为两个并列的 1 。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。</p><p>通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：</p><p>I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。<br>X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。<br>C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。<br>给定一个罗马数字，将其转换成整数。</p><h2 id="字典"><a href="#字典" class="headerlink" title="字典"></a>字典</h2><p>数组记录，小数在大数前面，则小数取负，最后全部相加。</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">romanToInt</span>(<span class="params">self, s: <span class="built_in">str</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="built_in">dict</span> = {<span class="string">'I'</span>:<span class="number">1</span>, <span class="string">'V'</span>:<span class="number">5</span>, <span class="string">'X'</span>:<span class="number">10</span>, <span class="string">'L'</span>:<span class="number">50</span>, <span class="string">'C'</span>:<span class="number">100</span>, <span class="string">'D'</span>:<span class="number">500</span>, <span class="string">'M'</span>:<span class="number">1000</span>}</span><br><span class="line"> st = [<span class="number">0</span>]</span><br><span class="line"> top = ans = <span class="number">0</span></span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> s:</span><br><span class="line"> st.append(<span class="built_in">dict</span>[i])</span><br><span class="line"> <span class="comment"># 小数在大数前面，则小数取负</span></span><br><span class="line"> <span class="keyword">if</span>(<span class="built_in">dict</span>[i]>st[top]):</span><br><span class="line"> st[top] = - st[top]</span><br><span class="line"> top += <span class="number">1</span></span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> st:</span><br><span class="line"> ans += i</span><br><span class="line"> <span class="keyword">return</span> ans</span><br></pre></td></tr></table></figure><h1 id="爬楼梯"><a href="#爬楼梯" class="headerlink" title="爬楼梯"></a><a href="https://leetcode.cn/problems/climbing-stairs/">爬楼梯</a></h1><p>假设你正在爬楼梯。需要 <code>n</code> 阶你才能到达楼顶。</p><p>每次你可以爬 <code>1</code> 或 <code>2</code> 个台阶。你有多少种不同的方法可以爬到楼顶呢？</p><p>类似斐波那契数列</p><h2 id="递归-8"><a href="#递归-8" class="headerlink" title="递归"></a>递归</h2><p>简单但超时</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">climbStairs</span>(<span class="params">self, n: <span class="built_in">int</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">if</span> n==<span class="number">0</span> <span class="keyword">or</span> n==<span class="number">1</span>:</span><br><span class="line"> <span class="keyword">return</span> <span class="number">1</span></span><br><span class="line"> <span class="keyword">return</span> self.climbStairs(n-<span class="number">1</span>)+self.climbStairs(n-<span class="number">2</span>)</span><br></pre></td></tr></table></figure><h2 id="动态规划"><a href="#动态规划" class="headerlink" title="动态规划"></a>动态规划</h2><p>自底向上求解，时间复杂度O(n)，空间复杂度O(n)</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">climbStairs</span>(<span class="params">self, n: <span class="built_in">int</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> res = [<span class="number">1</span>, <span class="number">1</span>]</span><br><span class="line"> <span class="keyword">if</span>(n<<span class="number">2</span>):</span><br><span class="line"> <span class="keyword">return</span> res[n]</span><br><span class="line"> <span class="comment"># 注意这里上限是n+1-1=n</span></span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">2</span>, n+<span class="number">1</span>):</span><br><span class="line"> res.append(res[-<span class="number">1</span>] + res[-<span class="number">2</span>])</span><br><span class="line"> <span class="keyword">return</span> res[n]</span><br></pre></td></tr></table></figure><h2 id="动态规划-优化空间"><a href="#动态规划-优化空间" class="headerlink" title="动态规划-优化空间"></a>动态规划-优化空间</h2><p>每次只用到n-1规模和n-2规模的解，所以可以只存前两个解。</p><p>时间复杂度O(n)，空间复杂度O(1)</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">climbStairs</span>(<span class="params">self, n: <span class="built_in">int</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> a, b = <span class="number">1</span>, <span class="number">1</span> <span class="comment"># f(0)=1, f(1)=1</span></span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">2</span>, n+<span class="number">1</span>):</span><br><span class="line"> a, b = b, a+b</span><br><span class="line"> <span class="keyword">return</span> b</span><br></pre></td></tr></table></figure><h2 id="记忆dfs"><a href="#记忆dfs" class="headerlink" title="记忆dfs"></a>记忆dfs</h2><p>记忆性dfs自顶向下计算</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">climbStairs</span>(<span class="params">self, n: <span class="built_in">int</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">dfs</span>(<span class="params">i, flag</span>):</span><br><span class="line"> <span class="keyword">if</span> i==<span class="number">0</span> <span class="keyword">or</span> i==<span class="number">1</span>:</span><br><span class="line"> <span class="keyword">return</span> <span class="number">1</span></span><br><span class="line"> <span class="keyword">if</span> flag[i]==<span class="string">'?'</span>:</span><br><span class="line"> flag[i] = dfs(i-<span class="number">1</span>, flag) + dfs(i-<span class="number">2</span>, flag)</span><br><span class="line"> <span class="keyword">return</span> flag[i]</span><br><span class="line"> </span><br><span class="line"> <span class="keyword">return</span> dfs(n, (n+<span class="number">1</span>)*[<span class="string">'?'</span>])</span><br></pre></td></tr></table></figure><h1 id="炒股"><a href="#炒股" class="headerlink" title="炒股"></a><a href="https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/">炒股</a></h1><p>给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。</p><p>你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。</p><p>返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。</p><p>实际上就是找到一个 i<j, max(prices[j] - prices[i])</p><h2 id="暴力穷举"><a href="#暴力穷举" class="headerlink" title="暴力穷举"></a>暴力穷举</h2><p>时间复杂度O(n^2)，超时</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">maxProfit</span>(<span class="params">self, prices: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> res = <span class="number">0</span></span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">0</span>, <span class="built_in">len</span>(prices)-<span class="number">1</span>):</span><br><span class="line"> <span class="keyword">for</span> j <span class="keyword">in</span> <span class="built_in">range</span>(i+<span class="number">1</span>, <span class="built_in">len</span>(prices)):</span><br><span class="line"> res = <span class="built_in">max</span>(prices[j]-prices[i], res)</span><br><span class="line"> <span class="keyword">return</span> res</span><br></pre></td></tr></table></figure><h2 id="一次遍历"><a href="#一次遍历" class="headerlink" title="一次遍历"></a>一次遍历</h2><p>思路：遍历一次，对于第i天记录此前价格最低点，假设在此前价格最低点买进，当天卖出，记录最大收益值。</p><p>时间复杂度O(n)</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">maxProfit</span>(<span class="params">self, prices: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">if</span> <span class="built_in">len</span>(prices)==<span class="number">0</span> <span class="keyword">or</span> <span class="built_in">len</span>(prices)==<span class="number">1</span>:</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span></span><br><span class="line"> min_price = prices[<span class="number">0</span>]</span><br><span class="line"> max_income = <span class="number">0</span></span><br><span class="line"> <span class="keyword">for</span> price <span class="keyword">in</span> prices:</span><br><span class="line"> <span class="comment"># 若今天卖出，获得最大收益是多少？是否是当前最大收益？</span></span><br><span class="line"> max_income = <span class="built_in">max</span>(max_income, price-min_price)</span><br><span class="line"> <span class="comment"># 更新当前价格最低点</span></span><br><span class="line"> min_price = <span class="built_in">min</span>(min_price, price)</span><br><span class="line"> <span class="keyword">return</span> max_income</span><br></pre></td></tr></table></figure><h1 id="用队列实现栈"><a href="#用队列实现栈" class="headerlink" title="用队列实现栈"></a><a href="https://leetcode.cn/problems/implement-stack-using-queues/">用队列实现栈</a></h1><p>请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">//实现 MyStack 类：</span></span><br><span class="line"></span><br><span class="line"><span class="type">void</span> <span class="title function_">push</span><span class="params">(<span class="type">int</span> x)</span> <span class="comment">//将元素 x 压入栈顶。</span></span><br><span class="line"><span class="type">int</span> <span class="title function_">pop</span><span class="params">()</span> <span class="comment">//移除并返回栈顶元素。</span></span><br><span class="line"><span class="type">int</span> <span class="title function_">top</span><span class="params">()</span> <span class="comment">//返回栈顶元素。</span></span><br><span class="line">boolean <span class="title function_">empty</span><span class="params">()</span> <span class="comment">//如果栈是空的，返回 true ；否则，返回 false 。</span></span><br></pre></td></tr></table></figure><p>注意：</p><p>你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。<br>你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。</p><h2 id="List"><a href="#List" class="headerlink" title="List"></a>List</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">MyStack</span>:</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">__init__</span>(<span class="params">self</span>):</span><br><span class="line"> self.st = []</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">push</span>(<span class="params">self, x: <span class="built_in">int</span></span>) -> <span class="literal">None</span>:</span><br><span class="line"> self.st.append(x)</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">pop</span>(<span class="params">self</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> tmp = self.st[-<span class="number">1</span>]</span><br><span class="line"> <span class="keyword">del</span> self.st[-<span class="number">1</span>]</span><br><span class="line"> <span class="keyword">return</span> tmp</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">top</span>(<span class="params">self</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">return</span> self.st[-<span class="number">1</span>]</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">empty</span>(<span class="params">self</span>) -> <span class="built_in">bool</span>:</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">len</span>(self.st)==<span class="number">0</span></span><br><span class="line"></span><br><span class="line"></span><br><span class="line"><span class="comment"># Your MyStack object will be instantiated and called as such:</span></span><br><span class="line"><span class="comment"># obj = MyStack()</span></span><br><span class="line"><span class="comment"># obj.push(x)</span></span><br><span class="line"><span class="comment"># param_2 = obj.pop()</span></span><br><span class="line"><span class="comment"># param_3 = obj.top()</span></span><br><span class="line"><span class="comment"># param_4 = obj.empty()</span></span><br></pre></td></tr></table></figure><h2 id="Dequeue-left"><a href="#Dequeue-left" class="headerlink" title="Dequeue-left"></a>Dequeue-left</h2><p>双端队列模拟，左边为栈顶</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">MyStack</span>:</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">__init__</span>(<span class="params">self</span>):</span><br><span class="line"> self.q = collections.deque()</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">push</span>(<span class="params">self, x: <span class="built_in">int</span></span>) -> <span class="literal">None</span>:</span><br><span class="line"> self.q.appendleft(x)</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">pop</span>(<span class="params">self</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">return</span> self.q.popleft()</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">top</span>(<span class="params">self</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">return</span> self.q[<span class="number">0</span>]</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">empty</span>(<span class="params">self</span>) -> <span class="built_in">bool</span>:</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">len</span>(self.q)==<span class="number">0</span></span><br><span class="line"></span><br><span class="line"></span><br><span class="line"><span class="comment"># Your MyStack object will be instantiated and called as such:</span></span><br><span class="line"><span class="comment"># obj = MyStack()</span></span><br><span class="line"><span class="comment"># obj.push(x)</span></span><br><span class="line"><span class="comment"># param_2 = obj.pop()</span></span><br><span class="line"><span class="comment"># param_3 = obj.top()</span></span><br><span class="line"><span class="comment"># param_4 = obj.empty()</span></span><br></pre></td></tr></table></figure><h2 id="Dequeue-right"><a href="#Dequeue-right" class="headerlink" title="Dequeue-right"></a>Dequeue-right</h2><p>双端队列，右边为栈顶模拟</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">MyStack</span>:</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">__init__</span>(<span class="params">self</span>):</span><br><span class="line"> self.q = collections.deque()</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">push</span>(<span class="params">self, x: <span class="built_in">int</span></span>) -> <span class="literal">None</span>:</span><br><span class="line"> self.q.append(x)</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">pop</span>(<span class="params">self</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">return</span> self.q.pop()</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">top</span>(<span class="params">self</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">return</span> self.q[<span class="built_in">len</span>(self.q)-<span class="number">1</span>]</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">empty</span>(<span class="params">self</span>) -> <span class="built_in">bool</span>:</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">len</span>(self.q)==<span class="number">0</span></span><br><span class="line"></span><br><span class="line"></span><br><span class="line"><span class="comment"># Your MyStack object will be instantiated and called as such:</span></span><br><span class="line"><span class="comment"># obj = MyStack()</span></span><br><span class="line"><span class="comment"># obj.push(x)</span></span><br><span class="line"><span class="comment"># param_2 = obj.pop()</span></span><br><span class="line"><span class="comment"># param_3 = obj.top()</span></span><br><span class="line"><span class="comment"># param_4 = obj.empty()</span></span><br></pre></td></tr></table></figure><h1 id="min栈"><a href="#min栈" class="headerlink" title="min栈"></a><a href="https://leetcode.cn/problems/bao-han-minhan-shu-de-zhan-lcof/">min栈</a></h1><p>定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。</p><h2 id="最小栈"><a href="#最小栈" class="headerlink" title="最小栈"></a>最小栈</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">MinStack</span>:</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">__init__</span>(<span class="params">self</span>):</span><br><span class="line"> <span class="string">"""</span></span><br><span class="line"><span class="string"> initialize your data structure here.</span></span><br><span class="line"><span class="string"> """</span></span><br><span class="line"> self.st = []</span><br><span class="line"> self.min_st = [math.inf]</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">push</span>(<span class="params">self, x: <span class="built_in">int</span></span>) -> <span class="literal">None</span>:</span><br><span class="line"> self.st.append(x)</span><br><span class="line"> self.min_st.append(<span class="built_in">min</span>(x, self.min_st[-<span class="number">1</span>]))</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">pop</span>(<span class="params">self</span>) -> <span class="literal">None</span>:</span><br><span class="line"> self.st.pop()</span><br><span class="line"> self.min_st.pop()</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">top</span>(<span class="params">self</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">return</span> self.st[-<span class="number">1</span>]</span><br><span class="line"></span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">min</span>(<span class="params">self</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">return</span> self.min_st[-<span class="number">1</span>]</span><br><span class="line"> </span><br><span class="line"></span><br><span class="line"></span><br><span class="line"><span class="comment"># Your MinStack object will be instantiated and called as such:</span></span><br><span class="line"><span class="comment"># obj = MinStack()</span></span><br><span class="line"><span class="comment"># obj.push(x)</span></span><br><span class="line"><span class="comment"># obj.pop()</span></span><br><span class="line"><span class="comment"># param_3 = obj.top()</span></span><br><span class="line"><span class="comment"># param_4 = obj.min()</span></span><br></pre></td></tr></table></figure><h1 id="有效的括号"><a href="#有效的括号" class="headerlink" title="有效的括号"></a><a href="https://leetcode.cn/problems/valid-parentheses/">有效的括号</a></h1><p>给定一个只包括 ‘(‘，’)’，’{‘，’}’，’[‘，’]’ 的字符串 s ，判断字符串是否有效。</p><p>有效字符串需满足：</p><ol><li>左括号必须用相同类型的右括号闭合。</li><li>左括号必须以正确的顺序闭合。</li><li>每个右括号都有一个对应的相同类型的左括号。</li></ol><h2 id="栈"><a href="#栈" class="headerlink" title="栈"></a>栈</h2><p>利用字典构造匹配关系</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">isValid</span>(<span class="params">self, s: <span class="built_in">str</span></span>) -> <span class="built_in">bool</span>:</span><br><span class="line"> <span class="built_in">dict</span> = {<span class="string">'('</span>:<span class="string">')'</span>, <span class="string">'{'</span>:<span class="string">'}'</span>, <span class="string">'['</span>:<span class="string">']'</span>, <span class="string">'?'</span>:<span class="string">'?'</span>}</span><br><span class="line"> stack = [<span class="string">'?'</span>]</span><br><span class="line"> <span class="keyword">for</span> c <span class="keyword">in</span> s:</span><br><span class="line"> <span class="keyword">if</span> c <span class="keyword">in</span> <span class="built_in">dict</span>:</span><br><span class="line"> stack.append(c)</span><br><span class="line"> <span class="keyword">elif</span> <span class="built_in">dict</span>[stack.pop()] != c:</span><br><span class="line"> <span class="keyword">return</span> <span class="literal">False</span></span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">len</span>(stack)==<span class="number">1</span></span><br><span class="line"> </span><br></pre></td></tr></table></figure><h1 id="回文数"><a href="#回文数" class="headerlink" title="回文数"></a><a href="https://leetcode.cn/problems/palindrome-number/">回文数</a></h1><p>给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。</p><p>回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。</p><p>例如，121 是回文，而 123 不是。</p><h2 id="直接计算"><a href="#直接计算" class="headerlink" title="直接计算"></a>直接计算</h2><p>如果x小于0则必不是回文数<br>如果x大于0则计算其倒序数值，比较和原x是否相等</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">isPalindrome</span>(<span class="params">self, x: <span class="built_in">int</span></span>) -> <span class="built_in">bool</span>:</span><br><span class="line"> <span class="keyword">if</span> x<<span class="number">0</span>:</span><br><span class="line"> <span class="keyword">return</span> <span class="literal">False</span></span><br><span class="line"> <span class="keyword">else</span>:</span><br><span class="line"> cur = <span class="number">0</span></span><br><span class="line"> num = x</span><br><span class="line"> <span class="keyword">while</span>(num><span class="number">0</span>):</span><br><span class="line"> cur = cur*<span class="number">10</span> + num%<span class="number">10</span></span><br><span class="line"> num = num//<span class="number">10</span></span><br><span class="line"> <span class="keyword">return</span> cur == x </span><br></pre></td></tr></table></figure><h2 id="反向切片"><a href="#反向切片" class="headerlink" title="反向切片"></a>反向切片</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">isPalindrome</span>(<span class="params">self, x: <span class="built_in">int</span></span>) -> <span class="built_in">bool</span>:</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">str</span>(x) == <span class="built_in">str</span>(x)[::-<span class="number">1</span>]</span><br></pre></td></tr></table></figure><h1 id="x的平方根"><a href="#x的平方根" class="headerlink" title="x的平方根"></a><a href="https://leetcode.cn/problems/sqrtx/">x的平方根</a></h1><p>给你一个非负整数 x ，计算并返回 x 的 算术平方根 。</p><p>由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。</p><p>注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。</p><h2 id="牛顿迭代法"><a href="#牛顿迭代法" class="headerlink" title="牛顿迭代法"></a>牛顿迭代法</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">mySqrt</span>(<span class="params">self, x: <span class="built_in">int</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">if</span> x == <span class="number">0</span>:</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span></span><br><span class="line"> x0, x1 = <span class="built_in">float</span>(x), <span class="built_in">float</span>(<span class="string">'inf'</span>)</span><br><span class="line"> <span class="keyword">while</span> x1-x0 > <span class="number">1e-7</span>:</span><br><span class="line"> x0, x1 = (x0 + x / x0) / <span class="number">2</span>, x0</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">int</span>(x0)</span><br></pre></td></tr></table></figure><h2 id="二分查找-1"><a href="#二分查找-1" class="headerlink" title="二分查找"></a>二分查找</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">mySqrt</span>(<span class="params">self, x: <span class="built_in">int</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> l, r, ans = <span class="number">0</span>, x, -<span class="number">1</span></span><br><span class="line"> <span class="keyword">while</span> l<=r:</span><br><span class="line"> m = (l+r)//<span class="number">2</span></span><br><span class="line"> <span class="keyword">if</span> m**<span class="number">2</span> <= x:</span><br><span class="line"> l = m + <span class="number">1</span></span><br><span class="line"> ans = m</span><br><span class="line"> <span class="keyword">else</span>:</span><br><span class="line"> r = m - <span class="number">1</span></span><br><span class="line"> <span class="keyword">return</span> ans</span><br><span class="line"> </span><br></pre></td></tr></table></figure><h2 id="math"><a href="#math" class="headerlink" title="math"></a>math</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">mySqrt</span>(<span class="params">self, x: <span class="built_in">int</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">if</span> x==<span class="number">0</span>:</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span></span><br><span class="line"> ans = <span class="built_in">int</span>(math.exp(<span class="number">0.5</span> * math.log(x)))</span><br><span class="line"> <span class="keyword">return</span> ans+<span class="number">1</span> <span class="keyword">if</span> (ans+<span class="number">1</span>)**<span class="number">2</span><=x <span class="keyword">else</span> ans</span><br></pre></td></tr></table></figure><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">mySqrt</span>(<span class="params">self, x: <span class="built_in">int</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">int</span>(math.<span class="built_in">pow</span>(x, <span class="number">0.5</span>))</span><br></pre></td></tr></table></figure><h1 id="到达终点数字"><a href="#到达终点数字" class="headerlink" title="到达终点数字"></a><a href="https://leetcode.cn/problems/reach-a-number/">到达终点数字</a></h1><p>在一根无限长的数轴上，你站在0的位置。终点在target的位置。</p><p>你可以做一些数量的移动 numMoves :</p><p>每次你可以选择向左或向右移动。<br>第 i 次移动（从 i == 1 开始，到 i == numMoves ），在选择的方向上走 i 步。<br>给定整数 target ，返回 到达目标所需的 最小 移动次数(即最小 numMoves ) 。</p><h2 id="math-1"><a href="#math-1" class="headerlink" title="math"></a>math</h2><p><a href="https://leetcode.cn/problems/reach-a-number/solution/dao-da-zhong-dian-shu-zi-by-leetcode-sol-ak90/">官方解答</a></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">reachNumber</span>(<span class="params">self, target: <span class="built_in">int</span></span>) -> <span class="built_in">int</span>:</span><br><span class="line"> target = <span class="built_in">abs</span>(target)</span><br><span class="line"> k = <span class="number">0</span></span><br><span class="line"> <span class="keyword">while</span> target > <span class="number">0</span>:</span><br><span class="line"> k += <span class="number">1</span></span><br><span class="line"> target -= k</span><br><span class="line"> <span class="keyword">return</span> k <span class="keyword">if</span> target % <span class="number">2</span> == <span class="number">0</span> <span class="keyword">else</span> k + <span class="number">1</span> + k % <span class="number">2</span> <span class="comment">#多走两步必奇数</span></span><br></pre></td></tr></table></figure><h1 id="majority-element"><a href="#majority-element" class="headerlink" title="majority-element"></a><a href="https://leetcode.cn/problems/majority-element/">majority-element</a></h1><p>给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。</p><p>你可以假设数组是非空的，并且给定的数组总是存在多数元素。</p><h2 id="排序"><a href="#排序" class="headerlink" title="排序"></a>排序</h2><p>排序后取nums[n//2]</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">majorityElement</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> nums.sort()</span><br><span class="line"> <span class="keyword">return</span> nums[<span class="built_in">len</span>(nums)//<span class="number">2</span>]</span><br></pre></td></tr></table></figure><h2 id="字典-1"><a href="#字典-1" class="headerlink" title="字典"></a>字典</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">majorityElement</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">return</span> Counter(nums).most_common(<span class="number">1</span>)[<span class="number">0</span>][<span class="number">0</span>]</span><br></pre></td></tr></table></figure><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">majorityElement</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> counts = collections.Counter(nums)</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">max</span>(counts.keys(), key=counts.get)</span><br></pre></td></tr></table></figure><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">majorityElement</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">max</span>(<span class="built_in">set</span>(nums), key=nums.count)</span><br></pre></td></tr></table></figure><h2 id="摩尔投票"><a href="#摩尔投票" class="headerlink" title="摩尔投票"></a>摩尔投票</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">majorityElement</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="built_in">int</span>:</span><br><span class="line"> count = <span class="number">0</span></span><br><span class="line"> candidate = <span class="literal">None</span></span><br><span class="line"> <span class="keyword">for</span> num <span class="keyword">in</span> nums:</span><br><span class="line"> <span class="comment"># 票数为0换候选人</span></span><br><span class="line"> <span class="keyword">if</span> count==<span class="number">0</span>:</span><br><span class="line"> candidate = num</span><br><span class="line"> count += (<span class="number">1</span> <span class="keyword">if</span> candidate == num <span class="keyword">else</span> -<span class="number">1</span>)</span><br><span class="line"> <span class="keyword">return</span> candidate</span><br></pre></td></tr></table></figure><h1 id="majority-element-ii"><a href="#majority-element-ii" class="headerlink" title="majority-element-ii"></a><a href="https://leetcode.cn/problems/majority-element-ii/">majority-element-ii</a></h1><p>给定一个大小为 <em>n</em> 的整数数组，找出其中所有出现超过 <code>⌊ n/3 ⌋</code> 次的元素。</p><h2 id="摩尔投票-1"><a href="#摩尔投票-1" class="headerlink" title="摩尔投票"></a>摩尔投票</h2><p>选出2个有希望超过⌊ n/3 ⌋的候选人，统计他们的票数是否真的超过⌊ n/3 ⌋。</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">majorityElement</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="type">List</span>[<span class="built_in">int</span>]:</span><br><span class="line"> vote1 = <span class="number">0</span></span><br><span class="line"> vote2 = <span class="number">0</span></span><br><span class="line"> candidate1 = <span class="literal">None</span></span><br><span class="line"> candidate2 = <span class="literal">None</span></span><br><span class="line"> <span class="keyword">for</span> num <span class="keyword">in</span> nums:</span><br><span class="line"> <span class="keyword">if</span> num==candidate1:</span><br><span class="line"> vote1 += <span class="number">1</span></span><br><span class="line"> <span class="keyword">elif</span> num==candidate2:</span><br><span class="line"> vote2 += <span class="number">1</span></span><br><span class="line"> <span class="keyword">elif</span> vote1==<span class="number">0</span>:</span><br><span class="line"> vote1 = <span class="number">1</span></span><br><span class="line"> candidate1 = num</span><br><span class="line"> <span class="keyword">elif</span> vote2==<span class="number">0</span>:</span><br><span class="line"> vote2 = <span class="number">1</span></span><br><span class="line"> candidate2 = num</span><br><span class="line"> <span class="keyword">else</span>:</span><br><span class="line"> vote1 -= <span class="number">1</span></span><br><span class="line"> vote2 -= <span class="number">1</span></span><br><span class="line"> res = []</span><br><span class="line"> cnt1, cnt2 = <span class="number">0</span>, <span class="number">0</span></span><br><span class="line"> <span class="keyword">for</span> num <span class="keyword">in</span> nums:</span><br><span class="line"> <span class="keyword">if</span> vote1><span class="number">0</span> <span class="keyword">and</span> num==candidate1:</span><br><span class="line"> cnt1 += <span class="number">1</span></span><br><span class="line"> <span class="keyword">elif</span> vote2><span class="number">0</span> <span class="keyword">and</span> num==candidate2:</span><br><span class="line"> cnt2 += <span class="number">1</span></span><br><span class="line"> <span class="keyword">if</span> cnt1 > <span class="built_in">len</span>(nums)//<span class="number">3</span>:</span><br><span class="line"> res.append(candidate1)</span><br><span class="line"> <span class="keyword">if</span> cnt2 > <span class="built_in">len</span>(nums)//<span class="number">3</span>:</span><br><span class="line"> res.append(candidate2)</span><br><span class="line"> <span class="keyword">return</span> res</span><br></pre></td></tr></table></figure><h2 id="哈希字典-3"><a href="#哈希字典-3" class="headerlink" title="哈希字典"></a>哈希字典</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">majorityElement</span>(<span class="params">self, nums: <span class="type">List</span>[<span class="built_in">int</span>]</span>) -> <span class="type">List</span>[<span class="built_in">int</span>]:</span><br><span class="line"> dic = {}</span><br><span class="line"> res = []</span><br><span class="line"> <span class="keyword">for</span> num <span class="keyword">in</span> nums:</span><br><span class="line"> <span class="keyword">if</span> num <span class="keyword">in</span> dic:</span><br><span class="line"> dic[num] += <span class="number">1</span></span><br><span class="line"> <span class="keyword">else</span>:</span><br><span class="line"> dic[num] = <span class="number">1</span></span><br><span class="line"> <span class="keyword">for</span> i <span class="keyword">in</span> dic.keys():</span><br><span class="line"> <span class="keyword">if</span> dic[i] > <span class="built_in">len</span>(nums)//<span class="number">3</span> :</span><br><span class="line"> res.append(i)</span><br><span class="line"> <span class="keyword">return</span> res</span><br></pre></td></tr></table></figure><h1 id="信号最好的坐标"><a href="#信号最好的坐标" class="headerlink" title="信号最好的坐标"></a><a href="https://leetcode.cn/problems/coordinate-with-maximum-network-quality/">信号最好的坐标</a></h1><p>给你一个数组 towers 和一个整数 radius 。</p><p>数组 towers 中包含一些网络信号塔，其中 towers[i] = [xi, yi, qi] 表示第 i 个网络信号塔的坐标是 (xi, yi) 且信号强度参数为 qi 。所有坐标都是在 X-Y 坐标系内的 整数 坐标。两个坐标之间的距离用 欧几里得距离 计算。</p><p>整数 radius 表示一个塔 能到达 的 最远距离 。如果一个坐标跟塔的距离在 radius 以内，那么该塔的信号可以到达该坐标。在这个范围以外信号会很微弱，所以 radius 以外的距离该塔是 不能到达的 。</p><p>如果第 i 个塔能到达 (x, y) ，那么该塔在此处的信号为 ⌊qi / (1 + d)⌋ ，其中 d 是塔跟此坐标的距离。一个坐标的 信号强度 是所有 能到达 该坐标的塔的信号强度之和。</p><p>请你返回数组 [cx, cy] ，表示 信号强度 最大的 整数 坐标点 (cx, cy) 。如果有多个坐标网络信号一样大，请你返回字典序最小的 非负 坐标。</p><p>注意：</p><p>坐标 (x1, y1) 字典序比另一个坐标 (x2, y2) 小，需满足以下条件之一：<br>要么 x1 < x2 ，<br>要么 x1 == x2 且 y1 < y2 。<br>⌊val⌋ 表示小于等于 val 的最大整数（向下取整函数）。</p><h2 id="枚举"><a href="#枚举" class="headerlink" title="枚举"></a>枚举</h2><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span>:</span><br><span class="line"> <span class="keyword">def</span> <span class="title function_">bestCoordinate</span>(<span class="params">self, towers: <span class="type">List</span>[<span class="type">List</span>[<span class="built_in">int</span>]], radius: <span class="built_in">int</span></span>) -> <span class="type">List</span>[<span class="built_in">int</span>]:</span><br><span class="line"> dis = <span class="keyword">lambda</span> s1, s2 : ((s1[<span class="number">0</span>] - s2[<span class="number">0</span>]) ** <span class="number">2</span> + (s1[<span class="number">1</span>] - s2[<span class="number">1</span>]) ** <span class="number">2</span>) ** <span class="number">0.5</span></span><br><span class="line"> maxq = <span class="number">0</span></span><br><span class="line"> res = [<span class="number">0</span>, <span class="number">0</span>]</span><br><span class="line"> <span class="keyword">for</span> x <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">51</span>):</span><br><span class="line"> <span class="keyword">for</span> y <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">51</span>):</span><br><span class="line"> q = <span class="number">0</span></span><br><span class="line"> <span class="keyword">for</span> t <span class="keyword">in</span> towers:</span><br><span class="line"> d = dis([x, y], t)</span><br><span class="line"> <span class="keyword">if</span> d <= radius:</span><br><span class="line"> q += floor(t[<span class="number">2</span>] / (<span class="number">1</span> + d))</span><br><span class="line"> <span class="keyword">if</span> q > maxq:</span><br><span class="line"> maxq, res = q, [x, y]</span><br><span class="line"> <span class="keyword">return</span> res</span><br></pre></td></tr></table></figure>]]></content>
<summary type="html"><p>简单题</p>
<h1 id="two-sum"><a href="#two-sum" class="headerlink" title="two-sum"></a><a href="https://leetcode.cn/problems/two-sum/">two-su</summary>
<category term="Algorithm" scheme="https://cyccyyycyc.github.io/categories/Algorithm/"/>
<category term="leetcode" scheme="https://cyccyyycyc.github.io/tags/leetcode/"/>
</entry>
<entry>
<title>Adversarial Robustness by 刘思佳</title>
<link href="https://cyccyyycyc.github.io/2022/10/26/Adversarial-Robustness-by%E5%88%98%E6%80%9D%E4%BD%B3/"/>
<id>https://cyccyyycyc.github.io/2022/10/26/Adversarial-Robustness-by%E5%88%98%E6%80%9D%E4%BD%B3/</id>
<published>2022-10-26T08:31:59.000Z</published>
<updated>2022-10-27T14:00:08.958Z</updated>
<content type="html"><![CDATA[<p>观后感</p><p><a href="http://scl.sribd.cn/seminar/index.html">Source</a> The 6th Lecture</p><h1 id="深度神经网络的对抗鲁棒性"><a href="#深度神经网络的对抗鲁棒性" class="headerlink" title="深度神经网络的对抗鲁棒性"></a>深度神经网络的对抗鲁棒性</h1><h2 id="攻击"><a href="#攻击" class="headerlink" title="攻击"></a>攻击</h2><h3 id="ZO-SGD"><a href="#ZO-SGD" class="headerlink" title="ZO-SGD"></a>ZO-SGD</h3><p>对于黑盒的对抗攻击，优化问题不能求导，便将其转化为一个零阶(ZO zero-order)优化问题，他们证明了收敛性。</p><p>但是存在收敛速度慢的问题：</p><ol><li>有偏差bias</li><li>方差较大</li><li>容易受到维度的影响，高维下收敛速度太慢。</li></ol><h3 id="ZO-signSGD"><a href="#ZO-signSGD" class="headerlink" title="ZO-signSGD"></a>ZO-signSGD</h3><p>相比于ZO-SGD，ZO-signSGD对估计的梯度取了正负。</p><p>效果：</p><ol><li>减少了估计的方差</li><li>收敛速度增加</li></ol><p>但是同时也引入了新的问题：收敛精度下降，难以取得和ZO-SGD一样的最值。</p><h3 id="ZO-Adam"><a href="#ZO-Adam" class="headerlink" title="ZO-Adam"></a>ZO-Adam</h3><p>sign减少估计的方差，而换一种思路，自适应的学习率adaptive learning rate也可以降低估计方差。因此可以采用ZO-Adam优化方法。</p><h2 id="防御"><a href="#防御" class="headerlink" title="防御"></a>防御</h2><p>对抗攻击会修改图片的interpretation maps （CAM），造成了可解释性上的差异。</p><p>由此，刘思佳教授设计相应的可解释性上的距离度量，并证明了该距离大于图片对原本类和目标类的激活值之差。 </p><p>将可解释性距离度量用于对抗训练，对有较大扰动的对抗攻击的鲁棒性提高效果很好，但是会使模型的精确性下降。</p><h2 id="未来"><a href="#未来" class="headerlink" title="未来"></a>未来</h2><ol><li>不同领域之间的鲁棒性的迁移性</li><li>大规模鲁棒训练</li><li>与传统信息安全领域交叉的鲁棒机器学习</li><li>攻击逆向工程与对攻击者意图探明</li><li>对抗鲁棒性与神经网络多种性质之间的关系</li></ol>]]></content>
<summary type="html"><p>观后感</p>
<p><a href="http://scl.sribd.cn/seminar/index.html">Source</a> The 6th Lecture</p>
<h1 id="深度神经网络的对抗鲁棒性"><a href="#深度神经网络的对抗鲁棒性" </summary>
<category term="AISP" scheme="https://cyccyyycyc.github.io/categories/AISP/"/>
<category term="对抗鲁棒性" scheme="https://cyccyyycyc.github.io/tags/%E5%AF%B9%E6%8A%97%E9%B2%81%E6%A3%92%E6%80%A7/"/>
</entry>
<entry>
<title>Towards Robust Representation by 谢慈航</title>
<link href="https://cyccyyycyc.github.io/2022/10/26/Towards-Robust-Representation-by%E8%B0%A2%E6%85%88%E8%88%AA/"/>
<id>https://cyccyyycyc.github.io/2022/10/26/Towards-Robust-Representation-by%E8%B0%A2%E6%85%88%E8%88%AA/</id>
<published>2022-10-26T07:25:03.000Z</published>
<updated>2022-10-27T14:00:16.937Z</updated>
<content type="html"><![CDATA[<p>观后感</p><p><a href="http://scl.sribd.cn/seminar/index.html">Source</a> The 5th Lecture</p><h1 id="鲁棒表示学习"><a href="#鲁棒表示学习" class="headerlink" title="鲁棒表示学习"></a>鲁棒表示学习</h1><p>AI下的DL分支目前发展迅猛，应用效果好，如：</p><ol><li>AlphaGo</li><li>Rubik’s Cube（机器人解魔方）</li><li>Self-Driving Cars(如特斯拉)</li><li>…</li></ol><p>而2013年对抗样本首次被提出，暴露了AI的脆弱性，也引发了人们的思考和关注：AI为什么不鲁棒？？</p><h2 id="脆弱性-Vuluerability"><a href="#脆弱性-Vuluerability" class="headerlink" title="脆弱性 Vuluerability"></a>脆弱性 Vuluerability</h2><p>（1）对抗样本影响各个领域：</p><ol><li>分类</li><li>语义分割</li><li>目标检测</li><li>强化学习</li><li>Pose Estimation</li><li>…</li></ol><p>（2）对抗样本具有一定迁移性：不同任务之间的对抗样本可以相互迁移</p><p>在黑盒攻击中，一个思路是利用对抗样本的迁移性。在本地代理模型Substitute Networks上生成对抗样本，用以迁移攻击目标模型。</p><p>（3）物理世界的对抗样本存在较大威胁性</p><h2 id="修改结构：鲁棒性提高"><a href="#修改结构：鲁棒性提高" class="headerlink" title="修改结构：鲁棒性提高"></a>修改结构：鲁棒性提高</h2><h3 id="中间层去噪"><a href="#中间层去噪" class="headerlink" title="中间层去噪"></a>中间层去噪</h3><p>一个现象是：在pix级别原图和对抗样本没有很大区别，但经过神经网络的放大处理，在feature map上呈现出比较大的差异。（如deepfake检测）</p><ol><li><p>中间层去噪：可以将图片去噪的经典方法（如中值滤波、均值滤波…）应用在中间层，防御对抗攻击。这个操作是为了提高模型鲁棒性，相应地，去噪操作会导致信息损失，模型精确度下降。</p></li><li><p>Denoising Block Design：对应优化模型架构，采用ResNet结构减少信息损失，提高模型精确度。</p></li></ol><h3 id="平滑的Function"><a href="#平滑的Function" class="headerlink" title="平滑的Function"></a>平滑的Function</h3><p>往往鲁棒性对应着平滑连续的表示函数。Relu存在跳跃，可以采用一些连续平滑的激活函数（如GElu，Elu，SmoothRelu…)来增强鲁棒性。</p><h2 id="用对抗样本进行数据增强"><a href="#用对抗样本进行数据增强" class="headerlink" title="用对抗样本进行数据增强"></a>用对抗样本进行数据增强</h2><p>进行数据增强有很多方法：</p><ol><li>很多方法都不具有普适性（如flip这样的处理，对于NLP, 强化学习等领域是不适用的）</li><li>对抗样本进行数据增强是一种通用的方法。</li></ol><h3 id="对抗训练"><a href="#对抗训练" class="headerlink" title="对抗训练"></a>对抗训练</h3><p>一般而言，对抗训练有时候会导致模型鲁棒性上升精确度下降。有一种思路是，先用对抗样本进行对抗训练后再用干净样本进行fine-tuning来提高准确度，但是这样模型可能会以往对抗训练中学到的东西。</p><h3 id="Adv-Prop"><a href="#Adv-Prop" class="headerlink" title="Adv-Prop"></a>Adv-Prop</h3><p>以前就有人提出，训练时将对抗样本和正常样本同时输入网络（2个BN分别归一化处理，其它不做修改）。测试时丢掉对抗样本对应的BN，只要干净样本对应的BN。</p><h2 id="未来"><a href="#未来" class="headerlink" title="未来"></a>未来</h2><p>构建人和机器之间的合作，可解释性是一个重要的问题。我们需要知道AI何时可以解决问题，什么场景下会出Bug，很多时候，对于输出的结果（如分类的结果），我们更需要它给出原因，是依据什么得出了这个输出。</p><h2 id="Q-amp-A"><a href="#Q-amp-A" class="headerlink" title="Q&A"></a>Q&A</h2><p>（1）可以从什么角度出发来提高模型鲁棒性？</p><ol><li>数据：对抗训练学到更多特征</li><li>结构：更加平滑的函数表示</li><li>损失函数：损失函数解决了模型如何训练的问题。</li></ol><p>这三者的优化是并行的。</p><p>（2）鲁棒性和泛化性的关系</p><p>对抗样本是一个子问题，是特殊的关系。</p><p>（3）鲁棒性和准确性是否矛盾？</p><p>在cv领域，用对抗样本进行数据增强往往会导致鲁棒性上升而准确性下降。而在NLP领域，由于数据多、模型大，它们的表征能力capacity往往更强，进行对抗训练往往是鲁棒性和准确性同时提升的。</p><p>（4）普通分类错误的样本和对抗样本有什么区别？</p><p>谢教授说他不会，可以思考下。</p><p>或许普遍意义上没有区别，感觉都是没学到足够的特征。乱说的，以后想到了来修改。</p>]]></content>
<summary type="html"><p>观后感</p>
<p><a href="http://scl.sribd.cn/seminar/index.html">Source</a> The 5th Lecture</p>
<h1 id="鲁棒表示学习"><a href="#鲁棒表示学习" class="heade</summary>
<category term="AISP" scheme="https://cyccyyycyc.github.io/categories/AISP/"/>
<category term="对抗样本" scheme="https://cyccyyycyc.github.io/tags/%E5%AF%B9%E6%8A%97%E6%A0%B7%E6%9C%AC/"/>
</entry>
<entry>
<title>Hierarchical-Clustering</title>
<link href="https://cyccyyycyc.github.io/2022/10/22/Hierarchical-Clustering/"/>
<id>https://cyccyyycyc.github.io/2022/10/22/Hierarchical-Clustering/</id>
<published>2022-10-22T11:10:17.000Z</published>
<updated>2022-10-23T05:29:20.672Z</updated>
<content type="html"><![CDATA[<p>[TOC]</p><h1 id="层次聚类-Hierarchical-Clustering"><a href="#层次聚类-Hierarchical-Clustering" class="headerlink" title="层次聚类 Hierarchical-Clustering"></a>层次聚类 Hierarchical-Clustering</h1><h2 id="场景"><a href="#场景" class="headerlink" title="场景"></a>场景</h2><p>随着网络技术的发展，我们迎来了信息爆炸的时代。我们都知道现代大数据有4个特点：</p><ol><li>体量大 Volume</li><li>高速化 Velocity</li><li>多样化 Variety</li><li>低价值密度 Value</li></ol><p>未经处理的数据信息之间的联系往往较低，体量大而价值密度低。为了更好地挖掘数据价值，一个思路是找到数据之间的相似点进行度量和聚类，将数据点进行聚类，获得关联以更好地利用数据。网络世界中的推荐算法就是数据应用的一个典型例子。如淘宝、京东、拼多多等购物平台的商品推荐页面，谷歌、百度等搜索引擎的推荐回答，网易云音乐的日推歌曲……高效的推荐算法可以帮助我们快速的从体量庞大的信息流中定位到我们需要的有价值的数据，一定程度上便利了我们的生活。</p><p>推荐算法如何能实现推荐我们感兴趣的内容呢？我们往往会发现这样一个事实：品味相似的人会对相似的事物感兴趣。由此衍生出的一个思路是从相似的人出发：如找到兴趣爱好相同的两个人A和B，便可以将A感兴趣的内容推荐给B，由此推广到整个社区类群。在实际应用中，有协同过滤算法基于用户历史数据对用户进行群组划分并在此基础上推荐相似的物品，挖掘用户潜在兴趣。</p><p>在协同过滤中实现聚类有较多方法，本实验选择自底向上的层次聚类进行复现。</p><h2 id="原理"><a href="#原理" class="headerlink" title="原理"></a>原理</h2><p>先明确我们要实现什么：我们有一些离散的无关联的数据点，想要衡量它们之间的相似度，并以此为准则进行聚类。</p><p>那么这就要解决2个问题：</p><ol><li>相似度如何定义？</li><li>如何评估聚类的效果？</li></ol><p>首先，关于相似度定义的问题，需要定义一个函数来进行样本距离的衡量。如：</p><ol><li>Single-Linkage最短距离法：取两个类中距离最近的两个样本的距离作为两个集合的距离。</li><li>Complete-Linkage最长距离法：取两个集合中距离最远的两个点的距离作为两个集合的距离。</li><li>Average-linkage中间距离法：取两两距离的平均值作为两个集合之间的距离。</li><li>类平均法：取两两距离的中值作为两个集合之间的距离。</li></ol><p>四种方法各有特点：</p><ol><li>最短距离法相对限制较少，最终会得到一个相对松散的社群。</li><li>最长距离法相对限制较大。一个问题是：有可能两个类群已经很接近了，但由于单个样本的干扰便没有合并。</li><li>最短距离和最长距离法这考虑了某个有特点的数据，而没有考虑类内数据的整体特点，时间复杂度相对较低。</li><li>类平均法与取均值相比更能消除个别偏离样本对结果的干扰。</li></ol><p>其次，关于聚类效果评估的问题。容易发现，聚类和分类是不同的。对于分类问题，我们已经有了正确的标签，因此分类问题是一个有监督的学习。而聚类本身没有一个“正确”的结果，是一种无监督的学习。因为聚类没有一个确定的答案，目前尚未有一个效果较好的的评测指标评价聚类效果，更多的是靠数据可视化和人工评测效果。</p><p>层次聚类有两种思路：</p><ol><li>自底向上的凝聚法：凝聚法指的是初始时将每个样本点当做一个类簇，然后依据相似度合并这些初始的类簇，直到达到某种条件或者达到设定的分类数目。</li><li>自顶向下的分裂法：初始时将所有的样本归为一个类簇，然后依据相似度进行逐渐的分裂，直到达到某种条件或者达到设定的分类数目。</li></ol><h2 id="特点"><a href="#特点" class="headerlink" title="特点"></a>特点</h2><h3 id="优点"><a href="#优点" class="headerlink" title="优点"></a>优点</h3><ol><li>距离度量函数可以任意定义，较为灵活。</li><li>层次聚类结果是一个树状图，包含关系结构清晰，一个结点可以属于多个类。</li><li>一次性获得整个聚类树，可以直接根据需要对聚类树进行横向切割获得指定数量的类簇。</li></ol><h3 id="缺点"><a href="#缺点" class="headerlink" title="缺点"></a>缺点</h3><ol><li>计算复杂度大</li><li>贪心算法获得局部最优，不一定是全局最优解。</li><li>层次聚类具有不可逆性，一旦聚类结果形成，想要就不能重新合并来优化聚类性能。</li><li>对于不同的问题，需要人为选择合适的距离度量函数、终止条件和参数。</li></ol><h2 id="实现步骤"><a href="#实现步骤" class="headerlink" title="实现步骤"></a>实现步骤</h2><ol><li>移除网络中的所有边，得到有 n 个孤立节点，每个节点作为一个集合。</li><li>两两计算相似度</li><li>根据选取相似度最小的两个结点进行合并</li><li>重复2和3直到满足条件终止，形成树状图</li><li>根据实际需求横切树状图，获得聚类的社区结构</li></ol><h2 id="代码执行"><a href="#代码执行" class="headerlink" title="代码执行"></a>代码执行</h2><h3 id="依赖"><a href="#依赖" class="headerlink" title="依赖"></a>依赖</h3><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">python==3.8.8</span><br><span class="line">numpy==1.23.3</span><br><span class="line">scipy==1.7.0</span><br><span class="line">scikit-learn==1.1.2</span><br><span class="line">matplotlib==3.5.3</span><br></pre></td></tr></table></figure><h3 id="代码实现"><a href="#代码实现" class="headerlink" title="代码实现"></a>代码实现</h3><h4 id="导入库"><a href="#导入库" class="headerlink" title="导入库"></a>导入库</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># 导入库</span></span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"><span class="keyword">import</span> matplotlib.pyplot <span class="keyword">as</span> plt</span><br><span class="line"><span class="keyword">from</span> scipy.cluster <span class="keyword">import</span> hierarchy</span><br><span class="line"><span class="keyword">from</span> sklearn.cluster <span class="keyword">import</span> AgglomerativeClustering</span><br><span class="line"><span class="keyword">from</span> sklearn <span class="keyword">import</span> datasets</span><br><span class="line"><span class="keyword">from</span> sklearn <span class="keyword">import</span> preprocessing</span><br><span class="line">%matplotlib inline</span><br></pre></td></tr></table></figure><h4 id="导入数据"><a href="#导入数据" class="headerlink" title="导入数据"></a>导入数据</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># 导入数据集</span></span><br><span class="line">iris = datasets.load_iris()</span><br><span class="line">iris_data = iris.data</span><br><span class="line"><span class="built_in">print</span>(iris_data.shape, iris_data.dtype)</span><br><span class="line"><span class="comment"># output:(150, 4) float64</span></span><br></pre></td></tr></table></figure><h4 id="数据预处理"><a href="#数据预处理" class="headerlink" title="数据预处理"></a>数据预处理</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># 数据集预处理</span></span><br><span class="line"></span><br><span class="line">data = np.array(iris_data[:, <span class="number">1</span>:-<span class="number">1</span>])</span><br><span class="line"><span class="built_in">print</span>(data.shape)</span><br><span class="line"><span class="comment"># output:(150, 2)</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># 将数据的每一个特征缩放到给定的范围(0,1)</span></span><br><span class="line">min_max_scaler = preprocessing.MinMaxScaler()</span><br><span class="line">data_M = min_max_scaler.fit_transform(data)</span><br></pre></td></tr></table></figure><h4 id="层次聚类树状图"><a href="#层次聚类树状图" class="headerlink" title="层次聚类树状图"></a>层次聚类树状图</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line">plt.figure(figsize=(<span class="number">20</span>, <span class="number">6</span>))</span><br><span class="line">plt.title(<span class="string">"Dendrograms"</span>) </span><br><span class="line"><span class="comment"># ward：集合间距离等于两类对象之间的最小距离。（即最短距离法single-linkage聚类）</span></span><br><span class="line"><span class="comment"># 计算距离的方法，可以是 “euclidean”（即 “l2”，欧氏距离）</span></span><br><span class="line">Z = hierarchy.linkage(data_scaled, method=<span class="string">'ward'</span>, metric=<span class="string">'euclidean'</span>)</span><br><span class="line">p = hierarchy.dendrogram(Z, <span class="number">0</span>)</span><br><span class="line">plt.show()</span><br></pre></td></tr></table></figure><p><img src="/2022/10/22/Hierarchical-Clustering/1.jpg" alt="1"></p><h4 id="层次聚类分布图"><a href="#层次聚类分布图" class="headerlink" title="层次聚类分布图"></a>层次聚类分布图</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># ward：集合间距离等于两类对象之间的最小距离。（即最短距离法single-linkage聚类）</span></span><br><span class="line"><span class="comment"># 计算距离的方法，可以是 “euclidean”（即 “l2”，欧氏距离）</span></span><br><span class="line">ac = AgglomerativeClustering(n_clusters=<span class="number">6</span>, affinity=<span class="string">'euclidean'</span>, linkage=<span class="string">'ward'</span>)</span><br><span class="line">ac.fit(data_scaled)</span><br><span class="line">labels = ac.fit_predict(data_scaled)</span><br><span class="line">plt.scatter(data_scaled[:,<span class="number">0</span>], data_scaled[:,<span class="number">1</span>], c=labels)</span><br><span class="line">plt.show()</span><br></pre></td></tr></table></figure><p><img src="/2022/10/22/Hierarchical-Clustering/2.jpg" alt="2"></p>]]></content>
<summary type="html"><p>[TOC]</p>
<h1 id="层次聚类-Hierarchical-Clustering"><a href="#层次聚类-Hierarchical-Clustering" class="headerlink" title="层次聚类 Hierarchical-Clust</summary>
</entry>
<entry>
<title>The Transfer-based Black-box Attack Method by 韦星星</title>
<link href="https://cyccyyycyc.github.io/2022/10/19/The-Transfer-based-Black-box-Attack-Method-by%E9%9F%A6%E6%98%9F%E6%98%9F/"/>
<id>https://cyccyyycyc.github.io/2022/10/19/The-Transfer-based-Black-box-Attack-Method-by%E9%9F%A6%E6%98%9F%E6%98%9F/</id>
<published>2022-10-19T15:57:49.000Z</published>
<updated>2022-10-21T03:50:27.089Z</updated>
<content type="html"><![CDATA[<p>观后感</p><p><a href="http://scl.sribd.cn/seminar/index.html">Source</a> The 4th Lecture</p><h2 id="基于Spatial-Momentum的迁移性增强方法"><a href="#基于Spatial-Momentum的迁移性增强方法" class="headerlink" title="基于Spatial Momentum的迁移性增强方法"></a>基于Spatial Momentum的迁移性增强方法</h2><h3 id="FGSM-Fast-Gradient-Sign-Method"><a href="#FGSM-Fast-Gradient-Sign-Method" class="headerlink" title="FGSM : Fast Gradient Sign Method"></a>FGSM : Fast Gradient Sign Method</h3><p>白盒场景下，用符号获得梯度方向，在原图增加噪声（对抗扰动）来生成对抗样本，是一种单步迭代攻击。</p><h3 id="I-FGSM-Iterative-Fast-Gradient-Sign-Method"><a href="#I-FGSM-Iterative-Fast-Gradient-Sign-Method" class="headerlink" title="I-FGSM : Iterative Fast Gradient Sign Method"></a>I-FGSM : Iterative Fast Gradient Sign Method</h3><p>多步迭代攻击，拟合效果更好了，但是迁移性不太好（可以从overfit角度直观理解）</p><h4 id="时序累加角度：时间域变换"><a href="#时序累加角度：时间域变换" class="headerlink" title="时序累加角度：时间域变换"></a>时序累加角度：时间域变换</h4><h5 id="MI-FGSM"><a href="#MI-FGSM" class="headerlink" title="MI-FGSM"></a>MI-FGSM</h5><p>时序上的梯度累加：当前梯度+过去梯度</p><h5 id="NI-FGSM"><a href="#NI-FGSM" class="headerlink" title="NI-FGSM"></a>NI-FGSM</h5><h4 id="数据增广角度：空间域变换"><a href="#数据增广角度：空间域变换" class="headerlink" title="数据增广角度：空间域变换"></a>数据增广角度：空间域变换</h4><h5 id="DII-FGSM-Diverse-Inputs"><a href="#DII-FGSM-Diverse-Inputs" class="headerlink" title="DII-FGSM : Diverse Inputs"></a>DII-FGSM : Diverse Inputs</h5><p>从数据增强角度，对输入数据有概率p进行随机大小的resize</p><h5 id="TI-FGSM-Translation-invariant-FGSM"><a href="#TI-FGSM-Translation-invariant-FGSM" class="headerlink" title="TI-FGSM : Translation invariant - FGSM"></a>TI-FGSM : Translation invariant - FGSM</h5><p>从数据增强角度，考虑像素点的领域（高斯）来生成对抗样本。</p><h4 id="时空累加角度"><a href="#时空累加角度" class="headerlink" title="时空累加角度"></a>时空累加角度</h4><h5 id="R-DIMI-FGSM"><a href="#R-DIMI-FGSM" class="headerlink" title="R-DIMI-FGSM"></a>R-DIMI-FGSM</h5><p>考虑梯度在空间上的累加，比较范围更广</p><h2 id="图像检测对抗样本的生成"><a href="#图像检测对抗样本的生成" class="headerlink" title="图像检测对抗样本的生成"></a>图像检测对抗样本的生成</h2><h3 id="现有方法问题"><a href="#现有方法问题" class="headerlink" title="现有方法问题"></a>现有方法问题</h3><p>现有攻击方法常常针对Fast-rcnn，攻击模型中的的分类模块（常常表征高级特征），而有些图像检测模型如yolo模型中无分类模块，则导致迁移性差。</p><ol><li>迁移性差，在一个模型训练生成的对抗样本往往无法成功攻击另一个模型。</li><li>时间复杂度高</li></ol><h3 id="改进"><a href="#改进" class="headerlink" title="改进"></a>改进</h3><h4 id="改进描述"><a href="#改进描述" class="headerlink" title="改进描述"></a>改进描述</h4><p>一种想法是对抗样本迁移和模型之间的共性相关。要想增强迁移能力，则应该从模型间的共性切入。</p><p>传统方法是攻击Fast-rcnn模型中的分类模块，而有些模型中不存在分类模块，则分类模块显然不是模型的共同子架构。</p><p>因此，提出基于base network的对抗样本生成，取Fast-rcnn模型中一些普遍应用的架构（如VGG、ResNet一些经典架构…），用attention机制来定位特征层的目标机制，增加feature loss，从中间特征层入手破坏物体特征层的特征（原来是直接攻击模型更后面更高级的分类模块），获得更高的迁移性。</p><h4 id="Q1-：底层特征更共性？"><a href="#Q1-：底层特征更共性？" class="headerlink" title="Q1 ：底层特征更共性？"></a>Q1 ：底层特征更共性？</h4><p>这时候可能有人会提出一个问题，既然攻击迁移性往往和模型之间的共同点高度相关，那为什么不选取破坏更加具有共性的底层特征来获得更大的迁移性呢？回答是这样对图片的破坏较大，会导致对抗样本和原图的距离较远，选择在中间特征层攻击是对图片质量（和原图的相似度）和迁移性的权衡结果。</p><p>进一步解释，神经网络往往是一个放大的过程，在底层添加微小噪声，经过网络不断放大，最终和原图便相去甚远。</p><h2 id="Q-amp-A"><a href="#Q-amp-A" class="headerlink" title="Q&A"></a>Q&A</h2><h3 id="Q1：可以从什么角度切入提高迁移性"><a href="#Q1：可以从什么角度切入提高迁移性" class="headerlink" title="Q1：可以从什么角度切入提高迁移性?"></a>Q1：可以从什么角度切入提高迁移性?</h3><ol><li>从梯度出发，找到一个更泛化的梯度计算的方法</li><li>从模型架构共性出发。现在的模型架构趋于模块化，更容易找到共性，提高迁移性。</li><li>（笔者目前个人认为）从模型拟合数据分布的角度出发。不同模型学到的知识不同，有的模型注重纹理有的注重轮廓。</li></ol><h3 id="Q2-：无法被迁移攻击的模型？"><a href="#Q2-：无法被迁移攻击的模型？" class="headerlink" title="Q2 ：无法被迁移攻击的模型？"></a>Q2 ：无法被迁移攻击的模型？</h3><ol><li>从模型架构共性出发：黑盒场景下，如果一个模型无法被迁移攻击，那么说明本地模型和目标模型相似度极低。这不太符合现实应用。不过脉冲神经网络或许是一个角度。</li><li>从模型拟合数据分布角度出发：往往经过对抗训练的模型会具有更高的鲁棒性，相同架构下往往会更难以被对抗攻击，这表明模型拟合出了一个不一样的分布，这个分布含有更多的知识。（有点像“吃一堑长一智”，模型之前见识过了对抗攻击，便学会了如何应对）</li></ol><h3 id="Q3-：语义角度的迁移攻击？"><a href="#Q3-：语义角度的迁移攻击？" class="headerlink" title="Q3 ：语义角度的迁移攻击？"></a>Q3 ：语义角度的迁移攻击？</h3><p>现有方法往往修改图像亮度、锐度、饱和度等属性（对抗属性）来生成对抗样本。可以进行扩展，尝试修改一些视觉友好的语义属性（比如颜色）来生成对抗样本，思考并探索：哪种属性更易于迁移？</p><h3 id="Q4-：如何寻找共性？"><a href="#Q4-：如何寻找共性？" class="headerlink" title="Q4 ：如何寻找共性？"></a>Q4 ：如何寻找共性？</h3><ol><li>从data的特征空间变换角度，可以寻找不同模型之间的一致性</li><li>从降维解构角度，可以实现降低搜索维度，在低维空间中搜索降低时间复杂度，在高维空间中攻击获得好的攻击效果。</li></ol><h3 id="Q5-：迁移性的理论相关？"><a href="#Q5-：迁移性的理论相关？" class="headerlink" title="Q5 ：迁移性的理论相关？"></a>Q5 ：迁移性的理论相关？</h3><p>目前理论尚待完善。</p><p>关于可迁移性的度量，由于迁移并不独立存在，一定是从一个模型到另一个模型，所以目前也无统一度量方法。</p><h3 id="Q6-：可证明的迁移攻击的防御"><a href="#Q6-：可证明的迁移攻击的防御" class="headerlink" title="Q6 ：可证明的迁移攻击的防御"></a>Q6 ：可证明的迁移攻击的防御</h3><p>由于目前迁移攻击的发展空间巨大（效果很差成功率很低），所以没有相关的防御。一般经过对抗训练就能很好地防御了。</p>]]></content>
<summary type="html"><p>观后感</p>
<p><a href="http://scl.sribd.cn/seminar/index.html">Source</a> The 4th Lecture</p>
<h2 id="基于Spatial-Momentum的迁移性增强方法"><a href="#</summary>
<category term="AISP" scheme="https://cyccyyycyc.github.io/categories/AISP/"/>
<category term="对抗样本" scheme="https://cyccyyycyc.github.io/tags/%E5%AF%B9%E6%8A%97%E6%A0%B7%E6%9C%AC/"/>
</entry>
<entry>
<title>Deepfake by 吕思伟</title>
<link href="https://cyccyyycyc.github.io/2022/10/18/Deepfake-by%E5%90%95%E6%80%9D%E4%BC%9F/"/>
<id>https://cyccyyycyc.github.io/2022/10/18/Deepfake-by%E5%90%95%E6%80%9D%E4%BC%9F/</id>
<published>2022-10-18T13:55:02.000Z</published>
<updated>2022-10-21T03:49:49.871Z</updated>
<content type="html"><![CDATA[<p>观后感</p><p><a href="http://scl.sribd.cn/seminar/index.html">Source</a> The 3td Lecture</p><h1 id="DEEP-FAKE"><a href="#DEEP-FAKE" class="headerlink" title="DEEP FAKE"></a>DEEP FAKE</h1><h2 id="Background"><a href="#Background" class="headerlink" title="Background"></a>Background</h2><ol><li>硬件近年来发展迅速，甚至超过了摩尔定律描述的速度。</li><li>互联网用户多，数据体量庞大，且传播较快较广泛。</li><li>AI发展迅速（其实是被大数据和高效的计算资源推着发展的）</li></ol><h2 id="Application"><a href="#Application" class="headerlink" title="Application"></a>Application</h2><h3 id="GAN-based-Image"><a href="#GAN-based-Image" class="headerlink" title="GAN-based Image"></a>GAN-based Image</h3><p>生成的fake_images有如下目标：</p><ol><li>质量高，有逼真的特征细节纹理</li><li>种类多</li></ol><h3 id="DNN-based-Speech"><a href="#DNN-based-Speech" class="headerlink" title="DNN-based Speech"></a>DNN-based Speech</h3><ol><li>VC (voice conversion)：可以理解为风格转换，A的内容＋B的风格</li><li>TTS (Text to Speech)</li></ol><h3 id="AE-based-Video"><a href="#AE-based-Video" class="headerlink" title="AE-based Video"></a>AE-based Video</h3><p>理解为逐帧进行替换（风格转换）</p><p>Decoder 分离identity and message，Encode进行一个重新添加。</p><p>问题：耗费较多训练资源，目前还需要比较多的人为调整，而调整操作必然留下痕迹，这也利于检测。</p><h2 id="Impact"><a href="#Impact" class="headerlink" title="Impact"></a>Impact</h2><h3 id="Positive"><a href="#Positive" class="headerlink" title="Positive"></a>Positive</h3><ol><li>电影高难度动作、或者一些场景都可以进行生成</li><li>游戏、远程教育可以通过生成提高交互性</li><li>利于数字匿名化，隐藏个人的identity，可用于个人隐私保护</li><li>生成更具多样性的数据集</li></ol><h3 id="Negative-main"><a href="#Negative-main" class="headerlink" title="Negative(main)"></a>Negative(main)</h3><ol><li>制造假象，混淆视听，误导大众做出错误决策</li><li>降低公众对媒体的信任感，俗称一颗老鼠屎坏了一锅粥</li><li>信息量变大了，含金量并没有提高，信息流变得更为复杂。</li></ol><h2 id="Detection"><a href="#Detection" class="headerlink" title="Detection"></a>Detection</h2><p>虚假信息其实一直都存在，只是随着AI的发展，虚假信息流增强，更难以分辨且威胁性更大，由此Deep-Fake Detection愈发重要。</p><p>下图为吕思伟教授在讲座中给出的DeepFake Detection分类</p><p><img src="/.././images/deepfake-video-detection.jpg" alt="deepfake-video-detection"></p><p>首先明确DeepFake检测是一个二分类问题。</p><p>其次可分为Single-modality 和 Multi-modality。</p><p>目前主流是Single-modality –> Frame-based –> Data-driven的检测手段。</p><p>Cue可以理解为Feature：</p><ol><li>Signal cues：不关心内容，只关心数据本身构成。如Post-processing方法，即为检测生成fake_images后贴到视频里的后处理痕迹，鉴定是否为真。</li><li>Semantic cues：关心数据内容本身是否符合规律。如人脸各个组成的朝向是否正确，如眨眼频率。（个人感觉听起来可延展性较弱，貌似只能针对特定数据特定分布，而且开源后攻击者就可以注意到这个规律，生成符合特定规律的图像就可以骗过检测模型了）</li></ol><p>总体感觉，没有一个普适性的、统一的、可延展的完善的检测方法，较为零碎。</p><h2 id="Challenge"><a href="#Challenge" class="headerlink" title="Challenge"></a>Challenge</h2><ol><li>可解释性：随着Deep-Fake的负面影响越来越严重，除了需要检测出”鉴定为假“的结果，在实际应用中，往往不能单纯依靠机器判别，还需要给出假的理由。</li><li>目前检测方法从不同角度切入，种类很多，但可扩展性不强，缺乏一个统一的检测方法。攻击者可以很容易针对专门检测方法进行调整，绕过检测防御。</li><li>很多检测方法误判率较高。实际应用中容易影响用户体验感。</li><li>目前的检测手段实际上是一种事后的被动防御。现在很多人都有一致的想法，利用后门去破坏Deep-Fake的生成，进行主动防御。</li></ol><h2 id="Future"><a href="#Future" class="headerlink" title="Future"></a>Future</h2><ol><li>生成范围逐渐扩展。不再局限于人脸，逐渐生成四肢、全身…</li><li>共同生成音效＋视频帧，更加逼真</li><li>逐步减少对数据的依赖。比如由单张图片生成动态的视频，由低维构建高维场景。</li></ol>]]></content>
<summary type="html"><p>观后感</p>
<p><a href="http://scl.sribd.cn/seminar/index.html">Source</a> The 3td Lecture</p>
<h1 id="DEEP-FAKE"><a href="#DEEP-FAKE" class=</summary>
<category term="AISP" scheme="https://cyccyyycyc.github.io/categories/AISP/"/>
<category term="DeepFake" scheme="https://cyccyyycyc.github.io/tags/DeepFake/"/>
</entry>
<entry>
<title>深度学习反脆弱技术的攻防和测评By刘祥龙</title>
<link href="https://cyccyyycyc.github.io/2022/10/18/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0%E5%8F%8D%E8%84%86%E5%BC%B1%E6%8A%80%E6%9C%AF%E7%9A%84%E6%94%BB%E9%98%B2%E5%92%8C%E6%B5%8B%E8%AF%84By%E5%88%98%E7%A5%A5%E9%BE%99/"/>
<id>https://cyccyyycyc.github.io/2022/10/18/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0%E5%8F%8D%E8%84%86%E5%BC%B1%E6%8A%80%E6%9C%AF%E7%9A%84%E6%94%BB%E9%98%B2%E5%92%8C%E6%B5%8B%E8%AF%84By%E5%88%98%E7%A5%A5%E9%BE%99/</id>
<published>2022-10-18T11:55:09.000Z</published>
<updated>2022-10-27T14:00:39.507Z</updated>
<content type="html"><![CDATA[<p>Source:</p><p><a href="http://scl.sribd.cn/seminar/index.html">论坛网站</a>The 2nd Lecture</p><h1 id="引入"><a href="#引入" class="headerlink" title="引入"></a>引入</h1><h2 id="安全挑战"><a href="#安全挑战" class="headerlink" title="安全挑战"></a>安全挑战</h2><p>非人为刻意引发<br>网络安全，公共安全（安检、自动驾驶），国防安全（侦察、遥感监测）等</p><p>人为刻意构造的全新类型攻击<br>对抗样本、噪音污染、数据投毒、数据伪造、后门攻击…</p><h1 id="对抗样本"><a href="#对抗样本" class="headerlink" title="对抗样本"></a>对抗样本</h1><h3 id="特点"><a href="#特点" class="headerlink" title="特点"></a>特点</h3><p>一类被恶意设计来攻击AI模型的样本</p><ol><li>与真实样本的差异不易感知</li><li>可以导致模型进行错误的判断</li></ol><p>“脆弱性在深度学习中具有普遍性”（Nature 2019）<br>本次主要从对抗样本角度出发关注深度学习的脆弱性。</p><h2 id="数字世界中的对抗样本"><a href="#数字世界中的对抗样本" class="headerlink" title="数字世界中的对抗样本"></a>数字世界中的对抗样本</h2><h3 id="特点-1"><a href="#特点-1" class="headerlink" title="特点"></a>特点</h3><ol><li>微小扰动，不易觉察</li><li>语义不变而欺骗模型</li></ol><h3 id="攻击分类"><a href="#攻击分类" class="headerlink" title="攻击分类"></a>攻击分类</h3><ol><li>黑盒攻击</li><li>白盒攻击</li></ol><h4 id="FGSM-attack-2014-基于梯度的攻击"><a href="#FGSM-attack-2014-基于梯度的攻击" class="headerlink" title="FGSM attack:2014,基于梯度的攻击"></a><a href="https://arxiv.org/abs/1412.6572">FGSM attack</a>:2014,基于梯度的攻击</h4><p>攻击假设：白盒，可以获得模型反向传播的梯度符号</p><p>特点<br>1.fast<br>2.sign</p><h4 id="C-amp-W-attack-2017-基于优化的攻击"><a href="#C-amp-W-attack-2017-基于优化的攻击" class="headerlink" title="C&W attack:2017,基于优化的攻击"></a><a href="https://arxiv.org/abs/1608.04644">C&W attack</a>:2017,基于优化的攻击</h4><p>攻击假设：白盒，攻击者需要获得模型数据</p><p>数学理解<br>D：distance<br>C：classification<br>f: 目标函数。当且仅当 f(x+δ)≤0时, C(x+δ)=t</p><p>函数连续：因为要进行优化，所以目标函数需要是光滑连续有梯度的。<br>slow：因为涉及多步优化计算w，所以速度相对较慢。</p><h4 id="PBBA-2017-基于迁移的攻击"><a href="#PBBA-2017-基于迁移的攻击" class="headerlink" title="PBBA:2017,基于迁移的攻击"></a><a href="https://arxiv.org/abs/1602.02697">PBBA</a>:2017,基于迁移的攻击</h4><ol><li>攻击假设：黑盒</li><li>对代理模型的攻击迁移到其它模型</li></ol><h4 id="AdvGAN-2018-基于模型的攻击"><a href="#AdvGAN-2018-基于模型的攻击" class="headerlink" title="AdvGAN:2018,基于模型的攻击"></a><a href="https://arxiv.org/abs/1801.02610">AdvGAN</a>:2018,基于模型的攻击</h4><p>攻击假设：白盒生成，需要获得受害者模型数据来计算adv-L</p><h4 id="其它任务"><a href="#其它任务" class="headerlink" title="其它任务"></a>其它任务</h4><h5 id="Video-Analysis"><a href="#Video-Analysis" class="headerlink" title="Video Analysis"></a>Video Analysis</h5><p>视频逐帧攻击</p><h5 id="Speech-Recognition"><a href="#Speech-Recognition" class="headerlink" title="Speech Recognition"></a>Speech Recognition</h5><h5 id="Natural-Language-Processing"><a href="#Natural-Language-Processing" class="headerlink" title="Natural Language Processing"></a>Natural Language Processing</h5><p>自然语言处理领域的对抗样本：<br>对于人类，语序不影响阅读，而文本字母顺序的调换会让模型输出错误的结果。</p><h5 id="Reinforcement-Learning"><a href="#Reinforcement-Learning" class="headerlink" title="Reinforcement Learning"></a>Reinforcement Learning</h5><p>强化学习领域对抗样本的运用实际上是对策略的攻击<br>一种理解是模型本身不够完善，没有学习到如何应对这个策略</p><h3 id="防御"><a href="#防御" class="headerlink" title="防御"></a>防御</h3><h2 id="物理世界中的对抗样本"><a href="#物理世界中的对抗样本" class="headerlink" title="物理世界中的对抗样本"></a>物理世界中的对抗样本</h2><p>物理世界对抗样本：改造物理实体以进行攻击<br>受限于：感知器质量、光照强度、远近距离…<br>与数字世界对抗样本相比，物理世界对抗样本具有黑盒特性，更复杂，危险性更大</p><p>根据数字世界和物理世界的差异，给出对抗样本泛化定义：<br>1.对于人类，视觉上具备友好性 For human, it disguises as a normal example.<br>2.对于模型具有攻击性，可以欺骗模型 For models, it misleads the model predictions</p><h2 id="反脆弱技术体系"><a href="#反脆弱技术体系" class="headerlink" title="反脆弱技术体系"></a>反脆弱技术体系</h2><h3 id="脆弱性原理"><a href="#脆弱性原理" class="headerlink" title="脆弱性原理"></a>脆弱性原理</h3><p>从关键决策路径动态地来看：<br>关键攻击路径刻画了从输入端到决策输出端错误输出的传播路径，这是对模型泛化应用影响最大的路径。<br>表明神经网络中存在脆弱单元，脆弱路径。</p><p>从注意力机制来看：<br>模式识别存在一定偏好，可能对特定的特征（如纹理）有一定偏好（理解为容易激活）</p><h3 id="脆弱性检测"><a href="#脆弱性检测" class="headerlink" title="脆弱性检测"></a>脆弱性检测</h3><p>深度学习网络的对抗鲁棒性和自然噪音鲁棒性往往呈现正相关。提高对抗鲁棒性利于整体鲁棒性的优化，这需要完备数据集的支撑。</p><p>问题：人工智能要想获得广泛使用，成为基础设施，就要有可靠性的保证。<br>挑战：建立完善的评估指标、技术规范和工具集，去测试其模型的可靠性。</p><h3 id="反脆弱加固"><a href="#反脆弱加固" class="headerlink" title="反脆弱加固"></a>反脆弱加固</h3><h4 id="数据端"><a href="#数据端" class="headerlink" title="数据端"></a>数据端</h4><p>过滤有害数据，但没有优化模型本身的反脆弱能力。</p><h5 id="1-污染检测"><a href="#1-污染检测" class="headerlink" title="1.污染检测"></a>1.污染检测</h5><p>对于数据进行domain迁移，数据增强，提高模型泛化能力</p><h5 id="2-污染抑制"><a href="#2-污染抑制" class="headerlink" title="2.污染抑制"></a>2.污染抑制</h5><p>增加防御补丁</p><h5 id="3-污染抑制"><a href="#3-污染抑制" class="headerlink" title="3.污染抑制"></a>3.污染抑制</h5><p>利用W-Distance来进行数据增强，提高模型泛化能力</p><h4 id="模型端：提高鲁棒性"><a href="#模型端：提高鲁棒性" class="headerlink" title="模型端：提高鲁棒性"></a>模型端：提高鲁棒性</h4><h5 id="1-训练加固"><a href="#1-训练加固" class="headerlink" title="1.训练加固"></a>1.训练加固</h5><p>模型单元增强：在中间层注入多样化的对抗噪音，提高鲁棒性，使其学习到更多的语义信息</p><h5 id="2-结构优化："><a href="#2-结构优化：" class="headerlink" title="2.结构优化："></a>2.结构优化：</h5><p>抑制脆弱路径：剪枝，压缩，稀疏化，量化，一定程度上可以抑制噪音<br>中心加权归一化BN进行神经网络模型数据分布整合，提高模型分布的稳定性和收敛性，改善了曲率</p><h1 id="Q-amp-A"><a href="#Q-amp-A" class="headerlink" title="Q&A"></a>Q&A</h1><ul><li>如何平衡模型的精确性和鲁棒性？<br>模型的精确性和鲁棒性使多因素共同作用下的结果，应该全面分析不同因素作用，综合考量设计优化目标</li><li>一种设想：大网络下的特定子网络结构具有鲁棒性</li></ul>]]></content>
<summary type="html"><p>Source:</p>
<p><a href="http://scl.sribd.cn/seminar/index.html">论坛网站</a>The 2nd Lecture</p>
<h1 id="引入"><a href="#引入" class="headerlink" </summary>
<category term="AISP" scheme="https://cyccyyycyc.github.io/categories/AISP/"/>
<category term="对抗样本" scheme="https://cyccyyycyc.github.io/tags/%E5%AF%B9%E6%8A%97%E6%A0%B7%E6%9C%AC/"/>
</entry>
<entry>
<title>数字图像处理</title>
<link href="https://cyccyyycyc.github.io/2022/10/18/%E6%95%B0%E5%AD%97%E5%9B%BE%E5%83%8F%E5%A4%84%E7%90%86/"/>
<id>https://cyccyyycyc.github.io/2022/10/18/%E6%95%B0%E5%AD%97%E5%9B%BE%E5%83%8F%E5%A4%84%E7%90%86/</id>
<published>2022-10-18T11:32:23.000Z</published>
<updated>2022-10-21T03:50:48.707Z</updated>
<content type="html"><![CDATA[<h3 id="图像基础"><a href="#图像基础" class="headerlink" title="图像基础"></a>图像基础</h3><h4 id="图片表示"><a href="#图片表示" class="headerlink" title="图片表示"></a>图片表示</h4><h5 id="二值图"><a href="#二值图" class="headerlink" title="二值图"></a>二值图</h5><p>只有2种取值</p><h5 id="灰度图"><a href="#灰度图" class="headerlink" title="灰度图"></a>灰度图</h5><p>unit8</p><p>8位灰度图（0~255）</p><p>二维矩阵（一个通道）</p><h5 id="彩色图"><a href="#彩色图" class="headerlink" title="彩色图"></a>彩色图</h5><p>三维矩阵（RGB三个通道）</p><p>真彩色</p><h3 id="通道的分离和合并"><a href="#通道的分离和合并" class="headerlink" title="通道的分离和合并"></a>通道的分离和合并</h3><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">img_bgr = cv.imread(img_path)</span><br><span class="line"><span class="comment"># 通道分离</span></span><br><span class="line">b, g, r = cv.split(img_bgr)</span><br><span class="line"><span class="comment"># 通道合并</span></span><br><span class="line">img_rgb = cv.merge([r, g, b])</span><br></pre></td></tr></table></figure><h3 id="彩色图转换成灰度图"><a href="#彩色图转换成灰度图" class="headerlink" title="彩色图转换成灰度图"></a>彩色图转换成灰度图</h3><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># 三通道按权值加权 0.299 0.587 0.114</span></span><br><span class="line">gray1 = <span class="number">0.299</span> * r + <span class="number">0.587</span> *g + <span class="number">0.114</span> *b</span><br><span class="line"><span class="comment"># dtype = uint8</span></span><br><span class="line">gray2 = np.uint8(gray1)</span><br><span class="line">gray3 = gray1.astype(np.uint8)</span><br><span class="line"></span><br><span class="line">gray4 = cv.cvtColor(img_bgr, cv.COLOR_BGR2GRAY)</span><br></pre></td></tr></table></figure><h3 id="图像二值化"><a href="#图像二值化" class="headerlink" title="图像二值化"></a>图像二值化</h3><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">thresh = <span class="number">125</span></span><br><span class="line">gray4[gray4 > thresh] = <span class="number">255</span></span><br><span class="line">gray4[gray4 <= thresh] = <span class="number">0</span></span><br><span class="line"><span class="comment"># gray4 已经被二值化</span></span><br><span class="line"></span><br><span class="line">ignore, img_bin = cv.threshold(gray_uint8_img, th1, th2, cv.THRESH_BINARY)</span><br></pre></td></tr></table></figure><h3 id="图像运算"><a href="#图像运算" class="headerlink" title="图像运算"></a>图像运算</h3><h5 id="图像相加"><a href="#图像相加" class="headerlink" title="图像相加"></a>图像相加</h5><p>混合图像、添加噪声</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># dtype = float64</span></span><br><span class="line">img_add1 = cv.add(img1*<span class="number">0.5</span>, img2*<span class="number">0.5</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># dtype = uint8</span></span><br><span class="line">img_add2 = cv.addWeighted(img1, alpha, img2, beta, gamma)</span><br></pre></td></tr></table></figure><h5 id="图像相减"><a href="#图像相减" class="headerlink" title="图像相减"></a>图像相减</h5><p>消除背景、差影法（比较差异，运动跟踪）</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">img_sub = cv.subtract(img1, img2)</span><br></pre></td></tr></table></figure><h5 id="图像相乘"><a href="#图像相乘" class="headerlink" title="图像相乘"></a>图像相乘</h5><p>掩膜mask</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">img = cv.multiply(img1, img2)</span><br></pre></td></tr></table></figure><h5 id="图像相除"><a href="#图像相除" class="headerlink" title="图像相除"></a>图像相除</h5><p>校正设备、比较差异</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">img = cv.divide(img1, img2)</span><br></pre></td></tr></table></figure><h3 id="图像变换"><a href="#图像变换" class="headerlink" title="图像变换"></a>图像变换</h3><h5 id="线性变换"><a href="#线性变换" class="headerlink" title="线性变换"></a>线性变换</h5><p>$$<br>s=b+kr<br>$$</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">img = cv.convertScaleAbs(img, alpha=1, beta=0)</span><br></pre></td></tr></table></figure><h5 id="非线性变换"><a href="#非线性变换" class="headerlink" title="非线性变换"></a>非线性变换</h5><p>$$<br>s=a+\frac{ln(r+1)}{blnc}<br>$$</p><h5 id="Gamma变换"><a href="#Gamma变换" class="headerlink" title="Gamma变换"></a>Gamma变换</h5><p>$$<br>s=cr^y<br>$$</p><p>y越大图像越亮</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">img = img / <span class="number">255</span></span><br><span class="line">img = np.power(img, y) * <span class="number">255</span></span><br></pre></td></tr></table></figure><h3 id="图像处理"><a href="#图像处理" class="headerlink" title="图像处理"></a>图像处理</h3><h5 id="裁剪"><a href="#裁剪" class="headerlink" title="裁剪"></a>裁剪</h5><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># numpy</span></span><br><span class="line">img = cv.imread(img_path)</span><br><span class="line"><span class="comment"># h * w * c</span></span><br><span class="line"><span class="comment"># y * x *c</span></span><br><span class="line">img = img[<span class="number">20</span>:<span class="number">100</span>, <span class="number">100</span>:<span class="number">200</span>, :]</span><br></pre></td></tr></table></figure><h5 id="放缩"><a href="#放缩" class="headerlink" title="放缩"></a>放缩</h5><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># OpenCv</span></span><br><span class="line"><span class="comment"># (x, y)=(w, h)=(500,400)</span></span><br><span class="line">img = cv.resize(img, (<span class="number">500</span>, <span class="number">400</span>))</span><br></pre></td></tr></table></figure><h5 id="平移"><a href="#平移" class="headerlink" title="平移"></a>平移</h5><p>仿射变换</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># 坐标的映射矩阵M</span></span><br><span class="line">M = np.array([...], dtype=np.float32)</span><br><span class="line">cv.warpAffine(img, M, dsize)</span><br></pre></td></tr></table></figure><h5 id="错切变换"><a href="#错切变换" class="headerlink" title="错切变换"></a>错切变换</h5><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">M = np.array([...], dtype=np.float32)</span><br><span class="line">img = cv.warpAffine(img, M, dsize)</span><br></pre></td></tr></table></figure><h5 id="镜像变换"><a href="#镜像变换" class="headerlink" title="镜像变换"></a>镜像变换</h5><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># 矩阵</span></span><br><span class="line">M = np.array([...], dtype=np.float32)</span><br><span class="line">img = cv.warpAffine(img, M, dsize)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 垂直镜像</span></span><br><span class="line">cv.flip(img, <span class="number">0</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 水平镜像</span></span><br><span class="line">cv.flip(img, <span class="number">1</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 同时进行</span></span><br><span class="line">cv.flit(img, -<span class="number">1</span>)</span><br></pre></td></tr></table></figure><h5 id="旋转变换"><a href="#旋转变换" class="headerlink" title="旋转变换"></a>旋转变换</h5><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># 旋转矩阵</span></span><br><span class="line">M = np.array([...], dtype=np.float32)</span><br><span class="line">img = cv.warpAffine(img, M, dsize)</span><br><span class="line"></span><br><span class="line"><span class="comment"># M = cv.getRotationMatrix2D(center, angle, scale)</span></span><br><span class="line">h, w, c = img.shape</span><br><span class="line"><span class="comment"># center = (x, y)</span></span><br><span class="line">M = cv.getRotationMatrix2D((w//<span class="number">2</span>, h//<span class="number">2</span>), <span class="number">45</span>)</span><br><span class="line">img = cv.warpAffine(img, M, dsize)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 顺时针逆时针旋转90°</span></span><br><span class="line">img_rotate = cv.rotate(img, cv.ROTATE_90_CLOCKWISE)</span><br></pre></td></tr></table></figure><h5 id="透视变换"><a href="#透视变换" class="headerlink" title="透视变换"></a>透视变换</h5><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">M = cv.getPerspectiveTransform(src, dst)</span><br><span class="line">img = cv.warpPerspective(img, M, dsize)</span><br></pre></td></tr></table></figure><h5 id="小总结"><a href="#小总结" class="headerlink" title="小总结"></a>小总结</h5><p>像素值没变，像素位置变了。<br>所以实际上计算了一个坐标变换的矩阵M。</p><h5 id="最近邻插值"><a href="#最近邻插值" class="headerlink" title="最近邻插值"></a>最近邻插值</h5><p>逆向思维：小图插值变大图 —> 大图变小图</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">img1 = cv.resize(img, dsize, interpolation=cv.INTER_NEAREST)</span><br></pre></td></tr></table></figure><h5 id="双线性插值"><a href="#双线性插值" class="headerlink" title="双线性插值"></a>双线性插值</h5><p>考虑邻近的像素点，按照权值计算。</p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">img1 = cv.resize(img, dsize, interpolation=cv.INTER_LINEAR_EXACT)</span><br></pre></td></tr></table></figure><h3 id="图像模糊"><a href="#图像模糊" class="headerlink" title="图像模糊"></a>图像模糊</h3><h5 id="卷积"><a href="#卷积" class="headerlink" title="卷积"></a>卷积</h5><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">img = cv.filter2D(img, -<span class="number">1</span>, kernel)</span><br></pre></td></tr></table></figure><h5 id="均值模糊"><a href="#均值模糊" class="headerlink" title="均值模糊"></a>均值模糊</h5><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">cv.blur(img, (<span class="number">5</span>,<span class="number">5</span>))</span><br><span class="line"></span><br><span class="line">cv.boxFilter(img, -<span class="number">1</span>, (<span class="number">5</span>,<span class="number">5</span>))</span><br></pre></td></tr></table></figure><h5 id="中值滤波"><a href="#中值滤波" class="headerlink" title="中值滤波"></a>中值滤波</h5><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">cv.medianBlur(img, <span class="number">3</span>) <span class="comment"># 奇数</span></span><br></pre></td></tr></table></figure><h5 id="高斯模糊"><a href="#高斯模糊" class="headerlink" title="高斯模糊"></a>高斯模糊</h5><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># sigma 方差</span></span><br><span class="line"><span class="comment"># 方差小则copy原图</span></span><br><span class="line"><span class="comment"># 方差大则和均值滤波差不多</span></span><br><span class="line">cv.GaussianBlur(img, (<span class="number">5</span>,<span class="number">5</span>), sigmaX)</span><br></pre></td></tr></table></figure><h5 id="双边滤波"><a href="#双边滤波" class="headerlink" title="双边滤波"></a>双边滤波</h5><p>一般模糊会丢失边缘信息，而双边滤波可以保留边缘高频信息，平滑颜色相近的地方。</p><p>需要一直更新卷积核的值：</p><ol><li>距离越远，加权值越小</li><li>颜色差异越大，加权值越小</li></ol><p>缺点：对高频噪声无滤波效果</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">cv.bilateralFilter(img, -1, sigmaColor=50, sigmaSpace=3)</span><br></pre></td></tr></table></figure><h3 id="图像边缘"><a href="#图像边缘" class="headerlink" title="图像边缘"></a>图像边缘</h3><p>……</p>]]></content>
<summary type="html"><h3 id="图像基础"><a href="#图像基础" class="headerlink" title="图像基础"></a>图像基础</h3><h4 id="图片表示"><a href="#图片表示" class="headerlink" title="图片表示"></a</summary>
<category term="cv" scheme="https://cyccyyycyc.github.io/categories/cv/"/>
</entry>
</feed>