-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathatom.xml
3554 lines (3413 loc) · 170 KB
/
atom.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
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
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
<id>https://Ryan-ovo.github.io</id>
<title>Gridea</title>
<updated>2021-04-21T09:55:27.025Z</updated>
<generator>https://github.com/jpmonette/feed</generator>
<link rel="alternate" href="https://Ryan-ovo.github.io"/>
<link rel="self" href="https://Ryan-ovo.github.io/atom.xml"/>
<subtitle>温故而知新</subtitle>
<logo>https://Ryan-ovo.github.io/images/avatar.png</logo>
<icon>https://Ryan-ovo.github.io/favicon.ico</icon>
<rights>All rights reserved 2021, Gridea</rights>
<entry>
<title type="html"><![CDATA[[题解]LeetCode91.解码方法]]></title>
<id>https://Ryan-ovo.github.io/post/solution-leetcode91/</id>
<link href="https://Ryan-ovo.github.io/post/solution-leetcode91/">
</link>
<updated>2021-04-21T04:04:52.000Z</updated>
<content type="html"><![CDATA[<h3 id="题目描述">题目描述</h3>
<p>一条包含字母 <code>A-Z</code> 的消息通过以下映射进行了 编码 ：</p>
<pre><code>'A' -> 1
'B' -> 2
...
'Z' -> 26
</code></pre>
<p>要 解码 已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。例如，<code>"11106"</code> 可以映射为：</p>
<p><code>"AAJF"</code> ，将消息分组为 <code>(1 1 10 6)</code><br>
<code>"KJF"</code> ，将消息分组为 <code>(11 10 6)</code><br>
注意，消息不能分组为 <code>(1 11 06)</code> ，因为 <code>"06"</code> 不能映射为 <code>"F"</code> ，这是由于 <code>"6"</code> 和 <code>"06"</code> 在映射中并不等价。</p>
<p>给你一个只含数字的 非空 字符串 <code>s</code> ，请计算并返回 解码 方法的 总数 。</p>
<p>题目数据保证答案肯定是一个 <code>32</code> 位 的整数。</p>
<h4 id="样例1">样例1</h4>
<pre><code>输入：s = "226"
输出：3
解释：它可以解码为 "BZ" (2 26), "VF" (22 6), 或者 "BBF" (2 2 6) 。
</code></pre>
<h4 id="样例2">样例2</h4>
<pre><code>输入：s = "0"
输出：0
解释：没有字符映射到以 0 开头的数字。
含有 0 的有效映射是 'J' -> "10" 和 'T'-> "20" 。
由于没有字符，因此没有有效的方法对此进行解码，因为所有数字都需要映射。
</code></pre>
<h4 id="样例3">样例3</h4>
<pre><code>输入：s = "06"
输出：0
解释："06" 不能映射到 "F" ，因为字符串含有前导 0（"6" 和 "06" 在映射中并不等价）。
</code></pre>
<hr>
<h3 id="算法1">算法1</h3>
<h4 id="动态规划-on">(动态规划) <span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>O</mi><mo>(</mo><mi>n</mi><mo>)</mo></mrow><annotation encoding="application/x-tex">O(n)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathdefault" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord mathdefault">n</span><span class="mclose">)</span></span></span></span></h4>
<ul>
<li>状态表示：<code>f[i]</code>表示<code>s</code>的前<code>i</code>个字符的解码方法总数</li>
<li>状态转移：如果<code>s[i]</code>不为0，单字符可解码，<code>f[i] += f[i-1]</code>；如果<code>s[i-1]</code>存在，且<code>s[i-1]</code>与<code>s[i]</code>组成的数字在<code>[10,26]</code>之间，则<code>f[i] += f[i-2]</code></li>
<li>初始化：由于<code>f[i-1]</code>和<code>f[i-2]</code>都可能被用到，所以<code>f[0]</code>应该被设置为<code>1</code>，表示空串的解码次数为<code>1</code></li>
<li>注意
<ol>
<li>前导<code>0</code>需要特判</li>
<li>状态定义为前<code>i</code>个字符时，可以在字符串前加个空格作为哨兵，否则下标需要减一</li>
</ol>
</li>
</ul>
<h4 id="java-代码">Java 代码</h4>
<pre><code class="language-java">class Solution {
public int numDecodings(String s) {
int n = s.length();
s = " " + s;
// s中前i个字符的解码方法总数
int[] f = new int[n+1];
if(s.charAt(0) == '0') return 0;
f[0] = 1;
for(int i = 1; i <= n; i++){
if(s.charAt(i) != '0') f[i] += f[i-1];
if(i > 1){
int num = (s.charAt(i-1) - '0') * 10 + s.charAt(i) - '0';
if(num >= 10 && num <= 26) f[i] += f[i-2];
}
}
return f[n];
}
}
</code></pre>
]]></content>
</entry>
<entry>
<title type="html"><![CDATA[[题解]LeetCode1707.与数组中元素的最大异或值]]></title>
<id>https://Ryan-ovo.github.io/post/solution-leetcode1707/</id>
<link href="https://Ryan-ovo.github.io/post/solution-leetcode1707/">
</link>
<updated>2021-04-19T02:48:24.000Z</updated>
<content type="html"><![CDATA[<p><ul class="markdownIt-TOC">
<li>
<ul>
<li>
<ul>
<li><a href="#%E9%A2%98%E7%9B%AE%E6%8F%8F%E8%BF%B0">题目描述</a>
<ul>
<li><a href="#%E6%A0%B7%E4%BE%8B1">样例1</a></li>
<li><a href="#%E6%A0%B7%E4%BE%8B2">样例2</a></li>
<li><a href="#%E6%8F%90%E7%A4%BA">提示</a></li>
</ul>
</li>
<li><a href="#%E7%AE%97%E6%B3%951">算法1</a>
<ul>
<li><a href="#0-1%E5%AD%97%E5%85%B8%E6%A0%91-%E7%A6%BB%E7%BA%BF%E6%80%9D%E6%83%B3-onlogn">(0-1字典树 + 离线思想) <span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>O</mi><mo>(</mo><mi>n</mi><mi>l</mi><mi>o</mi><mi>g</mi><mo>(</mo><mi>n</mi><mo>)</mo><mo>)</mo></mrow><annotation encoding="application/x-tex">O(nlog(n))</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathdefault" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord mathdefault">n</span><span class="mord mathdefault" style="margin-right:0.01968em;">l</span><span class="mord mathdefault">o</span><span class="mord mathdefault" style="margin-right:0.03588em;">g</span><span class="mopen">(</span><span class="mord mathdefault">n</span><span class="mclose">)</span><span class="mclose">)</span></span></span></span></a></li>
<li><a href="#java-%E4%BB%A3%E7%A0%81">Java 代码</a></li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</p>
<h3 id="题目描述">题目描述</h3>
<p>给你一个由非负整数组成的数组 <code>nums</code> 。另有一个查询数组 <code>queries</code> ，其中 <code>queries[i] = [xi, mi]</code> 。</p>
<p>第 <code>i</code> 个查询的答案是 <code>xi</code> 和任何 <code>nums</code> 数组中不超过 <code>mi</code> 的元素按位异或<code>（XOR）</code>得到的最大值。换句话说，答案是 <code>max(nums[j] XOR xi)</code> ，其中所有 <code>j</code> 均满足 <code>nums[j] <= mi</code> 。如果 <code>nums</code> 中的所有元素都大于 <code>mi</code>，最终答案就是 <code>-1</code> 。</p>
<p>返回一个整数数组 <code>answer</code> 作为查询的答案，其中 <code>answer.length == queries.length</code> 且 <code>answer[i]</code> 是第 <code>i</code> 个查询的答案。</p>
<h4 id="样例1">样例1</h4>
<pre><code>输入：nums = [0,1,2,3,4], queries = [[3,1],[1,3],[5,6]]
输出：[3,3,7]
解释：
1) 0 和 1 是仅有的两个不超过 1 的整数。0 XOR 3 = 3 而 1 XOR 3 = 2 。二者中的更大值是 3 。
2) 1 XOR 2 = 3.
3) 5 XOR 2 = 7.
</code></pre>
<h4 id="样例2">样例2</h4>
<pre><code>输入：nums = [5,2,4,6,6,3], queries = [[12,4],[8,1],[6,3]]
输出：[15,-1,5]
</code></pre>
<h4 id="提示">提示</h4>
<ul>
<li>1 <= nums.length, queries.length <= <span class="katex"><span class="katex-mathml"><math><semantics><mrow><mn>1</mn><msup><mn>0</mn><mn>5</mn></msup></mrow><annotation encoding="application/x-tex">10^5</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8141079999999999em;vertical-align:0em;"></span><span class="mord">1</span><span class="mord"><span class="mord">0</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141079999999999em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">5</span></span></span></span></span></span></span></span></span></span></span></li>
<li>queries[i].length == 2</li>
<li>0 <= nums[j], <span class="katex"><span class="katex-mathml"><math><semantics><mrow><msub><mi>x</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">x_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">i</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>, <span class="katex"><span class="katex-mathml"><math><semantics><mrow><msub><mi>m</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">m_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault">m</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">i</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> <= <span class="katex"><span class="katex-mathml"><math><semantics><mrow><mn>1</mn><msup><mn>0</mn><mn>9</mn></msup></mrow><annotation encoding="application/x-tex">10^9</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8141079999999999em;vertical-align:0em;"></span><span class="mord">1</span><span class="mord"><span class="mord">0</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141079999999999em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">9</span></span></span></span></span></span></span></span></span></span></span></li>
</ul>
<hr>
<h3 id="算法1">算法1</h3>
<h4 id="0-1字典树-离线思想-onlogn">(0-1字典树 + 离线思想) <span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>O</mi><mo>(</mo><mi>n</mi><mi>l</mi><mi>o</mi><mi>g</mi><mo>(</mo><mi>n</mi><mo>)</mo><mo>)</mo></mrow><annotation encoding="application/x-tex">O(nlog(n))</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathdefault" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord mathdefault">n</span><span class="mord mathdefault" style="margin-right:0.01968em;">l</span><span class="mord mathdefault">o</span><span class="mord mathdefault" style="margin-right:0.03588em;">g</span><span class="mopen">(</span><span class="mord mathdefault">n</span><span class="mclose">)</span><span class="mclose">)</span></span></span></span></h4>
<ul>
<li>由于每个查询中限制了数组中可选的最大元素不能超过m，所以基于离线思想，给queries数组对于m进行排序并记录原来的下标，按m从小到大来记录答案</li>
<li>排序原数组，并遍历查询数组：如果元素小于<span class="katex"><span class="katex-mathml"><math><semantics><mrow><msub><mi>m</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">m_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault">m</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">i</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>，则插入0-1字典树，并统计<span class="katex"><span class="katex-mathml"><math><semantics><mrow><msub><mi>x</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">x_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">i</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>与字典树中所有数的异或的最大值，最后在对应下标记录答案即可</li>
</ul>
<h4 id="java-代码">Java 代码</h4>
<pre><code class="language-java">class Solution {
class Node{
Node[] son = new Node[2];
}
Node root = new Node();
void insert(int x){
Node p = root;
for(int i = 30; i >= 0; i--){
int t = (x >> i) & 1;
if(p.son[t] == null){
p.son[t] = new Node();
}
p = p.son[t];
}
}
int search(int x){
Node p = root;
int target = 0;
for(int i = 30; i >= 0; i--){
int t = (x >> i) & 1;
if(p.son[t ^ 1] != null){
p = p.son[t ^ 1];
target |= 1 << i;
}else{
p = p.son[t];
}
}
return target;
}
public int[] maximizeXor(int[] nums, int[][] queries) {
int n = nums.length, m = queries.length;
Arrays.sort(nums);
Map<int[],Integer> map = new HashMap<>();
for(int i = 0; i < m; i++){
map.put(queries[i], i);
}
Arrays.sort(queries, (o1, o2) -> o1[1] - o2[1]);
int[] res = new int[m];
int k = 0;
for(int i = 0; i < m; i++){
int a = queries[i][0], b = queries[i][1];
while(k < n && nums[k] <= b){
insert(nums[k++]);
}
if(k == 0) res[map.get(queries[i])] = -1;
else res[map.get(queries[i])] = search(a);
}
return res;
}
}
</code></pre>
]]></content>
</entry>
<entry>
<title type="html"><![CDATA[[题解]LeetCode421.数组中两个数的最大异或和]]></title>
<id>https://Ryan-ovo.github.io/post/ti-jie-leetcode421shu-zu-zhong-liang-ge-shu-de-zui-da-yi-huo-he/</id>
<link href="https://Ryan-ovo.github.io/post/ti-jie-leetcode421shu-zu-zhong-liang-ge-shu-de-zui-da-yi-huo-he/">
</link>
<updated>2021-04-18T14:26:50.000Z</updated>
<content type="html"><![CDATA[<h3 id="题目描述">题目描述</h3>
<p>给定一个非空数组，数组中元素为 a0, a1, a2, … , an-1，其中 0 ≤ ai < 231 。</p>
<p>找到 ai 和aj 最大的异或 (XOR) 运算结果，其中0 ≤ i, j < n 。</p>
<p>你能在<span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>O</mi><mo>(</mo><mi>n</mi><mo>)</mo></mrow><annotation encoding="application/x-tex">O(n)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathdefault" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord mathdefault">n</span><span class="mclose">)</span></span></span></span>的时间解决这个问题吗？</p>
<h4 id="样例">样例</h4>
<pre><code>输入: [3, 10, 5, 25, 2, 8]
输出: 28
解释: 最大的结果是 5 ^ 25 = 28.
</code></pre>
<hr>
<h3 id="算法1">算法1</h3>
<h4 id="0-1字典树-on">(0-1字典树) <span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>O</mi><mo>(</mo><mi>n</mi><mo>)</mo></mrow><annotation encoding="application/x-tex">O(n)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathdefault" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord mathdefault">n</span><span class="mclose">)</span></span></span></span></h4>
<p>思想：将每个数字的二进制位，从高位到低位存储到前缀树中，也就是说前缀树中仅有0和1这两个数字。</p>
<ul>
<li>根据数学知识可以知道：<span class="katex"><span class="katex-mathml"><math><semantics><mrow><msup><mn>2</mn><mi>i</mi></msup></mrow><annotation encoding="application/x-tex">2^i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.824664em;vertical-align:0em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.824664em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">i</span></span></span></span></span></span></span></span></span></span></span> > <span class="katex"><span class="katex-mathml"><math><semantics><mrow><msup><mn>2</mn><mrow><mi>i</mi><mo>−</mo><mn>1</mn></mrow></msup></mrow><annotation encoding="application/x-tex">2^{i-1}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.824664em;vertical-align:0em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.824664em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathdefault mtight">i</span><span class="mbin mtight">−</span><span class="mord mtight">1</span></span></span></span></span></span></span></span></span></span></span></span>+<span class="katex"><span class="katex-mathml"><math><semantics><mrow><msup><mn>2</mn><mrow><mi>i</mi><mo>−</mo><mn>2</mn></mrow></msup></mrow><annotation encoding="application/x-tex">2^{i-2}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.824664em;vertical-align:0em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.824664em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathdefault mtight">i</span><span class="mbin mtight">−</span><span class="mord mtight">2</span></span></span></span></span></span></span></span></span></span></span></span>+...+<span class="katex"><span class="katex-mathml"><math><semantics><mrow><msup><mn>2</mn><mn>1</mn></msup></mrow><annotation encoding="application/x-tex">2^1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8141079999999999em;vertical-align:0em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141079999999999em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span></span></span></span></span></span></span></span>+<span class="katex"><span class="katex-mathml"><math><semantics><mrow><msup><mn>2</mn><mn>0</mn></msup></mrow><annotation encoding="application/x-tex">2^0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8141079999999999em;vertical-align:0em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141079999999999em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span></span></span></span></span></span></span></span></li>
<li>可以发现：异或只要两位不相同就是1，如果高位有一位是1，那么数就会大于这一位是0且低位全是1的情况。这就是从高位开始遍历的贪心思想。</li>
<li>如果某一位二进制位是0，但是前缀树的遍历过程中没有1的分支，则被迫走0的分支，反过来同理</li>
<li>树的高度由二进制位最多的数字决定，所以分支非0即1，不会有某一个数的二进制位先走到底的情况</li>
</ul>
<h4 id="java-代码">Java 代码</h4>
<pre><code class="language-java">class Solution {
class Node{
Node[] son = new Node[2];
}
Node root = new Node();
void insert(int x){
Node p = root;
for(int i = 30; i >= 0; i--){
int t = (x >> i) & 1;
if(p.son[t] == null){
p.son[t] = new Node();
}
p = p.son[t];
}
}
int search(int x){
Node p = root;
int xor = 0;
for(int i = 30; i >= 0; i--){
int t = (x >> i) & 1;
if(p.son[t ^ 1] != null){
xor += (1 << i);
p = p.son[t ^ 1];
}else{
p = p.son[t];
}
}
return xor;
}
public int findMaximumXOR(int[] nums) {
if(nums.length == 0) return 0;
for(int x: nums) insert(x);
int res = 0;
for(int x: nums) res = Math.max(res, search(x));
return res;
}
}
</code></pre>
]]></content>
</entry>
<entry>
<title type="html"><![CDATA[LeetCode第237场周赛题解]]></title>
<id>https://Ryan-ovo.github.io/post/leetcode-di-237-chang-zhou-sai-ti-jie/</id>
<link href="https://Ryan-ovo.github.io/post/leetcode-di-237-chang-zhou-sai-ti-jie/">
</link>
<updated>2021-04-18T09:33:13.000Z</updated>
<content type="html"><![CDATA[<h3 id="t1-判断句子是否为全字母句">T1-<a href="https://leetcode-cn.com/problems/check-if-the-sentence-is-pangram/">判断句子是否为全字母句</a></h3>
<ul>
<li>思路：模拟+计数</li>
</ul>
<pre><code class="language-java">class Solution {
public boolean checkIfPangram(String s) {
boolean[] st = new boolean[26];
for(char c: s.toCharArray()){
st[c-'a'] = true;
}
for(int i = 0; i < 26; i++){
if(!st[i]) return false;
}
return true;
}
}
</code></pre>
<ul>
<li>时间复杂度：<span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>O</mi><mo>(</mo><mi>n</mi><mo>)</mo></mrow><annotation encoding="application/x-tex">O(n)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathdefault" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord mathdefault">n</span><span class="mclose">)</span></span></span></span></li>
<li>空间复杂度：<span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>O</mi><mo>(</mo><mn>1</mn><mo>)</mo></mrow><annotation encoding="application/x-tex">O(1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathdefault" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord">1</span><span class="mclose">)</span></span></span></span></li>
</ul>
<h3 id="t2-雪糕的最大数量">T2-<a href="https://leetcode-cn.com/problems/maximum-ice-cream-bars/">雪糕的最大数量</a></h3>
<ul>
<li>思路：贪心</li>
<li>将数组从小到大排序依次选取即可</li>
</ul>
<pre><code class="language-java">class Solution {
public int maxIceCream(int[] costs, int coins) {
Arrays.sort(costs);
int res = 0;
int n = costs.length;
for(int i = 0; i < n; i++){
if(coins - costs[i] >= 0) {
coins -= costs[i];
res++;
}
if(coins <= 0) return res;
}
return res;
}
}
</code></pre>
<h3 id="t3-单线程cpu">T3-<a href="https://leetcode-cn.com/problems/single-threaded-cpu/">单线程CPU</a></h3>
<ul>
<li>思路：贪心+堆</li>
<li>创建三元组数组，分别保存开始时间，持续时间和下标；创建一个小根堆，先按照持续时间排序，相同再按照下标排序</li>
<li>对任务进行开始时间从小到大的排序，然后按题意进行模拟。
<ol>
<li>每次先求出当前进行到的时间，然后将所有开始时间早于当前时间的任务加入优先队列（如果当前时间堆中没有任务，则快进到下一个任务的开始时间）</li>
<li>取出堆顶的任务进行处理，并更新当前时间，直到任务列表全部执行结束</li>
</ol>
</li>
</ul>
<pre><code class="language-java">class Solution {
class Task{
int st;
int duration;
int idx;
}
public int[] getOrder(int[][] tasks) {
int n = tasks.length;
int[] res = new int[n];
Task[] ts = new Task[n];
for(int i = 0; i < n; i++){
ts[i] = new Task();
ts[i].st = tasks[i][0];
ts[i].duration = tasks[i][1];
ts[i].idx = i;
}
PriorityQueue<Task> heap = new PriorityQueue<>((t1, t2) -> t1.duration == t2.duration ? t1.idx - t2.idx : t1.duration - t2.duration);
Arrays.sort(ts, (t1, t2) -> t1.st - t2.st);
int i = 0, u = 0;
int now = 0; // 当前进行到多少分钟
while(heap.size() != 0 || i < n){
if(heap.size() == 0){
now = Math.max(now, ts[i].st);
}
while(i < n && ts[i].st <= now){
heap.offer(ts[i++]);
}
Task t = heap.poll();
now += t.duration;
res[u++] = t.idx;
}
return res;
}
}
</code></pre>
<h3 id="t4-所有数对按位与结果的异或和">T4-<a href="https://leetcode-cn.com/problems/find-xor-sum-of-all-pairs-bitwise-and/">所有数对按位与结果的异或和</a></h3>
<h4 id="方法1分配律">方法1：分配律</h4>
<ul>
<li><span class='katex-error' title='ParseError: KaTeX parse error: Expected 'EOF', got '&' at position 3: a &̲ (b ^ c) = (a &…'>a & (b ^ c) = (a & b) ^ (a & c)</span></li>
</ul>
<pre><code class="language-java">class Solution {
public int getXORSum(int[] a, int[] b) {
int s1 = 0, s2 = 0;
for(int x: a) s1 ^= x;
for(int x: b) s2 ^= x;
return s1 & s2;
}
}
</code></pre>
]]></content>
</entry>
<entry>
<title type="html"><![CDATA[[题解]LeetCode730.统计不同回文子序列]]></title>
<id>https://Ryan-ovo.github.io/post/ti-jie-leetcode730tong-ji-bu-tong-hui-wen-zi-xu-lie/</id>
<link href="https://Ryan-ovo.github.io/post/ti-jie-leetcode730tong-ji-bu-tong-hui-wen-zi-xu-lie/">
</link>
<updated>2021-04-17T14:38:44.000Z</updated>
<content type="html"><![CDATA[<h3 id="题目描述">题目描述</h3>
<p>给定一个字符串 S，找出 S 中不同的非空回文子序列个数，并返回该数字与 10^9 + 7 的模。</p>
<p>通过从 S 中删除 0 个或多个字符来获得子序列。</p>
<p>如果一个字符序列与它反转后的字符序列一致，那么它是回文字符序列。</p>
<p>如果对于某个 i，A_i != B_i，那么 A_1, A_2, ... 和 B_1, B_2, ... 这两个字符序列是不同的。</p>
<h4 id="样例">样例</h4>
<pre><code>输入：
S = 'bccb'
输出：6
解释：
6 个不同的非空回文子字符序列分别为：'b', 'c', 'bb', 'cc', 'bcb', 'bccb'。
注意：'bcb' 虽然出现两次但仅计数一次。
</code></pre>
<h4 id="提示">提示</h4>
<ul>
<li>字符串 S 的长度将在[1, 1000]范围内。</li>
<li>每个字符 S[i] 将会是集合 {'a', 'b', 'c', 'd'} 中的某一个。</li>
</ul>
<hr>
<h3 id="算法1">算法1</h3>
<h4 id="区间dp-双端队列-on2">(区间DP + 双端队列) <span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>O</mi><mo>(</mo><msup><mi>n</mi><mn>2</mn></msup><mo>)</mo></mrow><annotation encoding="application/x-tex">O(n^2)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.064108em;vertical-align:-0.25em;"></span><span class="mord mathdefault" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord"><span class="mord mathdefault">n</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141079999999999em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span></h4>
<ul>
<li>状态表示：<code>f[i][j]</code>表示<code>s[i]</code>到<code>s[j]</code>中包含的不同回文子序列个数，包含空串，答案为<code>f[0][n-1] - 1</code></li>
<li>状态转移：对于某个区间<code>[i, j]</code>，找到区间内最左边的和最右边的相同字符，下标为<code>l</code>和<code>r</code>，<code>f[i][j] += f[l + 1][r - 1]</code></li>
<li>由于区间DP枚举左右端点的性质，可以用一个双端队列维护这个过程：右端点更新时入队，左端点更新时出队。</li>
<li>对于每个不同字母都开一个deque，如果区间内包含某个字母，则区间内不同子序列个数加一，再判断是否有两个及以上不同的字符，进行状态转移；如果区间内不包含某个字符，则判断下一个字符</li>
</ul>
<h4 id="java-代码">Java 代码</h4>
<pre><code class="language-java">class Solution {
public int countPalindromicSubsequences(String s) {
int n = s.length();
int mod = (int)1e9 + 7;
// f[i][j]表示s[i~j]中回文子序列个数，包含空串
int[][] f = new int[n][n];
for(int[] ff: f) Arrays.fill(ff, 1);
// 单字符，包含空串
for(int i = 0; i < n; i++) f[i][i] = 2;
for(int len = 2; len <= n; len++){
Deque<Integer>[] dq = new Deque[4];
for(int i = 0; i < 4; i++){
dq[i] = new LinkedList<>();
}
for(int i = 0; i < len - 1; i++){
dq[s.charAt(i) - 'a'].offerLast(i);
}
for(int i = 0; i + len - 1 < n; i++){
int j = i + len - 1;
dq[s.charAt(j) - 'a'].offerLast(j);
for(int k = 0; k < 4; k++){
if(dq[k].size() > 0){
f[i][j]++;
int l = dq[k].peekFirst();
int r = dq[k].peekLast();
if(l < r){
f[i][j] = (f[i][j] + f[l + 1][r - 1]) % mod;
}
}
}
dq[s.charAt(i) - 'a'].pollFirst();
}
}
return f[0][n-1] - 1;
}
}
</code></pre>
]]></content>
</entry>
<entry>
<title type="html"><![CDATA[C++语法整理]]></title>
<id>https://Ryan-ovo.github.io/post/cpp_grammer/</id>
<link href="https://Ryan-ovo.github.io/post/cpp_grammer/">
</link>
<updated>2021-04-13T10:50:04.000Z</updated>
<content type="html"><![CDATA[<h3 id="第一章变量-输入输出-表达式和顺序语句">第一章.变量、输入输出、表达式和顺序语句</h3>
<h4 id="11-变量">1.1 变量</h4>
<ul>
<li>
<p>bool false/true 1byte</p>
</li>
<li>
<p>char 'c', 'a', ' ', ' \n' 1byte</p>
</li>
<li>
<p>int -2147483648 ~ 2147483647 (-2^31 ~ 2^31-1) 4byte</p>
</li>
<li>
<p>float 1.23, 2.5, 1.235e2, 6-7位有效数字 4byte</p>
</li>
<li>
<p>double 15-16位有效数字 8bype</p>
</li>
<li>
<p>long long (-2^63 ~ 2^63-1) btype</p>
</li>
<li>
<p>long double 16bype</p>
</li>
<li>
<p>字节1B = 8bit</p>
</li>
<li>
<p>带宽8Mb = 下载速度1MB/s</p>
</li>
</ul>
<pre><code class="language-c++">int a, b = 2, c = b;
float d = 1.5, e = 1, f = 1.235e2;
bool g = true, h = false;
char j = 'a', k = 'b';
long long l = 10000000000000000000ll;// 大小写l/L均可，不写默认为整型，超过2^31-1可能变为负数
long double m = 123.45
</code></pre>
<h4 id="12输入输出">1.2输入输出</h4>
<ul>
<li>scanf, printf在头文件cstdio中</li>
</ul>
<pre><code class="language-c++">#include <cstdio>
using namespace std;
int main(){
float a, b;
// int对应%d, 不会读入空格
// char对应%c, 会读入空格
// float对应%f, 默认保留6位小数
// double对应%lf, 默认保留6位小数
// long long对应%lld
// bool被当作整数来处理
scanf("%f%f", &a, &b);
printf("a + b = %.2f\na * b = %.3f\n", a+b, a*b);
printf("%5d\n", 123);
printf("%-5d\n", 123);
printf("%05d\n", 123);
printf("%5.2lf", 1.2);
}
</code></pre>
<ul>
<li>cin, cout, endl在头文件iostream中</li>
</ul>
<pre><code class="language-c++">#include <iostream>
using namespace std;
int main(){
int a, b;
// cin会自动过滤空格，输入中可以含有大量空格
cin >> a >> b;
cout << a+b << endl;
}
</code></pre>
<h4 id="13-表达式">1.3 表达式</h4>
<ul>
<li>取模运算的结果正负取决于第一个数的正负</li>
</ul>
<pre><code class="language-c++">cout << 5 % 2 << endl;
cout << -5 % 2 << endl;
cout << -5 % -2 << endl;
</code></pre>
<ul>
<li>变量类型转换</li>
</ul>
<pre><code>int 可以和 float, double相互转换, 其中float, double转为int为下取整
int 可以和char相互转换，通过ASCII码表
运算会让低精度向高精度转换
int和float, double做运算 结果会转换为float, double类型
char和int做运算，结果会转换为int //A + 2 = 67, (char)(A + 2) = C
int和long long做运算，结果会转换为long long
float和double做运算，结果会转换为double
</code></pre>
<h3 id="第二章判断结构">第二章.判断结构</h3>
<ul>
<li>判断闰年</li>
</ul>
<pre><code class="language-c++">#include <iostream>
#include <cstdio>
using namespace std;
int main(){
int year;
cin >> year;
if(year % 100 == 0){
if(year % 400 == 0) cout << "Yes" << endl;
else cout << "No" << endl;
}else{
if(year % 4 == 0) cout << "Yes" << endl;
else cout << "No" << endl;
}
return 0;
}
</code></pre>
<ul>
<li>逻辑运算符简化</li>
</ul>
<pre><code class="language-c++">#include <iostream>
#include <cstdio>
using namespace std;
int main(){
int year;
cin >> year;
// &&的优先级比||高, 不用加括号
if(year % 400 == 0 || year % 100 != 0 && year % 4 == 0){
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
return 0;
}
</code></pre>
<h3 id="第三章循环结构">第三章.循环结构</h3>
<ul>
<li>循环结构语法和Java一模一样</li>
</ul>
<pre><code class="language-c++">// while循环
while(){
}
// do-while循环
do{
}while();
// for循环
for(int i = 0; i < n; i++){
}
// 控制语句
break;
continue;
</code></pre>
<ul>
<li>奇数矩阵打印菱形</li>
</ul>
<pre><code class="language-c++">#include <iostream>
#include <cstdio>
using namespace std;
int main(){
int n;
cin >> n;
int cx = n/2, cy = n/2;
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
if(abs(i-cx) + abs(j-cy) <= n/2){
cout << "*";
}else{
cout << " ";
}
}
cout << endl;
}
return 0;
}
</code></pre>
<h3 id="第四章数组">第四章.数组</h3>
<h4 id="41-一维数组">4.1 一维数组</h4>
<ul>
<li>定义在函数内部的数组存储在栈空间中（局部变量），如果没有初始化则每个值都为随机数</li>
<li>定义在函数外部的数组存储在堆空间中（全局变量），默认值都为0</li>
<li>栈空间通常有大小限制，所以数组长度太大的数组局部变量，循环访问时可能发生段错误（解决方法：放到堆空间中）</li>
</ul>
<pre><code class="language-c++">// 定义了一个长度为3的数组
int a[3] = {0, 1, 2};
// 定义了一个长度为3的数组，长度由编译器计算
int b[] = {0, 1, 2};
// 定义了一个长度为5的数组，没有给出的值默认为0，等价于{0, 1, 2, 0, 0}
int c[5] = {0, 1, 2};
// 定义了一个长度为3的字符数组
char d[] = {'a', 'b', 'c'};
// 将数组全部初始化为0的写法
int f[100] = {0};
</code></pre>
<ul>
<li>将长度为n的数组顺时针旋转k次</li>
</ul>
<pre><code class="language-c++">#include <iostream>
#include <algorithm> //reverse函数在algorithm库中
using namespace std;
int a[100];
int main(){
int n, k;
cin >> n >> k;
for(int i = 0; i < n; i++) cin >> a[i];
// reverse(数组的起始位置, 数组的终止位置的下一个位置)
reverse(a, a + n);
reverse(a, a + k);
reverse(a + k, a + n);
for(int i = 0; i < n; i++) cout << a[i] << ' ';
return 0;
}
</code></pre>
<ul>
<li>memset函数</li>
</ul>
<pre><code class="language-c++">// 为数组进行初始化，按字节赋值
#include <iostream>
#include <cstring>
using namespace std;
int main(){
int a[10], b[10], c[10];
// int变量占4字节, 长度为10的int数组占40字节
// memset按字节赋值, 一个字节有8个bit位, 把8bit位全部置为第二个参数
// memset(a, 5, sizeof a)表示把每8bit都置为00000101
memset(a, 0, 40);
// sizeof为运算符, 可以计算出数组一共占多少字节
memset(a, 0, sizeof a);
// 只有0和-1初始化完恰好数组为全0或者全-1
memset(b, -1, sizeof b);
// 0x3f3f3f3f是一个非常大的数，其两倍都不会超出int的范围，常用于初始化一个很大的值
memset(c, 0x3f, sizeof c);
for(int i = 0; i < 10; i++) cout << a[i] << ' ';
for(int i = 0; i < 10; i++) cout << b[i] << ' ';
for(int i = 0; i < 10; i++) cout << c[i] << ' ';
return 0;
}
</code></pre>
<ul>
<li>memcpy函数在</li>
</ul>
<pre><code class="language-c++">#include <iostream>
#include <cstring>
using namespace std;
int main(){
int a[10], b[10];
for(int i = 0; i < 10; i++) a[i] = i;
memcpy(b, a, sizeof a);
for(int i = 0; i < 10; i++) cout << b[i] << ' ';
return 0;
}
</code></pre>
<h4 id="42-二维数组">4.2 二维数组</h4>
<pre><code class="language-c++">#include <iostream>
using namespace std;
int main(){
// 每一维都是一维数组，都可以按一维数组来初始化
// {{1, 2, 3, 4}, {1, 0, 0, 0}, {1, 0, 0, 0}} 不足补零
int a[3][4] = {{1, 2, 3, 4}, {1}, {1}};
for(int i = 0; i < 3; i++){
for(int j = 0; j < 4; j++){
cout << a[i][j] << ' ';
}
cout << endl;
}
return 0;
}
</code></pre>
<ul>
<li>多维数组可以实现，只要不超内存限制即可</li>
<li>二十维的数组，每一维的长度为2，能存储<span class="katex"><span class="katex-mathml"><math><semantics><mrow><msup><mn>2</mn><mn>2</mn></msup><mn>0</mn></mrow><annotation encoding="application/x-tex">2^20</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8141079999999999em;vertical-align:0em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141079999999999em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span><span class="mord">0</span></span></span></span>个数</li>
</ul>
<h3 id="第七章类-结构体-指针-引用">第七章.类 结构体 指针 引用</h3>
<h4 id="类">类</h4>
<ul>
<li>类可以把变量，数组，函数等打包到一起使用</li>
<li>类中不写修饰符默认为private</li>
<li>构造函数写法1：</li>
</ul>
<pre><code class="language-c++">#include <iostream>
using namespace std;
class Person{
private:
int age, height;
double money;
public:
Person(){}
Person(int _age, int _height, double _money){
age = _age;
height = _height;
money = _money;
}
string name;
void say(){
cout << "I'm " << name << endl;
}
int get_age(){
return age;
}
void add_money(int x){
money += x;
}
};
int main(){
Person p(18, 180, 0);
p.name = "zhangsan";
p.age = 18; // 无法访问私有变量
p.add_money(10000);
cout << p.name << endl;
cout << p.get_age() << endl;
return 0;
}
</code></pre>
<ul>
<li>构造函数写法2：</li>
</ul>
<pre><code class="language-c++">#include <iostream>
using namespace std;
class Person{
private:
int age, height;
double money;
public:
Person(){}
Person(int _age, int _height, double _money): age(_age), height(_height), money(_money){}
string name;
void say(){
cout << "I'm " << name << endl;
}
int get_age(){
return age;
}
void add_money(int x){
money += x;
}
};
int main(){
Person p(18, 180, 0);
p.name = "zhangsan";
// p.age = 18; // 无法访问私有变量
p.add_money(10000);
cout << p.name << endl;
cout << p.get_age() << endl;
return 0;
}
</code></pre>
<h4 id="结构体">结构体</h4>
<ul>
<li>结构体和类的作用相同，但是结构体用来存储相对简单的数据捆绑类型，类用来存储相对复杂，逻辑混乱的各类数据</li>
<li>结构体中修饰符不写默认为public</li>
<li>写法和类几乎一样</li>
</ul>
<pre><code class="language-c++">#include <iostream>
using namespace std;
struct Person{
int age, height;
double money;
string name;
Person(){}
Person(int _age, int _height, double _money): age(_age), height(_height), money(_money){}
void say(){
cout << "I'm " << name << endl;
}
int get_age(){
return age;
}
void add_money(int x){
money += x;
}
};
int main(){
Person p = {18, 180, 0};
// Person p(18, 180, 0);
p.name = "zhangsan";
p.age = 18;
p.add_money(10000);
cout << p.name << endl;
cout << p.get_age() << endl;
return 0;
}
</code></pre>
<h3 id="第八章stl">第八章.STL</h3>
<h4 id="pair">pair</h4>
<ul>
<li>二元组，泛型确定数据类型</li>
</ul>
<pre><code class="language-c++">#include <iostream>
using namespace std;
int main(){
pair<int,string> a;
// 初始化
a = {1, "aaa"};
a = make_pair(2, "bbb");
cout << a.first << ' ' << a.second << endl;
return 0;
}
</code></pre>
<h4 id="vector">vector</h4>
<ul>
<li>定义与初始化</li>
</ul>
<pre><code class="language-c++">#include <iostream>
#include <vector>
using namespace std;
int main(){
// 初始化为给定的值
vector<int> a({1, 2, 3});
// 初始化二维vector, 并赋初值为1
vector<vector<int>> b(3, vector<int>(4, 1));
// 定义长度为5的vector, 默认值都为0
vector<int> c(5);
// 定义长度为5的vector, 并赋初值为1
vector<int> d(5, 1);
return 0;
}
</code></pre>
<ul>
<li>遍历</li>
</ul>
<pre><code class="language-c++">#include <iostream>
#include <vector>
using namespace std;
int main(){
vector<int> a({1, 2, 3});
// 类似数组
for(int i = 0; i < a.size(); i++) cout << a[i] << ' ';
//迭代器(一般不用)
for(vector<int>::iterator i = a.begin(); i != a.end(); i++) cout << *i << ' ';
for(auto i = a.begin(); i != a.end(); i++) cout << *i << ' ';
for(auto i = a.begin(); i < a.end(); i++) cout << *i << ' ';
// for-each
for(int x: a) cout << x << ' ';
return 0;
}
</code></pre>
<ul>
<li>常用函数</li>
</ul>
<pre><code class="language-c++">#include <iostream>
#include <vector>
using namespace std;
int main(){
vector<int> a({1, 2, 3});
// 遍历
for(int i = 0; i < a.size(); i++) cout << a[i] << ' ';
for(auto i = a.begin(); i != a.end(); i++) cout << *i << ' ';
for(int x: a) cout << x << ' ';
// 数组长度
cout << a.size() << endl;
// 判空
cout << a.empty() << endl;
// 清空vector
a.clear();
// front(): 取出第一个元素
// back(): 取出最后一个元素
// rbegin(): 反向迭代器，指向最后一个元素
// rend(): 反向迭代器，指向第一个元素的前一个元素
// [begin(), end()) 前闭后开
cout << a.front() << ' ' << a[0] << ' ' << *a.begin() << ' ' << *(a.rend()-1) << endl;
cout << a.back() << ' ' << a[a.size()-1] << ' ' << *(a.end()-1) << ' ' << *a.rbegin() << endl;
// 往最后插入元素
a.push_back(4);
// 删除最后一个元素
a.pop_back();
// resize(n): 调整容器的大小, 使其包含n个元素
// 如果n比原来长度小, 则保留前n个元素, 如果n比原来长度大, 则用0补齐
// resize(n, v): 调整容器大小为n, 补齐的部分初始化为-1
a.resize(10);
// 1 2 3 0 0 0 0 0 0 0
for(int x: a) cout << x << ' ';
cout << endl;
a.resize(2);
// 1 2
for(int x: a) cout << x << ' ';
cout << endl;
a.resize(5, -1);
// 1 2 -1 -1 -1
for(int x: a) cout << x << ' ';
cout << endl;
return 0;
}
</code></pre>
<h4 id="queue">queue</h4>
<ul>
<li>头文件queue中含有queue, priority_queue</li>
<li>队列和栈都没有clear函数</li>
</ul>
<pre><code class="language-c++">#include <iostream>
#include <queue>
using namespace std;
int main(){
queue<int> q;
// 大根堆
priority_queue<int> a;
// 小根堆
priority_queue<int, vector<int>, greater<int>> b;
// 二元组大根堆
priority_queue<pair<int, int>> c;
// queue没有clear()函数，清空重新定义一遍即可、
q = queue<int>();
struct Rec{
int a, b;
bool operator> (const Rec& t) const{
return a > t.a;
}