-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathatom.xml
More file actions
1677 lines (1411 loc) · 682 KB
/
atom.xml
File metadata and controls
1677 lines (1411 loc) · 682 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
<title><![CDATA[Kepp It Simple && Stupid]]></title>
<link href="/atom.xml" rel="self"/>
<link href="https://github.com/sillyplus/"/>
<updated>2017-01-30T19:36:04.000Z</updated>
<id>https://github.com/sillyplus/</id>
<author>
<name><![CDATA[sillyplus]]></name>
</author>
<generator uri="http://hexo.io/">Hexo</generator>
<entry>
<title><![CDATA[2016 回顾]]></title>
<link href="https://github.com/sillyplus/2017/06/30/2016review/"/>
<id>https://github.com/sillyplus/2017/06/30/2016review/</id>
<published>2017-06-30T03:25:40.800Z</published>
<updated>2017-01-30T19:36:04.000Z</updated>
<content type="html"><![CDATA[<!-- excerpt -->
<h2 id="000B-1">000B</h2><p>well,该从何说起。</p>
<p>今晚见了一群小学同学,因为都是从小玩到大,毕竟同班好几年,外加大家都比较 friend(至少我这么觉得,,)。突然很感慨,然后翻了一下自己朋友圈,发现原来过去的 2016 似乎发生了很多事情,然而我却全忘记了……</p>
<p>突然很想写点什么,顺便给这个博客除除草。</p>
<h2 id="001B">001B</h2><p>回顾 2016 年,大概就是做了一点微小的工作,完成了几个小目标。如果不想看流水账,到此处就可以结束了😂</p>
<p>———————————————————— 我是丑丑的分割线—————————————————————</p>
<p>2016 年 元旦前夕,我编着程跨了个年,我想这是一个装 B 的新谈资。但是,当时写的项目后来拖拖沓沓到后来唯品会实习期间才最终结束,我想我没有接好这个锅,也挺对不起 PM 的。</p>
<p>春季找实习的时候,失意 Tencent ,意外去了 vipshop 当起了测试小弟,度过了一段愉快的时光。嗯,还是蛮愉快的。真心感激那里的每一个人。</p>
<p>入职当天,看到材料上写着我的导师是 张薇,嗯,这名字怎么看都是位小姐姐吧,我 kao,导师居然是女的,讲真,我不是想强调性别,至少有点意外。结果,领我走的人确是个 1 米 9 几的😂?,汉子!长这样叫这名字,我真的是拒绝的,还好后来证实不是本人。</p>
<p>高人,人如其名,确实是高,长得高,技术也高,是后端测试的 leader。从高人处学习了很多,不管是技术还是业务,还有职业素养。最初的几天,每晚都是差不多八九点才开始离开公司,从芳村回大学城。记得有一次高人给我讲业务,一起测一个项目,搞到九点半了,高人邀请我十点之后再走,可以报销打车回去,可惜身无分文的我打不起车,之后借口先走了😂,不过回到学校十一点多,估计十点后打车更快。还有一次压测一个项目,在高人的注视下,一直弄到了一点多,当时我是有点体味到所谓奔溃的感觉,毕竟太年轻了。</p>
<p>同个 Team 还有许多有趣又各具特色的同事,比方说健哥、仁昌、师妹、铁桥等等~突然觉得回忆不断涌出来,所以不详细写了。</p>
<p>在后端测试组呆了两个月左右,去了趟上海回来后就打算离职了,但是在 bose 的忽悠下就追随健哥去做前端测试自动化的开发了,比较跟 iOS 方向挂了一点点小勾。这期间,我们也有广新办公区搬家到了总部醉观公园,工作生活开始变得不那么紧迫,没有了上线的压力,开发有条不紊的进行着。中间出过重大事故,开了人,虽然跟我们关系不大,倒也是长了见识。</p>
<p>八月底,项目基本成型,写了点 wiki,搭建了 Mac 的测试环境,算是留下的痕迹,离职,开学了。</p>
<p>秋季学期开始后就是校招季,嗯,也发生了一些事情,因为台风,放弃了去网易杭州面试的机会;因为台风,中秋没回家;因为台风,都是借口。</p>
<p>这里不想写面经,感觉没什么可供别人参考的。总之莫名其妙,十月份等了大半个月(20 几天?),最终拿到了 DJI 的 offer。十一月底开始了第二段实习,but,不是去 DJI。</p>
<p>在广州找到了一家小小的创业公司,进去了才发现,员工满满的中大校友 + 潮汕同胞,还有同级同院的妹子,虽然之前都不认识,手动捂脸。讲真,如果让我推荐,我仍然很愿意向别人介绍这家集风投、咨询与技术与一身的初创公司 runwise,详情就自己请有兴趣的朋友自行 Google 了,要投简历可以找我~</p>
<p>在 runwise 的日子也是历历在目,毕竟就是最近的事情😂。好吧,必须强调的一点就是,去了 runwise 之后,伙食明显变好了,虽然是自费。对于在孤岛宅居几年的我来说,外面的世界真精彩(误),外面的饭菜真好吃~~~但是也在心中默默拉黑过楼下的韩日料理店。</p>
<p>在 runwise,技术总监 Pippa 是位做过几年老师的(现役?)程序媛,每天都有爱心便当吃,我也是觉得挺羡慕的。在我入职之后,技术队伍还在不断壮大,陆陆续续又招了很多实习,也有被我安利进去(jieguo)的。这中看这公司明显一步步成长的感觉真好。希望三月份项目能顺利完成,上线。</p>
<p>还有就是,原本面试 iOS 开发的我,最后其实是被忽悠去做后端 python 了,虽然也有我的一点个人意愿。现在算是题了离职,但是至于离了没,我也说不清。</p>
<p>在 vipshop 这样的大体量公司,以及 runwise 这样的初创公司,氛围和感受真的很不同。但是这些短暂的接触后,如果让我选择,我仍然不知道选择去那个,but ,我想,这些不同的经历都会成为我宝贵的财富吧。</p>
<h2 id="010B">010B</h2><p>2016 年呀,没有挂科,应该算是完成了不是目标的目标。</p>
<p>希望剩下的欠了三四年的一科,在下学期顺利 pass。虽然我也不介意延毕是的,但是毕竟重新找工作还是有点小烦,虽然我也不介意……</p>
<p>下学期还剩下毕设之类的东西,嗯,开完题了,就没然后了。</p>
<p>Anyway,毕不毕业有没有所谓?谁知道呢~,</p>
<p>好吧,我还是有点方的。</p>
<h2 id="011B">011B</h2><p>2016 年应该是我这辈子踢球最多的一年,至今看球最多的一年,也是受伤最多的一年,充满许多遗憾的一年。</p>
<p>年初的院系赛,淘汰赛早早出局,不得不说,责任在我,不甘心,至今仍不甘心。</p>
<p>秋招期间,每天不是在踢球就是在去踢球的路上。我觉得爱好真的是陪伴一个人一生的东西,人,也许轻易就离开了。足球,不明所以地喜欢,无法舍弃。大四的康乐杯,于曾经的“同城死敌”软院以及远自珠海的移动兄弟没代表 <em>中山大学数据科学与计算机学院</em> 出战,在各位大腿的 carry 下,进入了四校冠军决赛,惜败中山医,轻取中珠队伍(原谅我忘记叫什么来着)最终仅收获季军,感觉又会是一段充满汗水与不甘的基情燃烧的岁月。这一年,中大点球决胜,拿到了省长杯冠军,惋惜只能做场边观众。</p>
<p>这一年,空闲的时间多了,看了一些足球比赛,感受了一点不同与球场上的足球魅力。像阿森纳、利物浦、巴萨、恒大是冠军这种事情我还是知道的,但是我希望,像曼联、皇马、富力这样的小球队也不要放弃梦想,万一像我死忠了三十的莱斯特城一样呢。梦想还是要有的。</p>
<p>草草翻看了一下朋友圈,发现去年 4 月份、8 月份,我都发过关于对于左脚异样感影响足球生涯的担忧。然而我自身的疏忽、不负责任,导致伤情暗中发展,最终在康乐杯东校区决赛上爆发,上场不到一分钟,就被抬下了。不知道从什么时候起,开始挥霍自己的身体资本,脚踝膝盖相继扭伤后,我还是过于乐观,导致膝盖一而再,再而三地扭伤,现在已经有快两个月没踢球了吧。我也不记得多久了,球瘾发作的时候只能玩玩实况排遣,但是这会导致我一整天都在打实况😂。希望,现在好好养伤,早日康复呀我自己!!!</p>
<p>要是真的以后踢不了球,总感觉眼泪肯定忍不住。</p>
<h2 id="100B">100B</h2><ul>
<li>2016 年,从《海女》开始,走上了日剧的不归路,貌似之前看的都是美食类。</li>
<li>发现短发的妹子很可爱。</li>
<li>年初去东莞松山湖参加了高校互联网应用开发大会?莫名上台做了一把访问嘉宾😂。</li>
<li>去上海参加了 Apple 举办的夏令营交(wan)流(shua)。</li>
<li>独自跑去北京面试(轧马路),被风吹成傻子。</li>
<li>扇贝单词从大一开始,连续打卡了 1024 天之后,终于在 7 月 8 日决定停止,去之前我好像见了什么人。</li>
<li>看了一场富力赢球的广州德比。</li>
<li>学了一点半音阶口琴。</li>
<li>学了一点陶笛。</li>
<li>发现冬至刚好是生日,于是拒绝吃汤圆,反正我是忘记自己几岁了。</li>
<li>……</li>
</ul>
<h2 id="101B">101B</h2><p>2016 年,这一年在家 15 天,寒假的 15 天。</p>
<p>不在家的这段时间,家里发生了许多我不知道的事情,很多时候,只能从电话另一头了解到,无力。希望家人能都健健康康的。</p>
<h2 id="NULL">NULL</h2><p>😂😂😂如果您看到这里,难道不是真爱吗。看我这种思维混乱的人写的垃圾,不如没事找我吹吹水吧。</p>
<p>流水账就这么记完了,回到 603 十周年同学会的事件上。嗯,大家都走上了不同的道路,想必以后生命轨迹产生交叉的概率掰掰手指算一下都知道很低,能够久别重逢,相视一笑,我觉得就很足够了。同学会这种场合我是天生拒绝的,但是,当看到一个个熟悉的面孔(有的居然还长得跟小学生一样😂,这一定是我的错觉),还是很开心的 (>^ω^<)。</p>
<p>以上。</p>]]></content>
<summary type="html">
<![CDATA[<h2 id="000B">000B</h2><p>well,该从何说起。</p>
<p>今晚见了一群小学同学,因为都是从小玩到大,毕竟同班好几年,外加大家都比较 friend(至少我这么觉得,,)。突然很感慨,然后翻了一下自己朋友圈,发现原来过去的 2016 似乎发生了很多事情,然而我却全忘记了……</p>
<p>突然很想写点什么,顺便给这个博客除除草。</p>]]>
</summary>
<category term="总结" scheme="https://github.com/sillyplus/tags/%E6%80%BB%E7%BB%93/"/>
<category term="杂记" scheme="https://github.com/sillyplus/categories/%E6%9D%82%E8%AE%B0/"/>
</entry>
<entry>
<title><![CDATA[Xcode插件]]></title>
<link href="https://github.com/sillyplus/2015/10/26/make-up-your-xcode/"/>
<id>https://github.com/sillyplus/2015/10/26/make-up-your-xcode/</id>
<published>2015-10-26T00:41:27.000Z</published>
<updated>2015-10-26T08:03:41.000Z</updated>
<content type="html"><![CDATA[<!-- excerpt -->
<h1 id="Alcatraz">Alcatraz</h1><p><a href="http://alcatraz.io/" target="_blank" rel="external">Alcatraz</a> 是一个开源的 Xcode 包管理工具,包管理工具的好处就不用安利了。使用 Alcatraz 带来的便利,自己体验下就知道了。安装以及使用我觉得自行参考官方的说明是最好的了。<br><img src="alcatraz.png" alt=""></p>
<h1 id="Xvim">Xvim</h1><p>总的来说,我是一个 vim 爱好者,所以有时候会很想把 vim 下的一些使用体验延续到 Xcode 开发中,比如使用 hjkl 快速在代码中移动,以及其它各种操作,<a href="https://github.com/XVimProject/XVim">Xvim</a> 就很好的基本上满足了我的需求。Xvim 还有几个附加的命令可以帮助你编译,运行你的项目。</p>
<blockquote>
<p><strong>几个特殊命令</strong><br><figure class="highlight elixir"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="symbol">:run</span> <span class="comment">#相当于 command-R</span></span><br><span class="line"><span class="symbol">:make</span> <span class="comment">#相当于 command-B</span></span><br><span class="line"><span class="symbol">:xhelp</span> <span class="comment">#打开光标所在位置的快速帮助</span></span><br></pre></td></tr></table></figure></p>
<p><strong>遇到的坑</strong><br>我在 Xcode7.1 下,使用 Alcatrz 无法成功安装,找到的一个解决办法是自己下载 Xvim 在<br>GitHub 上的工程,自己编译运行一下即可安装成功,重启 Xcode 后便能生效。</p>
</blockquote>
<h1 id="SCXcodeMinimap">SCXcodeMinimap</h1><p>对于使用过 Sublime Text 的人来说,minimap 的特性一定不会陌生,<a href="https://github.com/stefanceriu/SCXcodeMiniMap">SCXcodeMiniMap</a> 就是一个这样的插件,如果你喜欢 minimap 特性一定不要错过。</p>
<h1 id="VVDocumenter-Xcode">VVDocumenter-Xcode</h1><p><a href="https://github.com/onevcat/VVDocumenter-Xcode">VVDocumenter-Xcode</a> 是人称 <a href="http://www.onevcat.com/" target="_blank" rel="external">猫神</a> 的大牛开发维护的一个快速文档注释插件,支持 OC 还有 swift。</p>
<h1 id="最后附效果图一张">最后附效果图一张</h1><p><img src="233.png" alt=""></p>]]></content>
<summary type="html">
<![CDATA[<p>在我看来,Xcode 已经是一个非常强大的IDE,而且苹果公司也一直在它添加新特性,不断的完善。即便 Xcode 已经足够强大了,但是总会有人觉得它不够好,或者想要给它做一些个性化的配置。如果你也有这样的想法的话,那么给 Xcode 安装第三方插件,或者自己给它写插件就是你的不二选择了。</p>]]>
</summary>
<category term="Alcatraz" scheme="https://github.com/sillyplus/tags/Alcatraz/"/>
<category term="Plugins" scheme="https://github.com/sillyplus/tags/Plugins/"/>
<category term="Xcode" scheme="https://github.com/sillyplus/tags/Xcode/"/>
<category term="Xvim" scheme="https://github.com/sillyplus/tags/Xvim/"/>
<category term="技术" scheme="https://github.com/sillyplus/categories/%E6%8A%80%E6%9C%AF/"/>
</entry>
<entry>
<title><![CDATA[MacTeX中的一个可用中文的方法]]></title>
<link href="https://github.com/sillyplus/2014/12/28/usingchineseinTeX/"/>
<id>https://github.com/sillyplus/2014/12/28/usingchineseinTeX/</id>
<published>2014-12-27T16:00:00.000Z</published>
<updated>2015-10-19T10:06:42.000Z</updated>
<content type="html"><![CDATA[<pre><code><span class="comment"><figure class="highlight tex"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">%!TEX TS-program = xelatex</span></span><br><span class="line"><span class="comment">%!TEX encoding = UTF-8 Unicode</span></span><br><span class="line"></span><br><span class="line"><span class="command">\documentclass</span><span class="special">[</span>12pt, a4paper<span class="special">]</span><span class="special">{</span>book<span class="special">}</span></span><br><span class="line"><span class="command">\usepackage</span><span class="special">{</span>extsizes<span class="special">}</span> <span class="comment">%使用自定义字号</span></span><br><span class="line"><span class="command">\usepackage</span><span class="special">{</span>fontspec<span class="special">}</span> <span class="comment">%字体控制包</span></span><br><span class="line"><span class="command">\usepackage</span><span class="special">{</span>xltxtra<span class="special">}</span></span><br><span class="line"><span class="command">\usepackage</span><span class="special">{</span>xunicode<span class="special">}</span> <span class="comment">%Unicode</span></span><br><span class="line"><span class="command">\usepackage</span><span class="special">{</span>indentfirst<span class="special">}</span> <span class="comment">%中文行首缩进</span></span><br><span class="line"><span class="command">\defaultfontfeatures</span><span class="special">{</span>Mapping=tex-text<span class="special">}</span></span><br><span class="line"><span class="command">\setromanfont</span><span class="special">{</span>Yuanti SC<span class="special">}</span> <span class="comment">%设置中文字体</span></span><br><span class="line"><span class="command">\XeTeXlinebreaklocale</span> “zh”</span><br><span class="line"><span class="command">\XeTeXlinebreakskip</span> =<span class="number"> 0pt</span> plus 1pt minus 0.1pt <span class="comment">%文章内中文自动换行</span></span><br><span class="line"></span><br><span class="line"><span class="command">\newfontfamily</span><span class="special">{</span><span class="command">\H</span><span class="special">}</span><span class="special">{</span>STSong<span class="special">}</span></span><br><span class="line"><span class="command">\newfontfamily</span><span class="special">{</span><span class="command">\E</span><span class="special">}</span><span class="special">{</span>Zapfino<span class="special">}</span></span><br></pre></td></tr></table></figure></span>
</code></pre><p>TeX可以使用的字体大小默认为10pt|11pt|13pt,可以通过使用extsizes这个package来使<br>用其它大小的字体,可选的类型有8~12, 14, 17 和 20pt。</p>
]]></content>
<summary type="html">
<![CDATA[<pre><code><span class="comment"><figure class="highlight tex"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class]]>
</summary>
<category term="MacTeX" scheme="https://github.com/sillyplus/tags/MacTeX/"/>
<category term="技术" scheme="https://github.com/sillyplus/categories/%E6%8A%80%E6%9C%AF/"/>
</entry>
<entry>
<title><![CDATA[Floyd算法求最小环]]></title>
<link href="https://github.com/sillyplus/2014/11/04/floyd-and-mincircle/"/>
<id>https://github.com/sillyplus/2014/11/04/floyd-and-mincircle/</id>
<published>2014-11-03T16:00:00.000Z</published>
<updated>2015-10-26T01:55:10.000Z</updated>
<content type="html"><![CDATA[<h2 id="算法思想">算法思想</h2><p>对于构成最小环的点集{x1, x2, …},其中必定存在一个最大点xk,那么最小环的长度可以由<code>dis[i][j]+m[j][xk]+m[xk][i]</code>来表示,其中i,j均在点集中且小于xk,dis[i][j]是i到j的最短路径。因为xk是点集中最大的那个点,所以i到j的最短路径没有经过编号比xk更大的点。那么要求最小环的长度就可以由小到大枚举一下xk就行了。我们知道,floyd算法最外层每循环一次,就是由一个中间节点k更新点i到j的最短路径。k从小到大枚举,就保证了循环到k的时候,当前i到j的最短路经过的最大节点只可能是k,这刚好满足上面提到的dis[i][j]的定义。所以我们就可以愉快的使用floyd来求最小环了。</p>
<a id="more"></a>
<h2 id="例题">例题</h2><h3 id="vijos_P1046_观光旅游">vijos P1046 观光旅游</h3><p>很裸的描述了,直接求最小环就好了。</p>
<h3 id="Timus_1004-_Sightseeing_Trip">Timus 1004. Sightseeing Trip</h3><p>同上,不过要注意的就是,这个题目要求最小环的路径。</p>
<figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br><span class="line">63</span><br><span class="line">64</span><br><span class="line">65</span><br><span class="line">66</span><br><span class="line">67</span><br><span class="line">68</span><br><span class="line">69</span><br><span class="line">70</span><br><span class="line">71</span><br><span class="line">72</span><br><span class="line">73</span><br></pre></td><td class="code"><pre><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstdio></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstring></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><algorithm></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cmath></span></span></span><br><span class="line"></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><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> MN = <span class="number">110</span>;</span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> INF = <span class="number">1e8</span>;</span><br><span class="line"></span><br><span class="line"><span class="keyword">int</span> n, m, num, ans;</span><br><span class="line"><span class="keyword">int</span> mp[MN][MN], dis[MN][MN], pre[MN][MN];</span><br><span class="line"><span class="keyword">int</span> path[MN];</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">get_path</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> (pre[a][b]) {</span><br><span class="line"> get_path(a, pre[a][b]);</span><br><span class="line"> get_path(pre[a][b], b);</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> path[num++] = a;</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="keyword">while</span> (<span class="built_in">scanf</span>(<span class="string">"%d"</span>, &n) && (n != -<span class="number">1</span>)) {</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%d"</span>, &m);</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 <= n; j++) {</span><br><span class="line"> mp[i][j] = INF;</span><br><span class="line"> dis[i][j] = INF;</span><br><span class="line"> pre[i][j] = <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">int</span> a, b, l;</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 class="built_in">scanf</span>(<span class="string">"%d%d%d"</span>, &a, &b, &l);</span><br><span class="line"> mp[a][b] = min(mp[a][b], l);</span><br><span class="line"> mp[b][a] = dis[a][b] = dis[b][a] = mp[a][b];</span><br><span class="line"> }</span><br><span class="line"> ans = INF;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> k = <span class="number">1</span>; k <= n; k++) {</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">1</span>; i < k; i++)</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> j = i+<span class="number">1</span>; j < k; j++) {</span><br><span class="line"> <span class="keyword">int</span> tmp = dis[i][j] + mp[j][k] + mp[k][i];</span><br><span class="line"> <span class="keyword">if</span> (tmp < ans) {</span><br><span class="line"> ans = tmp;</span><br><span class="line"> num = <span class="number">0</span>;</span><br><span class="line"> get_path(i, j);</span><br><span class="line"> path[num++] = j;</span><br><span class="line"> path[num++] = k;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"></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"> <span class="keyword">for</span> (<span class="keyword">int</span> j = <span class="number">1</span>; j <= n; j++) {</span><br><span class="line"> <span class="keyword">int</span> tmp = dis[i][k] + dis[k][j];</span><br><span class="line"> <span class="keyword">if</span> (dis[i][j] > tmp) {</span><br><span class="line"> dis[i][j] = tmp;</span><br><span class="line"> pre[i][j] = k;</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> (ans == INF) {</span><br><span class="line"> <span class="built_in">cout</span> << <span class="string">"No solution."</span> << endl;</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i < num; i++)</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%d "</span>, path[i]);</span><br><span class="line"> <span class="built_in">cout</span> << endl;</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>
<summary type="html">
<![CDATA[<h2 id="算法思想">算法思想</h2><p>对于构成最小环的点集{x1, x2, …},其中必定存在一个最大点xk,那么最小环的长度可以由<code>dis[i][j]+m[j][xk]+m[xk][i]</code>来表示,其中i,j均在点集中且小于xk,dis[i][j]是i到j的最短路径。因为xk是点集中最大的那个点,所以i到j的最短路径没有经过编号比xk更大的点。那么要求最小环的长度就可以由小到大枚举一下xk就行了。我们知道,floyd算法最外层每循环一次,就是由一个中间节点k更新点i到j的最短路径。k从小到大枚举,就保证了循环到k的时候,当前i到j的最短路经过的最大节点只可能是k,这刚好满足上面提到的dis[i][j]的定义。所以我们就可以愉快的使用floyd来求最小环了。</p>]]>
</summary>
<category term="Timus" scheme="https://github.com/sillyplus/tags/Timus/"/>
<category term="题解" scheme="https://github.com/sillyplus/categories/%E9%A2%98%E8%A7%A3/"/>
</entry>
<entry>
<title><![CDATA[Github Page + Jekyll 博客搭建小记]]></title>
<link href="https://github.com/sillyplus/2014/10/12/github-jekyll-build-a-blog/"/>
<id>https://github.com/sillyplus/2014/10/12/github-jekyll-build-a-blog/</id>
<published>2014-10-11T16:00:00.000Z</published>
<updated>2015-10-19T10:12:12.000Z</updated>
<content type="html"><![CDATA[<h3 id="占位扯淡"><del>占位扯淡</del></h3><p><del>折腾了几天,终于可以坐下来写点总结了。不过现在是早上三点多快四点,还在想六七点的时候要去踢球,所以只是<br>占个位置而已,熟悉一下。毕竟还有很多东西不会,不过光是搭好现在这个样子就用了挺多时间的(其实也不是很多啦。。。)</del></p>
<a id="more"></a>
<h3 id="博客搭建">博客搭建</h3><h4 id="(ー_ー;)">(ー ー;)</h4><p>从搭好这个blog到现在已经好几天了,然后今天发现已经没有来写这样一篇介绍的热情了。。。原因是,介绍这个方面的内容在网上很容易就能找到许多,<br>所以似乎没有必要重复说明,但是每个人的搭建过程都多少还是会遇到各种不同的问题。这里我打算来记录一下我遇到的一些问题吧。</p>
<p>以下这些我都是Mac下做的,因为OS X是类UNIX系统,所以很多都是基本跟Linux下一样的,如果你在搭建过程中遇到什么问题没办法解决,<br>可以尝试在搜索的时候添加跟Linux相关的关键字。</p>
<h4 id="Github_Page的设置">Github Page的设置</h4><p>首先你要有一个Github的账号<del>,这不废话嘛</del>,然后进入这个页面:<a href="https://pages.github.com" target="_blank" rel="external">Github Page</a>,<br>Github Page有两种类型,一种是个人或者组织的站点,一种是作为项目的主页,因为我们是要搭建个人博客,<br>所以选择创建一个User site就好了,然后就是按照引导就能十分轻松的成功创建了。最后把repo存到本地来,<br>另外说一下我用的是Mac的客户端来管理repo的,不是用的命令行,所以对于git的那些命令就不是很清楚了,<br>如果你想了解更多请自行Google。Github Page使用的是Jekyll模版系统,相当于是静态页面发布。</p>
<h4 id="Jekyll的设置">Jekyll的设置</h4><p>这个也是很简单的啊,还是直接看<a href="http://jekyllrb.com/docs/quickstart/" target="_blank" rel="external">官网</a>。我貌似是用brew安装的,<br>不过没差啦。至于怎么使用还是看官网的说明好了(感觉会被喷:什么都说去看官方文档,她喵的我还看你博客干嘛。。。)</p>
<p>在terminal中,进入到你自己本地那个Github Page的repo,然后执行下面的命令创建</p>
<pre><code><span class="title">jekyll</span> build
</code></pre><p>创建成功的话,会得到类似如下的目录结构</p>
<pre><code>.
├── _config.yml
├── _drafts
<span class="string">| ├── begin-with-the-crazy-ideas.textile</span>
<span class="string">| └── on-simplicity-in-technology.markdown</span>
├── _includes
<span class="string">| ├── footer.html</span>
<span class="string">| └── header.html</span>
├── _layouts
<span class="string">| ├── default.html</span>
<span class="string">| └── post.html</span>
├── _posts
<span class="string">| ├── 2007-10-29-why-every-programmer-should-play-nethack.textile</span>
<span class="string">| └── 2009-04-26-barcamp-boston-4-roundup.textile</span>
├── _data
<span class="string">| └── members.yml</span>
├── _site
└── index.html
</code></pre><p>然后启用本地服务器只需进入到上面的目录中,执行</p>
<pre><code><span class="title">jekyll</span> serve
</code></pre><p>就能在浏览器打开</p>
<pre><code><span class="string">http:</span><span class="comment">//localhost:4000</span>
</code></pre><p>jekyll更多的使用方法可以查看官方说明或者在终端中输入</p>
<pre><code>jekyll <span class="comment">--help</span>
</code></pre><p>在Github上你可以找到许多Jekyll博客的模版,而且其中绝大部分都是你能直接使用的,我也是使用的别人的模版进行简单的修改,<br>如果对这个模版有兴趣,可以进入的我的<a href="https://github.com/Sillyplus">Github主页</a>查看。</p>
<p>现在你就可以愉快的写作啦~\(^o^)/</p>
<h3 id="wordpress博客迁移">wordpress博客迁移</h3><p>接下来的内容多半是我的吐槽,如果你赶时间去写博客的话可以忽略,如果你实在闲得发慌,不介意的话可以看一看,<br>说不定能发现一点有用的内容。</p>
<p>本来打算顺便说一下域名绑定的,但我在这方面花费的时间比较长主要是自己的问题,绑定之后居然要一整天才能生效,<br>不清楚这个的我也被纠结了很久啦。既然是这样的话,我们就直接进入主题啦~</p>
<p>我之前使用的是wordpress,虽然我已经尽可能的选择一些简单的工具来使用,但是我发现,一堆要维护的东西搞得自己都没办法只是专注于内容了。<br>这也是我为什么决定转到这边来啦,现在直接使用Atom编辑markdown文档,用这种方式来写博文体验真的很好( ̄▽ ̄)。<br>虽然原本的博客内容不多,但还是想要把它们搬到这边来,所以在wordpress里导出了所有博文。导出的是xml的文件,<br>然后使用<a href="https://github.com/thomasf/exitwp">exitwp</a>来从xml文件中提取出内容,并转换成markdown的文档。<br>使用方法看作者的说明就好了,另外,我在运行exitwp.py的时候提示出错</p>
<pre><code>Traceback (most recent <span class="operator"><span class="keyword">call</span> <span class="keyword">last</span>):
<span class="keyword">File</span> <span class="string">"exitwp.py"</span>, line <span class="number">11</span>, <span class="keyword">in</span> <<span class="keyword">module</span>>
<span class="keyword">from</span> bs4 <span class="keyword">import</span> BeautifulSoup
ImportError: <span class="keyword">No</span> <span class="keyword">module</span> named bs4</span>
</code></pre><p>然后我在pip list中发现我装的直接是BeautifulSoup,并没有bs4,所以我exitwp.py中的</p>
<pre><code><span class="label">from</span> <span class="keyword">bs4 </span><span class="preprocessor">import</span> <span class="keyword">BeautifulSoup</span>
</code></pre><p>直接改为</p>
<pre><code><span class="preprocessor"><span class="keyword">import</span> BeautifulSoup</span>
</code></pre><p>然后就能成功运行了,这样就导出成功了。如果你对python比较熟悉,你也可以自己修改exitwp.py,使它特定导出你想要的内容。<br>如果你想要从其它博客系统迁移博客过来的话,jekyll的官网上貌似也有相关的教程说明。</p>
]]></content>
<summary type="html">
<![CDATA[<h3 id="占位扯淡"><del>占位扯淡</h3><p><del>折腾了几天,终于可以坐下来写点总结了。不过现在是早上三点多快四点,还在想六七点的时候要去踢球,所以只是<br>占个位置而已,熟悉一下。毕竟还有很多东西不会,不过光是搭好现在这个样子就用了挺多时间的(其实也不是很多啦。。。)</p>]]>
</summary>
<category term="Github" scheme="https://github.com/sillyplus/tags/Github/"/>
<category term="Jekyll" scheme="https://github.com/sillyplus/tags/Jekyll/"/>
<category term="OSX" scheme="https://github.com/sillyplus/tags/OSX/"/>
<category term="python" scheme="https://github.com/sillyplus/tags/python/"/>
<category term="技术" scheme="https://github.com/sillyplus/categories/%E6%8A%80%E6%9C%AF/"/>
</entry>
<entry>
<title><![CDATA[Tyvj_P1143 - 飘飘乎居士的约会]]></title>
<link href="https://github.com/sillyplus/2014/07/25/tyvj-p1143/"/>
<id>https://github.com/sillyplus/2014/07/25/tyvj-p1143/</id>
<published>2014-07-25T00:40:48.000Z</published>
<updated>2015-10-19T11:47:38.000Z</updated>
<content type="html"><![CDATA[<p>背景 Background</p>
<p>一阵狂风吹过<br>只听“pong”的一声,飘飘乎居士降落了!!!<br>描述 Description</p>
<p>又是美妙的一天,这天飘飘乎居士要和MM约会,因此他打扮的格外帅气。但是,因为打扮的时间花了太久,离约会的时间已经所剩无几。<br>幸运的是,现在飘飘乎居士得到了一张n<em>m的地图,图中左上角是飘飘乎居士的位置,右下角是约会的地点。‘.’代表马路,‘</em>’代表房屋。飘飘乎居士只能沿着‘.’行走(也就是不能踏入‘<em>’),而且行走的方向只能为上下左右的相邻格子。为了不让MM等待太久,飘飘乎居士在整个过程中可能会使用一次飘飘神功(也可能不使用,但最多使用一次),使用飘飘神功后,飘飘乎居士可以走进房屋一次(也就是在全程的行走中最多可以走一个‘</em>’,注意,只有一个);<br>现在飘飘乎居士想要知道最少需要走多少步,飘飘乎居士才能到达约会的地点。<br><a id="more"></a></p>
<p>输入格式 InputFormat</p>
<p>第一行,2个正整数 n和m,表示一个n<em>m的矩阵<br>接下来n行,每行m个字符,字符一定为 ’.’ 或者是‘</em>’ ,分别代表马路和房屋。<br>输入数据保证左上角和右下角都为‘.’<br>输出格式 OutputFormat</p>
<p>一行,如果可以到达,则输入需要行走的最少步数(飘飘神功也记为一步)<br>如果不可以到达,则输出‘no’<br>样例输入 SampleInput [复制数据]</p>
<p>样例输入1<br>3 3<br>.*.<br>…<br>…</p>
<p>样例输入2<br>3 3<br>.**</p>
<hr>
<p>**.<br>样例输出 SampleOutput [复制数据]</p>
<p>样例输入1<br>4</p>
<p>样例输入2<br>no<br>数据范围和注释 Hint</p>
<p>0<N M <=1000<br>来源 Source</p>
<p>飘飘乎居士——violet hill</p>
<p>//————————————————————–</p>
<p>这道我的做法是分别由起点和终点开始,做两遍bfs,求出各自到其它点的最短距离,然后枚举使用飘飘神功的点,如果起点和终点都可以到达与该点相连并且相异的点就更新一下答案</p>
<figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br><span class="line">63</span><br><span class="line">64</span><br><span class="line">65</span><br><span class="line">66</span><br><span class="line">67</span><br><span class="line">68</span><br><span class="line">69</span><br><span class="line">70</span><br><span class="line">71</span><br><span class="line">72</span><br><span class="line">73</span><br><span class="line">74</span><br><span class="line">75</span><br><span class="line">76</span><br><span class="line">77</span><br><span class="line">78</span><br><span class="line">79</span><br><span class="line">80</span><br><span class="line">81</span><br><span class="line">82</span><br><span class="line">83</span><br><span class="line">84</span><br><span class="line">85</span><br><span class="line">86</span><br><span class="line">87</span><br><span class="line">88</span><br></pre></td><td class="code"><pre><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cmath></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstring></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><queue></span></span></span><br><span class="line"></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><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> MN = <span class="number">1010</span>;</span><br><span class="line"></span><br><span class="line"><span class="keyword">struct</span> pos{</span><br><span class="line"> <span class="keyword">int</span> x, y, deep;</span><br><span class="line">};</span><br><span class="line"></span><br><span class="line"><span class="built_in">queue</span><pos> q;</span><br><span class="line"></span><br><span class="line"><span class="keyword">bool</span> vis[MN][MN];</span><br><span class="line"><span class="keyword">int</span> a[MN][MN], b[MN][MN];</span><br><span class="line"><span class="keyword">char</span> c[MN][MN];</span><br><span class="line"><span class="keyword">int</span> n, m;</span><br><span class="line"><span class="keyword">int</span> dx[] = {<span class="number">0</span>, -<span class="number">1</span>, <span class="number">0</span>, <span class="number">1</span>};</span><br><span class="line"><span class="keyword">int</span> dy[] = {-<span class="number">1</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">0</span>};</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">bool</span> <span class="title">check</span><span class="params">(pos t)</span> </span>{</span><br><span class="line"> <span class="keyword">bool</span> ret = (t.x >= <span class="number">0</span> && t.y >= <span class="number">0</span> && t.x < n && t.y < m);</span><br><span class="line"> <span class="keyword">if</span> (ret) {</span><br><span class="line"> <span class="keyword">if</span> (vis[t.x][t.y] || (c[t.x][t.y] == <span class="string">'*'</span>)) ret = <span class="literal">false</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><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">bfs</span><span class="params">(pos sr, <span class="keyword">int</span> d[][MN])</span> </span>{</span><br><span class="line"> <span class="built_in">memset</span>(vis, <span class="literal">false</span>, <span class="keyword">sizeof</span>(vis));</span><br><span class="line"> <span class="keyword">while</span> (!q.empty()) q.pop();</span><br><span class="line"> q.push(sr);</span><br><span class="line"> vis[sr.x][sr.y] = <span class="literal">true</span>;</span><br><span class="line"> d[sr.x][sr.y] = sr.deep;</span><br><span class="line"> <span class="keyword">while</span> (!q.empty()) {</span><br><span class="line"> pos now, next;</span><br><span class="line"> now = q.front();</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">4</span>; i++) {</span><br><span class="line"> next.x = now.x + dx[i];</span><br><span class="line"> next.y = now.y + dy[i];</span><br><span class="line"> <span class="keyword">if</span> (check(next)) {</span><br><span class="line"> next.deep = now.deep+<span class="number">1</span>;</span><br><span class="line"> d[next.x][next.y] = next.deep;</span><br><span class="line"> q.push(next);</span><br><span class="line"> vis[next.x][next.y] = <span class="literal">true</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> q.pop();</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="built_in">cin</span> >> n >> m;</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="built_in">cin</span> >> c[i];</span><br><span class="line"> <span class="built_in">memset</span>(a, <span class="number">63</span>, <span class="keyword">sizeof</span>(a));</span><br><span class="line"> <span class="built_in">memset</span>(b, <span class="number">63</span>, <span class="keyword">sizeof</span>(b));</span><br><span class="line"> <span class="keyword">int</span> INF = a[<span class="number">0</span>][<span class="number">0</span>]; <span class="comment">//!!!!!!</span></span><br><span class="line"> pos sro, orz, l, r;</span><br><span class="line"> sro.x = sro.y = sro.deep = <span class="number">0</span>;</span><br><span class="line"> orz.x = n-<span class="number">1</span>, orz.y = m-<span class="number">1</span>, orz.deep = <span class="number">0</span>;</span><br><span class="line"> bfs(sro, a);</span><br><span class="line"> bfs(orz, b);</span><br><span class="line"> <span class="keyword">int</span> ans = INF;</span><br><span class="line"> ans = min(ans, a[n-<span class="number">1</span>][m-<span class="number">1</span>]);</span><br><span class="line"> <span class="built_in">memset</span>(vis, <span class="literal">false</span>, <span class="keyword">sizeof</span>(vis));</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 class="keyword">if</span> (c[i][j] == <span class="string">'*'</span>) {</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> p = <span class="number">0</span>; p < <span class="number">4</span>; p++) {</span><br><span class="line"> l.x = i+dx[p], l.y = j+dy[p];</span><br><span class="line"> <span class="keyword">if</span> (check(l))</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> q = <span class="number">0</span>; q < <span class="number">4</span>; q++) <span class="keyword">if</span> (p != q) {</span><br><span class="line"> r.x = i+dx[q], r.y = j+dy[q];</span><br><span class="line"> <span class="keyword">if</span> (check(r)) {</span><br><span class="line"> ans = min(ans, a[l.x][l.y]+b[r.x][r.y]+<span class="number">2</span>);</span><br><span class="line"> }</span><br><span class="line"> }</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> (ans != INF)</span><br><span class="line"> <span class="built_in">cout</span> << ans << endl;</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> <span class="built_in">cout</span> << <span class="string">"no"</span> << endl;</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>
<summary type="html">
<![CDATA[<p>背景 Background</p>
<p>一阵狂风吹过<br>只听“pong”的一声,飘飘乎居士降落了!!!<br>描述 Description</p>
<p>又是美妙的一天,这天飘飘乎居士要和MM约会,因此他打扮的格外帅气。但是,因为打扮的时间花了太久,离约会的时间已经所剩无几。<br>幸运的是,现在飘飘乎居士得到了一张n<em>m的地图,图中左上角是飘飘乎居士的位置,右下角是约会的地点。‘.’代表马路,‘</em>’代表房屋。飘飘乎居士只能沿着‘.’行走(也就是不能踏入‘<em>’),而且行走的方向只能为上下左右的相邻格子。为了不让MM等待太久,飘飘乎居士在整个过程中可能会使用一次飘飘神功(也可能不使用,但最多使用一次),使用飘飘神功后,飘飘乎居士可以走进房屋一次(也就是在全程的行走中最多可以走一个‘</em>’,注意,只有一个);<br>现在飘飘乎居士想要知道最少需要走多少步,飘飘乎居士才能到达约会的地点。<br>]]>
</summary>
<category term="BFS" scheme="https://github.com/sillyplus/tags/BFS/"/>
<category term="Tyvj" scheme="https://github.com/sillyplus/tags/Tyvj/"/>
<category term="题解" scheme="https://github.com/sillyplus/categories/%E9%A2%98%E8%A7%A3/"/>
</entry>
<entry>
<title><![CDATA[Tyvj_P1309_刷题的玖君]]></title>
<link href="https://github.com/sillyplus/2014/07/16/tyvj_p1309/"/>
<id>https://github.com/sillyplus/2014/07/16/tyvj_p1309/</id>
<published>2014-07-16T06:40:33.000Z</published>
<updated>2015-10-19T11:47:32.000Z</updated>
<content type="html"><![CDATA[<p>描述 Description</p>
<p>某一天在网上闲逛的玖君不小心发现了TYVJ,就立刻被TYVJ吸引住了,果断驻扎下来。玖君决定按照顺序来切题,因为离复赛越来越近了,所以他希望能够用最短时间AC掉前面N道题目,完成第i道题目玖君需要花费t[i]个单位的代价。玖君做题有个特点,他喜欢看完几道题后,一次把几道题的代码写完。如果玖君决定一次写完从编号L到编号R的题目,那么他完成这些题目的总代价等于编号L到R题目的代价之和与R之积,即SUM{t[L..R]} <em>R。此外每道题在被切之前都会等待被切,等待的时间,也被算在代价里面,对于每个第k次被切的题,在它被切之前的等待代价为(k-1)</em>S。综上,切完N道题的总代价=第1次切题的代价+第2次切题的代价+…+第k次切题的代价+每道题的等待代价。现在我们想知道玖君切完这N道题目的最小代价。<br><a id="more"></a><br>输入格式 InputFormat</p>
<p>第1行:2个用空格分开的整数N, S<br>第2行:N个用空格分开的整数,分别表示t[1]到t[N]<br>输出格式 OutputFormat</p>
<p>第1行:1个整数,表示玖君完成N道题的最小代价<br>样例输入 SampleInput [复制数据]</p>
<p>4 7<br>8 1 7 6<br>样例输出 SampleOutput [复制数据]</p>
<p>79<br>数据范围和注释 Hint</p>
<p>[样例解释]<br>第1次切1、2、3题:代价为48<br>第2次切4题:代价为24<br>其中每道题的等待时间代价为:0,0,0,7<br>共计48 + 24 + 7 = 79</p>
<p>[数据范围]<br>对于70%的数据,1 <= N <= 3000<br>对于100%的数据,1 <= N <= 30000<br>对于100%的数据,1 <= S,t[i] <= 100</p>
<p>Dp,然后先求前缀和数组,方便后面用到,设f[i]表示刷完前i个题所花费的最小代价,然后一个比较容易想到的方程就是</p>
<ul>
<li>f[i]=min{f[j]+(sum[i]-sum[j])<em>i+(n-i)</em>S|0<=j<i} //shiugaosuyixiawo(n-i)*sshisuanfeiyongtiqianjisuanma?</li>
</ul>
<p>然后这个显然当N=30000时是不行的,会T,然后就发现,设用k更新i比用j更优,则</p>
<ul>
<li>f[k] + (sum[i]-sum[k]) <em> i + (n-i)</em>s >=f[j] + (sum[i]-sum[j]) <em> i + (n-i)</em>s</li>
</ul>
<ul>
<li>(f[k]-f[j])/(sum[k]-sum[j])<=i</li>
</ul>
<p>当满足这个条件时,k优于j ,然后就维护一个队列就行了,这个是所谓的斜率优化?还是得好好消化啊,dp水平太次了我。。。</p>
<figure class="highlight perl"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">#include <iostream></span></span><br><span class="line"><span class="comment">#include <cstdio></span></span><br><span class="line"><span class="comment">#include <cmath></span></span><br><span class="line"></span><br><span class="line">using namespace std;</span><br><span class="line"></span><br><span class="line">typedef long long LL;</span><br><span class="line"></span><br><span class="line">const <span class="keyword">int</span> MN = <span class="number">30010</span>;</span><br><span class="line"></span><br><span class="line">LL n, <span class="keyword">s</span>;</span><br><span class="line">LL f[MN];</span><br><span class="line">LL sum[MN];</span><br><span class="line"><span class="keyword">int</span> <span class="string">q[MN]</span>;</span><br><span class="line"></span><br><span class="line">double grad(<span class="keyword">int</span> j, <span class="keyword">int</span> k) {</span><br><span class="line"> <span class="keyword">return</span> ((f[k]-f[j])*<span class="number">1.0</span> / (sum[k]-sum[j]));</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="keyword">int</span> main() {</span><br><span class="line"> cin >> n >> <span class="keyword">s</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"> scanf(<span class="string">"<span class="variable">%lld</span>"</span>, &sum[i]);</span><br><span class="line"> sum[i] += sum[i-<span class="number">1</span>];</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">int</span> h = <span class="number">1</span>, t = <span class="number">1</span>;</span><br><span class="line"> f[<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">1</span>; i <= n; i++) {</span><br><span class="line"> <span class="keyword">while</span> ((h < t) && (grad(<span class="string">q[h]</span>, <span class="string">q[h+1]</span>) <= i)) ++h;</span><br><span class="line"> f[i] = f[<span class="string">q[h]</span>] + (sum[i]-sum[<span class="string">q[h]</span>])*i + (n-i)*<span class="keyword">s</span>;</span><br><span class="line"> <span class="keyword">while</span> ((h < t) && (grad(<span class="string">q[t-1]</span>, <span class="string">q[t]</span>) >= grad(<span class="string">q[t]</span>, i))) --t;</span><br><span class="line"> <span class="string">q[++t]</span> = i;</span><br><span class="line"> }</span><br><span class="line"> cout << f[n] << endl;</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>
<summary type="html">
<![CDATA[<p>描述 Description</p>
<p>某一天在网上闲逛的玖君不小心发现了TYVJ,就立刻被TYVJ吸引住了,果断驻扎下来。玖君决定按照顺序来切题,因为离复赛越来越近了,所以他希望能够用最短时间AC掉前面N道题目,完成第i道题目玖君需要花费t[i]个单位的代价。玖君做题有个特点,他喜欢看完几道题后,一次把几道题的代码写完。如果玖君决定一次写完从编号L到编号R的题目,那么他完成这些题目的总代价等于编号L到R题目的代价之和与R之积,即SUM{t[L..R]} <em>R。此外每道题在被切之前都会等待被切,等待的时间,也被算在代价里面,对于每个第k次被切的题,在它被切之前的等待代价为(k-1)</em>S。综上,切完N道题的总代价=第1次切题的代价+第2次切题的代价+…+第k次切题的代价+每道题的等待代价。现在我们想知道玖君切完这N道题目的最小代价。<br>]]>
</summary>
<category term="DP" scheme="https://github.com/sillyplus/tags/DP/"/>
<category term="Tyvj" scheme="https://github.com/sillyplus/tags/Tyvj/"/>
<category term="题解" scheme="https://github.com/sillyplus/categories/%E9%A2%98%E8%A7%A3/"/>
</entry>
<entry>
<title><![CDATA[Tyvj_P1064_P1404_旧题]]></title>
<link href="https://github.com/sillyplus/2014/07/16/tyvj_p1064_p1404/"/>
<id>https://github.com/sillyplus/2014/07/16/tyvj_p1064_p1404/</id>
<published>2014-07-16T02:20:15.000Z</published>
<updated>2015-10-19T11:47:26.000Z</updated>
<content type="html"><![CDATA[<p>这两道题都是从我开始接触tyvj的时候就看过的,可是一直没去写,今天终于。。。</p>
<p>P1064 - 新三国争霸</p>
<p>描述 Description<br>PP 特别喜欢玩即时战略类游戏,但他觉得那些游戏都有美中不足的地方。灾害总不降临道路,而只降临城市,而且道路不能被占领,没有保护粮草的真实性。于是他就研发了《新三国争霸》。<br>在这款游戏中,加入灾害对道路的影响(也就是一旦道路W[i,j]受到了灾害的影响,那么在一定时间内,这条路将不能通过)和道路的占领权(对于一条道路W[i,j],至少需要K[i,j]个士兵才能守住)。<br>PP可真是高手,不一会,就攻下了N-1座城市,加上原来的就有N座城市了,但他忽略了一点……那就是防守同样重要,不过现在还来的及。因为才打完仗所以很多城市都需要建设,PP估算了一下,大概需要T天。他现在无暇分身进攻了,只好在这T天内好好的搞建设了。所以他秒要派士兵占领一些道路,以确保任何两个城市之间都有路(不然敌人就要分而攻之了,是很危险的)。士兵可不是白干活的,每个士兵每天都要吃掉V的军粮。因为有灾害,所以方案可能有变化(每改变一次就需要K的军粮,初始方案也需要K的军粮)。<br>因为游戏是PP编的,所以他知道什么时候有灾害。PP可是一个很节约的人,他希望这T天在道路的防守上花最少的军粮。<br>N<=300,M<=5000 ,T<=50;<br><a id="more"></a><br>输入格式 InputFormat<br>第一行有5个整数N,M,T,V,K。N表示有城市数,M表示道路数,T表示需要修养的天数,V表示每个士兵每天吃掉的军粮数,K表示修改一次花掉的军粮数。<br>以下M行,每行3个数A,B,C。表示A与B有一条路(路是双向的)需要C个士兵才能守住。<br>第M+2行是一个数P,表示有P个灾害。<br>以下P行,每行4个数,X,Y,T1,T2。表示X到Y的这条路,在T1到T2这几天都会受灾害。</p>
<p>输出格式 OutputFormat<br>T天在道路的防守上花费最少的军粮。</p>
<p>样例输入 SampleInput [复制数据]<br>3 3 5 10 30<br>1 2 1<br>2 3 2<br>1 3 4<br>1<br>1 3 2 5<br>样例输出 SampleOutput [复制数据]<br>180<br>个人感觉一道不错的动态规划题吧,一直不敢下手写,写完真是心旷神怡啊~~<br>设F[i]表示前i天的最少花费,则有<br>F[i] = min(F[i], F[j-1] + mt<em>(i-j+1)</em>v+k)<br>其中,mt表示第j天到第i天的最少花费,也就是在第j天到第i天可通行的道路求一遍最小生成树,一开始我是认为必须在第j天到第i天均不能通行的才不用排兵去收,不过事实好像是只要这期间道路遭遇灾害就可以不用派兵把守了。还是说是我没读懂题意</p>
<figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br><span class="line">63</span><br><span class="line">64</span><br><span class="line">65</span><br><span class="line">66</span><br><span class="line">67</span><br><span class="line">68</span><br><span class="line">69</span><br><span class="line">70</span><br><span class="line">71</span><br><span class="line">72</span><br><span class="line">73</span><br><span class="line">74</span><br><span class="line">75</span><br><span class="line">76</span><br></pre></td><td class="code"><pre><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cmath></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstdio></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><algorithm></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstring></span></span></span><br><span class="line"></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><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> MM = <span class="number">5050</span>;</span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> INF = <span class="number">1000000000</span>;</span><br><span class="line"></span><br><span class="line"><span class="keyword">struct</span> edge{</span><br><span class="line"> <span class="keyword">int</span> x, y, w;</span><br><span class="line"> <span class="keyword">bool</span> <span class="keyword">operator</span> < (<span class="keyword">const</span> edge & a) <span class="keyword">const</span> {</span><br><span class="line"> <span class="keyword">return</span> w < a.w;</span><br><span class="line"> }</span><br><span class="line">} e[MM];</span><br><span class="line"></span><br><span class="line"><span class="keyword">int</span> n, m, t, v, k, p;</span><br><span class="line"><span class="keyword">bool</span> can[MM], road[MM][MM];</span><br><span class="line"><span class="keyword">int</span> f[MM/<span class="number">10</span>], fa[MM];</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">getfa</span><span class="params">(<span class="keyword">int</span> x)</span> </span>{</span><br><span class="line"> <span class="keyword">return</span> (fa[x] == x ? x : fa[x] = getfa(fa[x]));</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">kruskal</span><span class="params">(<span class="keyword">int</span> t1, <span class="keyword">int</span> t2)</span> </span>{</span><br><span class="line"> <span class="built_in">memset</span>(can, <span class="literal">true</span>, <span class="keyword">sizeof</span>(can));</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">1</span>; i <= m; i++)</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> j = t1; j <= t2; j++)</span><br><span class="line"> <span class="keyword">if</span> (!road[i][j]) {</span><br><span class="line"> can[i] = <span class="literal">false</span>;</span><br><span class="line"> <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">1</span>; i <= m; i++)</span><br><span class="line"> fa[i] = i;</span><br><span class="line"> <span class="keyword">int</span> ret = <span class="number">0</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">1</span>; i <= m; i++)</span><br><span class="line"> <span class="keyword">if</span> (can[i]) {</span><br><span class="line"> <span class="keyword">int</span> f1 = getfa(e[i].x);</span><br><span class="line"> <span class="keyword">int</span> f2 = getfa(e[i].y);</span><br><span class="line"> <span class="keyword">if</span> (f1 != f2) {</span><br><span class="line"> fa[f1] = f2;</span><br><span class="line"> ret += e[i].w;</span><br><span class="line"> cnt++;</span><br><span class="line"> <span class="keyword">if</span> (cnt == n-<span class="number">1</span>)</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="keyword">return</span> INF;</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="built_in">cin</span> >> n >> m >> t >> v >> k;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">1</span>; i <= m; i++)</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%d%d%d"</span>, &e[i].x, &e[i].y, &e[i].w);</span><br><span class="line"> sort(e+<span class="number">1</span>, e+<span class="number">1</span>+m);</span><br><span class="line"> <span class="built_in">cin</span> >> p;</span><br><span class="line"> <span class="built_in">memset</span>(road, <span class="literal">true</span>, <span class="keyword">sizeof</span>(road));</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i < p; i++) {</span><br><span class="line"> <span class="keyword">int</span> x, y, t1, t2;</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%d%d%d%d"</span>, &x, &y,&t1, &t2);</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> j = <span class="number">1</span>; j <= m; j++)</span><br><span class="line"> <span class="keyword">if</span> (((e[j].x == x) && (e[j].y == y)) || ((e[j].x == y) && (e[j].y == x))) {</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> tt = t1; tt <= t2; tt++)</span><br><span class="line"> road[j][tt] = <span class="literal">false</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">1</span>; i <= t; i++)</span><br><span class="line"> f[i] = INF;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">1</span>; i <= t; i++)</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> j = <span class="number">1</span>; j <= i; j++)</span><br><span class="line"> f[i] = min(f[i], f[j-<span class="number">1</span>]+kruskal(j, i)*(i-j+<span class="number">1</span>)*v+k);</span><br><span class="line"> <span class="built_in">cout</span> << f[t] << endl;</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>P1404 - [NOIP2010]引水入城</p>
<p>noip的题目,所以网上一堆题解,所以就贴一下自己的代码就好了</p>
<p>主要就是由一个证明说某蓄水池在最后一排城市可到达的是一个连续的区间,然后就可以从第一排开始dfs求出对应区间的左右边界,然后就是一个最小区间覆盖吧,然后数据好像之后500,DP一下就行,然后好像关于最小区间覆盖的话是有一个贪心的解法。以后再想想看。</p>
<figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br><span class="line">63</span><br><span class="line">64</span><br><span class="line">65</span><br><span class="line">66</span><br><span class="line">67</span><br><span class="line">68</span><br><span class="line">69</span><br></pre></td><td class="code"><pre><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstdio></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstring></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cmath></span></span></span><br><span class="line"></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><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> MN = <span class="number">510</span>;</span><br><span class="line"></span><br><span class="line"><span class="keyword">int</span> n, m, root;</span><br><span class="line"><span class="keyword">int</span> dx[] = {<span class="number">0</span>, -<span class="number">1</span>, <span class="number">0</span>, <span class="number">1</span>};</span><br><span class="line"><span class="keyword">int</span> dy[] = {-<span class="number">1</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">0</span>};</span><br><span class="line"><span class="keyword">int</span> a[MN][MN];</span><br><span class="line"><span class="keyword">int</span> l[MN], r[MN], f[MN];</span><br><span class="line"><span class="keyword">bool</span> vis[MN][MN];</span><br><span class="line"><span class="keyword">bool</span> last[MN];</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">bool</span> <span class="title">ck</span><span class="params">(<span class="keyword">int</span> x, <span class="keyword">int</span> y)</span> </span>{</span><br><span class="line"> <span class="keyword">return</span> (x > <span class="number">0</span> && y > <span class="number">0</span> && x <= n && y <= m);</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">sc</span><span class="params">(<span class="keyword">int</span> x, <span class="keyword">int</span> y)</span> </span>{</span><br><span class="line"> vis[x][y] = <span class="literal">true</span>;</span><br><span class="line"> <span class="keyword">if</span> (x == n) {</span><br><span class="line"> last[y] = <span class="literal">true</span>;</span><br><span class="line"> l[root] = min(l[root], y);</span><br><span class="line"> r[root] = max(r[root], y);</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 < <span class="number">4</span>; i++) {</span><br><span class="line"> <span class="keyword">int</span> tx = x + dx[i];</span><br><span class="line"> <span class="keyword">int</span> ty = y + dy[i];</span><br><span class="line"> <span class="keyword">if</span> (ck(tx, ty)) {</span><br><span class="line"> <span class="keyword">if</span> ((a[x][y] > a[tx][ty]) && (!vis[tx][ty]))</span><br><span class="line"> sc(tx, ty);</span><br><span class="line"> }</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="built_in">cin</span> >> n >> m;</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"> <span class="keyword">for</span>(<span class="keyword">int</span> j = <span class="number">1</span>; j <= m; j++)</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%d"</span>, &a[i][j]);</span><br><span class="line"> <span class="built_in">memset</span>(last, <span class="literal">false</span>, <span class="keyword">sizeof</span>(last));</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i < MN; i++)</span><br><span class="line"> l[i] = MN;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">1</span>; i <= m; i++)</span><br><span class="line"> <span class="keyword">if</span> ((a[<span class="number">1</span>][i] >= a[<span class="number">1</span>][i-<span class="number">1</span>]) && (a[<span class="number">1</span>][i] >= a[<span class="number">1</span>][i+<span class="number">1</span>])) {</span><br><span class="line"> <span class="built_in">memset</span>(vis, <span class="literal">false</span>, <span class="keyword">sizeof</span>(vis));</span><br><span class="line"> root = i;</span><br><span class="line"> sc(<span class="number">1</span>, i);</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 <= m; i++)</span><br><span class="line"> <span class="keyword">if</span> (!last[i]) ans++;</span><br><span class="line"> <span class="keyword">if</span> (ans) {</span><br><span class="line"> <span class="built_in">cout</span> << <span class="number">0</span> << endl << ans << endl;</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"> f[<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">1</span>; i <= m; i++)</span><br><span class="line"> f[i] = MN;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">1</span>; i <= m; i++)</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> j = l[i]; j <= r[i]; j++)</span><br><span class="line"> f[j] = min(f[j], f[l[i]-<span class="number">1</span>] + <span class="number">1</span>);</span><br><span class="line"> <span class="built_in">cout</span> << <span class="number">1</span> << endl;</span><br><span class="line"> <span class="built_in">cout</span> << f[m] << endl;</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>
<summary type="html">
<![CDATA[<p>这两道题都是从我开始接触tyvj的时候就看过的,可是一直没去写,今天终于。。。</p>
<p>P1064 - 新三国争霸</p>
<p>描述 Description<br>PP 特别喜欢玩即时战略类游戏,但他觉得那些游戏都有美中不足的地方。灾害总不降临道路,而只降临城市,而且道路不能被占领,没有保护粮草的真实性。于是他就研发了《新三国争霸》。<br>在这款游戏中,加入灾害对道路的影响(也就是一旦道路W[i,j]受到了灾害的影响,那么在一定时间内,这条路将不能通过)和道路的占领权(对于一条道路W[i,j],至少需要K[i,j]个士兵才能守住)。<br>PP可真是高手,不一会,就攻下了N-1座城市,加上原来的就有N座城市了,但他忽略了一点……那就是防守同样重要,不过现在还来的及。因为才打完仗所以很多城市都需要建设,PP估算了一下,大概需要T天。他现在无暇分身进攻了,只好在这T天内好好的搞建设了。所以他秒要派士兵占领一些道路,以确保任何两个城市之间都有路(不然敌人就要分而攻之了,是很危险的)。士兵可不是白干活的,每个士兵每天都要吃掉V的军粮。因为有灾害,所以方案可能有变化(每改变一次就需要K的军粮,初始方案也需要K的军粮)。<br>因为游戏是PP编的,所以他知道什么时候有灾害。PP可是一个很节约的人,他希望这T天在道路的防守上花最少的军粮。<br>N<=300,M<=5000 ,T<=50;<br>]]>
</summary>
<category term="DFS" scheme="https://github.com/sillyplus/tags/DFS/"/>
<category term="DP" scheme="https://github.com/sillyplus/tags/DP/"/>
<category term="MST" scheme="https://github.com/sillyplus/tags/MST/"/>
<category term="Tyvj" scheme="https://github.com/sillyplus/tags/Tyvj/"/>
<category term="题解" scheme="https://github.com/sillyplus/categories/%E9%A2%98%E8%A7%A3/"/>
</entry>
<entry>
<title><![CDATA[Tyvj_P1253 - 无聊的战争]]></title>
<link href="https://github.com/sillyplus/2014/07/06/tyvj_p1253/"/>
<id>https://github.com/sillyplus/2014/07/06/tyvj_p1253/</id>
<published>2014-07-06T03:51:11.000Z</published>
<updated>2015-10-19T11:47:21.000Z</updated>
<content type="html"><![CDATA[<p>描述 Description</p>
<p>ForeverBell不仅精通破译密码,更是我军的重要代码编写者(至于什么代码,自己想吧).战争的日子是无聊的,有一天,ForeverBell找到了treeboy,出了一个极其简单的问题:给定一段序列,找出这段数列中第k小的数.<br>为了照顾treeboy的超弱语文水平,ForeverBell极其耐心地解释了这个问题:给定一个整数数列num[1…n],序列中的每个数字都不相同.你需要回答一组格式为Q(i,j,k)的查询,表示”在num[i…j]中第k小的数是多少”.<br>由于treeboy不仅语文差,而且代码能力巨弱,所以再次找到了你,请你编写一个程序,应对ForeverBell的询问.<br>输入格式 InputFormat</p>
<p>第一行两个整数n,m.分别是数列的总长度和ForeverBell询问的次数. 1≤n≤100 000,1≤m≤5 000<br>第二行有n个数,代表数列的元素,所有数都不相同,而且不会超过10^9 。<br>接下来有m行,每行三个整数i、j、k,代表一次查询,i、j、k满足:1≤i≤j≤n, 1≤k≤j-i+1。<br>输出格式 OutputFormat</p>
<p>一共m行.第i行表示第i次询问的答案.<br>样例输入 SampleInput [复制数据]</p>
<p>7 3<br>1 5 2 6 3 7 4<br>2 5 3<br>4 4 1<br>1 7 3<br>样例输出 SampleOutput [复制数据]</p>
<p>5<br>6<br>3</p>
<p>这道题算是模版题吧,看了一下说是什么划分树,不懂。。。然后就百度了一下,然后发现百度上的模版直接就能用了,然后就学习了一下,然后我打算把百度百科上的说明copy下来这里方便查阅。。。<br><a id="more"></a><br>划分树是一种基于线段树的数据结构。主要用于快速求出(在log(n)的时间复杂度内)序列区间的第k大值</p>
<h4 id="1简介"><strong>1简介</strong></h4><p>查找整序列的第k大值往往采用快速查找法。然而此方法会破坏原序列,并且需要O(n)的时间复杂度。抑或使用二叉平衡树进行维护,此方法每次查找时间复杂度仅为O(logn)。然而此方法丢失了原序列的顺序信息,无法查找出某区间内的第k大值。</p>
<p>划分树的基本思想就是对于某个区间,把它划分成两个子区间,左边区间的数小于右边区间的数。查找的时候通过记录进入左子树的数的个数,确定下一个查找区间,最后范围缩小到1,就找到了。</p>
<h4 id="2建树"><strong>2建树</strong></h4><p>建树的过程比较简单,对于区间[l,r],首先通过对原数组的排序找到这个区间的中位数a[mid],小于a[mid]的数划入他的左子树[l,mid-1],大于它的划入右子树[mid,r]。同时,对于第i个数,记录在[l,i]区间内有多少数被划入左子树。最后,对它的左子树区间[l,mid-1]和右子树区间[mid,r]递归的继续建树就可以了。<br>建树的时候要注意对于被分到同一子树的元素,元素间的相对位置不能改变。</p>
<h4 id="3查找"><strong>3查找</strong></h4><p>查找的过程中主要问题就是确定将要查找的区间。这个问题有些麻烦。</p>
<p>先看一下查找过程tree_find.他的定义如下:</p>
<p>查找深度为h,在大区间[st,ed]中找小区间[s,e]中的第k元素。<br>再看看他是如何工作的。我们的想法是,先判断[s,e]中第k元素在[st,ed]的哪个子树中,然后找出对应的小区间和k,递归的进行查找,直到小区间的s=e为止。<br>那如何解决这个问题呢?这时候前面记录的进入左子树的元素个数就派上用场了。通过之前的记录可以知道,在区间[st,s-1]中有el[h,s-1]进入左子树,记它为l。同理区间[st,e]中有el[h,e]个数进去左子树,记它为r。所以,我们知道区间小区间[s,e]中有(r-l)个数进入左子树。那么如果(r-l)>=k,那么就在左子树中继续查找,否则就在右子树中继续查找。<br>接着解决查找的小区间的问题。<br>如果接下来要查找的是左子树,那么小区间应该是[st+([st,s-1]区间进入左子树的个数),st+([st,e]区间内进入左子树的个数)-1],即区间[st+l,st+r-1]。显然,这里k不用变。<br>如果接下来要查找的是右子树,那么小区间应该是[mid+([st,s-1]区间中进入右子树的个数),mid+([st,e]区间进入右子树的个数)-1]。即区间[mid+(s-st-l),mid+(e-st-r)]。显然,这里k要减去区间里已经进入左子树的个数,即k变为k-(r-l)。<br>于是递归继续查找直到s=e即可。</p>
<figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br><span class="line">63</span><br><span class="line">64</span><br><span class="line">65</span><br><span class="line">66</span><br><span class="line">67</span><br><span class="line">68</span><br><span class="line">69</span><br><span class="line">70</span><br><span class="line">71</span><br><span class="line">72</span><br><span class="line">73</span><br></pre></td><td class="code"><pre><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstdio></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><algorithm></span></span></span><br><span class="line"></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><br><span class="line"><span class="preprocessor">#<span class="keyword">define</span> N <span class="number">100500</span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">define</span> MID ((l+r)>><span class="number">1</span>)</span></span><br><span class="line"></span><br><span class="line"><span class="keyword">int</span> a[N], s[N], t[<span class="number">20</span>][N], num[<span class="number">20</span>][N], n, m;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">Build</span><span class="params">(<span class="keyword">int</span> c, <span class="keyword">int</span> l, <span class="keyword">int</span> r)</span> </span>{</span><br><span class="line"> <span class="keyword">int</span> lm = MID-l+<span class="number">1</span>, lp = l, rp = MID+<span class="number">1</span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = l; i <= MID; i++)</span><br><span class="line"> lm -= s[i] < s[MID];</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = l; i <= r; i++) {</span><br><span class="line"> <span class="keyword">if</span> (i == l)</span><br><span class="line"> num[c][i] = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> num[c][i] = num[c][i-<span class="number">1</span>];</span><br><span class="line"> <span class="keyword">if</span> (t[c][i] == s[MID]) {</span><br><span class="line"> <span class="keyword">if</span> (lm) {</span><br><span class="line"> lm--;</span><br><span class="line"> num[c][i]++;</span><br><span class="line"> t[c+<span class="number">1</span>][lp++] = t[c][i];</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> t[c+<span class="number">1</span>][rp++] = t[c][i];</span><br><span class="line"> }</span><br><span class="line"> } <span class="keyword">else</span> <span class="keyword">if</span> (t[c][i] < s[MID]) {</span><br><span class="line"> num[c][i]++;</span><br><span class="line"> t[c+<span class="number">1</span>][lp++] = t[c][i];</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> t[c+<span class="number">1</span>][rp++] = t[c][i];</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span> (l < r) {</span><br><span class="line"> Build(c+<span class="number">1</span>, l, MID);</span><br><span class="line"> Build(c+<span class="number">1</span>, MID+<span class="number">1</span>, r);</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">Query</span><span class="params">(<span class="keyword">int</span> c, <span class="keyword">int</span> l, <span class="keyword">int</span> r, <span class="keyword">int</span> ql, <span class="keyword">int</span> qr, <span class="keyword">int</span> k)</span> </span>{</span><br><span class="line"> <span class="keyword">if</span> (l == r)</span><br><span class="line"> <span class="keyword">return</span> t[c][l];</span><br><span class="line"> <span class="keyword">int</span> s, ss;</span><br><span class="line"> <span class="keyword">if</span> (l == ql) {</span><br><span class="line"> s = <span class="number">0</span>;</span><br><span class="line"> ss = num[c][qr];</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> s = num[c][ql-<span class="number">1</span>];</span><br><span class="line"> ss = num[c][qr] - num[c][ql-<span class="number">1</span>];</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span> (k <= ss)</span><br><span class="line"> <span class="keyword">return</span> Query(c+<span class="number">1</span>, l, MID, l+s, l+s+ss-<span class="number">1</span>, k);</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> <span class="keyword">return</span> Query(c+<span class="number">1</span>, MID+<span class="number">1</span>, r, MID+<span class="number">1</span>+ql-l-s, MID+<span class="number">1</span>+qr-l-s-ss, k-ss);</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="built_in">scanf</span>(<span class="string">"%d%d"</span>, &n, &m);</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"> <span class="built_in">scanf</span>(<span class="string">"%d"</span>, &a[i]);</span><br><span class="line"> s[i] = t[<span class="number">0</span>][i] = a[i];</span><br><span class="line"> }</span><br><span class="line"> sort(s+<span class="number">1</span>, s+<span class="number">1</span>+n);</span><br><span class="line"> Build(<span class="number">0</span>, <span class="number">1</span>, n);</span><br><span class="line"> <span class="keyword">while</span> (m--) {</span><br><span class="line"> <span class="keyword">int</span> l, r, k;</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%d%d%d"</span>, &l, &r, &k);</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%d\n"</span>, Query(<span class="number">0</span>, <span class="number">1</span>, n, l, r, k));</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>
<summary type="html">
<![CDATA[<p>描述 Description</p>
<p>ForeverBell不仅精通破译密码,更是我军的重要代码编写者(至于什么代码,自己想吧).战争的日子是无聊的,有一天,ForeverBell找到了treeboy,出了一个极其简单的问题:给定一段序列,找出这段数列中第k小的数.<br>为了照顾treeboy的超弱语文水平,ForeverBell极其耐心地解释了这个问题:给定一个整数数列num[1…n],序列中的每个数字都不相同.你需要回答一组格式为Q(i,j,k)的查询,表示”在num[i…j]中第k小的数是多少”.<br>由于treeboy不仅语文差,而且代码能力巨弱,所以再次找到了你,请你编写一个程序,应对ForeverBell的询问.<br>输入格式 InputFormat</p>
<p>第一行两个整数n,m.分别是数列的总长度和ForeverBell询问的次数. 1≤n≤100 000,1≤m≤5 000<br>第二行有n个数,代表数列的元素,所有数都不相同,而且不会超过10^9 。<br>接下来有m行,每行三个整数i、j、k,代表一次查询,i、j、k满足:1≤i≤j≤n, 1≤k≤j-i+1。<br>输出格式 OutputFormat</p>
<p>一共m行.第i行表示第i次询问的答案.<br>样例输入 SampleInput [复制数据]</p>
<p>7 3<br>1 5 2 6 3 7 4<br>2 5 3<br>4 4 1<br>1 7 3<br>样例输出 SampleOutput [复制数据]</p>
<p>5<br>6<br>3</p>
<p>这道题算是模版题吧,看了一下说是什么划分树,不懂。。。然后就百度了一下,然后发现百度上的模版直接就能用了,然后就学习了一下,然后我打算把百度百科上的说明copy下来这里方便查阅。。。<br>]]>
</summary>
<category term="Tyvj" scheme="https://github.com/sillyplus/tags/Tyvj/"/>
<category term="划分树" scheme="https://github.com/sillyplus/tags/%E5%88%92%E5%88%86%E6%A0%91/"/>
<category term="题解" scheme="https://github.com/sillyplus/categories/%E9%A2%98%E8%A7%A3/"/>
</entry>
<entry>
<title><![CDATA[Timus_1008_Image Encoding]]></title>
<link href="https://github.com/sillyplus/2014/07/05/timus_1008_image-encoding/"/>
<id>https://github.com/sillyplus/2014/07/05/timus_1008_image-encoding/</id>
<published>2014-07-05T07:37:28.000Z</published>
<updated>2015-10-19T11:47:13.000Z</updated>
<content type="html"><![CDATA[<p>我应该怎么说这道题好呢,只能怪自己英语没有学好吧T^T,为什么造福小众,我决定不翻译题意了,大家自己看吧。。。。<br><a id="more"></a><br>There are several ways to encode an image. In this problem we will consider two representations of an image. We assume that the image consists of black and white pixels. There is at least one black pixel and all black pixels are connected with their sides. Coordinates of black pixels are not less than 1 and not greater than 10. An example of such an image is at the figure.</p>
<p>Both representations describe arrangement of black pixels only.</p>
<p>At the first representation we specify in the first line number of black pixels and coordinates of each black pixel in the following lines. Pixels are listed in order of increasing X. In case of equality of X they are listed in order of increasing Y. Image at the figure is encoded as follows:</p>
<p><strong>6<br>2 3<br>2 4<br>3 3<br>3 4<br>4 2<br>4 3
</strong></p>
<p>At the second representation we specify in the first line coordinates of the lowest left black pixel. Each of the following lines contains a description of neighbors for one of the pixels. At first, neighbors of the lowest left pixel are specified, then neighbors of its first neighbor (if it exists) are specified, then neighbors of its second neighbor (if it also exists) follow. When all its neighbors are described the description of the neighbors of its first neighbor follows. The description of the neighbors of its second neighbor follows then and so on.</p>
<p>Each descriptive line contains at most one letter for each neighbor: R for the right, T for the top, L for the left, B for the bottom. If the neighbor was already specified it is not included into the descriptive line and vice-versa. Also there is only one descriptive line for each pixel. Neighbors are listed counter-clockwise starting with the right. Each descriptive line except the last ends with a comma. The last line ends with a full stop. Image at the figure is encoded as follows:</p>
<p><strong>2 3<br>RT,<br>RT,<br>,<br>B,<br>,<br>.
</strong></p>
<p>There are no leading or tailing spaces in any representation. There is exactly one space between X and Y coordinates.</p>
<h3 id="Input">Input</h3><p>One representation of the image will be given to your program in the input.</p>
<h3 id="Output">Output</h3><p>Your program has to write other representation of the image to the output.</p>
<h3 id="Sample">Sample</h3><table class="sample"><br><tbody><br><tr><br>input<br>output<br></tr><br><tr><br><br><td><br><br><br> 6<br> 2 3<br> 2 4<br> 3 3<br> 3 4<br> 4 2<br> 4 3<br><br><br><br><br></td><br><br><td><br><br><br> 2 3<br> RT,<br> RT,<br> ,<br> B,<br> ,<br> .<br><br><br><br><br></td><br></tr><br></tbody><br></table>
<p><strong>Problem Source: </strong>Third Open USTU Collegiate Programming Contest (PhysTech Cup), March 18, 2000</p>
<p>我只想说重点在最后几句话。。可能只有我没看清楚吧。。。。<br>看懂题意之后就会发现整个转换的过程其实就是bfs吧,然后就硬上了。一开始我由于没看清楚题意只写了一个转换,wa了几次,后来经过谷哥翻译才发现有这么个坑。<br>然后读入数据有点麻烦,总之就是我最不擅长的东西,还有要记得是逆时针方向,搜的时候。然后我就因为不明原因一直爆内存。。。。后来的后来,把原本读入字符数组的部分改成读字符串后不知道为什么就过了。。。。白白D了那么久的bug了。。。。<br><figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br><span class="line">63</span><br><span class="line">64</span><br><span class="line">65</span><br><span class="line">66</span><br><span class="line">67</span><br><span class="line">68</span><br><span class="line">69</span><br><span class="line">70</span><br><span class="line">71</span><br><span class="line">72</span><br><span class="line">73</span><br><span class="line">74</span><br><span class="line">75</span><br><span class="line">76</span><br><span class="line">77</span><br><span class="line">78</span><br><span class="line">79</span><br><span class="line">80</span><br><span class="line">81</span><br><span class="line">82</span><br><span class="line">83</span><br><span class="line">84</span><br><span class="line">85</span><br><span class="line">86</span><br><span class="line">87</span><br><span class="line">88</span><br><span class="line">89</span><br><span class="line">90</span><br><span class="line">91</span><br><span class="line">92</span><br><span class="line">93</span><br><span class="line">94</span><br><span class="line">95</span><br><span class="line">96</span><br><span class="line">97</span><br><span class="line">98</span><br><span class="line">99</span><br><span class="line">100</span><br><span class="line">101</span><br><span class="line">102</span><br><span class="line">103</span><br><span class="line">104</span><br><span class="line">105</span><br><span class="line">106</span><br><span class="line">107</span><br><span class="line">108</span><br><span class="line">109</span><br><span class="line">110</span><br></pre></td><td class="code"><pre><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><string></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><queue></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstdio></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstring></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><algorithm></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstdlib></span></span></span><br><span class="line"></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><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> MN = <span class="number">20</span>;</span><br><span class="line"></span><br><span class="line"><span class="keyword">struct</span> pt{</span><br><span class="line"> <span class="keyword">int</span> x, y;</span><br><span class="line">};</span><br><span class="line"></span><br><span class="line"><span class="keyword">int</span> n, ans, vx, vy;</span><br><span class="line"><span class="keyword">bool</span> vis[MN][MN];</span><br><span class="line"><span class="keyword">int</span> dx[] = {<span class="number">1</span>, <span class="number">0</span>, -<span class="number">1</span>, <span class="number">0</span>};</span><br><span class="line"><span class="keyword">int</span> dy[] = {<span class="number">0</span>, <span class="number">1</span>, <span class="number">0</span>, -<span class="number">1</span>};</span><br><span class="line">pt a[MN*MN];</span><br><span class="line"><span class="keyword">char</span> c[] = {<span class="string">'R'</span>, <span class="string">'T'</span>, <span class="string">'L'</span>, <span class="string">'B'</span>}, b[MN];</span><br><span class="line"><span class="built_in">queue</span><pt> q;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">bool</span> <span class="title">comp</span><span class="params">(<span class="keyword">const</span> pt &pa, <span class="keyword">const</span> pt &pb)</span> </span>{</span><br><span class="line"> <span class="keyword">if</span> (pa.x != pb.x) <span class="keyword">return</span> pa.x < pb.x;</span><br><span class="line"> <span class="keyword">return</span> pa.y < pb.y;</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">bfsa</span><span class="params">()</span> </span>{</span><br><span class="line"> pt now, next;</span><br><span class="line"> <span class="built_in">string</span> dir;</span><br><span class="line"> <span class="keyword">while</span> (!q.empty()) {</span><br><span class="line"> now = q.front();</span><br><span class="line"> a[ans] = now;</span><br><span class="line"> <span class="built_in">cin</span> >> dir;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i < dir.length() - <span class="number">1</span>; i++) {</span><br><span class="line"> <span class="keyword">char</span> tc = dir[i];</span><br><span class="line"> <span class="keyword">int</span> j;</span><br><span class="line"> <span class="keyword">for</span> (j = <span class="number">0</span>; j < <span class="number">4</span>; j++) {</span><br><span class="line"> <span class="keyword">if</span> (c[j] == tc) <span class="keyword">break</span>;</span><br><span class="line"> }</span><br><span class="line"> next.x = now.x + dx[j];</span><br><span class="line"> next.y = now.y + dy[j];</span><br><span class="line"> q.push(next);</span><br><span class="line"> }</span><br><span class="line"> q.pop();</span><br><span class="line"> ans++;</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">bfsb</span><span class="params">()</span> </span>{</span><br><span class="line"> pt now, next;</span><br><span class="line"> <span class="keyword">while</span> (!q.empty()) {</span><br><span class="line"> now = q.front();</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">4</span>; i++) {</span><br><span class="line"> <span class="keyword">int</span> tx = now.x + dx[i];</span><br><span class="line"> <span class="keyword">int</span> ty = now.y + dy[i];</span><br><span class="line"> <span class="keyword">if</span> (vis[tx][ty] == <span class="number">1</span>) {</span><br><span class="line"> <span class="built_in">cout</span> << c[i];</span><br><span class="line"> vis[tx][ty] = <span class="number">0</span>;</span><br><span class="line"> next.x = tx;</span><br><span class="line"> next.y = ty;</span><br><span class="line"> q.push(next);</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> ans++;</span><br><span class="line"> <span class="keyword">if</span> (ans != n)</span><br><span class="line"> <span class="built_in">cout</span> << <span class="string">",\n"</span>;</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> <span class="built_in">cout</span> << <span class="string">".\n"</span>;</span><br><span class="line"> q.pop();</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="built_in">string</span> s;</span><br><span class="line"> getline(<span class="built_in">cin</span>, s);</span><br><span class="line"> <span class="built_in">memset</span>(vis, <span class="number">0</span>, <span class="keyword">sizeof</span>(vis));</span><br><span class="line"> pt k;</span><br><span class="line"> <span class="keyword">if</span> (s.find(<span class="string">' '</span>) != <span class="built_in">string</span>::npos) {</span><br><span class="line"> s.copy(b, s.find(<span class="string">' '</span>), <span class="number">0</span>);</span><br><span class="line"> vx = atoi(b);</span><br><span class="line"> s.copy(b, <span class="number">100</span>, s.find(<span class="string">' '</span>) + <span class="number">1</span>);</span><br><span class="line"> vy = atoi(b);</span><br><span class="line"> pt k;</span><br><span class="line"> k.x = vx;</span><br><span class="line"> k.y = vy;</span><br><span class="line"> q.push(k);</span><br><span class="line"> bfsa();</span><br><span class="line"> sort(a, a+ans, comp);</span><br><span class="line"> <span class="built_in">cout</span> << ans << endl;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i < ans; i++)</span><br><span class="line"> <span class="built_in">cout</span> << a[i].x << <span class="string">' '</span> << a[i].y << endl;</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> n = atoi(s.c_str());</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="built_in">cin</span> >> k.x >> k.y;</span><br><span class="line"> vis[k.x][k.y] = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">if</span> (i == <span class="number">0</span>) {</span><br><span class="line"> q.push(k);</span><br><span class="line"> <span class="built_in">cout</span> << k.x << <span class="string">' '</span> << k.y << endl;</span><br><span class="line"> vis[k.x][k.y] = <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> ans = <span class="number">0</span>;</span><br><span class="line"> bfsb();</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></p>
]]></content>
<summary type="html">
<![CDATA[<p>我应该怎么说这道题好呢,只能怪自己英语没有学好吧T^T,为什么造福小众,我决定不翻译题意了,大家自己看吧。。。。<br>]]>
</summary>
<category term="BFS" scheme="https://github.com/sillyplus/tags/BFS/"/>
<category term="Tyvj" scheme="https://github.com/sillyplus/tags/Tyvj/"/>
<category term="题解" scheme="https://github.com/sillyplus/categories/%E9%A2%98%E8%A7%A3/"/>
</entry>
<entry>
<title><![CDATA[Tyvj_P1297 - 小气的小B]]></title>
<link href="https://github.com/sillyplus/2014/07/04/tyvj_p1297/"/>
<id>https://github.com/sillyplus/2014/07/04/tyvj_p1297/</id>
<published>2014-07-03T22:34:13.000Z</published>
<updated>2015-10-19T11:45:38.000Z</updated>
<content type="html"><![CDATA[<p>经典问题,RMQ,不过为了增加一下文章长度,我打算贴一下题目<br><a id="more"></a><br>描述 Description</p>
<p>其实你们都不知道,小B是很小气的。一天小B带着他的弟弟小B’一起去摘果子,走着走着,他们忽然发现了一颗长满了果子的树。由于弟弟长得太矮了,弟弟只有让哥哥小B帮他摘一些果子下来。哥哥小B说:”弟弟啊,不是我不想给你摘多,我只是一次拿不了那么多,昨天晚上又没睡好,只能上一次树。所以哥哥只能给你摘一个哈。”没办法,弟弟只有答应了这个要求。<br>于是几下小B就上了树,树上的果子还真多,有N个呢!!但是小B很快发现这些果子大小不一。抠门的小B就想给自己拿个最大的,给弟弟拿个最小的果子。但是由于树上有些果子太高,小B不一定可以够着,所以他给你选了P个可以够着的果子区间,让你在这些区间里面找一个最大的果子和一个最小的果子。</p>
<p>输入格式 InputFormat</p>
<p>共p+2行,<br>第一行为n和p,<br>第二行为区间[1,n]的果子大小(用正整数表示)<br>后面p行形如a b,意为每次询问的区间的左界和右界</p>
<p>输出格式 OutputFormat</p>
<p>共p行,第i行为第i次询问时得到的最大值以及最小值(一个询问用空格空开max和min)</p>
<p>【注意】在输入数据中果子的大小是无序的。</p>
<p>样例输入 SampleInput [复制数据]</p>
<p>5 2<br>1 3 2 4 5<br>1 4<br>2 5</p>
<p>样例输出 SampleOutput [复制数据]</p>
<p>4 1<br>5 2</p>
<p>数据范围和注释 Hint</p>
<p>【数据范围】<br>保证果子大小不超过maxlongint<br>40%的数据: 1<=n,p<=1,000<br>100%的数据:1<=n<=50,000<br>1<=p<=20,000</p>
<p>有很多种解法啦,线段树也可以,之前我还写过一篇<a href="http://sillyplus.com/2013/06/98/" target="_blank" rel="external">块状数组</a>的也能解决这个问题,然后就是今天复习了一下st算法,所以就用st写了,关于st算法的话可以看看Archive里面的模版。</p>
<figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br></pre></td><td class="code"><pre><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstdio></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cmath></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstring></span></span></span><br><span class="line"></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><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> MN = <span class="number">50010</span>;</span><br><span class="line"></span><br><span class="line"><span class="keyword">int</span> st[MN][<span class="number">32</span>][<span class="number">2</span>];</span><br><span class="line"><span class="keyword">int</span> a[MN], pl[MN];</span><br><span class="line"><span class="keyword">int</span> n, m;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">stp</span><span class="params">(<span class="keyword">int</span> n)</span> </span>{</span><br><span class="line"> pl[<span class="number">1</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">2</span>; i <= n; i++) {</span><br><span class="line"> pl[i] = pl[i-<span class="number">1</span>];</span><br><span class="line"> <span class="keyword">if</span> ((<span class="number">1</span> << (pl[i]+<span class="number">1</span>)) == i) {</span><br><span class="line"> pl[i]++;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = n-<span class="number">1</span>; i >= <span class="number">0</span>; i--) {</span><br><span class="line"> st[i][<span class="number">0</span>][<span class="number">0</span>] = st[i][<span class="number">0</span>][<span class="number">1</span>] = a[i];</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> j = <span class="number">1</span>; (i + (<span class="number">1</span> << j) - <span class="number">1</span>) < n; j++) {</span><br><span class="line"> st[i][j][<span class="number">0</span>] = max(st[i][j-<span class="number">1</span>][<span class="number">0</span>], st[i + (<span class="number">1</span> << (j-<span class="number">1</span>))][j-<span class="number">1</span>][<span class="number">0</span>]);</span><br><span class="line"> st[i][j][<span class="number">1</span>] = min(st[i][j-<span class="number">1</span>][<span class="number">1</span>], st[i + (<span class="number">1</span> << (j-<span class="number">1</span>))][j-<span class="number">1</span>][<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><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="built_in">cin</span> >> n >> m;</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="built_in">scanf</span>(<span class="string">"%d"</span>, &a[i]);</span><br><span class="line"> }</span><br><span class="line"> stp(n);</span><br><span class="line"> <span class="keyword">int</span> l, r, len, k, mx, mi;</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 class="built_in">scanf</span>(<span class="string">"%d%d"</span>, &l, &r);</span><br><span class="line"> l--;</span><br><span class="line"> r--;</span><br><span class="line"> len = r-l+<span class="number">1</span>;</span><br><span class="line"> k = pl[len];</span><br><span class="line"> mx = max(st[l][k][<span class="number">0</span>], st[r-(<span class="number">1</span><<k)+<span class="number">1</span>][k][<span class="number">0</span>]);</span><br><span class="line"> mi = min(st[l][k][<span class="number">1</span>], st[r-(<span class="number">1</span><<k)+<span class="number">1</span>][k][<span class="number">1</span>]);</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%d %d\n"</span>, mx, mi);</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>
<summary type="html">
<![CDATA[<p>经典问题,RMQ,不过为了增加一下文章长度,我打算贴一下题目<br>]]>
</summary>
<category term="ST" scheme="https://github.com/sillyplus/tags/ST/"/>
<category term="Tyvj" scheme="https://github.com/sillyplus/tags/Tyvj/"/>
<category term="题解" scheme="https://github.com/sillyplus/categories/%E9%A2%98%E8%A7%A3/"/>
</entry>
<entry>
<title><![CDATA[Tyvj_P1323 - 识别水果]]></title>
<link href="https://github.com/sillyplus/2014/07/03/tyvj_p1323/"/>
<id>https://github.com/sillyplus/2014/07/03/tyvj_p1323/</id>
<published>2014-07-03T08:14:02.000Z</published>
<updated>2015-10-19T11:45:30.000Z</updated>
<content type="html"><![CDATA[<p>本来说好的每日一题解,因为下午睡了一觉醒来发现已经快十点了,然后才开始做题。。然后发现现在已经过了十二点了。。。</p>
<p>题目可以在这里看:<a href="http://www.tyvj.cn/Problem_Show.aspx?id=1323" target="_blank" rel="external">传送门</a></p>
<p>然后这可以说是一道陈年老题了,我从高中的时候就打算要写,然后一直拖到现在-_-#,根据题意很容易想到可以用并查集来解决,我们可以添加一个节点0,然后有毒的水果都合并到0,然后最后统计一下有多少水果是有毒的就行了。<br><a id="more"></a><br><figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br><span class="line">63</span><br></pre></td><td class="code"><pre><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstdio></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstring></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><string></span></span></span><br><span class="line"></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><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> MN = <span class="number">10010</span>;</span><br><span class="line"></span><br><span class="line"><span class="keyword">char</span> a[<span class="number">30</span>], b[<span class="number">30</span>];</span><br><span class="line"><span class="keyword">int</span> n, m, k, p;</span><br><span class="line"><span class="keyword">int</span> f[MN];</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="built_in">string</span> <span class="title">cv</span><span class="params">(<span class="built_in">string</span> s)</span> </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">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i < s.length(); i++) {</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">26</span>; j++)</span><br><span class="line"> <span class="keyword">if</span> (s[i] == a[j]) {</span><br><span class="line"> ret += b[j];</span><br><span class="line"> <span class="keyword">break</span>;</span><br><span class="line"> }</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 class="function"><span class="keyword">int</span> <span class="title">find</span><span class="params">(<span class="keyword">int</span> v)</span> </span>{</span><br><span class="line"> <span class="keyword">return</span> f[v] = f[v] == v ? v : find(f[v]);</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="built_in">cin</span> >> a;</span><br><span class="line"> <span class="built_in">cin</span> >> b;</span><br><span class="line"> <span class="built_in">cin</span> >> n >> m;</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"> f[i] = i;</span><br><span class="line"> <span class="built_in">string</span> s;</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 class="built_in">cin</span> >> k >> s;</span><br><span class="line"> s = cv(s);</span><br><span class="line"> <span class="keyword">int</span> t = s.find(<span class="string">"poison"</span>);</span><br><span class="line"> <span class="keyword">if</span> (t < s.length())</span><br><span class="line"> f[k] = <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="built_in">cin</span> >> p;</span><br><span class="line"> <span class="keyword">int</span> x, y;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i < p; i++) {</span><br><span class="line"> <span class="built_in">cin</span> >> x >> y;</span><br><span class="line"> <span class="keyword">int</span> fx = find(x), fy = find(y);</span><br><span class="line"> <span class="keyword">if</span> (fx == <span class="number">0</span> || fy == <span class="number">0</span>) {</span><br><span class="line"> f[fx] = <span class="number">0</span>;</span><br><span class="line"> f[fy] = <span class="number">0</span>;</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> f[fx] = fy;</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"> f[i] = find(i);</span><br><span class="line"> <span class="keyword">if</span> (f[i] == <span class="number">0</span>) ans++;</span><br><span class="line"> }</span><br><span class="line"> <span class="built_in">cout</span> << n-ans << endl;</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>
<p>ps:我这哪还是在写题解。。。这样下去真的可以吗T^T</p>
]]></content>
<summary type="html">
<![CDATA[<p>本来说好的每日一题解,因为下午睡了一觉醒来发现已经快十点了,然后才开始做题。。然后发现现在已经过了十二点了。。。</p>
<p>题目可以在这里看:<a href="http://www.tyvj.cn/Problem_Show.aspx?id=1323">传送门</a></p>
<p>然后这可以说是一道陈年老题了,我从高中的时候就打算要写,然后一直拖到现在-_-#,根据题意很容易想到可以用并查集来解决,我们可以添加一个节点0,然后有毒的水果都合并到0,然后最后统计一下有多少水果是有毒的就行了。<br>]]>
</summary>
<category term="Tyvj" scheme="https://github.com/sillyplus/tags/Tyvj/"/>
<category term="并查集" scheme="https://github.com/sillyplus/tags/%E5%B9%B6%E6%9F%A5%E9%9B%86/"/>
<category term="题解" scheme="https://github.com/sillyplus/categories/%E9%A2%98%E8%A7%A3/"/>
</entry>
<entry>
<title><![CDATA[Timus_1727_Znaika's Magic Numbers]]></title>
<link href="https://github.com/sillyplus/2014/07/02/timus_1727_znaikas-magic-numbers/"/>
<id>https://github.com/sillyplus/2014/07/02/timus_1727_znaikas-magic-numbers/</id>
<published>2014-07-01T16:00:00.000Z</published>
<updated>2015-10-19T11:45:23.000Z</updated>
<content type="html"><![CDATA[<p>题目大意:给你一个N (0 < N < 10^5),把N分解成若干个不相同且值不超过10^5的整数的各个位数的和,例如:N=17时有,17 = 7 + 1 + 2 + 4 + 3,所以17可以分解成7, 12, 43,这三个不同的整数。</p>
<p>题目其实是比较简单的,解法也有很多种,我就说一个我认为比较有趣的解法。我们可以每次把N加到所求的整数集合里面,然后再把N减去自身各位数字的和得到新的N’,直到N等于零。正确性也很容易验证,注意到我们每次往集合里添加的数必然都是递减的,这就保证了无重复数字的出现,然后按照生成的规则可知,减到N为0的时候自然集合里的所有数的各位数字之和就为最初的N了。<br><a id="more"></a><br>其他解法:比如说先把1~99999,每个数的位数和算出来,然后排个序,然后就由大到小减等等。。。</p>
<p>烂烂的还是贴下代码。。。。。</p>
<figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br></pre></td><td class="code"><pre><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><vector></span></span></span><br><span class="line"></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><br><span class="line"><span class="built_in">vector</span><<span class="keyword">int</span>> v;</span><br><span class="line"><span class="built_in">vector</span><<span class="keyword">int</span>>::iterator its;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">ds</span><span class="params">(<span class="keyword">int</span> x)</span> </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> (x) {</span><br><span class="line"> ret += (x % <span class="number">10</span>);</span><br><span class="line"> x /= <span class="number">10</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><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="keyword">int</span> n;</span><br><span class="line"> <span class="built_in">cin</span> >> n;</span><br><span class="line"> <span class="keyword">while</span> (n) {</span><br><span class="line"> v.push_back(n);</span><br><span class="line"> n -= ds(n);</span><br><span class="line"> }</span><br><span class="line"> <span class="built_in">cout</span> << v.size() << endl;</span><br><span class="line"> <span class="keyword">for</span> (its = v.begin(); its != v.end(); its++)</span><br><span class="line"> <span class="built_in">cout</span> << *its << <span class="string">' '</span>;</span><br><span class="line"> <span class="built_in">cout</span> << endl;</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>
<summary type="html">
<![CDATA[<p>题目大意:给你一个N (0 < N < 10^5),把N分解成若干个不相同且值不超过10^5的整数的各个位数的和,例如:N=17时有,17 = 7 + 1 + 2 + 4 + 3,所以17可以分解成7, 12, 43,这三个不同的整数。</p>
<p>题目其实是比较简单的,解法也有很多种,我就说一个我认为比较有趣的解法。我们可以每次把N加到所求的整数集合里面,然后再把N减去自身各位数字的和得到新的N’,直到N等于零。正确性也很容易验证,注意到我们每次往集合里添加的数必然都是递减的,这就保证了无重复数字的出现,然后按照生成的规则可知,减到N为0的时候自然集合里的所有数的各位数字之和就为最初的N了。<br>]]>
</summary>
<category term="Math" scheme="https://github.com/sillyplus/tags/Math/"/>
<category term="Timus" scheme="https://github.com/sillyplus/tags/Timus/"/>
<category term="题解" scheme="https://github.com/sillyplus/categories/%E9%A2%98%E8%A7%A3/"/>
</entry>
<entry>
<title><![CDATA[Timus 1028 1318 [树状数组]]]></title>
<link href="https://github.com/sillyplus/2014/07/01/timus_1028_1318/"/>
<id>https://github.com/sillyplus/2014/07/01/timus_1028_1318/</id>
<published>2014-06-30T19:56:24.000Z</published>
<updated>2015-10-19T11:45:16.000Z</updated>
<content type="html"><![CDATA[<h4 id="除草向"><em>除草向</em></h4><p>博客好久没有更新了,自从打完补选赛之后就一直一副颓废状态,外加要期末考,得预习课内知识(虽然我到最后还是。。。),不管怎么样,现在以及放假了,所以我打算兑现之前对自己的承诺,暑假好好做题,所以这段时间应该会比较经常更新一些水题的题解啦( ´ ▽ ` )ノ。昨天选拔赛第一场就爆零滚粗,作为一名候补选手,我只剩下今天这个最后一次机会了,好伤感的说T^T,希望写一写题解涨张RP。。。<br><a id="more"></a><br>吐槽完毕,接下来进入正题啦~ ,虽然以前偶尔也又写过树状数组的题目,不过基本就没去记住,然后每次都得看模版。。。这两天写了两三次,终于记住啦啦啦啦</p>
<ol>
<li>Star</li>
</ol>
<p>题目大衣:一个二维平面上又N (1 ≤ <em>N</em> ≤ 15000)个点(0 ≤ <em>X</em>,<em>Y</em> ≤ 32000),然后定义每个点的level,对于点i,它的level为横纵坐标均不大于点i的点的个数。要求输出0~N-1的各个level的的点数。</p>
<p>这道题的只要求出每个点的level,统计一下就行了。然后就是求level的办法了,我们首先可以把每个点先按x递增,然后y递增的顺序排序。这样x就有序了,然后我们顺序处理每个点,对一个点Pi,已知点Pj(j<i)的x不大于Pi的x,然后要做的就是统计一下Pj中y小于等于Pi的y的个数。我们用c[i]表示y为i的点的个数,Pi的level值就为sum= c[0] + c[1] + .. + c[y-1], 然后再更新一下c数组,c[y]+1,以上都可以用树状数组来解决。</p>
<figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br></pre></td><td class="code"><pre><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstdio></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><algorithm></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cmath></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstring></span></span></span><br><span class="line"></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><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> MN = <span class="number">32001</span>;</span><br><span class="line"></span><br><span class="line"><span class="keyword">struct</span> pt{</span><br><span class="line"> <span class="keyword">int</span> x, y;</span><br><span class="line">};</span><br><span class="line"></span><br><span class="line">pt a[MN/<span class="number">2</span>];</span><br><span class="line"><span class="keyword">int</span> level[MN/<span class="number">2</span>];</span><br><span class="line"><span class="keyword">int</span> t[MN+<span class="number">10</span>];</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">bool</span> <span class="title">comp</span><span class="params">(<span class="keyword">const</span> pt &a, <span class="keyword">const</span> pt &b)</span> </span>{</span><br><span class="line"> <span class="keyword">if</span> (a.x != b.x) <span class="keyword">return</span> a.x < b.x;</span><br><span class="line"> <span class="keyword">return</span> a.y < b.y;</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">inline</span> <span class="keyword">int</span> <span class="title">lowbit</span><span class="params">(<span class="keyword">int</span> x)</span> </span>{</span><br><span class="line"> <span class="keyword">return</span> (x & -x);</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">add</span><span class="params">(<span class="keyword">int</span> x, <span class="keyword">int</span> value)</span> </span>{</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = x; i <= MN; i += lowbit(i))</span><br><span class="line"> t[i] += value;</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">get</span><span class="params">(<span class="keyword">int</span> x)</span> </span>{</span><br><span class="line"> <span class="keyword">int</span> sum = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = x; i; i -= lowbit(i))</span><br><span class="line"> sum += t[i];</span><br><span class="line"> <span class="keyword">return</span> sum;</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="keyword">int</span> n;</span><br><span class="line"> <span class="built_in">cin</span> >> 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"> <span class="built_in">scanf</span>(<span class="string">"%d%d"</span>, &a[i].x, &a[i].y);</span><br><span class="line"> }</span><br><span class="line"> sort(a, a+n, comp);</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">int</span> k = a[i].y+<span class="number">1</span>;</span><br><span class="line"> level[get(k)]++;</span><br><span class="line"> add(k, <span class="number">1</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><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%d\n"</span>, level[i]);</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>
<ol>
<li>Electronic Auction</li>
</ol>
<p>题目大衣:好像是拍卖铁猪来着,价格0.01~10000.00,最多两位小数。然后有几个操作:</p>
<ul>
<li>BID X 以X元竞标一头猪</li>
</ul>
<ul>
<li>DEL X 取消一个价格为X的竞标</li>
</ul>
<ul>
<li>SALE X K 以X元卖掉K头猪</li>
</ul>
<ul>
<li>QUIT 结束输入</li>
</ul>
<p>对于每一个SALE,前K个出价不小于X的客户可以得到一头猪,如果不够K个客户满足条件,自然是能买出多少就多少了,每卖出一头获利0.01,求最大获利好像差不多就是这样了把。</p>
<p>然后其实我们可以把每个数乘上100,就变成整数,不过直接这样好像会有精度问题,我因此WA了几次,后来看了讨论区,弄了个修正的办法。数组a[i]表示出价X的客户数,然后就直接套树状数组了吧,SALE的时候就是求a[i]~a[maxn],这个一个除法也就出来了。</p>
<figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br></pre></td><td class="code"><pre><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstdio></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cmath></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstring></span></span></span><br><span class="line"></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><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> MN = <span class="number">1000000</span>;</span><br><span class="line"></span><br><span class="line"><span class="keyword">char</span> str[<span class="number">5</span>];</span><br><span class="line"><span class="keyword">double</span> d;</span><br><span class="line"><span class="keyword">int</span> f[MN+<span class="number">10</span>] = {<span class="number">0</span>};</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">inline</span> <span class="keyword">int</span> <span class="title">lowbit</span><span class="params">(<span class="keyword">int</span> x)</span> </span>{</span><br><span class="line"> <span class="keyword">return</span> (x & -x);</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">add</span><span class="params">(<span class="keyword">int</span> x, <span class="keyword">int</span> value)</span> </span>{</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = x; i <= MN; i += lowbit(i))</span><br><span class="line"> f[i] += value;</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">get</span><span class="params">(<span class="keyword">int</span> x)</span> </span>{</span><br><span class="line"> <span class="keyword">int</span> sum = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = x; i; i -= lowbit(i))</span><br><span class="line"> sum += f[i];</span><br><span class="line"> <span class="keyword">return</span> sum;</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="built_in">cin</span> >> str;</span><br><span class="line"> <span class="keyword">double</span> ans = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">int</span> k;</span><br><span class="line"> <span class="keyword">while</span> (str[<span class="number">0</span>] != <span class="string">'Q'</span>) {</span><br><span class="line"> <span class="keyword">if</span> (str[<span class="number">0</span>] == <span class="string">'B'</span>) {</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%lf"</span>, &d);</span><br><span class="line"> add(<span class="keyword">int</span>(d*<span class="number">100</span> + <span class="number">0.5</span>), <span class="number">1</span>);</span><br><span class="line"> } <span class="keyword">else</span> <span class="keyword">if</span> (str[<span class="number">0</span>] == <span class="string">'D'</span>) {</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%lf"</span>, &d);</span><br><span class="line"> add(<span class="keyword">int</span>(d*<span class="number">100</span> + <span class="number">0.5</span>), -<span class="number">1</span>);</span><br><span class="line"> } <span class="keyword">else</span> <span class="keyword">if</span> (str[<span class="number">0</span>] == <span class="string">'S'</span>) {</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%lf%d"</span>, &d, &k);</span><br><span class="line"> <span class="keyword">int</span> t = <span class="keyword">int</span>(d*<span class="number">100</span> + <span class="number">0.5</span>);</span><br><span class="line"> <span class="keyword">int</span> ts = get(MN) - get(t-<span class="number">1</span>);</span><br><span class="line"> ans += min(k, ts);</span><br><span class="line"> }</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%s"</span>, str);</span><br><span class="line"> }</span><br><span class="line"> ans /= <span class="number">100.0</span>;</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%.2f\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>
<p>因为赶着要去吃饭然后打选拔赛去了,所以后面没怎么想好表达就乱写了,实在想在比赛前写完。故事不会就这样终结的,</p>
]]></content>
<summary type="html">
<![CDATA[<h4 id="除草向"><em>除草向</em></h4><p>博客好久没有更新了,自从打完补选赛之后就一直一副颓废状态,外加要期末考,得预习课内知识(虽然我到最后还是。。。),不管怎么样,现在以及放假了,所以我打算兑现之前对自己的承诺,暑假好好做题,所以这段时间应该会比较经常更新一些水题的题解啦( ´ ▽ ` )ノ。昨天选拔赛第一场就爆零滚粗,作为一名候补选手,我只剩下今天这个最后一次机会了,好伤感的说T^T,希望写一写题解涨张RP。。。<br>]]>
</summary>
<category term="Timus" scheme="https://github.com/sillyplus/tags/Timus/"/>
<category term="树状数组" scheme="https://github.com/sillyplus/tags/%E6%A0%91%E7%8A%B6%E6%95%B0%E7%BB%84/"/>
<category term="题解" scheme="https://github.com/sillyplus/categories/%E9%A2%98%E8%A7%A3/"/>
</entry>
<entry>
<title><![CDATA[Timus_1106_Two Teams]]></title>
<link href="https://github.com/sillyplus/2014/05/21/timus_1106_two-teams/"/>
<id>https://github.com/sillyplus/2014/05/21/timus_1106_two-teams/</id>
<published>2014-05-21T09:17:54.000Z</published>
<updated>2015-10-19T11:45:05.000Z</updated>
<content type="html"><![CDATA[<p>题目大意:给一个无向图,N个顶点(n<=100,好小的样子。。),要求把这N个顶点分成两组,使得对任一个组中的每个顶点,都至少存在一条边连接到另一组中的某个顶点,要求给出任一满足条件的分组,输出其中一个组的顶点编号。</p>
<p>话说一开始看完题目我想到的是二分图,应该是可以做的,不过本题似乎不必那么麻烦。因为题目给的条件相当宽松,我们可以对每个顶点进行染色,从某个为染色的顶点出发,把跟它相邻同时还没有染色的顶点染色跟它相反的颜色,然后就这样一直搜下去好了,要注意的就是整个图可能存在多个联通块,然后应该就没有然后了吧。。。<br><a id="more"></a><br><figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br></pre></td><td class="code"><pre><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><vector></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstdio></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstring></span></span></span><br><span class="line"></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><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> MN = <span class="number">110</span>;</span><br><span class="line"></span><br><span class="line"><span class="keyword">int</span> n, k;</span><br><span class="line"><span class="built_in">vector</span><<span class="keyword">int</span>> g[MN];</span><br><span class="line"><span class="keyword">int</span> vit[MN];</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">dfs</span><span class="params">(<span class="keyword">int</span> x, <span class="keyword">int</span> color)</span> </span>{</span><br><span class="line"> vit[x] = color;</span><br><span class="line"> color = (color == <span class="number">1</span> ? <span class="number">2</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 < g[x].size(); i++)</span><br><span class="line"> <span class="keyword">if</span> (!vit[g[x][i]]) dfs(g[x][i], color);</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="built_in">memset</span>(vit, <span class="number">0</span>, <span class="keyword">sizeof</span>(vit));</span><br><span class="line"> <span class="built_in">cin</span> >> n;</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"> <span class="built_in">scanf</span>(<span class="string">"%d"</span>, &k);</span><br><span class="line"> <span class="keyword">while</span> (k) {</span><br><span class="line"> g[i].push_back(k);</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%d"</span>, &k);</span><br><span class="line"> }</span><br><span class="line"> }</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"> <span class="keyword">if</span> (!vit[i]) dfs(i, <span class="number">1</span>);</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"> <span class="keyword">if</span> (!vit[i]) {</span><br><span class="line"> <span class="built_in">cout</span> << <span class="number">0</span> << endl;</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"> } <span class="keyword">else</span> <span class="keyword">if</span> (vit[i] == <span class="number">1</span>) ans++;</span><br><span class="line"> <span class="built_in">cout</span> << ans << endl;</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"> <span class="keyword">if</span> (vit[i] == <span class="number">1</span>) <span class="built_in">cout</span> << i << <span class="string">' '</span>;</span><br><span class="line"> <span class="built_in">cout</span> << endl;</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>
]]></content>
<summary type="html">
<![CDATA[<p>题目大意:给一个无向图,N个顶点(n<=100,好小的样子。。),要求把这N个顶点分成两组,使得对任一个组中的每个顶点,都至少存在一条边连接到另一组中的某个顶点,要求给出任一满足条件的分组,输出其中一个组的顶点编号。</p>
<p>话说一开始看完题目我想到的是二分图,应该是可以做的,不过本题似乎不必那么麻烦。因为题目给的条件相当宽松,我们可以对每个顶点进行染色,从某个为染色的顶点出发,把跟它相邻同时还没有染色的顶点染色跟它相反的颜色,然后就这样一直搜下去好了,要注意的就是整个图可能存在多个联通块,然后应该就没有然后了吧。。。<br>]]>
</summary>
<category term="DFS" scheme="https://github.com/sillyplus/tags/DFS/"/>
<category term="Graph" scheme="https://github.com/sillyplus/tags/Graph/"/>
<category term="Timus" scheme="https://github.com/sillyplus/tags/Timus/"/>
<category term="题解" scheme="https://github.com/sillyplus/categories/%E9%A2%98%E8%A7%A3/"/>
</entry>
<entry>
<title><![CDATA[Timus_1024_Permutations]]></title>
<link href="https://github.com/sillyplus/2014/05/15/timus_1024_permutations/"/>
<id>https://github.com/sillyplus/2014/05/15/timus_1024_permutations/</id>
<published>2014-05-14T16:29:38.000Z</published>
<updated>2015-10-19T11:44:59.000Z</updated>
<content type="html"><![CDATA[<p>因为题目的编号是2^10,所以决定写一下题解。</p>
<p>题目大意:给出一个n阶的置换P,问P的多少次幂等于单位元E。n <= 1000,保证答案不超过1e9.</p>
<p>如果有一点置换群的知识的话就很好解决了,其实题目也就清楚的告诉你是怎么置换了。我们知道在置换群中有这样一个定理</p>
<ul>
<li>任何一个置换都可以表示成若干循环的乘积</li>
</ul>
<p>关于循环的概念,相信应该不难理解,简单点说就是根据题目,_P_k(x) = x,__则在置换过程中得到的k个数便构成一个k阶的循环。题目要求的答案便是k1, k2…..kn的最小公倍数。显然,对于1~n,每个数字仅会出现在一个循环当中,同一个循环中的数对于的k便是一样的。这样复杂度就可以做到O(nlogn),由于n只有1000,我就懒得去标记什么的了,直接用O(n^2 logn)的做法。<br><a id="more"></a><br><figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br></pre></td><td class="code"><pre><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"></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><br><span class="line"><span class="keyword">int</span> f[<span class="number">1010</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">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">return</span> (b == <span class="number">0</span>) ? a : 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">main</span><span class="params">()</span> </span>{</span><br><span class="line"> <span class="keyword">int</span> n;</span><br><span class="line"> <span class="built_in">cin</span> >> n;</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"> <span class="built_in">cin</span> >> f[i];</span><br><span class="line"> <span class="keyword">int</span> ans = <span class="number">1</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"> <span class="keyword">int</span> x = f[i], loop = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">while</span> (x != i) {</span><br><span class="line"> x = f[x];</span><br><span class="line"> loop++;</span><br><span class="line"> }</span><br><span class="line"> ans = ans * (loop / gcd(ans, loop));</span><br><span class="line"> }</span><br><span class="line"> <span class="built_in">cout</span> << ans << endl;</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>
<p>期间WA过一次,原因是这个</p>
<ul>
<li>ans = ans * (loop / gcd(ans, loop));</li>
</ul>
<p>写成这样子</p>
<ul>
<li>ans = ans * loop / gcd(ans, loop);</li>
</ul>
<p>但是没用long long 结果就乘爆了,使用上面的式子并用int,以及时候下面的式子并使用long long,后者在时间以及空间上十分微妙的更优一些,这是为什么呢,因为括号的缘故?求科普啊。</p>
]]></content>
<summary type="html">
<![CDATA[<p>因为题目的编号是2^10,所以决定写一下题解。</p>
<p>题目大意:给出一个n阶的置换P,问P的多少次幂等于单位元E。n <= 1000,保证答案不超过1e9.</p>
<p>如果有一点置换群的知识的话就很好解决了,其实题目也就清楚的告诉你是怎么置换了。我们知道在置换群中有这样一个定理</p>
<ul>
<li>任何一个置换都可以表示成若干循环的乘积</li>
</ul>
<p>关于循环的概念,相信应该不难理解,简单点说就是根据题目,_P_k(x) = x,__则在置换过程中得到的k个数便构成一个k阶的循环。题目要求的答案便是k1, k2…..kn的最小公倍数。显然,对于1~n,每个数字仅会出现在一个循环当中,同一个循环中的数对于的k便是一样的。这样复杂度就可以做到O(nlogn),由于n只有1000,我就懒得去标记什么的了,直接用O(n^2 logn)的做法。<br>]]>
</summary>
<category term="Math" scheme="https://github.com/sillyplus/tags/Math/"/>
<category term="题解" scheme="https://github.com/sillyplus/categories/%E9%A2%98%E8%A7%A3/"/>
</entry>
<entry>
<title><![CDATA[Timus_1122_Game]]></title>
<link href="https://github.com/sillyplus/2014/05/08/timus_1122_game/"/>
<id>https://github.com/sillyplus/2014/05/08/timus_1122_game/</id>
<published>2014-05-08T06:30:49.000Z</published>
<updated>2015-10-19T11:44:47.000Z</updated>
<content type="html"><![CDATA[<p>题目大意:给出一个4×4的用黑白两色棋子覆盖的棋盘状态,以及选择任意某一棋子以其为中心进行翻转的一个3×3的01翻转规则,1为翻转,0则不翻转,问能否经过若干次操作,是的整个棋盘变成同一种颜色。</p>
<p>其实题目比较简单,类似的题也做过几道了。显然每个棋子以其为中心最多翻转一次。这样总共16个棋子也就是有2ˆ16种状态,然后就直接枚举每一种情况。然后我居然因为一个数组开小了,一直WA。最近真的脑子有点乱乱的=_=,刚才终于让我De完bug了,所以写写题解放松一下。<br><a id="more"></a><br><figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br><span class="line">63</span><br><span class="line">64</span><br><span class="line">65</span><br><span class="line">66</span><br><span class="line">67</span><br><span class="line">68</span><br><span class="line">69</span><br><span class="line">70</span><br><span class="line">71</span><br></pre></td><td class="code"><pre><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstring></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cmath></span></span></span><br><span class="line"></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><br><span class="line"><span class="keyword">int</span> f[<span class="number">8</span>][<span class="number">8</span>] = {<span class="number">0</span>}, a[<span class="number">8</span>][<span class="number">8</span>] = {<span class="number">0</span>}, b[<span class="number">4</span>][<span class="number">4</span>] = {<span class="number">0</span>};</span><br><span class="line"><span class="keyword">int</span> dx[<span class="number">4</span>][<span class="number">4</span>], dy[<span class="number">4</span>][<span class="number">4</span>];</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">bool</span> <span class="title">check</span><span class="params">()</span> </span>{</span><br><span class="line"> <span class="keyword">int</span> s = 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">1</span>; i <= <span class="number">4</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">4</span>; j++)</span><br><span class="line"> <span class="keyword">if</span> (a[i][j] != s) <span class="keyword">return</span> <span class="literal">false</span>;</span><br><span class="line"> <span class="keyword">return</span> <span class="literal">true</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">convert</span><span class="params">(<span class="keyword">int</span> x, <span class="keyword">int</span> y)</span> </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">3</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">3</span>; j++)</span><br><span class="line"> a[x+dx[i][j]][y+dy[i][j]] = a[x+dx[i][j]][y+dy[i][j]] ^ b[i][j];</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">get</span><span class="params">()</span> </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">4</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">4</span>; j++)</span><br><span class="line"> a[i][j] = f[i][j];</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="keyword">char</span> c;</span><br><span class="line"> <span class="built_in">memset</span>(f, <span class="number">0</span>, <span class="keyword">sizeof</span>(f));</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">3</span>; i++) {</span><br><span class="line"> dy[i][<span class="number">1</span>] = dx[<span class="number">1</span>][i] = -<span class="number">1</span>;</span><br><span class="line"> dy[i][<span class="number">2</span>] = dx[<span class="number">2</span>][i] = <span class="number">0</span>;</span><br><span class="line"> dy[i][<span class="number">3</span>] = dx[<span class="number">3</span>][i] = <span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"></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">4</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">4</span>; j++) {</span><br><span class="line"> <span class="built_in">cin</span> >> c;</span><br><span class="line"> <span class="keyword">if</span> (c == <span class="string">'B'</span>) f[i][j] = <span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"></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">3</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">3</span>; j++) {</span><br><span class="line"> <span class="built_in">cin</span> >> c;</span><br><span class="line"> b[i][j] = c - <span class="string">'0'</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">int</span> ans = <span class="number">1</span> << <span class="number">17</span>, x, y;</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">1</span> << <span class="number">16</span>); i++) {</span><br><span class="line"> get();</span><br><span class="line"> <span class="keyword">int</span> tmp = <span class="number">0</span>, k = i, bit = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">while</span> (k) {</span><br><span class="line"> <span class="keyword">while</span> (k % <span class="number">2</span> == <span class="number">0</span>) {</span><br><span class="line"> bit++;</span><br><span class="line"> k /= <span class="number">2</span>;</span><br><span class="line"> }</span><br><span class="line"> x = (bit-<span class="number">1</span>)/<span class="number">4</span> + <span class="number">1</span>;</span><br><span class="line"> y = (bit % <span class="number">4</span> == <span class="number">0</span>) ? <span class="number">4</span> : bit%<span class="number">4</span>;</span><br><span class="line"> convert(x, y);</span><br><span class="line"> tmp++;</span><br><span class="line"> bit++;</span><br><span class="line"> k /= <span class="number">2</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span> (check()) ans = min(ans, tmp);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span> (ans < (<span class="number">1</span> << <span class="number">17</span>)) <span class="built_in">cout</span> << ans << endl;</span><br><span class="line"> <span class="keyword">else</span> <span class="built_in">cout</span> << <span class="string">"Impossible"</span> << endl;</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>
]]></content>
<summary type="html">
<![CDATA[<p>题目大意:给出一个4×4的用黑白两色棋子覆盖的棋盘状态,以及选择任意某一棋子以其为中心进行翻转的一个3×3的01翻转规则,1为翻转,0则不翻转,问能否经过若干次操作,是的整个棋盘变成同一种颜色。</p>
<p>其实题目比较简单,类似的题也做过几道了。显然每个棋子以其为中心最多翻转一次。这样总共16个棋子也就是有2ˆ16种状态,然后就直接枚举每一种情况。然后我居然因为一个数组开小了,一直WA。最近真的脑子有点乱乱的=_=,刚才终于让我De完bug了,所以写写题解放松一下。<br>]]>
</summary>
<category term="Search" scheme="https://github.com/sillyplus/tags/Search/"/>
<category term="Timus" scheme="https://github.com/sillyplus/tags/Timus/"/>
<category term="题解" scheme="https://github.com/sillyplus/categories/%E9%A2%98%E8%A7%A3/"/>
</entry>
<entry>
<title><![CDATA[Timus_一周做题记录]]></title>
<link href="https://github.com/sillyplus/2014/05/04/timus-a-week/"/>
<id>https://github.com/sillyplus/2014/05/04/timus-a-week/</id>
<published>2014-05-04T03:53:51.000Z</published>
<updated>2015-10-19T11:44:41.000Z</updated>
<content type="html"><![CDATA[<p>虽然很多是水题,不过还是记录一下。。。。然后还有好多得做的题目都还没补TAT<br><a id="more"></a><br><strong>1209. 1, 10, 100, 1000…</strong></p>
<p>一个这样的串110100100010000……问第n位是什么。</p>
<p>很明显第n*(n+1)/2位才会是1,其中n为正整数,所以判断一下就行了。</p>
<p><strong>1224. Spiral</strong></p>
<p>给定一个N*M的矩阵,开始面向左侧,由右上角开始顺时针方向走,每个格子走过一次,为走完整个矩阵需要改变方向多少次。</p>
<p>答案是这个:min(2<em>(n-1), 2</em>(m-1)+1)。至于为什么,仔细想想的话应该就明白了,不过这题虽然简单,我好像还是被坑了好几次。比如说什么 <em>N</em>, <em>M</em> (1 ≤ <em>N</em>, <em>M</em> ≤ 2^31 − 1),但是乘一下就爆int,得用long long之类的。。。</p>
<p><strong>1225. Flags</strong></p>
<p>用红、白、蓝三种颜色去染一排连续的格子,染色规则是</p>
<ul>
<li>相邻两个格子颜色不能一样</li>
<li>蓝色必须夹在红色和白色的格子中间</li>
</ul>
<p>求给定格子数的染色方案<br>显然,最后一个格子不能染蓝色,就是说,最后一个格子只能是红or白。那个我们就可以得到如下关系</p>
<pre><code>F<span class="string">[N]</span> = F<span class="string">[N-1]</span> + F<span class="string">[N-2]</span>
</code></pre><p>第N-1个,最后是红或者白,那么第N个只能选白或者红。第N-1个是蓝色,即N-2个为红或者白,就是F[N-2],那么第N个只能是白或者红。然后就是F[1] = F[2] = 2。</p>
<p><strong>1226. esreveR redrO</strong></p>
<p>给定一个文本,把每一段连续的字母翻转,其它字符保持不变。<br>直接做咯,每次看到涉及字符串的题总是会有恐惧感。贴一下代码,安慰一下自己的心灵,有时候字符串的题没有想像中那么多坑。</p>
<figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br></pre></td><td class="code"><pre><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstdio></span></span></span><br><span class="line"></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><br><span class="line"><span class="keyword">char</span> a[<span class="number">300</span>];</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="keyword">char</span> c;</span><br><span class="line"> <span class="keyword">int</span> t = -<span class="number">1</span>;</span><br><span class="line"> <span class="keyword">while</span> (<span class="number">1</span>) {</span><br><span class="line"> c = getchar();</span><br><span class="line"> <span class="keyword">if</span> (c == EOF) <span class="keyword">break</span>;</span><br><span class="line"> <span class="keyword">if</span> ((c >= <span class="string">'a'</span> && c <= <span class="string">'z'</span>) || (c >= <span class="string">'A'</span> && c <= <span class="string">'Z'</span>)) {</span><br><span class="line"> a[++t] = c;</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = t; i >= <span class="number">0</span>; i--)</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%c"</span>, a[i]);</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%c"</span>, c);</span><br><span class="line"> t = -<span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = t; i >= <span class="number">0</span>; i--)</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%c"</span>, a[i]);</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><strong> 1227. Rally Championship</strong></p>
<p><a href="http://sillyplus.com/2014/05/389/" target="_blank" rel="external">详情请戳</a></p>
<p><strong>1228. Array</strong></p>
<p>这个读懂题就会做了。。。。</p>
<p><strong>1229. Strong Brickwork</strong></p>
<p><a href="http://sillyplus.com/2014/05/383/" target="_blank" rel="external">详情请戳</a></p>
<p><strong> 1258. Pool</strong></p>
<p>题目可以理解为,给一个矩形,上下左右四条边分别用F、B、L、R表示,给定起始点还有终点的坐标,求一束光由起点到终点的移动距离,给出反射的边的序列。</p>
<p>我们可以把四条边都想像成镜子,然后就是我们学物理时的那点小花招,把求两点间的折线的长度转化成了求两点间的直线距离。我想了好久才理清楚怎么变换坐标。。。。,感觉这还是一道很有趣的题目,一开始以为是变态的计算机何,所以不敢做TAT</p>
<figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br></pre></td><td class="code"><pre><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><string></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cmath></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstdio></span></span></span><br><span class="line"></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><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="keyword">double</span> w, d, x1, y1, x2, y2, x, y;</span><br><span class="line"> <span class="built_in">string</span> s;</span><br><span class="line"> <span class="built_in">cin</span> >> w >> d;</span><br><span class="line"> <span class="built_in">cin</span> >> x1 >> y1;</span><br><span class="line"> <span class="built_in">cin</span> >> x2 >> y2;</span><br><span class="line"> <span class="built_in">cin</span> >> s;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i < s.length(); i++) {</span><br><span class="line"> <span class="keyword">switch</span> (s[i]) {</span><br><span class="line"> <span class="keyword">case</span> <span class="string">'F'</span>:</span><br><span class="line"> y1 = -y1;</span><br><span class="line"> <span class="keyword">break</span>;</span><br><span class="line"> <span class="keyword">case</span> <span class="string">'B'</span>:</span><br><span class="line"> y1 = <span class="number">2</span> * d - y1;</span><br><span class="line"> <span class="keyword">break</span>;</span><br><span class="line"> <span class="keyword">case</span> <span class="string">'L'</span>:</span><br><span class="line"> x1 = -x1;</span><br><span class="line"> <span class="keyword">break</span>;</span><br><span class="line"> <span class="keyword">case</span> <span class="string">'R'</span>:</span><br><span class="line"> x1 = <span class="number">2</span> * w - x1;</span><br><span class="line"> <span class="keyword">break</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="built_in">cout</span> << x1 << <span class="string">' '</span> << y1 << endl;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">double</span> ans;</span><br><span class="line"> ans = <span class="built_in">sqrt</span>((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%.4f\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>
<p><strong> 1259. How to Become Star?</strong></p>
<p>根据给定的定义,求N角星的个数。</p>
<p><strong>Definition.</strong> A <em>star</em> is the closed broken line built by the final amount of steps of the following algorithm:</p>
<ol>
<li>Fix and arbitrary angle α (0 < α < π).</li>
</ol>
<ol>
<li>The first link is (0, 0) — (1, 0).</li>
</ol>
<ol>
<li>The second link is the resultant of the turn by the angle α counter-clockwise with respect to the point (1, 0) of the first one.</li>
</ol>
<ol>
<li>The (<em>i</em> + 2)-nd link is the resultant of the turn by the angle α counter-clockwise of the (<em>i</em> + 1)-st one with respect to the free end (the opposite to the one that is connected to the <em>i</em>-th link) of the (<em>i</em> + 1)-st link.</li>
</ol>
<ol>
<li>The algorithm stops immediately when the broken line is closed.</li>
</ol>
<p><img src="http://acm.timus.ru/image/get.aspx/fd5fa0a0-4cea-47b0-82a0-5ffb61f70b4e" alt="Problem illustration"><img src="http://acm.timus.ru/image/get.aspx/a879b546-2258-4a58-9cf6-d6916cc441ef" alt="Problem illustration"></p>
<p>该怎么证明呢( ´ ▽ ` )ノ,自行参见题目的discuss吧或者自行证明,可以用复数。最后答案是Φ(n)/2</p>
<p>好吧,来补个证明,希望没讲错,外加能讲清楚:</p>
<ul>
<li>设 β=π-α ,则 0 < β < π ; //N, α为题目描述中的</li>
</ul>
<ul>
<li>有 Nβ mod 2π = 0,则对于该β,N为对应的最小的整数。 //为什么mod 2π等于0,我们可以想像把N角星的各个顶点移动到(1, 0)这点,则每次画一条新边就是上一条边顺时针旋转β,第n条边要刚好跟第一条边重合,且是第一次跟第一条边重合。</li>
</ul>
<ul>
<li>∴β = p * π / N, p为整数, 又为满足上式p要为偶数</li>
</ul>
<ul>
<li>∴β = 2 <em> i </em> π / N ,0 < i < N/2</li>
</ul>
<ul>
<li>上面说到,N为β对应的最小的整数,即不存在整数 k,k < N, 且 kβ mod 2π = 0, 即</li>
</ul>
<ul>
<li>对任意k < N,k <em> 2 </em> i * π / N mod 2π ≠ 0.</li>
</ul>
<ul>
<li>∴k * i / N 不能为整数,即 i 必须与 N 互质,可得最后的答案为Φ(n)/2</li>
</ul>
<p><strong>1260. Nudnik Photographer</strong></p>
<p>1~n进行排列,第一位为1,相邻两个数字的差不能超过2。求方案数。</p>
<p>F[N]表示N个数的方案数,那么F[N]可由如下方法得到:</p>
<ul>
<li>2放在第二位,则是F[N-1]</li>
</ul>
<ul>
<li>3放在第二位,第三位放2(那么再小一位一定是4),就是F[N-3]</li>
</ul>
<ul>
<li>3放在第二位,第三位不放2,且n >=4,那么就只有一种方案,形如:1、3、5、7、8、6、4、2</li>
</ul>
<p>所以最后可的方程:F[N] = F[N-1] + F[N-3] + 1</p>
<p><strong>1261. Tips</strong></p>
<p>某岛使用的货币的面值是3的幂,3,9,27…..,你要付一笔N元的账单,并且需要给小费,小费需要由不同面值的纸币组成。输出你需要付的最少的钱数sum,以及小费数tips。</p>
<p>显然3进制下,sum以及tips只由1和0组成。然后就是构造出这个最小的tips了,我们可以把N表示成3进制,由最低位开始,如果N在该位为2,tips和N就加上3在该位的幂。好像大概就是这么回事了。</p>
<figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br></pre></td><td class="code"><pre><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"></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><br><span class="line"><span class="keyword">int</span> a[<span class="number">100</span>];</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="keyword">int</span> n, m = <span class="number">1</span>, x = <span class="number">0</span>, y = <span class="number">0</span>;</span><br><span class="line"> <span class="built_in">cin</span> >> n;</span><br><span class="line"> x = n;</span><br><span class="line"> <span class="keyword">do</span> {</span><br><span class="line"> <span class="keyword">if</span> (n % <span class="number">3</span> == <span class="number">2</span>) {</span><br><span class="line"> y += m;</span><br><span class="line"> n++;</span><br><span class="line"> }</span><br><span class="line"> n /= <span class="number">3</span>;</span><br><span class="line"> m *= <span class="number">3</span>;</span><br><span class="line"> } <span class="keyword">while</span> (n);</span><br><span class="line"> <span class="keyword">if</span> (!y) y = m;</span><br><span class="line"> <span class="built_in">cout</span> << x + y << <span class="string">' '</span> << y << endl;</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><strong> 1262. Pseudo-Roman Number</strong></p>
<p>这题的难度同样在于读题,理解题意后就会发现,对于1~9每个数字都有一个最短的表示方式,然后逐位处理就行了。</p>
<p><strong>1263. Elections</strong></p>
<p>直接做,统计每个数字出现的百分比,不解释</p>
<p><strong>1264. Workdays</strong></p>
<p>这是签到题吧=_=</p>
<p><strong>后记:</strong>终于写完了的说,发现写题解还是很累,很多自己想得明白但还是说不清楚,再也不写这种一点都不过简要的什么一周记录了,以后就挑一些有趣的来写就好了,可是我觉得很多题都很有趣怎么办(°_°)</p>
]]></content>
<summary type="html">
<![CDATA[<p>虽然很多是水题,不过还是记录一下。。。。然后还有好多得做的题目都还没补TAT<br>]]>
</summary>
<category term="Math" scheme="https://github.com/sillyplus/tags/Math/"/>
<category term="Timus" scheme="https://github.com/sillyplus/tags/Timus/"/>
<category term="题解" scheme="https://github.com/sillyplus/categories/%E9%A2%98%E8%A7%A3/"/>
</entry>
<entry>
<title><![CDATA[Timus_1227_Rally Championship]]></title>
<link href="https://github.com/sillyplus/2014/05/04/timus-1227-rally-championship/"/>
<id>https://github.com/sillyplus/2014/05/04/timus-1227-rally-championship/</id>
<published>2014-05-04T02:41:30.000Z</published>
<updated>2015-10-19T11:43:28.000Z</updated>
<content type="html"><![CDATA[<p>题目大意:给一个M给节点,N条边的无向图。问是否存在长度 >= S的一条路径。每条边一旦被选择,就只能从固定的一个方向通过。1 ≤ <em>M</em> ≤ 100; 1 ≤ <em>N</em> ≤ 10000; 1 ≤ <em>S</em> ≤ 10^6.</p>
<p>显然,如果存在回路必然可以,且注意可能存在重边。那么我们就可以对每个节点做一遍dfs。在dfs的过程中判断是否存在回到该点的回路,如果不存在就能得到由该点出发的最长路了,注意更新答案就行了。<br><a id="more"></a><br><figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br></pre></td><td class="code"><pre><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstdio></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstring></span></span></span><br><span class="line"></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><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> MN = <span class="number">110</span>;</span><br><span class="line"></span><br><span class="line"><span class="keyword">int</span> <span class="built_in">map</span>[MN][MN] = {<span class="number">0</span>};</span><br><span class="line"><span class="keyword">bool</span> f[MN] = {<span class="number">0</span>};</span><br><span class="line"></span><br><span class="line"><span class="keyword">int</span> n, m, s, root;</span><br><span class="line"><span class="keyword">bool</span> flag = <span class="literal">false</span>;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">dfs</span><span class="params">(<span class="keyword">int</span> rt, <span class="keyword">int</span> ds)</span> </span>{</span><br><span class="line"> <span class="keyword">if</span> (flag) <span class="keyword">return</span>;</span><br><span class="line"> <span class="keyword">if</span> (ds >= s) {</span><br><span class="line"> flag = <span class="literal">true</span>;</span><br><span class="line"> <span class="keyword">return</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">1</span>; i <= m; i++) {</span><br><span class="line"> <span class="keyword">if</span> (!f[i] && <span class="built_in">map</span>[rt][i]) {</span><br><span class="line"> <span class="keyword">int</span> tmp = <span class="built_in">map</span>[rt][i];</span><br><span class="line"> <span class="built_in">map</span>[rt][i] = <span class="built_in">map</span>[i][rt] = <span class="number">0</span>;</span><br><span class="line"> f[i] = <span class="literal">true</span>;</span><br><span class="line"> <span class="keyword">if</span> (i == root) {</span><br><span class="line"> flag = <span class="literal">true</span>;</span><br><span class="line"> <span class="keyword">return</span>;</span><br><span class="line"> }</span><br><span class="line"> dfs(i, ds+tmp);</span><br><span class="line"> <span class="built_in">map</span>[rt][i] = <span class="built_in">map</span>[i][rt] = tmp;</span><br><span class="line"> f[i] = <span class="literal">false</span>;</span><br><span class="line"> <span class="keyword">if</span> (flag) <span class="keyword">return</span>;</span><br><span class="line"> }</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="built_in">cin</span> >> m >> n >> s;</span><br><span class="line"> <span class="keyword">int</span> u, v, dis;</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="built_in">scanf</span>(<span class="string">"%d%d%d"</span>, &u, &v, &dis);</span><br><span class="line"> <span class="keyword">if</span> (!<span class="built_in">map</span>[u][v]) {</span><br><span class="line"> <span class="built_in">map</span>[u][v] = <span class="built_in">map</span>[v][u] = dis;</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> flag = <span class="literal">true</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">1</span>; i <= m; i++) {</span><br><span class="line"> <span class="keyword">if</span> (flag) <span class="keyword">break</span>;</span><br><span class="line"> <span class="built_in">memset</span>(f, <span class="literal">false</span>, <span class="keyword">sizeof</span>(f));</span><br><span class="line"> root = i;</span><br><span class="line"> dfs(i, <span class="number">0</span>);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span> (flag)</span><br><span class="line"> <span class="built_in">cout</span> << <span class="string">"YES"</span> << endl;</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> <span class="built_in">cout</span> << <span class="string">"NO"</span> << endl;</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>
]]></content>
<summary type="html">
<![CDATA[<p>题目大意:给一个M给节点,N条边的无向图。问是否存在长度 >= S的一条路径。每条边一旦被选择,就只能从固定的一个方向通过。1 ≤ <em>M</em> ≤ 100; 1 ≤ <em>N</em> ≤ 10000; 1 ≤ <em>S</em> ≤ 10^6.</p>
<p>显然,如果存在回路必然可以,且注意可能存在重边。那么我们就可以对每个节点做一遍dfs。在dfs的过程中判断是否存在回到该点的回路,如果不存在就能得到由该点出发的最长路了,注意更新答案就行了。<br>]]>
</summary>
<category term="题解" scheme="https://github.com/sillyplus/categories/%E9%A2%98%E8%A7%A3/"/>
</entry>
<entry>
<title><![CDATA[Timus_1229_Strong Brickwork]]></title>
<link href="https://github.com/sillyplus/2014/05/04/timus-1229-strong-brickwork/"/>
<id>https://github.com/sillyplus/2014/05/04/timus-1229-strong-brickwork/</id>
<published>2014-05-04T01:36:11.000Z</published>
<updated>2015-10-19T11:43:46.000Z</updated>
<content type="html"><![CDATA[<p><a href="http://acm.timus.ru/problem.aspx?space=1&num=1229" target="_blank" rel="external">Strong Brickwork</a></p>
<p>题目大意:给一个N*M(N, M均为偶数,且不超过100)的棋盘,该棋盘有两层,使用1*2的骨牌覆盖,现在给你第一层的覆盖方案,要你求出符合以下要求的任意一个完全覆盖第二层的方案:</p>
<ul>
<li>一块骨牌不能完全放在第一层的某块骨牌上<br>也就是说第二层的每一块骨牌必须同时在第一层的两块不同的骨牌上面<br>看到棋盘还跟骨牌覆盖方案有关,很容易就会想到那个——二分图匹配。构图也很简单,先把格子黑白染色分类,想像一下平时看到的国际象棋棋盘。然后对于每个黑色格子(或白色),如果跟他相邻的格子,如果他们不在同一块骨牌上就连一条边,这样就构图完毕了,跑一边完全匹配,如果刚好有匹配成功(N*M)/2条边就说明有解。<a id="more"></a>
做这道题算是试了一下匈牙利算法的模版,然后写的时候一开始染色分类的时候写错了,纠结了好久=_=。<br><table width="722" style="height: 174px;" class="sample"><br><tbody><br><tr><br>input<br>output<br></tr><tr>
</tr></tbody></table></li>
</ul>
<td><br><br><br> 2 4<br> 1 1 2 2<br> 3 3 4 4<br><br><br><br></td>
<td>
<pre><code><span class="number">2</span> <span class="number">1</span> <span class="number">1</span> <span class="number">4</span>
<span class="number">2</span> <span class="number">3</span> <span class="number">3</span> <span class="number">4</span>
</code></pre><p></p></td><br><br><br><p></p>
<figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br><span class="line">63</span><br><span class="line">64</span><br><span class="line">65</span><br><span class="line">66</span><br><span class="line">67</span><br><span class="line">68</span><br><span class="line">69</span><br><span class="line">70</span><br><span class="line">71</span><br><span class="line">72</span><br><span class="line">73</span><br><span class="line">74</span><br><span class="line">75</span><br><span class="line">76</span><br><span class="line">77</span><br><span class="line">78</span><br><span class="line">79</span><br><span class="line">80</span><br></pre></td><td class="code"><pre><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><vector></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstdio></span></span></span><br><span class="line"><span class="preprocessor">#<span class="keyword">include</span> <span class="string"><cstring></span></span></span><br><span class="line"></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><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> MN = <span class="number">110</span>;</span><br><span class="line"></span><br><span class="line"><span class="keyword">int</span> n, m, tot;</span><br><span class="line"><span class="keyword">int</span> mp1[MN][MN] = {<span class="number">0</span>};</span><br><span class="line"><span class="keyword">int</span> mp2[MN][MN] = {<span class="number">0</span>};</span><br><span class="line"><span class="keyword">int</span> from[MN*MN] = {<span class="number">0</span>};</span><br><span class="line"><span class="built_in">vector</span><<span class="keyword">int</span>> g[MN*MN];</span><br><span class="line"><span class="keyword">bool</span> use[MN*MN];</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">bool</span> <span class="title">match</span><span class="params">(<span class="keyword">int</span> x)</span> </span>{</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i < g[x].size(); i++)</span><br><span class="line"> <span class="keyword">if</span> (!use[g[x][i]]) {</span><br><span class="line"> use[g[x][i]] = <span class="literal">true</span>;</span><br><span class="line"> <span class="keyword">if</span> (from[g[x][i]] == -<span class="number">1</span> || match(from[g[x][i]])) {</span><br><span class="line"> from[g[x][i]] = x;</span><br><span class="line"> <span class="keyword">return</span> <span class="literal">true</span>;</span><br><span class="line"> }</span><br><span class="line"> }</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="function"><span class="keyword">int</span> <span class="title">hungary</span><span class="params">()</span> </span>{</span><br><span class="line"> tot = <span class="number">0</span>;</span><br><span class="line"> <span class="built_in">memset</span>(from, <span class="number">255</span>, <span class="keyword">sizeof</span>(from));</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i < n*m; i++) {</span><br><span class="line"> <span class="built_in">memset</span>(use, <span class="number">0</span>, <span class="keyword">sizeof</span>(use));</span><br><span class="line"> <span class="keyword">if</span> (match(i)) tot++;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> tot;</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="built_in">cin</span> >> n >> m;</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 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">"%d"</span>, &mp1[i][j]);</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 class="keyword">for</span> (<span class="keyword">int</span> j = <span class="number">0</span>; j < m; j++) <span class="keyword">if</span> ((i+j)%<span class="number">2</span> != <span class="number">0</span>) {</span><br><span class="line"> <span class="keyword">if</span> ((j+<span class="number">1</span> < m) && (mp1[i][j] != mp1[i][j+<span class="number">1</span>]))</span><br><span class="line"> g[i*m+j].push_back(i*m+j+<span class="number">1</span>);</span><br><span class="line"> <span class="keyword">if</span> ((i+<span class="number">1</span> < n) && (mp1[i][j] != mp1[i+<span class="number">1</span>][j]))</span><br><span class="line"> g[i*m+j].push_back((i+<span class="number">1</span>)*m+j);</span><br><span class="line"> <span class="keyword">if</span> ((j-<span class="number">1</span> >= <span class="number">0</span>) && (mp1[i][j] != mp1[i][j-<span class="number">1</span>]))</span><br><span class="line"> g[i*m+j].push_back(i*m+j-<span class="number">1</span>);</span><br><span class="line"> <span class="keyword">if</span> ((i-<span class="number">1</span> >= <span class="number">0</span>) && (mp1[i][j] != mp1[i-<span class="number">1</span>][j]))</span><br><span class="line"> g[i*m+j].push_back((i-<span class="number">1</span>)*m+j);</span><br><span class="line"> }</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"> ans = hungary();</span><br><span class="line"> <span class="keyword">if</span> (ans == (n*m/<span class="number">2</span>)) {</span><br><span class="line"> <span class="built_in">memset</span>(mp2, <span class="number">255</span>, <span class="keyword">sizeof</span>(mp2));</span><br><span class="line"> <span class="keyword">int</span> k = <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 < n*m; i++)</span><br><span class="line"> <span class="keyword">if</span> (from[i] != -<span class="number">1</span>) {</span><br><span class="line"> k++;</span><br><span class="line"> mp2[from[i]/m][from[i]%m] = k;</span><br><span class="line"> mp2[i/m][i%m] = k;</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 class="built_in">printf</span>(<span class="string">"%d"</span>, mp2[i][<span class="number">0</span>]);</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> j = <span class="number">1</span>; j < m; j++)</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">" %d"</span>, mp2[i][j]);</span><br><span class="line"> <span class="built_in">cout</span> << endl;</span><br><span class="line"> }</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> <span class="built_in">cout</span> << -<span class="number">1</span> << endl;</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>
<summary type="html">
<![CDATA[<p><a href="http://acm.timus.ru/problem.aspx?space=1&num=1229">Strong Brickwork</a></p>
<p>题目大意:给一个N*M(N, M均为偶数,且不超过100)的棋盘,该棋盘有两层,使用1*2的骨牌覆盖,现在给你第一层的覆盖方案,要你求出符合以下要求的任意一个完全覆盖第二层的方案:</p>
<ul>
<li>一块骨牌不能完全放在第一层的某块骨牌上<br>也就是说第二层的每一块骨牌必须同时在第一层的两块不同的骨牌上面<br>看到棋盘还跟骨牌覆盖方案有关,很容易就会想到那个——二分图匹配。构图也很简单,先把格子黑白染色分类,想像一下平时看到的国际象棋棋盘。然后对于每个黑色格子(或白色),如果跟他相邻的格子,如果他们不在同一块骨牌上就连一条边,这样就构图完毕了,跑一边完全匹配,如果刚好有匹配成功(N*M)/2条边就说明有解。]]>
</summary>
<category term="Timus" scheme="https://github.com/sillyplus/tags/Timus/"/>
<category term="二分图" scheme="https://github.com/sillyplus/tags/%E4%BA%8C%E5%88%86%E5%9B%BE/"/>
<category term="题解" scheme="https://github.com/sillyplus/categories/%E9%A2%98%E8%A7%A3/"/>
</entry>
<entry>
<title><![CDATA[Poj 数论/组合/博弈论 题目列表]]></title>
<link href="https://github.com/sillyplus/2014/04/29/poj-n-c-g-list/"/>
<id>https://github.com/sillyplus/2014/04/29/poj-n-c-g-list/</id>
<published>2014-04-29T08:31:24.000Z</published>
<updated>2015-10-19T11:43:24.000Z</updated>
<content type="html"><![CDATA[<p>转自:<a href="http://hi.baidu.com/lydrainbowcat/item/f16e64103f8c5c088fbde44c" target="_blank" rel="external">传送门</a></p>
<a id="more"></a>
<p><strong>博弈论</strong></p>
<p>POJ 2234 Matches Game<br>POJ 2975 Nim<br>POJ 2505 A multiplication game<br>POJ 1067 取石子游戏<br>POJ 2484 A Funny Game<br>POJ 2425 A Chess Game<br>POJ 2960 S-Nim<br>POJ 1704 Georgia and Bob<br>POJ 1740 A New Stone Game<br>POJ 2068 Nim<br>POJ 3480 John<br>POJ 2348 Euclid’s Game<br>POJ 3710 Christmas Game<br>POJ 3533 Light Switching Game<br>POJ 3537 Crosses and Crosses</p>
<p><strong>数论/组合</strong></p>
<p><strong>1.burnside定理,polya计数法</strong><br>这个大家可以看brudildi的《组合数学》,那本书的这一章写的很详细也很容易理解。最好能完全看懂了,理解了再去做题,不要只记个公式。<br><em>简单题:(直接用套公式就可以了)<br>pku2409 Let it Bead<br>pku2154 Color<br>pku1286 Necklace of Beads
</em>强烈推荐:(这题很不错哦,很巧妙)<br>pku2888 Magic Bracelet<br><strong>2.置换,置换的运算</strong></p>
<pre><code>置换的概念还是比较好理解的,《组合数学》里面有讲。对于置换的幂运算大家可以参考一下潘震皓的那篇《置换群快速幂运算研究与探讨》,写的很好。
</code></pre><p><em>简单题:(应该理解概念就可以了)<br>pku3270 Cow Sorting<br>pku1026 Cipher
</em>置换幂运算:<br>pku1721 CARDS<br>pku3128 Leonardo’s Notebook<br><em>推荐:(不错的应用)<br>pku3590 The shuffle Problem<br><em>*3.素数,整数分解,欧拉函数</em></em></p>
<pre><code><span class="xml">素数是可能数论里最永恒,最经典的问题了(我们的队名就叫PrimeMusic</span><span class="keyword">^-</span><span class="xml">^)。素数的判断,筛法求素数,大素数的判断···还有很多其他问题都会用到素数。</span>
</code></pre><p><em>最水最水的:(心情不爽时用来解闷吧)<br>pku1365 Prime Land<br>pku2034 Anti-prime Sequences<br>pku2739 Sum of Consecutive Prime Numbers<br>pku3518 Prime Gap<br>pku3126 Prime Path<br>pku1595 Prime Cuts<br>pku3641 Pseudoprime numbers<br>pku2191 Mersenne Composite Numbers<br>pku1730 Perfect Pth Powers<br>pku2262 Goldbach’s Conjecture<br>pku2909 Goldbach’s Conjecture
</em>筛法:<br>pku2689 Prime Distance(很好的一个应用)<br><em>反素数:<br>zoj2562 More Divisors
</em>素数判断,整数分解:<br>这两题都要用到miller_rabin的素数判断和pollard_rho的整数分解,算法书上都会有,应该是属于模板题吧,不过最好看懂自己敲一遍。<br>pku1811 Prime Test<br>pku2429 GCD & LCM Inverse</p>
<p><em>欧拉函数:<br>数论里很多地方都能用到欧拉函数,很重要的。<br>pku1284 Primitive Roots (关于原根的定理:p的原根为euler(euler(p)),本题中当p为奇素数时euler(p)=p-1,故答案为euler(p-1))<br>pku2407 Relatives (很水)<br>pku2773 Happy 2006<br>pku2478 Farey Sequence (快速求欧拉函数)<br>pku3090 Visible Lattice Points (法雷级数)
</em>推荐:(欧拉函数,费马小定理)<br>pku3358 Period of an Infinite Binary Expansion<br><em>整数分解<br>这个也很重要的耶,包括大数的表示方法。<br>pku2992 Divisors<br>pku3101 Astronomy (分数的最小公倍数)<br><em>*4.扩展欧几里得,线性同余,中国剩余定理</em></em></p>
<pre><code>这应该是数论里比较重要的一个部分吧,这类的题目也挺多,具体的内容最好先看看数论书,我也整理过一些,可以参考参考:
</code></pre><p><em>简单题:<br>pku1006 Biorhythms<br>pku1061 青蛙的约会<br>pku2891 Strange Way to Express Integers<br>pku2115 C Looooops<br>pku2142 The Balance
</em>强烈推荐:<br>sgu106 The equation<br>pku3708 Recurrent Function (经典)<br><strong> 5.约瑟夫环问题</strong></p>
<pre><code>这个问题还是比较有意思的,不是很难。
</code></pre><p><em>简单题:<br>pku3517 And Then There Was One<br>pku1781 In Danger<br>pku1012 Joseph<br>pku2244 Eeny Meeny Moo
</em>推荐:<br>pku2886 Who Gets the Most Candies?<br><strong>6.高斯消元法解方程</strong></p>
<pre><code>其实解方程并不是很难,就是按线性代数中学的那种方法,把系数矩阵化成上三角矩阵或数量矩阵,不过有些题目要判断是否有解,或枚举所有解。不过这类题目我认为比较难的还是怎么去建立这个方程组,这个理解了,就没什么大问题了。
</code></pre><p><em>简单题:<br>pku1222 EXTENDED LIGHTS OUT<br>pku1681 Painter’s Problem<br>pku1830 开关问题
</em>推荐:<br>pku2947 Widget Factory<br>pku2065 SETI<br><em>强烈推荐:<br>pku1753 Flip Game<br>pku3185 The Water Bowls
</em>变态题:<br>pku1487 Single-Player Games</p>
<p><strong>7.矩阵</strong><br>用矩阵来解决问题确实很常见,但我现在用到还不是很好,很多难题我还不会做。建议大家可以去看Matrix67的那篇关于矩阵的十个问题,确实很经典,但不太好看懂。<br><em>简单:<br>pku3070 Fibonacci<br>pku3233 Matrix Power Series<br>pku3735 Training little cats<br><em>*8.高次同余方程</em></em></p>
<pre><code>有关这个问题我应该是没什么发言权了,A^B%<span class="keyword">C</span>=<span class="keyword">D</span>,我现在只会求<span class="keyword">D</span>和B,唉,很想知道A该怎么求。就先推荐几道题目吧,这里涉及到了一个baby-step,giant-step算法。
</code></pre><p>pku3243 Clever Y<br>pku2417 Discrete Logging<br><strong>9.容斥原理,鸽巢原理</strong></p>
<pre><code>很有用的两个定理,但好像单独考这两个定理的不是很多。
</code></pre><p><em>鸽巢原理:<br>pku2356 Find a multiple<br>pku3370 Halloween treats
</em>容斥原理:<br>hdu1695 GCD<br>hdu2461 Rectangles<br><strong>10.找规律,推公式</strong></p>
<pre><code>这类题目的设计一般都非常巧妙,真的是很难想出来,但只要找到规律或推出公式,就不是很难了。我很多都是在参考别人思路的情况下做的,能自己想出来真的很不容易。
</code></pre><p><em>个人感觉都挺不错的:<br>pku3372 Candy Distribution<br>pku3244 Difference between Triplets<br>pku1809 Regetni<br>pku1831 不定方程组<br>pku1737 Connected Graph<br>pku2480 Longge’s problem<br>pku1792 Hexagonal Routes<br><em>*11.排列组合,区间计数,计数序列</em></em></p>
<pre><code>这些题目可能需要一些组合数学知识,基本上高中的知识就够了。区间计数问题一般不难,但写的时候需要仔细一些,各种情况要考虑到位。至于像卡特兰数,差分序列,斯特灵数···都还挺有意思,可以去看看《组合数学》。
</code></pre><p><em>简单题:<br>pku1850 Code<br>pku1150 The Last Non-zero Digit<br>pku1715 Hexadecimal Numbers<br>pku2282 The Counting Problem<br>pku3286 How many 0’s?
</em>推荐:<br>pku3252 Round Numbers<br><em>计数序列:<br>pku1430 Binary Stirling Numbers<br>pku2515 Birthday Cake<br>pku1707 Sum of powers<br><em>*12.二分法</em></em></p>
<pre><code>二分的思想还是很重要的,这里就简单推荐几个纯粹的二分题。
</code></pre><p><em>简单:<br>pku3273 Monthly Expense<br>pku3258 River Hopscotch<br>pku1905 Expanding Rods<br>pku3122 Pie
</em>推荐:<br>pku1845 Sumdiv<br><strong>13.稳定婚姻问题</strong></p>
<pre><code>无意中接触到这个算法,还蛮有意思的,《组合数学》中有详细的介绍。
</code></pre><p>pku3487 The Stable Marriage Problem<br>zoj1576 Marriage is Stable<br><strong>14.数位类统计问题</strong></p>
<pre><code>在航点月赛中第一次接触到这类问题,scau大牛little龙推荐我看了一篇论文,<span class="number">09</span>年刘聪的《浅谈数位类统计问题》,这篇论文相当精彩,也相当详 细,每道题都有详细的分析和作者的参考代码。所以我也没什么可说的了,这些题的代码我博客里也就不贴了,大家直接去看论文吧。
</code></pre><p>简单:<br>ural1057 Amount of degrees<br>spoj1182 Sorted bit squence<br>hdu3271 SNIBB<br>较难:<br>spoj2319 Sequence<br>sgu390 Tickets</p>
]]></content>
<summary type="html">
<![CDATA[<p>转自:<a href="http://hi.baidu.com/lydrainbowcat/item/f16e64103f8c5c088fbde44c">传送门</a></p>]]>
</summary>
<category term="Poj" scheme="https://github.com/sillyplus/tags/Poj/"/>
<category term="资源" scheme="https://github.com/sillyplus/tags/%E8%B5%84%E6%BA%90/"/>
<category term="资源" scheme="https://github.com/sillyplus/categories/%E8%B5%84%E6%BA%90/"/>
</entry>
<entry>
<title><![CDATA[Poj 计算几何入门题目列表]]></title>
<link href="https://github.com/sillyplus/2014/04/19/poj-geometry-list/"/>
<id>https://github.com/sillyplus/2014/04/19/poj-geometry-list/</id>
<published>2014-04-19T07:30:20.000Z</published>
<updated>2015-10-19T11:43:19.000Z</updated>
<content type="html"><![CDATA[<p>转载自:<a href="http://hi.baidu.com/novosbirsk/item/16330d2b7be6910e42634a13" target="_blank" rel="external">PKKJ @ SCAU - A GISer</a></p>
<p>计算几何题的特点与做题要领:</p>
<p>1.大部分不会很难,少部分题目思路很巧妙<br>2.做计算几何题目,模板很重要,模板必须高度可靠。<br>3.要注意代码的组织,因为计算几何的题目很容易上两百行代码,里面大部分是模板。如果代码一片混乱,那么会严重影响做题正确率。<br>4.注意精度控制。<br>5.能用整数的地方尽量用整数,要想到扩大数据的方法(扩大一倍,或扩大sqrt2)。因为整数不用考虑浮点误差,而且运算比浮点快。<br><a id="more"></a><br>一。点,线,面,形基本关系,点积叉积的理解 </p>
<p>POJ 2318 TOYS(推荐)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=2318" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=2318</a><br>POJ 2398 Toy Storage(推荐)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=2398" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=2398</a><br>一个矩形,有被若干直线分成N个格子,给出一个点的坐标,问你该点位于哪个点中。<br>知识点:其实就是点在凸四边形内的判断,若利用叉积的性质,可以二分求解。 </p>
<p>POJ 3304 Segments<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=3304" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=3304</a><br>知识点:线段与直线相交,注意枚举时重合点的处理 </p>
<p>POJ 1269 Intersecting Lines<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1269" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1269</a><br>知识点:直线相交判断,求相交交点 </p>
<p>POJ 1556 The Doors (推荐)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1556" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1556</a><br>知识点:简单图论+简单计算几何,先求线段相交,然后再用Dij求最短路。 </p>
<p>POJ 2653 Pick-up sticks<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=2653" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=2653</a><br>知识点:还是线段相交判断 </p>
<p>POJ 1066 Treasure Hunt<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1066" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1066</a><br>知识点:线段相交判断,不过必须先理解“走最少的门”是怎么一回事。 </p>
<p>POJ 1410 Intersection<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1410" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1410</a><br>知识点:线段与矩形相交。正确理解题意中相交的定义。<br>详见:<a href="http://hi.baidu.com/novosbirsk/blog/item/68c682c67e8d1f1d9d163df0.html" target="_blank" rel="external">http://hi.baidu.com/novosbirsk/blog/item/68c682c67e8d1f1d9d163df0.html
</a><br>POJ 1696 Space Ant (推荐)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1696" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1696</a><br>德黑兰赛区的好题目。需要理解点积叉积的性质 </p>
<p>POJ 3347 Kadj Squares<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=3347" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=3347</a><br>本人的方法极度猥琐。复杂的线段相交问题。这个题目是计算几何的扩大数据运算的典型应用,扩大根号2倍之后就避免了小数。 </p>
<p>POJ 2826 An Easy Problem?! (推荐)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=2826" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=2826</a><br>问:两条直线组成一个图形,能容纳多少雨水。很不简单的Easy Problem,要考虑所有情况。你不看discuss看看能否AC。(本人基本不能)提示一下,水是从天空垂直落下的。 </p>
<p>POJ 1039 Pipe<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1039" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1039</a><br>又是线段与直线相交的判断,再加上枚举的思想即可。 </p>
<p>POJ 3449 Geometric Shapes<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=3449" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=3449</a><br>判断几何体是否相交,不过输入输出很恶心。<br>此外,还有一个知识点,就是给出一个正方形(边不与轴平行)的两个对角线上的顶点,需要你求出另外两个点。必须掌握其方法。 </p>
<p>POJ 1584 A Round Peg in a Ground Hole<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1584" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1584</a><br>知识点:点到直线距离,圆与多边形相交,多边形是否为凸 </p>
<p>POJ 2074 Line of Sight (推荐)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=2074" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=2074</a><br>与视线问题的解法,关键是求过两点的直线方程,以及直线与线段的交点。数据有一个trick,要小心。 </p>
<p>二。凸包问题 </p>
<p>POJ 1113 Wall<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1113" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1113</a><br>知识点:赤裸裸的凸包问题,凸包周长加上圆周。 </p>
<p>POJ 2007 Scrambled Polygon<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=2007" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=2007</a><br>知识点:凸包,按极角序输出方案 </p>
<p>POJ 1873 The Fortified Forest (推荐)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1873" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1873</a><br>World Final的水题,先求凸包,然后再搜索。由于规模不大,可以使用位运算枚举。<br>详见:<a href="http://hi.baidu.com/novosbirsk/blog/item/333abd54c7f22c52574e0067.html" target="_blank" rel="external">http://hi.baidu.com/novosbirsk/blog/item/333abd54c7f22c52574e0067.html</a> </p>
<p>POJ 1228 Grandpa’s Estate (推荐)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1228" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1228</a><br>求凸包顶点数目,很多人求凸包的模板是会多出点的,虽然求面积时能得到正确答案,但是在这个题目就会出问题。此外,还要正确理解凸包的性质。 </p>
<p>POJ 3348 Cows<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=3348" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=3348</a><br>凸包面积计算 </p>
<p>三。面积问题,公式问题 </p>
<p>POJ 1654 Area<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1654" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1654</a><br>知识点:利用有向面积(叉积)计算多边形面积 </p>
<p>POJ 1265 Area<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1265" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1265</a><br>POJ 2954 Triangle<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=2954" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=2954</a><br>Pick公式的应用,多边形与整点的关系。(存在一个GCD的关系) </p>
<p>四。半平面交 </p>
<p>半平面交的主要应用是判断多边形是否存在核,还可以解决一些与线性方程组可行区域相关的问题(就是高中时的那些)。 </p>
<p>POJ 3335 Rotating Scoreboard<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=3335" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=3335</a><br>POJ 3130 How I Mathematician Wonder What You Are!<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=3130" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=3130</a><br>POJ 1474 Video Surveillance<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1474" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1474</a><br>知识点:半平面交求多边形的核,存在性判断 </p>
<p>POJ 1279 Art Gallery<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1279" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1279</a><br>半平面交求多边形的核,求核的面积 </p>
<p>POJ 3525 Most Distant Point from the Sea (推荐)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=3525" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=3525</a><br>给出一个多边形,求里面的一个点,其距离离多边形的边界最远,也就是多边形中最大半径圆。<br>可以使用半平面交+二分法解。二分这个距离,边向内逼近,直到达到精度。 </p>
<p>POJ 3384 Feng Shui (推荐)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=3384" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=3384</a><br>半平面交实际应用,用两个圆覆盖一个多边形,问最多能覆盖多边形的面积。<br>解法:用半平面交将多边形的每条边一起向“内”推进R,得到新的多边形,然后求多边形的最远两点。 </p>
<p>POJ 1755 Triathlon (推荐)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1755" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1755</a><br>半平面交判断不等式是否有解。注意不等式在转化时正负号的选择,这直接影响到半平面交的方向。 </p>
<p>POJ 2540 Hotter Colder<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=2540" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=2540</a><br>半平面交求线性规划可行区域的面积。 </p>
<p>POJ 2451 Uyuw’s Concert<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=2451" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=2451</a><br>Zzy专为他那篇nlogn算法解决半平面交问题的论文而出的题目。 </p>
<p>五。计算几何背景,实际上解题的关键是其他问题(数据结构、组合数学,或者是枚举思想)<br>若干道经典的离散化+扫描线的题目,ACM选手必做题目 </p>
<p>POJ 1151 Atlantis (推荐)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1151" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1151</a><br>POJ 1389 Area of Simple Polygons<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1389" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1389</a><br>矩形离散化,线段树处理,矩形面积求交 </p>
<p>POJ 1177 Picture (推荐)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1177" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1177</a><br>矩形离散化,线段树处理,矩形交的周长,这个题目的数据比较强。线段树必须高效。 </p>
<p>POJ 3565 Ants (推荐)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=3565" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=3565</a><br>计算几何中的调整思想,有点像排序。要用到线段相交的判断。<br>详见:<a href="http://hi.baidu.com/novosbirsk/blog/item/fb668cf0f362bec47931aae2.html" target="_blank" rel="external">http://hi.baidu.com/novosbirsk/blog/item/fb668cf0f362bec47931aae2.html</a> </p>
<p>POJ 3695 Rectangles<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=3695" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=3695</a><br>又是矩形交的面积,但是由于是多次查询,而且矩形不多,使用组合数学中的容斥原理解决之最适合。线段树是通法,但是除了线段树,还有其他可行的方法。 </p>
<p>POJ 2002 Squares<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=2002" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=2002</a><br>枚举思想,求平面上若干个点最多能组成多少个正方形,点的Hash </p>
<p>POJ 1434 Fill the Cisterns!(推荐)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1434" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1434</a><br>一开始发昏了,准备弄个线段树。其实只是个简单的二分。 </p>
<p>六。随机算法<br>POJ 2420 A Star not a Tree?<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=2420" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=2420</a><br>多边形的费马点。所谓费马点,就是多边形中一个点P,该点到其他点的距离之和最短。四边形以上的多边形没有公式求费马点,因此可以使用随机化变步长贪心法。<br>详见:<a href="http://hi.baidu.com/novosbirsk/blog/item/75983f138499f825dd54019b.html" target="_blank" rel="external">http://hi.baidu.com/novosbirsk/blog/item/75983f138499f825dd54019b.html</a> </p>
<p>七。解析几何<br>这种题目本人不擅长,所以做得不多,模板很重要。当然,熟练运用叉积、点积的性质还是很有用的。<br>POJ 1375 Intervals<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1375" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1375</a><br>知识点:过圆外一点求与圆的切线 </p>
<p>POJ 1329 Circle Through Three Points<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1329" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1329</a><br>求三角形外接圆 </p>
<p>POJ 2354 Titanic<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=2354" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=2354</a><br>求球面上两个点的距离,而且给的是地理经纬坐标。 </p>
<p>POJ 1106 Transmitters<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1106" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1106</a><br>角度排序,知道斜率求角度,使用atan函数。 </p>
<p>POJ 1673 EXOCENTER OF A TRIANGLE<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1673" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1673</a><br>可以转化为三角形的垂心问题。 </p>
<p>八。旋转卡壳 </p>
<p>POJ 2187 Beauty Contest<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=2187" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=2187</a><br>凸包求最远点对。可以暴力枚举,也可以使用旋转卡壳。 </p>
<p>POJ 3608 Bridge Across Islands(难)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=3608" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=3608</a><br>两个凸包的最近距离。本人的卡壳始终WA。郁闷。 </p>
<p>九。其他问题<br>POJ 1981 Circle and Points<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1981" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1981</a><br>求单位圆最多能覆盖平面上多少个点</p>
]]></content>
<summary type="html">
<![CDATA[<p>转载自:<a href="http://hi.baidu.com/novosbirsk/item/16330d2b7be6910e42634a13">PKKJ @ SCAU - A GISer</a></p>
<p>计算几何题的特点与做题要领:</p>
<p>1.大部分不会很难,少部分题目思路很巧妙<br>2.做计算几何题目,模板很重要,模板必须高度可靠。<br>3.要注意代码的组织,因为计算几何的题目很容易上两百行代码,里面大部分是模板。如果代码一片混乱,那么会严重影响做题正确率。<br>4.注意精度控制。<br>5.能用整数的地方尽量用整数,要想到扩大数据的方法(扩大一倍,或扩大sqrt2)。因为整数不用考虑浮点误差,而且运算比浮点快。<br>]]>
</summary>
<category term="Poj" scheme="https://github.com/sillyplus/tags/Poj/"/>
<category term="计算几何" scheme="https://github.com/sillyplus/tags/%E8%AE%A1%E7%AE%97%E5%87%A0%E4%BD%95/"/>
<category term="资源" scheme="https://github.com/sillyplus/tags/%E8%B5%84%E6%BA%90/"/>
<category term="资源" scheme="https://github.com/sillyplus/categories/%E8%B5%84%E6%BA%90/"/>
</entry>
<entry>
<title><![CDATA[Poj 搜索题目列表]]></title>
<link href="https://github.com/sillyplus/2014/04/17/poj-search-list/"/>
<id>https://github.com/sillyplus/2014/04/17/poj-search-list/</id>
<published>2014-04-16T23:24:47.000Z</published>
<updated>2015-10-19T11:28:11.000Z</updated>
<content type="html"><![CDATA[<p><strong>声明:</strong></p>
<p>1.这不是我原创的,是从网上找到的,跟大家分享一下。(然后我在从lyd那里转来的)<br><a id="more"></a><br>POJ 1069 -The Bermuda Triangle(难)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1069" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1069</a><br>题意:用给定三角型填充六边形<br>解法:此题的思想上精华在于坐标化<br>ps:传说中比较bt,确实比较bt,主要很容易写错,我ac了,但程序没完全对….</p>
<p>POJ 1077 - Eight(中等,此题不做人生不完整)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1077" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1077</a><br>题意:八数码问题,超经典题<br>解法:广搜,A*,双向广搜<br>相关:<a href="http://hi.baidu.com/lydrainbowcat/blog/item/d19758588b89fa95800a1804.html" target="_blank" rel="external">http://hi.baidu.com/lydrainbowcat/blog/item/d19758588b89fa95800a1804.html</a></p>
<p>POJ 1084 - Square Destroyer(中等,经典题)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1084" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1084</a><br>题意:把每个正方型看做集合中的元素,每个木棒看做是一个子集,求最小的子集覆盖<br>解法:dfs,A*,广搜肯定爆空间<a href="http://hi.baidu.com/lydrainbowcat/blog/item/5759d80f6735133e6059f393.html" target="_blank" rel="external">http://hi.baidu.com/lydrainbowcat/blog/item/5759d80f6735133e6059f393.html</a></p>
<p>POJ 1167 - The Buses(难)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1167" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1167</a><br>题意:这道题综合了很多经典的深搜技巧,狂顶<br>解法:dfs<a href="http://hi.baidu.com/lydrainbowcat/blog/item/4231cba7965a0681d14358f7.html" target="_blank" rel="external">http://hi.baidu.com/lydrainbowcat/blog/item/4231cba7965a0681d14358f7.html</a></p>
<p>POJ 1190 - 生日蛋糕(基础,好题)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1190" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1190</a><br>题意:略<br>解法:dfs,题偏简单,但做出来还是有些感觉的<a href="http://hi.baidu.com/lydrainbowcat/blog/item/41c21823e0748950ad34deb7.html" target="_blank" rel="external">http://hi.baidu.com/lydrainbowcat/blog/item/41c21823e0748950ad34deb7.html</a></p>
<p>POJ 1324 - Holedox Moving(中等)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1324" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1324</a><br>题意:略<br>解法:A*,dfs + 上界剪枝,广搜<br>相关:<a href="http://hi.baidu.com/zfy0701/blog/item/7fcaba2c3d5425e98a1399cf.html" target="_blank" rel="external">http://hi.baidu.com/zfy0701/blog/item/7fcaba2c3d5425e98a1399cf.html</a><br><a href="http://hi.baidu.com/zfy0701/blog/item/a3c44ecc049b1c1501e92806.html" target="_blank" rel="external">http://hi.baidu.com/zfy0701/blog/item/a3c44ecc049b1c1501e92806.html</a></p>
<p>POJ 1376 - Robot(基础)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1376" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1376</a><br>题意:略<br>解法:bfs,A*….</p>
<p>POJ 1475 - Pushing Boxes(中等,很推荐)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1475" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1475</a><br>题意:推箱子游戏<br>解法:双重bfs(对箱子bfs 时 对人bfs),A* <a href="http://hi.baidu.com/lydrainbowcat/blog/item/19f2bfd1d09f0e2c9b5027b8.html" target="_blank" rel="external">http://hi.baidu.com/lydrainbowcat/blog/item/19f2bfd1d09f0e2c9b5027b8.html</a></p>
<p>POJ 1945 - Power Hungry Cows(??)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1945" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1945</a><br>题意:略<br>解法:在一份解题报告中被列为难题,不过好好像写了个很简单很暴力的bfs就过了…速度还是有些慢,暂时想不到好的启发函数</p>
<p>POJ 2044 - Weather Forecast(中等)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=2044" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=2044</a><br>题意:略<br>解法:广搜,dp,深搜<br>相关:<a href="http://hi.baidu.com/lydrainbowcat/blog/item/a8c86e11f1d52bd2a7ef3f00.html" target="_blank" rel="external">http://hi.baidu.com/lydrainbowcat/blog/item/a8c86e11f1d52bd2a7ef3f00.html</a><br>POJ 2286 - The Rotation Game(较难)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=2286" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=2286</a><br>题意:略<br>解法:IDA*(迭代加深+上下界强剪<br>相关:<a href="http://hi.baidu.com/lydrainbowcat/blog/item/36e183d1e3782ac7572c84a8.html" target="_blank" rel="external">http://hi.baidu.com/lydrainbowcat/blog/item/36e183d1e3782ac7572c84a8.html</a><br>POJ 2308 - Dearboy’s Puzzle(中等,但做的人少?)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=2308" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=2308</a><br>题意:判断连连看是否有解<br>解法:DFS + BFS<br>相关:<a href="http://poj.org/showmessage?message_id=161113" target="_blank" rel="external">http://poj.org/showmessage?message_id=161113</a></p>
<p>POJ 2426 Remainder(较难,=)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=2426" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=2426</a><br>题意:略,主要是数论部分比较容易让人抓狂<br>解法:bfs<br>相关:<a href="http://hi.baidu.com/zfy0701/blog/item/7fcaba2c3d5425e98a1399cf.html" target="_blank" rel="external">http://hi.baidu.com/zfy0701/blog/item/7fcaba2c3d5425e98a1399cf.html</a></p>
<p>POJ 2449 Remmarguts’ Date(中等,强烈推荐)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=2449" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=2449</a><br>题意:经典问题:K短路<br>解法:dijkstra+A*,方法很多<br>相关:<a href="http://hi.baidu.com/lydrainbowcat/blog/item/df505f8841d1e980a5c2727c.html" target="_blank" rel="external">http://hi.baidu.com/lydrainbowcat/blog/item/df505f8841d1e980a5c2727c.html</a></p>
<p>POJ1072 PuzzleOut(较难,强烈推荐)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=1072" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=1072</a><br>题意:有关解密的 解法:Trie+DFS+剪枝<br>相关:本空间有题解<a href="http://hi.baidu.com/lydrainbowcat/blog/item/f12b38355913fb9fa71e1277.html" target="_blank" rel="external">http://hi.baidu.com/lydrainbowcat/blog/item/f12b38355913fb9fa71e1277.html</a></p>
<p>POJ2222 DeeperBlue(中等)<br>题意:一个国际象棋盘上放着几个子,问最少去掉几个可以不互相攻击。主要考察细心,题目跟题号的性质相符(比较2);<br>解法:dfs、暴力枚举<a href="http://hi.baidu.com/lydrainbowcat/blog/item/2194090a8975ec2ab1351db3.html" target="_blank" rel="external">http://hi.baidu.com/lydrainbowcat/blog/item/2194090a8975ec2ab1351db3.html</a></p>
<p>POJ 2688 - Cleaning Robot(基础)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=2688" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=2688</a><br>题意:bfs后转换为tsp问题<br>解法:状态压缩BFS。转化为TSP的话极易超时。<br>相关:本空间有题解<a href="http://hi.baidu.com/lydrainbowcat/blog/item/025fa9a48850a8e39052eefa.html" target="_blank" rel="external">http://hi.baidu.com/lydrainbowcat/blog/item/025fa9a48850a8e39052eefa.html</a></p>
<p>POJ 2908 - Quantum(中等)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=2908" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=2908</a><br>题意:其实就是找单源最短路径<br>解法:优先队列广搜(即dijkstra),建议用位运算优化</p>
<p>POJ 3074 - Sudoku(中等)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=3074" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=3074</a><br>题意:数独游戏,数据比2676强很多,但比3076弱<br>解法:用dfs回溯基本可过,不过每次应选择可能填的数字最少的格子搜<br>更快的方法是先转换成exact cover问题,然后用经典dancing links解决,<br>本空间有关于DancingLinks和本题的介绍和题解。<a href="http://hi.baidu.com/lydrainbowcat/blog/item/2194090a2276192ab1351dbc.html" target="_blank" rel="external">http://hi.baidu.com/lydrainbowcat/blog/item/2194090a2276192ab1351dbc.html</a><br>POJ 3322 - Bloxorz I(基础)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=3322" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=3322</a><br>题意:略,这个游戏本身很好玩(<a href="http://jandan.net/2008/01/24/bloxorz.html)" target="_blank" rel="external">http://jandan.net/2008/01/24/bloxorz.html)</a><br>解法:广搜,双向广搜。朴素的BFS就可以,非常简单,这是我除了A+B以外在poj第一道一次就AC的题目。<br>相关:<a href="http://hi.baidu.com/zfy0701/blog/item/d7b6490f847948e8ab6457c6.html" target="_blank" rel="external">http://hi.baidu.com/zfy0701/blog/item/d7b6490f847948e8ab6457c6.html</a></p>
<p>POJ 3460 - Booksort(较难,很推荐)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=3460" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=3460</a><br>题意:略<br>解法:IDA<em>,A</em>,双向BFS<br>相关:<a href="http://hi.baidu.com/lydrainbowcat/blog/item/26767f24c8aed5278744f99d.html" target="_blank" rel="external">http://hi.baidu.com/lydrainbowcat/blog/item/26767f24c8aed5278744f99d.html</a></p>
<p>POJ 3523 - The Morning after Halloween(较难)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=3523" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=3523</a><br>题意:把所有机器人移到各自的位置,不能相撞或重合<br>解法:我的状态设计太暴力了:以所有机器人位置表示状态。然后用A*过,排倒数第几,郁闷。谁知道好的状态设计方法告诉我^_^</p>
<p>POJ 3633 - Copying DNA(较难)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=3633" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=3633</a><br>题意:一个填充字符串的搜索题<br>解法:各种搜法皆宜<br>相关:算法的实现较挑战,我是参考了 <a href="http://www.wiskey86.cn/wordpress/?p=54" target="_blank" rel="external">http://www.wiskey86.cn/wordpress/?p=54</a> 才搞定的</p>
<p>POJ 3635 full tank?(中等)<br><a href="http://acm.pku.edu.cn/JudgeOnline/problem?id=3635" target="_blank" rel="external">http://acm.pku.edu.cn/JudgeOnline/problem?id=3635</a><br>题意:最短路变形<br>解法:广搜<br>相关:<a href="http://hi.baidu.com/lydrainbowcat/blog/item/0fb2503317caee57ad4b5fed.html" target="_blank" rel="external">http://hi.baidu.com/lydrainbowcat/blog/item/0fb2503317caee57ad4b5fed.html</a></p>
]]></content>
<summary type="html">
<![CDATA[<p><strong>声明:</strong></p>
<p>1.这不是我原创的,是从网上找到的,跟大家分享一下。(然后我在从lyd那里转来的)<br>]]>
</summary>
<category term="资源" scheme="https://github.com/sillyplus/tags/%E8%B5%84%E6%BA%90/"/>
<category term="资源" scheme="https://github.com/sillyplus/categories/%E8%B5%84%E6%BA%90/"/>
</entry>
<entry>