-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathsearch.xml
3237 lines (3205 loc) · 537 KB
/
search.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"?>
<search>
<entry>
<title>Hello World</title>
<url>/hello-world/</url>
<content><![CDATA[<p>Welcome to <a href="https://hexo.io/">Hexo</a>! This is your very first post. Check <a href="https://hexo.io/docs/">documentation</a> for more info. If you get any problems when using Hexo, you can find the answer in <a href="https://hexo.io/docs/troubleshooting.html">troubleshooting</a> or you can ask me on <a href="https://github.com/hexojs/hexo/issues">GitHub</a>.</p>
<h2 id="Quick-Start"><a href="#Quick-Start" class="headerlink" title="Quick Start"></a>Quick Start</h2><h3 id="Create-a-new-post"><a href="#Create-a-new-post" class="headerlink" title="Create a new post"></a>Create a new post</h3><figure class="highlight bash"><table><tr><td class="code"><pre><span class="line">$ hexo new <span class="string">"My New Post"</span></span><br></pre></td></tr></table></figure>
<p>More info: <a href="https://hexo.io/docs/writing.html">Writing</a></p>
<h3 id="Run-server"><a href="#Run-server" class="headerlink" title="Run server"></a>Run server</h3><figure class="highlight bash"><table><tr><td class="code"><pre><span class="line">$ hexo server</span><br></pre></td></tr></table></figure>
<p>More info: <a href="https://hexo.io/docs/server.html">Server</a></p>
<h3 id="Generate-static-files"><a href="#Generate-static-files" class="headerlink" title="Generate static files"></a>Generate static files</h3><figure class="highlight bash"><table><tr><td class="code"><pre><span class="line">$ hexo generate</span><br></pre></td></tr></table></figure>
<p>More info: <a href="https://hexo.io/docs/generating.html">Generating</a></p>
<h3 id="Deploy-to-remote-sites"><a href="#Deploy-to-remote-sites" class="headerlink" title="Deploy to remote sites"></a>Deploy to remote sites</h3><figure class="highlight bash"><table><tr><td class="code"><pre><span class="line">$ hexo deploy</span><br></pre></td></tr></table></figure>
<p>More info: <a href="https://hexo.io/docs/one-command-deployment.html">Deployment</a></p>
]]></content>
</entry>
<entry>
<title>20210220 leetcode 第 46 场双周赛</title>
<url>/acm/0220leetcode%E5%8F%8C%E5%91%A8%E8%B5%9B/</url>
<content><![CDATA[<h1 id="21-02-21-双周赛（补题完成度【1-4】）"><a href="#21-02-21-双周赛（补题完成度【1-4】）" class="headerlink" title="[21.02.21]双周赛（补题完成度【1/4】）"></a>[21.02.21]双周赛（补题完成度【1/4】）</h1><ul>
<li>1.读错题祸害很大；<span id="more"></span></li>
<li>2.全局变量和初始化；</li>
<li>3.边界条件，及时退出，for循环有比较好的写法，应该练习；</li>
<li>4.c++的true和false是小写的；</li>
<li>5.如果把字符对应到数字，可以分别i-‘A’和i-‘a’，避免出错；</li>
<li>6.不要偷懒用一个数组记录两个变量，可能会出现意想不到的问题。案例：用同一个数组表示A和a是否出现，是做不到的；</li>
<li>7.std::string : append(<strong>number</strong>, char) / .length() / .c_str() / .substr(begin_pos, <strong>new_len</strong>)</li>
<li>8.std::vector : .push_back() / .size() / .pop_back() (未验证）</li>
<li>9.std::pair : 把make_pair和pair和first和second的缩写define下来。</li>
<li>10.ascii : ‘a’ = ‘A’ + 32 ， 注意还原的位置 /</li>
</ul>
]]></content>
<categories>
<category>acm</category>
</categories>
<tags>
<tag>acm</tag>
<tag>leetcode</tag>
</tags>
</entry>
<entry>
<title>20210223 Codeforces Round 704 (Div. 2)</title>
<url>/acm/0223codeforces/</url>
<content><![CDATA[<h1 id="21-02-23-codeforces-704-div2（补题完成度【4-5】）"><a href="#21-02-23-codeforces-704-div2（补题完成度【4-5】）" class="headerlink" title="[21.02.23]codeforces 704 div2（补题完成度【4/5】）"></a>[21.02.23]codeforces 704 div2（补题完成度【4/5】）</h1><p>复健选手的第一场cf，rating0-575。<br>现在的cf竟然是从灰名往上爬升了。还是说我已经是掉到灰名水平了。震惊。</p>
<span id="more"></span>
<ul>
<li>A是签到</li>
<li>B是算结论题。有样例就是方便，公式没推，注意细节想清楚。</li>
<li>C是字符串双向遍历。这次的代码下标和写法我还是比较满意的，还是细节有点马虎，注意边界。</li>
<li>D是构造题。比赛时候最后十几分钟，找了一个二进制减法计算起才发现万能的构造做法，没交上去。以前打acm的时候不会犯这种错误的。</li>
<li>E从感觉上像dp/搜索/构造成图论或网络流，暂时没做出来。</li>
</ul>
<hr>
<h2 id="D-Genius’s-Gambit"><a href="#D-Genius’s-Gambit" class="headerlink" title="D.Genius’s Gambit"></a>D.Genius’s Gambit</h2><p><strong>题意</strong>：两个二进制串s,t，每个串都是a个0和b个1组成，希望使他们二进制相减后有k个1，判断是否存在，存在则任意构造。<br><strong>思路</strong>：</p>
<ul>
<li>众所周知，二进制数某一位做减法时0-0=0，1-1=0。仅0-1或者1-0的时候相减会出现1。<ul>
<li>当1-0时，仅此位为1，对题意构造的k比较浪费。</li>
<li>当0-1时借位，导致之前的所有相等的位全部变成1，直到再碰到对应位不同的位置。<ul>
<li>如果碰到0-1，当位为0，继续向前借位。</li>
<li>如果碰到1-0，之后所有相等的位都是0.</li>
<li>s>t且位数相同，所以总会碰见1-0的情况，因为s和t的0/1个数都相同，所以多余0-1对使构造复杂，应尽可能避免干扰。</li>
</ul>
</li>
</ul>
</li>
<li>列出基本的两种构造，不需要用的位都相等的列在前边，后面从右往左一组0-1，中间相等，直到碰到一组1-0停止。（不是最终答案）<ul>
<li>1x..x10000减1x..x00001，得到4个1</li>
<li>1x..x11110减1x..x01111，得到4个1</li>
<li>只要能拿出一些0和1构造这样的序列前面多少个按位对其x都行。因此，k<a和k<b-1的时候一定可构造。（s和t的首位都必须是1）<br>那么，k>a and b一定不行吗？并不是（这段当时差几分钟没交上去）</li>
</ul>
</li>
<li>只要是s和t形如1x..x0和0x..x1，只要s和t按位对齐，这个过程中x是0或者1可以穿插出现。<ul>
<li>构造：s’=11..1 00..0。</li>
<li>按k从右到左找到01交换位:如果位置是1则和尾巴的0交换，</li>
<li>则作为t’=1..101..1 00..01。</li>
<li>s’和t’就符合要求啦。</li>
</ul>
</li>
</ul>
<p>例子：</p>
<figure class="highlight apache"><table><tr><td class="code"><pre><span class="line"><span class="attribute">4</span> <span class="number">5</span> <span class="number">6</span></span><br><span class="line"><span class="attribute">Yes</span></span><br><span class="line"><span class="attribute">111110000</span></span><br><span class="line"><span class="attribute">110110001</span></span><br></pre></td></tr></table></figure>
<ul>
<li>但这个方法有个问题：如果找到的位置的数字是0就没办法和末尾0交换了。</li>
<li>为了避免这种情况，可以在之前把对应位置和第二位往后任意一个1提前交换作为s，保证待交换位是1。这样只要k<a+b-1，都可行。</li>
</ul>
<p>例子：</p>
<figure class="highlight awk"><table><tr><td class="code"><pre><span class="line"><span class="number">4</span> <span class="number">5</span> <span class="number">2</span></span><br><span class="line"><span class="regexp">//</span> <span class="number">111110000</span> 需要交换倒数第<span class="number">3</span>位和倒数第<span class="number">1</span>位</span><br><span class="line"><span class="regexp">//</span> <span class="number">101110100</span> 倒数第<span class="number">3</span>位是<span class="number">0</span>，和正数第<span class="number">2</span>位的<span class="number">1</span>交换</span><br><span class="line"></span><br><span class="line">Yes</span><br><span class="line"><span class="number">101110100</span></span><br><span class="line"><span class="number">101110001</span></span><br></pre></td></tr></table></figure>
<ul>
<li>而k=a+b-1，k+00..1=100..0 (a+b位)，需要交换第一个数字，而第一个数字必须是1，总之不存在。</li>
</ul>
<p><strong>代码</strong>如下：</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span><span class="meta-string"><bits/stdc++.h></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line"><span class="keyword">int</span> ans[<span class="number">200005</span>];</span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> a,b,k;</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%d%d%d"</span>, &a, &b, &k); <span class="comment">// (0, 1, k)</span></span><br><span class="line"> <span class="keyword">if</span>(k == <span class="number">0</span>){</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"Yes\n"</span>);</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < b; i++)<span class="built_in">printf</span>(<span class="string">"1"</span>);</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < a; i++)<span class="built_in">printf</span>(<span class="string">"0"</span>);</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"\n"</span>);</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < b; i++)<span class="built_in">printf</span>(<span class="string">"1"</span>);</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < a; i++)<span class="built_in">printf</span>(<span class="string">"0"</span>);</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"\n"</span>);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">if</span>(k == a+b || a==<span class="number">0</span> || b==<span class="number">1</span>){</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"No\n"</span>);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">if</span>(k < a+b<span class="number">-1</span>){</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"Yes\n"</span>);</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < b; i++)ans[i] = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = b; i < b+a; i++)ans[i] = <span class="number">0</span>;</span><br><span class="line"> k = a+b-k<span class="number">-1</span>;</span><br><span class="line"> <span class="keyword">int</span> change = ans[k];</span><br><span class="line"> <span class="keyword">if</span>(change == <span class="number">1</span>){</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < b+a; i++)<span class="built_in">printf</span>(<span class="string">"%d"</span>, ans[i]);<span class="built_in">printf</span>(<span class="string">"\n"</span>);</span><br><span class="line"> ans[k] = <span class="number">0</span>;</span><br><span class="line"> ans[b+a<span class="number">-1</span>] = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < b+a; i++)<span class="built_in">printf</span>(<span class="string">"%d"</span>, ans[i]);<span class="built_in">printf</span>(<span class="string">"\n"</span>);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span>{</span><br><span class="line"> ans[<span class="number">1</span>] = <span class="number">0</span>;</span><br><span class="line"> ans[k] = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < b+a; i++)<span class="built_in">printf</span>(<span class="string">"%d"</span>, ans[i]);<span class="built_in">printf</span>(<span class="string">"\n"</span>);</span><br><span class="line"> ans[k] = <span class="number">0</span>;</span><br><span class="line"> ans[b+a<span class="number">-1</span>] = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < b+a; i++)<span class="built_in">printf</span>(<span class="string">"%d"</span>, ans[i]);<span class="built_in">printf</span>(<span class="string">"\n"</span>);</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span>{</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"No\n"</span>);</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<hr>
<h2 id="C-Maximum-width"><a href="#C-Maximum-width" class="headerlink" title="C. Maximum width"></a>C. Maximum width</h2><p><strong>题意</strong>：长度为n的字符串s，长度为m的字符串t。找到s的子序列等于t。定义wideth为子序列中任意两字母相距位置的最大值。找到所有符合条件的子序列最大的width。<br><strong>思路</strong>：贪心。从左到右遍历s找一个最左边的子序列a，从右到左遍历s找一个最右边的子序列b，则答案的子序列为a的左半边和b的右半边拼接的结果，拼接位置遍历一遍。<br><strong>代码</strong>如下：</p>
<figure class="highlight arduino"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span><span class="meta-string"><bits/stdc++.h></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line"><span class="keyword">char</span> s[<span class="number">200005</span>];</span><br><span class="line"><span class="keyword">char</span> t[<span class="number">200005</span>];</span><br><span class="line"><span class="keyword">int</span> ans1[<span class="number">200005</span>];</span><br><span class="line"><span class="keyword">int</span> ans2[<span class="number">200005</span>];</span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> n, m;</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%d%d"</span>, &n, &m);</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%s"</span>, s);</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%s"</span>, t);</span><br><span class="line"> <span class="keyword">int</span> pointt=<span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> points=<span class="number">0</span>; points < n; points++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span>(s[points] == t[pointt]){ans1[pointt++]=points;<span class="keyword">if</span>(pointt == m)<span class="keyword">break</span>;}</span><br><span class="line"> }</span><br><span class="line"> pointt = m<span class="number">-1</span>;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> points=n<span class="number">-1</span>; points > <span class="number">-1</span>; points--)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span>(s[points] == t[pointt]){ans2[pointt--]=points;<span class="keyword">if</span>(pointt == <span class="number">-1</span>)<span class="keyword">break</span>;}</span><br><span class="line"> }</span><br><span class="line"> </span><br><span class="line"> <span class="keyword">int</span> ans = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">1</span>; i < n; i++){</span><br><span class="line"> ans = <span class="built_in">max</span>(ans, ans2[i]-ans1[i<span class="number">-1</span>]);</span><br><span class="line"> }</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%d\n"</span>, ans);</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
]]></content>
<categories>
<category>acm</category>
</categories>
<tags>
<tag>acm</tag>
<tag>codeforces</tag>
</tags>
</entry>
<entry>
<title>20210418 leetcode 第 237 场周赛</title>
<url>/acm/0418leetcode%E5%91%A8%E8%B5%9B/</url>
<content><![CDATA[<h1 id="21-04-18-周赛（ak）"><a href="#21-04-18-周赛（ak）" class="headerlink" title="[21.04.18]周赛（ak）"></a>[21.04.18]周赛（ak）</h1><p>第四题很离谱，做完一看，wow想拿奖要20分钟写完四道题5555</p>
<h2 id="判断句子是否为全字母句"><a href="#判断句子是否为全字母句" class="headerlink" title="判断句子是否为全字母句"></a>判断句子是否为全字母句</h2><p>无脑hash </p>
<hr>
<span id="more"></span>
<h2 id="雪糕的最大数量"><a href="#雪糕的最大数量" class="headerlink" title="雪糕的最大数量"></a>雪糕的最大数量</h2><p>无脑贪心</p>
<hr>
<h2 id="单线程-CPU"><a href="#单线程-CPU" class="headerlink" title="单线程 CPU"></a>单线程 CPU</h2><p>需要绑定当前下标，起始时间和执行长度。按起始时间排序。<br>优先队列。按事件长度排序。<br>每次把所有符合时间段的事件扔进优先队列。<br>队列每次取出事件长度最小的事件，更新当前时间，扔新的事件进去。<br>这道题几乎百分百考察的是代码稳定性。 </p>
<figure class="highlight arduino"><table><tr><td class="code"><pre><span class="line"><span class="class"><span class="keyword">class</span> <span class="title">Solution</span> {</span></span><br><span class="line"><span class="keyword">public</span>:</span><br><span class="line"> <span class="function"><span class="keyword">static</span> <span class="keyword">bool</span> <span class="title">cmp_time</span><span class="params">(<span class="built_in">pair</span><<span class="keyword">int</span>, <span class="built_in">vector</span><<span class="keyword">int</span>>>&taska, <span class="built_in">pair</span><<span class="keyword">int</span>, <span class="built_in">vector</span><<span class="keyword">int</span>>>&taskb)</span></span>{</span><br><span class="line"> <span class="keyword">if</span>(taska.second[<span class="number">0</span>] < taskb.second[<span class="number">0</span>])<span class="keyword">return</span> <span class="literal">true</span>;</span><br><span class="line"> <span class="keyword">return</span> <span class="literal">false</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="class"><span class="keyword">struct</span> <span class="title">cmp_len</span>{</span></span><br><span class="line"> <span class="function"><span class="keyword">bool</span> <span class="title">operator</span><span class="params">()</span><span class="params">(<span class="built_in">pair</span><<span class="keyword">int</span>, <span class="built_in">vector</span><<span class="keyword">int</span>>>&taska, <span class="built_in">pair</span><<span class="keyword">int</span>, <span class="built_in">vector</span><<span class="keyword">int</span>> >&taskb)</span> </span>{</span><br><span class="line"> <span class="keyword">if</span>(taska.second[<span class="number">1</span>] > taskb.second[<span class="number">1</span>])<span class="keyword">return</span> <span class="literal">true</span>;</span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">if</span>(taska.second[<span class="number">1</span>] == taskb.second[<span class="number">1</span>] && taska.first > taskb.first)<span class="keyword">return</span> <span class="literal">true</span>; </span><br><span class="line"> <span class="keyword">return</span> <span class="literal">false</span>;</span><br><span class="line"> }</span><br><span class="line"> };</span><br><span class="line"> <span class="comment">// static bool cmp_time(vector<int>&taska, vector<int>&taskb){</span></span><br><span class="line"> <span class="comment">// if(taska[0] < taskb[0])return true;</span></span><br><span class="line"> <span class="comment">// return false;</span></span><br><span class="line"> <span class="comment">// }</span></span><br><span class="line"> <span class="function"><span class="built_in">vector</span><<span class="keyword">int</span>> <span class="title">getOrder</span><span class="params">(<span class="built_in">vector</span><<span class="built_in">vector</span><<span class="keyword">int</span>>>& tasks)</span> </span>{</span><br><span class="line"> <span class="built_in">vector</span><<span class="keyword">int</span>>ret;</span><br><span class="line"> <span class="built_in">pair</span><<span class="keyword">int</span>,<span class="built_in">vector</span><<span class="keyword">int</span>>> order[tasks.<span class="built_in">size</span>()+<span class="number">5</span>];</span><br><span class="line"> <span class="built_in">memset</span>(order, <span class="number">0</span>, <span class="keyword">sizeof</span>(order));</span><br><span class="line"> ret.<span class="built_in">clear</span>();</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < tasks.<span class="built_in">size</span>(); i++){</span><br><span class="line"> <span class="comment">//pair<int,vector<int> now;</span></span><br><span class="line"> order[i].first = i;</span><br><span class="line"> order[i].second.push_back(tasks[i][<span class="number">0</span>]);</span><br><span class="line"> order[i].second.push_back(tasks[i][<span class="number">1</span>]);</span><br><span class="line"> }</span><br><span class="line"> sort(order, order+tasks.<span class="built_in">size</span>(), cmp_time);</span><br><span class="line"> <span class="comment">// for(int i = 0; i < tasks.size(); i++){</span></span><br><span class="line"> <span class="comment">// printf("%d %d,%d\n", order[i].first, order[i].second[0], order[i].second[1]);</span></span><br><span class="line"> <span class="comment">// }</span></span><br><span class="line"> <span class="built_in">priority_queue</span><<span class="built_in">pair</span><<span class="keyword">int</span>, <span class="built_in">vector</span><<span class="keyword">int</span>>>, <span class="built_in">vector</span><<span class="built_in">pair</span><<span class="keyword">int</span>, <span class="built_in">vector</span><<span class="keyword">int</span>>> >, cmp_len>q;</span><br><span class="line"> <span class="keyword">while</span>(!q.empty())q.pop();</span><br><span class="line"> <span class="keyword">int</span> time = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < tasks.<span class="built_in">size</span>();){</span><br><span class="line"> <span class="comment">//printf("time=%d\n", time);</span></span><br><span class="line"> <span class="keyword">if</span>(q.empty()){</span><br><span class="line"> q.push(order[i]);</span><br><span class="line"> time = <span class="built_in">max</span>(time, order[i].second[<span class="number">0</span>]);</span><br><span class="line"> i++;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">while</span>(i < tasks.<span class="built_in">size</span>() && time >= order[i].second[<span class="number">0</span>]){</span><br><span class="line"> q.push(order[i]);</span><br><span class="line"> i++;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span>(i < tasks.<span class="built_in">size</span>() && time < order[i].second[<span class="number">0</span>]){</span><br><span class="line"> time += q.top().second[<span class="number">1</span>];</span><br><span class="line"> ret.push_back(q.top().first);</span><br><span class="line"> q.pop();;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">while</span>(!q.empty()){</span><br><span class="line"> ret.push_back(q.top().first);</span><br><span class="line"> q.pop();</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> ret;</span><br><span class="line"> }</span><br><span class="line">};</span><br></pre></td></tr></table></figure>
<hr>
<h2 id="所有数对按位与结果的异或和"><a href="#所有数对按位与结果的异或和" class="headerlink" title="所有数对按位与结果的异或和"></a>所有数对按位与结果的异或和</h2><p>考虑与或非运算：<br>与相当于按位乘法，异或相当于按位加法（不进位） 。<br>众所周知，a_1<em>b+a_2</em>b+…+a_n*b = (a_1+a_2+…+a_n)*b<br>按位运算同样符合其性质。 </p>
<figure class="highlight arduino"><table><tr><td class="code"><pre><span class="line"><span class="class"><span class="keyword">class</span> <span class="title">Solution</span> {</span></span><br><span class="line"><span class="keyword">public</span>:</span><br><span class="line"> <span class="function"><span class="keyword">int</span> <span class="title">getXORSum</span><span class="params">(<span class="built_in">vector</span><<span class="keyword">int</span>>& arr1, <span class="built_in">vector</span><<span class="keyword">int</span>>& arr2)</span> </span>{</span><br><span class="line"> <span class="keyword">int</span> arra = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">int</span> ans = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < arr1.<span class="built_in">size</span>(); i++)arra ^= arr1[i];</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> j = <span class="number">0</span>; j < arr2.<span class="built_in">size</span>(); j++)ans ^= arra & arr2[j];</span><br><span class="line"> <span class="keyword">return</span> ans;</span><br><span class="line"></span><br><span class="line"> }</span><br><span class="line">};</span><br></pre></td></tr></table></figure>
]]></content>
<categories>
<category>acm</category>
</categories>
<tags>
<tag>acm</tag>
<tag>leetcode</tag>
</tags>
</entry>
<entry>
<title>20210321 leetcode 第 48 场双周赛</title>
<url>/acm/0321leetcode%E5%8F%8C%E5%91%A8%E8%B5%9B/</url>
<content><![CDATA[<h1 id="21-03-21-双周赛（补题已完成）"><a href="#21-03-21-双周赛（补题已完成）" class="headerlink" title="[21.03.21]双周赛（补题已完成）"></a>[21.03.21]双周赛（补题已完成）</h1><h2 id="字符串中第i大的数字"><a href="#字符串中第i大的数字" class="headerlink" title="字符串中第i大的数字"></a>字符串中第i大的数字</h2><p>又读错题了，还好这题过于简单，好改。</p>
<span id="more"></span>
<hr>
<h2 id="设计一个验证系统"><a href="#设计一个验证系统" class="headerlink" title="设计一个验证系统"></a>设计一个验证系统</h2><p>因为我leetcode做得不多，所以这是第一次见到leetcode的C++题（而不是算法题）。</p>
<ul>
<li> 成员变量：public, 不需要self.而是直接调用，尽量不要和传参数重名。<h3 id="map"><a href="#map" class="headerlink" title="map"></a>map</h3>初始化：注意迭代器的参数类型。<figure class="highlight cpp"><table><tr><td class="code"><pre><span class="line"><span class="built_in">map</span><<span class="built_in">string</span>, <span class="keyword">int</span>>mm;</span><br><span class="line"><span class="built_in">map</span><<span class="built_in">string</span>, <span class="keyword">int</span>>::iterator iter;</span><br></pre></td></tr></table></figure>
遍历：<figure class="highlight ocaml"><table><tr><td class="code"><pre><span class="line"><span class="keyword">for</span>(iter = mm.<span class="keyword">begin</span><span class="literal">()</span>; iter != mm.<span class="keyword">end</span><span class="literal">()</span>; iter++)</span><br><span class="line"> <span class="built_in">string</span> a = iter->first;</span><br><span class="line"> <span class="built_in">int</span> b = iter->second;</span><br></pre></td></tr></table></figure>
访问：<figure class="highlight css"><table><tr><td class="code"><pre><span class="line">if(mm<span class="selector-attr">[key]</span> > <span class="number">0</span>)mm<span class="selector-attr">[key]</span>++;</span><br></pre></td></tr></table></figure>
待更新。</li>
</ul>
<hr>
<h2 id="你能构造出连续值的最大数目"><a href="#你能构造出连续值的最大数目" class="headerlink" title="你能构造出连续值的最大数目"></a>你能构造出连续值的最大数目</h2><p>数学归纳法思想：</p>
<ol>
<li>极端构造序列：1,2,4,8,…</li>
<li>一定无法构造：sum(i) + 1 < a[i+1]，一定会停止</li>
<li>a[1] = 1，从0-1都可构造，否则连续值为0.</li>
<li>a[2] = 1或2，从0-sum(2)都可构造出来</li>
<li>如果0-sum(i-1)都能构造出来，a[i]不是停止点，那么sum(i-1)+a[i]=sum(i)就能构造出来<br>综上，若第一个停止点为a[i]，则最大构造为0-sum(i-1)，答案即sum(i-1)+1<br>代码：<figure class="highlight arduino"><table><tr><td class="code"><pre><span class="line"><span class="class"><span class="keyword">class</span> <span class="title">Solution</span> {</span></span><br><span class="line"> <span class="built_in">map</span><<span class="keyword">int</span>, <span class="keyword">bool</span>>mm;</span><br><span class="line"> <span class="keyword">long</span> <span class="keyword">long</span> maxm;</span><br><span class="line"><span class="keyword">public</span>:</span><br><span class="line"> <span class="function"><span class="keyword">int</span> <span class="title">getMaximumConsecutive</span><span class="params">(<span class="built_in">vector</span><<span class="keyword">int</span>>& coins)</span> </span>{</span><br><span class="line"> sort(coins.<span class="built_in">begin</span>(), coins.<span class="built_in">end</span>());</span><br><span class="line"> <span class="keyword">int</span> maxm = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">if</span>(coins[<span class="number">0</span>] > <span class="number">1</span>)<span class="keyword">return</span> <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < coins.<span class="built_in">size</span>(); i++){</span><br><span class="line"> <span class="keyword">if</span>(coins[i] > maxm+<span class="number">1</span>)<span class="keyword">break</span>;</span><br><span class="line"> maxm += coins[i];</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> maxm+<span class="number">1</span>;</span><br><span class="line"></span><br><span class="line"> }</span><br><span class="line">};</span><br></pre></td></tr></table></figure>
</li>
</ol>
<hr>
<h2 id="N-次操作后的最大分数和"><a href="#N-次操作后的最大分数和" class="headerlink" title="N 次操作后的最大分数和"></a>N 次操作后的最大分数和</h2><p>gcd+dfs<br>对2*N个数两两配对，使得sum(i<em>gcd())计算值最大。<br>先暴力gcd一遍，存数组。然后数据范围实在太小了(15\</em>13*11*9*7*5*3*1撑死1e7)，可以直接dfs。</p>
<ul>
<li> 写爆搜的熟练度0分啊，注意return之前的状态还原。</li>
<li> 复习了gcd的写法（顺便发现原来辗转相除可以不递归的）</li>
<li> vector.pop_back()</li>
<li> wa之后一顿debug，最终发现sort(vector.begin(), vector.end())有时候会改变内部元素的值？这就奇怪了，不知道是不是pop_back的原因，或是我的边界值有问题。原因之后搜一下。<figure class="highlight arduino"><table><tr><td class="code"><pre><span class="line"><span class="class"><span class="keyword">class</span> <span class="title">Solution</span> {</span></span><br><span class="line"> <span class="keyword">int</span> sss[<span class="number">15</span>][<span class="number">15</span>];</span><br><span class="line"> <span class="keyword">bool</span> used[<span class="number">15</span>];</span><br><span class="line"> <span class="keyword">int</span> pair_number;</span><br><span class="line"> <span class="built_in">vector</span><<span class="keyword">int</span>>score;</span><br><span class="line"> <span class="keyword">int</span> N;</span><br><span class="line"> <span class="keyword">int</span> max_ans;</span><br><span class="line"> <span class="keyword">int</span> nn_score[<span class="number">20</span>];</span><br><span class="line"><span class="keyword">public</span>:</span><br><span class="line"> <span class="function"><span class="keyword">int</span> <span class="title">gcd</span><span class="params">(<span class="keyword">int</span> a, <span class="keyword">int</span> b)</span></span>{</span><br><span class="line"> <span class="keyword">if</span>(a < b)swap(a, b);</span><br><span class="line"> <span class="keyword">if</span>(b < <span class="number">1</span>)<span class="keyword">return</span> a;</span><br><span class="line"> <span class="keyword">return</span> gcd(b, a%b);</span><br><span class="line"> }</span><br><span class="line"> </span><br><span class="line"> <span class="function"><span class="keyword">int</span> <span class="title">calculate_score</span><span class="params">()</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">int</span> ans = <span class="number">0</span>;</span><br><span class="line"> <span class="built_in">memset</span>(nn_score, <span class="number">0</span>, <span class="keyword">sizeof</span>(nn_score));</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < N; i++)nn_score[i] = score[i];</span><br><span class="line"> sort(nn_score, nn_score+N);</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < N; i++){</span><br><span class="line"> ans += nn_score[i]*(i+<span class="number">1</span>);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> ans;</span><br><span class="line"> }</span><br><span class="line"> </span><br><span class="line"> <span class="function"><span class="keyword">int</span> <span class="title">dfs</span><span class="params">(<span class="keyword">int</span> id)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">if</span>(id >= <span class="number">2</span>*N){<span class="built_in">printf</span>(<span class="string">"fatal error!"</span>);<span class="keyword">return</span> <span class="number">-1</span>;}</span><br><span class="line"> <span class="keyword">while</span>(used[id] && id < <span class="number">2</span>*N)id++;</span><br><span class="line"> used[id] = <span class="literal">true</span>;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = id+<span class="number">1</span>; i < <span class="number">2</span>*N; i++){</span><br><span class="line"> <span class="keyword">if</span>(used[i])<span class="keyword">continue</span>;</span><br><span class="line"> used[i] = <span class="literal">true</span>;</span><br><span class="line"> score.push_back(sss[id][i]);</span><br><span class="line"> pair_number++;</span><br><span class="line"> <span class="keyword">if</span>(pair_number == N){</span><br><span class="line"> <span class="keyword">int</span> ans = calculate_score();</span><br><span class="line"> <span class="keyword">if</span>(max_ans < ans)max_ans = ans;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span>{</span><br><span class="line"> dfs(id+<span class="number">1</span>);</span><br><span class="line"> }</span><br><span class="line"> used[i] = <span class="literal">false</span>;</span><br><span class="line"> score.pop_back();</span><br><span class="line"> pair_number--;</span><br><span class="line"> }</span><br><span class="line"> used[id] = <span class="literal">false</span>;</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">int</span> <span class="title">maxScore</span><span class="params">(<span class="built_in">vector</span><<span class="keyword">int</span>>& nums)</span> </span>{</span><br><span class="line"> N = nums.<span class="built_in">size</span>() / <span class="number">2</span>;</span><br><span class="line"> max_ans = <span class="number">0</span>;</span><br><span class="line"> pair_number = <span class="number">0</span>;</span><br><span class="line"> <span class="built_in">memset</span>(used, <span class="number">0</span>, <span class="keyword">sizeof</span>(used));</span><br><span class="line"> score.<span class="built_in">clear</span>();</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < <span class="number">2</span>*N; i++){</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> j = i+<span class="number">1</span>; j < <span class="number">2</span>*N; j++)</span><br><span class="line"> {</span><br><span class="line"> sss[i][j] = gcd(nums[i], nums[j]);</span><br><span class="line"> sss[j][i] = sss[i][j];</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> dfs(<span class="number">0</span>);</span><br><span class="line"> <span class="keyword">return</span> max_ans;</span><br><span class="line"> </span><br><span class="line"> }</span><br><span class="line">};</span><br></pre></td></tr></table></figure>
</li>
</ul>
]]></content>
<categories>
<category>acm</category>
</categories>
<tags>
<tag>acm</tag>
<tag>leetcode</tag>
</tags>
</entry>
<entry>
<title>20210417 leetcode 第 50 场双周赛</title>
<url>/acm/0417leetcode%E5%8F%8C%E5%91%A8%E8%B5%9B/</url>
<content><![CDATA[<h1 id="21-04-17-双周赛（补题进度【3-4】）"><a href="#21-04-17-双周赛（补题进度【3-4】）" class="headerlink" title="[21.04.17]双周赛（补题进度【3/4】）"></a>[21.04.17]双周赛（补题进度【3/4】）</h1><h2 id="最少操作使数组递增"><a href="#最少操作使数组递增" class="headerlink" title="最少操作使数组递增"></a>最少操作使数组递增</h2><p>一个小坑：暴力++++会超时<br>直接计算即可 </p>
<hr>
<span id="more"></span>
<h2 id="统计一个圆中点的数目"><a href="#统计一个圆中点的数目" class="headerlink" title="统计一个圆中点的数目"></a>统计一个圆中点的数目</h2><p>直接a^2+b^2 <= r^2计算 </p>
<hr>
<h2 id="每个查询的最大异或值"><a href="#每个查询的最大异或值" class="headerlink" title="每个查询的最大异或值"></a>每个查询的最大异或值</h2><p>利用位运算的性质：s^a^a=s<br>从后往前每一步结果转移，都是上一步的k ^= a[i]<br>注意的细节：不超过第maximumBit的约束，如果maxBit < max(nums)直接算，否则多余的位是111…11 </p>
<figure class="highlight arduino"><table><tr><td class="code"><pre><span class="line"><span class="class"><span class="keyword">class</span> <span class="title">Solution</span> {</span></span><br><span class="line"><span class="keyword">public</span>:</span><br><span class="line"> <span class="function"><span class="built_in">vector</span><<span class="keyword">int</span>> <span class="title">getMaximumXor</span><span class="params">(<span class="built_in">vector</span><<span class="keyword">int</span>>& nums, <span class="keyword">int</span> maximumBit)</span> </span>{</span><br><span class="line"> <span class="keyword">int</span> init = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < nums.<span class="built_in">size</span>(); i++){</span><br><span class="line"> init ^= nums[i];</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">int</span> max_ans = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">int</span> i = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">while</span>(nums[nums.<span class="built_in">size</span>()<span class="number">-1</span>]>>(i<span class="number">-1</span>))i++;</span><br><span class="line"> max_ans <<= i;</span><br><span class="line"> max_ans -= <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">int</span> vvb = (<span class="number">1</span><<(maximumBit))<span class="number">-1</span>;</span><br><span class="line"> <span class="built_in">vector</span><<span class="keyword">int</span>>ret;</span><br><span class="line"> ret.<span class="built_in">clear</span>();</span><br><span class="line"> <span class="comment">//printf("%d-%d ", init, max_ans);</span></span><br><span class="line"> <span class="keyword">int</span> now = init ^ max_ans;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = nums.<span class="built_in">size</span>()<span class="number">-1</span>; i >= <span class="number">0</span>; i--){</span><br><span class="line"> <span class="comment">//printf("%d-%d ", now, vvb);</span></span><br><span class="line"> <span class="comment">//now &= vvb;</span></span><br><span class="line"> ret.push_back(vvb & ((now & vvb) | (max_ans ^ vvb)));</span><br><span class="line"> now ^= nums[i];</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> ret;</span><br><span class="line"> </span><br><span class="line"> }</span><br><span class="line">};</span><br></pre></td></tr></table></figure>
<hr>
<h2 id="使字符串有序的最少操作次数"><a href="#使字符串有序的最少操作次数" class="headerlink" title="使字符串有序的最少操作次数"></a>使字符串有序的最少操作次数</h2><p>看了半天这什么玩意，相信一定是有规律的。试图打表未果，最后看了看样例发现，这不是全排列吗。<br>总之这题是给你一串字符串，计算他是当前这些字符组成的全排列的字典序第几个。<br>无重复数字的全排列可以用康托展开，这个有重复数字的全排列，除了排列组合之外没想到什么好的解决方案。。</p>
<p>更新：看了看题解，确实就是用组合数计算的，思路没问题，待补题。</p>
]]></content>
<categories>
<category>acm</category>
</categories>
<tags>
<tag>acm</tag>
<tag>leetcode</tag>
</tags>
</entry>
<entry>
<title>2018年清华夏令营机试题（思想） 积木 二分+线段树</title>
<url>/acm/2018%E6%B8%85%E5%8D%8E%E5%A4%8F%E4%BB%A4%E8%90%A5%E6%9C%BA%E8%AF%95%E9%A2%98%20%EF%BC%88%E6%80%9D%E6%83%B3%EF%BC%89%E7%A7%AF%E6%9C%A8%20%E4%BA%8C%E5%88%86+%E7%BA%BF%E6%AE%B5%E6%A0%91%20/</url>
<content><![CDATA[<p>题目描述：一摞积木(1e5)，每个长宽都是1*1，高h，密度ρ，由题目输入。每块积木承重a，由题目输入（超重不会塌）。现在我从第一块开始一块一块的堆积木，问堆到第几块的时候超重体积超过V，V由题目输入。</p>
<span id="more"></span>
<p>思想：</p>
<p>首先，所有积木的超重体积随着积木的增多是单调递增的。因此可以用二分记录它在放上哪块积木时超重，然后用一个数组add记录放上某块积木时新增的超重部分的体积，求前缀和就是放上第i块后超重部分的总体积，最后二分查找一下V就可以了。当然题目是多组询问，也可以给询问排序后遍历一遍取得所有答案。</p>
<p>但是这里有个很大的问题，就是积木可能是有一部分超重，一部分没超重，不能看做一个整体。可以说在放上第i块积木时有一部分超重了，但是没有全超重，然后可能在放上第i+1块，第i+2块，…，第j块超重部分一直在增加，直到第j块放上整个积木完全超重体积不再增加。</p>
<p>任意时刻，F（下表面）= F（上表面） + G0（自重）。我可以二分一下每块积木的上下表面超重时分别是第几块，得到一个变换区间(i, j)。</p>
<p>在(i,j)变换区间内有一个有趣的问题，就是放上第k块积木时超重体积增加了多少呢。</p>
<p>假如一块积木S，在变换区间内的某时刻的超重临界点在P点，称重Fp。那么放上积木k的时候，Fp’ = Fp + G(k)。因此积木平衡点将上移直到抵消这个G(k)，而抵消是通过减少上方自重，因此从原来的临界点P到新的临界点P’，减少的积木重量为G(k)，即是新增超重部分的重量G(k)。则新增体积为V(s, k) = G(k) / ρ(s)。</p>
<p>值得一提的是边界i和j需要单独计算一下新增的超重部分体积，这个最后处理。i,j开区间内直接处理即可。</p>
<p>现在我定义一个公式A(s, k) = V(s, k) / G(k) = 1/ρ(s)。</p>
<p>我们需要分别求放上某块积木k的时候，其下方所有积木增加的重量，于是对于每一个在变换区间的积木x1, x2, …, xn，体积增加都是V(xi, k)。定义∑V(k) = G(k) * ∑A(k)。</p>
<p>对于每块积木来说，在它变换区间范围内的点，虽然V不一定相同，但是A都是相同的1/ρ(s)。</p>
<p>因此可以给数组A构造一个线段树，初始化为0，对于每块积木s的变换区间（共n个）进行一次区间更新，给所有数加上1/ρ(s)，复杂度O(nlogn)，然后更新完依次取得每个点的最终值，复杂度O(nlogn)。</p>
<p>然后给每个点的最终值*G(k)，加到add上，将n个区间的边界分别加到add上，O(n)。</p>
<p>最后还是可以通过add的前缀数组处理多组询问的答案。</p>
<p>代码：2021年仍然不会写=w=。</p>
]]></content>
<categories>
<category>acm</category>
</categories>
<tags>
<tag>acm</tag>
<tag>contest</tag>
</tags>
</entry>
<entry>
<title>C/C++ STL set/map</title>
<url>/acm/C++%20stl%20set-map1/</url>
<content><![CDATA[<p>set和map由红黑树RBtree实现。</p>
<h1 id="初始化"><a href="#初始化" class="headerlink" title="初始化"></a>初始化</h1><figure class="highlight arduino"><table><tr><td class="code"><pre><span class="line"><span class="built_in">set</span><<span class="keyword">int</span>>ss;</span><br><span class="line">ss.<span class="built_in">clear</span>();</span><br><span class="line"><span class="built_in">map</span><<span class="keyword">int</span>, <span class="keyword">int</span>>mm;</span><br><span class="line">mm.<span class="built_in">clear</span>();</span><br></pre></td></tr></table></figure>
<h1 id="插入"><a href="#插入" class="headerlink" title="插入"></a>插入</h1><figure class="highlight less"><table><tr><td class="code"><pre><span class="line"><span class="selector-tag">ss</span><span class="selector-class">.insert</span>(k);</span><br><span class="line"><span class="selector-tag">map</span><span class="selector-attr">[k]</span>++;</span><br></pre></td></tr></table></figure>
<h1 id="删除"><a href="#删除" class="headerlink" title="删除"></a>删除</h1><figure class="highlight gcode"><table><tr><td class="code"><pre><span class="line">ss.erase<span class="comment">(num)</span></span><br><span class="line">ss.erase<span class="comment">(num_begin, num_end)</span></span><br><span class="line"><span class="comment">//?</span></span><br></pre></td></tr></table></figure>
<h1 id="遍历"><a href="#遍历" class="headerlink" title="遍历"></a>遍历</h1><figure class="highlight arduino"><table><tr><td class="code"><pre><span class="line"><span class="built_in">set</span><<span class="keyword">int</span>>::iterator it;</span><br><span class="line"><span class="keyword">for</span>(<span class="keyword">int</span> it = ss.<span class="built_in">begin</span>(); it != ss.<span class="built_in">end</span>(); it++){</span><br><span class="line"> <span class="keyword">int</span> a = *it;</span><br><span class="line">}</span><br><span class="line"><span class="built_in">map</span><<span class="keyword">int</span>, <span class="keyword">int</span>>::iterator it;</span><br><span class="line"><span class="keyword">for</span>(<span class="keyword">int</span> it = mm.<span class="built_in">begin</span>(); it != mm.<span class="built_in">end</span>(); it++){</span><br><span class="line"> <span class="keyword">int</span> a = it ->first;</span><br><span class="line"> <span class="keyword">int</span> b = it ->second;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h1 id="查找"><a href="#查找" class="headerlink" title="查找"></a>查找</h1><figure class="highlight dart"><table><tr><td class="code"><pre><span class="line"><span class="comment">// map</span></span><br><span class="line"><span class="keyword">if</span>(mm[<span class="built_in">num</span>] != <span class="number">0</span>){}</span><br><span class="line"><span class="keyword">if</span>(mm.find(<span class="built_in">num</span>));</span><br><span class="line"><span class="comment">// set 查到返回迭代器，查不到返回std::end</span></span><br><span class="line"><span class="keyword">if</span>(ss.find(<span class="built_in">num</span>) != ss.end()){}</span><br><span class="line"><span class="keyword">if</span>(ss.count(<span class="built_in">num</span>)){}</span><br></pre></td></tr></table></figure>
]]></content>
<categories>
<category>acm</category>
</categories>
<tags>
<tag>acm</tag>
<tag>leetcode</tag>
</tags>
</entry>
<entry>
<title>C/C++ STL sort</title>
<url>/acm/C++%20stl%20sort/</url>
<content><![CDATA[<figure class="highlight arduino"><table><tr><td class="code"><pre><span class="line"><span class="meta"># <span class="meta-keyword">include</span> <span class="meta-string"><algorithm></span></span></span><br><span class="line">sort(<span class="built_in">begin</span>,<span class="built_in">begin</span>+len,greater<data_type>())</span><br><span class="line">sort(<span class="built_in">begin</span>,<span class="built_in">begin</span>+len,less<data_type>())</span><br></pre></td></tr></table></figure>
<h1 id="自定义比较运算符"><a href="#自定义比较运算符" class="headerlink" title="自定义比较运算符"></a>自定义比较运算符</h1><figure class="highlight cpp"><table><tr><td class="code"><pre><span class="line"><span class="function"><span class="keyword">bool</span> <span class="title">cmp</span><span class="params">(<span class="keyword">int</span> a, <span class="keyword">int</span> b)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">return</span> a>b;</span><br><span class="line"> <span class="comment">// 在cmp=true是期望的，反之是不期望的。</span></span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h1 id="sort-的本质"><a href="#sort-的本质" class="headerlink" title="sort 的本质"></a>sort 的本质</h1><ul>
<li> 元素规模小于一定阈值16插入排序；</li>
<li>元素规模大于一定阈值16<ul>
<li> 递归层数阈值2*lg(n)，太深用堆排序</li>
<li> 不深，变形的一次快排（首尾中找一个中间值的元素作为分隔）</li>
</ul>
</li>
</ul>
]]></content>
<categories>
<category>acm</category>
</categories>
<tags>
<tag>acm</tag>
<tag>leetcode</tag>
</tags>
</entry>
<entry>
<title>C/C++ STL stack/queue</title>
<url>/acm/C++%20stl%20stack%20queue/</url>
<content><![CDATA[<p>stack和queue大概由deque实现。priority_queue由堆实现。</p>
<h1 id="初始化"><a href="#初始化" class="headerlink" title="初始化"></a>初始化</h1><figure class="highlight cpp"><table><tr><td class="code"><pre><span class="line"><span class="built_in">stack</span><<span class="keyword">int</span>>stk;</span><br><span class="line"><span class="keyword">while</span>(!stk.empty())stk.pop();</span><br><span class="line"><span class="built_in">queue</span><<span class="keyword">int</span>>que;</span><br><span class="line"><span class="keyword">while</span>(!que.empty())que.pop();</span><br><span class="line"><span class="built_in">priority_queue</span><<span class="keyword">int</span>>tq;</span><br><span class="line"><span class="keyword">while</span>(!tq.empty())tq.pop();</span><br></pre></td></tr></table></figure>
<h1 id="插入"><a href="#插入" class="headerlink" title="插入"></a>插入</h1><figure class="highlight abnf"><table><tr><td class="code"><pre><span class="line">stk.push(x)<span class="comment">;</span></span><br><span class="line">que.push(x)<span class="comment">;</span></span><br><span class="line">tq.push(x)<span class="comment">;</span></span><br></pre></td></tr></table></figure>
<h1 id="删除"><a href="#删除" class="headerlink" title="删除"></a>删除</h1><figure class="highlight abnf"><table><tr><td class="code"><pre><span class="line">stk.pop(x)<span class="comment">;</span></span><br><span class="line">que.pop(x)<span class="comment">;</span></span><br><span class="line">tq.pop(x)<span class="comment">;</span></span><br></pre></td></tr></table></figure>
<h1 id="取顶部元素"><a href="#取顶部元素" class="headerlink" title="取顶部元素"></a>取顶部元素</h1><figure class="highlight abnf"><table><tr><td class="code"><pre><span class="line">int x = stk.top()<span class="comment">;</span></span><br><span class="line">int y = que.front()<span class="comment">;</span></span><br><span class="line">int z = tq.front()<span class="comment">;</span></span><br></pre></td></tr></table></figure>
<h1 id="取底部元素"><a href="#取底部元素" class="headerlink" title="取底部元素"></a>取底部元素</h1><figure class="highlight angelscript"><table><tr><td class="code"><pre><span class="line"><span class="built_in">int</span> y2=que.back(); <span class="comment">// 大惊喜，糟糕的是priority_queue没有实现这个操作。</span></span><br></pre></td></tr></table></figure>
<h1 id="优先队列的细节"><a href="#优先队列的细节" class="headerlink" title="优先队列的细节"></a>优先队列的细节</h1><figure class="highlight cpp"><table><tr><td class="code"><pre><span class="line"><span class="built_in">priority_queue</span><<span class="keyword">int</span>, <span class="built_in">vector</span><<span class="keyword">int</span>>, greater<<span class="keyword">int</span>> >pq;</span><br><span class="line"><span class="comment">// 类型，容器，运算符</span></span><br><span class="line"><span class="comment">// 默认是*降序*，greater为升序，less为降序。</span></span><br></pre></td></tr></table></figure>
<p>小根堆初步代码实现</p>
<figure class="highlight csharp"><table><tr><td class="code"><pre><span class="line"><span class="meta"># include <queue></span></span><br><span class="line"><span class="meta"># include <cstdio></span></span><br><span class="line"><span class="meta"># include <cstring></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="title">std</span>;</span><br><span class="line"><span class="keyword">class</span> <span class="title">NodeTree</span></span><br><span class="line">{</span><br><span class="line"><span class="keyword">public</span>:</span><br><span class="line"> <span class="built_in">int</span> <span class="keyword">var</span>;</span><br><span class="line">};</span><br><span class="line"><span class="keyword">class</span> <span class="title">Heap</span></span><br><span class="line">{</span><br><span class="line"><span class="keyword">public</span>:</span><br><span class="line"> NodeTree treenode[<span class="number">1005</span>];</span><br><span class="line"> <span class="built_in">int</span> length;</span><br><span class="line"> Heap()</span><br><span class="line"> {</span><br><span class="line"> length = <span class="number">0</span>;</span><br><span class="line"> memset(treenode, <span class="number">0</span>, <span class="keyword">sizeof</span>(treenode));</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">insert_heap</span>(<span class="params"><span class="built_in">int</span> number</span>)</span></span><br><span class="line"><span class="function"></span> {</span><br><span class="line"> length++;</span><br><span class="line"> treenode[length].<span class="keyword">var</span> = number;</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="built_in">int</span> <span class="title">modify_heap</span>(<span class="params"><span class="built_in">int</span> i</span>)</span></span><br><span class="line"><span class="function"></span> {</span><br><span class="line"> <span class="built_in">int</span> now=i;</span><br><span class="line"> <span class="built_in">int</span> left = <span class="number">2</span>*i, right=<span class="number">2</span>*i+<span class="number">1</span>;</span><br><span class="line"> <span class="keyword">if</span>(right > length){</span><br><span class="line"> <span class="keyword">if</span>(left <= length && treenode[left].<span class="keyword">var</span> < treenode[now].<span class="keyword">var</span>){swap(treenode[left].<span class="keyword">var</span>, treenode[now].<span class="keyword">var</span>);<span class="keyword">return</span> <span class="number">1</span>;}</span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span>{</span><br><span class="line"> <span class="keyword">if</span>(treenode[left].<span class="keyword">var</span> > treenode[right].<span class="keyword">var</span> && treenode[right].<span class="keyword">var</span> < treenode[now].<span class="keyword">var</span>){swap(treenode[right].<span class="keyword">var</span>, treenode[now].<span class="keyword">var</span>);<span class="keyword">return</span> <span class="number">2</span>;}</span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">if</span>(treenode[left].<span class="keyword">var</span> <= treenode[right].<span class="keyword">var</span> && treenode[left].<span class="keyword">var</span> < treenode[now].<span class="keyword">var</span>){swap(treenode[left].<span class="keyword">var</span>, treenode[now].<span class="keyword">var</span>);<span class="keyword">return</span> <span class="number">1</span>;}</span><br><span class="line"></span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">build_heap</span>(<span class="params">vector<<span class="built_in">int</span>> number</span>)</span></span><br><span class="line"><span class="function"></span> {</span><br><span class="line"> <span class="keyword">for</span>(<span class="built_in">int</span> i = <span class="number">0</span>; i < number.size(); i++){</span><br><span class="line"> insert_heap(number[i]);</span><br><span class="line"> <span class="keyword">for</span>(<span class="built_in">int</span> i = length; i > <span class="number">0</span>; i--)</span><br><span class="line"> modify_heap(i);</span><br><span class="line"> }</span><br><span class="line"><span class="comment">// printf("build complete\n");</span></span><br><span class="line"><span class="comment">// for(int i = 1; i <= length; i++){</span></span><br><span class="line"><span class="comment">// printf("%d-", treenode[i]);</span></span><br><span class="line"><span class="comment">// }</span></span><br><span class="line"><span class="comment">// printf("\n");</span></span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">push</span>(<span class="params"><span class="built_in">int</span> i</span>)</span>{</span><br><span class="line"> insert_heap(i);</span><br><span class="line"> <span class="keyword">for</span>(<span class="built_in">int</span> i = length; i > <span class="number">0</span>; i>>=<span class="number">1</span>)</span><br><span class="line"> modify_heap(i);</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="built_in">int</span> <span class="title">top</span>(<span class="params"></span>)</span></span><br><span class="line"><span class="function"></span> {</span><br><span class="line"> <span class="keyword">return</span> treenode[<span class="number">1</span>].<span class="keyword">var</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">pop</span>(<span class="params"></span>)</span></span><br><span class="line"><span class="function"></span> {</span><br><span class="line"> treenode[<span class="number">1</span>].<span class="keyword">var</span> = treenode[length].<span class="keyword">var</span>;</span><br><span class="line"> length--;</span><br><span class="line"> <span class="keyword">for</span>(<span class="built_in">int</span> i = <span class="number">1</span>; i <= length; ){</span><br><span class="line"> <span class="built_in">int</span> p = modify_heap(i);</span><br><span class="line"> <span class="keyword">if</span>(p == <span class="number">0</span>)<span class="keyword">break</span>;</span><br><span class="line"> <span class="keyword">if</span>(p == <span class="number">1</span>)i *= <span class="number">2</span>;</span><br><span class="line"> <span class="keyword">if</span>(p == <span class="number">2</span>)i = <span class="number">2</span>*i+<span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="built_in">bool</span> <span class="title">empty</span>(<span class="params"></span>)</span></span><br><span class="line"><span class="function"></span> {</span><br><span class="line"> <span class="keyword">return</span> length==<span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line">};</span><br><span class="line"><span class="function"><span class="built_in">int</span> <span class="title">main</span>(<span class="params"></span>)</span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> vector<<span class="built_in">int</span>>number={<span class="number">39</span>,<span class="number">24</span>,<span class="number">12</span>,<span class="number">64</span>,<span class="number">2</span>,<span class="number">67</span>,<span class="number">34</span>,<span class="number">77</span>,<span class="number">25</span>,<span class="number">23</span>, <span class="number">29</span>, <span class="number">66</span>};</span><br><span class="line"> Heap heap;</span><br><span class="line"> heap.build_heap(number);</span><br><span class="line"></span><br><span class="line"> <span class="keyword">while</span>(!heap.empty())</span><br><span class="line"> {</span><br><span class="line"> printf(<span class="string">"=%d="</span>, heap.top());</span><br><span class="line"> heap.pop();</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br><span class="line"></span><br></pre></td></tr></table></figure>
]]></content>
<categories>
<category>acm</category>
</categories>
<tags>
<tag>acm</tag>
<tag>leetcode</tag>
</tags>
</entry>
<entry>
<title>C/C++ STL vector</title>
<url>/acm/C++%20stl%20vector/</url>
<content><![CDATA[<h1 id="初始化"><a href="#初始化" class="headerlink" title="初始化"></a>初始化</h1><figure class="highlight arduino"><table><tr><td class="code"><pre><span class="line"><span class="built_in">vector</span><<span class="keyword">int</span>>vec;</span><br><span class="line">vec.<span class="built_in">clear</span>();</span><br></pre></td></tr></table></figure>
<h1 id="插入"><a href="#插入" class="headerlink" title="插入"></a>插入</h1><figure class="highlight reasonml"><table><tr><td class="code"><pre><span class="line">vec.push<span class="constructor">_back(<span class="params">k</span>)</span>;</span><br></pre></td></tr></table></figure>
<h1 id="删除"><a href="#删除" class="headerlink" title="删除"></a>删除</h1><figure class="highlight reasonml"><table><tr><td class="code"><pre><span class="line">vec.pop<span class="constructor">_back(<span class="params">k</span>)</span>;</span><br><span class="line"><span class="comment">// 似乎会出现细节问题？</span></span><br></pre></td></tr></table></figure>
<h1 id="遍历"><a href="#遍历" class="headerlink" title="遍历"></a>遍历</h1><figure class="highlight applescript"><table><tr><td class="code"><pre><span class="line"><span class="keyword">for</span>(int <span class="keyword">it</span> = <span class="number">0</span>; <span class="keyword">it</span> < vec.size(); <span class="keyword">it</span>++){</span><br><span class="line"> int a = vec[<span class="keyword">it</span>];</span><br><span class="line">}</span><br><span class="line"></span><br></pre></td></tr></table></figure>
<h1 id="查找"><a href="#查找" class="headerlink" title="查找"></a>查找</h1><p>时间复杂度o(n)</p>
<h1 id="排序"><a href="#排序" class="headerlink" title="排序"></a>排序</h1><figure class="highlight lisp"><table><tr><td class="code"><pre><span class="line">sort(<span class="name">vec</span>.begin(), vec.end())<span class="comment">;</span></span><br><span class="line">sort(<span class="name">vec</span>.begin(), vec.end(), greater<int>())</span><br></pre></td></tr></table></figure>
]]></content>
<categories>
<category>acm</category>
</categories>
<tags>
<tag>acm</tag>
<tag>leetcode</tag>
</tags>
</entry>
<entry>
<title>C/C++ STL string常用操作</title>
<url>/acm/C++%20stl%20string/</url>
<content><![CDATA[<h1 id="初始化"><a href="#初始化" class="headerlink" title="初始化"></a>初始化</h1><p>string str;</p>
<h1 id="char转换"><a href="#char转换" class="headerlink" title="char转换"></a>char转换</h1><figure class="highlight axapta"><table><tr><td class="code"><pre><span class="line"><span class="built_in">char</span> *cstr = <span class="built_in">str</span>.c_str();</span><br></pre></td></tr></table></figure>
<h1 id="插入"><a href="#插入" class="headerlink" title="插入"></a>插入</h1><figure class="highlight x86asm"><table><tr><td class="code"><pre><span class="line"><span class="keyword">str</span><span class="number">.</span>insert(<span class="number">ch</span>, pos)<span class="comment">;</span></span><br></pre></td></tr></table></figure>
<h1 id="删除"><a href="#删除" class="headerlink" title="删除"></a>删除</h1><figure class="highlight apache"><table><tr><td class="code"><pre><span class="line"><span class="attribute">str</span>.erase(pos<span class="number">1</span>, pos<span class="number">2</span>);</span><br></pre></td></tr></table></figure>
<h1 id="查找"><a href="#查找" class="headerlink" title="查找"></a>查找</h1><figure class="highlight routeros"><table><tr><td class="code"><pre><span class="line">str.<span class="builtin-name">find</span>(ch)</span><br></pre></td></tr></table></figure>
]]></content>
<categories>
<category>acm</category>
</categories>
<tags>
<tag>acm</tag>
<tag>leetcode</tag>
</tags>
</entry>
<entry>
<title>Codeforces 1006F Xor-Paths 双向dfs</title>
<url>/acm/codeforces%201006F%20Xor-Paths%20%E5%8F%8C%E5%90%91dfs/</url>
<content><![CDATA[<p><a href="http://codeforces.com/problemset/problem/1006/F">题目链接</a><br>题意：简而言之，一个m<em>n（20</em>20）的数组，每个点有个权值，从（1,1）出发，每次可以向下/右走一个格，取路径所有权值的异或和^，求有几条路使从起点到到（m,n）的时候异或和为K(1e18)。</p>
<span id="more"></span>
<p>思路：<br>第一反应是裸dp，然后发现dp[i][j][k] = dp[i-1][j][ k^map[i][j] ] + dp[i][j-1][ k^map[i][j] ]但是第三维度显然存不下。</p>
<p>然后想了想mn不大，用vector<pair<long long, long long>>试试，i*m+j标号，把转移的（k,time）对都存在数组里，使用完清空，MLE。然后想遍历vector如果有first相同的元素更新second, TLE。然后想想好像跟暴力也没啥大区别。</p>
<p>然后想用map<pair<pair<int, int >, long long > >或者map<pair<int, int>, map<long long> >，发现不会stl嵌套。</long></p>
<p>然后看了看大神的代码，dfs超时，但是只有一个双向搜索就能搞定，连剪纸都不太要，感觉自己十分愚蠢。异或是满足结合律的。而且这个搜索只要先搜一半再对比一半就ok了，连动态左一下右一下都不要。</p>
<p>meet-in-the-middle。对于这个二维数组，一端的扫描从（1,1）开始，到达x+y = *在从左下到右上的那条先作为中轴线停止，x+y固定，下标只需要知道x就能取得y，map<int>[long long]记录。然后从另一端找过来，也是到了中轴线就可以判断次数。这样极限条件下到达中线时两边搜索层数都在10-20层，时间复杂度很够用。</int></p>
<p>特别注意一下中线位置的x+y应该等于多少的细节问题</p>
<p>代码：</p>
<figure class="highlight arduino"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><bits/stdc++.h></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> MAXN = <span class="number">22</span>;</span><br><span class="line"><span class="keyword">long</span> <span class="keyword">long</span> a[MAXN][MAXN];</span><br><span class="line"><span class="keyword">int</span> n, m;</span><br><span class="line"><span class="keyword">long</span> <span class="keyword">long</span> KK, ans;</span><br><span class="line"><span class="built_in">map</span><<span class="keyword">long</span> <span class="keyword">long</span>, <span class="keyword">long</span> <span class="keyword">long</span>>mp[MAXN];</span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">dfs_down</span><span class="params">(<span class="keyword">int</span> x, <span class="keyword">int</span> y, <span class="keyword">long</span> <span class="keyword">long</span> maxn)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">if</span>(x + y == (n + m - <span class="number">1</span>) / <span class="number">2</span>){mp[x][maxn]++;<span class="keyword">return</span>;}</span><br><span class="line"> <span class="keyword">if</span>(x < n<span class="number">-1</span>)dfs_down(x+<span class="number">1</span>, y, maxn^a[x+<span class="number">1</span>][y]);</span><br><span class="line"> <span class="keyword">if</span>(y < m<span class="number">-1</span>)dfs_down(x, y+<span class="number">1</span>, maxn^a[x][y+<span class="number">1</span>]);</span><br><span class="line">}</span><br><span class="line"> </span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">dfs_up</span><span class="params">(<span class="keyword">int</span> x, <span class="keyword">int</span> y, <span class="keyword">long</span> <span class="keyword">long</span> maxn)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">if</span>(x + y == (n + m - <span class="number">1</span>) / <span class="number">2</span>){</span><br><span class="line"> <span class="keyword">if</span>(mp[x].<span class="built_in">find</span>(maxn ^ KK ^ a[x][y]) != mp[x].<span class="built_in">end</span>()){</span><br><span class="line"> ans += mp[x][maxn ^ KK ^ a[x][y]];</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span>(x > <span class="number">0</span>)dfs_up(x<span class="number">-1</span>, y, maxn^a[x<span class="number">-1</span>][y]);</span><br><span class="line"> <span class="keyword">if</span>(y > <span class="number">0</span>)dfs_up(x, y<span class="number">-1</span>, maxn^a[x][y<span class="number">-1</span>]);</span><br><span class="line"> </span><br><span class="line">}</span><br><span class="line"> </span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%d%d%lld"</span>, &n, &m, &KK);</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < n; i++){</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> j = <span class="number">0</span>; j < m; j++){</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%lld"</span>, &a[i][j]);</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> dfs_down(<span class="number">0</span>,<span class="number">0</span>, a[<span class="number">0</span>][<span class="number">0</span>]);</span><br><span class="line"> dfs_up(n<span class="number">-1</span>, m<span class="number">-1</span>, a[n<span class="number">-1</span>][m<span class="number">-1</span>]);</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%lld\n"</span>, ans);</span><br><span class="line">}</span><br></pre></td></tr></table></figure>]]></content>
<categories>
<category>acm</category>
</categories>
<tags>
<tag>acm</tag>
<tag>codeforces</tag>
</tags>
</entry>
<entry>
<title>Codeforces 1012C Hills 比较简单的DP</title>
<url>/acm/codeforces%201012C%20Hills%20%E6%AF%94%E8%BE%83%E7%AE%80%E5%8D%95%E7%9A%84DP/</url>
<content><![CDATA[<p>刚刚拿到一个夏令营的offer，顺便在附近城市玩了两天，算起来出门在外有10天了？重新开始补题。</p>
<hr>
<p><a href="http://codeforces.com/problemset/problem/1012/C">题目链接</a></p>
<span id="more"></span>
<p>题意：输入一串数字代表一串山坡的高度，可以建房子的山坡的定义是这个山坡的高度严格比旁边两个山坡大。我可以用挖掘机挖山坡使其高度-1（可以减到负数）。现在要分别找到想建1-n/2个房子，问要挖掉的总高度的最小值。（n:5e3）</p>
<p>从题目知道我们房子显然不能两个贴在一起放，如果第i个山坡修了房子，则第i+1个山坡一定放不了房子，然后第i+2个山坡的左侧山坡可能在修第i个山坡的时候被挖掉了一块。所以i只对i+1和i+2都有影响。</p>
<p>直观的思想：定义dp[i][j][k]，i为现在计算第i个山坡的情况（如果空间不足可以滚动），j代表之前的这段区间修了j个房子，k代表上个房子的位置，状态取值为0-2，分别代表上个房子在很早以前（即对i无影响）、在第i个山坡、在第i-1个山坡（影响修i的时候挖掉的面积）。值为修到这里需要挖走的最小高度。</p>
<p>转移公式为:</p>
<p>dp[i][j][0] = min(dp[i-1][j][0], dp[i-1][j][2]);</p>
<p>dp[i][j][1] = min( dp[i-1][j][0]+max(0, h[i-1]-h[i]+1), dp[i-1][j][2]+max(0, max(0, min(h[i-2]-1, h[i-1]) - h[i] + 1 )(从2状态转移，提前计算i-1现在的高度)</p>
<p>dp[i][j][2] = dp[i-1][j][1]</p>
<p>然后我写了long long 的数组，悲剧的发现爆内存了，尤其是发现别人用int写的三种状态并没有爆内存。</p>
<p>然后发现所有2状态可以用公式3替换掉。但是需要注意的是这样的话最后求解对每个j需要算：min(dp[n-1][j][0], dp[n-1][j][1], dp[n-2][j][1])。这里很容易把第三项丢掉。</p>
<p>然后注意一下初始化，判断一下n=1的情况和边界，然后注意一下输出k的取值是(n+1)/2就可以了。</p>
<p>代码：</p>
<figure class="highlight inform7"><table><tr><td class="code"><pre><span class="line">#include <bits/stdc++.h></span><br><span class="line">using namespace std;</span><br><span class="line">const int MAXN = 5e3 + 3;</span><br><span class="line">const long long MAXLL = 9e18;</span><br><span class="line">long long h<span class="comment">[MAXN]</span>;</span><br><span class="line">long long dp<span class="comment">[MAXN]</span><span class="comment">[MAXN]</span><span class="comment">[2]</span>; //last <span class="keyword">is</span> i, now has j</span><br><span class="line">int main()</span><br><span class="line">{</span><br><span class="line"> int n;</span><br><span class="line"> scanf(<span class="string">"%d"</span>, &n);</span><br><span class="line"> for(int i = 0; i < n; i++)</span><br><span class="line"> {</span><br><span class="line"> scanf(<span class="string">"%lld"</span>, &h<span class="comment">[i]</span>);</span><br><span class="line"> }</span><br><span class="line"> for(int i = 0; i <= n; i++)</span><br><span class="line"> {</span><br><span class="line"> for(int j = 0; j <= n; j++)</span><br><span class="line"> {</span><br><span class="line"> dp<span class="comment">[i]</span><span class="comment">[j]</span><span class="comment">[0]</span> = MAXLL;</span><br><span class="line"> dp<span class="comment">[i]</span><span class="comment">[j]</span><span class="comment">[1]</span> = MAXLL;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> for(int i = 0; i < n; i++)dp<span class="comment">[i]</span><span class="comment">[0]</span><span class="comment">[0]</span> = 0LL;</span><br><span class="line"> if(n == 1)</span><br><span class="line"> {</span><br><span class="line"> printf(<span class="string">"0\n"</span>);return 0;</span><br><span class="line"> }</span><br><span class="line"> if(n > 1)dp<span class="comment">[0]</span><span class="comment">[1]</span><span class="comment">[1]</span> = max(0LL, h<span class="comment">[1]</span> - h<span class="comment">[0]</span> + 1LL);</span><br><span class="line"> for(int i = 2; i < n; i++)dp<span class="comment">[0]</span><span class="comment">[i]</span><span class="comment">[0]</span> = dp<span class="comment">[0]</span><span class="comment">[i]</span><span class="comment">[1]</span>= MAXLL;</span><br><span class="line"> for(int i = 1; i < n; i++)</span><br><span class="line"> {</span><br><span class="line"> for(int j = 1; j <= i/2 + 1; j++)</span><br><span class="line"> {</span><br><span class="line"> dp<span class="comment">[i]</span><span class="comment">[j]</span><span class="comment">[0]</span> = dp<span class="comment">[i-1]</span><span class="comment">[j]</span><span class="comment">[0]</span>;</span><br><span class="line"> if(i > 1)dp<span class="comment">[i]</span><span class="comment">[j]</span><span class="comment">[0]</span> = min(dp<span class="comment">[i]</span><span class="comment">[j]</span><span class="comment">[0]</span>, dp<span class="comment">[i-2]</span><span class="comment">[j]</span><span class="comment">[1]</span>);</span><br><span class="line"> dp<span class="comment">[i]</span><span class="comment">[j]</span><span class="comment">[1]</span> = dp<span class="comment">[i-1]</span><span class="comment">[j-1]</span><span class="comment">[0]</span> + max(0LL, h<span class="comment">[i-1]</span> - h<span class="comment">[i]</span> + 1LL);</span><br><span class="line"> if(i > 1){dp<span class="comment">[i]</span><span class="comment">[j]</span><span class="comment">[1]</span> = min(dp<span class="comment">[i]</span><span class="comment">[j]</span><span class="comment">[1]</span>, dp<span class="comment">[i-2]</span><span class="comment">[j-1]</span><span class="comment">[1]</span> + max(0LL, min(h<span class="comment">[i-2]</span>-1LL, h<span class="comment">[i-1]</span>) - h<span class="comment">[i]</span> + 1LL));}</span><br><span class="line"> if(i < n-1)dp<span class="comment">[i]</span><span class="comment">[j]</span><span class="comment">[1]</span> += max(0LL, h<span class="comment">[i+1]</span> - h<span class="comment">[i]</span> + 1LL);</span><br><span class="line"> //dp<span class="comment">[i]</span><span class="comment">[j]</span><span class="comment">[2]</span> = dp<span class="comment">[i-1]</span><span class="comment">[j]</span><span class="comment">[1]</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> /*for(int i = 0; i < n; i++)</span><br><span class="line"> {</span><br><span class="line"> for(int j = 0; j < n; j++)printf(<span class="string">"%lld:%lld "</span>, dp<span class="comment">[i]</span><span class="comment">[j]</span><span class="comment">[0]</span>, dp<span class="comment">[i]</span><span class="comment">[j]</span><span class="comment">[1]</span>);printf(<span class="string">"\n"</span>);</span><br><span class="line"> }*/</span><br><span class="line"> long long ans = 0;</span><br><span class="line"> for(int i = 1; i <= (n+1)/2; i++){</span><br><span class="line"> ans = min(dp<span class="comment">[n-1]</span><span class="comment">[i]</span><span class="comment">[0]</span>, min(dp<span class="comment">[n-1]</span><span class="comment">[i]</span><span class="comment">[1]</span>, dp<span class="comment">[n-2]</span><span class="comment">[i]</span><span class="comment">[1]</span>));</span><br><span class="line"> printf(<span class="string">"%lld%c"</span>, ans, i == n/2+1? '\n' : ' ');</span><br><span class="line"> }</span><br><span class="line"> </span><br><span class="line"> return 0;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>]]></content>
<categories>
<category>acm</category>
</categories>
<tags>
<tag>acm</tag>
<tag>codeforces</tag>
</tags>
</entry>
<entry>
<title>csp 201712-2 游戏 暴力，附：约瑟夫环的递推</title>
<url>/acm/csp%20201712-2%20%E6%B8%B8%E6%88%8F%20%E6%9A%B4%E5%8A%9B+%EF%BC%88%E4%BB%A5%E6%AD%A4%E4%B8%BA%E4%BE%8B%EF%BC%89%E7%BA%A6%E7%91%9F%E5%A4%AB%E7%8E%AF%E7%9A%84%E9%80%92%E6%8E%A8/</url>
<content><![CDATA[<p>中问题竟然愚蠢的看错题了。中文读题能力还不如英文，有待提升。</p>
<p>所以这道题用普通的数组模拟操作就可以了。总之跟暴力模拟的约瑟夫环没什么区别。</p>
<p>可以用next数组模拟指针做数据结构，但是数据范围不大的情况下不建议这么写，维护一个指针环写起来还是比较麻烦的。</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><cstdio></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><cstring></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><cmath></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><algorithm></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> MAXN = <span class="number">1005</span>;</span><br><span class="line"><span class="keyword">bool</span> survive[MAXN];</span><br><span class="line"> </span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">solve</span><span class="params">(<span class="keyword">int</span> n, <span class="keyword">int</span> k)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < n; i++)</span><br><span class="line"> {</span><br><span class="line"> survive[i] = <span class="literal">true</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">int</span> cnt = <span class="number">0</span>, snum = n;</span><br><span class="line"> <span class="keyword">int</span> idx = <span class="number">-1</span>;</span><br><span class="line"> <span class="keyword">while</span>(snum)</span><br><span class="line"> {</span><br><span class="line"> idx = (idx + <span class="number">1</span>) % n;</span><br><span class="line"> <span class="keyword">if</span>(survive[idx] == <span class="literal">true</span>){</span><br><span class="line"> cnt++;</span><br><span class="line"> <span class="keyword">if</span>(cnt % k == <span class="number">0</span> || cnt % <span class="number">10</span> == k){</span><br><span class="line"> survive[idx] = <span class="literal">false</span>;</span><br><span class="line"> <span class="comment">//printf("%d\n", idx+1);</span></span><br><span class="line"> snum--;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span>(snum == <span class="number">1</span>)<span class="keyword">break</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < n; i++)<span class="keyword">if</span>(survive[i] == <span class="literal">true</span>)<span class="keyword">return</span> i;</span><br><span class="line">}</span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"> </span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> n, k;</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%d%d"</span>, &n, &k);</span><br><span class="line"> <span class="keyword">int</span> ans = solve(n, k);</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%d\n"</span>, ans+<span class="number">1</span>);</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<p>但是突然想到比得十分GG的蓝桥杯国赛，必须要记录一下约瑟夫环的标准数学（找规律）解法。</p>
<p>将k固定，设解ANS[n,k] = ans(n)</p>
<p>具有m个数的m约瑟夫环中，删除一个数之后，相当于重新标号后的m-1约瑟夫环问题。</p>
<p>设从a(1)开始的m约瑟夫环答案为ans(m) = s，在m+1约瑟夫环中，由于经历了重新标号，m中的标号a(i)应该为a((k+i)%(m+1)) ,所以答案下标也要从s移动到(s+k)%(m+1).</p>
<p>公式：ans(1) = 1, ans(m+1) = (ans(m)+k)%(m+1)。代码如下：</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><cstdio></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><cstring></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><cmath></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><algorithm></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line"><span class="comment">//标准约瑟夫环，非此题题解</span></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> n, k;</span><br><span class="line"> <span class="keyword">int</span> i, s = <span class="number">0</span>;</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%d%d"</span>, &n, &k);</span><br><span class="line"> <span class="keyword">for</span> (i = <span class="number">2</span>; i <= n; i++)</span><br><span class="line"> {</span><br><span class="line"> s = (s + k) % i;</span><br><span class="line"> <span class="comment">//printf("%d\n",s+1);</span></span><br><span class="line"> }</span><br><span class="line"> <span class="built_in">printf</span> (<span class="string">"%d\n"</span>, s+<span class="number">1</span>);</span><br><span class="line">}</span><br></pre></td></tr></table></figure>]]></content>
<categories>
<category>acm</category>
</categories>
<tags>
<tag>acm</tag>
<tag>csp</tag>
</tags>
</entry>
<entry>
<title>csp 201712-3 Crontab （恶心的）string处理 大模拟</title>
<url>/acm/csp%20201712-3%20Crontab%20%EF%BC%88%E6%81%B6%E5%BF%83%E7%9A%84%EF%BC%89string%E5%A4%84%E7%90%86%20%E5%A4%A7%E6%A8%A1%E6%8B%9F/</url>
<content><![CDATA[<p><a href="http://118.190.20.162/view.page?gpid=T66">题目链接</a></p>
<p>然后贴上一份别人比我写得好看的<a href="https://blog.csdn.net/banana_cjb/article/details/79174688">代码</a></p>
<p>不得不说，不提前规划好怎么写，或者不用C++的string，或者写代码的时候不够心细，处理起来是很恶心的。所以考试的时候一定要先写简单的部分，否则这题性价比挺低的，尤其是错了点细节可能会让你写了上百行的代码得20分。</p>
<span id="more"></span>
<p><strong>本人遇到的问题：</strong></p>
<p>1.数组下标写错。代码能力所致。</p>
<p>2.erase写错，因为是多重遍历，跳出循环需要处理一下字符串。所以提前规划好要怎么写是很重要的，不要中途改来改去。</p>
<p>3.日期数错。这个就尴尬了，用了一个数组记某个月过去这一年多少天，也就是31.28.31.30…的前缀数组。但是我算错了一个数，硬生生少了40分。</p>
<p>4.看错题忽略掉关键细节。首先Jun这种表示法，大小写都有可能。最后的15分看了别人的代码才发现错哪了。然后数据范围是左闭右开。</p>
<p>5.整数和字符串转化问题。不同于java，这里的string拼接整数，不能用+加号，或者直接构造，否则会出现奇怪的结果。然后整数转字符串可以注意一下补位的问题。</p>
<p>6.合法数据的额外判断。4月31号， 非闰年的2月29号等之类的数据要额外排除掉。</p>
<p><strong>然后string的一些用法：</strong></p>
<p>1.size()和length()。取得字符串长度。size等同于其他STL，length在string中刚好是同义词，就是说用哪个都可以。</p>
<p>2.at()和[]。取得某个位置的元素可以用at(i)后者直接下标访问。</p>
<p>3.+和append。用来拼接。append可以添加另一个字符的子串（string str, int pos, int len），或者多个相同字符（int time, char ch）</p>
<p>4.erase。用来删除从pos开始的len长度的字符（int pos, int len）。或删除一个或两个迭代器之间的字符。</p>
<p>5.find。用来查找某个字符串中某字符/串第一次出现的位置，没有返回npos。（str/char，pos=0）.</p>
<p>6.substr。返回某个字符串从pos开始，长度为len的子串。</p>
<p>7.replace。把某个字符串，从pos开始，长度为len的串，替换成新串。（pos, len, string newstr）</p>
<p><strong>然后处理逻辑：</strong><br>每个指令存5个string类型的vector，分别记录其合法分、小时、天、月、星期的两位字符串。通过遍历找到所有合法组，用星期和范围判断是否是一个指令，把拼接成的字符串存起来，最后通过排序得到按时间排序的指令集。</p>
<ul>
<li><p>数据处理：</p>
<ul>
<li><p>1.将Week和Month的英文串替换成数字。用两个数组遍历查找一遍即可。</p>
</li>
<li><p>2.将可能出现的数字替换成两位的字符串。可能会有补位问题。</p>
</li>
<li><p>3.处理<em>。如果是</em>将范围内所有数丢进vector。</p>
</li>
<li><p>4.否则按步骤循环处理每个,</p>
</li>
<li><p>5.在处理一组,隔开的解时，判断是否有-，有则转换整数将范围内所有数丢进vector，否则将整体丢进vector。</p>
</li>
</ul>
</li>
<li><p>遍历判断：</p>
<ul>
<li><p>1.通过5重循环（年、月、日、时、分）拼接字符串，一边拼接一边判断是否超过范围，超过修改str并continue.</p>
</li>
<li><p>2.遍历之前判重，避免插入重复数据（理论上来说不会）</p>
</li>
<li><p>3.走到最内层时。将特殊不合法日期去掉。并计算一下星期，查找是否在合法week_vector中，如果不在去掉。</p>
<p>代码：</p>
<figure class="highlight arduino"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><cstdio></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><cstring></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><cmath></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><algorithm></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><iostream></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><vector></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line"><span class="keyword">const</span> <span class="built_in">string</span> Months[] = {<span class="string">" "</span>, <span class="string">"jan"</span>, <span class="string">"feb"</span>, <span class="string">"mar"</span>, <span class="string">"apr"</span>, <span class="string">"may"</span>, <span class="string">"jun"</span>, <span class="string">"jul"</span>, <span class="string">"aug"</span>, <span class="string">"sep"</span>, <span class="string">"oct"</span>, <span class="string">"nov"</span>, <span class="string">"dec"</span>};</span><br><span class="line"><span class="keyword">const</span> <span class="built_in">string</span> Weekdays[] = {<span class="string">"sun"</span>, <span class="string">"mon"</span>, <span class="string">"tue"</span>, <span class="string">"wed"</span>, <span class="string">"thu"</span>, <span class="string">"fri"</span>, <span class="string">"sat"</span>};</span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> Dnum[] = {<span class="number">0</span>, <span class="number">31</span>, <span class="number">59</span>, <span class="number">90</span>, <span class="number">120</span>, <span class="number">151</span>, <span class="number">181</span>, <span class="number">212</span>, <span class="number">243</span>, <span class="number">273</span>, <span class="number">304</span>, <span class="number">334</span>, <span class="number">365</span>};</span><br><span class="line"> </span><br><span class="line"><span class="built_in">string</span> sttime, edtime;<span class="comment">//起止时间，左闭右开</span></span><br><span class="line"><span class="keyword">typedef</span> <span class="class"><span class="keyword">struct</span> <span class="title">Ans</span></span></span><br><span class="line"><span class="class">{</span></span><br><span class="line"> <span class="built_in">string</span> time, work;</span><br><span class="line"> </span><br><span class="line">}Ans;</span><br><span class="line"><span class="built_in">vector</span><Ans>ans;<span class="comment">//答案组，多条指令不清空。</span></span><br><span class="line"><span class="function"><span class="keyword">bool</span> <span class="title">cmp</span><span class="params">(<span class="keyword">const</span> Ans &a, <span class="keyword">const</span> Ans &b)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">return</span> a.time < b.time;</span><br><span class="line">}</span><br><span class="line"> </span><br><span class="line"> </span><br><span class="line"><span class="class"><span class="keyword">class</span> <span class="title">Order</span></span></span><br><span class="line"><span class="class">{</span></span><br><span class="line"> <span class="built_in">vector</span><<span class="built_in">string</span>> mm, hh, DD, MM, Wek;</span><br><span class="line"> <span class="built_in">string</span> work;</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">init</span><span class="params">()</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> mm.<span class="built_in">clear</span>(), hh.<span class="built_in">clear</span>(), DD.<span class="built_in">clear</span>(), MM.<span class="built_in">clear</span>(), Wek.<span class="built_in">clear</span>();</span><br><span class="line"> }</span><br><span class="line"> </span><br><span class="line"> <span class="comment">//----------- string和int转换--------------</span></span><br><span class="line"> <span class="function"><span class="keyword">int</span> <span class="title">stoi</span><span class="params">(<span class="built_in">string</span> str)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="comment">//cout<<"stoi:"<<str<<endl;</span></span><br><span class="line"> <span class="keyword">int</span> ret = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">while</span>(str != <span class="string">""</span>){</span><br><span class="line"> ret *= <span class="number">10</span>;</span><br><span class="line"> ret += str.at(<span class="number">0</span>) - <span class="string">'0'</span>;</span><br><span class="line"> str = str.substr(<span class="number">1</span>, str.<span class="built_in">size</span>() - <span class="number">1</span>);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> ret;</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="built_in">string</span> <span class="title">itos</span><span class="params">(<span class="keyword">int</span> ipt)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="built_in">string</span> ret = <span class="string">""</span>;</span><br><span class="line"> <span class="keyword">while</span>(ipt)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">char</span> ch = ipt % <span class="number">10</span> + <span class="string">'0'</span>;</span><br><span class="line"> ipt /= <span class="number">10</span>;</span><br><span class="line"> ret = ch + ret;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">while</span>(ret.<span class="built_in">size</span>() < <span class="number">2</span>)ret = <span class="string">'0'</span> + ret;</span><br><span class="line"> <span class="keyword">return</span> ret;</span><br><span class="line"> }</span><br><span class="line"> </span><br><span class="line"> <span class="comment">//------------修改过的replaceAll(C++里没有)--------------</span></span><br><span class="line"> <span class="function"><span class="built_in">string</span> <span class="title">replaceAll</span><span class="params">(<span class="built_in">string</span> oldstr, <span class="built_in">string</span> old_value, <span class="built_in">string</span> new_value)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="comment">//cout<<"replaceAll"<<oldstr<<": "<<old_value<<"->"<<new_value<<endl;</span></span><br><span class="line"> <span class="keyword">int</span> pos = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < oldstr.length(); i++)<span class="keyword">if</span>(oldstr[i] <= <span class="string">'Z'</span> && oldstr[i] >= <span class="string">'A'</span>)oldstr[i] = oldstr[i] - <span class="string">'A'</span> + <span class="string">'a'</span>;</span><br><span class="line"> <span class="keyword">while</span>((pos=oldstr.<span class="built_in">find</span>(old_value))!=<span class="built_in">string</span>::npos) {</span><br><span class="line"> oldstr = oldstr.replace(pos,old_value.<span class="built_in">size</span>(),new_value);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> oldstr;</span><br><span class="line"> </span><br><span class="line"> }</span><br><span class="line"> </span><br><span class="line"> <span class="comment">//------------分别处理5个数据。因为逻辑基本相同，理论上来说可以带上vector参数用一个函数实现。</span></span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">convMin</span><span class="params">(<span class="built_in">string</span> str)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="built_in">string</span> strn;</span><br><span class="line"> <span class="built_in">string</span> pb;</span><br><span class="line"> <span class="keyword">if</span>(str == <span class="string">"*"</span>){</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < <span class="number">60</span>; i++){pb = itos(i); mm.push_back(pb);}</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span> {</span><br><span class="line"> <span class="keyword">while</span>(str != <span class="string">""</span>){</span><br><span class="line"> <span class="keyword">int</span> pos;</span><br><span class="line"> <span class="keyword">if</span>((pos = str.<span class="built_in">find</span>(<span class="string">','</span>)) != <span class="built_in">string</span>::npos){</span><br><span class="line"> strn = str.substr(<span class="number">0</span>, pos);</span><br><span class="line"> str = str.substr(pos+<span class="number">1</span>, str.<span class="built_in">size</span>() - pos);}</span><br><span class="line"> <span class="keyword">else</span> {strn = str; str = <span class="string">""</span>;}</span><br><span class="line"> <span class="keyword">int</span> posn;</span><br><span class="line"> <span class="keyword">if</span>((posn = strn.<span class="built_in">find</span>(<span class="string">'-'</span>)) != <span class="built_in">string</span>::npos){</span><br><span class="line"> <span class="built_in">string</span> left = strn.substr(<span class="number">0</span>, posn);</span><br><span class="line"> <span class="keyword">int</span> il = stoi(left);</span><br><span class="line"> <span class="built_in">string</span> right = strn.substr(posn+<span class="number">1</span>, strn.<span class="built_in">size</span>()-posn);</span><br><span class="line"> <span class="keyword">int</span> ir = stoi(right);</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = il; i <= ir; i++){pb = itos(i); mm.push_back(pb);}</span><br><span class="line"> </span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span> mm.push_back(itos(stoi(strn)));</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="comment">/*cout<<"mm:"<<endl;</span></span><br><span class="line"><span class="comment"> for(int i = 0; i < mm.size(); i++)cout<<mm[i]<<" ";</span></span><br><span class="line"><span class="comment"> cout<<endl;*/</span></span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">convHour</span><span class="params">(<span class="built_in">string</span> str)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="built_in">string</span> strn;</span><br><span class="line"> <span class="built_in">string</span> pb;</span><br><span class="line"> <span class="keyword">if</span>(str == <span class="string">"*"</span>)<span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < <span class="number">24</span>; i++){pb = itos(i); hh.push_back(pb);}</span><br><span class="line"> <span class="keyword">else</span> {</span><br><span class="line"> <span class="keyword">while</span>(str != <span class="string">""</span>){</span><br><span class="line"> <span class="keyword">int</span> pos, posn;</span><br><span class="line"> <span class="keyword">if</span>((pos = str.<span class="built_in">find</span>(<span class="string">','</span>)) != <span class="built_in">string</span>::npos){strn = str.substr(<span class="number">0</span>, pos);str = str.substr(pos+<span class="number">1</span>, str.<span class="built_in">size</span>() - pos);}</span><br><span class="line"> <span class="keyword">else</span> {strn = str; str = <span class="string">""</span>;}</span><br><span class="line"> <span class="keyword">if</span>((posn = strn.<span class="built_in">find</span>(<span class="string">'-'</span>)) != <span class="built_in">string</span>::npos){</span><br><span class="line"> <span class="built_in">string</span> left = strn.substr(<span class="number">0</span>, posn);</span><br><span class="line"> <span class="keyword">int</span> il = stoi(left);</span><br><span class="line"> <span class="built_in">string</span> right = strn.substr(posn+<span class="number">1</span>, strn.<span class="built_in">size</span>()-posn);</span><br><span class="line"> <span class="keyword">int</span> ir = stoi(right);</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = il; i <= ir; i++){pb = itos(i); hh.push_back(pb);}</span><br><span class="line"> </span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span> hh.push_back(itos(stoi(strn)));</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="comment">/*cout<<"hh:"<<endl;</span></span><br><span class="line"><span class="comment"> for(int i = 0; i < hh.size(); i++)cout<<hh[i]<<" ";</span></span><br><span class="line"><span class="comment"> cout<<endl;*/</span></span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">convDay</span><span class="params">(<span class="built_in">string</span> str)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="built_in">string</span> strn;</span><br><span class="line"> <span class="built_in">string</span> pb;</span><br><span class="line"> <span class="keyword">if</span>(str == <span class="string">"*"</span>)<span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">1</span>; i < <span class="number">32</span>; i++){pb = itos(i); DD.push_back(pb);}</span><br><span class="line"> <span class="keyword">else</span> {</span><br><span class="line"> <span class="keyword">while</span>(str != <span class="string">""</span>){</span><br><span class="line"> <span class="keyword">int</span> pos, posn;</span><br><span class="line"> <span class="keyword">if</span>((pos = str.<span class="built_in">find</span>(<span class="string">','</span>)) != <span class="built_in">string</span>::npos){strn = str.substr(<span class="number">0</span>, pos);str = str.substr(pos+<span class="number">1</span>, str.<span class="built_in">size</span>() - pos);}</span><br><span class="line"> <span class="keyword">else</span> {strn = str; str = <span class="string">""</span>;}</span><br><span class="line"> <span class="keyword">if</span>((posn = strn.<span class="built_in">find</span>(<span class="string">'-'</span>)) != <span class="built_in">string</span>::npos){</span><br><span class="line"> <span class="built_in">string</span> left = strn.substr(<span class="number">0</span>, posn);</span><br><span class="line"> <span class="keyword">int</span> il = stoi(left);</span><br><span class="line"> <span class="built_in">string</span> right = strn.substr(posn+<span class="number">1</span>, strn.<span class="built_in">size</span>()-posn);</span><br><span class="line"> <span class="keyword">int</span> ir = stoi(right);</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = il; i <= ir; i++){pb = itos(i); DD.push_back(pb);}</span><br><span class="line"> </span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span> DD.push_back(itos(stoi(strn)));</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="comment">/*cout<<"DD:"<<endl;</span></span><br><span class="line"><span class="comment"> for(int i = 0; i < DD.size(); i++)cout<<DD[i]<<" ";</span></span><br><span class="line"><span class="comment"> cout<<endl;*/</span></span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">convMon</span><span class="params">(<span class="built_in">string</span> str)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="built_in">string</span> strn;</span><br><span class="line"> <span class="built_in">string</span> pb;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">1</span>; i <= <span class="number">12</span>; i++){</span><br><span class="line"> pb = itos(i);</span><br><span class="line"> str = replaceAll(str, Months[i], pb);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span>(str == <span class="string">"*"</span>)<span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">1</span>; i < <span class="number">13</span>; i++){pb = itos(i);MM.push_back(pb);}</span><br><span class="line"> <span class="keyword">else</span> {</span><br><span class="line"> <span class="keyword">int</span> pos, posn;</span><br><span class="line"> <span class="keyword">while</span>(str != <span class="string">""</span>){</span><br><span class="line"> <span class="keyword">if</span>((pos = str.<span class="built_in">find</span>(<span class="string">','</span>)) != <span class="built_in">string</span>::npos){strn = str.substr(<span class="number">0</span>, pos);str = str.substr(pos+<span class="number">1</span>, str.<span class="built_in">size</span>() - pos);}</span><br><span class="line"> <span class="keyword">else</span> {strn = str; str = <span class="string">""</span>;}</span><br><span class="line"> <span class="keyword">if</span>((posn = strn.<span class="built_in">find</span>(<span class="string">'-'</span>)) != <span class="built_in">string</span>::npos){</span><br><span class="line"> <span class="built_in">string</span> left = strn.substr(<span class="number">0</span>, posn);</span><br><span class="line"> <span class="keyword">int</span> il = stoi(left);</span><br><span class="line"> <span class="built_in">string</span> right = strn.substr(posn+<span class="number">1</span>, strn.<span class="built_in">size</span>()-posn);</span><br><span class="line"> <span class="keyword">int</span> ir = stoi(right);</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = il; i <= ir; i++){pb = itos(i);MM.push_back(pb);}</span><br><span class="line"> </span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span> MM.push_back(itos(stoi(strn)));</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">convWek</span><span class="params">(<span class="built_in">string</span> str)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="built_in">string</span> strn;</span><br><span class="line"> <span class="built_in">string</span> pb;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < <span class="number">7</span>; i++)</span><br><span class="line"> {</span><br><span class="line"> pb = itos(i);</span><br><span class="line"> str = replaceAll(str, Weekdays[i], pb);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span>(str == <span class="string">"*"</span>)<span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < <span class="number">7</span>; i++){pb = itos(i); Wek.push_back(pb);}</span><br><span class="line"> <span class="keyword">else</span> {</span><br><span class="line"> <span class="keyword">int</span> pos , posn;</span><br><span class="line"> <span class="keyword">while</span>(str != <span class="string">""</span>){</span><br><span class="line"> <span class="keyword">if</span>((pos = str.<span class="built_in">find</span>(<span class="string">','</span>)) != <span class="built_in">string</span>::npos){strn = str.substr(<span class="number">0</span>, pos);str = str.substr(pos+<span class="number">1</span>, str.<span class="built_in">size</span>() - pos);}</span><br><span class="line"> <span class="keyword">else</span> {strn = str; str = <span class="string">""</span>;}</span><br><span class="line"> <span class="keyword">if</span>((posn = strn.<span class="built_in">find</span>(<span class="string">'-'</span>)) != <span class="built_in">string</span>::npos){</span><br><span class="line"> <span class="built_in">string</span> left = strn.substr(<span class="number">0</span>, posn);</span><br><span class="line"> <span class="keyword">int</span> il = stoi(left);</span><br><span class="line"> <span class="built_in">string</span> right = strn.substr(posn+<span class="number">1</span>, strn.<span class="built_in">size</span>()-posn);</span><br><span class="line"> <span class="keyword">int</span> ir = stoi(right);</span><br><span class="line"> <span class="comment">//cout<<left<<" -- "<<right<<endl;</span></span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = il; i <= ir; i++){pb = itos(i); Wek.push_back(pb);}</span><br><span class="line"> </span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span> Wek.push_back(itos(stoi(strn)));</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> ;</span><br><span class="line"> }</span><br><span class="line"> </span><br><span class="line"> <span class="comment">//-------判断闰年和查找星期------------</span></span><br><span class="line"> <span class="function"><span class="keyword">bool</span> <span class="title">luyear</span><span class="params">(<span class="keyword">int</span> year)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">return</span> year%<span class="number">400</span> == <span class="number">0</span> || (year%<span class="number">100</span> != <span class="number">0</span> && year%<span class="number">4</span> == <span class="number">0</span>);</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">int</span> <span class="title">getWeekday</span><span class="params">(<span class="built_in">string</span> str)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">int</span> ans = <span class="number">4</span>;</span><br><span class="line"> <span class="keyword">int</span> year = stoi(str.substr(<span class="number">0</span>, <span class="number">4</span>));</span><br><span class="line"> <span class="keyword">int</span> month = stoi(str.substr(<span class="number">4</span>, <span class="number">2</span>));</span><br><span class="line"> <span class="keyword">int</span> day = stoi(str.substr(<span class="number">6</span>, <span class="number">2</span>));</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">1970</span>; i < year; i++){</span><br><span class="line"> <span class="keyword">if</span>(luyear(i))ans += <span class="number">2</span>;</span><br><span class="line"> <span class="keyword">else</span> ans += <span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"> ans %= <span class="number">7</span>;</span><br><span class="line"> ans += Dnum[month<span class="number">-1</span>];</span><br><span class="line"> <span class="keyword">if</span>(luyear(year) && month > <span class="number">2</span>)ans++;</span><br><span class="line"> ans %= <span class="number">7</span>;</span><br><span class="line"> ans += day<span class="number">-1</span>;</span><br><span class="line"> ans %= <span class="number">7</span>;</span><br><span class="line"> <span class="keyword">return</span> ans;</span><br><span class="line"> }</span><br><span class="line"> </span><br><span class="line"> <span class="comment">//创建ans组集</span></span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">getAns</span><span class="params">()</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="built_in">string</span> str;</span><br><span class="line"> sort(mm.<span class="built_in">begin</span>(), mm.<span class="built_in">end</span>());</span><br><span class="line"> sort(hh.<span class="built_in">begin</span>(), hh.<span class="built_in">end</span>());</span><br><span class="line"> sort(DD.<span class="built_in">begin</span>(), DD.<span class="built_in">end</span>());</span><br><span class="line"> sort(MM.<span class="built_in">begin</span>(), MM.<span class="built_in">end</span>());</span><br><span class="line"> sort(Wek.<span class="built_in">begin</span>(), Wek.<span class="built_in">end</span>());</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> y = stoi(sttime.substr(<span class="number">0</span>, <span class="number">4</span>)); y <= stoi(edtime.substr(<span class="number">0</span>, <span class="number">4</span>)); y++){</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> l = <span class="number">0</span>; l < MM.<span class="built_in">size</span>(); l++){</span><br><span class="line"> <span class="keyword">if</span>(l > <span class="number">0</span> && MM[l] == MM[l<span class="number">-1</span>]){str.erase(<span class="number">4</span>, <span class="number">2</span>);<span class="keyword">continue</span>;}</span><br><span class="line"> str = itos(y) + MM[l];</span><br><span class="line"> <span class="keyword">if</span>(str < sttime.substr(<span class="number">0</span>, <span class="number">6</span>) || str > edtime.substr(<span class="number">0</span>, <span class="number">6</span>)){str.erase(<span class="number">4</span>, <span class="number">2</span>);<span class="keyword">continue</span>;}</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> k = <span class="number">0</span>; k < DD.<span class="built_in">size</span>(); k++)</span><br><span class="line"> {</span><br><span class="line"> str = itos(y) + MM[l] + DD[k];</span><br><span class="line"> <span class="keyword">if</span>(k > <span class="number">0</span> && DD[k] == DD[k<span class="number">-1</span>]){str.erase(<span class="number">6</span>, <span class="number">2</span>);<span class="keyword">continue</span>;}</span><br><span class="line"> <span class="keyword">if</span>(str < sttime.substr(<span class="number">0</span>, <span class="number">8</span>) || str > edtime.substr(<span class="number">0</span>, <span class="number">8</span>)){str.erase(<span class="number">6</span>, <span class="number">2</span>);<span class="keyword">continue</span>;}</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> j = <span class="number">0</span>; j < hh.<span class="built_in">size</span>(); j++){</span><br><span class="line"> <span class="keyword">if</span>(j > <span class="number">0</span> && hh[j] == hh[j<span class="number">-1</span>]){str.erase(<span class="number">8</span>, <span class="number">2</span>);<span class="keyword">continue</span>;}</span><br><span class="line"> str = itos(y) + MM[l] + DD[k] + hh[j];</span><br><span class="line"> <span class="keyword">if</span>(str < sttime.substr(<span class="number">0</span>, <span class="number">10</span>) || str > edtime.substr(<span class="number">0</span>, <span class="number">10</span>)){str.erase(<span class="number">8</span>, <span class="number">2</span>);<span class="keyword">continue</span>;}</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < mm.<span class="built_in">size</span>(); i++){</span><br><span class="line"> <span class="keyword">if</span>(i > <span class="number">0</span> && mm[i] == mm[i<span class="number">-1</span>]){str.erase(<span class="number">10</span>, <span class="number">2</span>);<span class="keyword">continue</span>;}<span class="comment">//判重</span></span><br><span class="line"> <span class="keyword">if</span>(DD[k] == <span class="string">"31"</span> && (MM[l] == <span class="string">"04"</span> || MM[l] == <span class="string">"06"</span> || MM[l] == <span class="string">"09"</span> || MM[l] == <span class="string">"11"</span> || MM[l] == <span class="string">"02"</span>)){str.erase(<span class="number">10</span>, <span class="number">2</span>);<span class="keyword">continue</span>;}<span class="comment">//去掉非法日期</span></span><br><span class="line"> <span class="keyword">if</span>(MM[l] == <span class="string">"02"</span> && (DD[k] == <span class="string">"30"</span> || (DD[k] == <span class="string">"29"</span> && !luyear(y)))){str.erase(<span class="number">10</span>, <span class="number">2</span>);<span class="keyword">continue</span>;}</span><br><span class="line"> str = itos(y) + MM[l] + DD[k] + hh[j]+ mm[i] + <span class="string">'\0'</span>;</span><br><span class="line"> <span class="keyword">if</span>(str < sttime.substr(<span class="number">0</span>, <span class="number">12</span>) || str >= edtime.substr(<span class="number">0</span>, <span class="number">12</span>)){str.erase(<span class="number">10</span>, <span class="number">2</span>);<span class="keyword">continue</span>;} <span class="comment">//判断范围</span></span><br><span class="line"> <span class="keyword">int</span> gwed = getWeekday(str);</span><br><span class="line"> <span class="built_in">string</span> sgwed = itos(gwed);</span><br><span class="line"> <span class="keyword">bool</span> flag = <span class="literal">false</span>;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> m = <span class="number">0</span>; m < Wek.<span class="built_in">size</span>(); m++){<span class="comment">//判断合法星期</span></span><br><span class="line"> <span class="keyword">if</span>(Wek[m] == sgwed)flag = <span class="literal">true</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span>(flag == <span class="literal">false</span>){str.erase(<span class="number">10</span>, <span class="number">2</span>);<span class="keyword">continue</span>;}</span><br><span class="line"> Ans now;</span><br><span class="line"> now.time = str, now.work = work;ans.push_back(now);</span><br><span class="line"> str.erase(<span class="number">10</span>, <span class="number">2</span>);</span><br><span class="line"> }</span><br><span class="line"> str.erase(<span class="number">8</span>, <span class="number">2</span>);</span><br><span class="line"> }</span><br><span class="line"> str.erase(<span class="number">6</span>, <span class="number">2</span>);</span><br><span class="line"> }</span><br><span class="line"> str.erase(<span class="number">4</span>, <span class="number">2</span>);</span><br><span class="line"> }</span><br><span class="line"> str = <span class="string">""</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"><span class="keyword">public</span>:</span><br><span class="line"> </span><br><span class="line"> Order(<span class="built_in">string</span> a, <span class="built_in">string</span> b, <span class="built_in">string</span> c, <span class="built_in">string</span> d, <span class="built_in">string</span> e, <span class="built_in">string</span> f)<span class="comment">//构造函数直接调用</span></span><br><span class="line"> {</span><br><span class="line"> init();</span><br><span class="line"> work = f;</span><br><span class="line"> convMin(a);</span><br><span class="line"> convHour(b);</span><br><span class="line"> convDay(c);</span><br><span class="line"> convMon(d);</span><br><span class="line"> convWek(e);</span><br><span class="line"> getAns();</span><br><span class="line"> }</span><br><span class="line">};</span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> ans.<span class="built_in">clear</span>();</span><br><span class="line"> <span class="keyword">int</span> n;</span><br><span class="line"> <span class="built_in">cin</span>>>n>>sttime>>edtime;</span><br><span class="line"> <span class="built_in">string</span> a, b, c, d, e, w;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < n; i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="built_in">cin</span>>>a>>b>>c>>d>>e>>w;</span><br><span class="line"> Order *ord = <span class="keyword">new</span> Order(a, b, c, d, e, w);</span><br><span class="line"> }</span><br><span class="line"> sort(ans.<span class="built_in">begin</span>(), ans.<span class="built_in">end</span>(), cmp);<span class="comment">//给所有合法指令集按时间排序。</span></span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < ans.<span class="built_in">size</span>(); i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="built_in">cout</span><<ans[i].time<<<span class="string">" "</span><<ans[i].work<<<span class="built_in">endl</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
</li>
</ul>
</li>
</ul>
]]></content>
<categories>
<category>acm</category>
</categories>
<tags>
<tag>acm</tag>
<tag>csp</tag>
</tags>
</entry>
<entry>
<title>csp 201712-2 游戏 暴力，附：约瑟夫环的递推</title>
<url>/acm/csp%20201712-4%20%E8%A1%8C%E8%BD%A6%E8%B7%AF%E7%BA%BF%20spfa+%E5%89%AA%E6%9E%9D/</url>
<content><![CDATA[<p><a href="http://118.190.20.162/view.page?gpid=T65">题目链接</a><br>题目描述：有一n点(500)m边(1e5)的图，有两种路，每个路有距离，走大路疲劳度+d(1e5)，走小路疲劳度+连续走的小路长度的平方。求从1到n最小的疲劳度。（答案不超过1e6）</p>
<span id="more"></span>
<p>努力了一番终于满分了=w=<br>提醒大家在交任何题之前一定要从头到尾检查一遍数据范围会不会爆。<br>还有输出条件的一些限制细节。<br>另外对于csp这种不实时返回结果的题来说，spfa这种玄学复杂度的算法一定要能剪枝就剪枝。</p>
<p>核心思想：</p>
<p>1.如果全是大路可以直接dijkstra，看到求连续走的小路长度和很多人是不是懵了。但是解法很简单。假设现在准备走一条从i到j的小路，长度dij，i点原来的距离Di, 连续走的小路长度为Li，Di包含了Li^2，</p>
<p>因此Dj = Di - Li^2 + (Li+dij)^2或者可以把平方式展开，Dj = Di + dij^2 + 2<em>dij</em>Li（我用的这种）</p>
<p>所以使用spfa搜索时，需要记录的是三元组(id, len, lazy)（下个点标号，距离，当前连续小路长度），在转移时</p>
<pre><code> a)转移到大路，(nextid, len+dij, 0)
b)转移到小路，(nextid, len+2*dij*li + dij^2, lazy+dij)
</code></pre>
<p>2.然后存图用vector数组，存(id, dis, type)（编号，路径长度，路径类型）。因为我使用了优先队列做spfa（会被大佬批评），然后自定义排序dis从小到大（cmp要反着写），这样只要访问到n点一定是答案。</p>
<p>3.优化和剪枝：</p>
<p>3.1采用类似dijkstra算法类似的visit数组，初始化为1e6。但是dijkstra的visit是用来防止多次入队的，SPFA用来松弛，我们这是用来剪枝的。如果一条大路一条小路到达同一个点路径长相等，选择大路走一定是对的。所以用大路更新visit最大值，如果某时刻路径长大于visit直接跳过。如果到达i点是一条大路，判断是否要更新visit，如果到达的是小路则不可以更新visit。把从当前点出发的三元组放进队列前，可以用visit和1e6剪枝，判断这个三元组是否应该直接跳过。<em>此处有坑，因为dij的平方和dij</em>Li可能会爆int，因此需要时刻先卡住1e6再卡住visit。</p>
<p>3.2看了看数据范围，发现不能保证图中没有自环和重边。自环要判断一下（不判断不会超时）。最开始我为了避免往queue里放太多元素导致插入排序超时或者爆内存，读完图以后给vector按dis从小到大排了个序，然后发现排序反而比不排慢，不要排了。虽然用map存每对点大路小路两条长度最小的边也是很好的，但是写着太麻烦了。</p>
<p>代码：（cmp的注释颜色很有趣）</p>
<figure class="highlight arduino"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><cstdio></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><cstring></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><cmath></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><algorithm></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><queue></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> pii pair<span class="meta-string"><int, int></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> piii pair<span class="meta-string"><int, pii></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> mp make_pair</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> pb push_back</span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> MAXN = <span class="number">505</span>;</span><br><span class="line"><span class="built_in">vector</span><piii>path[MAXN];<span class="comment">//point, dis, type;</span></span><br><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">cmp</span>//<span class="title">queue</span>用的<span class="title">cmp</span></span></span><br><span class="line"><span class="class">{</span></span><br><span class="line"> <span class="function"><span class="keyword">bool</span> <span class="title">operator</span> <span class="params">()</span> <span class="params">(piii a, piii b)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">return</span> a.second.first > b.second.first;</span><br><span class="line"> }</span><br><span class="line"> </span><br><span class="line">};</span><br><span class="line"><span class="function"><span class="keyword">bool</span> <span class="title">cmp0</span><span class="params">(piii a, piii b)</span><span class="comment">//sort用的cmp0</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">return</span> a.second.first < b.second.first;</span><br><span class="line">}</span><br><span class="line"><span class="built_in">priority_queue</span><piii, <span class="built_in">vector</span><piii >, cmp>q;<span class="comment">//point, dis, lazy</span></span><br><span class="line"><span class="keyword">int</span> visit[MAXN];</span><br><span class="line"><span class="function">piii <span class="title">mpp</span> <span class="params">(<span class="keyword">int</span> a, <span class="keyword">int</span> b, <span class="keyword">int</span> c)</span><span class="comment">//pair<int, pair<int, int> >的make_pair函数</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> pii x = mp(b, c);</span><br><span class="line"> piii xx = mp(a, x);</span><br><span class="line"> <span class="keyword">return</span> xx;</span><br><span class="line">}</span><br><span class="line"> </span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> n, m;</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%d%d"</span>, &n, &m);</span><br><span class="line"> <span class="keyword">int</span> a, b, s, t;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < m; i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%d %d %d %d"</span>, &t, &a, &b, &s);</span><br><span class="line"> a--;<span class="comment">//此题可用0存边</span></span><br><span class="line"> b--;</span><br><span class="line"> <span class="keyword">if</span>(a == b)<span class="keyword">continue</span>;<span class="comment">//去掉自环</span></span><br><span class="line"> path[a].pb(mpp(b, s, t));</span><br><span class="line"> path[b].pb(mpp(a, s, t));</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < n; i++)</span><br><span class="line"> {</span><br><span class="line"> visit[i] = <span class="number">1000001</span>;</span><br><span class="line"> <span class="comment">//sort(path[i].begin(), path[i].end(), cmp0);//优化</span></span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">int</span> nextp, nextd, nextt;</span><br><span class="line"> visit[<span class="number">0</span>] = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < path[<span class="number">0</span>].<span class="built_in">size</span>(); i++)<span class="comment">//第一次入队</span></span><br><span class="line"> {</span><br><span class="line"> nextp = path[<span class="number">0</span>][i].first;</span><br><span class="line"> nextd = path[<span class="number">0</span>][i].second.first;</span><br><span class="line"> nextt = path[<span class="number">0</span>][i].second.second;</span><br><span class="line"> <span class="keyword">if</span>(nextt == <span class="number">0</span> && visit[nextp] > nextd){<span class="comment">//visit剪枝+更新visit</span></span><br><span class="line"> q.push(mpp(nextp, nextd, <span class="number">0</span>));</span><br><span class="line"> visit[nextp] = nextd;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">if</span>(nextt == <span class="number">1</span> && nextd <= <span class="number">1000</span> && visit[nextp] > nextd * nextd){ <span class="comment">//爆1e6剪枝和visit剪枝</span></span><br><span class="line"> q.push(mpp(nextp, nextd*nextd, nextd));</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">while</span>(!q.empty())<span class="comment">//开始搜索</span></span><br><span class="line"> {</span><br><span class="line"> piii pnow = q.top();<span class="comment">//当前访问点</span></span><br><span class="line"> q.pop();</span><br><span class="line"> <span class="keyword">int</span> idx = pnow.first;</span><br><span class="line"> <span class="keyword">int</span> lenx = pnow.second.first;</span><br><span class="line"> <span class="keyword">int</span> lazx = pnow.second.second;</span><br><span class="line"> <span class="keyword">if</span>(lenx > <span class="number">1000000</span>)<span class="keyword">continue</span>;</span><br><span class="line"> <span class="keyword">if</span>(lenx > visit[idx])<span class="keyword">continue</span>;<span class="comment">//visit剪枝</span></span><br><span class="line"> <span class="keyword">if</span>(idx == n<span class="number">-1</span>){<span class="comment">//ans</span></span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%d\n"</span>, pnow.second.first);</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < path[idx].<span class="built_in">size</span>(); i++)</span><br><span class="line"> {</span><br><span class="line"> nextp = path[idx][i].first;</span><br><span class="line"> nextd = path[idx][i].second.first;</span><br><span class="line"> nextt = path[idx][i].second.second;</span><br><span class="line"> <span class="keyword">if</span>(nextt == <span class="number">0</span>){ <span class="comment">//大路visit剪枝+更新+更新visit</span></span><br><span class="line"> <span class="keyword">if</span>(visit[nextp] < nextd + lenx)<span class="keyword">continue</span>;</span><br><span class="line"> q.push(mpp(nextp, nextd + lenx, <span class="number">0</span>));</span><br><span class="line"> visit[nextp] = nextd + lenx;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">if</span>(nextt == <span class="number">1</span>){<span class="comment">//小路判断爆1e6(注意爆int)+visit剪枝+更新</span></span><br><span class="line"> <span class="keyword">double</span> sum = (<span class="keyword">double</span>)nextd * (<span class="keyword">double</span>)nextd + (<span class="keyword">double</span>)lenx + <span class="number">2</span> * (<span class="keyword">double</span>)lazx * (<span class="keyword">double</span>)nextd;</span><br><span class="line"> <span class="keyword">if</span>(sum > <span class="number">1000000</span>)<span class="keyword">continue</span>;</span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">if</span>(visit[nextp] < nextd * nextd + lenx + <span class="number">2</span> * lazx * nextd)<span class="keyword">continue</span>;</span><br><span class="line"> q.push(mpp(nextp, nextd * nextd + lenx + <span class="number">2</span> * lazx * nextd, lazx + nextd));</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>]]></content>
<categories>
<category>acm</category>
</categories>
<tags>
<tag>acm</tag>
<tag>csp</tag>
</tags>
</entry>
<entry>
<title>201803-4 棋局评估 min-max搜索</title>
<url>/acm/csp%20201803-4%20%E6%A3%8B%E5%B1%80%E8%AF%84%E4%BC%B0%20min-max%E6%90%9C%E7%B4%A2/</url>
<content><![CDATA[<p><a href="http://118.190.20.162/submitlist.page?gpid=T70">题目链接</a></p>
<p>题意：井字棋，现在放了某些棋子。连成线的时候得分为(空格子数+1)（B赢*-1）问当前棋局中，如果Alice和Bob都按最优策略下棋，最终得分。</p>
<span id="more"></span>
<p>思路：典型的min-max对抗搜索，A选取分数最高的一种走法，B选取分数最低的一种走法。</p>
<p>注意的是dfs返回值的初始化问题，min搜索初始值不一定小于0， max初始值不一定大于0（因为这个愚蠢的错了好几回）。</p>
<p>代码：</p>
<figure class="highlight arduino"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><cstdio></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><cstring></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><cmath></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><algorithm></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line"><span class="keyword">int</span> graph[<span class="number">5</span>][<span class="number">5</span>];</span><br><span class="line"> </span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">judge</span><span class="params">()</span><span class="comment">//是否结束，返回赢家</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < <span class="number">3</span>; i++)<span class="keyword">if</span>(graph[<span class="number">0</span>][i] != <span class="number">0</span> && graph[<span class="number">0</span>][i] == graph[<span class="number">1</span>][i] && graph[<span class="number">2</span>][i] == graph[<span class="number">0</span>][i])<span class="keyword">return</span> graph[<span class="number">0</span>][i];</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < <span class="number">3</span>; i++)<span class="keyword">if</span>(graph[i][<span class="number">0</span>] != <span class="number">0</span> && graph[i][<span class="number">0</span>] == graph[i][<span class="number">1</span>] && graph[i][<span class="number">2</span>] == graph[i][<span class="number">0</span>])<span class="keyword">return</span> graph[i][<span class="number">0</span>];</span><br><span class="line"> <span class="keyword">if</span>(graph[<span class="number">0</span>][<span class="number">0</span>] != <span class="number">0</span> && graph[<span class="number">0</span>][<span class="number">0</span>] == graph[<span class="number">1</span>][<span class="number">1</span>] && graph[<span class="number">0</span>][<span class="number">0</span>] == graph[<span class="number">2</span>][<span class="number">2</span>])<span class="keyword">return</span> graph[<span class="number">0</span>][<span class="number">0</span>];</span><br><span class="line"> <span class="keyword">if</span>(graph[<span class="number">2</span>][<span class="number">0</span>] != <span class="number">0</span> && graph[<span class="number">2</span>][<span class="number">0</span>] == graph[<span class="number">1</span>][<span class="number">1</span>] && graph[<span class="number">2</span>][<span class="number">0</span>] == graph[<span class="number">0</span>][<span class="number">2</span>])<span class="keyword">return</span> graph[<span class="number">2</span>][<span class="number">0</span>];</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br><span class="line"> </span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">getdonow</span><span class="params">()</span><span class="comment">//当前空格子数</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> cnt = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < <span class="number">3</span>; i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> j = <span class="number">0</span>; j < <span class="number">3</span>; j++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span>(graph[i][j] == <span class="number">0</span>)cnt++;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> cnt;</span><br><span class="line">}</span><br><span class="line"> </span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">dfs</span><span class="params">(<span class="keyword">int</span> donow)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> person = donow % <span class="number">2</span>;<span class="comment">//当前操作者</span></span><br><span class="line"> <span class="keyword">if</span>(person == <span class="number">0</span>)person = <span class="number">2</span>;</span><br><span class="line"> <span class="keyword">if</span>(judge() != <span class="number">0</span>)<span class="keyword">return</span> person == <span class="number">2</span>? donow+<span class="number">1</span> : -donow<span class="number">-1</span>;<span class="comment">//此时已结束，有赢家</span></span><br><span class="line"> <span class="keyword">if</span>(donow == <span class="number">0</span>)<span class="keyword">return</span> <span class="number">0</span>;<span class="comment">//此时已结束，平局</span></span><br><span class="line"> <span class="keyword">int</span> retmax = <span class="number">-100</span>, retmin = <span class="number">100</span>;<span class="comment">//完全可以合成一个写</span></span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < <span class="number">3</span>; i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> j = <span class="number">0</span>; j < <span class="number">3</span>; j++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span>(graph[i][j] == <span class="number">0</span>){</span><br><span class="line"> graph[i][j] = person;<span class="comment">//准备下一步递归</span></span><br><span class="line"> <span class="keyword">if</span>(person == <span class="number">1</span>)retmax = <span class="built_in">max</span>(retmax, dfs(donow<span class="number">-1</span>));<span class="comment">//max</span></span><br><span class="line"> <span class="keyword">else</span> retmin = <span class="built_in">min</span>(retmin, dfs(donow<span class="number">-1</span>));<span class="comment">//min</span></span><br><span class="line"> graph[i][j] = <span class="number">0</span>;<span class="comment">//回溯</span></span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span>(person == <span class="number">1</span>)<span class="keyword">return</span> retmax;</span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">return</span> retmin;</span><br><span class="line">}</span><br><span class="line"> </span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> T;</span><br><span class="line"> <span class="keyword">int</span> flag;</span><br><span class="line"> <span class="keyword">int</span> donow;</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%d"</span>, &T);</span><br><span class="line"> <span class="keyword">while</span>(T--)</span><br><span class="line"> {</span><br><span class="line"> <span class="built_in">memset</span>(graph, <span class="number">0</span>, <span class="keyword">sizeof</span>(graph));</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i < <span class="number">3</span>; i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%d%d%d"</span>, &graph[i][<span class="number">0</span>], &graph[i][<span class="number">1</span>], &graph[i][<span class="number">2</span>]);</span><br><span class="line"> }</span><br><span class="line"> donow = getdonow();</span><br><span class="line"> <span class="keyword">int</span> ans = dfs(donow);</span><br><span class="line"> <span class="keyword">if</span>(ans > <span class="number">0</span> && ans % <span class="number">2</span> == <span class="number">0</span>)ans++;<span class="comment">//如果题目严谨，没有什么用</span></span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">if</span>(ans < <span class="number">0</span> && ans % <span class="number">2</span> == <span class="number">1</span>)ans --;</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%d\n"</span>, ans);</span><br><span class="line"> </span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>]]></content>
<categories>
<category>acm</category>
</categories>
<tags>
<tag>acm</tag>
<tag>csp</tag>
</tags>
</entry>
<entry>
<title>leetcode常用简单题思想</title>
<url>/acm/leetcode%E5%B8%B8%E7%94%A8%E7%AE%80%E5%8D%95%E9%A2%98%E6%80%9D%E6%83%B3/</url>
<content><![CDATA[<ul>
<li> 暴力：注意数据范围和边界条件</li>
<li> C++和STL: 注意用法</li>
<li> 双指针/滑动窗口/前缀和（注意边界条件）</li>
<li> 位运算（比较巧妙）</li>
<li> 递归，排序和搜索（个人需要练一下）</li>
<li> 离散数学：gcd辗转相除，</li>
<li> DP，</li>
<li> 有待更新</li>
</ul>
]]></content>
<categories>
<category>leetcode</category>
</categories>
<tags>
<tag>acm</tag>
<tag>leetcode</tag>
</tags>
</entry>
<entry>
<title>leetcode刷题规则</title>
<url>/acm/leetcode%E8%A7%84%E5%88%99/</url>
<content><![CDATA[<h1 id="Leetcode-刷题规则"><a href="#Leetcode-刷题规则" class="headerlink" title="Leetcode 刷题规则"></a>Leetcode 刷题规则</h1><p>规则： </p>
<ul>
<li>stdout可以输出，但stdout可能造成误判。</li>
<li>不需要调用包，所有包都可以直接使用。</li>
<li>如果运行样例与测试结果不同，注意<strong>memset</strong>，注意<strong>清零</strong>，注意<strong>初始化</strong>，注意不要有<strong>全局变量</strong>。</li>
<li>不要<strong>读错题</strong>。 </li>
<li>注意<strong>合理的下标名</strong>，注意尽量不要用可能是<strong>关键字</strong>的变量名。 <span id="more"></span></li>
</ul>
]]></content>
<categories>
<category>acm</category>
</categories>
<tags>
<tag>leetcode</tag>
</tags>
</entry>
<entry>
<title>A笔试题（4.2）概率dp</title>
<url>/acm/%E6%9F%90%E7%AC%94%E8%AF%95%E9%A2%982/</url>
<content><![CDATA[<h1 id="题目描述"><a href="#题目描述" class="headerlink" title="题目描述"></a>题目描述</h1><p>原始a=b=n，n为输入。数据范围1e9。<br>四种等概率操作：<br> 1.(a-100, b)<br> 2.(a-75, b-25)<br> 3.(a-50, b-50)<br> 4.(a-25, b-75)<br>直到a<=0或b<=0时停止。 </p>
<p>记a先到0的概率为p(a)，b先到0的概率为p(b)，ab同时到0的概率为p(ab)<br>求：对于输入的n，输出p(a)+0.5*p(ab) </p>
<span id="more"></span>
<hr>
<h1 id="化简"><a href="#化简" class="headerlink" title="化简"></a>化简</h1><p>(n+24)/25</p>
<h1 id="概率dp"><a href="#概率dp" class="headerlink" title="概率dp"></a>概率dp</h1><p>dp[i,j]=dp[i-4,j]+dp[i-3,j-1]+dp[i-2,j-2]+dp[i-1,j-3];</p>
<h1 id="打表"><a href="#打表" class="headerlink" title="打表"></a>打表</h1><p>数据范围超过几百的时候，dp[i,i]已经是1.00000000了，直接判断。</p>
<h1 id="代码（赛后写的，不保证对）"><a href="#代码（赛后写的，不保证对）" class="headerlink" title="代码（赛后写的，不保证对）"></a>代码（赛后写的，不保证对）</h1><hr>
<figure class="highlight arduino"><table><tr><td class="code"><pre><span class="line"><span class="meta"># <span class="meta-keyword">include</span><span class="meta-string"><cstdio></span></span></span><br><span class="line"><span class="meta"># <span class="meta-keyword">include</span> <span class="meta-string"><cstring></span></span></span><br><span class="line"><span class="meta"># <span class="meta-keyword">include</span> <span class="meta-string"><cmath></span></span></span><br><span class="line"><span class="meta"># <span class="meta-keyword">include</span> <span class="meta-string"><algorithm></span></span></span><br><span class="line"><span class="meta"># <span class="meta-keyword">include</span> <span class="meta-string"><utility></span></span></span><br><span class="line"><span class="meta"># <span class="meta-keyword">include</span> <span class="meta-string"><map></span></span></span><br><span class="line"><span class="meta"># <span class="meta-keyword">define</span> mp make_pair</span></span><br><span class="line"><span class="meta"># <span class="meta-keyword">define</span> pff pair<span class="meta-string"><float, float></span></span></span><br><span class="line"><span class="meta"># <span class="meta-keyword">define</span> pfff pair<span class="meta-string"><float, pair<float, float> ></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line">pfff dp[<span class="number">1005</span>][<span class="number">1005</span>];</span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> T;</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%d"</span>, &T);</span><br><span class="line"> <span class="built_in">memset</span>(dp, <span class="number">0</span>, <span class="keyword">sizeof</span>(dp));</span><br><span class="line"> dp[<span class="number">0</span>][<span class="number">0</span>] = mp(<span class="number">0.0</span>, mp(<span class="number">1.0</span>, <span class="number">0.0</span>));</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">1</span>; i < <span class="number">1000</span>; i++){dp[i][<span class="number">0</span>] = mp(<span class="number">0.0</span>, mp(<span class="number">0.0</span>, <span class="number">1.0</span>));dp[<span class="number">0</span>][i] = mp(<span class="number">1.0</span>, mp(<span class="number">0.0</span>, <span class="number">0.0</span>));}</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">1</span>; i < <span class="number">1000</span>; i++){</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> j = <span class="number">1</span>; j < <span class="number">1000</span>; j++){</span><br><span class="line"> <span class="keyword">int</span> pointeri = i, pointerj = j;</span><br><span class="line"> <span class="keyword">int</span> pos[<span class="number">5</span>][<span class="number">5</span>] = {{<span class="number">-4</span>,<span class="number">0</span>}, {<span class="number">-3</span>,<span class="number">-1</span>}, {<span class="number">-2</span>,<span class="number">-2</span>}, {<span class="number">-1</span>,<span class="number">-3</span>}};</span><br><span class="line"> <span class="keyword">for</span>(<span class="keyword">int</span> k = <span class="number">0</span>; k < <span class="number">4</span>; k++){</span><br><span class="line"> pointeri = <span class="built_in">max</span>(<span class="number">0</span>, i+pos[k][<span class="number">0</span>]);</span><br><span class="line"> pointerj = <span class="built_in">max</span>(<span class="number">0</span>, j+pos[k][<span class="number">1</span>]);</span><br><span class="line"> <span class="comment">//printf("%d-%d ", pointeri, pointerj);</span></span><br><span class="line"> dp[i][j].first += <span class="number">0.25</span>*dp[pointeri][pointerj].first;</span><br><span class="line"> dp[i][j].second.first += <span class="number">0.25</span>*dp[pointeri][pointerj].second.first;</span><br><span class="line"> dp[i][j].second.second += <span class="number">0.25</span>*dp[pointeri][pointerj].second.second;</span><br><span class="line"> }<span class="comment">//printf("\n");</span></span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">while</span>(T--)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> n;</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%d"</span>, &n);</span><br><span class="line"> n = (n+<span class="number">24</span>)/<span class="number">25</span>;</span><br><span class="line"> <span class="keyword">if</span>(n > <span class="number">500</span>)<span class="built_in">printf</span>(<span class="string">"1.00000000\n"</span>);</span><br><span class="line"> <span class="keyword">else</span>{</span><br><span class="line"> pfff ans = dp[n][n];</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%.8f\n"</span>,(ans.first + ans.second.first*<span class="number">0.5</span>));</span><br><span class="line"> }</span><br><span class="line"> <span class="comment">//mm.clear();</span></span><br><span class="line"> }</span><br><span class="line"> <span class="comment">//for(int i = 0; i < 1000; i++){</span></span><br><span class="line"> <span class="comment">// pfff ans = dp[i][i];</span></span><br><span class="line"> <span class="comment">// printf("%d--%.8f\n", i, (ans.first + ans.second.first*0.5));</span></span><br><span class="line"> <span class="comment">//}</span></span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>]]></content>
</entry>
<entry>
<title>位运算</title>
<url>/acm/%E4%BD%8D%E8%BF%90%E7%AE%97/</url>
<content><![CDATA[<h1 id="与运算：-amp"><a href="#与运算：-amp" class="headerlink" title="与运算：&"></a>与运算：&</h1><p>&1判断最后一位是不是0，<br>&x保留一些特定位；<br>x&(x-1)消除最后一个1</p>
<h1 id="或运算："><a href="#或运算：" class="headerlink" title="或运算：|"></a>或运算：|</h1><h1 id="异或运算："><a href="#异或运算：" class="headerlink" title="异或运算：^"></a>异或运算：^</h1><p>异或运算找到两个数据不一样的位<br>a^a=0，找唯一一个出现一次的数（leetcode例题)</p>
<h1 id="注意事项"><a href="#注意事项" class="headerlink" title="注意事项"></a>注意事项</h1><ul>
<li> 逻辑运算符优先于低于==符号。</li>
</ul>
]]></content>
<categories>
<category>acm</category>
</categories>
<tags>
<tag>acm</tag>
<tag>leetcode</tag>
</tags>
</entry>
<entry>
<title>Miss Detection vs. False Alarm: Adversarial Learning for Small Object Segmentation in Infrared Images</title>
<url>/paper/1/</url>
<content><![CDATA[<h1 id="动机和概述："><a href="#动机和概述：" class="headerlink" title="动机和概述："></a>动机和概述：</h1><p>平衡MD和FA两个指标，分开使用两个Generator，每个Generator使用不同的网络，分别根据任务生成一个结果。最后会根据两个结果以及两个的平均结果？<br>使用Conditional GAN 进行交互和对抗。</p>
<h1 id="Conditional-GAN"><a href="#Conditional-GAN" class="headerlink" title="+Conditional GAN:"></a>+Conditional GAN:</h1><p>一个挺通用而早期的GAN框架，与普通GAN的具体区别是输入包括判别条件以及图像两部分，以保证生成器生成的图像不但接近真实而且符合判别要求（如将标签作为判别条件输入G和D，保证生成器生成的不是其他种类的图片。）文中将input image作为条件，ground truth和两个生成的predicted image都输入cGAN，loss做了从两个到三个的简单的改动。</p>
<h1 id="评价："><a href="#评价：" class="headerlink" title="评价："></a>评价：</h1><p>想法和动机像老师提到的idea一样不错。但是这个工作的Loss也是由好几个部分组成:</p>
<ul>
<li><pre><code> cGAN生成的对抗loss；
</code></pre>
</li>
<li><pre><code> 两种结果间的一致性loss；
</code></pre>
</li>
<li><pre><code> 而且也对另外一个指标加进去了，只是加了个很小的权，据作者说可以达到更好的initialization.
</code></pre>
</li>
<li><pre><code> 最后对这三种Loss的重要性加了个权，而且属于实验超参数-.-
</code></pre>
实验：红外数据集太少，于是收集了一部分真实数据并扩充了一部分人造数据，数据集开源了。。分别对比了普通的小物体检测和红外线图小物体检测方法，红外线图检测方法表现非常好（大概是研究的人少，任务相对困难），普通的小物体检测的Precision和F-measure还行，recall表现不够好，作者解释整体看结果还不错。<h1 id="总之Loss看起来不是很漂亮，不知道如果时间更加充足，有没有机会阅读更多paper加以改进。"><a href="#总之Loss看起来不是很漂亮，不知道如果时间更加充足，有没有机会阅读更多paper加以改进。" class="headerlink" title="总之Loss看起来不是很漂亮，不知道如果时间更加充足，有没有机会阅读更多paper加以改进。"></a>总之Loss看起来不是很漂亮，不知道如果时间更加充足，有没有机会阅读更多paper加以改进。</h1></li>
</ul>
<hr>
<p>*在红外线图等一些冷门的领域做实验，我觉得是可以的，（其实去年就有想到）</p>
]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>深度学习</category>
<category>强化学习</category>
<category>多智能体</category>
</categories>
<tags>
<tag>reinforcement learning</tag>
<tag>multi-agent</tag>
<tag>small object detection</tag>
</tags>
</entry>
<entry>
<title>CAM: Learning Deep Features for Discriminative Localization</title>
<url>/paper/2/</url>
<content><![CDATA[<p><a href="https://arxiv.org/pdf/1512.04150.pdf">https://arxiv.org/pdf/1512.04150.pdf</a><br>避免全连接层造成的local信息丢失。<br>关联工作：<br> 1弱监督的定位问题：cam实现的就是类激活图。做object localization<br> 2CNN可视化：相关工作使用反卷积或者识别场景。我们去掉全连接层。与之前不同，我们可以精确地突出图像的哪些区域对于区分是重要的。<br>global average pooling (GAP)</p>
]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>计算机视觉</category>
<category>经典工作</category>
</categories>
<tags>
<tag>CAM</tag>
</tags>
</entry>
<entry>
<title>T笔试题（4.4）口胡版</title>
<url>/acm/%E6%9F%90%E7%AC%94%E8%AF%95%E9%A2%98/</url>
<content><![CDATA[<h1 id="题目1（dp60分-gt-双向dp口胡）"><a href="#题目1（dp60分-gt-双向dp口胡）" class="headerlink" title="题目1（dp60分->双向dp口胡）"></a>题目1（dp60分->双向dp口胡）</h1><h2 id="题目描述"><a href="#题目描述" class="headerlink" title="题目描述"></a>题目描述</h2><p>一个矩阵数组，从左上角走到右下角，每一步可向右or向下，走完之后的总价值为通过的位置的数的乘积，（每个数的范围是-8到8，矩阵数组15*15），求最大总价值，答案mod 1e9+7。 </p>
<h2 id="解题思路"><a href="#解题思路" class="headerlink" title="解题思路"></a>解题思路</h2><span id="more"></span>
<ul>
<li><ol>
<li>原始版本：全是正数，经典模型，保留dp[i][j]为最大值，dp[i][j] = max(dp[i-1][j], dp[i][j-1])*value[i][j]。 </li>
</ol>
</li>
<li><ol start="2">
<li>正数和复数都有：如果value[i][j]为负，取max反而得到最小的value，而最大的value由之前的最小值得到。因此保留每一步转移的最大值和最小值。dp_max[i][j], dp_min[i][j]。<br>dp_max[i][j] = max(dp_max[i-1][j], dp_max[i][j-1])*value[i][j], dp_min[i][j] = min(dp_min[i-1][j], dp_min[i][j-1])*value[i][j]<br>if value[i][j]< 0:<br>swap(dp_max[i][j], dp_min[i][j]);</li>
</ol>
</li>
<li><ol start="3">
<li>（赛后发现）上一步得到了60分。赛后发现，数据范围8=2^3，则8^15大于long long，需要过程中取模，而过程中的取模会导致dp方程转移失败。但8^8就不会大于long long，不需要过程取模，因此，把单项dp递推，改为从左上角和右下角分别双向递推，应该就能拿满分。（赛后才想明白，没办法）。。<h1 id="题目2（高精度？0分）"><a href="#题目2（高精度？0分）" class="headerlink" title="题目2（高精度？0分）"></a>题目2（高精度？0分）</h1><h2 id="题目描述-1"><a href="#题目描述-1" class="headerlink" title="题目描述"></a>题目描述</h2>计算一个带有开立方+取模+高精度的公式，答案也是高精度的科学表示法。<h2 id="解题思路-1"><a href="#解题思路-1" class="headerlink" title="解题思路"></a>解题思路</h2>没想明白。<br>目前想到的是，把题目中出现的10^-15和10^-20往上乘一些量级避免精度太高的浮点数运算，且sum这个部分可以用前缀和。但精度仍然不够高，或许需要数学层面的优化。<br>开立方：pow(x,1.0/3.0)，感觉上误差应该不小？<h1 id="题目3（dp100分）"><a href="#题目3（dp100分）" class="headerlink" title="题目3（dp100分）"></a>题目3（dp100分）</h1><h2 id="题目描述-2"><a href="#题目描述-2" class="headerlink" title="题目描述"></a>题目描述</h2>一排m个盒子，n个颜色的数量无限的小球，要求每个盒子一个小球，最多有连续两个盒子里球的颜色相同。求方法数。<h2 id="解题思路-2"><a href="#解题思路-2" class="headerlink" title="解题思路"></a>解题思路</h2>无脑的dp。dp[i][2]，dp[i][1]代表当前颜色和上一个相同的方案数，dp[i][0]代表当前颜色和上一个不同的方案数。<br>dp[i][0] = (dp[i-1][0]+dp[i-1][1])*(n-1);<br>dp[i][1] = dp[i-1][0];<br>（写成这个样子的dp，是不是能压成一维？反正没必要）<br>唯一一道100分的，第一次还因为取模次数太多得了95分，相当于卡常。 <h1 id="题目4（递归30分-gt-有新思路）"><a href="#题目4（递归30分-gt-有新思路）" class="headerlink" title="题目4（递归30分->有新思路）"></a>题目4（递归30分->有新思路）</h1><h2 id="题目描述-3"><a href="#题目描述-3" class="headerlink" title="题目描述"></a>题目描述</h2>一串n个数的集合，每个数的大小在0-2n范围内，每次根据数组的最大值和最小值的平均值（取地板—）把数划成两个子集。求所有子集的元素和的和。<h2 id="解题思路-3"><a href="#解题思路-3" class="headerlink" title="解题思路"></a>解题思路</h2>对于集合中任意一个元素，他被计算的次数等于参与划分的次数。即一个数被一直划分，每次加一个它的值，直到他无法被划分成两个子集。<br>子集划分停止条件：1.集合中只有一个元素。2.集合中所有数大于或小于(min+max/2)。即所有数的大小相等。<br>然后就可以直接模拟+递归了，复杂度理论上是nlogn就能解决。<br>如果能划分，找到划分元素的位置。我就是因为找划分元素套了一个二分查找多了logn的复杂度超时。没有注意题目是元素范围是0-2n，直接遍历数组记录0-2n的划分位置下标就没这回事了，当时过于着急，二分查找是又难写又超时T T。<h1 id="题目5-（map和set0分，没做完）"><a href="#题目5-（map和set0分，没做完）" class="headerlink" title="题目5 （map和set0分，没做完）"></a>题目5 （map和set0分，没做完）</h1><h2 id="题目描述-4"><a href="#题目描述-4" class="headerlink" title="题目描述"></a>题目描述</h2>n个文档，分别k个字符。每个文档中每个字符的重要度定义为(本文档中字符出现次数/多少个文档出现了这个字符)。每个文档的重要度定义为它最重要的字符的重要度。依次输出重要度。<h2 id="解题思路-4"><a href="#解题思路-4" class="headerlink" title="解题思路"></a>解题思路</h2>map<string, long long>mp0记录所有出现过的字符以及出现的文档。value我想的是bool二进制编码。数据范围大的话可能要再嵌套一个set。<br>map<string, int>mp1[n]记录各个文档各个字符出现次数。<br>然后map遍历。不知道有没有坑以及时间复杂度，大约是这样吧。<br>没有拿到模板的情况下，遍历map一直报错，没改明白。</li>
</ol>
</li>
</ul>
]]></content>
</entry>
<entry>
<title>CoMatch: Semi-supervised Learning with Contrastive Graph Regularization</title>
<url>/paper/comatch/</url>
<content><![CDATA[]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>计算机视觉</category>
<category>半监督学习</category>
</categories>
<tags>
<tag>semi-supervised learning</tag>
</tags>
</entry>
<entry>
<title>A2-RL: Aesthetics Aware Reinforcement Learning for Image Cropping</title>
<url>/paper/drl/</url>
<content><![CDATA[<h1 id="主题：图像裁剪"><a href="#主题：图像裁剪" class="headerlink" title="主题：图像裁剪"></a>主题：图像裁剪</h1><p>image cropping ：根据图片的构图裁剪图像<br>点评：<a href="https://baijiahao.baidu.com/s?id=1594068742057154438&wfr=spider&for=pc">https://baijiahao.baidu.com/s?id=1594068742057154438&wfr=spider&for=pc</a><br>多数弱监督学习：基于滑动窗口机制。缺点：1.限定纵横比，裁剪大小任意。2.需要上万的备选窗口，费时间。</p>
<h1 id="我们的工作概述："><a href="#我们的工作概述：" class="headerlink" title="我们的工作概述："></a>我们的工作概述：</h1><p>将图像裁剪看成序列决策过程，提出弱监督强化学习框架：Aesthetics Aware Reinforcement Learning (A2-RL) </p>
<h2 id="framework"><a href="#framework" class="headerlink" title="framework"></a>framework</h2><p>-》尤其是提出一种关于美学图像裁剪的奖励函数<br>-》与人类裁剪图像相同，采用一种综合的状态表示法，表示当前视图和历史经验。<br>-》采用端到端的actor-critic结构训练agent智能体<br>-》agent采用一些不可视的裁剪数据集评估，发现跟原来的方法比时间快、窗口少，打到要求。</p>
<h1 id="他人工作步骤："><a href="#他人工作步骤：" class="headerlink" title="他人工作步骤："></a>他人工作步骤：</h1><p>密集提取备选窗口<br>找到每个窗口的特征<br>评估找到最佳区域</p>
<h1 id="我们评价："><a href="#我们评价：" class="headerlink" title="我们评价："></a>我们评价：</h1><p>第一个使用强化学习解决图像裁剪问题。选择窗口很快得到任意形状的结果。<br>验证数据集：[34, 11, 4]</p>
<h1 id="他人具体工作："><a href="#他人具体工作：" class="headerlink" title="他人具体工作："></a>他人具体工作：</h1><p>[15, 7, 19, 9]：设计手动的特征，基于人类的直觉和摄影的规则技巧<br>感谢深度学习和大规模数据集[22]，[16, 20, 8]使用深度学习进行审美评价<br>两种类型方法：1.基于美学。2.基于注意力机制<br> [28, 27, 24, 2] 基于注意力：找到最显眼的东西，不考虑构图<br> 基于审美：找到最合适构图。 评价基于美学质量分类法 [23, 11]。或使用RankSVM [4] or RankNet [5]对比原始图像和裁剪图像丢弃低质量。或重定向方法 [6, 3]调整目标和原始纵横比并不丢弃重要内容。<br>两种监督：1.监督（boxs贵）。2.弱监督（滑动窗口）。取决于是否使用 bounding box annotations<br>我们使用强化学习选择窗口。<br>*Hong et al. [12]也讲看作时间序列问题，但是使用了bba<br>强化学习在图像中的成功应用：图像主题〔26〕、物体检测〔1, 13〕和视觉关系检测〔18〕<br>*active object localization method [1]在无区域检测的检测算法中表现最好<br>*tree-RL method [13]用强化学习获取区域建议比RPN [25]更好<br>#上述强化学习算法用了bba做标记，我们只用美学质量做标记。</p>
<h1 id="主题：智能体读取原始图像和窗口图像，根据经验状态做出动作分割图像，得到外部奖励，调整。"><a href="#主题：智能体读取原始图像和窗口图像，根据经验状态做出动作分割图像，得到外部奖励，调整。" class="headerlink" title="主题：智能体读取原始图像和窗口图像，根据经验状态做出动作分割图像，得到外部奖励，调整。"></a>主题：智能体读取原始图像和窗口图像，根据经验状态做出动作分割图像，得到外部奖励，调整。</h1><p>状态空间：st，当前+历史状态的集合。使用LSTM记忆历史视图。<br>动作空间：14个，大小、位置、长宽比。移动为0.05倍的图片。终止有触发器，自动停止，当奖励分数不再增加时。<br>奖励函数：用aesthetic score。比较每次和上一次。为了快点结束，加一个和次数t相关的奖励函数。<br>奖励函数：</p>
<p>。sign:符号函数？（-1/1）。t为操作次数。<br>*长宽比超过2或不足0.5，给出消极信号nr<br>ar和nr调整。</p>
<h1 id="结构："><a href="#结构：" class="headerlink" title="结构："></a>结构：</h1><p>图像：5个卷积block，1个全连block。<br>接着分为两部分。Agent:3个全连层+LSTM（长短期记忆网络）。另一部分评估。<br>两个输出：actor:critical<br><img src="https://www.evernote.com/shard/s324/res/e37077fd-deda-4974-9af3-57b1b65ff17c" alt="image"></p>
<h1 id="模型训练："><a href="#模型训练：" class="headerlink" title="模型训练："></a>模型训练：</h1><p>A3C</p>
<h1 id="模型评估："><a href="#模型评估：" class="headerlink" title="模型评估："></a>模型评估：</h1><p>数据集描述，数据集表现略。参数：相同面积/总截取面积。<br>和之前方法、不采用LSVM、不采用纵横比截取对比。</p>
<p>*来源：中科院自动化所智能计算与感知中心</p>
<p>cropping<br>裁剪<br>#proposal <br>提议\建议（region proposal ）<br>theoretically<br>理论上<br>composition<br>构图<br>optimize<br>优化<br>intuitional<br>直觉的<br>mechanism<br>机制<br>manipulate<br>操纵<br>convolution<br>卷积<br>supervision<br>监督<br>execute<br>执行<br>assess<br>评估<br>annotation<br>注释<br>converge<br>收敛<br>estimation<br>评价<br>novel<br>新的<br>heuristic<br>启发式<br>asynchronous<br>异步的<br>obtain<br>得到<br>corresponding<br>相应的<br>optimization<br>最优化<br>densely<br>密集的<br>penalty<br>刑罚<br>entropy<br>熵<br>extract<br>提取<br>modify<br>修改<br>denote<br>代表<br>inevitably<br>不可避免地<br>capture<br>捕获<br>parameters<br>参数<br>discriminate<br>辨析<br>trigger<br>触发器</p>
]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>深度学习</category>
<category>强化学习</category>
</categories>
<tags>
<tag>reinforcement learning</tag>
</tags>
</entry>
<entry>
<title>Deep Progressive Reinforcement Learning for Skeleton-based Action Recognition</title>
<url>/paper/drl10/</url>
<content><![CDATA[<p>主题：视频中，基于骨架的行为识别。<br>解读：<a href="https://blog.csdn.net/b224618/article/details/81143736">https://blog.csdn.net/b224618/article/details/81143736</a><br>解读：<a href="https://blog.csdn.net/chenhaojing/article/details/81476244">https://blog.csdn.net/chenhaojing/article/details/81476244</a></p>
<h1 id="其他人：用DRL做行为识别的很少、类似的工作一般一次提取一个关键帧"><a href="#其他人：用DRL做行为识别的很少、类似的工作一般一次提取一个关键帧" class="headerlink" title="其他人：用DRL做行为识别的很少、类似的工作一般一次提取一个关键帧"></a>其他人：用DRL做行为识别的很少、类似的工作一般一次提取一个关键帧</h1><h1 id="框架：用DRL训练-FDNet提取关键帧，用GCNN训练。"><a href="#框架：用DRL训练-FDNet提取关键帧，用GCNN训练。" class="headerlink" title="框架：用DRL训练 FDNet提取关键帧，用GCNN训练。"></a>框架：用DRL训练 FDNet提取关键帧，用GCNN训练。</h1><p><img src="https://www.evernote.com/shard/s324/res/5ecd3f73-c778-4fb3-abae-e88fae03e107" alt="img1"></p>
<h1 id="RL"><a href="#RL" class="headerlink" title="RL:"></a>RL:</h1><p>状态：F\M\Sb<br>F:global frames: 所有帧的信息：帧数<em>关键点数</em>三个维度。<br> *帧非整数：双三次插值。保证首尾与原相同。<br> * 双三次插值（英语：Bicubic interpolation）是二维空间中最常用的插值方法。<br>M:selected frames：当前被选择帧的信息。<br>Sb:被选择帧的掩码</p>
<p>动作：向哪个方向移动帧（3种）<br> *移动有固定范围，不会交叉。上下界：当前帧和下一帧的一半<br>奖励：GCNN训练好。从绝对正确帧与错误帧跳跃时加大奖励惩罚，其他用<br><img src="https://www.evernote.com/shard/s324/res/f4e441d0-20a9-49cf-ab77-01a0413e73ff" alt="img2"></p>
<p>GCNN:（这里有一些数学公式没看懂）<br>构图，后卷积<br><img src="https://www.evernote.com/shard/s324/res/6e5d1d7a-34fe-4bee-8e7f-d33aa4d94b26" alt="img3"></p>
<p>loss function选取的是交叉熵（= =） <br> *交叉熵：度量两个概率分布间的差异性信息</p>
<p>训练：使用 policy gradient。Deep Q-learning工作量大。<br>算法：先用等间距帧训练GCNN，之后训练和用DRL调整。</p>
<h1 id="评价"><a href="#评价" class="headerlink" title="评价"></a>评价</h1><p>优点：在动作识别领域，增强学习的应用还不多。基于骨架的CNN，之前研究只考虑互连骨架，其实不互连的也有用。<br>缺点：1.关键帧数量。2.移动卡住，有些范围无法达到等问题。3.正确帧一个范围。4.有的帧从对到错，有的帧从错到对（r是累加的？还是一个？）<br> *这个帧移动/奖励函数 的机制一定有问题，可以构造一下看看。但是DRL本来就不能解决。。</p>
<hr>
<p>vertex<br>顶点<br>cross-entropy<br>交叉熵<br>sensory<br>感觉<br>mutually<br>交互地<br>frame<br>框架</p>
<p>concatenate<br>连接</p>
<p>aggregate<br>总计的</p>
<p>enforce<br>执行</p>
]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>深度学习</category>
<category>强化学习</category>
</categories>
<tags>
<tag>reinforcement learning</tag>
</tags>
</entry>
<entry>
<title>FROM LANGUAGE TO GOALS INVERSE REINFORCEMENT LEARNING FOR VISION-BASED INSTRUCTION FOLLOWING</title>
<url>/paper/drl12/</url>
<content><![CDATA[<p>将语音控制机器人移动和拾取物品的，从policy改为从逆强化学习的reward。action和state很自然。<br>实验不是特别convincing，pick比navigate好.</p>
<p>作者提到的问题：人类语言不够精确。</p>
]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>深度学习</category>
<category>强化学习</category>
</categories>
<tags>
<tag>reinforcement learning</tag>
</tags>
</entry>
<entry>
<title>Transfer Learning for Related Reinforcement Learning Tasks via Image-to-Image Translation</title>
<url>/paper/drl13/</url>
<content><![CDATA[<p>评价：描述的问题很有趣，方法有限。</p>
<p>将强化学习的agent从一个任务迁移到另一个由变化环境，（游戏场景）使用GAN对图片Mapping，将state对应起来。<br>用模仿学习加速新任务的rl，从imperfect demonstrations，收集原有agent的几条轨迹，模仿学习一个新任务的policy。</p>
]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>深度学习</category>
<category>强化学习</category>
</categories>
<tags>
<tag>reinforcement learning</tag>
</tags>
</entry>
<entry>
<title>Sampling Strategies for GAN Synthetic Data</title>
<url>/paper/drl11/</url>
<content><![CDATA[<p>将GAN生成的假数据采样的方法，包括<br>1判别器的confidence score，<br>2confidence on target label，<br>3RL：meaningful </p>
]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>深度学习</category>
<category>强化学习</category>
</categories>
<tags>
<tag>reinforcement learning</tag>
</tags>
</entry>
<entry>
<title>Dual-Agent Deep Reinforcement Learning for Deformable Face Tracking(ECCV2018)</title>
<url>/paper/drl14/</url>
<content><![CDATA[<p>a tracking agent and an alignment agent，一个移动bounding box，原有1/2。另一个根据当前关键点位置，控制是否停止。共用一个环境。<br>MA-DRL的框架细节写得不清楚，看起来比较普通没有创新，不像DRL出身的团队。</p>
]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>深度学习</category>
<category>强化学习</category>
</categories>
<tags>
<tag>reinforcement learning</tag>
</tags>
</entry>
<entry>
<title>Collaborative Deep Reinforcement Learning for Multi-Object Tracking</title>
<url>/paper/drl15/</url>
<content><![CDATA[<h1 id="任务："><a href="#任务：" class="headerlink" title="任务："></a>任务：</h1><p>视频中的多行人追踪任务。由于人在场景中的数量自由变化且可能相互遮挡，适用自由度高注重交互的多agent。</p>
<h1 id="概述："><a href="#概述：" class="headerlink" title="概述："></a>概述：</h1><p>任务分为两个部分，predict和decision。在每一帧形成一个多目标detect的结果，另外通过predict网络使用每一个物体的历史轨迹预测下一帧的各个物体位置（未使用DRL）。<br>然后，考虑离这个物体最近的其他物体neighbor，根据他定义的距离（分别比较2个结果），判断是否考虑可能造成遮挡的agent，然后将predict、detect、neighbor(或空白图)，3张图片输入到Decision Network(DRL环境)。DRL用于学习判断对三张图片最优的利用方式。</p>
<h1 id="Decision部分的DRL细节："><a href="#Decision部分的DRL细节：" class="headerlink" title="Decision部分的DRL细节："></a>Decision部分的DRL细节：</h1><p>State:理论上包含当前帧的detect图，所有agent的上一帧位置，但multi-agentDRL系统，每个agent的decision网络输入只有3张图片。<br>action集:{block(Detection结果不存在，使用predict更新位置)；ignore(认为detection结果不可信，使用predict更新位置)；update(综合predict和detection更新位置)；delete(detection结果不存在，predict预测物体已离开场景，删除agent)；}，另外已使用过的detect结果删除，如果发现有多余的detect，判断有新物体进入场景，初始化一个新的agent。<br>reward：根据综合选择动作后，预测的位置与ground truth的IoU</p>
<h1 id="实验："><a href="#实验：" class="headerlink" title="实验："></a>实验：</h1><p>做得非常充分，各种offline和online多目标追踪的指标和对比方法，但是由于对比过多，直观的效果看着并不是很好？作者详细论证了某个指标出色的方法在其他指标表现不好，或者某些情况存在缺陷，以证明自己的方法综合来看比较好，能充分利用上下文信息。</p>
<h1 id="评价："><a href="#评价：" class="headerlink" title="评价："></a>评价：</h1><p>从理解层面场景适合multi-agent解决。用DRL，利用最近的neighbor，衡量detection以及predict两个结果的可信度。实验非常充分，效果不能说很突出。文章细节写得不错。</p>
<h1 id="思考："><a href="#思考：" class="headerlink" title="思考："></a>思考：</h1><p>*物体过多，遮挡后可能会出现id出错（认错人）的问题，保留前几帧的物体特征。但是对于行人的相似，还是有一些挑战。因为方法只能考虑两个agent的交互。<br>*multi-agent，输入Q网络的包括一些其他agent的信息，其他的相比普通drl不是很特别。<br>*为什么predict部分不用DRL的方法呢？<br>*类似我之前考虑的reward设计部分的问题，生成多个结果后用DRL判断应该使用哪个结果或综合考虑。然而真正drl的reward，如果再套用drl，这部分奖励很难定义。</p>
]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>深度学习</category>
<category>强化学习</category>
</categories>
<tags>
<tag>reinforcement learning</tag>
</tags>
</entry>
<entry>
<title>Deep Reinforcement Learning with Iterative Shift for Visual Tracking(ICLR2019)</title>
<url>/paper/drl16/</url>
<content><![CDATA[<p>参考链接：<br><a href="http://www.yidianzixun.com/article/0LPKOG9R">http://www.yidianzixun.com/article/0LPKOG9R</a></p>
]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>深度学习</category>
<category>强化学习</category>
</categories>
<tags>
<tag>reinforcement learning</tag>
</tags>
</entry>
<entry>
<title>待阅读</title>
<url>/paper/drl17/</url>
<content><![CDATA[<p>待添加。<br>Deep Reinforcement Learning with Iterative Shift for Visual Tracking<br>Part-Activated Deep Reinforcement Learning for Action Prediction<br>Multi-Agent Deep Reinforcement Learning for Multi-Object Tracker<br>Improving Spatiotemporal Self-Supervision by Deep Reinforcement Learning<br>Language-driven Temporal Activity Localization: A Semantic Matching Reinforcement Learning Model</p>
]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>深度学习</category>
<category>强化学习</category>
</categories>
<tags>
<tag>reinforcement learning</tag>
</tags>
</entry>
<entry>
<title>IRLAS: Inverse Reinforcement Learning for Architecture Search (CVPR2019)</title>
<url>/paper/drl18/</url>
<content><![CDATA[<p>与block-wise qnn同作者，设计reward，通过强化学习生成的网络尽可能接近人工设计的经典网络模型。主要是比较规范。<br>关于NAS的文章很多，形成了一个体系。除了提升性能外，很多都在为减小搜索复杂性/看起来更加规范而创新。</p>
]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>深度学习</category>
<category>强化学习</category>
</categories>
<tags>
<tag>reinforcement learning</tag>
</tags>
</entry>
<entry>
<title>Merge or Not? Learning to Group Faces via Imitation Learning（AAAI2018）</title>
<url>/paper/drl19/</url>
<content><![CDATA[<p>强化学习聚类。解决action过大：用一个recommender推荐两个图片，action判断是否相连。（？？？这是个很奇怪的用法）按时间给不同操作加权。<br>逆强化学习：本质是reward不通过人为设定，而是从其他算法，用少量样本以及action，用短视的方法学习reward。</p>
]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>深度学习</category>
<category>强化学习</category>
</categories>
<tags>
<tag>reinforcement learning</tag>
</tags>
</entry>
<entry>
<title>Attention-aware deep reinforcement learning for video face recognition</title>
<url>/paper/drl2/</url>
<content><![CDATA[<p>用drl训练注意力模型，判断两个视频的人脸是否相同。drl的工作是过滤帧，每一步在一堆帧中选择一个丢弃。<br>类似用GAN采样的用法。</p>
]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>深度学习</category>
<category>强化学习</category>
</categories>
<tags>
<tag>reinforcement learning</tag>
</tags>
</entry>
<entry>
<title>Reinforced Cross-Modal Matching and Self-Supervised Imitation Learning for Vision-Language Navigation (cvpr2019满分)</title>
<url>/paper/drl20/</url>
<content><![CDATA[<p>CVPR 2019最佳论文，主要应该是效果好且实用。<br>Agent学习对应运动轨迹和语言子指令的映射，惩罚错误的轨迹。在环境变化时，智能体用模仿学习，利用之前比较好的轨迹迁移到新环境。</p>
<p>（引用）<br>具体来说，他们使用了一个匹配指标，它成为了鼓励模型增强外部指令和运动轨迹之间匹配的固有反馈；模型也使用了一个推理导航器，它用来在局部视觉场景中执行跨模态参照。在一个 VLN benchmark 数据集上进行的评估结果表明，们提出的 RCM 模型大幅超越已有模型，SPL 分数提高了 10%，成为了新的 SOTA。为了提高学习到的策略的泛化性，们还进一步提出了一个自模仿学习（SIL）方法，通过模仿自己以往的良好决策的方式探索未曾见过的环境。们表明了 SIL 可以逼近出更好、更高效的策略，这极大程度减小了智能体在见过和未见过的环境中的成功率表现的差别（从 30.7% 降低到 11.7%）</p>
]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>深度学习</category>
<category>强化学习</category>
</categories>
<tags>
<tag>reinforcement learning</tag>
</tags>
</entry>
<entry>
<title>Automatic Face Aging in Videos via Deep Reinforcement Learning（CVPR2019）</title>
<url>/paper/drl21/</url>
<content><![CDATA[<p>在视频中，找到从一个年轻的组到年老的组的图像的最近距离？应用是实现自动老化。</p>
]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>深度学习</category>
<category>强化学习</category>
</categories>
<tags>
<tag>reinforcement learning</tag>
</tags>
</entry>
<entry>
<title>RL-GAN-Net: A Reinforcement Learning Agent Controlled GAN Network for Real-Time Point Cloud Shape Completion（CVPR2019）</title>
<url>/paper/drl22/</url>
<content><![CDATA[<p>智能体用DRL挑选合适的种子，GAN的G生成点云，D判断并给出reward<br><img src="https://www.evernote.com/shard/s324/res/f56f8188-2ce2-4df6-82cd-ad9d13fc9606" alt="img1"><br><img src="https://www.evernote.com/shard/s324/res/5a4a274c-45fb-4013-a2a1-9b0c6db8691f" alt="img2"><br>评价:文中其实只是用DRL帮G挑选合适的生成点云的种子，也不是特别新颖创新的。但DRL确实跟各种其他框架结合可以。</p>
<p>（以下内容来自引用）<br>RL GAN Net，其中强化学习RL代理提供对生成对抗性网络GAN的快速且稳健的控制。</p>
<p>框架应用于点云形状完成，通过控制GAN将嘈杂的部分点云数据转换为高保真完成形状。虽然GAN不稳定且难以训练，但我们通过在潜在空间表示上训练GAN来避免问题，其中空间表示与原始点云输入相比减小;</p>
<p>2使用RL代理来查找到GAN的正确输入生成最适合当前不完整点云输入的形状的潜在空间表示。建议的管道可以完美地完成具有大量缺失区域的点云。</p>
<p>据我们所知，这是第一次尝试训练RL代理来控制GAN，这有效地学习了从GAN的输入噪声到点云的潜在空间的高度非线性映射。 </p>
<p>RL代理取代了复杂优化的需要，从而使我们的技术实时化。<br>此外，我们证明我们的管道可用于提高缺少数据的点云的分类准确性。</p>
]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>深度学习</category>
<category>强化学习</category>
</categories>
<tags>
<tag>reinforcement learning</tag>
</tags>
</entry>
<entry>
<title>Deep Reinforcement Learning of Volume-guided Progressive View Inpainting for 3D Point Scene Completion from a Single Depth Image (cvpr2019 Oral)</title>
<url>/paper/drl23/</url>
<content><![CDATA[<p>基于单视角深度图恢复完整三维场景，提出了一种基于三维 与 二维卷积神经网路协同学习的多视角补全技术，并首次将深度强化学习用于引入该问题的求解过程。本文的方法在公开数据集上获得了世界领先水平。</p>
<p>本工作受阿里巴巴创新研究计划资助。</p>
]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>深度学习</category>
<category>强化学习</category>
</categories>
<tags>
<tag>reinforcement learning</tag>
</tags>
</entry>
<entry>
<title>SeedNet: Automatic Seed Generation with Deep Reinforcement Learning for Robust Interactive Segmentation(cvpr2018)</title>
<url>/paper/drl24/</url>
<content><![CDATA[<p>主题：交互式图像分割的自动种子生成。保证少量用户输入的情况下的鲁棒性<br>用户只需要在一开始的时候指定一个背景里的点和一个目标物体的点，剩下的都会自动生成.<br><a href="https://blog.csdn.net/chenhaojing/article/details/82667017">https://blog.csdn.net/chenhaojing/article/details/82667017</a></p>
<h1 id="贡献："><a href="#贡献：" class="headerlink" title="贡献："></a>贡献：</h1><p>1.将交互式分割任务变为马尔科夫过程，智能体添加种子辅助判断。<br>2.新的奖励函数。intersection-over-union (IoU) score.</p>
<h1 id="他人工作："><a href="#他人工作：" class="headerlink" title="他人工作："></a>他人工作：</h1><p>交互式切割<br>1.Numerous methods such as GrabCut [26], random walks [13, 16], geodesics [5], and methods with shape prior [30, 14]<br>2.Wu et al. [33]considered interactive segmentation as a weakly supervised learning problem sweeping line multiple instance learning (MIL)<br>3.for extending seed information.<br>4.FCN etc.<br><img src="https://www.evernote.com/shard/s324/res/fbbf01a0-8c43-425e-8611-b0b8ef21978d" alt="img1"><br>状态：整个图。<br>动作：给每个点标记为红/绿<br>分割网络：RW，成型的分割网络。<br>奖励：common metric。<br>除IoU，借鉴：我们认为分的点的类型和GT相比是对的就给奖励。<br>在IoU的基础上：一个GT-MASK 从中间向外分成4部分，当生成的新seed在不同的区域时，给不同的Reward.<br><img src="https://www.evernote.com/shard/s324/res/0f8864f1-8ed0-45df-b868-81bcd1375361" alt="img2"><br><img src="https://www.evernote.com/shard/s324/res/9488386f-03a3-4672-abfa-314cea598e41" alt="img3"></p>
<h1 id="实验"><a href="#实验" class="headerlink" title="实验"></a>实验</h1><p>论证了我们的Reward和IoU的关系比较合理。</p>
]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>深度学习</category>
<category>强化学习</category>
</categories>
<tags>
<tag>reinforcement learning</tag>
</tags>
</entry>
<entry>
<title>Reinforced Multi-Label Image Classification by Exploring Curriculum（AAAI2018）</title>
<url>/paper/drl25/</url>
<content><![CDATA[<p>多标签图像分类，feature，action为各个label，选择最容易的label，reward+1/-1。声称参考了curriculum learning，从简单</p>
]]></content>
<categories>
<category>科研</category>
<category>论文</category>
<category>论文笔记</category>
<category>深度学习</category>
<category>强化学习</category>
<category>多标签识别与分类</category>
</categories>
<tags>
<tag>reinforcement learning</tag>
<tag>multi-label classification</tag>
</tags>
</entry>
<entry>
<title>Sim-Real Joint Reinforcement Transfer for 3D Indoor Navigation</title>