-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathsearch.xml
More file actions
517 lines (412 loc) · 162 KB
/
search.xml
File metadata and controls
517 lines (412 loc) · 162 KB
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
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
<?xml version="1.0" encoding="utf-8"?>
<search>
<entry>
<title>Bfs/Dfs</title>
<url>/2022/10/09/Bfs:Dfs/</url>
<content><![CDATA[<h2 id="Bfs-x2F-Dfs"><a href="#Bfs-x2F-Dfs" class="headerlink" title="Bfs/Dfs"></a>Bfs/Dfs</h2><span id="more"></span>
<h3 id="Dfs"><a href="#Dfs" class="headerlink" title="Dfs"></a>Dfs</h3><h4 id="N皇后"><a href="#N皇后" class="headerlink" title="N皇后"></a>N皇后</h4><p>按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。</p>
<p>n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。</p>
<p>给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。</p>
<p>每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。</p>
<figure class="highlight java"><table><tr><td class="code"><pre><code class="hljs Java"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br> <span class="hljs-comment">//表示第几列已经有皇后了</span><br> Set<Integer> cols = <span class="hljs-keyword">new</span> <span class="hljs-title class_">HashSet</span><Integer>();<br> <span class="hljs-comment">//使用行下标减去列下标之差来表示对角线</span><br> Set<Integer> diagonals1 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">HashSet</span><Integer>();<br> Set<Integer> diagonals2 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">HashSet</span><Integer>();<br> <span class="hljs-keyword">public</span> List<List<String>> <span class="hljs-title function_">solveNQueens</span><span class="hljs-params">(<span class="hljs-type">int</span> n)</span> {<br> List<List<String>> solutions = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span><List<String>>();<br> <span class="hljs-comment">//表示第几行的皇后所在的列数，例如第一行第二列有皇后，则queens[0] = 1</span><br> <span class="hljs-type">int</span>[] queens = <span class="hljs-keyword">new</span> <span class="hljs-title class_">int</span>[n];<br> Arrays.fill(queens, -<span class="hljs-number">1</span>);<br> dfs(solutions, queens, n, <span class="hljs-number">0</span>);<br> <span class="hljs-keyword">return</span> solutions;<br> }<br> <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title function_">dfs</span><span class="hljs-params">(List<List<String>> solutions, <span class="hljs-type">int</span>[] queens, <span class="hljs-type">int</span> n, <span class="hljs-type">int</span> row)</span> {<br> <span class="hljs-keyword">if</span> (row == n) {<br> List<String> board = generateBoard(queens, n);<br> solutions.add(board);<br> <span class="hljs-keyword">return</span>;<br> }<br> <span class="hljs-comment">//遍历col</span><br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> <span class="hljs-variable">i</span> <span class="hljs-operator">=</span> <span class="hljs-number">0</span>; i < n; i++) {<br> <span class="hljs-comment">//先判断是否无法落皇后</span><br> <span class="hljs-type">int</span> <span class="hljs-variable">diagonal1</span> <span class="hljs-operator">=</span> row - i;<br> <span class="hljs-type">int</span> <span class="hljs-variable">diagonal2</span> <span class="hljs-operator">=</span> row + i;<br> <span class="hljs-keyword">if</span> (cols.contains(i)) <span class="hljs-keyword">continue</span>;<br> <span class="hljs-keyword">if</span> (diagonals1.contains(diagonal1)) <span class="hljs-keyword">continue</span>;<br> <span class="hljs-keyword">if</span> (diagonals2.contains(diagonal2)) <span class="hljs-keyword">continue</span>;<br> <span class="hljs-comment">//开始落皇后</span><br> queens[row] = i;<br> cols.add(i);<br> diagonals1.add(diagonal1);<br> diagonals2.add(diagonal2);<br> dfs(solutions, queens, n, row + <span class="hljs-number">1</span>);<br> <span class="hljs-comment">//恢复</span><br> queens[row] = -<span class="hljs-number">1</span>;<br> cols.remove(i);<br> diagonals1.remove(diagonal1);<br> diagonals2.remove(diagonal2);<br> }<br> }<br> <span class="hljs-keyword">public</span> List<String> <span class="hljs-title function_">generateBoard</span><span class="hljs-params">(<span class="hljs-type">int</span>[] queens, <span class="hljs-type">int</span> n)</span> {<br> List<String> board = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span><String>();<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> <span class="hljs-variable">i</span> <span class="hljs-operator">=</span> <span class="hljs-number">0</span>; i < n; i++) {<br> <span class="hljs-type">char</span>[] row = <span class="hljs-keyword">new</span> <span class="hljs-title class_">char</span>[n];<br> Arrays.fill(row, <span class="hljs-string">'.'</span>);<br> row[queens[i]] = <span class="hljs-string">'Q'</span>;<br> board.add(<span class="hljs-keyword">new</span> <span class="hljs-title class_">String</span>(row));<br> }<br> <span class="hljs-keyword">return</span> board;<br> }<br>}<br></code></pre></td></tr></table></figure>
<h4 id="组合总和-II"><a href="#组合总和-II" class="headerlink" title="组合总和 II"></a>组合总和 II</h4><p>给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。</p>
<p>candidates 中的每个数字在每个组合中只能使用 一次 。</p>
<p>注意：解集不能包含重复的组合。 </p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> vector<vector<<span class="hljs-type">int</span>>> ans;<br> vector<<span class="hljs-type">int</span>> t;<br> vector<<span class="hljs-type">int</span>> nums;<br><br> <span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">dfs</span><span class="hljs-params">(<span class="hljs-type">int</span> target, <span class="hljs-type">int</span> index)</span> </span>{<br> <span class="hljs-keyword">if</span> (target == <span class="hljs-number">0</span>) {<br> ans.<span class="hljs-built_in">push_back</span>(t);<br> <span class="hljs-keyword">return</span>;<br> }<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = index; i < nums.<span class="hljs-built_in">size</span>() && nums[i] <= target; i++) {<br> <span class="hljs-keyword">if</span> (i > index && nums[i] == nums[i - <span class="hljs-number">1</span>]) {<br> <span class="hljs-keyword">continue</span>;<br> }<br> t.<span class="hljs-built_in">push_back</span>(nums[i]);<br> <span class="hljs-built_in">dfs</span>(target - nums[i], i + <span class="hljs-number">1</span>);<br> t.<span class="hljs-built_in">pop_back</span>();<br> }<br> }<br><br> vector<vector<<span class="hljs-type">int</span>>> <span class="hljs-built_in">combinationSum2</span>(vector<<span class="hljs-type">int</span>>& candidates, <span class="hljs-type">int</span> target) {<br> nums = candidates;<br> <span class="hljs-built_in">sort</span>(nums.<span class="hljs-built_in">begin</span>(), nums.<span class="hljs-built_in">end</span>());<br> <span class="hljs-built_in">dfs</span>(target,<span class="hljs-number">0</span>);<br> <span class="hljs-keyword">return</span> ans;<br> }<br>};<br></code></pre></td></tr></table></figure>
<h4 id="岛屿的最大面积"><a href="#岛屿的最大面积" class="headerlink" title="岛屿的最大面积"></a>岛屿的最大面积</h4><img src="/2022/10/09/Bfs:Dfs/L695.png" class>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">private</span>:<br> <span class="hljs-type">int</span> max_x;<br> <span class="hljs-type">int</span> max_y;<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-type">const</span> <span class="hljs-type">int</span> dx[<span class="hljs-number">4</span>] = {<span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">1</span>};<br> <span class="hljs-type">const</span> <span class="hljs-type">int</span> dy[<span class="hljs-number">4</span>] = {<span class="hljs-number">-1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>};<br> <span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">dfs</span><span class="hljs-params">(vector<vector<<span class="hljs-type">int</span>>>& grid, <span class="hljs-type">int</span> y, <span class="hljs-type">int</span> x)</span> </span>{<br> <span class="hljs-keyword">if</span> (x < <span class="hljs-number">0</span> || y < <span class="hljs-number">0</span> || x >= max_x || y >= max_y || grid[y][x] == <span class="hljs-number">0</span>) <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;<br> grid[y][x] = <span class="hljs-number">0</span>;<br> <span class="hljs-type">int</span> ans = <span class="hljs-number">1</span>;<br><br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> k = <span class="hljs-number">0</span>; k < <span class="hljs-number">4</span>; k++) {<br> <span class="hljs-type">int</span> next_y = y + dy[k];<br> <span class="hljs-type">int</span> next_x = x + dx[k];<br> ans += <span class="hljs-built_in">dfs</span>(grid, next_y, next_x);<br> }<br><br> <span class="hljs-keyword">return</span> ans;<br><br> }<br> <span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">maxAreaOfIsland</span><span class="hljs-params">(vector<vector<<span class="hljs-type">int</span>>>& grid)</span> </span>{<br> <span class="hljs-type">int</span> area = <span class="hljs-number">0</span>;<br> max_y = grid.<span class="hljs-built_in">size</span>();<br> max_x = grid[<span class="hljs-number">0</span>].<span class="hljs-built_in">size</span>();<br><br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < max_y; i++) {<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> j = <span class="hljs-number">0</span>; j < max_x; j++) {<br> area = <span class="hljs-built_in">max</span>(area, <span class="hljs-built_in">dfs</span>(grid, i, j));<br> }<br> }<br><br> <span class="hljs-keyword">return</span> area;<br> }<br>};<br></code></pre></td></tr></table></figure>
<h4 id="岛屿数量"><a href="#岛屿数量" class="headerlink" title="岛屿数量"></a>岛屿数量</h4><p>给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。</p>
<p>岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。</p>
<p>此外，你可以假设该网格的四条边均被水包围。</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-type">int</span> dy[<span class="hljs-number">4</span>] = {<span class="hljs-number">1</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>};<br> <span class="hljs-type">int</span> dx[<span class="hljs-number">4</span>] = {<span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">-1</span>};<br> <span class="hljs-type">int</span> m = <span class="hljs-number">0</span>;<br> <span class="hljs-type">int</span> n = <span class="hljs-number">0</span>;<br> <span class="hljs-type">int</span> ans = <span class="hljs-number">0</span>;<br> <span class="hljs-function"><span class="hljs-type">bool</span> <span class="hljs-title">outOfRange</span><span class="hljs-params">(<span class="hljs-type">int</span> y, <span class="hljs-type">int</span> x)</span> </span>{<br> <span class="hljs-keyword">return</span> y < <span class="hljs-number">0</span> || y >= m || x < <span class="hljs-number">0</span> || x >= n;<br> }<br> <span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">dfs</span><span class="hljs-params">(vector<vector<<span class="hljs-type">char</span>>>& grid, <span class="hljs-type">int</span> y, <span class="hljs-type">int</span> x)</span> </span>{<br> grid[y][x] = <span class="hljs-string">'0'</span>;<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < <span class="hljs-number">4</span>; i++) {<br> <span class="hljs-type">int</span> ty = y + dy[i];<br> <span class="hljs-type">int</span> tx = x + dx[i];<br> <span class="hljs-keyword">if</span> (!<span class="hljs-built_in">outOfRange</span>(ty, tx) && grid[ty][tx] == <span class="hljs-string">'1'</span>) {<br> <span class="hljs-built_in">dfs</span>(grid, ty, tx);<br> }<br> }<br> }<br> <span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">numIslands</span><span class="hljs-params">(vector<vector<<span class="hljs-type">char</span>>>& grid)</span> </span>{<br> m = grid.<span class="hljs-built_in">size</span>();<br> n = grid[<span class="hljs-number">0</span>].<span class="hljs-built_in">size</span>();<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < m; i++) {<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> j = <span class="hljs-number">0</span>; j < n; j++) {<br> <span class="hljs-keyword">if</span> (grid[i][j] == <span class="hljs-string">'1'</span>) {<br> ans++;<br> <span class="hljs-built_in">dfs</span>(grid, i, j);<br> }<br> }<br> }<br> <span class="hljs-keyword">return</span> ans;<br> }<br>};<br></code></pre></td></tr></table></figure>
<h4 id="解数独"><a href="#解数独" class="headerlink" title="解数独"></a>解数独</h4><p>编写一个程序，通过填充空格来解决数独问题。</p>
<p>数独的解法需 <strong>遵循如下规则</strong>：</p>
<ol>
<li>数字 <code>1-9</code> 在每一行只能出现一次。</li>
<li>数字 <code>1-9</code> 在每一列只能出现一次。</li>
<li>数字 <code>1-9</code> 在每一个以粗实线分隔的 <code>3x3</code> 宫内只能出现一次。（请参考示例图）</li>
</ol>
<p>数独部分空格内已填入了数字，空白格用 <code>'.'</code> 表示。</p>
<img src="/2022/10/09/Bfs:Dfs/1.png" class>
<figure class="highlight java"><table><tr><td class="code"><pre><code class="hljs java"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br> <span class="hljs-keyword">private</span> <span class="hljs-type">boolean</span>[][] row = <span class="hljs-keyword">new</span> <span class="hljs-title class_">boolean</span>[<span class="hljs-number">9</span>][<span class="hljs-number">9</span>];<br> <span class="hljs-keyword">private</span> <span class="hljs-type">boolean</span>[][] col = <span class="hljs-keyword">new</span> <span class="hljs-title class_">boolean</span>[<span class="hljs-number">9</span>][<span class="hljs-number">9</span>];<br> <span class="hljs-keyword">private</span> <span class="hljs-type">boolean</span>[][][] block = <span class="hljs-keyword">new</span> <span class="hljs-title class_">boolean</span>[<span class="hljs-number">3</span>][<span class="hljs-number">3</span>][<span class="hljs-number">9</span>];<br> <span class="hljs-keyword">private</span> <span class="hljs-type">boolean</span> <span class="hljs-variable">valid</span> <span class="hljs-operator">=</span> <span class="hljs-literal">false</span>;<br> <span class="hljs-keyword">private</span> List<<span class="hljs-type">int</span>[]> spaces = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span><<span class="hljs-type">int</span>[]>();<br><br> <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title function_">solveSudoku</span><span class="hljs-params">(<span class="hljs-type">char</span>[][] board)</span> {<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> <span class="hljs-variable">i</span> <span class="hljs-operator">=</span> <span class="hljs-number">0</span>; i < <span class="hljs-number">9</span>; i++) {<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> <span class="hljs-variable">j</span> <span class="hljs-operator">=</span> <span class="hljs-number">0</span>; j < <span class="hljs-number">9</span>; j++) {<br> <span class="hljs-keyword">if</span> (board[i][j] == <span class="hljs-string">'.'</span>) {<br> spaces.add(<span class="hljs-keyword">new</span> <span class="hljs-title class_">int</span>[] {i, j});<br> } <span class="hljs-keyword">else</span> {<br> <span class="hljs-type">int</span> <span class="hljs-variable">dight</span> <span class="hljs-operator">=</span> board[i][j] - <span class="hljs-string">'0'</span> - <span class="hljs-number">1</span>;<br> Fill(i, j, dight, <span class="hljs-literal">true</span>);<br> }<br> }<br> }<br> dfs(board, <span class="hljs-number">0</span>);<br> }<br><br> <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title function_">Fill</span><span class="hljs-params">(<span class="hljs-type">int</span> i, <span class="hljs-type">int</span> j, <span class="hljs-type">int</span> dight, <span class="hljs-type">boolean</span> target)</span> {<br> row[i][dight] = target;<br> col[j][dight] = target;<br> block[i / <span class="hljs-number">3</span>][j / <span class="hljs-number">3</span>][dight] = target;<br> }<br><br> <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title function_">dfs</span><span class="hljs-params">(<span class="hljs-type">char</span>[][] board, <span class="hljs-type">int</span> pos)</span> {<br> <span class="hljs-keyword">if</span> (pos == spaces.size()) {<br> valid = <span class="hljs-literal">true</span>;<br> <span class="hljs-keyword">return</span>;<br> }<br> <span class="hljs-type">var</span> <span class="hljs-variable">space</span> <span class="hljs-operator">=</span> spaces.get(pos);<br> <span class="hljs-type">int</span> <span class="hljs-variable">i</span> <span class="hljs-operator">=</span> space[<span class="hljs-number">0</span>], j = space[<span class="hljs-number">1</span>];<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> <span class="hljs-variable">dight</span> <span class="hljs-operator">=</span> <span class="hljs-number">0</span>; dight < <span class="hljs-number">9</span> && !valid; dight++) {<br> <span class="hljs-keyword">if</span> (!row[i][dight] && !col[j][dight] && !block[i / <span class="hljs-number">3</span>][j / <span class="hljs-number">3</span>][dight]) {<br> Fill(i, j, dight, <span class="hljs-literal">true</span>);<br> board[i][j] = (<span class="hljs-type">char</span>)(dight + <span class="hljs-string">'0'</span> + <span class="hljs-number">1</span>);<br> dfs(board, pos + <span class="hljs-number">1</span>);<br> Fill(i, j, dight, <span class="hljs-literal">false</span>);<br> }<br> }<br> }<br>}<br></code></pre></td></tr></table></figure>
<h3 id="Bfs"><a href="#Bfs" class="headerlink" title="Bfs"></a>Bfs</h3><h4 id="填充每个节点的下一个右侧节点指针"><a href="#填充每个节点的下一个右侧节点指针" class="headerlink" title="填充每个节点的下一个右侧节点指针"></a>填充每个节点的下一个右侧节点指针</h4><img src="/2022/10/09/Bfs:Dfs/L116.png" class>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-comment">/*</span><br><span class="hljs-comment">// Definition for a Node.</span><br><span class="hljs-comment">class Node {</span><br><span class="hljs-comment">public:</span><br><span class="hljs-comment"> int val;</span><br><span class="hljs-comment"> Node* left;</span><br><span class="hljs-comment"> Node* right;</span><br><span class="hljs-comment"> Node* next;</span><br><span class="hljs-comment"></span><br><span class="hljs-comment"> Node() : val(0), left(NULL), right(NULL), next(NULL) {}</span><br><span class="hljs-comment"></span><br><span class="hljs-comment"> Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}</span><br><span class="hljs-comment"></span><br><span class="hljs-comment"> Node(int _val, Node* _left, Node* _right, Node* _next)</span><br><span class="hljs-comment"> : val(_val), left(_left), right(_right), next(_next) {}</span><br><span class="hljs-comment">};</span><br><span class="hljs-comment">*/</span><br><br><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function">Node* <span class="hljs-title">connect</span><span class="hljs-params">(Node* root)</span> </span>{<br> <span class="hljs-keyword">if</span> (root == <span class="hljs-literal">nullptr</span>) {<br> <span class="hljs-keyword">return</span> root;<br> }<br> queue<Node*> Q;<br> Q.<span class="hljs-built_in">push</span>(root);<br> <span class="hljs-keyword">while</span> (!Q.<span class="hljs-built_in">empty</span>()) {<br> <span class="hljs-type">int</span> size = Q.<span class="hljs-built_in">size</span>();<br> <span class="hljs-keyword">for</span>(<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < size; i++) {<br> Node* node = Q.<span class="hljs-built_in">front</span>();<br> Q.<span class="hljs-built_in">pop</span>();<br> <span class="hljs-keyword">if</span> (i < size - <span class="hljs-number">1</span>) {<br> node->next = Q.<span class="hljs-built_in">front</span>();<br> }<br> <span class="hljs-keyword">if</span> (node->left != <span class="hljs-literal">nullptr</span>) {<br> Q.<span class="hljs-built_in">push</span>(node->left);<br> }<br> <span class="hljs-keyword">if</span> (node->right != <span class="hljs-literal">nullptr</span>) {<br> Q.<span class="hljs-built_in">push</span>(node->right);<br> }<br> }<br> }<br> <br> <span class="hljs-keyword">return</span> root;<br> }<br>};<br></code></pre></td></tr></table></figure>
<h4 id="图像渲染"><a href="#图像渲染" class="headerlink" title="图像渲染"></a>图像渲染</h4><p>有一幅以 m x n 的二维整数数组表示的图画 image ，其中 image[i][j] 表示该图画的像素值大小。</p>
<p>你也被给予三个整数 sr , sc 和 newColor 。你应该从像素 image[sr][sc] 开始对图像进行 上色填充 。</p>
<p>为了完成 上色工作 ，从初始像素开始，记录初始坐标的 上下左右四个方向上 像素值与初始坐标相同的相连像素点，接着再记录这四个方向上符合条件的像素点与他们对应 四个方向上 像素值与初始坐标相同的相连像素点，……，重复该过程。将所有有记录的像素点的颜色值改为 newColor 。</p>
<p>最后返回 经过上色渲染后的图像 。</p>
<img src="/2022/10/09/Bfs:Dfs/L733.png" class>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-type">const</span> <span class="hljs-type">int</span> dx[<span class="hljs-number">4</span>] = {<span class="hljs-number">1</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">-1</span>};<br> <span class="hljs-type">const</span> <span class="hljs-type">int</span> dy[<span class="hljs-number">4</span>] = {<span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">0</span>};<br> vector<vector<<span class="hljs-type">int</span>>> <span class="hljs-built_in">floodFill</span>(vector<vector<<span class="hljs-type">int</span>>>& image, <span class="hljs-type">int</span> sr, <span class="hljs-type">int</span> sc, <span class="hljs-type">int</span> newColor) {<br> <span class="hljs-type">int</span> currColor = image[sr][sc];<br> <span class="hljs-keyword">if</span> (currColor == newColor) <span class="hljs-keyword">return</span> image;<br> <span class="hljs-type">int</span> n = image.<span class="hljs-built_in">size</span>(), m = image[<span class="hljs-number">0</span>].<span class="hljs-built_in">size</span>();<br> queue<pair<<span class="hljs-type">int</span>, <span class="hljs-type">int</span>>> que;<br> que.<span class="hljs-built_in">push</span>(<span class="hljs-built_in">make_pair</span>(sr, sc)); <span class="hljs-comment">//使用make_pair</span><br> image[sr][sc] = newColor;<br> <span class="hljs-keyword">while</span> (!que.<span class="hljs-built_in">empty</span>()) {<br> <span class="hljs-type">int</span> x = que.<span class="hljs-built_in">front</span>().first, y = que.<span class="hljs-built_in">front</span>().second;<br> que.<span class="hljs-built_in">pop</span>();<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < <span class="hljs-number">4</span>; i++) {<br> <span class="hljs-type">int</span> mx = x + dx[i], my = y + dy[i];<br> <span class="hljs-keyword">if</span> (mx >= <span class="hljs-number">0</span> && mx < n && my >= <span class="hljs-number">0</span> && my < m && image[mx][my] == currColor) {<br> que.<span class="hljs-built_in">push</span>(<span class="hljs-built_in">make_pair</span>(mx,my));<br> image[mx][my] = newColor;<br> }<br> }<br> }<br> <span class="hljs-keyword">return</span> image;<br> }<br>};<br></code></pre></td></tr></table></figure>
<h4 id="腐烂的橘子"><a href="#腐烂的橘子" class="headerlink" title="腐烂的橘子"></a>腐烂的橘子</h4><p>在给定的 m x n 网格 grid 中，每个单元格可以有以下三个值之一：</p>
<p>值 0 代表空单元格；<br>值 1 代表新鲜橘子；<br>值 2 代表腐烂的橘子。<br>每分钟，腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。</p>
<p>返回 直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1 。</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">orangesRotting</span><span class="hljs-params">(vector<vector<<span class="hljs-type">int</span>>>& grid)</span> </span>{<br> <span class="hljs-type">const</span> <span class="hljs-type">int</span> dy[<span class="hljs-number">4</span>] = {<span class="hljs-number">1</span>,<span class="hljs-number">-1</span>,<span class="hljs-number">0</span>,<span class="hljs-number">0</span>};<br> <span class="hljs-type">const</span> <span class="hljs-type">int</span> dx[<span class="hljs-number">4</span>] = {<span class="hljs-number">0</span>,<span class="hljs-number">0</span>,<span class="hljs-number">-1</span>,<span class="hljs-number">1</span>};<br> <span class="hljs-type">int</span> max_y = grid.<span class="hljs-built_in">size</span>();<br> <span class="hljs-type">int</span> max_x = grid[<span class="hljs-number">0</span>].<span class="hljs-built_in">size</span>();<br> queue<pair<<span class="hljs-type">int</span>,<span class="hljs-type">int</span>>> Q;<br> <span class="hljs-type">int</span> minute = <span class="hljs-number">0</span>;<br> <span class="hljs-type">int</span> cnt = <span class="hljs-number">0</span>;<br> <span class="hljs-type">int</span> time[max_y][max_x];<span class="hljs-comment">//橘子腐烂需要的时间</span><br> <span class="hljs-built_in">memset</span>(time, <span class="hljs-number">-1</span>, <span class="hljs-built_in">sizeof</span>(time));<br><br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < max_y; i++) {<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> j = <span class="hljs-number">0</span>; j < max_x; j++) {<br> <span class="hljs-keyword">if</span> (grid[i][j] == <span class="hljs-number">2</span>) {<br> Q.<span class="hljs-built_in">push</span>(<span class="hljs-built_in">make_pair</span>(i, j));<br> time[i][j] = <span class="hljs-number">0</span>;<br> } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (grid[i][j] == <span class="hljs-number">1</span>) {<br> cnt++;<br> }<br> }<br> }<br><br> <span class="hljs-keyword">while</span> (!Q.<span class="hljs-built_in">empty</span>()) {<br> pair<<span class="hljs-type">int</span>,<span class="hljs-type">int</span>> t = Q.<span class="hljs-built_in">front</span>();<br> Q.<span class="hljs-built_in">pop</span>();<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < <span class="hljs-number">4</span>; i++) {<br> <span class="hljs-type">int</span> x = t.second + dx[i];<br> <span class="hljs-type">int</span> y = t.first + dy[i];<br> <span class="hljs-keyword">if</span> (x >= <span class="hljs-number">0</span> && x < max_x && y >= <span class="hljs-number">0</span> && y < max_y && grid[y][x] == <span class="hljs-number">1</span>) {<br> grid[y][x] = <span class="hljs-number">2</span>;<br> Q.<span class="hljs-built_in">push</span>(<span class="hljs-built_in">make_pair</span>(y, x));<br> time[y][x] = time[t.first][t.second] + <span class="hljs-number">1</span>;<br> cnt--;<br> minute = time[y][x];<br> }<br> }<br> <br> }<br><br> <span class="hljs-keyword">return</span> cnt != <span class="hljs-number">0</span> ? <span class="hljs-number">-1</span> : minute;<br> }<br>};<br></code></pre></td></tr></table></figure>
]]></content>
<categories>
<category>算法</category>
</categories>
</entry>
<entry>
<title>Disjoint Set Union</title>
<url>/2022/11/03/Disjoint-Set-Union/</url>
<content><![CDATA[<h2 id="Disjoint-Set-Union"><a href="#Disjoint-Set-Union" class="headerlink" title="Disjoint Set Union"></a>Disjoint Set Union</h2><span id="more"></span>
<h2 id="小蓝鲸分组"><a href="#小蓝鲸分组" class="headerlink" title="小蓝鲸分组"></a>小蓝鲸分组</h2><p>小蓝鲸要去旅游，现在要将他们分成任意大小的 <strong>两组</strong>。由于，每个小蓝鲸都有可能不喜欢其他小蓝鲸，这样的两个小蓝鲸不应该分到一个组里。</p>
<p>现在需要你来判断给定的 n 个小蓝鲸(编号为1, 2 ..，n)是否能成功的分到两个组中。（提示：本题要采用并查集的方法）</p>
<h3 id="输入格式"><a href="#输入格式" class="headerlink" title="输入格式"></a>输入格式</h3><p>第一行输入 n 、 k ，分别表示小蓝鲸的个数和不能分在同一组的小蓝鲸对数</p>
<p>接下来 k 行每行两个整数，代表小蓝鲸的编号</p>
<h3 id="输出格式"><a href="#输出格式" class="headerlink" title="输出格式"></a>输出格式</h3><p>输出一行，若能成功分为两组则输出 true， 否则输出 false</p>
<h4 id="样例1"><a href="#样例1" class="headerlink" title="样例1"></a>样例1</h4><figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-number">4</span> <span class="hljs-number">3</span><br><span class="hljs-number">1</span> <span class="hljs-number">2</span><br><span class="hljs-number">1</span> <span class="hljs-number">3</span><br><span class="hljs-number">2</span> <span class="hljs-number">4</span><br><span class="hljs-comment">//true</span><br></code></pre></td></tr></table></figure>
<p>解释：</p>
<p>第一个组为[1, 4]，</p>
<p>第二个组为[2, 3]。</p>
<h4 id="样例2"><a href="#样例2" class="headerlink" title="样例2"></a>样例2</h4><figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-number">3</span> <span class="hljs-number">3</span><br><span class="hljs-number">1</span> <span class="hljs-number">2</span><br><span class="hljs-number">1</span> <span class="hljs-number">3</span><br><span class="hljs-number">2</span> <span class="hljs-number">3</span><br><span class="hljs-comment">//false</span><br></code></pre></td></tr></table></figure>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string"><iostream></span></span><br><span class="hljs-keyword">using</span> <span class="hljs-keyword">namespace</span> std;<br><span class="hljs-keyword">typedef</span> <span class="hljs-type">long</span> <span class="hljs-type">long</span> ll;<br><span class="hljs-meta">#<span class="hljs-keyword">define</span> N 10005</span><br><span class="hljs-type">int</span> a[N][<span class="hljs-number">2</span>];<br><span class="hljs-type">int</span> pre[N];<br><span class="hljs-comment">//改进查找算法：完成路径压缩，将 x的上级直接变为根结点，那么树的高度就会大大降低</span><br><span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">find</span><span class="hljs-params">(<span class="hljs-type">int</span> x)</span> </span>{<br> <span class="hljs-keyword">if</span>(pre[x] == x) <span class="hljs-keyword">return</span> x;<br> <span class="hljs-comment">//先找到根结点 root[x]，然后 pre[x]=root[x]</span><br> <span class="hljs-keyword">return</span> pre[x] = <span class="hljs-built_in">find</span>(pre[x]);<br>}<br><span class="hljs-comment">//判断两个结点是否连通</span><br><span class="hljs-function"><span class="hljs-type">bool</span> <span class="hljs-title">isSame</span><span class="hljs-params">(<span class="hljs-type">int</span> x, <span class="hljs-type">int</span> y)</span> </span>{<br> <span class="hljs-keyword">return</span> <span class="hljs-built_in">find</span>(x) == <span class="hljs-built_in">find</span>(y);<br>}<br><br><span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">join</span><span class="hljs-params">(<span class="hljs-type">int</span> x, <span class="hljs-type">int</span> y)</span> </span>{<br> <span class="hljs-type">int</span> rootx = <span class="hljs-built_in">find</span>(x);<br> <span class="hljs-type">int</span> rooty = <span class="hljs-built_in">find</span>(y);<br> <span class="hljs-keyword">if</span>(rootx != rooty) pre[rootx] = rooty;<br>}<br><br><span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">solve</span><span class="hljs-params">()</span> </span>{<br> <span class="hljs-type">int</span> n, k;<br> cin >> n >> k;<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < k; i++) cin >> a[i][<span class="hljs-number">0</span>] >> a[i][<span class="hljs-number">1</span>];<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">1</span>; i <= n; i++) pre[i] = i;<br> <span class="hljs-comment">//确立两个不一样的根</span><br> <span class="hljs-type">int</span> r1 = a[<span class="hljs-number">0</span>][<span class="hljs-number">0</span>], r2 = a[<span class="hljs-number">0</span>][<span class="hljs-number">1</span>];<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < k; i++) {<br> <span class="hljs-keyword">if</span> (<span class="hljs-built_in">isSame</span>(a[i][<span class="hljs-number">0</span>], r1)) {<br> <span class="hljs-built_in">join</span>(a[i][<span class="hljs-number">1</span>], r2);<br> } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (<span class="hljs-built_in">isSame</span>(a[i][<span class="hljs-number">0</span>], r2)) {<br> <span class="hljs-built_in">join</span>(a[i][<span class="hljs-number">1</span>], r1);<br> } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (<span class="hljs-built_in">isSame</span>(a[i][<span class="hljs-number">1</span>], r1)) {<br> <span class="hljs-built_in">join</span>(a[i][<span class="hljs-number">0</span>], r2);<br> } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (<span class="hljs-built_in">isSame</span>(a[i][<span class="hljs-number">1</span>], r2)) {<br> <span class="hljs-built_in">join</span>(a[i][<span class="hljs-number">0</span>], r1);<br> } <span class="hljs-keyword">else</span> {<br> <span class="hljs-built_in">join</span>(a[i][<span class="hljs-number">0</span>], r1);<br> <span class="hljs-built_in">join</span>(a[i][<span class="hljs-number">1</span>], r2);<br> }<br> <span class="hljs-keyword">if</span> (<span class="hljs-built_in">isSame</span>(a[i][<span class="hljs-number">0</span>], a[i][<span class="hljs-number">1</span>])) {<br> cout << <span class="hljs-string">"false"</span>;<br> <span class="hljs-built_in">exit</span>(<span class="hljs-number">0</span>);<br> }<br> }<br> cout << <span class="hljs-string">"true"</span>;<br>}<br><br><span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">main</span><span class="hljs-params">()</span> </span>{<br><br> <span class="hljs-built_in">solve</span>();<br> <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;<br>}<br><br></code></pre></td></tr></table></figure>
]]></content>
<categories>
<category>算法</category>
</categories>
</entry>
<entry>
<title>Data Structure</title>
<url>/2022/10/09/Data-Structure/</url>
<content><![CDATA[<p>Binary-Tree, HashMap, Stack, Heap</p>
<span id="more"></span>
<h3 id="Heap"><a href="#Heap" class="headerlink" title="Heap"></a>Heap</h3><h4 id="雇佣K位工人的总代价"><a href="#雇佣K位工人的总代价" class="headerlink" title="雇佣K位工人的总代价"></a>雇佣K位工人的总代价</h4><p>给你一个下标从 0 开始的整数数组 costs ，其中 costs[i] 是雇佣第 i 位工人的代价。</p>
<p>同时给你两个整数 k 和 candidates 。我们想根据以下规则恰好雇佣 k 位工人：</p>
<p>总共进行 k 轮雇佣，且每一轮恰好雇佣一位工人。<br>在每一轮雇佣中，从最前面 candidates 和最后面 candidates 人中选出代价最小的一位工人，如果有多位代价相同且最小的工人，选择下标更小的一位工人。<br>比方说，costs = [3,2,7,7,1,2] 且 candidates = 2 ，第一轮雇佣中，我们选择第 4 位工人，因为他的代价最小 [3,2,7,7,1,2] 。<br>第二轮雇佣，我们选择第 1 位工人，因为他们的代价与第 4 位工人一样都是最小代价，而且下标更小，[3,2,7,7,2] 。注意每一轮雇佣后，剩余工人的下标可能会发生变化。<br>如果剩余员工数目不足 candidates 人，那么下一轮雇佣他们中代价最小的一人，如果有多位代价相同且最小的工人，选择下标更小的一位工人。<br>一位工人只能被选择一次。<br>返回雇佣恰好 k 位工人的总代价。</p>
<h5 id="Java"><a href="#Java" class="headerlink" title="Java"></a>Java</h5><figure class="highlight java"><table><tr><td class="code"><pre><code class="hljs java"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br> <span class="hljs-keyword">public</span> <span class="hljs-type">long</span> <span class="hljs-title function_">totalCost</span><span class="hljs-params">(<span class="hljs-type">int</span>[] costs, <span class="hljs-type">int</span> k, <span class="hljs-type">int</span> candidates)</span> {<br> PriorityQueue<Integer> leftQueue = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PriorityQueue</span><>();<br> PriorityQueue<Integer> rightQueue = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PriorityQueue</span><>();<br> <span class="hljs-type">int</span> <span class="hljs-variable">n</span> <span class="hljs-operator">=</span> costs.length, l = <span class="hljs-number">0</span>, r = n - <span class="hljs-number">1</span>;<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> <span class="hljs-variable">i</span> <span class="hljs-operator">=</span> <span class="hljs-number">0</span>; i < candidates; i++) {<br> <span class="hljs-keyword">if</span> (l <= r) leftQueue.offer(costs[l++]);<br> <span class="hljs-keyword">if</span> (l <= r) rightQueue.offer(costs[r--]); <br> }<br> <span class="hljs-type">long</span> <span class="hljs-variable">totalCost</span> <span class="hljs-operator">=</span> <span class="hljs-number">0</span>;<br> <span class="hljs-keyword">while</span> (k > <span class="hljs-number">0</span>) {<br> k--;<br> <span class="hljs-type">int</span> <span class="hljs-variable">leftMin</span> <span class="hljs-operator">=</span> leftQueue.isEmpty() ? Integer.MAX_VALUE : leftQueue.peek();<br> <span class="hljs-type">int</span> <span class="hljs-variable">rightMin</span> <span class="hljs-operator">=</span> rightQueue.isEmpty() ? Integer.MAX_VALUE : rightQueue.peek();<br> <span class="hljs-keyword">if</span> (leftMin <= rightMin) {<br> leftQueue.poll();<br> <span class="hljs-keyword">if</span> (l <= r) {<br> leftQueue.offer(costs[l++]);<br> }<br> } <span class="hljs-keyword">else</span> {<br> rightQueue.poll();<br> <span class="hljs-keyword">if</span> (l <= r) {<br> rightQueue.offer(costs[r--]);<br> }<br> }<br> totalCost += Math.min(leftMin, rightMin);<br> }<br> <span class="hljs-keyword">return</span> totalCost;<br> }<br>}<br></code></pre></td></tr></table></figure>
<h5 id="Cpp"><a href="#Cpp" class="headerlink" title="Cpp"></a>Cpp</h5><figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function"><span class="hljs-type">long</span> <span class="hljs-type">long</span> <span class="hljs-title">totalCost</span><span class="hljs-params">(vector<<span class="hljs-type">int</span>>& costs, <span class="hljs-type">int</span> k, <span class="hljs-type">int</span> candidates)</span> </span>{<br> <span class="hljs-type">long</span> <span class="hljs-type">long</span> ans = <span class="hljs-number">0</span>;<br> priority_queue<<span class="hljs-type">int</span>, vector<<span class="hljs-type">int</span>>, greater<<span class="hljs-type">int</span>>> leftPq, rightPq;<br> <span class="hljs-type">int</span> n = costs.<span class="hljs-built_in">size</span>(), l = <span class="hljs-number">0</span>, r = n - <span class="hljs-number">1</span>;<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < candidates; i++) {<br> <span class="hljs-keyword">if</span> (l <= r) leftPq.<span class="hljs-built_in">push</span>(costs[l++]);<br> <span class="hljs-keyword">if</span> (l <= r) rightPq.<span class="hljs-built_in">push</span>(costs[r--]);<br> }<br> <span class="hljs-keyword">while</span> (k > <span class="hljs-number">0</span>) {<br> k--;<br> <span class="hljs-type">int</span> leftMin = leftPq.<span class="hljs-built_in">empty</span>() ? INT_MAX : leftPq.<span class="hljs-built_in">top</span>();<br> <span class="hljs-type">int</span> rightMin = rightPq.<span class="hljs-built_in">empty</span>() ? INT_MAX : rightPq.<span class="hljs-built_in">top</span>();<br> <span class="hljs-keyword">if</span> (leftMin <= rightMin) {<br> leftPq.<span class="hljs-built_in">pop</span>();<br> <span class="hljs-keyword">if</span> (l <= r) leftPq.<span class="hljs-built_in">push</span>(costs[l++]);<br> } <span class="hljs-keyword">else</span> {<br> rightPq.<span class="hljs-built_in">pop</span>();<br> <span class="hljs-keyword">if</span> (l <= r) rightPq.<span class="hljs-built_in">push</span>(costs[r--]);<br> }<br> ans += <span class="hljs-built_in">min</span>(leftMin, rightMin);<br> }<br> <span class="hljs-keyword">return</span> ans;<br> }<br>};<br></code></pre></td></tr></table></figure>
<h3 id="Binary-Tree"><a href="#Binary-Tree" class="headerlink" title="Binary-Tree"></a>Binary-Tree</h3><h4 id="合并二叉树"><a href="#合并二叉树" class="headerlink" title="合并二叉树"></a>合并二叉树</h4><p>给你两棵二叉树： root1 和 root2 。</p>
<p>想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。</p>
<p>返回合并后的二叉树。</p>
<p>注意: 合并过程必须从两个树的根节点开始。</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function">TreeNode* <span class="hljs-title">mergeTrees</span><span class="hljs-params">(TreeNode* root1, TreeNode* root2)</span> </span>{<br> <span class="hljs-keyword">if</span> (root1 == <span class="hljs-literal">nullptr</span> && root2 == <span class="hljs-literal">nullptr</span>) <span class="hljs-keyword">return</span> <span class="hljs-literal">nullptr</span>;<br> <span class="hljs-keyword">if</span> (root1 == <span class="hljs-literal">nullptr</span>) <span class="hljs-keyword">return</span> root2;<br> <span class="hljs-keyword">if</span> (root2 == <span class="hljs-literal">nullptr</span>) <span class="hljs-keyword">return</span> root1;<br> root1->val += root2->val;<br> <br> root1->left = <span class="hljs-built_in">mergeTrees</span>(root1->left, root2->left);<br> root1->right = <span class="hljs-built_in">mergeTrees</span>(root1->right, root2->right);<br><br> <span class="hljs-keyword">return</span> root1;<br><br> }<br>};<br></code></pre></td></tr></table></figure>
<h4 id="从前序与中序遍历序列构造二叉树"><a href="#从前序与中序遍历序列构造二叉树" class="headerlink" title="从前序与中序遍历序列构造二叉树"></a>从前序与中序遍历序列构造二叉树</h4><p>给定两个整数数组 <code>preorder</code> 和 <code>inorder</code> ，其中 <code>preorder</code> 是二叉树的<strong>先序遍历</strong>， <code>inorder</code> 是同一棵树的<strong>中序遍历</strong>，请构造二叉树并返回其根节点。</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> unordered_map<<span class="hljs-type">int</span>, <span class="hljs-type">int</span>> index;<br> <span class="hljs-function">TreeNode* <span class="hljs-title">dfs</span><span class="hljs-params">(vector<<span class="hljs-type">int</span>>& preorder, vector<<span class="hljs-type">int</span>>& inorder, <span class="hljs-type">int</span> pre_l, <span class="hljs-type">int</span> pre_r, <span class="hljs-type">int</span> in_l, <span class="hljs-type">int</span> in_r)</span> </span>{<br> <span class="hljs-keyword">if</span> (pre_l > pre_r) <span class="hljs-keyword">return</span> <span class="hljs-literal">nullptr</span>;<br> <span class="hljs-type">int</span> pre_root = pre_l;<br> <span class="hljs-type">int</span> in_root = index[preorder[pre_root]];<br> TreeNode *root = <span class="hljs-keyword">new</span> <span class="hljs-built_in">TreeNode</span>(preorder[pre_root]);<br> <span class="hljs-type">int</span> left_subtree_size = in_root - in_l;<br> root->left = <span class="hljs-built_in">dfs</span>(preorder, inorder, pre_l + <span class="hljs-number">1</span>, pre_l + left_subtree_size, in_l, in_root - <span class="hljs-number">1</span>);<br> root->right = <span class="hljs-built_in">dfs</span>(preorder, inorder, pre_l + left_subtree_size + <span class="hljs-number">1</span>, pre_r, in_root + <span class="hljs-number">1</span>, in_r);<br> <span class="hljs-keyword">return</span> root;<br> }<br> <span class="hljs-function">TreeNode* <span class="hljs-title">buildTree</span><span class="hljs-params">(vector<<span class="hljs-type">int</span>>& preorder, vector<<span class="hljs-type">int</span>>& inorder)</span> </span>{<br> <span class="hljs-type">int</span> n = preorder.<span class="hljs-built_in">size</span>();<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < n; i++) index[inorder[i]] = i;<br> <span class="hljs-keyword">return</span> <span class="hljs-built_in">dfs</span>(preorder, inorder, <span class="hljs-number">0</span>, n - <span class="hljs-number">1</span>, <span class="hljs-number">0</span>, n - <span class="hljs-number">1</span>);<br> }<br>};<br></code></pre></td></tr></table></figure>
<h4 id="二叉树的所有路径"><a href="#二叉树的所有路径" class="headerlink" title="二叉树的所有路径"></a>二叉树的所有路径</h4><p>给你一个二叉树的根节点 <code>root</code> ，按 <strong>任意顺序</strong> ，返回所有从根节点到叶子节点的路径。</p>
<p><strong>叶子节点</strong> 是指没有子节点的节点。</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">construct_paths</span><span class="hljs-params">(TreeNode* root, string path, vector<string>& paths)</span> </span>{<br> <span class="hljs-keyword">if</span> (root != <span class="hljs-literal">nullptr</span>) {<br> path += <span class="hljs-built_in">to_string</span>(root->val);<br> <span class="hljs-keyword">if</span> (root->left == <span class="hljs-literal">nullptr</span> && root->right == <span class="hljs-literal">nullptr</span>) { <br> paths.<span class="hljs-built_in">push_back</span>(path); <br> } <span class="hljs-keyword">else</span> {<br> path += <span class="hljs-string">"->"</span>; <span class="hljs-comment">// 当前节点不是叶子节点，继续递归遍历</span><br> <span class="hljs-built_in">construct_paths</span>(root->left, path, paths);<br> <span class="hljs-built_in">construct_paths</span>(root->right, path, paths);<br> }<br> }<br> }<br><br> <span class="hljs-function">vector<string> <span class="hljs-title">binaryTreePaths</span><span class="hljs-params">(TreeNode* root)</span> </span>{<br> vector<string> paths;<br> <span class="hljs-built_in">construct_paths</span>(root, <span class="hljs-string">""</span>, paths);<br> <span class="hljs-keyword">return</span> paths;<br> }<br>};<br></code></pre></td></tr></table></figure>
<p>使用string path来记录过程，简化回溯过程</p>
<h4 id="平衡二叉树"><a href="#平衡二叉树" class="headerlink" title="平衡二叉树"></a>平衡二叉树</h4><p>给定一个二叉树，判断它是否是高度平衡的二叉树。</p>
<p>本题中，一棵高度平衡二叉树定义为：</p>
<p>一个二叉树<em>每个节点</em> 的左右两个子树的高度差的绝对值不超过 1 </p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">height</span><span class="hljs-params">(TreeNode* root)</span> </span>{<br> <span class="hljs-keyword">if</span> (root == <span class="hljs-literal">nullptr</span>) {<br> <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;<br> }<br> <span class="hljs-keyword">return</span> <span class="hljs-built_in">max</span>(<span class="hljs-built_in">height</span>(root->left), <span class="hljs-built_in">height</span>(root->right)) + <span class="hljs-number">1</span>;<br> }<br> <span class="hljs-function"><span class="hljs-type">bool</span> <span class="hljs-title">isBalanced</span><span class="hljs-params">(TreeNode* root)</span> </span>{<br> <span class="hljs-keyword">if</span> (root == <span class="hljs-literal">nullptr</span>) {<br> <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;<br> }<br> <span class="hljs-keyword">return</span> <span class="hljs-built_in">abs</span>(<span class="hljs-built_in">height</span>(root->left) - <span class="hljs-built_in">height</span>(root->right)) <= <span class="hljs-number">1</span> && <span class="hljs-built_in">isBalanced</span>(root->left) && <span class="hljs-built_in">isBalanced</span>(root->right);<br> }<br>};<br></code></pre></td></tr></table></figure>
<h3 id="Hashmap"><a href="#Hashmap" class="headerlink" title="Hashmap"></a>Hashmap</h3><h4 id="字符串的排列"><a href="#字符串的排列" class="headerlink" title="字符串的排列"></a>字符串的排列</h4><p>给你两个字符串 s1 和 s2 ，写一个函数来判断 s2 是否包含 s1 的排列。如果是，返回 true ；否则，返回 false 。</p>
<p>换句话说，s1 的排列之一是 s2 的 子串 。</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function"><span class="hljs-type">bool</span> <span class="hljs-title">checkInclusion</span><span class="hljs-params">(string s1, string s2)</span> </span>{<br> <span class="hljs-type">int</span> n = s1.<span class="hljs-built_in">length</span>(), m = s2.<span class="hljs-built_in">length</span>();<br> <span class="hljs-keyword">if</span> (n > m) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;<br> <span class="hljs-function">vector<<span class="hljs-type">int</span>> <span class="hljs-title">cnt1</span><span class="hljs-params">(<span class="hljs-number">26</span>)</span>, <span class="hljs-title">cnt2</span><span class="hljs-params">(<span class="hljs-number">26</span>)</span></span>;<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < n; ++i) {<br> ++cnt1[s1[i] - <span class="hljs-string">'a'</span>];<br> ++cnt2[s2[i] - <span class="hljs-string">'a'</span>];<br> }<br> <span class="hljs-keyword">if</span> (cnt1 == cnt2) <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = n; i < m; ++i) {<br> ++cnt2[s2[i] - <span class="hljs-string">'a'</span>];<br> --cnt2[s2[i - n] - <span class="hljs-string">'a'</span>];<br> <span class="hljs-keyword">if</span> (cnt1 == cnt2) <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;<br> }<br> <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;<br> }<br>};<br></code></pre></td></tr></table></figure>
<h3 id="Stack"><a href="#Stack" class="headerlink" title="Stack"></a>Stack</h3><h4 id="删除字符串中的所有相邻重复项"><a href="#删除字符串中的所有相邻重复项" class="headerlink" title="删除字符串中的所有相邻重复项"></a>删除字符串中的所有相邻重复项</h4><p>给出由小写字母组成的字符串 <code>S</code>，<strong>重复项删除操作</strong>会选择两个相邻且相同的字母，并删除它们。</p>
<p>在 S 上反复执行重复项删除操作，直到无法继续删除。</p>
<p>在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function">string <span class="hljs-title">removeDuplicates</span><span class="hljs-params">(string s)</span> </span>{<br> string st;<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">char</span> c : s) {<br> <span class="hljs-keyword">if</span> (st.<span class="hljs-built_in">empty</span>() || c != st.<span class="hljs-built_in">back</span>()) {<br> st.<span class="hljs-built_in">push_back</span>(c);<br> } <span class="hljs-keyword">else</span> {<br> st.<span class="hljs-built_in">pop_back</span>();<br> }<br> }<br> <span class="hljs-keyword">return</span> st;<br> }<br>};<br></code></pre></td></tr></table></figure>
<p>利用cpp的string来模拟stack</p>
<h4 id="逆波兰表达式求值"><a href="#逆波兰表达式求值" class="headerlink" title="逆波兰表达式求值"></a>逆波兰表达式求值</h4><p>根据<a href="https://baike.baidu.com/item/%E9%80%86%E6%B3%A2%E5%85%B0%E5%BC%8F/128437"> 逆波兰表示法</a>，求表达式的值。</p>
<p>有效的算符包括 <code>+</code>、<code>-</code>、<code>*</code>、<code>/</code> 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。</p>
<p><strong>注意</strong> 两个整数之间的除法只保留整数部分。</p>
<p>可以保证给定的逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-comment">//由于官方改数据，所以要使用long long</span><br><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">evalRPN</span><span class="hljs-params">(vector<string>& tokens)</span> </span>{<br> stack<<span class="hljs-type">long</span> <span class="hljs-type">long</span>> st;<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < tokens.<span class="hljs-built_in">size</span>(); i++) {<br> <span class="hljs-keyword">if</span> (tokens[i] == <span class="hljs-string">"+"</span> || tokens[i] == <span class="hljs-string">"-"</span> || tokens[i] == <span class="hljs-string">"*"</span> || tokens[i] == <span class="hljs-string">"/"</span>) {<br> <span class="hljs-comment">//注意两个操作数的出栈顺序</span><br> <span class="hljs-type">long</span> <span class="hljs-type">long</span> op2 = st.<span class="hljs-built_in">top</span>();<br> st.<span class="hljs-built_in">pop</span>();<br> <span class="hljs-type">long</span> <span class="hljs-type">long</span> op1 = st.<span class="hljs-built_in">top</span>();<br> st.<span class="hljs-built_in">pop</span>();<br> <span class="hljs-keyword">if</span> (tokens[i] == <span class="hljs-string">"+"</span>) st.<span class="hljs-built_in">push</span>(op1 + op2);<br> <span class="hljs-keyword">if</span> (tokens[i] == <span class="hljs-string">"-"</span>) st.<span class="hljs-built_in">push</span>(op1 - op2);<br> <span class="hljs-keyword">if</span> (tokens[i] == <span class="hljs-string">"*"</span>) st.<span class="hljs-built_in">push</span>(op1 * op2);<br> <span class="hljs-keyword">if</span> (tokens[i] == <span class="hljs-string">"/"</span>) st.<span class="hljs-built_in">push</span>(op1 / op2);<br> } <span class="hljs-keyword">else</span> {<br> st.<span class="hljs-built_in">push</span>(<span class="hljs-built_in">stoll</span>(tokens[i]));<br> }<br> }<br><br> <span class="hljs-type">int</span> result = st.<span class="hljs-built_in">top</span>();<br> <span class="hljs-keyword">return</span> result;<br> }<br>};<br></code></pre></td></tr></table></figure>
<h4 id="解析布尔表达式"><a href="#解析布尔表达式" class="headerlink" title="解析布尔表达式"></a>解析布尔表达式</h4><p>给你一个以字符串形式表述的 布尔表达式（boolean） expression，返回该式的运算结果。</p>
<p>有效的表达式需遵循以下约定：</p>
<p>“t”，运算结果为 True<br>“f”，运算结果为 False<br>“!(expr)”，运算过程为对内部表达式 expr 进行逻辑 非的运算（NOT）<br>“&(expr1,expr2,…)”，运算过程为对 2 个或以上内部表达式 expr1, expr2, … 进行逻辑 与的运算（AND）<br>“|(expr1,expr2,…)”，运算过程为对 2 个或以上内部表达式 expr1, expr2, … 进行逻辑 或的运算（OR）</p>
<h5 id="题解"><a href="#题解" class="headerlink" title="题解"></a>题解</h5><img src="/2022/10/09/Data-Structure/1.png" class>
<figure class="highlight java"><table><tr><td class="code"><pre><code class="hljs java"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br> <span class="hljs-keyword">public</span> <span class="hljs-type">boolean</span> <span class="hljs-title function_">parseBoolExpr</span><span class="hljs-params">(String expression)</span> {<br> <span class="hljs-type">int</span> <span class="hljs-variable">n</span> <span class="hljs-operator">=</span> expression.length();<br> Deque<Character> stack = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayDeque</span><Character>();<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> <span class="hljs-variable">i</span> <span class="hljs-operator">=</span> <span class="hljs-number">0</span>; i < n; i++) {<br> <span class="hljs-type">char</span> <span class="hljs-variable">flag</span> <span class="hljs-operator">=</span> expression.charAt(i);<br> <span class="hljs-keyword">if</span> (flag == <span class="hljs-string">'c'</span>) {<br> <span class="hljs-keyword">continue</span>;<br> } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (flag != <span class="hljs-string">')'</span>) {<br> stack.push(flag);<br> } <span class="hljs-keyword">else</span> {<br> <span class="hljs-type">int</span> <span class="hljs-variable">t</span> <span class="hljs-operator">=</span> <span class="hljs-number">0</span>, f = <span class="hljs-number">0</span>;<br> <span class="hljs-keyword">while</span> (stack.peek() != <span class="hljs-string">'('</span>) {<br> <span class="hljs-type">char</span> <span class="hljs-variable">val</span> <span class="hljs-operator">=</span> stack.pop();<br> <span class="hljs-keyword">if</span> (val == <span class="hljs-string">'t'</span>) {<br> t++;<br> } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (val == <span class="hljs-string">'f'</span>) {<br> f++;<br> }<br> }<br> stack.pop();<br> <span class="hljs-type">char</span> <span class="hljs-variable">op</span> <span class="hljs-operator">=</span> stack.pop();<br> <span class="hljs-keyword">if</span> (op == <span class="hljs-string">'!'</span>) stack.push(f == <span class="hljs-number">1</span> ? <span class="hljs-string">'t'</span> : <span class="hljs-string">'f'</span>);<br> <span class="hljs-keyword">if</span> (op == <span class="hljs-string">'|'</span>) stack.push(t > <span class="hljs-number">0</span> ? <span class="hljs-string">'t'</span> : <span class="hljs-string">'f'</span>);<br> <span class="hljs-keyword">if</span> (op == <span class="hljs-string">'&'</span>) stack.push(f > <span class="hljs-number">0</span> ? <span class="hljs-string">'f'</span> : <span class="hljs-string">'t'</span>);<br> }<br> }<br> <span class="hljs-keyword">return</span> stack.pop() == <span class="hljs-string">'t'</span>;<br> }<br>}<br></code></pre></td></tr></table></figure>
]]></content>
<categories>
<category>算法</category>
</categories>
</entry>
<entry>
<title>Double Pointer</title>
<url>/2022/10/09/Double-Pointer/</url>
<content><![CDATA[<h3 id="Double-Pointer"><a href="#Double-Pointer" class="headerlink" title="Double Pointer"></a>Double Pointer</h3><span id="more"></span>
<h4 id="三数之和"><a href="#三数之和" class="headerlink" title="三数之和"></a>三数之和</h4><p><code>sort</code></p>
<p>给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请</p>
<p>你返回所有和为 0 且不重复的三元组。</p>
<p>注意：答案中不可以包含重复的三元组。</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> vector<vector<<span class="hljs-type">int</span>>> <span class="hljs-built_in">threeSum</span>(vector<<span class="hljs-type">int</span>>& nums) {<br> vector<vector<<span class="hljs-type">int</span>>> res;<br> <span class="hljs-type">int</span> n = nums.<span class="hljs-built_in">size</span>();<br> <span class="hljs-built_in">sort</span>(nums.<span class="hljs-built_in">begin</span>(), nums.<span class="hljs-built_in">end</span>());<br> <span class="hljs-type">int</span> i,j,k;<br> <span class="hljs-keyword">for</span> (i = <span class="hljs-number">0</span>; i < n - <span class="hljs-number">2</span>; i++) {<br> <span class="hljs-keyword">if</span> (i > <span class="hljs-number">0</span> && nums[i] == nums[i<span class="hljs-number">-1</span>]) <span class="hljs-keyword">continue</span>;<br> <span class="hljs-keyword">if</span> (nums[i] > <span class="hljs-number">0</span>) <span class="hljs-keyword">continue</span>;<br> j = i + <span class="hljs-number">1</span>;<br> k = n - <span class="hljs-number">1</span>;<br> <span class="hljs-keyword">while</span> (j < k) {<br> <span class="hljs-type">int</span> temp = nums[i] + nums[j] + nums[k];<br> <span class="hljs-keyword">if</span> (temp < <span class="hljs-number">0</span>) {<br> j++;<br> } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (temp > <span class="hljs-number">0</span>) {<br> k--;<br> } <span class="hljs-keyword">else</span> {<br> res.<span class="hljs-built_in">push_back</span>({nums[i], nums[j], nums[k]});<br> j++;<br> k--;<br> <span class="hljs-keyword">while</span> (j < k && nums[j] == nums[j<span class="hljs-number">-1</span>]) j++;<br> <span class="hljs-keyword">while</span> (j < k && nums[k] == nums[k+<span class="hljs-number">1</span>]) k--;<br> }<br> }<br> }<br> <span class="hljs-keyword">return</span> res;<br> }<br>};<br></code></pre></td></tr></table></figure>
]]></content>
<categories>
<category>算法</category>
</categories>
</entry>
<entry>
<title>Dp</title>
<url>/2022/10/09/Dp/</url>
<content><![CDATA[<h3 id="Dp"><a href="#Dp" class="headerlink" title="Dp"></a>Dp</h3><span id="more"></span>
<h4 id="最长回文子串"><a href="#最长回文子串" class="headerlink" title="最长回文子串"></a>最长回文子串</h4><p>给你一个字符串 <code>s</code>，找到 <code>s</code> 中最长的回文子串。</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function">string <span class="hljs-title">longestPalindrome</span><span class="hljs-params">(string s)</span> </span>{<br> <span class="hljs-type">int</span> n = s.<span class="hljs-built_in">size</span>();<br> <span class="hljs-keyword">if</span> (n < <span class="hljs-number">2</span>) {<br> <span class="hljs-keyword">return</span> s;<br> }<br> <span class="hljs-type">bool</span> dp[n][n];<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < n; i++) {<br> dp[i][i] = <span class="hljs-literal">true</span>;<br> }<br> <span class="hljs-type">int</span> maxlen = <span class="hljs-number">1</span>;<br> <span class="hljs-type">int</span> begin = <span class="hljs-number">0</span>;<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> l = <span class="hljs-number">2</span>; l <= n; l++) {<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < n; i++) {<br> <span class="hljs-type">int</span> j = l + i - <span class="hljs-number">1</span>;<br> <span class="hljs-keyword">if</span> (j >= n) {<br> <span class="hljs-keyword">break</span>;<br> }<br> <span class="hljs-keyword">if</span> (s[i] != s[j]) {<br> dp[i][j] = <span class="hljs-literal">false</span>;<br> } <span class="hljs-keyword">else</span> {<br> dp[i][j] = (j - i < <span class="hljs-number">3</span>) ? <span class="hljs-literal">true</span> : dp[i + <span class="hljs-number">1</span>][j - <span class="hljs-number">1</span>];<br> <span class="hljs-keyword">if</span> (dp[i][j] && j - i + <span class="hljs-number">1</span> > maxlen) {<br> maxlen = j - i + <span class="hljs-number">1</span>;<br> begin = i;<br> }<br> }<br> }<br><br> }<br> <span class="hljs-keyword">return</span> s.<span class="hljs-built_in">substr</span>(begin, maxlen);<br> }<br>};<br></code></pre></td></tr></table></figure>
<h4 id="最长有效括号"><a href="#最长有效括号" class="headerlink" title="最长有效括号"></a>最长有效括号</h4><p>给你一个只包含 <code>'('</code> 和 <code>')'</code> 的字符串，找出最长有效（格式正确且连续）括号子串的长度。</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">longestValidParentheses</span><span class="hljs-params">(string s)</span> </span>{<br> <br> <span class="hljs-type">int</span> n = s.<span class="hljs-built_in">length</span>();<br> <span class="hljs-type">int</span> ans = <span class="hljs-number">0</span>;<br> <span class="hljs-keyword">if</span> (n == <span class="hljs-number">0</span>) <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;<br> <span class="hljs-type">int</span> dp[n];<br> <span class="hljs-built_in">memset</span>(dp, <span class="hljs-number">0</span>, <span class="hljs-built_in">sizeof</span>(dp));<span class="hljs-comment">//dp[i] means the longest valid bracket list which ends with index of i</span><br> <br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">1</span>; i < n; i++) {<br> <span class="hljs-keyword">if</span> (s[i] == <span class="hljs-string">')'</span>) {<br> <span class="hljs-keyword">if</span> (s[i<span class="hljs-number">-1</span>] == <span class="hljs-string">'('</span>) {<br> dp[i] += (i >= <span class="hljs-number">2</span> ? dp[i<span class="hljs-number">-2</span>] : <span class="hljs-number">0</span>) + <span class="hljs-number">2</span>;<br> } <span class="hljs-keyword">else</span> {<br> <span class="hljs-keyword">if</span> (i - dp[i<span class="hljs-number">-1</span>] - <span class="hljs-number">1</span> >= <span class="hljs-number">0</span> && s[i - dp[i<span class="hljs-number">-1</span>] - <span class="hljs-number">1</span>] == <span class="hljs-string">'('</span>) {<br> <span class="hljs-keyword">if</span> (i - dp[i<span class="hljs-number">-1</span>] - <span class="hljs-number">2</span> >= <span class="hljs-number">0</span>) {<br> dp[i] = (dp[i - dp[i<span class="hljs-number">-1</span>] - <span class="hljs-number">2</span>] ? dp[i - dp[i<span class="hljs-number">-1</span>] - <span class="hljs-number">2</span>] : <span class="hljs-number">0</span>) + dp[i<span class="hljs-number">-1</span>] + <span class="hljs-number">2</span>;<br> } <span class="hljs-keyword">else</span> {<br> dp[i] = dp[i<span class="hljs-number">-1</span>] + <span class="hljs-number">2</span>;<br> }<br> }<br> }<br> } <br> ans = <span class="hljs-built_in">max</span>(ans, dp[i]);<br> }<br><br> <span class="hljs-keyword">return</span> ans;<br> }<br>};<br></code></pre></td></tr></table></figure>
<h4 id="打家劫舍"><a href="#打家劫舍" class="headerlink" title="打家劫舍"></a>打家劫舍</h4><p>你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。</p>
<p>给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">rob</span><span class="hljs-params">(vector<<span class="hljs-type">int</span>>& nums)</span> </span>{<br> <span class="hljs-type">int</span> n = nums.<span class="hljs-built_in">size</span>();<br> <span class="hljs-type">int</span> dp[n];<br> <span class="hljs-keyword">if</span> (n == <span class="hljs-number">1</span>) <span class="hljs-keyword">return</span> nums[<span class="hljs-number">0</span>];<br> dp[<span class="hljs-number">0</span>] = nums[<span class="hljs-number">0</span>];<br> dp[<span class="hljs-number">1</span>] = <span class="hljs-built_in">max</span>(nums[<span class="hljs-number">0</span>], nums[<span class="hljs-number">1</span>]);<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">2</span>; i < n; i++) {<br> dp[i] = <span class="hljs-built_in">max</span>(dp[i<span class="hljs-number">-1</span>], dp[i<span class="hljs-number">-2</span>] + nums[i]);<br> }<br> <span class="hljs-keyword">return</span> dp[n<span class="hljs-number">-1</span>];<br><br> }<br>};<br></code></pre></td></tr></table></figure>
<p>这道题是非常经典的dp入门题，对于相邻状态的处理有非常好的理解作用</p>
<h4 id="删除并获得点数"><a href="#删除并获得点数" class="headerlink" title="删除并获得点数"></a>删除并获得点数</h4><p>给你一个整数数组 nums ，你可以对它进行一些操作。</p>
<p>每次操作中，选择任意一个 nums[i] ，删除它并获得 nums[i] 的点数。之后，你必须删除 所有 等于 nums[i] - 1 和 nums[i] + 1 的元素。</p>
<p>开始你拥有 0 个点数。返回你能通过这些操作获得的最大点数。</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">private</span>:<br> <span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">rob</span><span class="hljs-params">(vector<<span class="hljs-type">int</span>> &nums)</span> </span>{<br> <span class="hljs-type">int</span> size = nums.<span class="hljs-built_in">size</span>();<br> <span class="hljs-type">int</span> first = nums[<span class="hljs-number">0</span>], second = <span class="hljs-built_in">max</span>(nums[<span class="hljs-number">0</span>], nums[<span class="hljs-number">1</span>]);<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">2</span>; i < size; i++) {<br> <span class="hljs-type">int</span> temp = second;<br> second = <span class="hljs-built_in">max</span>(first + nums[i], second);<br> first = temp;<br> }<br> <span class="hljs-keyword">return</span> second;<br> }<br><br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">deleteAndEarn</span><span class="hljs-params">(vector<<span class="hljs-type">int</span>> &nums)</span> </span>{<br> <span class="hljs-type">int</span> maxVal = <span class="hljs-number">0</span>;<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> val : nums) {<br> maxVal = <span class="hljs-built_in">max</span>(maxVal, val);<br> }<br> <span class="hljs-function">vector<<span class="hljs-type">int</span>> <span class="hljs-title">sum</span><span class="hljs-params">(maxVal + <span class="hljs-number">1</span>)</span></span>;<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> val : nums) {<br> sum[val] += val;<br> }<br> <span class="hljs-keyword">return</span> <span class="hljs-built_in">rob</span>(sum);<br> }<br>};<br></code></pre></td></tr></table></figure>
<p>注意这道题目用到了打家劫舍的模型</p>
<h4 id="环形子数组的最大和-Kanade-算法"><a href="#环形子数组的最大和-Kanade-算法" class="headerlink" title="环形子数组的最大和(Kanade 算法)"></a>环形子数组的最大和(Kanade 算法)</h4><img src="/2022/10/09/Dp/L918.png" class>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">maxSubarraySumCircular</span><span class="hljs-params">(vector<<span class="hljs-type">int</span>>& A)</span> </span>{<br> <span class="hljs-comment">//统一注释，total为数组的总和，maxSum为最大子数组和，minSum为最小子数组和，curMax为包含当前元素的最大子数组和，curMin为包含当前元素的最小子数组和</span><br> <span class="hljs-type">int</span> total = <span class="hljs-number">0</span>, maxSum = A[<span class="hljs-number">0</span>], curMax = <span class="hljs-number">0</span>, minSum = A[<span class="hljs-number">0</span>], curMin = <span class="hljs-number">0</span>;<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> a : A) {<br> curMax = <span class="hljs-built_in">max</span>(curMax + a, a);<br> maxSum = <span class="hljs-built_in">max</span>(maxSum, curMax);<br> curMin = <span class="hljs-built_in">min</span>(curMin + a, a);<br> minSum = <span class="hljs-built_in">min</span>(minSum, curMin);<br> total += a;<br> }<br> <span class="hljs-keyword">return</span> maxSum > <span class="hljs-number">0</span> ? <span class="hljs-built_in">max</span>(maxSum, total - minSum) : maxSum;<br> <span class="hljs-comment">//如果元素都是非正的话,要分类讨论</span><br> }<br><br>};<br></code></pre></td></tr></table></figure>
]]></content>
<categories>
<category>算法</category>
</categories>
</entry>
<entry>
<title>Finite State Machine</title>
<url>/2022/11/07/Finite-State-Machine/</url>
<content><![CDATA[<h2 id="有效状态机"><a href="#有效状态机" class="headerlink" title="有效状态机"></a>有效状态机</h2><span id="more"></span>
<h3 id="有效数字"><a href="#有效数字" class="headerlink" title="有效数字"></a>有效数字</h3><p>有效数字（按顺序）可以分成以下几个部分：</p>
<p>一个 小数 或者 整数<br>（可选）一个 ‘e’ 或 ‘E’ ，后面跟着一个 整数<br>小数（按顺序）可以分成以下几个部分：</p>
<p>（可选）一个符号字符（’+’ 或 ‘-‘）<br>下述格式之一：<br>至少一位数字，后面跟着一个点 ‘.’<br>至少一位数字，后面跟着一个点 ‘.’ ，后面再跟着至少一位数字<br>一个点 ‘.’ ，后面跟着至少一位数字<br>整数（按顺序）可以分成以下几个部分：</p>
<p>（可选）一个符号字符（’+’ 或 ‘-‘）<br>至少一位数字<br>部分有效数字列举如下：[“2”, “0089”, “-0.1”, “+3.14”, “4.”, “-.9”, “2e10”, “-90E3”, “3e+7”, “+6e-1”, “53.5e93”, “-123.456e789”]</p>
<p>部分无效数字列举如下：[“abc”, “1a”, “1e”, “e3”, “99e2.5”, “–6”, “-+3”, “95a54e53”]</p>
<p>给你一个字符串 s ，如果 s 是一个 有效数字 ，请返回 true 。</p>
<h4 id="分析（表驱动法）"><a href="#分析（表驱动法）" class="headerlink" title="分析（表驱动法）"></a>分析（表驱动法）</h4><p>构建出来的状态机如封面图片所示（红色为 终止状态，蓝色为 中间状态）。根据《编译原理》的解释，DFA 从状态 0 接受串 s 作为输入。当s耗尽的时候如果当前状态处于中间状态，则拒绝；如果到达终止状态，则接受。</p>
<p>然后，根据 DFA 列出如下的状态跳转表，之后我们就可以采用 表驱动法 进行编程实现了。需要注意的是，这里面多了一个状态 8，是用于处理串后面的若干个多余空格的。所以，所有的终止态都要跟上一个状态 8。其中，有一些状态标识为-1，是表示遇到了一些意外的字符，可以直接停止后续的计算。状态跳转表如下：</p>
<img src="/2022/11/07/Finite-State-Machine/1.png" class>
<img src="/2022/11/07/Finite-State-Machine/2.png" class>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function"><span class="hljs-type">bool</span> <span class="hljs-title">isNumber</span><span class="hljs-params">(string s)</span> </span>{<br> <span class="hljs-keyword">if</span>(s.<span class="hljs-built_in">empty</span>()) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;<br> <span class="hljs-type">int</span> n = s.<span class="hljs-built_in">size</span>();<br><br> <span class="hljs-type">int</span> state = <span class="hljs-number">0</span>;<br> <span class="hljs-function">vector<<span class="hljs-type">bool</span>> <span class="hljs-title">finals</span><span class="hljs-params">({<span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">0</span>, <span class="hljs-number">1</span>})</span></span>; <span class="hljs-comment">// 合法的终止状态</span><br> vector<vector<<span class="hljs-type">int</span>> > <span class="hljs-built_in">transfer</span>({<br> {<span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">6</span>, <span class="hljs-number">2</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">-1</span>},<br> {<span class="hljs-number">-1</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">6</span>, <span class="hljs-number">2</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">-1</span>},<br> {<span class="hljs-number">-1</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">3</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">-1</span>},<br> {<span class="hljs-number">8</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">3</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">4</span>, <span class="hljs-number">-1</span>},<br> {<span class="hljs-number">-1</span>, <span class="hljs-number">7</span>, <span class="hljs-number">5</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">-1</span>},<br> {<span class="hljs-number">8</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">5</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">-1</span>},<br> {<span class="hljs-number">8</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">6</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">-1</span>},<br> {<span class="hljs-number">-1</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">5</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">-1</span>},<br> {<span class="hljs-number">8</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">-1</span>, <span class="hljs-number">-1</span>},<br> });<br><br> <span class="hljs-keyword">for</span>(<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < n; ++i) {<br> state = transfer[state][_make(s[i])];<br> <span class="hljs-keyword">if</span>(state < <span class="hljs-number">0</span>) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;<br> }<br> <span class="hljs-keyword">return</span> finals[state];<br> }<br><br> <span class="hljs-type">int</span> _make(<span class="hljs-type">const</span> <span class="hljs-type">char</span>& c) {<br> <span class="hljs-keyword">switch</span>(c) {<br> <span class="hljs-keyword">case</span> <span class="hljs-string">' '</span>: <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;<br> <span class="hljs-keyword">case</span> <span class="hljs-string">'+'</span>: <span class="hljs-keyword">return</span> <span class="hljs-number">1</span>;<br> <span class="hljs-keyword">case</span> <span class="hljs-string">'-'</span>: <span class="hljs-keyword">return</span> <span class="hljs-number">1</span>;<br> <span class="hljs-keyword">case</span> <span class="hljs-string">'.'</span>: <span class="hljs-keyword">return</span> <span class="hljs-number">3</span>;<br> <span class="hljs-keyword">case</span> <span class="hljs-string">'e'</span>: <span class="hljs-keyword">return</span> <span class="hljs-number">4</span>;<br> <span class="hljs-keyword">case</span> <span class="hljs-string">'E'</span>: <span class="hljs-keyword">return</span> <span class="hljs-number">4</span>;<br> <span class="hljs-keyword">default</span>: <span class="hljs-keyword">return</span> _number(c);<br> }<br> }<br><br> <span class="hljs-type">int</span> _number(<span class="hljs-type">const</span> <span class="hljs-type">char</span>& c) {<br> <span class="hljs-keyword">if</span>(c >= <span class="hljs-string">'0'</span> && c <= <span class="hljs-string">'9'</span>)<br> <span class="hljs-keyword">return</span> <span class="hljs-number">2</span>;<br> <span class="hljs-keyword">else</span><br> <span class="hljs-keyword">return</span> <span class="hljs-number">5</span>;<br> }<br>};<br></code></pre></td></tr></table></figure>
]]></content>
<categories>
<category>算法</category>
</categories>
</entry>
<entry>
<title>Greedy</title>
<url>/2022/10/12/Greedy/</url>
<content><![CDATA[<h3 id="Greedy"><a href="#Greedy" class="headerlink" title="Greedy"></a>Greedy</h3><span id="more"></span>
<h4 id="最多重叠区间的区间数量"><a href="#最多重叠区间的区间数量" class="headerlink" title="最多重叠区间的区间数量"></a>最多重叠区间的区间数量</h4><p>给定一个数字m，和m组区间</p>
<p>输出具有最多重叠区间的区间数量</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-meta">#<span class="hljs-keyword">include</span><span class="hljs-string"><iostream></span></span><br><span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string"><vector></span></span><br><br><span class="hljs-keyword">using</span> <span class="hljs-keyword">namespace</span> std;<br><br><span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">main</span><span class="hljs-params">()</span> </span>{<br><br> <span class="hljs-type">int</span> m;<br> cin >> m;<br> vector<pair<<span class="hljs-type">int</span>, <span class="hljs-type">int</span>>> <span class="hljs-built_in">v</span>(m);<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < m; i++) cin >> v[i].first >> v[i].second;<br> <span class="hljs-keyword">auto</span> cmp = [](pair<<span class="hljs-type">int</span>, <span class="hljs-type">int</span>> p1, pair<<span class="hljs-type">int</span>, <span class="hljs-type">int</span>> p2) {<br> <span class="hljs-keyword">return</span> p1.second < p2.second;<br> };<br> <span class="hljs-built_in">sort</span>(v.<span class="hljs-built_in">begin</span>(), v.<span class="hljs-built_in">end</span>(), cmp);<br> <span class="hljs-type">int</span> ans = <span class="hljs-number">0</span>, cur = v[<span class="hljs-number">0</span>].second, cnt = <span class="hljs-number">0</span>;<br> <span class="hljs-keyword">for</span> (<span class="hljs-keyword">auto</span> p : v) {<br> <span class="hljs-keyword">if</span> (p.first > cur) { <span class="hljs-comment">//此处是闭区间的情况，如果是开区间那么则是>=</span><br> cur = p.second;<br> ans = <span class="hljs-built_in">max</span>(ans,cnt);<br> } <span class="hljs-keyword">else</span> {<br> cnt++;<br> }<br> }<br> ans = <span class="hljs-built_in">max</span>(ans, cnt);<br><br> cout << ans;<br><br> <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;<br>}<br><br><br></code></pre></td></tr></table></figure>
<p>这道题目的变式：</p>
<h4 id="用最少数量的箭引爆气球"><a href="#用最少数量的箭引爆气球" class="headerlink" title="用最少数量的箭引爆气球"></a>用最少数量的箭引爆气球</h4><p>有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 <code>points</code> ，其中<code>points[i] = [xstart, xend]</code> 表示水平直径在 <code>xstart</code> 和 <code>xend</code>之间的气球。你不知道气球的确切 y 坐标。</p>
<p>一支弓箭可以沿着 x 轴从不同点 <strong>完全垂直</strong> 地射出。在坐标 <code>x</code> 处射出一支箭，若有一个气球的直径的开始和结束坐标为 <code>xstart</code>，<code>xend</code>， 且满足 <code>xstart ≤ x ≤ xend</code>，则该气球会被 <strong>引爆</strong> 。可以射出的弓箭的数量 <strong>没有限制</strong> 。 弓箭一旦被射出之后，可以无限地前进。</p>
<p>给你一个数组 <code>points</code> ，<em>返回引爆所有气球所必须射出的 <strong>最小</strong> 弓箭数</em> 。</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">findMinArrowShots</span><span class="hljs-params">(vector<vector<<span class="hljs-type">int</span>>>& points)</span> </span>{<br> <span class="hljs-keyword">if</span> (points.<span class="hljs-built_in">empty</span>()) {<br> <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;<br> }<br> <span class="hljs-built_in">sort</span>(points.<span class="hljs-built_in">begin</span>(), points.<span class="hljs-built_in">end</span>(), [](<span class="hljs-type">const</span> vector<<span class="hljs-type">int</span>>& u, <span class="hljs-type">const</span> vector<<span class="hljs-type">int</span>>& v) {<br> <span class="hljs-keyword">return</span> u[<span class="hljs-number">1</span>] < v[<span class="hljs-number">1</span>];<br> });<br> <span class="hljs-type">int</span> pos = points[<span class="hljs-number">0</span>][<span class="hljs-number">1</span>];<br> <span class="hljs-type">int</span> ans = <span class="hljs-number">1</span>;<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">const</span> vector<<span class="hljs-type">int</span>>& balloon: points) {<br> <span class="hljs-keyword">if</span> (balloon[<span class="hljs-number">0</span>] > pos) {<br> pos = balloon[<span class="hljs-number">1</span>];<br> ++ans;<br> }<br> }<br> <span class="hljs-keyword">return</span> ans;<br> }<br>};<br><br></code></pre></td></tr></table></figure>
]]></content>
<categories>
<category>算法</category>
</categories>
</entry>
<entry>
<title>Graph</title>
<url>/2022/10/24/Graph/</url>
<content><![CDATA[<h2 id="Graph"><a href="#Graph" class="headerlink" title="Graph"></a>Graph</h2><span id="more"></span>
<h4 id="所有可能的路径"><a href="#所有可能的路径" class="headerlink" title="所有可能的路径"></a>所有可能的路径</h4><p>给你一个有 <code>n</code> 个节点的 <strong>有向无环图（DAG）</strong>，请你找出所有从节点 <code>0</code> 到节点 <code>n-1</code> 的路径并输出（<strong>不要求按特定顺序</strong>）</p>
<p> <code>graph[i]</code> 是一个从节点 <code>i</code> 可以访问的所有节点的列表（即从节点 <code>i</code> 到节点 <code>graph[i][j]</code>存在一条有向边）。</p>
<img src="/2022/10/24/Graph/1.jpg" class>
<figure class="highlight markdown"><table><tr><td class="code"><pre><code class="hljs markdown">输入：graph = [[4,3,1],[3,2,4],[3],[4],[]]<br>输出：[[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]<br></code></pre></td></tr></table></figure>
<h5 id="DFS"><a href="#DFS" class="headerlink" title="DFS"></a>DFS</h5><figure class="highlight java"><table><tr><td class="code"><pre><code class="hljs java"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br> <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title function_">dfs</span><span class="hljs-params">(<span class="hljs-type">int</span>[][] graph, <span class="hljs-type">int</span> node, List<Integer> path, List<List<Integer>> paths)</span> {<br> path.add(node);<br> <span class="hljs-keyword">if</span> (node == graph.length - <span class="hljs-number">1</span>) {<br> paths.add(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span><>(path));<br> }<br> <span class="hljs-type">int</span>[] nextNodes = graph[node];<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> nextNode : nextNodes) {<br> dfs(graph, nextNode, path, paths);<br> path.remove(path.size() - <span class="hljs-number">1</span>);<br> }<br> <br> }<br> <span class="hljs-keyword">public</span> List<List<Integer>> <span class="hljs-title function_">allPathsSourceTarget</span><span class="hljs-params">(<span class="hljs-type">int</span>[][] graph)</span> {<br> List<List<Integer>> paths = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span><>();<br> dfs(graph, <span class="hljs-number">0</span>, <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span><>(), paths);<br> <span class="hljs-keyword">return</span> paths;<br> }<br>}<br></code></pre></td></tr></table></figure>
<h5 id="BFS"><a href="#BFS" class="headerlink" title="BFS"></a>BFS</h5><figure class="highlight java"><table><tr><td class="code"><pre><code class="hljs java"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br> <span class="hljs-keyword">public</span> List<List<Integer>> <span class="hljs-title function_">allPathsSourceTarget</span><span class="hljs-params">(<span class="hljs-type">int</span>[][] graph)</span> {<br> List<List<Integer>> paths = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span><>();<br> Queue<List<Integer>> queue = <span class="hljs-keyword">new</span> <span class="hljs-title class_">LinkedList</span><>();<br> List<Integer> path = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span><>();<br> path.add(<span class="hljs-number">0</span>);<br> queue.add(path);<br> <span class="hljs-keyword">while</span> (!queue.isEmpty()) {<br> List<Integer> curPath = queue.poll();<br> <span class="hljs-type">int</span> <span class="hljs-variable">node</span> <span class="hljs-operator">=</span> curPath.get(curPath.size() - <span class="hljs-number">1</span>);<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> nextNode : graph[node]) {<br> List<Integer> tempPath = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span><>(curPath);<br> tempPath.add(nextNode);<br> <span class="hljs-keyword">if</span> (nextNode == graph.length - <span class="hljs-number">1</span>) {<br> paths.add(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span><>(tempPath));<br> } <span class="hljs-keyword">else</span> {<br> queue.add(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span><>(tempPath));<br> }<br> }<br> }<br> <span class="hljs-keyword">return</span> paths;<br> }<br>}<br></code></pre></td></tr></table></figure>
<h4 id="课程表"><a href="#课程表" class="headerlink" title="课程表"></a>课程表</h4><p>你这个学期必须选修 <code>numCourses</code> 门课程，记为 <code>0</code> 到 <code>numCourses - 1</code> 。</p>
<p>在选修某些课程之前需要一些先修课程。 先修课程按数组 <code>prerequisites</code> 给出，其中 <code>prerequisites[i] = [ai, bi]</code> ，表示如果要学习课程 <code>ai</code> 则 <strong>必须</strong> 先学习课程 <code>bi</code> 。</p>
<ul>
<li>例如，先修课程对 <code>[0, 1]</code> 表示：想要学习课程 <code>0</code> ，你需要先完成课程 <code>1</code> 。</li>
</ul>
<p>请你判断是否可能完成所有课程的学习？如果可以，返回 <code>true</code> ；否则，返回 <code>false</code> 。</p>
<figure class="highlight java"><table><tr><td class="code"><pre><code class="hljs java"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br> List<List<Integer>> edges;<br> <span class="hljs-type">int</span>[] visited;<br> <span class="hljs-type">boolean</span> <span class="hljs-variable">valid</span> <span class="hljs-operator">=</span> <span class="hljs-literal">true</span>;<br><br> <span class="hljs-keyword">public</span> <span class="hljs-type">boolean</span> <span class="hljs-title function_">canFinish</span><span class="hljs-params">(<span class="hljs-type">int</span> numCourses, <span class="hljs-type">int</span>[][] prerequisites)</span> {<br> edges = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span><List<Integer>>();<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> <span class="hljs-variable">i</span> <span class="hljs-operator">=</span> <span class="hljs-number">0</span>; i < numCourses; ++i) {<br> edges.add(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span><Integer>());<br> }<br> visited = <span class="hljs-keyword">new</span> <span class="hljs-title class_">int</span>[numCourses];<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span>[] info : prerequisites) {<br> edges.get(info[<span class="hljs-number">1</span>]).add(info[<span class="hljs-number">0</span>]);<br> }<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> <span class="hljs-variable">i</span> <span class="hljs-operator">=</span> <span class="hljs-number">0</span>; i < numCourses && valid; ++i) {<br> <span class="hljs-keyword">if</span> (visited[i] == <span class="hljs-number">0</span>) {<br> dfs(i);<br> }<br> }<br> <span class="hljs-keyword">return</span> valid;<br> }<br><br> <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title function_">dfs</span><span class="hljs-params">(<span class="hljs-type">int</span> u)</span> {<br> visited[u] = <span class="hljs-number">1</span>;<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> v: edges.get(u)) {<br> <span class="hljs-keyword">if</span> (visited[v] == <span class="hljs-number">0</span>) {<br> dfs(v);<br> <span class="hljs-keyword">if</span> (!valid) {<br> <span class="hljs-keyword">return</span>;<br> }<br> } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (visited[v] == <span class="hljs-number">1</span>) {<br> valid = <span class="hljs-literal">false</span>;<br> <span class="hljs-keyword">return</span>;<br> }<br> }<br> visited[u] = <span class="hljs-number">2</span>;<br> }<br>}<br></code></pre></td></tr></table></figure>
]]></content>
<categories>
<category>算法</category>
</categories>
</entry>
<entry>
<title>Math</title>
<url>/2022/10/17/Math/</url>
<content><![CDATA[<h3 id="Math"><a href="#Math" class="headerlink" title="Math"></a>Math</h3><span id="more"></span>
<h4 id="快乐数"><a href="#快乐数" class="headerlink" title="快乐数"></a>快乐数</h4><p><code>Hashset</code></p>
<p>编写一个算法来判断一个数 <code>n</code> 是不是快乐数。</p>
<p><strong>「快乐数」</strong> 定义为：</p>
<ul>
<li>对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。</li>
<li>然后重复这个过程直到这个数变为 1，也可能是 <strong>无限循环</strong> 但始终变不到 1。</li>
<li>如果这个过程 <strong>结果为</strong> 1，那么这个数就是快乐数。</li>
</ul>
<p>如果 <code>n</code> 是 <em>快乐数</em> 就返回 <code>true</code> ；不是，则返回 <code>false</code> 。</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">getNum</span><span class="hljs-params">(<span class="hljs-type">int</span> n)</span> </span>{<br> <span class="hljs-type">int</span> ans = <span class="hljs-number">0</span>;<br> <span class="hljs-keyword">while</span> (n > <span class="hljs-number">0</span>) {<br> ans += (n % <span class="hljs-number">10</span>) * (n % <span class="hljs-number">10</span>);<br> n /= <span class="hljs-number">10</span>;<br> }<br> <span class="hljs-keyword">return</span> ans;<br> }<br> <span class="hljs-function"><span class="hljs-type">bool</span> <span class="hljs-title">isHappy</span><span class="hljs-params">(<span class="hljs-type">int</span> n)</span> </span>{<br> unordered_set<<span class="hljs-type">int</span>> s;<br> <span class="hljs-keyword">while</span> (<span class="hljs-literal">true</span>) {<br> <span class="hljs-type">int</span> sum = <span class="hljs-built_in">getNum</span>(n);<br> <span class="hljs-keyword">if</span> (sum == <span class="hljs-number">1</span>) <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;<br> <span class="hljs-comment">//说明这个数字已经出现过了</span><br> <span class="hljs-keyword">if</span> (s.<span class="hljs-built_in">find</span>(sum) != s.<span class="hljs-built_in">end</span>()) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;<br> s.<span class="hljs-built_in">insert</span>(sum);<br> n = sum;<br> }<br> }<br>};<br></code></pre></td></tr></table></figure>
<h4 id="到达终点数字"><a href="#到达终点数字" class="headerlink" title="到达终点数字"></a>到达终点数字</h4><p>在一根无限长的数轴上，你站在<code>0</code>的位置。终点在<code>target</code>的位置。</p>
<p>你可以做一些数量的移动 <code>numMoves</code> :</p>
<ul>
<li>每次你可以选择向左或向右移动。</li>
<li>第 <code>i</code> 次移动（从 <code>i == 1</code> 开始，到 <code>i == numMoves</code> ），在选择的方向上走 <code>i</code> 步。</li>
</ul>
<p>给定整数 <code>target</code> ，返回 <em>到达目标所需的 <strong>最小</strong> 移动次数(即最小 <code>numMoves</code> )</em> 。</p>
<img src="/2022/10/17/Math/1.png" class>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">reachNumber</span><span class="hljs-params">(<span class="hljs-type">int</span> target)</span> </span>{<br> target = <span class="hljs-built_in">abs</span>(target);<br> <span class="hljs-type">int</span> k = <span class="hljs-number">0</span>;<br> <span class="hljs-keyword">while</span> (target > <span class="hljs-number">0</span>) {<br> k++;<br> target -= k;<br> }<br> <span class="hljs-keyword">return</span> target % <span class="hljs-number">2</span> == <span class="hljs-number">0</span> ? k : k + <span class="hljs-number">1</span> + k % <span class="hljs-number">2</span>;<br> }<br>};<br></code></pre></td></tr></table></figure>
<h4 id="美丽整数的最小增量"><a href="#美丽整数的最小增量" class="headerlink" title="美丽整数的最小增量"></a>美丽整数的最小增量</h4><p><code>Greedy</code></p>
<p>给你两个正整数 n 和 target 。</p>
<p>如果某个整数每一位上的数字相加小于或等于 target ，则认为这个整数是一个 美丽整数 。</p>
<p>找出并返回满足 n + x 是 美丽整数 的最小非负整数 x 。生成的输入保证总可以使 n 变成一个美丽整数。</p>
<p>例子：</p>
<p>输入：n = 16, target = 6<br>输出：4<br>解释：最初，n 是 16 ，且其每一位数字的和是 1 + 6 = 7 。在加 4 之后，n 变为 20 且每一位数字的和变成 2 + 0 = 2 。可以证明无法加上一个小于 4 的非负整数使 n 变成一个美丽整数。</p>
<figure class="highlight java"><table><tr><td class="code"><pre><code class="hljs Java"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><br> <span class="hljs-comment">/** 求数位和 */</span><br> <span class="hljs-keyword">public</span> <span class="hljs-type">int</span> <span class="hljs-title function_">getSum</span><span class="hljs-params">(<span class="hljs-type">long</span> n)</span> {<br> <span class="hljs-type">int</span> <span class="hljs-variable">sum</span> <span class="hljs-operator">=</span> <span class="hljs-number">0</span>;<br> <span class="hljs-keyword">while</span> (n > <span class="hljs-number">0</span>) {<br> sum += n % <span class="hljs-number">10</span>;<br> n /= <span class="hljs-number">10</span>;<br> }<br> <span class="hljs-keyword">return</span> sum;<br> }<br><br> <span class="hljs-keyword">public</span> <span class="hljs-type">long</span> <span class="hljs-title function_">makeIntegerBeautiful</span><span class="hljs-params">(<span class="hljs-type">long</span> n, <span class="hljs-type">int</span> target)</span> {<br><br> <span class="hljs-keyword">if</span> (getSum(n) <= target) <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;<br><br> <span class="hljs-type">long</span> <span class="hljs-variable">mod</span> <span class="hljs-operator">=</span> <span class="hljs-number">10L</span>, res = <span class="hljs-number">0L</span>;<br><br> <span class="hljs-keyword">while</span> (getSum(n) > target) {<br> <span class="hljs-type">long</span> <span class="hljs-variable">t</span> <span class="hljs-operator">=</span> mod - (n % mod);<br> <span class="hljs-comment">//想要进位加的最小值就是t</span><br> res += t;<br> n += t;<br> <span class="hljs-comment">//对这个位操作不行就进到下一位</span><br> mod *= <span class="hljs-number">10</span>;<br> } <br><br> <span class="hljs-keyword">return</span> res; <br><br> }<br>}<br></code></pre></td></tr></table></figure>
]]></content>
<categories>
<category>算法</category>
</categories>
</entry>
<entry>
<title>Other Algorithm</title>
<url>/2022/10/09/Other-Algorithm/</url>
<content><![CDATA[<p>快速幂</p>
<span id="more"></span>
<h3 id="Pow-x-n"><a href="#Pow-x-n" class="headerlink" title="Pow(x, n)"></a>Pow(x, n)</h3><p>实现pow(x, n) ，即计算 <code>x</code> 的整数 <code>n</code> 次幂函数。</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function"><span class="hljs-type">double</span> <span class="hljs-title">myMul</span><span class="hljs-params">(<span class="hljs-type">double</span> x, <span class="hljs-type">long</span> <span class="hljs-type">long</span> n)</span> </span>{<br> <span class="hljs-keyword">if</span> (n == <span class="hljs-number">0</span>) <span class="hljs-keyword">return</span> <span class="hljs-number">1.0</span>;<br> <span class="hljs-type">double</span> y = <span class="hljs-built_in">myMul</span>(x, n / <span class="hljs-number">2</span>);<br> <span class="hljs-keyword">return</span> n % <span class="hljs-number">2</span> == <span class="hljs-number">0</span> ? y * y : y * y * x;<br> }<br> <span class="hljs-function"><span class="hljs-type">double</span> <span class="hljs-title">myPow</span><span class="hljs-params">(<span class="hljs-type">double</span> x, <span class="hljs-type">int</span> n)</span> </span>{<br> <span class="hljs-type">long</span> <span class="hljs-type">long</span> exp = (<span class="hljs-type">long</span> <span class="hljs-type">long</span>) n;<br> <span class="hljs-comment">//考虑到n是负数的情况</span><br> <span class="hljs-keyword">return</span> exp >= <span class="hljs-number">0</span> ? <span class="hljs-built_in">myMul</span>(x, exp) : <span class="hljs-number">1.0</span> / <span class="hljs-built_in">myMul</span>(x, -exp);<br> }<br>};<br></code></pre></td></tr></table></figure>
]]></content>
<categories>
<category>算法</category>
</categories>
</entry>
<entry>
<title>Prefix Add</title>
<url>/2022/10/15/Prefix-Add/</url>
<content><![CDATA[<h3 id="Prefix-Add"><a href="#Prefix-Add" class="headerlink" title="Prefix-Add"></a>Prefix-Add</h3><span id="more"></span>
<h4 id="最大和子矩阵"><a href="#最大和子矩阵" class="headerlink" title="最大和子矩阵"></a>最大和子矩阵</h4><p>给定一个n * m的矩阵，找出其中和最大的子矩阵</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">main</span><span class="hljs-params">()</span> </span>{<br> <span class="hljs-type">int</span> n, m;<br> cin >> n >> m;<br> <span class="hljs-type">int</span> dp[n+<span class="hljs-number">1</span>][m+<span class="hljs-number">1</span>];<br> <span class="hljs-built_in">memset</span>(dp, <span class="hljs-number">0</span>, <span class="hljs-built_in">sizeof</span> (dp));<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">1</span>; i <= n; i++) {<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> j = <span class="hljs-number">1</span>; j <= m; j++) {<br> <span class="hljs-type">int</span> num;<br> cin >> num;<br> dp[i][j] = dp[i<span class="hljs-number">-1</span>][j] + num;<br> }<br> }<br> <span class="hljs-comment">//dp[i][j]代表在第j列中从第1行到第i行元素的和</span><br> <span class="hljs-type">long</span> <span class="hljs-type">long</span> ans = <span class="hljs-number">0</span>;<br> <span class="hljs-keyword">for</span>(<span class="hljs-type">int</span> i = <span class="hljs-number">1</span>; i <= n; i++){<br> <span class="hljs-keyword">for</span>(<span class="hljs-type">int</span> j = i; j <= n; j++){<br> <span class="hljs-type">long</span> <span class="hljs-type">long</span> sum = <span class="hljs-number">0</span>;<br> <span class="hljs-keyword">for</span>(<span class="hljs-type">int</span> k = <span class="hljs-number">1</span>; k <= m; k++){<br> sum = sum + (dp[j][k] - dp[i<span class="hljs-number">-1</span>][k]);<br> <span class="hljs-keyword">if</span>(sum < <span class="hljs-number">0</span>) sum = <span class="hljs-number">0</span>;<br> <span class="hljs-keyword">if</span>(sum > ans) ans = sum;<br> }<br> }<br> }<br> cout << ans;<br><br>}<br></code></pre></td></tr></table></figure>
]]></content>
<categories>
<category>算法</category>
</categories>
</entry>
<entry>
<title>Sliding Window</title>
<url>/2022/10/09/Sliding-Window/</url>
<content><![CDATA[<h3 id="SlidingWindow"><a href="#SlidingWindow" class="headerlink" title="SlidingWindow"></a>SlidingWindow</h3><span id="more"></span>
<h4 id="无重复字符的最长子串"><a href="#无重复字符的最长子串" class="headerlink" title="无重复字符的最长子串"></a>无重复字符的最长子串</h4><p><code>HashMap</code></p>
<p>给定一个字符串<code>s</code>，请你找出其中不含有重复字符的 <strong>最长子串</strong> 的长度。</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">lengthOfLongestSubstring</span><span class="hljs-params">(string s)</span> </span>{<br> <span class="hljs-type">int</span> n = s.<span class="hljs-built_in">length</span>();<br> <span class="hljs-type">int</span> res = <span class="hljs-number">0</span>, temp = <span class="hljs-number">0</span>;<br> unordered_map<<span class="hljs-type">char</span>, <span class="hljs-type">int</span>> hashmap;<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < n; i++) {<br> <span class="hljs-keyword">if</span> (hashmap.<span class="hljs-built_in">find</span>(s[i]) == hashmap.<span class="hljs-built_in">end</span>()) {<br> temp++;<br> } <span class="hljs-keyword">else</span> {<br> temp = <span class="hljs-built_in">min</span>(temp + <span class="hljs-number">1</span>, i - hashmap[s[i]]);<br> }<br> hashmap[s[i]] = i;<br> res = <span class="hljs-built_in">max</span>(res, temp);<br> }<br> <span class="hljs-keyword">return</span> res;<br> }<br>};<br></code></pre></td></tr></table></figure>
<h4 id="长度最小的子数组"><a href="#长度最小的子数组" class="headerlink" title="长度最小的子数组"></a>长度最小的子数组</h4><p>给定一个含有 <code>n</code> 个正整数的数组和一个正整数 <code>target</code> <strong>。</strong></p>
<p>找出该数组中满足其和 <code>≥ target</code> 的长度最小的 <strong>连续子数组</strong> <code>[numsl, numsl+1, ..., numsr-1, numsr]</code> ，并返回其长度<strong>。</strong>如果不存在符合条件的子数组，返回 <code>0</code> 。</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">minSubArrayLen</span><span class="hljs-params">(<span class="hljs-type">int</span> s, vector<<span class="hljs-type">int</span>>& nums)</span> </span>{<br> <span class="hljs-type">int</span> ans = INT_MAX;<br> <span class="hljs-type">int</span> start = <span class="hljs-number">0</span>, end = <span class="hljs-number">0</span>;<br> <span class="hljs-type">int</span> sum = <span class="hljs-number">0</span>;<br> <span class="hljs-keyword">while</span> (end < n) {<br> sum += nums[end];<br> <span class="hljs-keyword">while</span> (sum >= s) {<br> ans = <span class="hljs-built_in">min</span>(ans, end - start + <span class="hljs-number">1</span>);<br> sum -= nums[start];<br> start++;<br> }<br> end++;<br> }<br> <span class="hljs-keyword">return</span> ans == INT_MAX ? <span class="hljs-number">0</span> : ans;<br> }<br>};<br></code></pre></td></tr></table></figure>
<h4 id="水果成篮"><a href="#水果成篮" class="headerlink" title="水果成篮"></a>水果成篮</h4><p><code>Hashmap</code></p>
<p>你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 <code>fruits</code> 表示，其中 <code>fruits[i]</code> 是第 <code>i</code> 棵树上的水果 <strong>种类</strong> 。</p>
<p>你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：</p>
<ul>
<li>你只有 <strong>两个</strong> 篮子，并且每个篮子只能装 <strong>单一类型</strong> 的水果。每个篮子能够装的水果总量没有限制。</li>
<li>你可以选择任意一棵树开始采摘，你必须从 <strong>每棵</strong> 树（包括开始采摘的树）上 <strong>恰好摘一个水果</strong> 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。</li>
<li>一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。</li>
</ul>
<p>给你一个整数数组 <code>fruits</code> ，返回你可以收集的水果的 <strong>最大</strong> 数目。</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Solution</span> {<br><span class="hljs-keyword">public</span>:<br> <span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">totalFruit</span><span class="hljs-params">(vector<<span class="hljs-type">int</span>>& fruits)</span> </span>{<br> <span class="hljs-type">int</span> n = fruits.<span class="hljs-built_in">size</span>();<br> unordered_map<<span class="hljs-type">int</span>, <span class="hljs-type">int</span>> cnt;<br> <span class="hljs-type">int</span> l = <span class="hljs-number">0</span>, ans = <span class="hljs-number">0</span>;<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> r = <span class="hljs-number">0</span>; r < n; r++) {<br> ++cnt[fruits[r]];<br> <span class="hljs-keyword">while</span> ((<span class="hljs-type">int</span>)cnt.<span class="hljs-built_in">size</span>() > <span class="hljs-number">2</span>) {<br> cnt[fruits[l]]--;<br> <span class="hljs-keyword">if</span> (cnt[fruits[l]] == <span class="hljs-number">0</span>) cnt.<span class="hljs-built_in">erase</span>(fruits[l]);<br> l++;<br> }<br> ans = <span class="hljs-built_in">max</span>(ans, r - l + <span class="hljs-number">1</span>);<br> }<br> <br> <span class="hljs-keyword">return</span> ans;<br> }<br>};<br></code></pre></td></tr></table></figure>
]]></content>
<categories>
<category>算法</category>
</categories>
</entry>
<entry>
<title>cpp header</title>
<url>/2022/10/04/cpp-header/</url>
<content><![CDATA[<p>由于在上机考试的时候编辑器的原因，在这里整理了一些常用函数以及需要的头文件</p>
<span id="more"></span>
<h3 id="include-lt-algorithm-gt"><a href="#include-lt-algorithm-gt" class="headerlink" title="#include <algorithm>"></a>#include <algorithm></h3><h4 id="max-min-abs"><a href="#max-min-abs" class="headerlink" title="max(),min(),abs()"></a>max(),min(),abs()</h4><p><code>abs()</code>函数只能用于求整型变量的绝对值，而<code>#include<cmath></code>中的<code>fabs()</code>函数还可用于求浮点型变量的绝对值，不要搞混~</p>
<h4 id="交换函数：swap"><a href="#交换函数：swap" class="headerlink" title="交换函数：swap()"></a>交换函数：swap()</h4><figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">swap</span><span class="hljs-params">( T& a, T& b )</span></span>;<br></code></pre></td></tr></table></figure>
<h4 id="翻转函数：reverse"><a href="#翻转函数：reverse" class="headerlink" title="翻转函数：reverse()"></a>翻转函数：reverse()</h4><figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">reverse</span><span class="hljs-params">(BidirIt first, BidirIt last )</span></span>;<br></code></pre></td></tr></table></figure>
<h4 id="排序函数：sort"><a href="#排序函数：sort" class="headerlink" title="排序函数：sort()"></a>排序函数：sort()</h4><figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs Cpp"><span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">sort</span><span class="hljs-params">( RandomIt first, RandomIt last )</span></span>;<br><span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">sort</span><span class="hljs-params">( RandomIt first, RandomIt last, Compare comp )</span></span>;<br><br><span class="hljs-comment">//从小到大</span><br>std::<span class="hljs-built_in">sort</span>(s.<span class="hljs-built_in">begin</span>(), s.<span class="hljs-built_in">end</span>());<br><span class="hljs-comment">//从大到小</span><br>std::<span class="hljs-built_in">sort</span>(s.<span class="hljs-built_in">begin</span>(), s.<span class="hljs-built_in">end</span>(), std::<span class="hljs-built_in">greater</span><<span class="hljs-type">int</span>>());<br></code></pre></td></tr></table></figure>
<h4 id="查找函数：find-、upper-bound-、lower-bound"><a href="#查找函数：find-、upper-bound-、lower-bound" class="headerlink" title="查找函数：find()、upper_bound()、lower_bound()"></a>查找函数：find()、upper_bound()、lower_bound()</h4><p>find在string, map, set中可以用，在vector中不可以用</p>
<p>upper_bound, lower_bound在数组和vector中常用</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-comment">/**Returns an iterator pointing to the first element in the range [first, last) that does not satisfy element < value (or comp(element, value)), (i.e. greater or equal to), or last if no such element is found.</span><br><span class="hljs-comment">**/</span><br><span class="hljs-function">ForwardIt <span class="hljs-title">lower_bound</span><span class="hljs-params">( ForwardIt first, ForwardIt last, <span class="hljs-type">const</span> T& value )</span></span>;<br><br><span class="hljs-function">ForwardIt <span class="hljs-title">upper_bound</span><span class="hljs-params">( ForwardIt first, ForwardIt last, <span class="hljs-type">const</span> T& value )</span></span>;<br></code></pre></td></tr></table></figure>
<h4 id="查找某值出现的次数：count"><a href="#查找某值出现的次数：count" class="headerlink" title="查找某值出现的次数：count()"></a>查找某值出现的次数：count()</h4><p>count在string, map, set中可以用，在vector中不可以用</p>
<h3 id="include-lt-cstring-gt"><a href="#include-lt-cstring-gt" class="headerlink" title="#include <cstring>"></a>#include <cstring></h3><h4 id="memset"><a href="#memset" class="headerlink" title="memset"></a>memset</h4><figure class="highlight c++"><table><tr><td class="code"><pre><code class="hljs c++"><span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string"><string.h></span></span><br><span class="hljs-function"><span class="hljs-type">void</span> *<span class="hljs-title">memset</span><span class="hljs-params">(<span class="hljs-type">void</span> *s, <span class="hljs-type">int</span> c, <span class="hljs-type">size_t</span> n)</span></span>; <br></code></pre></td></tr></table></figure>
<h3 id="include-lt-string-gt"><a href="#include-lt-string-gt" class="headerlink" title="#include <string>"></a>#include <string></h3><h4 id="stoi-stol-stoll"><a href="#stoi-stol-stoll" class="headerlink" title="stoi(),stol(),stoll()"></a>stoi(),stol(),stoll()</h4><p>转化之前会进行范围检查，如果发现超出范围会发出 runtime error!</p>
<p>converts a string to a signed integer </p>
<h4 id="stof-stod"><a href="#stof-stod" class="headerlink" title="stof(),stod()"></a>stof(),stod()</h4><p>converts a string to a floating point value </p>
<h4 id="to-string"><a href="#to-string" class="headerlink" title="to_string()"></a>to_string()</h4><p>converts an integral or floating point value to string</p>
<h4 id="find-find-first-of"><a href="#find-find-first-of" class="headerlink" title="find(), find_first_of()"></a>find(), find_first_of()</h4><figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-function">size_type <span class="hljs-title">find</span><span class="hljs-params">( <span class="hljs-type">const</span> basic_string& str, size_type pos = <span class="hljs-number">0</span> )</span> <span class="hljs-type">const</span></span>;<br><span class="hljs-function">size_type <span class="hljs-title">find_first_of</span><span class="hljs-params">( <span class="hljs-type">const</span> basic_string& str, size_type pos = <span class="hljs-number">0</span> )</span> <span class="hljs-type">const</span></span>;<br><br><span class="hljs-comment">//返回值：如果查找成功，则返回查找到的子字符串第一个字符的位置；否则返回string::npos</span><br></code></pre></td></tr></table></figure>
<h4 id="erase"><a href="#erase" class="headerlink" title="erase()"></a>erase()</h4><figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-function">iterator <span class="hljs-title">erase</span><span class="hljs-params">(iterator p)</span></span>; <span class="hljs-comment">//删除p指向的字符</span><br><span class="hljs-function">string& <span class="hljs-title">erase</span><span class="hljs-params">(<span class="hljs-type">size_t</span> pos=<span class="hljs-number">0</span>, <span class="hljs-type">size_t</span> len = npos)</span> <span class="hljs-comment">//删除从pos开始，长度为len的子串</span></span><br></code></pre></td></tr></table></figure>
<h3 id="include-lt-sstream-gt"><a href="#include-lt-sstream-gt" class="headerlink" title="#include <sstream>"></a>#include <sstream></h3><h4 id="stringstream"><a href="#stringstream" class="headerlink" title="stringstream"></a>stringstream</h4><figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp">string s = <span class="hljs-string">"ab cd 123 abcde"</span>;<br><span class="hljs-function">stringstream <span class="hljs-title">ss</span><span class="hljs-params">(s)</span></span>;<br></code></pre></td></tr></table></figure>
]]></content>
<categories>
<category>编程语言</category>
</categories>
</entry>
<entry>
<title>cpp tips</title>
<url>/2022/09/29/cpp-tips/</url>
<content><![CDATA[<p>这篇博客整理了自己学习cpp过程中遇到的一些小技巧和想法，会持续更新</p>
<span id="more"></span>
<h4 id="cpp删除容器中重复元素的方法："><a href="#cpp删除容器中重复元素的方法：" class="headerlink" title="cpp删除容器中重复元素的方法："></a>cpp删除容器中重复元素的方法：</h4><figure class="highlight c++"><table><tr><td class="code"><pre><code class="hljs c++">a.<span class="hljs-built_in">erase</span>(<span class="hljs-built_in">unique</span>(a.<span class="hljs-built_in">begin</span>(),a.<span class="hljs-built_in">end</span>()),a.<span class="hljs-built_in">end</span>())；<br></code></pre></td></tr></table></figure>
<h4 id="stl中有关排列组合的api"><a href="#stl中有关排列组合的api" class="headerlink" title="stl中有关排列组合的api"></a>stl中有关排列组合的api</h4><figure class="highlight c++"><table><tr><td class="code"><pre><code class="hljs c++"><span class="hljs-keyword">do</span> {<br><span class="hljs-comment">//func();</span><br>} <span class="hljs-keyword">while</span> (<span class="hljs-built_in">next_permutation</span>(s.<span class="hljs-built_in">begin</span>(), s.<span class="hljs-built_in">end</span>()));<br></code></pre></td></tr></table></figure>
<h4 id="lower-bound-amp-amp-upper-bound"><a href="#lower-bound-amp-amp-upper-bound" class="headerlink" title="lower_bound && upper_bound"></a>lower_bound && upper_bound</h4><p>lower_bound( )和upper_bound( )都是利用二分查找的方法在一个排好序的数组中进行查找元素的方法。</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><code class="hljs c++"><span class="hljs-comment">//在从小到大的排序数组中,以vector<int> nums为例子</span><br><span class="hljs-comment">/**</span><br><span class="hljs-comment">从数组的begin位置到end-1位置二分查找第一个大于或等于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。</span><br><span class="hljs-comment">*/</span><br>vector<<span class="hljs-type">int</span>> nums;<br><span class="hljs-type">int</span> idx = <span class="hljs-built_in">lower_bound</span>(nums.<span class="hljs-built_in">begin</span>(), nums.<span class="hljs-built_in">end</span>(), target) - nums.<span class="hljs-built_in">begin</span>();<br><span class="hljs-comment">/**</span><br><span class="hljs-comment">从数组的begin位置到end-1位置二分查找第一个大于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。</span><br><span class="hljs-comment">*/</span><br><span class="hljs-type">int</span> idx = <span class="hljs-built_in">upper_bound</span>(nums.<span class="hljs-built_in">begin</span>(), nums.<span class="hljs-built_in">end</span>(), target) - nums.<span class="hljs-built_in">begin</span>();<br><br><span class="hljs-comment">//在从大到小的排序数组中，重载lower_bound()和upper_bound()</span><br><span class="hljs-comment">/**</span><br><span class="hljs-comment">从数组的begin位置到end-1位置二分查找第一个小于或等于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。</span><br><span class="hljs-comment">*/</span><br><span class="hljs-built_in">lower_bound</span>(nums.<span class="hljs-built_in">begin</span>(), nums.<span class="hljs-built_in">end</span>(), target, <span class="hljs-built_in">greater</span><<span class="hljs-type">int</span>>());<br><span class="hljs-comment">/**</span><br><span class="hljs-comment">从数组的begin位置到end-1位置二分查找第一个小于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。</span><br><span class="hljs-comment">*/</span><br><span class="hljs-built_in">upper_bound</span>(nums.<span class="hljs-built_in">begin</span>(), nums.<span class="hljs-built_in">end</span>(), target, <span class="hljs-built_in">greater</span><<span class="hljs-type">int</span>>());<br></code></pre></td></tr></table></figure>
<h4 id="循环中的格式化输出"><a href="#循环中的格式化输出" class="headerlink" title="循环中的格式化输出"></a>循环中的格式化输出</h4><figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < n; i++) {<br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> j = <span class="hljs-number">0</span>; j < n; j++) {<br> cout << mat[i][j] << (j < n - <span class="hljs-number">1</span> ? <span class="hljs-string">" "</span> : <span class="hljs-string">"\n"</span>);<br> }<br>}<br></code></pre></td></tr></table></figure>
<h3 id="I-x2F-0技巧"><a href="#I-x2F-0技巧" class="headerlink" title="I/0技巧"></a>I/0技巧</h3><h4 id="能读入空格和回车符的输入方式"><a href="#能读入空格和回车符的输入方式" class="headerlink" title="能读入空格和回车符的输入方式"></a>能读入空格和回车符的输入方式</h4><figure class="highlight c++"><table><tr><td class="code"><pre><code class="hljs c++">string s;<br><span class="hljs-type">char</span> c;<br><span class="hljs-keyword">while</span> (cin.<span class="hljs-built_in">get</span>()) {<br> s += c;<br>}<br></code></pre></td></tr></table></figure>
<h4 id="读入一个整数之后再读入行"><a href="#读入一个整数之后再读入行" class="headerlink" title="读入一个整数之后再读入行"></a>读入一个整数之后再读入行</h4><figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-type">int</span> n;<br>cin >> n;<br>cin >> ws;<br>string t;<br><span class="hljs-built_in">getline</span>(cin, t);<br></code></pre></td></tr></table></figure>
<h4 id="输入未知个数的数字"><a href="#输入未知个数的数字" class="headerlink" title="输入未知个数的数字"></a>输入未知个数的数字</h4><figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-type">int</span> n;<br><span class="hljs-keyword">while</span> (cin >> n) {<br> <span class="hljs-built_in">func</span>();<br>}<br></code></pre></td></tr></table></figure>
<h4 id="输入未知个数的字符和字符串"><a href="#输入未知个数的字符和字符串" class="headerlink" title="输入未知个数的字符和字符串"></a>输入未知个数的字符和字符串</h4><p>此处以字符串为例子，cin会跳过空格以及换行符</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp">string s;<br>vector<string> v;<br><span class="hljs-keyword">while</span> (cin >> s) {<br> v.<span class="hljs-built_in">push_back</span>(s);<br>}<br></code></pre></td></tr></table></figure>
<h4 id="读入一行以空格分割的字符串"><a href="#读入一行以空格分割的字符串" class="headerlink" title="读入一行以空格分割的字符串"></a>读入一行以空格分割的字符串</h4><figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-function">vector<string> <span class="hljs-title">split</span><span class="hljs-params">(string s, <span class="hljs-type">char</span> seq)</span> </span>{<br> <span class="hljs-function">stringstream <span class="hljs-title">ss</span><span class="hljs-params">(s)</span></span>;<br> vector<string> ans;<br> string temp;<br> <span class="hljs-keyword">while</span> (<span class="hljs-built_in">getline</span>(ss, temp, seq)) {<br> ans.<span class="hljs-built_in">push_back</span>(temp);<br> }<br> <span class="hljs-keyword">return</span> ans;<br>}<br><br><span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">main</span><span class="hljs-params">()</span> </span>{<br><br> string s;<br> <span class="hljs-built_in">getline</span>(cin, s);<br> <span class="hljs-function">vector<string> <span class="hljs-title">strs</span><span class="hljs-params">(split(s, <span class="hljs-string">' '</span>))</span></span>;<br> <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;<br>}<br></code></pre></td></tr></table></figure>
]]></content>
<categories>
<category>编程语言</category>
</categories>
</entry>
<entry>
<title>SpringBoot基本配置整理</title>
<url>/2022/10/29/SpringBoot%E5%9F%BA%E6%9C%AC%E9%85%8D%E7%BD%AE%E6%95%B4%E7%90%86/</url>
<content><![CDATA[<h2 id="SpringBoot基本配置整理"><a href="#SpringBoot基本配置整理" class="headerlink" title="SpringBoot基本配置整理"></a>SpringBoot基本配置整理</h2><span id="more"></span>
<h3 id="pom-xml"><a href="#pom-xml" class="headerlink" title="pom.xml"></a>pom.xml</h3><figure class="highlight xml"><table><tr><td class="code"><pre><code class="hljs xml"><span class="hljs-tag"><<span class="hljs-name">dependencies</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">dependency</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">groupId</span>></span>org.springframework.boot<span class="hljs-tag"></<span class="hljs-name">groupId</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">artifactId</span>></span>spring-boot-starter-web<span class="hljs-tag"></<span class="hljs-name">artifactId</span>></span><br> <span class="hljs-tag"></<span class="hljs-name">dependency</span>></span><br><br> <span class="hljs-tag"><<span class="hljs-name">dependency</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">groupId</span>></span>org.projectlombok<span class="hljs-tag"></<span class="hljs-name">groupId</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">artifactId</span>></span>lombok<span class="hljs-tag"></<span class="hljs-name">artifactId</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">optional</span>></span>true<span class="hljs-tag"></<span class="hljs-name">optional</span>></span><br> <span class="hljs-tag"></<span class="hljs-name">dependency</span>></span><br> <br> <span class="hljs-tag"><<span class="hljs-name">dependency</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">groupId</span>></span>org.springframework.boot<span class="hljs-tag"></<span class="hljs-name">groupId</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">artifactId</span>></span>spring-boot-starter-test<span class="hljs-tag"></<span class="hljs-name">artifactId</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">scope</span>></span>test<span class="hljs-tag"></<span class="hljs-name">scope</span>></span><br> <span class="hljs-tag"></<span class="hljs-name">dependency</span>></span><br> <br> <span class="hljs-tag"><<span class="hljs-name">dependency</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">groupId</span>></span>com.baomidou<span class="hljs-tag"></<span class="hljs-name">groupId</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">artifactId</span>></span>mybatis-plus-boot-starter<span class="hljs-tag"></<span class="hljs-name">artifactId</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">version</span>></span>3.4.2<span class="hljs-tag"></<span class="hljs-name">version</span>></span><br> <span class="hljs-tag"></<span class="hljs-name">dependency</span>></span><br> <br> <span class="hljs-tag"><<span class="hljs-name">dependency</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">groupId</span>></span>com.alibaba<span class="hljs-tag"></<span class="hljs-name">groupId</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">artifactId</span>></span>druid-spring-boot-starter<span class="hljs-tag"></<span class="hljs-name">artifactId</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">version</span>></span>1.2.6<span class="hljs-tag"></<span class="hljs-name">version</span>></span><br> <span class="hljs-tag"></<span class="hljs-name">dependency</span>></span><br> <br> <span class="hljs-tag"><<span class="hljs-name">dependency</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">groupId</span>></span>mysql<span class="hljs-tag"></<span class="hljs-name">groupId</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">artifactId</span>></span>mysql-connector-java<span class="hljs-tag"></<span class="hljs-name">artifactId</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">scope</span>></span>runtime<span class="hljs-tag"></<span class="hljs-name">scope</span>></span><br> <span class="hljs-tag"></<span class="hljs-name">dependency</span>></span><br> <span class="hljs-tag"></<span class="hljs-name">dependencies</span>></span><br><br> <span class="hljs-tag"><<span class="hljs-name">build</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">plugins</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">plugin</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">groupId</span>></span>org.springframework.boot<span class="hljs-tag"></<span class="hljs-name">groupId</span>></span><br> <span class="hljs-tag"><<span class="hljs-name">artifactId</span>></span>spring-boot-maven-plugin<span class="hljs-tag"></<span class="hljs-name">artifactId</span>></span><br> <span class="hljs-tag"></<span class="hljs-name">plugin</span>></span><br> <span class="hljs-tag"></<span class="hljs-name">plugins</span>></span><br> <span class="hljs-tag"></<span class="hljs-name">build</span>></span><br></code></pre></td></tr></table></figure>
<h3 id="application-yml"><a href="#application-yml" class="headerlink" title="application.yml"></a>application.yml</h3><figure class="highlight properties"><table><tr><td class="code"><pre><code class="hljs properties"><span class="hljs-attr">server</span>:<span class="hljs-string"></span><br> <span class="hljs-attr">port</span>: <span class="hljs-string">80</span><br><span class="hljs-attr">spring</span>:<span class="hljs-string"></span><br> <span class="hljs-attr">datasource</span>:<span class="hljs-string"></span><br> <span class="hljs-attr">druid</span>:<span class="hljs-string"></span><br> <span class="hljs-attr">driver-class-name</span>: <span class="hljs-string">com.mysql.cj.jdbc.Driver</span><br> <span class="hljs-attr">url</span>: <span class="hljs-string">jdbc:mysql://localhost:3306/todolist?useUnicode=true&characterEncoding=utf-8&useSSL=false</span><br> <span class="hljs-attr">username</span>: <span class="hljs-string">root</span><br> <span class="hljs-attr">password</span>: <span class="hljs-string">123456</span><br><br><span class="hljs-attr">mybatis-plus</span>:<span class="hljs-string"></span><br> <span class="hljs-attr">global-config</span>:<span class="hljs-string"></span><br> <span class="hljs-attr">db-config</span>:<span class="hljs-string"></span><br> <span class="hljs-attr">table-prefix</span>: <span class="hljs-string">tbl_</span><br> <span class="hljs-attr">id-type</span>: <span class="hljs-string">auto</span><br> <span class="hljs-attr">configuration</span>:<span class="hljs-string"></span><br> <span class="hljs-attr">log-impl</span>: <span class="hljs-string">org.apache.ibatis.logging.stdout.StdOutImpl</span><br><br><br></code></pre></td></tr></table></figure>
]]></content>
<categories>
<category>SpringBoot</category>
</categories>
</entry>
<entry>
<title>cpp 坑</title>
<url>/2022/10/04/cpp-%E5%9D%91/</url>
<content><![CDATA[<p>这篇博客整理了自己在学习cpp时踩的一些坑……</p>
<span id="more"></span>
<h4 id="头文件中的模板类编译时的一个坑及其原因"><a href="#头文件中的模板类编译时的一个坑及其原因" class="headerlink" title="头文件中的模板类编译时的一个坑及其原因"></a>头文件中的模板类编译时的一个坑及其原因</h4><p>如果把模板类的声明和定义都放在头文件中。需要用到模板类的时候，只需要包含该头文件，然后进行实例化。</p>
<p>如果模板类的声明和定义分别放在头文件和源文件中。当实例化的时候，只包含头文件会发证链接错误。</p>
<p>原因是模板类的实例化要分成两个步骤，模板的特例化和特例的实例化。</p>
<p>编译器在编译阶段，由于没有定义，所以编译器不能生成具体的模板特例，但是这并不会报错误，编译器将把问题抛给链接器来做。在编译源文件的时候，程序找不到该模板的特例，只是有模板而已，所以无法生成对象。所以会发生错误。</p>
<h4 id="string-substr-int-a-int-b"><a href="#string-substr-int-a-int-b" class="headerlink" title="string.substr(int a, int b);"></a>string.substr(int a, int b);</h4><p>注意b不是末尾下标，a是选取的首字母下标，b是选取字符串的长度</p>
<h4 id="数组a-n-中a在函数传递的理解"><a href="#数组a-n-中a在函数传递的理解" class="headerlink" title="数组a[n]中a在函数传递的理解"></a>数组a[n]中a在函数传递的理解</h4><figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">f</span><span class="hljs-params">(<span class="hljs-type">int</span> a[], <span class="hljs-type">int</span> n)</span> </span>{<span class="hljs-comment">//在参数传递的过程中，a传递的是a[0]的地址，一定要传递数组个数n</span><br> <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < <span class="hljs-built_in">sizeof</span>(a) / <span class="hljs-built_in">sizeof</span>(a[<span class="hljs-number">0</span>]); i++) {<br> cout << a[i] << <span class="hljs-string">" "</span>;<br> }<br> <span class="hljs-comment">//此时是执行不了的！！！</span><br>}<br><br><span class="hljs-type">int</span> a[<span class="hljs-number">6</span>];<br><span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i < <span class="hljs-number">6</span>; i++) a[i] = i;<br><span class="hljs-built_in">f</span>(a, <span class="hljs-number">6</span>);<br></code></pre></td></tr></table></figure>
<h4 id="cpp是没有越界检查的"><a href="#cpp是没有越界检查的" class="headerlink" title="cpp是没有越界检查的"></a>cpp是没有越界检查的</h4><p>“烫”的出现原因</p>
<h4 id="memset"><a href="#memset" class="headerlink" title="memset"></a>memset</h4><p>memset初始化的值只能为0和-1（二进制为全0和全1）</p>
]]></content>
<categories>
<category>编程语言</category>
</categories>
</entry>
<entry>
<title>模板</title>
<url>/2022/10/05/%E6%A8%A1%E6%9D%BF/</url>
<content><![CDATA[<p>许多时候有一些常见的代码模板一直在复用，自己整理一下</p>
<span id="more"></span>
<h2 id="算法"><a href="#算法" class="headerlink" title="算法"></a>算法</h2><h3 id="大数加法"><a href="#大数加法" class="headerlink" title="大数加法"></a>大数加法</h3><figure class="highlight cpp"><table><tr><td class="code"><pre><code class="hljs cpp"><span class="hljs-function">string <span class="hljs-title">add</span><span class="hljs-params">(string a, string b)</span> </span>{<br> <span class="hljs-type">int</span> i = a.<span class="hljs-built_in">length</span>() - <span class="hljs-number">1</span>, j = b.<span class="hljs-built_in">length</span>() - <span class="hljs-number">1</span>, carry = <span class="hljs-number">0</span>;<br> string res;<br> <span class="hljs-keyword">while</span> (i >= <span class="hljs-number">0</span> || j >= <span class="hljs-number">0</span> || carry > <span class="hljs-number">0</span>) {<br> <span class="hljs-type">int</span> x = i >= <span class="hljs-number">0</span> ? a[i] - <span class="hljs-string">'0'</span> : <span class="hljs-number">0</span>;<br> <span class="hljs-type">int</span> y = j >= <span class="hljs-number">0</span> ? b[j] - <span class="hljs-string">'0'</span> : <span class="hljs-number">0</span>;<br> <span class="hljs-type">int</span> sum = x + y + carry;<br> res.<span class="hljs-built_in">push_back</span>(<span class="hljs-string">'0'</span> + sum % <span class="hljs-number">10</span>);<br> carry = sum / <span class="hljs-number">10</span>;<br> i--;<br> j--;<br> }<br> <span class="hljs-comment">//注意需要翻转</span><br> <span class="hljs-built_in">reverse</span>(res.<span class="hljs-built_in">begin</span>(), res.<span class="hljs-built_in">end</span>());<br> <span class="hljs-keyword">return</span> res;<br>}<br></code></pre></td></tr></table></figure>
]]></content>
<categories>
<category>模板</category>
</categories>
</entry>
<entry>
<title>无法连接本地数据库</title>
<url>/2022/10/22/%E6%97%A0%E6%B3%95%E8%BF%9E%E6%8E%A5%E6%9C%AC%E5%9C%B0%E6%95%B0%E6%8D%AE%E5%BA%93/</url>
<content><![CDATA[<h1 id="IDEA无法连接本地数据库"><a href="#IDEA无法连接本地数据库" class="headerlink" title="IDEA无法连接本地数据库"></a>IDEA无法连接本地数据库</h1><span id="more"></span>
<p>由于重装了一次MySQL（重设密码也折腾了好久），自己在重连的时候一直报如下的bug，找了好久终于找到了问题所在</p>
<img src="/2022/10/22/%E6%97%A0%E6%B3%95%E8%BF%9E%E6%8E%A5%E6%9C%AC%E5%9C%B0%E6%95%B0%E6%8D%AE%E5%BA%93/1.png" class>
<p>由于IDEA, DG的默认端口号都是3306，但是查找MySQL的端口号发现是0，所以无法连接。（第一次装的时候没出现这个问题，不知道是否是MacOS 13的坑）</p>
<img src="/2022/10/22/%E6%97%A0%E6%B3%95%E8%BF%9E%E6%8E%A5%E6%9C%AC%E5%9C%B0%E6%95%B0%E6%8D%AE%E5%BA%93/2.png" class>
<p>接下来我们对port进行修改</p>
<p>首先手动关闭MySQL，这里发现关闭多次后仍然显示绿色。那么我们使用终端进行关闭</p>
<img src="/2022/10/22/%E6%97%A0%E6%B3%95%E8%BF%9E%E6%8E%A5%E6%9C%AC%E5%9C%B0%E6%95%B0%E6%8D%AE%E5%BA%93/3.png" class>
<figure class="highlight shell"><table><tr><td class="code"><pre><code class="hljs shell">mysql -u root -p<br>//输入password之后 (mysql的并非是本地主机root的)<br>shutdown;<br></code></pre></td></tr></table></figure>
<p>如下图就弄好了</p>
<img src="/2022/10/22/%E6%97%A0%E6%B3%95%E8%BF%9E%E6%8E%A5%E6%9C%AC%E5%9C%B0%E6%95%B0%E6%8D%AE%E5%BA%93/4.png" class>
<p>接下来我们需要找到传说中的mysql配置文件（找了半天还是没找到）</p>
<p>突然，无意间我瞥到了这句评论！！！！</p>
<img src="/2022/10/22/%E6%97%A0%E6%B3%95%E8%BF%9E%E6%8E%A5%E6%9C%AC%E5%9C%B0%E6%95%B0%E6%8D%AE%E5%BA%93/5.png" class>
<p>我突然想到是不是长时间的MySQL运行（我设置的是开机即打开MySQL)使得端口发生改变，于是我重启MySQL,(在上一步中关闭)</p>
<p>！！！！！！！</p>
<img src="/2022/10/22/%E6%97%A0%E6%B3%95%E8%BF%9E%E6%8E%A5%E6%9C%AC%E5%9C%B0%E6%95%B0%E6%8D%AE%E5%BA%93/6.png" class>
<p>配置成功！！！！</p>
<p>总结：</p>
<p>感觉如果没必要还是不用开机启动MySQL，使用的时候再启动最好！</p>
]]></content>
<categories>
<category>踩坑</category>
</categories>
</entry>
</search>