-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathatom.xml
More file actions
656 lines (473 loc) · 417 KB
/
Copy pathatom.xml
File metadata and controls
656 lines (473 loc) · 417 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
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
<title>NaCNer</title>
<link href="/atom.xml" rel="self"/>
<link href="http://yoursite.com/"/>
<updated>2021-01-16T01:18:52.000Z</updated>
<id>http://yoursite.com/</id>
<author>
<name>HCN</name>
</author>
<generator uri="https://hexo.io/">Hexo</generator>
<entry>
<title>About me</title>
<link href="http://yoursite.com/2022/12/31/%E6%9D%BF%E5%AD%90/"/>
<id>http://yoursite.com/2022/12/31/%E6%9D%BF%E5%AD%90/</id>
<published>2022-12-31T02:47:00.000Z</published>
<updated>2021-01-16T01:18:52.000Z</updated>
<content type="html"><![CDATA[<p><img src="https://cfrating.rbs.workers.dev/?username=SorryNaCN" alt=""></p><p><img src="https://cfrating.rbs.workers.dev/?username=NaCNer" alt=""></p><p><img src="https://cfrating.rbs.workers.dev/?username=misakicoca" alt=""></p><a id="more"></a><p>搬运中</p>]]></content>
<summary type="html">
<p><img src="https://cfrating.rbs.workers.dev/?username=SorryNaCN" alt=""></p>
<p><img src="https://cfrating.rbs.workers.dev/?username=NaCNer" alt=""></p>
<p><img src="https://cfrating.rbs.workers.dev/?username=misakicoca" alt=""></p>
</summary>
</entry>
<entry>
<title>训练记录</title>
<link href="http://yoursite.com/2021/12/31/%E8%AE%AD%E7%BB%83%E8%AE%B0%E5%BD%95/"/>
<id>http://yoursite.com/2021/12/31/%E8%AE%AD%E7%BB%83%E8%AE%B0%E5%BD%95/</id>
<published>2021-12-31T02:47:00.000Z</published>
<updated>2021-05-04T08:56:03.946Z</updated>
<content type="html"><![CDATA[<h2 id="训练日程"><a href="#训练日程" class="headerlink" title="训练日程"></a>训练日程</h2><ul><li><p>√ 代表赛中AC</p></li><li><p>· 代表赛中尝试但未AC</p></li><li><p>O 代表赛后AC</p></li><li><p>- 代表题目不存在</p></li><li><p>? 代表对题目/标程存疑</p></li><li><p>× 代表题目/标程有问题</p></li></ul><h3 id="团队摸鱼"><a href="#团队摸鱼" class="headerlink" title="团队摸鱼"></a>团队摸鱼</h3><div class="table-container"><table><thead><tr><th>date</th><th>contest</th><th>rank</th><th>A</th><th>B</th><th>C</th><th>D</th><th>E</th><th>F</th><th>G</th><th>H</th><th>I</th><th>J</th><th>K</th><th>L</th><th>M</th><th>N</th><th>O</th></tr></thead><tbody><tr><td>2021/05/02</td><td>gym103049</td><td>143/307</td><td>√</td><td></td><td>√</td><td>√</td><td>O</td><td>√</td><td></td><td>√</td><td>O</td><td></td><td>√</td><td>-</td><td>-</td><td>-</td><td>-</td></tr><tr><td>2021/05/01</td><td>gym103055</td><td>148/644</td><td>√</td><td>O</td><td>√</td><td>O</td><td></td><td>√</td><td>√</td><td></td><td>O</td><td>√</td><td></td><td>√</td><td>√</td><td>-</td><td>-</td></tr></tbody></table></div><a id="more"></a><p><details><br> <summary>脑瘫问题首发</summary></p><ul><li>$s.earse(地址)$</li><li>递归是用全局$vetor$</li><li>线段树$if(!tag[pos])$</li><li>可撤销并查集可以采用<strong>保持合并前所有信息</strong></li><li>多项式 $如果 while(ML<n+m-1)$ ,$n,m为项数$，如果$ML\leq n+m$<br>$n,m$为最高项系数，$sqrt,Inv….$等倒入的是项数（有多少项）。</li><li>多项式合并时注意限制项数。</li><li>线段树注意$lazy$的初始化</li><li>公式化的离散化线段变成左开右闭 </li><li>直径看清楚是否需要$-1$</li><li>虚树注意清空该清空的</li><li>多维$dp$转移注意边界</li><li>后缀树上$lcp(i,j)=len(lca(i,j))$</li><li>全排列二项式定理，也要考虑单独概率考虑</li><li>随机化使用$std::mt19937 rnd(std::chrono::steady_clock::now().time_since_epoch().count());$</li><li>树链剖分注意$top[rt]$，注意$w[dfn[x]]$</li><li>$KruskalTree重构树$开两倍空间。</li><li>负数向下取整$>>1$</li><li>$KruskalTree重构树$是特胖叶子节点$g[x].size()\leq 1$!!,可以减少特胖</li><li>字典序表示先字母大小再长度</li><li>二分图的最大团=补图的最大独立集。，最大独立集=所有顶点数-最小顶点覆盖，最小顶点覆盖等于二分图的最大匹配。</li><li>Boruvka算法快。</li><li>李超线段树$\max,\min$ 里面都要仔细改</li><li>点分治的时候记住情况应该清空的数据结构，要记住有$a[rt]$这个点也要加入。</li><li>map.count!!!!!</li></ul><details><!-- ### 牛客多校+ [2020牛客暑期多校训练营（第一场）](https://ac.nowcoder.com/acm/contest/5666) $solve(2/10)$,$upsolve(2/10)$+ [2020牛客暑期多校训练营（第二场）](https://ac.nowcoder.com/acm/contest/5667) $solve(1/11)$,$upsolve(9/11)$+ [2020牛客暑期多校训练营（第三场）](https://ac.nowcoder.com/acm/contest/5668) $solve(5/12)$,$upsolve(9/12)$+ [2020牛客暑期多校训练营（第四场）](https://ac.nowcoder.com/acm/contest/5669) $solve(3/10)$,$upsolve(4/10)$+ [2020牛客暑期多校训练营（第五场）](https://ac.nowcoder.com/acm/contest/5670) $solve(4/11)$,$upsolve(8/10)$+ [2020牛客暑期多校训练营（第六场）](https://ac.nowcoder.com/acm/contest/5671) $solve(2/11)$,$upsolve(6/11)$+ [2020牛客暑期多校训练营（第七场）](https://ac.nowcoder.com/acm/contest/5672) + [2020牛客暑期多校训练营（第八场）](https://ac.nowcoder.com/acm/contest/5673) $solve(3/11)$,$upsolve(5/11)$+ [2020牛客暑期多校训练营（第九场）](https://ac.nowcoder.com/acm/contest/5673) $solve(3/11)$,$upsolve(10/12)$ -->]]></content>
<summary type="html">
<h2 id="训练日程"><a href="#训练日程" class="headerlink" title="训练日程"></a>训练日程</h2><ul>
<li><p>√ 代表赛中AC</p>
</li>
<li><p>· 代表赛中尝试但未AC</p>
</li>
<li><p>O 代表赛后AC</p>
</li>
<li><p>- 代表题目不存在</p>
</li>
<li><p>? 代表对题目/标程存疑</p>
</li>
<li><p>× 代表题目/标程有问题</p>
</li>
</ul>
<h3 id="团队摸鱼"><a href="#团队摸鱼" class="headerlink" title="团队摸鱼"></a>团队摸鱼</h3><div class="table-container">
<table>
<thead>
<tr>
<th>date</th>
<th>contest</th>
<th>rank</th>
<th>A</th>
<th>B</th>
<th>C</th>
<th>D</th>
<th>E</th>
<th>F</th>
<th>G</th>
<th>H</th>
<th>I</th>
<th>J</th>
<th>K</th>
<th>L</th>
<th>M</th>
<th>N</th>
<th>O</th>
</tr>
</thead>
<tbody>
<tr>
<td>2021/05/02</td>
<td>gym103049</td>
<td>143/307</td>
<td>√</td>
<td></td>
<td>√</td>
<td>√</td>
<td>O</td>
<td>√</td>
<td></td>
<td>√</td>
<td>O</td>
<td></td>
<td>√</td>
<td>-</td>
<td>-</td>
<td>-</td>
<td>-</td>
</tr>
<tr>
<td>2021/05/01</td>
<td>gym103055</td>
<td>148/644</td>
<td>√</td>
<td>O</td>
<td>√</td>
<td>O</td>
<td></td>
<td>√</td>
<td>√</td>
<td></td>
<td>O</td>
<td>√</td>
<td></td>
<td>√</td>
<td>√</td>
<td>-</td>
<td>-</td>
</tr>
</tbody>
</table>
</div>
</summary>
</entry>
<entry>
<title>P7323 [WC2021] 括号路径</title>
<link href="http://yoursite.com/2021/04/10/P7323/"/>
<id>http://yoursite.com/2021/04/10/P7323/</id>
<published>2021-04-10T02:47:00.000Z</published>
<updated>2021-04-26T13:40:04.431Z</updated>
<content type="html"><![CDATA[<p>题意：$n$ 点 $2m$ 边有向图，有 $k$ 个括号类型。输入 $u,v,w$ 表示有一条从 $u$ 到 $v$，括号类型为 $w$ 的左括号和一条通 $v$ 到 $u$，括号类型为 $w$ 的右括号。问有多少个无序点对满足它们中的一条有向路径的括号连成的字符串是一个合法括号匹配串。<br><a id="more"></a></p><p>考虑$u\rightarrow v$，则$v\rightarrow u$,</p><p>又$u\rightarrow t ,t\rightarrow v$，则一定存在 $u\rightarrow v$。</p><p>考虑最简单的单个括号$u\rightarrow a\leftarrow v$,则有$u,v$。</p><p>为了方便起见，把方向变反就好统计了</p><p>$u\rightarrow a\leftarrow v$ 如果合并了这个，那么相当于缩点了。<br>要把$v$出去的和$u$出去的再合并一边这里得启发式合并找合并的边，反正最多$m$条边。</p><p>根据第二个定理和第一个定理，在一个集合内两两互通，相当于无向边了。/<br>复杂度应该是$O(m\log^2n)$</p><details> <summary>代码</summary><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><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></pre></td><td class="code"><pre><span class="line"></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><bits/stdc++.h></span></span></span><br><span class="line"></span><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><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">solve</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> n, m, k;</span><br><span class="line"> <span class="built_in">cin</span> >> n >> m >> k;</span><br><span class="line"> <span class="function"><span class="built_in">vector</span><<span class="keyword">int</span>> <span class="title">fa</span><span class="params">(n)</span></span>;</span><br><span class="line"> iota(fa.<span class="built_in">begin</span>(), fa.<span class="built_in">end</span>(), <span class="number">0</span>);</span><br><span class="line"> function<<span class="keyword">int</span>(<span class="keyword">int</span>)> <span class="built_in">find</span> = [&](<span class="keyword">int</span> x) { <span class="keyword">return</span> fa[x] == x ? x : fa[x] = <span class="built_in">find</span>(fa[x]); };</span><br><span class="line"> vector<map<int, int>> cnt(n);</span><br><span class="line"> <span class="built_in">queue</span><pair<<span class="keyword">int</span>, <span class="keyword">int</span>>> q;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">auto</span> merge = [&](<span class="keyword">int</span> u, <span class="keyword">int</span> v) {</span><br><span class="line"> <span class="keyword">int</span> x = <span class="built_in">find</span>(u);</span><br><span class="line"> <span class="keyword">int</span> y = <span class="built_in">find</span>(v);</span><br><span class="line"> <span class="keyword">if</span> (x == y)</span><br><span class="line"> <span class="keyword">return</span>;</span><br><span class="line"> <span class="keyword">if</span> (cnt[x].<span class="built_in">size</span>() > cnt[y].<span class="built_in">size</span>())</span><br><span class="line"> swap(x, y);</span><br><span class="line"> fa[x] = y;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">auto</span> [i, j] : cnt[x])</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (cnt[y].count(i))</span><br><span class="line"> {</span><br><span class="line"> q.push({cnt[y][i], j});</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> cnt[y][i] = j;</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">0</span>; i < m; i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> u, v, w;</span><br><span class="line"> <span class="built_in">cin</span> >> u >> v >> w;</span><br><span class="line"> u--, v--, w--;</span><br><span class="line"> <span class="keyword">if</span> (cnt[v].count(w))</span><br><span class="line"> q.push({cnt[v][w], u});</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> cnt[v][w] = u;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">while</span> (!q.empty())</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">auto</span> [u, v] = q.front();</span><br><span class="line"> q.pop();</span><br><span class="line"> merge(u, v);</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="built_in">vector</span><<span class="keyword">int</span>> <span class="title">size</span><span class="params">(n)</span></span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i < n; i++)</span><br><span class="line"> <span class="built_in">size</span>[<span class="built_in">find</span>(i)]++;</span><br><span class="line"> ll ans = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i < n; i++)</span><br><span class="line"> <span class="keyword">if</span> (<span class="built_in">find</span>(i) == i)</span><br><span class="line"> ans += <span class="number">1l</span>l * <span class="built_in">size</span>[i] * (<span class="built_in">size</span>[i] - <span class="number">1</span>) / <span class="number">2</span>;</span><br><span class="line"> <span class="built_in">cout</span> << ans << <span class="built_in">endl</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">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> ios::sync_with_stdio(<span class="literal">false</span>);</span><br><span class="line"> <span class="built_in">cin</span>.tie(<span class="literal">nullptr</span>);</span><br><span class="line"> <span class="keyword">int</span> T = <span class="number">1</span>;</span><br><span class="line"> <span class="comment">//cin >> T;</span></span><br><span class="line"> <span class="keyword">while</span> (T--)</span><br><span class="line"> {</span><br><span class="line"> solve();</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure> </details>]]></content>
<summary type="html">
<p>题意：$n$ 点 $2m$ 边有向图，有 $k$ 个括号类型。输入 $u,v,w$ 表示有一条从 $u$ 到 $v$，括号类型为 $w$ 的左括号和一条通 $v$ 到 $u$，括号类型为 $w$ 的右括号。问有多少个无序点对满足它们中的一条有向路径的括号连成的字符串是一个合法括号匹配串。<br>
</summary>
<category term="启发式合并" scheme="http://yoursite.com/tags/%E5%90%AF%E5%8F%91%E5%BC%8F%E5%90%88%E5%B9%B6/"/>
</entry>
<entry>
<title>CF1238G. Adilbek and the Watering System</title>
<link href="http://yoursite.com/2021/01/01/CF1238G/"/>
<id>http://yoursite.com/2021/01/01/CF1238G/</id>
<published>2021-01-01T02:47:00.000Z</published>
<updated>2021-01-04T13:03:31.000Z</updated>
<content type="html"><![CDATA[<p>有一个容量为$c$的水箱，初始是$c0$.</p><p>每时刻会掉$1ml$滴水。</p><p>有$n$个人，在$t_i$时刻来，最多带来$a_i$水，每毫升$b_i$元。</p><p>要让水箱可以坚持到$m$时刻。</p><p>求最小花费。</p><a id="more"></a><p>贪心。。。。</p><p>很妙。显然当要用到水的时候再用水，并且用价格最少的。</p><p>假设先把水都放进去，不管容量。每次发现要用水的时候，从里面取出最小的即可。</p><ul><li>如果我取出来，导致之前本来可以过的过不去呢？放心每次过需要水的时候按时间计算了。</li></ul><p>如果考虑容量，如果我装满了，并且发现我的水多余了，那我可以取代那些预准备费用大于他的水。</p><p>用<br><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">map</span><<span class="keyword">int</span>,<span class="keyword">int</span>>q;</span><br></pre></td></tr></table></figure><br>$q[x]$表示价格为$x$的水在准备区有多少。</p><p>一些小细节注意</p><ul><li>初始化准备区的水，以及$q[0]$。</li><li>每次需要用水，准备区里的水需要减。</li><li>水溢出需要的细节</li></ul><p>弹出准备区的水复杂度最多$O(n\log n)$</p><details> <summary>代码</summary><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><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><br><span class="line"></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><bits/stdc++.h></span></span></span><br><span class="line"></span><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="meta">#<span class="meta-keyword">define</span> ll int64_t</span></span><br><span class="line"></span><br><span class="line"><span class="function">ll <span class="title">solve</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> n, m, c, c0;</span><br><span class="line"> <span class="built_in">cin</span> >> n >> m >> c >> c0;</span><br><span class="line"> vector<array<int, 3>> tmp(n + 2);</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><br><span class="line"> <span class="built_in">cin</span> >> tmp[i][<span class="number">0</span>] >> tmp[i][<span class="number">1</span>] >> tmp[i][<span class="number">2</span>];</span><br><span class="line"> }</span><br><span class="line"> tmp[n + <span class="number">1</span>] = {m, <span class="number">0</span>, <span class="number">0</span>};</span><br><span class="line"> sort(tmp.<span class="built_in">begin</span>(), tmp.<span class="built_in">end</span>());</span><br><span class="line"> <span class="built_in">map</span><<span class="keyword">int</span>, ll> q;</span><br><span class="line"> ll ans = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">int</span> now = c0;</span><br><span class="line"> q[<span class="number">0</span>] = c0;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">1</span>; i < tmp.<span class="built_in">size</span>(); i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">auto</span> [t, A, b] = tmp[i];</span><br><span class="line"> <span class="keyword">int</span> del = t - tmp[i - <span class="number">1</span>][<span class="number">0</span>];</span><br><span class="line"> <span class="keyword">if</span> (del > c)</span><br><span class="line"> <span class="keyword">return</span> <span class="number">-1</span>;</span><br><span class="line"> <span class="keyword">while</span> (!q.empty() && del > <span class="number">0</span>)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> w = <span class="built_in">min</span>(q.<span class="built_in">begin</span>()->second, <span class="number">1l</span>l * del);</span><br><span class="line"> q.<span class="built_in">begin</span>()->second -= w, del -= w, now -= w;</span><br><span class="line"> ans += <span class="number">1l</span>l * w * q.<span class="built_in">begin</span>()->first;</span><br><span class="line"> <span class="keyword">if</span> (q.<span class="built_in">begin</span>()->second == <span class="number">0</span>)</span><br><span class="line"> q.erase(q.<span class="built_in">begin</span>());</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span> (del)</span><br><span class="line"> <span class="keyword">return</span> <span class="number">-1</span>;</span><br><span class="line"> <span class="keyword">int</span> add = <span class="built_in">min</span>(c - now, A);</span><br><span class="line"> now += add;</span><br><span class="line"> <span class="keyword">while</span> (!q.empty() && A - add > <span class="number">0</span> && b < q.rbegin()->first)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">auto</span> it = q.rbegin();</span><br><span class="line"> <span class="keyword">if</span> (A - add >= it->second)</span><br><span class="line"> {</span><br><span class="line"> add += it->second;</span><br><span class="line"> q.erase(--q.<span class="built_in">end</span>());</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> {</span><br><span class="line"> it->second -= A - add;</span><br><span class="line"> add = A;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> q[b] += add;</span><br><span class="line"> <span class="comment">// cout << ans << endl;</span></span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> ans;</span><br><span class="line">}</span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> ios::sync_with_stdio(<span class="literal">false</span>);</span><br><span class="line"> <span class="built_in">cin</span>.tie(<span class="literal">nullptr</span>);</span><br><span class="line"> <span class="keyword">int</span> T;</span><br><span class="line"> <span class="built_in">cin</span> >> T;</span><br><span class="line"> <span class="keyword">while</span> (T--)</span><br><span class="line"> {</span><br><span class="line"> <span class="built_in">cout</span> << solve() << <span class="built_in">endl</span>;</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure> </details>]]></content>
<summary type="html">
<p>有一个容量为$c$的水箱，初始是$c0$.</p>
<p>每时刻会掉$1ml$滴水。</p>
<p>有$n$个人，在$t_i$时刻来，最多带来$a_i$水，每毫升$b_i$元。</p>
<p>要让水箱可以坚持到$m$时刻。</p>
<p>求最小花费。</p>
</summary>
<category term="贪心" scheme="http://yoursite.com/tags/%E8%B4%AA%E5%BF%83/"/>
</entry>
<entry>
<title>数学公式</title>
<link href="http://yoursite.com/2020/12/31/%E4%B8%80%E4%BA%9B%E6%95%B0%E5%AD%A6%E5%85%AC%E5%BC%8F/"/>
<id>http://yoursite.com/2020/12/31/%E4%B8%80%E4%BA%9B%E6%95%B0%E5%AD%A6%E5%85%AC%E5%BC%8F/</id>
<published>2020-12-31T02:47:00.000Z</published>
<updated>2020-11-01T08:12:25.000Z</updated>
<content type="html"><![CDATA[<p>忘记太多了..<br><a id="more"></a></p>]]></content>
<summary type="html">
<p>忘记太多了..<br>
</summary>
</entry>
<entry>
<title>乱七八糟题解</title>
<link href="http://yoursite.com/2020/12/31/%E4%B9%B1%E4%B8%83%E5%85%AB%E7%B3%9F%E9%A2%98%E8%A7%A3/"/>
<id>http://yoursite.com/2020/12/31/%E4%B9%B1%E4%B8%83%E5%85%AB%E7%B3%9F%E9%A2%98%E8%A7%A3/</id>
<published>2020-12-31T02:47:00.000Z</published>
<updated>2020-12-25T14:31:36.000Z</updated>
<content type="html"><![CDATA[<p>鸽子的题解太多了。只好直接写。</p><!-- TOC --><ul><li><a href="#gym">GYM</a><ul><li><a href="#2019-ccpc-哈尔滨">2019-CCPC-哈尔滨</a><ul><li><a href="#b-binary-numbers">B. Binary Numbers</a></li><li><a href="#e-exchanging-gifts">E. Exchanging Gifts</a></li><li><a href="#i-interesting-permutation">I. Interesting Permutation</a></li><li><a href="#l-lru-algorithm">L. LRU Algorithm</a></li></ul></li><li><a href="#300iq-contest-1">300iq Contest 1</a><ul><li><a href="#bbest-subsequence">B.Best Subsequence</a></li><li><a href="#ccool-pairs">C.Cool Pairs</a></li><li><a href="#d-dates">D. Dates</a></li><li><a href="#f-free-edges">F. Free Edges</a></li><li><a href="#k-knowledge">K. Knowledge</a></li></ul></li><li><a href="#icpc-asia-east-continent-final">ICPC Asia-East Continent Final</a><ul><li><a href="#hking">H.King</a></li></ul></li></ul></li><li><a href="#雅礼集训">雅礼集训</a><ul><li><a href="#loj6029-雅礼集训-2017-day1市场">LOJ6029. 「雅礼集训 2017 Day1」市场</a></li><li><a href="#loj6030-雅礼集训-2017-day1矩阵">LOJ6030. 「雅礼集训 2017 Day1」矩阵</a></li><li><a href="#loj6031-雅礼集训-2017-day1字符串">LOJ6031. 「雅礼集训 2017 Day1」字符串</a></li><li><a href="#loj6032-雅礼集训-2017-day2水箱">LOJ6032. 「雅礼集训 2017 Day2」水箱</a></li><li><a href="#loj6033-雅礼集训-2017-day2棋盘游戏">LOJ6033. 「雅礼集训 2017 Day2」棋盘游戏</a></li><li><a href="#loj6034-雅礼集训-2017-day2线段游戏">LOJ6034. 「雅礼集训 2017 Day2」线段游戏</a></li><li><a href="#loj6035-雅礼集训-2017-day4洗衣服">LOJ6035. 「雅礼集训 2017 Day4」洗衣服</a></li><li><a href="#loj6036-雅礼集训-2017-day4编码">LOJ6036. 「雅礼集训 2017 Day4」编码</a></li><li><a href="#loj6038-雅礼集训-2017-day5远行">LOJ6038. 「雅礼集训 2017 Day5」远行</a></li><li><a href="#loj6039-雅礼集训-2017-day5珠宝">LOJ6039. 「雅礼集训 2017 Day5」珠宝</a></li><li><a href="#loj6040-雅礼集训-2017-day5矩阵">LOJ6040. 「雅礼集训 2017 Day5」矩阵</a></li><li><a href="#loj6041-雅礼集训-2017-day7事情的相似度">LOJ6041. 「雅礼集训 2017 Day7」事情的相似度</a></li><li><a href="#loj6045-雅礼集训-2017-day8价">LOJ6045. 「雅礼集训 2017 Day8」价</a></li></ul></li><li><a href="#codeforces">Codeforces</a><ul><li><a href="#cf1358f-tasty-cookie">CF1358F Tasty Cookie</a></li><li><a href="#cf1367f2-flying-sort-hard-version">CF1367F2 Flying Sort (Hard Version)</a></li><li><a href="#cf1368e-ski-accidents">CF1368E Ski Accidents</a></li><li><a href="#cf1374e2-reading-books-hard-version">CF1374E2 Reading Books (hard version)</a></li><li><a href="#cf1380g-circular-dungeon">CF1380G Circular Dungeon</a></li><li><a href="#cf1384d-gamegame">CF1384D. GameGame</a></li><li><a href="#cf1387b1-village-minimum">CF1387B1 Village (Minimum)</a></li><li><a href="#cf1387b2-village-maximum">CF1387B2 Village (Maximum)</a></li><li><a href="#cf1399e2-weights-division-hard-version">CF1399E2 Weights Division (hard version)</a></li><li><a href="#cf1354c2-not-so-simple-polygon-embedding">CF1354C2. Not So Simple Polygon Embedding</a></li><li><a href="#cf1354f-summoning-minions">CF1354F. Summoning Minions</a></li><li><a href="#cf1354g-find-a-gift">CF1354G. Find a Gift</a></li><li><a href="#cf1421e-swedish-heroes">CF1421E. Swedish Heroes</a></li><li><a href="#cf1353f-decreasing-heights">CF1353F. Decreasing Heights</a></li><li><a href="#cf1353e-k-periodic-garland">CF1353E. K-periodic Garland</a></li><li><a href="#cf1427e--xum">CF1427E . Xum</a></li><li><a href="#cf1344drésumé-review">CF1344D.Résumé Review</a></li><li><a href="#cf1344c-quantifier-question">CF1344C Quantifier Question</a></li><li><a href="#cf1363f-rotating-substrings">CF1363F Rotating Substrings</a></li><li><a href="#cf1408e-avoid-rainbow-cycles">CF1408E Avoid Rainbow Cycles</a></li><li><a href="#cf1408f-two-different">CF1408F Two Different</a></li><li><a href="#cf1422f-boring-queries">CF1422F Boring Queries</a></li><li><a href="#cf1437g---death-dbms">CF1437G - Death DBMS</a></li><li><a href="#cf1436f-sum-over-subsets">CF1436F. Sum Over Subsets</a></li><li><a href="#cf1443f---identify-the-operations">CF1443F - Identify the Operations</a></li><li><a href="#cf1443e---long-permutation">CF1443E - Long Permutation</a></li><li><a href="#cf19d">CF19D</a></li><li><a href="#cf204e-little-elephant-and-strings">CF204E Little Elephant and Strings</a></li><li><a href="#cf793c-mice-problem">CF793C Mice problem</a></li><li><a href="#cf1285e-delete-a-segment">CF1285E Delete a Segment</a></li><li><a href="#cf1451e-bitwise-queries">CF1451E Bitwise Queries</a></li><li><a href="#cf1452e-two-editorials">CF1452E Two Editorials</a></li><li><a href="#cf1158b-the-minimal-unique-substring">CF1158B The minimal unique substring</a></li><li><a href="#cf1158c-permutation-recovery">CF1158C Permutation recovery</a></li><li><a href="#cf1251e2-voting-hard-version">CF1251E2 Voting (Hard Version)</a></li><li><a href="#cf1283f-diy-garland">CF1283F DIY Garland</a></li><li><a href="#cf1461f-mathematical-expression">CF1461F Mathematical Expression</a></li><li><a href="#cf1462f-the-treasure-of-the-segments">CF1462F The Treasure of The Segments</a></li><li><a href="#cf1463e-plan-of-lectures">CF1463E Plan of Lectures</a></li><li><a href="#cf1464b-grime-zoo">CF1464B Grime Zoo</a></li><li><a href="#cf1464c-poman-numbers">CF1464C Poman Numbers</a></li></ul></li><li><a href="#洛谷">洛谷</a><ul><li><a href="#p4103-heoi2014大工程">P4103 [HEOI2014]大工程</a></li><li><a href="#p5504-jsoi2011柠檬">P5504 [JSOI2011]柠檬</a></li><li><a href="#p2542-ahoi2005-航线规划">P2542 [AHOI2005] 航线规划</a></li></ul></li><li><a href="#atcoder">Atcoder</a><ul><li><a href="#atcoder-grand-contest-048">AtCoder Grand Contest 048</a></li><li><a href="#acl-beginner-contest">ACL Beginner Contest</a><ul><li><a href="#f---heights-and-pairs">F - Heights and Pairs</a></li></ul></li></ul></li><li><a href="#牛客">牛客</a><ul><li><a href="#icpc小米邀请赛2">ICPC小米邀请赛2</a><ul><li><a href="#a2020">A.2020</a></li><li><a href="#isubsequence-pair">I.Subsequence Pair</a></li></ul></li></ul></li></ul><!-- /TOC --><a id="more"></a><h1 id="GYM"><a href="#GYM" class="headerlink" title="GYM"></a>GYM</h1><h2 id="2019-CCPC-哈尔滨"><a href="#2019-CCPC-哈尔滨" class="headerlink" title="2019-CCPC-哈尔滨"></a>2019-CCPC-哈尔滨</h2><h3 id="B-Binary-Numbers"><a href="#B-Binary-Numbers" class="headerlink" title="B. Binary Numbers"></a>B. Binary Numbers</h3><p>$f(a,b)$即$a,b$的最长公共前缀长度，然后暴力打表，可以知道$a,b$越相近，$f(a,b)越大$，从每个区间里选出一个代表数字$A i$，如果对于所有区间$i$，满足$f ( A_i , k ) ≥ f ( A_j , k )$,$L_i≤k≤R_i$。</p><p>显然根据单调性</p><ul><li>$f ( A_{i-1} , R_{i-1} ) ≥ f ( A_{i} , R_{i-1})$</li></ul><ul><li>$f ( A_i , L_i ) ≥ f ( A_{i-1} , L_i )$</li></ul><p>$f ( A_{i-1} , L_i ),f ( A_{i-1} , R_{i-1} )$当作$dp[i-1][][]$的状态去转移，根据两个条件看是否转移，以及更新状态即可。</p><h3 id="E-Exchanging-Gifts"><a href="#E-Exchanging-Gifts" class="headerlink" title="E. Exchanging Gifts"></a>E. Exchanging Gifts</h3><p><strong>请先搞清楚，基本最大快乐值如何求</strong>。</p><p>两个操作可以想成一颗树，然后根据最后需要的向下类似$dp$,最后得到某些数的数量。</p><p>就是比较最大值和总和之间大小的分类讨论。</p><h3 id="I-Interesting-Permutation"><a href="#I-Interesting-Permutation" class="headerlink" title="I. Interesting Permutation"></a>I. Interesting Permutation</h3><p>考虑每次就相当于一个区间长度，$tmp=$可插空位</p><ul><li>$h_{i+1}=h_i$,$ans=ans\times tmp,tmp-1$</li><li>$h_{i+1}>h_i$,$ans=2\times ans,tmp=tmp+h_{i+1}-h_i-1$,表示新的数可以插前面和后面。并且更新可插空位。</li></ul><h3 id="L-LRU-Algorithm"><a href="#L-LRU-Algorithm" class="headerlink" title="L. LRU Algorithm"></a>L. LRU Algorithm</h3><p>找到规律发现，内存其实无所谓，假设内存无限大，那么对于有内存去前面$k$个即可，轻松可以预处理$hash[n][k]$，然后每次暴力查找即可。注意$0$。</p><h2 id="300iq-Contest-1"><a href="#300iq-Contest-1" class="headerlink" title="300iq Contest 1"></a>300iq Contest 1</h2><h3 id="B-Best-Subsequence"><a href="#B-Best-Subsequence" class="headerlink" title="B.Best Subsequence"></a>B.Best Subsequence</h3><p>逆向思维取删出相邻最大的一定最优。用$set$模拟即可。</p><h3 id="C-Cool-Pairs"><a href="#C-Cool-Pairs" class="headerlink" title="C.Cool Pairs"></a>C.Cool Pairs</h3><p>转化成$a_i< -b_j=z_j$，这类构造先考虑$k=0$,直接$z_j=-n$，再将$a_i$按照顺序变$[-n,-1]$。然后慢慢调整$z_j$大小。</p><ul><li>如果不够，直接设$z_j=1$,就可以覆盖$j-1$个$a_i$。</li><li>如果够了，将$i<j$的$a_i$，排个序找到第$k$小的$a$,$z_j$直接等于就好了，并且结束，由于$a_i$是负的，保证$z_j$单调递减。</li></ul><h3 id="D-Dates"><a href="#D-Dates" class="headerlink" title="D. Dates"></a>D. Dates</h3><p>每个妹子匹配一个时间区间，每个时间最多选择𝑎𝑖个妹子，每个妹子有一个快乐值，最大化总快乐值。</p><p>由于一个妹子最多只会占用其他妹子的约会时间，所以贪心的选择快乐值总没错。</p><p>那么题意就变成选择妹子是否可以保证能成功过匹配。</p><p>对于任意区间$[i,j]$，区间$[i,j]$中选中妹子的数量需要小于等于这个区间和。</p><p>此时相当于判断是否所有子集的邻域（即与其相邻的点构成的集合）大小都比子集本身大。由于$L_i\leq L_{i+1},R_i\leq R_{i+1}$，左侧的区间的情况只有$n^2$种。</p><p>$c[j]-c[i-1]\leq s[r_j]-s[l_i-1]$</p><p>$c[j]-s[r_j]\leq c[i-1]-s[l_i-1]$</p><p>考虑我加入一个选中一个妹子的时候左侧$[j,n]$会发生变化。右侧$[j+1,n]$会发生变化。判断变化的那端是否发生左侧最大值$[j,n]$是否大于右侧最小值$[1,j]$了。</p><p>不然撤回操作。</p><h3 id="F-Free-Edges"><a href="#F-Free-Edges" class="headerlink" title="F. Free Edges"></a>F. Free Edges</h3><p>问至少删掉多少条边后图中不存在环。并茶几瞎几把找一找就好了</p><h3 id="K-Knowledge"><a href="#K-Knowledge" class="headerlink" title="K. Knowledge"></a>K. Knowledge</h3><p>每次可以删加掉$aa$,$bb$,$ababab$。</p><p>发现任何字符串都可以变成一个最短无法变短字符串<br>找到关键的几个变化</p><ul><li>$aa\rightarrow$</li><li>$bbb\rightarrow$</li><li>$abba \rightarrow bab$</li><li>$ababa\rightarrow bb$</li><li>$abba\rightarrow bab$</li><li>$baba\rightarrow abb$</li></ul><p>多写一点就好了，然后发现就$12$个为基底的字符串。</p><p>然后即从$k$长度的字符串变成$s$,考虑$12$个的互相变换关系，相当与走路径一样，查看从$x$走到$y$有几种走法，这里就是从空字符串走$k$步，有多少种变成$s$的路径种类，矩阵快速幂即可。</p><h2 id="ICPC-Asia-East-Continent-Final"><a href="#ICPC-Asia-East-Continent-Final" class="headerlink" title="ICPC Asia-East Continent Final"></a>ICPC Asia-East Continent Final</h2><h3 id="H-King"><a href="#H-King" class="headerlink" title="H.King"></a>H.King</h3><p>找到$qa_i \equiv a_{i+1} \pmod p$,$\geq n/2$的最长子序列。<br>$q\equiv a_{i+1}a^{-1}_i \pmod p$</p><p>$\geq n/2$的最长子序列。必定存在相邻的$a_i$。</p><p>随机化枚举即可。</p><h1 id="雅礼集训"><a href="#雅礼集训" class="headerlink" title="雅礼集训"></a>雅礼集训</h1><h2 id="LOJ6029-「雅礼集训-2017-Day1」市场"><a href="#LOJ6029-「雅礼集训-2017-Day1」市场" class="headerlink" title="LOJ6029. 「雅礼集训 2017 Day1」市场"></a>LOJ6029. 「雅礼集训 2017 Day1」市场</h2><p>当线段树上的点$max[pos]-min[pos]< d$就会变成减法，而$\sum a_i+d$，只会改变两个$max-min$。即我最多需要除$qlog(q\times 10^4)$。<br>需要一个支持最大值，最小值，区间和的线段树即可。</p><h2 id="LOJ6030-「雅礼集训-2017-Day1」矩阵"><a href="#LOJ6030-「雅礼集训-2017-Day1」矩阵" class="headerlink" title="LOJ6030. 「雅礼集训 2017 Day1」矩阵"></a>LOJ6030. 「雅礼集训 2017 Day1」矩阵</h2><p>先构造一行都是#,然后填充竖即可。（注意需要注意已经$ok$的竖，以及填充此行只需要有这行的竖，或者<strong>花费一次构造这个竖</strong></p><h2 id="LOJ6031-「雅礼集训-2017-Day1」字符串"><a href="#LOJ6031-「雅礼集训-2017-Day1」字符串" class="headerlink" title="LOJ6031. 「雅礼集训 2017 Day1」字符串"></a>LOJ6031. 「雅礼集训 2017 Day1」字符串</h2><p>$qk\leq 10^5$</p><ul><li><p>$k\leq 300$，暴力跳所有子串，然后暴力二分询问$mp[l][r]，在[a,b]$中有几个,可以离线做到$O(qk^2)$，在线就是$O(qk^2\log n)$</p></li><li><p>$q\leq300$,从$1$走子串保证后缀那种，每走到$r$，需有所有的$l$,这个时候倍增往上跳寻找$siz$最大。$O(qm\log n)$</p></li></ul><h2 id="LOJ6032-「雅礼集训-2017-Day2」水箱"><a href="#LOJ6032-「雅礼集训-2017-Day2」水箱" class="headerlink" title="LOJ6032. 「雅礼集训 2017 Day2」水箱"></a>LOJ6032. 「雅礼集训 2017 Day2」水箱</h2><p>按照高度排序，（注意这里需要先合并再处理那些条件),$ans[x]$表示$x$个块的答案，$f[x]$表示目前为止有水需求的数量。</p><ul><li>考虑合并，合并答案即可。</li><li>考虑有水，则$f[find(x)]$++,更新答案$ans[x]$</li><li>考虑无水，则直接更新$ans[x]$</li></ul><h2 id="LOJ6033-「雅礼集训-2017-Day2」棋盘游戏"><a href="#LOJ6033-「雅礼集训-2017-Day2」棋盘游戏" class="headerlink" title="LOJ6033. 「雅礼集训 2017 Day2」棋盘游戏"></a>LOJ6033. 「雅礼集训 2017 Day2」棋盘游戏</h2><p>二分图博弈，即找到那些点是非必须点。即删除了之后对最大匹配没影响。考虑一个非匹配点𝑥，假如它连向了一个匹配点𝑦，那么它就能替换掉当前当前和这个匹配点匹配的点𝑧，而这时𝑧也可以进行同样的操作。</p><p>首先根据时间戳的匈牙利算法可以找到所有可能的匹配点，然后找非匹配点。</p><p>于是我们从每个非匹配𝑥出发进行𝑑𝑓𝑠，途经的和𝑥同一集合的点都满足要求。</p><h2 id="LOJ6034-「雅礼集训-2017-Day2」线段游戏"><a href="#LOJ6034-「雅礼集训-2017-Day2」线段游戏" class="headerlink" title="LOJ6034. 「雅礼集训 2017 Day2」线段游戏"></a>LOJ6034. 「雅礼集训 2017 Day2」线段游戏</h2><p>李超线段树模版题。</p><h2 id="LOJ6035-「雅礼集训-2017-Day4」洗衣服"><a href="#LOJ6035-「雅礼集训-2017-Day4」洗衣服" class="headerlink" title="LOJ6035. 「雅礼集训 2017 Day4」洗衣服"></a>LOJ6035. 「雅礼集训 2017 Day4」洗衣服</h2><p>考虑只洗衣服，则用优先队列维护当前最小洗衣时间。就可以得到洗$k$间衣服需要的最短时间。同样处理烘干衣服的时间。</p><p>考虑到所有衣服都被烘干后烘干机全部是空的，可以把这个过程倒过来，这样子就和洗衣服一样。即当$i$衣服洗完后，选如果当第$p_i$烘干的则时间</p><script type="math/tex; mode=display">\max(a_1+b_{p_1},a_2+b_{p_2}....a_n+b_{p_n})</script><p>顺序和大于等于乱序和大于等于逆序和,求个逆序和即可。</p><h2 id="LOJ6036-「雅礼集训-2017-Day4」编码"><a href="#LOJ6036-「雅礼集训-2017-Day4」编码" class="headerlink" title="LOJ6036. 「雅礼集训 2017 Day4」编码"></a>LOJ6036. 「雅礼集训 2017 Day4」编码</h2><p>可以得到一个$O(n^2)$的2-SAT。<br>考虑如何优化</p><p>首先按照长度排序，就可以减少不必要的分类讨论。</p><p>如果有遍历到前缀，那么连接两个点表示不能同时成立。</p><p>在最后不能把这个情况直接压入终止节点，会导致某个节点太多点。考虑每次新建点，$new$不能与$old$同时成立，但需要和$tmp$同时成立。</p><h2 id="LOJ6038-「雅礼集训-2017-Day5」远行"><a href="#LOJ6038-「雅礼集训-2017-Day5」远行" class="headerlink" title="LOJ6038. 「雅礼集训 2017 Day5」远行"></a>LOJ6038. 「雅礼集训 2017 Day5」远行</h2><p>只可能是直径上的点，用LCT和并查集动态维护直径即可。</p><h2 id="LOJ6039-「雅礼集训-2017-Day5」珠宝"><a href="#LOJ6039-「雅礼集训-2017-Day5」珠宝" class="headerlink" title="LOJ6039. 「雅礼集训 2017 Day5」珠宝"></a>LOJ6039. 「雅礼集训 2017 Day5」珠宝</h2><p>对于$C$一样的物品，我们要选肯定是要先选价值大的，所以$sum$数组是一个上凸的</p><p>$i<j$且$i$的决策点为$p$，即有任意$s<p$满足 $dp[s]+sum[s,i]<dp[p]+sum[p,i]$,然后决策单调性即可。 </p><h2 id="LOJ6040-「雅礼集训-2017-Day5」矩阵"><a href="#LOJ6040-「雅礼集训-2017-Day5」矩阵" class="headerlink" title="LOJ6040. 「雅礼集训 2017 Day5」矩阵"></a>LOJ6040. 「雅礼集训 2017 Day5」矩阵</h2><p> 咕咕</p><h2 id="LOJ6041-「雅礼集训-2017-Day7」事情的相似度"><a href="#LOJ6041-「雅礼集训-2017-Day7」事情的相似度" class="headerlink" title="LOJ6041. 「雅礼集训 2017 Day7」事情的相似度"></a>LOJ6041. 「雅礼集训 2017 Day7」事情的相似度</h2><p>建好link树之后。</p><ul><li>给定一棵树，每个点有一个权值$(𝑚𝑥𝑙𝑒𝑛)$，询问编号在一段区间内的点两两之间$𝑙𝑐𝑎$权值的最大值。</li></ul><p>离线来看，对于一个点他到根节点的都要打上标记，如果下次访问到则表示存在$lca$.其实就是动态维护所有的$lca$出现的时机。</p><p>若遇到了以前打的标记，则该节点为旧标记与新标记的$lca$ 。贪心可得应把标记尽量<strong>覆盖为较大的值</strong>，已经只会维护$[i,r]$之间区间。</p><h2 id="LOJ6045-「雅礼集训-2017-Day8」价"><a href="#LOJ6045-「雅礼集训-2017-Day8」价" class="headerlink" title="LOJ6045. 「雅礼集训 2017 Day8」价"></a>LOJ6045. 「雅礼集训 2017 Day8」价</h2><hr><h1 id="Codeforces"><a href="#Codeforces" class="headerlink" title="Codeforces"></a>Codeforces</h1><h2 id="CF1358F-Tasty-Cookie"><a href="#CF1358F-Tasty-Cookie" class="headerlink" title="CF1358F Tasty Cookie"></a>CF1358F Tasty Cookie</h2><ul><li>翻转$a$数列</li><li>将$a$数列变成他的前缀和</li></ul><p>前缀和不断增大得很快。$n\geq 3$模拟即可，你问我咋模拟，$std$,满足单调增就差分，不满足就倒置，否则就$-1$。</p><p>$n=2$,就特别麻烦。</p><ul><li>根据上题，我们需要把本来差分的部分快速差分，</li><li>如果快速差分过程中出现$a$数组，两两特判。</li><li>以上情况都没有并且被差分到某个数$=0$,$-1$</li></ul><p>之后就是看清题意写整齐</p><h2 id="CF1367F2-Flying-Sort-Hard-Version"><a href="#CF1367F2-Flying-Sort-Hard-Version" class="headerlink" title="CF1367F2 Flying Sort (Hard Version)"></a>CF1367F2 Flying Sort (Hard Version)</h2><p>我们可以发现，中间的数字是不能插进去的，所以这组数是在排序后仍相邻的数，则要找到最长的子序列。</p><p>对于相同数字的考究。</p><ul><li>如果一个数当第一位以及最后一位，数量是可以任意。</li><li>否则必须全部数字加进去。</li></ul><p>先离散化一下。<br>我们可以这样$dp$,$dp[i]$，表示$[1,i]$最长的不严格增序列</p><ul><li>把$a[i]-1$当中间的数字，则$dp[i]=dp[l[a[i]-1]+cnt[a[i]-1]$</li><li>把$a[i]-1$当第一的数字，则$dp[i]=cnt[a[i]-1]+1$</li><li>把$a[i]$当最后一位的数字，则$dp[i]=dp[pre[a[i]]]+1$</li></ul><h2 id="CF1368E-Ski-Accidents"><a href="#CF1368E-Ski-Accidents" class="headerlink" title="CF1368E Ski Accidents"></a>CF1368E Ski Accidents</h2><p>有 $n$ 个顶点，以及 $m$条有向边，所有有向边$(u,v)$ 均满足 $u<v$ ，且所有顶点的出度都不超过 $2$ ，要求从中删去不超过 $\frac{4}{7}$个顶点，使得图中不存在长度超过$1$ 的路径。</p><p>如果是完全二叉树显然可以的$4/7$。考虑反向建边，如果找到长度为 $2$的路径的顶点时，将顶点 $i$ 删掉即可,并且由于题目所给$u<v$，就不会有后效性了。</p><h2 id="CF1374E2-Reading-Books-hard-version"><a href="#CF1374E2-Reading-Books-hard-version" class="headerlink" title="CF1374E2 Reading Books (hard version)"></a>CF1374E2 Reading Books (hard version)</h2><p>思路很明显，先离散化离线，后面做权值线段树第$k$大。别把线段树写错了。</p><h2 id="CF1380G-Circular-Dungeon"><a href="#CF1380G-Circular-Dungeon" class="headerlink" title="CF1380G Circular Dungeon"></a>CF1380G Circular Dungeon</h2><p>自己做出来的，按照宝箱大小去分配遇到$k$个之前的价值。这里可以提前预处理，前缀和即可。注意下无法$(n-i)\mod i \not = 0$即可。</p><h2 id="CF1384D-GameGame"><a href="#CF1384D-GameGame" class="headerlink" title="CF1384D. GameGame"></a>CF1384D. GameGame</h2><p>对于每位来说如果异或位$0$,则这位没影响。</p><p>考虑最高位异或不为$0$,必定在此有决战，且必定有奇数个$1$。观察下可得如果都是$1$,则$cnt\mod 4=1$。或者$cnt\mod 4=2,(n-cnt)\mod 2=1$，拿到奇数个$1$之后有$0$拿。</p><h2 id="CF1387B1-Village-Minimum"><a href="#CF1387B1-Village-Minimum" class="headerlink" title="CF1387B1 Village (Minimum)"></a>CF1387B1 Village (Minimum)</h2><p>简单的树形$dp$。</p><h2 id="CF1387B2-Village-Maximum"><a href="#CF1387B2-Village-Maximum" class="headerlink" title="CF1387B2 Village (Maximum)"></a>CF1387B2 Village (Maximum)</h2><p>答案显而易见$\sum min(n - siz[i], siz[i])$。</p><p>看怎么合理分配。$min(n - siz[i], siz[i])\leq n/2$，也就是路径必须经过重心</p><p>则答案一定产生在重心的子树里，$siz[i]\leq n/2$,也一定是重心的每个子树里的点互相匹配。</p><p>这个序列的第$i$项和第$i+\lfloor\frac{n}{2}\rfloor$，匹配，注意$n\&1$，有个点会保持不变，其实此时交换不会发生变化，随便找个点互换即可。</p><h2 id="CF1399E2-Weights-Division-hard-version"><a href="#CF1399E2-Weights-Division-hard-version" class="headerlink" title="CF1399E2 Weights Division (hard version)"></a>CF1399E2 Weights Division (hard version)</h2><p>分类花费硬币的价值每个边权计算$/2$给予的价值。可以提前$n\log$处理，反正除我之前一定要除我之前的。</p><p>就变成花费硬币$1$，所以直接枚举一个的种类使用的数量，再二分或者单调队列另一个。</p><h2 id="CF1354C2-Not-So-Simple-Polygon-Embedding"><a href="#CF1354C2-Not-So-Simple-Polygon-Embedding" class="headerlink" title="CF1354C2. Not So Simple Polygon Embedding"></a>CF1354C2. Not So Simple Polygon Embedding</h2><p>求$n$为奇数，$n$为偶数</p><ul><li>可以变成扩大变成偶数，偶数就是非常简单。</li><li>选择$\frac{pi}{2n}$，<strong>不要被六边形迷惑计算</strong>。</li></ul><h2 id="CF1354F-Summoning-Minions"><a href="#CF1354F-Summoning-Minions" class="headerlink" title="CF1354F. Summoning Minions"></a>CF1354F. Summoning Minions</h2><p>解释一下为啥是一定是前$k-1$张放下，然后$n-k$张放了就拿走，最后一张再放下。</p><p>首先无论怎么放终究是$\sum a_i+(k-1)\sum b_i+\sum (j-1)b_j$。</p><p>这样肯定是最优的，然后其实就是枚举所有最后留在桌子上的$C_n^k$张权值就定了。一定不会错过最优解，然后知道了就简单的二维$dp$。</p><h2 id="CF1354G-Find-a-Gift"><a href="#CF1354G-Find-a-Gift" class="headerlink" title="CF1354G. Find a Gift"></a>CF1354G. Find a Gift</h2><p>注意$k\leq \frac{n}{2}$，就可以随机化确定$1$是否为礼物了。只要出现小的一定是礼物。显然随机化$k$,如果是礼物一定会出现$2$。否则是石头是不会出现$2$的。</p><p>然后就可以通过一次次倍增确定$[1,2^k]$是否为石子， 也可以发现$(2^k,<br>2^{k+1}]$，然后既然我知道有可以对比的任何小于区间的石头,就可以轻松用二分找到最左端的礼物在哪了。</p><h2 id="CF1421E-Swedish-Heroes"><a href="#CF1421E-Swedish-Heroes" class="headerlink" title="CF1421E. Swedish Heroes"></a>CF1421E. Swedish Heroes</h2><p>找到规律一定是正负交替，并且发现只需要$(n+\sum [p_i=-1])\mod 3=1$。并且不能为$+-+-+$这样显然不可能。设$m=\sum [p_i=-1]$,$dp[n][m][last][flag]$,$last=$最后一个$a_i$的正负，是否当前为$+-+-$</p><h2 id="CF1353F-Decreasing-Heights"><a href="#CF1353F-Decreasing-Heights" class="headerlink" title="CF1353F. Decreasing Heights"></a>CF1353F. Decreasing Heights</h2><p>一定有元素不变，直接枚举不变的$O(n^4)dp$</p><h2 id="CF1353E-K-periodic-Garland"><a href="#CF1353E-K-periodic-Garland" class="headerlink" title="CF1353E. K-periodic Garland"></a>CF1353E. K-periodic Garland</h2><p>看错题意+失误，类似于求子段最大和一样即可。注意$dp$可以重头开始，也可以接后面的。</p><h2 id="CF1427E-Xum"><a href="#CF1427E-Xum" class="headerlink" title="CF1427E . Xum"></a>CF1427E . Xum</h2><p>通过给定的$a$,$a$为奇数，操作$\oplus, +$构造出一个$1$,显然$ax-by=1$即可。构造一个互质的$y$即可，暴力枚举$(a\times(2k+1)\oplus a)$，然后注意范围$ax\leq 10^{12}$，$x\times t$这个好构造。注意控制大小。</p><h2 id="CF1344D-Resume-Review"><a href="#CF1344D-Resume-Review" class="headerlink" title="CF1344D.Résumé Review"></a>CF1344D.Résumé Review</h2><p>暴力很好想，把$a_i-3x^2+3x-1$，放到优先队列里面一个一个取。</p><p>而这里巧妙枚举了最后结束的$\Delta f(i,x)$，可以判断每个最多可以取多少。（这里再用二分）。</p><p>然后细节就需要，因为可能有好几个相同的值，所以二分时候往大的方向取答案，即找到满足条件的尽可能小的值，然后由于可能多了使用次数，找到$=ans$,—。</p><h2 id="CF1344C-Quantifier-Question"><a href="#CF1344C-Quantifier-Question" class="headerlink" title="CF1344C Quantifier Question"></a>CF1344C Quantifier Question</h2><p>题意很恶心，注意$x$成立是有顺序的，显然有环不可能。然后所有存在一定可能，然后发现如果出现一个任意，递推到我的和我递推的都要变成存在，又因为$a<b,b<c,a<c$,具有传递性，就是说跑这个有向图跑到的点都要变成存在（别忘记跑反图。然后我们发现只要被任意一个图跑到的节点，他的值也确定了，我的反图和正图那些也不能任意了，要做一样的操作。</p><h2 id="CF1363F-Rotating-Substrings"><a href="#CF1363F-Rotating-Substrings" class="headerlink" title="CF1363F Rotating Substrings"></a>CF1363F Rotating Substrings</h2><p>给定两个长度为 $n$ 的字符串 $s$，$t$。定义一次操作为选择 $s$ 的一个子串 $s_{l, l +1, \dots, r}$<br><br> ，然后将之修改为 $s_{r, l, l + 1, l + 2, \dots, r - 1 }$s<br>请求助使 $s$ 与 $t$ 相等的最小操作次数。无解输出 $-1$。</p><p>$S$的前$i$个字符和$T$的前$j$个字符匹配的最小花费</p><p>每一个操作可以让一个字符提到前面的任何位置，并不能提到到后面，最少的操作次数是$n$ - 两个字符串的最长公共子序列。</p><p>但是对于$acbd,adbc$。匹配到第三个字符的时候，显然不能把$c$放到后面去。这个时候在做最长公共子序列。我们需要加上一个条件，$s$的每个字母后缀数量必须比$t$多即可。</p><h2 id="CF1408E-Avoid-Rainbow-Cycles"><a href="#CF1408E-Avoid-Rainbow-Cycles" class="headerlink" title="CF1408E Avoid Rainbow Cycles"></a>CF1408E Avoid Rainbow Cycles</h2><p>如果我保留某个元素，那么这个集合就会和所有有这个元素的点连边。我们把集合当成一个点，那么当两个集合同时选择一个$x$，$x$连集合$A$,集合$B$连$x$,$A-B$，即最后要搞一个最大生成树即可。</p><h2 id="CF1408F-Two-Different"><a href="#CF1408F-Two-Different" class="headerlink" title="CF1408F Two Different"></a>CF1408F Two Different</h2><p>模拟时，显然$2^n$的长度暴力模拟，就会全部变成一个。然后对剩下的贪心分配。</p><p>但是直接正做一遍，反做一遍就好了。(我是傻逼)</p><h2 id="CF1422F-Boring-Queries"><a href="#CF1422F-Boring-Queries" class="headerlink" title="CF1422F Boring Queries"></a>CF1422F Boring Queries</h2><p>在线区间$lcm$</p><p> 解1</p><ul><li><p>对于小于等$\sqrt{2\cdot 10^5}$的质因子，直接各开一个线段树暴力维护，需要动态以及常数优化</p></li><li><p>对于大于 $\sqrt{2\cdot 10^5}$<br>的质因子，每个元素至多有一个。这有点像维护区间不同颜色个数，$\sum [last_x<l]$只不过每个颜色还带了权值（强制在线）</p></li><li><p>版本$r$这个线段树维护的是点$x$，维护的是$last[t]=x$,的$t$的所有乘积。</p><p>解2</p></li></ul><p>根据解$1$去做预处理第 $i$版本的线段树时，将 $i$ 位置的权值乘上 $a_i$的大质因子，为了防止二次计算，并将$a_i$上次出现的位置除掉该质因子。</p><ul><li>版本$r$这个线段树维护的是位置$x$,在$[1,r]$上的乘积。</li></ul><h2 id="CF1437G-Death-DBMS"><a href="#CF1437G-Death-DBMS" class="headerlink" title="CF1437G - Death DBMS"></a>CF1437G - Death DBMS</h2><p>$AC$自动机上树链剖分最大值，或者标记永久化线段树维护子树点的最大值。</p><h2 id="CF1436F-Sum-Over-Subsets"><a href="#CF1436F-Sum-Over-Subsets" class="headerlink" title="CF1436F. Sum Over Subsets"></a>CF1436F. Sum Over Subsets</h2><p>用$jiangly$的话说看到$\gcd=1$,一定想到莫比乌斯容斥这种东西。</p><p>然后想想没有限制咋做。</p><ul><li>$a_i\times a_i$产生贡献。选择一个$(k-1)$是被踢掉的，然后随便选$2^{k-2}$</li><li>$a_i\times a_j$产生贡献。（是有顺序的那种），$2^{k-3}(k-2)[a_i,a_j\in A]+^{k-3}(k-2)[a_j\in A,a_i\in B]$。</li></ul><p>维护一下两个乘积的$\sum$即可。</p><h2 id="CF1443F-Identify-the-Operations"><a href="#CF1443F-Identify-the-Operations" class="headerlink" title="CF1443F - Identify the Operations"></a>CF1443F - Identify the Operations</h2><p>先考虑如何处理不合法的情况。每次删观察是否两边都是不需要的数。</p><p>正解其实很简单，观察拿出某个数之后，此时这个数就成了不必要的数。如果下次想拿被移走的数，其实间接在拿$pos_{b_i}$，并且一定拿的到，然后模拟一下就没了。</p><h2 id="CF1443E-Long-Permutation"><a href="#CF1443E-Long-Permutation" class="headerlink" title="CF1443E - Long Permutation"></a>CF1443E - Long Permutation</h2><p>大水题，逆康托展开得维护后$14$个数就好了。</p><ul><li>提醒我要准备他两板子了。两者都可以做到$n\log n$。</li></ul><h2 id="CF19D"><a href="#CF19D" class="headerlink" title="CF19D"></a>CF19D</h2><p>这题告诉我们线段树上区间二分时间复杂度不大。</p><h2 id="CF204E-Little-Elephant-and-Strings"><a href="#CF204E-Little-Elephant-and-Strings" class="headerlink" title="CF204E Little Elephant and Strings"></a>CF204E Little Elephant and Strings</h2><p>锁定字符串的每个$r$,就可以知道这个后缀是否存在$k$个重复。</p><p>然后标记下，某个结点可以贡献的就是结点到根最大有标记的$len$，瞎几把维护即可。</p><h2 id="CF793C-Mice-problem"><a href="#CF793C-Mice-problem" class="headerlink" title="CF793C Mice problem"></a>CF793C Mice problem</h2><p>阴间题。</p><p>我们只要把每一个老鼠在矩形里的时间段算出来然后取交集，若交集非空则输出交集中的任意点即可。<br>但是有很多恶心的点。</p><ul><li>出现与边的线段一样的直线，永远不能交在矩阵内。</li><li>如果最后交集在一个时间点，也永远不能在矩阵内。</li><li>如果有不动点要特殊判断。</li></ul><h2 id="CF1285E-Delete-a-Segment"><a href="#CF1285E-Delete-a-Segment" class="headerlink" title="CF1285E Delete a Segment"></a>CF1285E Delete a Segment</h2><p>你要求出 正好删去一条线段后，并集 最多包括多少条线段。</p><ul><li><p>如果不删，就把所有线段排个序加入，然后判如果加入的左端点小于当前最大右端点则，出现了一个新的线段。考虑$dp[i][r][2]$显然空间不够，但是发现删一条边，对枚举到一个点的$r$产生$2$个状态。直接暴力$map$保持即可。</p></li><li><p>考虑计算去掉每条线段的贡献，显然如果出现$[[\ ],[\ ]]$这种情况这条线段的贡献是+2的，推广到一般形式，如果在括号匹配中遇到$set$里只有一个括号$[$显然去掉我是可以让之后的括号与之前括号分离。但是要记住加入一个括号他自己这个并集也会消失，然后用$set$维护即可（主要$set$好删除）</p></li></ul><h2 id="CF1451E-Bitwise-Queries"><a href="#CF1451E-Bitwise-Queries" class="headerlink" title="CF1451E Bitwise Queries"></a>CF1451E Bitwise Queries</h2><p>其实就是探究如何在$4$次询问找到$a,b,c$</p><p>首先记住$a+b=a\oplus b+2(a\&b)$</p><p>观察题目都是$[0,2^n)$。</p><p>假设有重复那就很简单。</p><p>如果没有重复</p><ul><li><p>可以白票一个询问，一定存在$a_i \oplus a_j=2^n$,并且此时$a_i \& a_j=2^n$</p></li><li><p>或者直接确定根据异或1的和异或2的推导出即可。</p></li></ul><h2 id="CF1452E-Two-Editorials"><a href="#CF1452E-Two-Editorials" class="headerlink" title="CF1452E Two Editorials"></a>CF1452E Two Editorials</h2><p>二维差分细节题，只是场上摸鱼了。这里只是告诉自己别摸鱼</p><h2 id="CF1158B-The-minimal-unique-substring"><a href="#CF1158B-The-minimal-unique-substring" class="headerlink" title="CF1158B The minimal unique substring"></a>CF1158B The minimal unique substring</h2><p>打表得到的，循环$(n-k)/2$个$1$+$0$,即可。</p><p>考虑$110110110$此时每加循环$k=k+1$,设$x$个1</p><script type="math/tex; mode=display">n-2(x+1)+2=k,x=(n+k)/2</script><h2 id="CF1158C-Permutation-recovery"><a href="#CF1158C-Permutation-recovery" class="headerlink" title="CF1158C Permutation recovery"></a>CF1158C Permutation recovery</h2><p>考虑最简单$val_{nxt[i]}>i,i>j， j\in[i+1,nxt[i]-1]$</p><p>连好边，有线段树优化一下边，就可以拓扑排序，就做完了。</p><h2 id="CF1251E2-Voting-Hard-Version"><a href="#CF1251E2-Voting-Hard-Version" class="headerlink" title="CF1251E2 Voting (Hard Version)"></a>CF1251E2 Voting (Hard Version)</h2><p>很巧妙的贪心，从跟随大贪心去考虑，如果发现我就算把后面全部选完，还不能免费跟随，就需要从剩下里选最小的，保证后面都选完就可以免费跟随了。</p><h2 id="CF1283F-DIY-Garland"><a href="#CF1283F-DIY-Garland" class="headerlink" title="CF1283F DIY Garland"></a>CF1283F DIY Garland</h2><p>可以知道叶子结点，根结点，以及<strong>每个点的出度</strong>。从小的选，一定选叶子结点里面最小的那个结点，这里注意当点的出度为$0$，才能放入堆里，。仔细思考想想即可。</p><h2 id="CF1461F-Mathematical-Expression"><a href="#CF1461F-Mathematical-Expression" class="headerlink" title="CF1461F Mathematical Expression"></a>CF1461F Mathematical Expression</h2><p>大力分类讨论。</p><p>只需要处理$*+$</p><p>用$0$分开每一段。</p><p>此时就有个$n^2$的$dp$。首先去头尾$1$，一定是$+$,如果我一段之间的乘积是$K$，如果用$1$分开，最坏就是$2+K/2+n>K$,$K>2n$用$1$分开就没有意义了。考虑到此时非$1$的有$\log n$个。</p><p>对于$dp$</p><ul><li>$a[i]=1$,一定选择$+$。</li><li>$a[i]\not ={1}$,需要选择乘法区间转移即可$dp[i]=\max{dp[j]+\prod_{t=j+1}^ia[t]}$。</li></ul><p>拿个数组记录过程即可复杂度$O(n\log n)$</p><h2 id="CF1462F-The-Treasure-of-The-Segments"><a href="#CF1462F-The-Treasure-of-The-Segments" class="headerlink" title="CF1462F The Treasure of The Segments"></a>CF1462F The Treasure of The Segments</h2><p>求的是删除最少的线段使存在一条线段能够和其他所有线段均重合</p><p>对于每条线段求一遍即可，统计一下跟他不重合的就行了。</p><h2 id="CF1463E-Plan-of-Lectures"><a href="#CF1463E-Plan-of-Lectures" class="headerlink" title="CF1463E Plan of Lectures"></a>CF1463E Plan of Lectures</h2><p>一直在想咋判不正确。显然需要输出方案，直接缩点拓扑排序，为了防止缩点里面又不合法的，我们直接在原图上再连边去拓扑排序，看是否可以实现。</p><h2 id="CF1464B-Grime-Zoo"><a href="#CF1464B-Grime-Zoo" class="headerlink" title="CF1464B Grime Zoo"></a>CF1464B Grime Zoo</h2><p>如果$1$,$0$的数量定了，$01+10$已经定了。<br>那我要让$10$更多，坑定是把$1$往前放，获得更多$10$，反之也是。<br>所以只需要瞎几把预处理即可。枚举前缀都是$0$，后缀都是$1$的情况。</p><h2 id="CF1464C-Poman-Numbers"><a href="#CF1464C-Poman-Numbers" class="headerlink" title="CF1464C Poman Numbers"></a>CF1464C Poman Numbers</h2><p>打表，贪心。</p><hr><h1 id="洛谷"><a href="#洛谷" class="headerlink" title="洛谷"></a>洛谷</h1><h2 id="P4103-HEOI2014-大工程"><a href="#P4103-HEOI2014-大工程" class="headerlink" title="P4103 [HEOI2014]大工程"></a>P4103 [HEOI2014]大工程</h2><p>记录下最长边，最小边，次小边，次大边即可,虚树模版题。</p><h2 id="P5504-JSOI2011-柠檬"><a href="#P5504-JSOI2011-柠檬" class="headerlink" title="P5504 [JSOI2011]柠檬"></a>P5504 [JSOI2011]柠檬</h2><p>一番证明就可以发现最优的两端一定是相同数，如果左右端点贝壳大小不相等的话，必然有一个端点对答案没有贡献。干嘛不直接分开呢？</p><p>上凸包维护对于每个$a_i$。然后斜率优化即可单调栈（PS:好像没啥麻烦的，甚至直接二分上凸包也可以）。</p><h2 id="P2542-AHOI2005-航线规划"><a href="#P2542-AHOI2005-航线规划" class="headerlink" title="P2542 [AHOI2005] 航线规划"></a>P2542 [AHOI2005] 航线规划</h2><p>LCT维护边权，简单多了。如果连接成环，就把这些全部变成$0$.这些就不会是关键路径。</p><hr><h1 id="Atcoder"><a href="#Atcoder" class="headerlink" title="Atcoder"></a>Atcoder</h1><h2 id="AtCoder-Grand-Contest-048"><a href="#AtCoder-Grand-Contest-048" class="headerlink" title="AtCoder Grand Contest 048"></a>AtCoder Grand Contest 048</h2><h2 id="ACL-Beginner-Contest"><a href="#ACL-Beginner-Contest" class="headerlink" title="ACL Beginner Contest"></a>ACL Beginner Contest</h2><h3 id="F-Heights-and-Pairs"><a href="#F-Heights-and-Pairs" class="headerlink" title="F - Heights and Pairs"></a>F - Heights and Pairs</h3><p>容斥是显然的。$f(i)$表示保证$i$对相同的答案。$g(i)$表示随便选$i$人成对的数量。$z(i)$表示选$i$对情侣的方法。</p><p>对于每种$h_i$我们可以计算出选出$i$对的方法,变成多项式就是$(k_0x^0+k_1x_1+k_2x^2…)$，启发式$NTT$即可。</p><p>$g(i)=g(i-2)\times C_{i-2}^2/(i/2)$</p><p>$f(i)=g(2n-2i)z(i)$</p><p>$ans=f(0)-f(1)+f(2)-f(3)…$</p><p>当然想要想的更快，二项式反演就不用思考了。（显然我要复习下）</p><hr><h1 id="牛客"><a href="#牛客" class="headerlink" title="牛客"></a>牛客</h1><h2 id="ICPC小米邀请赛2"><a href="#ICPC小米邀请赛2" class="headerlink" title="ICPC小米邀请赛2"></a>ICPC小米邀请赛2</h2><h3 id="A-2020"><a href="#A-2020" class="headerlink" title="A.2020"></a>A.2020</h3><p>赛时没做，考虑二分，先安排前$k$个再安排后$k$个，就没了。</p><h3 id="I-Subsequence-Pair"><a href="#I-Subsequence-Pair" class="headerlink" title="I.Subsequence Pair"></a>I.Subsequence Pair</h3><p>脑子进水题，想到$lcs$然后，问马老师：说不需要$LCS$。</p><p>其实就是$lcs$裸题。</p><ul><li>$\max(dp_{i,j}+m-j)$,公共一样直接贪心染$t$取最长。</li><li>$\max(dp_{i-1,j-1}+m-j-1+n-j-1)$，如果发现$s_i<t_j$,发现取完之后就随便取了。</li></ul>]]></content>
<summary type="html">
<p>鸽子的题解太多了。只好直接写。</p>
<!-- TOC -->
<ul>
<li><a href="#gym">GYM</a><ul>
<li><a href="#2019-ccpc-哈尔滨">2019-CCPC-哈尔滨</a><ul>
<li><a href="#b-binary-numbers">B. Binary Numbers</a></li>
<li><a href="#e-exchanging-gifts">E. Exchanging Gifts</a></li>
<li><a href="#i-interesting-permutation">I. Interesting Permutation</a></li>
<li><a href="#l-lru-algorithm">L. LRU Algorithm</a></li>
</ul>
</li>
<li><a href="#300iq-contest-1">300iq Contest 1</a><ul>
<li><a href="#bbest-subsequence">B.Best Subsequence</a></li>
<li><a href="#ccool-pairs">C.Cool Pairs</a></li>
<li><a href="#d-dates">D. Dates</a></li>
<li><a href="#f-free-edges">F. Free Edges</a></li>
<li><a href="#k-knowledge">K. Knowledge</a></li>
</ul>
</li>
<li><a href="#icpc-asia-east-continent-final">ICPC Asia-East Continent Final</a><ul>
<li><a href="#hking">H.King</a></li>
</ul>
</li>
</ul>
</li>
<li><a href="#雅礼集训">雅礼集训</a><ul>
<li><a href="#loj6029-雅礼集训-2017-day1市场">LOJ6029. 「雅礼集训 2017 Day1」市场</a></li>
<li><a href="#loj6030-雅礼集训-2017-day1矩阵">LOJ6030. 「雅礼集训 2017 Day1」矩阵</a></li>
<li><a href="#loj6031-雅礼集训-2017-day1字符串">LOJ6031. 「雅礼集训 2017 Day1」字符串</a></li>
<li><a href="#loj6032-雅礼集训-2017-day2水箱">LOJ6032. 「雅礼集训 2017 Day2」水箱</a></li>
<li><a href="#loj6033-雅礼集训-2017-day2棋盘游戏">LOJ6033. 「雅礼集训 2017 Day2」棋盘游戏</a></li>
<li><a href="#loj6034-雅礼集训-2017-day2线段游戏">LOJ6034. 「雅礼集训 2017 Day2」线段游戏</a></li>
<li><a href="#loj6035-雅礼集训-2017-day4洗衣服">LOJ6035. 「雅礼集训 2017 Day4」洗衣服</a></li>
<li><a href="#loj6036-雅礼集训-2017-day4编码">LOJ6036. 「雅礼集训 2017 Day4」编码</a></li>
<li><a href="#loj6038-雅礼集训-2017-day5远行">LOJ6038. 「雅礼集训 2017 Day5」远行</a></li>
<li><a href="#loj6039-雅礼集训-2017-day5珠宝">LOJ6039. 「雅礼集训 2017 Day5」珠宝</a></li>
<li><a href="#loj6040-雅礼集训-2017-day5矩阵">LOJ6040. 「雅礼集训 2017 Day5」矩阵</a></li>
<li><a href="#loj6041-雅礼集训-2017-day7事情的相似度">LOJ6041. 「雅礼集训 2017 Day7」事情的相似度</a></li>
<li><a href="#loj6045-雅礼集训-2017-day8价">LOJ6045. 「雅礼集训 2017 Day8」价</a></li>
</ul>
</li>
<li><a href="#codeforces">Codeforces</a><ul>
<li><a href="#cf1358f-tasty-cookie">CF1358F Tasty Cookie</a></li>
<li><a href="#cf1367f2-flying-sort-hard-version">CF1367F2 Flying Sort (Hard Version)</a></li>
<li><a href="#cf1368e-ski-accidents">CF1368E Ski Accidents</a></li>
<li><a href="#cf1374e2-reading-books-hard-version">CF1374E2 Reading Books (hard version)</a></li>
<li><a href="#cf1380g-circular-dungeon">CF1380G Circular Dungeon</a></li>
<li><a href="#cf1384d-gamegame">CF1384D. GameGame</a></li>
<li><a href="#cf1387b1-village-minimum">CF1387B1 Village (Minimum)</a></li>
<li><a href="#cf1387b2-village-maximum">CF1387B2 Village (Maximum)</a></li>
<li><a href="#cf1399e2-weights-division-hard-version">CF1399E2 Weights Division (hard version)</a></li>
<li><a href="#cf1354c2-not-so-simple-polygon-embedding">CF1354C2. Not So Simple Polygon Embedding</a></li>
<li><a href="#cf1354f-summoning-minions">CF1354F. Summoning Minions</a></li>
<li><a href="#cf1354g-find-a-gift">CF1354G. Find a Gift</a></li>
<li><a href="#cf1421e-swedish-heroes">CF1421E. Swedish Heroes</a></li>
<li><a href="#cf1353f-decreasing-heights">CF1353F. Decreasing Heights</a></li>
<li><a href="#cf1353e-k-periodic-garland">CF1353E. K-periodic Garland</a></li>
<li><a href="#cf1427e--xum">CF1427E . Xum</a></li>
<li><a href="#cf1344drésumé-review">CF1344D.Résumé Review</a></li>
<li><a href="#cf1344c-quantifier-question">CF1344C Quantifier Question</a></li>
<li><a href="#cf1363f-rotating-substrings">CF1363F Rotating Substrings</a></li>
<li><a href="#cf1408e-avoid-rainbow-cycles">CF1408E Avoid Rainbow Cycles</a></li>
<li><a href="#cf1408f-two-different">CF1408F Two Different</a></li>
<li><a href="#cf1422f-boring-queries">CF1422F Boring Queries</a></li>
<li><a href="#cf1437g---death-dbms">CF1437G - Death DBMS</a></li>
<li><a href="#cf1436f-sum-over-subsets">CF1436F. Sum Over Subsets</a></li>
<li><a href="#cf1443f---identify-the-operations">CF1443F - Identify the Operations</a></li>
<li><a href="#cf1443e---long-permutation">CF1443E - Long Permutation</a></li>
<li><a href="#cf19d">CF19D</a></li>
<li><a href="#cf204e-little-elephant-and-strings">CF204E Little Elephant and Strings</a></li>
<li><a href="#cf793c-mice-problem">CF793C Mice problem</a></li>
<li><a href="#cf1285e-delete-a-segment">CF1285E Delete a Segment</a></li>
<li><a href="#cf1451e-bitwise-queries">CF1451E Bitwise Queries</a></li>
<li><a href="#cf1452e-two-editorials">CF1452E Two Editorials</a></li>
<li><a href="#cf1158b-the-minimal-unique-substring">CF1158B The minimal unique substring</a></li>
<li><a href="#cf1158c-permutation-recovery">CF1158C Permutation recovery</a></li>
<li><a href="#cf1251e2-voting-hard-version">CF1251E2 Voting (Hard Version)</a></li>
<li><a href="#cf1283f-diy-garland">CF1283F DIY Garland</a></li>
<li><a href="#cf1461f-mathematical-expression">CF1461F Mathematical Expression</a></li>
<li><a href="#cf1462f-the-treasure-of-the-segments">CF1462F The Treasure of The Segments</a></li>
<li><a href="#cf1463e-plan-of-lectures">CF1463E Plan of Lectures</a></li>
<li><a href="#cf1464b-grime-zoo">CF1464B Grime Zoo</a></li>
<li><a href="#cf1464c-poman-numbers">CF1464C Poman Numbers</a></li>
</ul>
</li>
<li><a href="#洛谷">洛谷</a><ul>
<li><a href="#p4103-heoi2014大工程">P4103 [HEOI2014]大工程</a></li>
<li><a href="#p5504-jsoi2011柠檬">P5504 [JSOI2011]柠檬</a></li>
<li><a href="#p2542-ahoi2005-航线规划">P2542 [AHOI2005] 航线规划</a></li>
</ul>
</li>
<li><a href="#atcoder">Atcoder</a><ul>
<li><a href="#atcoder-grand-contest-048">AtCoder Grand Contest 048</a></li>
<li><a href="#acl-beginner-contest">ACL Beginner Contest</a><ul>
<li><a href="#f---heights-and-pairs">F - Heights and Pairs</a></li>
</ul>
</li>
</ul>
</li>
<li><a href="#牛客">牛客</a><ul>
<li><a href="#icpc小米邀请赛2">ICPC小米邀请赛2</a><ul>
<li><a href="#a2020">A.2020</a></li>
<li><a href="#isubsequence-pair">I.Subsequence Pair</a></li>
</ul>
</li>
</ul>
</li>
</ul>
<!-- /TOC -->
</summary>
<category term="训练记录" scheme="http://yoursite.com/tags/%E8%AE%AD%E7%BB%83%E8%AE%B0%E5%BD%95/"/>
</entry>
<entry>
<title>要失业了</title>
<link href="http://yoursite.com/2020/12/31/%E9%9D%A2%E8%AF%95%E6%80%BB%E7%BB%93/"/>
<id>http://yoursite.com/2020/12/31/%E9%9D%A2%E8%AF%95%E6%80%BB%E7%BB%93/</id>
<published>2020-12-31T02:47:00.000Z</published>
<updated>2021-01-22T12:24:46.000Z</updated>
<content type="html"><![CDATA[<p>要失业了</p><a id="more"></a><!-- TOC --><ul><li><a href="#计算机网络">计算机网络</a><ul><li><a href="#osi">OSI</a></li><li><a href="#输入url之后">输入URL之后</a><ul><li><a href="#构建请求">构建请求</a></li></ul></li><li><a href="#tcp-ip">TCP IP</a><ul><li><a href="#区别">区别</a></li><li><a href="#tcp的可靠连接-报文的往返时间rtt">TCP的可靠连接 报文的往返时间RTT</a><ul><li><a href="#校验和">校验和：</a></li><li><a href="#确认应答ack机制">确认应答（ACK）机制：</a></li><li><a href="#超时重传">超时重传：</a></li><li><a href="#连接管理机制">连接管理机制</a></li><li><a href="#流量控制">流量控制：</a></li><li><a href="#拥塞控制">拥塞控制：</a></li><li><a href="#停止等待协议">停止等待协议</a></li></ul></li><li><a href="#tcp三次握手">TCP三次握手</a><ul><li><a href="#tcp四次握手">TCP四次握手</a></li></ul></li><li><a href="#为什么连接的时候是三次握手关闭的时候却是四次握手">为什么连接的时候是三次握手，关闭的时候却是四次握手？</a></li><li><a href="#为什么time_wait状态需要经过2msl最大报文段生存时间才能返回到close状态">为什么TIME_WAIT状态需要经过2MSL(最大报文段生存时间)才能返回到CLOSE状态？</a></li><li><a href="#http">http</a></li></ul></li><li><a href="#http-1">HTTP</a><ul><li><a href="#报文构成">报文构成</a><ul><li><a href="#响应报文">响应报文</a></li></ul></li><li><a href="#http-状态码">HTTP 状态码</a></li><li><a href="#http10和http11的区别">HTTP1.0和HTTP1.1的区别</a></li><li><a href="#http-和-https-的区别">http 和 https 的区别</a><ul><li><a href="#https-优点-缺点">https 优点 缺点</a></li></ul></li><li><a href="#get和post的区别">GET和POST的区别</a></li></ul></li><li><a href="#ip-mac地址">IP MAC地址</a><ul><li><a href="#tcpip-数据链路交互过程">TCP/IP 数据链路交互过程。</a></li></ul></li></ul></li><li><a href="#数据库">数据库</a><ul><li><a href="#redis">redis</a><ul><li><a href="#与mongodb-数据库">与mongodb 数据库</a></li><li><a href="#数据类型">数据类型</a></li></ul></li></ul></li><li><a href="#c">C++</a><ul><li><a href="#虚函数以及多态">虚函数以及多态</a></li><li><a href="#析构函数-虚函数">析构函数 虚函数</a></li><li><a href="#关于虚函数的常见问题">关于虚函数的常见问题</a><ul><li><a href="#虚函数的代价">虚函数的代价</a></li><li><a href="#那些函数不能是虚函数">那些函数不能是虚函数？</a></li><li><a href="#虚函数和纯虚函数的区别">虚函数和纯虚函数的区别？</a></li><li><a href="#菱形继承的内存结构如何解决菱形继承存在的问题">菱形继承的内存结构？如何解决菱形继承存在的问题？</a></li><li><a href="#虚析构函数的作用父类的析构函数为什么一定要设置成虚函数">虚析构函数的作用？父类的析构函数为什么一定要设置成虚函数？</a></li><li><a href="#构造函数和析构函数中为什么不可以调用虚函数">构造函数和析构函数中为什么不可以调用虚函数？</a></li><li><a href="#构造函数为什么不能为虚函数什么情况下析构函数必须为虚函数">构造函数为什么不能为虚函数？什么情况下析构函数必须为虚函数？</a></li></ul></li><li><a href="#字节对齐">字节对齐</a><ul><li><a href="#字节对齐的细节和编译器实现相关但一般而言满足三个准则">字节对齐的细节和编译器实现相关，但一般而言，满足三个准则：</a></li></ul></li><li><a href="#c中内存泄漏的几种情况">C++中内存泄漏的几种情况</a></li><li><a href="#new和malloc的区别">new和malloc的区别</a><ul><li><a href="#属性">属性</a></li><li><a href="#参数">参数</a></li><li><a href="#返回类型">返回类型</a></li><li><a href="#分配失败">分配失败</a></li><li><a href="#自定义类型">自定义类型</a></li><li><a href="#重载">重载</a></li><li><a href="#内存区域">内存区域</a><ul><li><a href="#左值和右值的区别右值引用的概念及其应用场景">左值和右值的区别，右值引用的概念及其应用场景</a></li></ul></li><li><a href="#左值lvalue">左值(lvalue)：</a></li><li><a href="#右值rvalue">右值(rvalue)：</a></li><li><a href="#左右值转换">左右值转换</a><ul><li><a href="#左值引用">左值引用</a></li><li><a href="#右值引用">右值引用</a></li></ul></li><li><a href="#右值引用的用途">右值引用的用途</a></li></ul></li><li><a href="#free与delete的区别">free与delete的区别</a></li><li><a href="#堆和栈的区别是什么">堆和栈的区别是什么</a><ul><li><a href="#静态函数">静态函数</a></li><li><a href="#类的静态成员">类的静态成员</a></li></ul></li><li><a href="#cast转换">cast转换</a></li><li><a href="#dynamic_cast">dynamic_cast</a></li><li><a href="#reinterpret_cast">reinterpret_cast</a></li><li><a href="#指针与引用">指针与引用</a></li><li><a href="#virtual关键字的作用">virtual关键字的作用</a></li><li><a href="#resize-reserve">resize reserve</a></li><li><a href="#智能指针">智能指针</a></li><li><a href="#静态函数与虚函数的区别">静态函数与虚函数的区别</a></li><li><a href="#重载-重写">重载 重写</a></li><li><a href="#虚函数和多态">虚函数和多态</a></li><li><a href="#newdelete-mallocfree-的区别">new/delete malloc/free 的区别</a></li><li><a href="#虚函数表具体是怎么实现运行时多态的">虚函数表具体是怎么实现运行时多态的？</a></li></ul></li><li><a href="#操作系统">操作系统</a><ul><li><a href="#用户态与内核态">用户态与内核态</a></li><li><a href="#上下文切换">上下文切换</a></li><li><a href="#进程与线程的概念">进程与线程的概念</a><ul><li><a href="#进程">进程</a></li><li><a href="#线程">线程</a></li><li><a href="#区别-1">区别</a></li><li><a href="#进程调度算法">进程调度算法</a></li><li><a href="#进程间通信方式">进程间通信方式</a><ul><li><a href="#普通管道pipe">普通管道PIPE</a></li><li><a href="#命名管道fifo">命名管道FIFO</a></li><li><a href="#系统ipc">系统IPC</a></li></ul></li><li><a href="#线程间通信方式">线程间通信方式</a></li></ul></li><li><a href="#linux-虚拟地址空间">Linux 虚拟地址空间</a><ul><li><a href="#好处">好处</a></li></ul></li><li><a href="#代价">代价</a></li><li><a href="#并发-并行">并发 并行</a></li><li><a href="#os缺页置换算法">OS缺页置换算法</a></li><li><a href="#死锁">死锁</a><ul><li><a href="#必要条件">必要条件</a></li></ul></li><li><a href="#解决方法">解决方法</a></li><li><a href="#epoll">epoll</a></li><li><a href="#tcp和udp可以同时监听相同的端口吗">TCP和UDP可以同时监听相同的端口吗</a></li><li><a href="#cookie和session有什么区别">COOKIE和SESSION有什么区别？</a></li></ul></li></ul><!-- /TOC --><h1 id="计算机网络"><a href="#计算机网络" class="headerlink" title="计算机网络"></a>计算机网络</h1><h2 id="OSI"><a href="#OSI" class="headerlink" title="OSI"></a>OSI</h2><p>七层划分为</p><ul><li>应用层(HTTP，FTP，DNS) 文件传输，电子邮件，文件服务，虚拟终端 </li><li>表示层（JPEG，ASII）数据格式化，代码转换，数据加密</li><li>会话层（RPC，NFS） 解除或建立与别的接点的联系</li><li>传输层（TCP，UDP） 提供端对端的接口</li><li>网络层 (IP，ARP，ICMP) 为数据包选择路由</li><li>数据链路层(MAC，VLAN，PPP) 传输有地址的帧以及错误检测功能</li><li>物理层。</li></ul><p>五层划分为：应用层、传输层、网络层、数据链路层、物理层。</p><p>四层划分为：应用层、传输层、网络层、网络接口层。</p><h2 id="输入URL之后"><a href="#输入URL之后" class="headerlink" title="输入URL之后"></a>输入URL之后</h2><ul><li><p>浏览器查找域名对应的IP地址<br>DNS查找过程为：<br>浏览器缓存->系统缓存->路由器缓存->ISP DNS缓存->递归搜索<br>递归搜索过程为：从根域名服务器到顶级域名服务器到你查询的域名服务器。</p></li><li><p>浏览器打开TCP连接（默认端口为80），向该IP的服务器发送一条HTTP请求，如果浏览器存储了该域名下的cookie，那么cookie也会放入http请求中</p></li><li>服务器给浏览器进行一个301永久重定向响应。该IP对应的服务器很可能是代理服务器，比如你输入“<a href="http://baidu.com”,而不是“http://www.baidu.com”,按道理这两个网址对应的是同一个网页，因此通过代理服务器的方式进行重定向相应，让这两个网址访问的是同一个网页。" target="_blank" rel="noopener">http://baidu.com”,而不是“http://www.baidu.com”,按道理这两个网址对应的是同一个网页，因此通过代理服务器的方式进行重定向相应，让这两个网址访问的是同一个网页。</a></li><li>TCP连接</li><li>浏览器根据重定向地址再次进行HTTP请求。</li><li>服务器分析HTTP请求，生成HTTP响应，将响应发给客户端。</li><li>浏览器收到响应内容之后，生成主页框架，同时向服务端继续发送请求，请求的内容是主页里的一些资源，比如说图片、视频等。</li><li>对于静态的页面内容，浏览器通常进行缓存，对于动态的内容通常不缓存，缓存的时间也是有期限的。</li><li>浏览器向服务器发送异步请求，因为有些页面显示完成之后客户端仍需要与服务端保持联系。</li><li>整个过程结束之后，浏览器关闭TCP连接。</li></ul><h3 id="构建请求"><a href="#构建请求" class="headerlink" title="构建请求"></a>构建请求</h3><ul><li>应用层进行DNS解析</li><li>应用层生成HTTP请求报文</li><li>传输层建立TCP连接 因TCP是一个可靠的传输控制协议，传输层还会加入序列号、确认号、窗口大小、校验和等参数，共添加20字节的头部信息</li><li>网络层使用IP协议来选择路线</li></ul><h2 id="TCP-IP"><a href="#TCP-IP" class="headerlink" title="TCP IP"></a>TCP IP</h2><h3 id="区别"><a href="#区别" class="headerlink" title="区别"></a>区别</h3><ul><li>TCP是面向连接的，可靠性高，UDP是基于非连接的，可靠性低。</li><li>TCP三次握手延迟高，实时性较强。</li><li>在传输相同大小数据时，TCP首部开销大，报头更复杂，实际保护数据较少。 但TCP提供超时重传机制，保证不会出现丢包乱序。UDP有丢包。</li><li>TCP提供双全工通信，每条TCP的连接只能点到点。UDP支持一对多，多对一，多对多的交互通信。</li><li>数据链路层实现网络相邻结点间可靠的数据通信</li><li>物理层传输数据</li></ul><p>构建TCP请求会增加大量的网络时延，常用的优化方式如下所示</p><ul><li><p>资源打包，合并请求</p></li><li><p>多使用缓存，减少网络传输</p></li><li><p>使用keep-alive建立持久连接</p></li><li><p>使用多个域名，增加浏览器的资源并发加载数，或者使用HTTP2的管道化连接的多路复用技术</p></li></ul><h3 id="TCP的可靠连接-报文的往返时间RTT"><a href="#TCP的可靠连接-报文的往返时间RTT" class="headerlink" title="TCP的可靠连接 报文的往返时间RTT"></a>TCP的可靠连接 报文的往返时间RTT</h3><p>应用数据被分割成TCP认为最适合发送的数据块。 </p><h4 id="校验和："><a href="#校验和：" class="headerlink" title="校验和："></a>校验和：</h4><p>发送的数据包的二进制相加然后取反，目的是检测数据在传输过程中的任何变化。如果收到段的检验和有差错，TCP将丢弃这个报文段和不确认收到此报文段。 </p><h4 id="确认应答（ACK）机制："><a href="#确认应答（ACK）机制：" class="headerlink" title="确认应答（ACK）机制："></a>确认应答（ACK）机制：</h4><p>TCP将每个字节的数据都进行了编号，即为序列号。确认序号=序号+1<br>接收方收到报文就会确认（累积确认：对所有按序接收的数据的确认）<br>TCP给发送的每一个包进行编号，接收方对数据包进行排序，把有序数据传送给应用层。 </p><h4 id="超时重传："><a href="#超时重传：" class="headerlink" title="超时重传："></a>超时重传：</h4><p>当TCP发出一个段后，它启动一个定时器，等待目的端确认收到这个报文段。如果不能及时收到一个确认，将重发这个报文段。 </p><p>如果主机A未收到B发来的确认应答，也可能是因为ACK丢了。因此主机B会收到很多重复的数据，那么，TCP协议需要能够识别出那些包是重复的包，并且把重复的包丢弃，这时候我们可以用前面提到的序列号，很容易做到去重的效果</p><p>超时重传的时间设置的太短，会引起很多报文的不必要重传；<br>时间设置的过长，又会使网络的空闲时间增大，降低传输效率；<br>TCP采用了一种自适应算法，它记录一个报文发出的时间，以及收到相应确认的时间，者两个时间之差就是报文的往返时间RTT；<br>最理想的情况下，找到一个最小的时间，保证确认应答一定能在这个时间内返回<br>Linux中，超时以500s为一个单位进行控制，每次判定超时重发的超时时间都是500ms的整数倍；如果重发一次仍然得不到应答，等待2<em>500ms后再进行重传；如果仍然得不到应答，等待4</em>500ms进行重传，依次类推，以指数形式递增;累积到一定的重传次数，TCP认为网络或者对端主机出现异常，强制关闭连接。</p><h4 id="连接管理机制"><a href="#连接管理机制" class="headerlink" title="连接管理机制"></a>连接管理机制</h4><p>TCP是面向连接的，进行可靠性传输</p><h4 id="流量控制："><a href="#流量控制：" class="headerlink" title="流量控制："></a>流量控制：</h4><p>让发送方的发送速率不要太快</p><p>TCP连接的每一方都有固定大小的缓冲空间，TCP的接收端只允许发送端发送接收端缓冲区能接纳的数据。当接收方来不及处理发送方的数据，能提示发送方降低发送的速率，防止包丢失。TCP使用的流量控制协议是可变大小的滑动窗口协议。</p><p>流量控制的实现方法：接收端将自己可接受的缓冲区大小放入TCP首部中的”窗口大小字段”，通过ACK通知发送端；窗口大小字段越大，说明网络的吞吐量越高；接收端一旦发现自己的缓冲区快满了，就会将窗口大小设置成一个更小的值给发送端；发送端接受到这个窗口之后，就会减慢自己的发送速率；如果接受缓冲区满了，就会将窗口设置为0，这时发送方不在发送数据，但是需要定期发送一个窗口探测数据段，使接收端把窗口大小告诉发送端。</p><p>接收方有即时窗口（滑动窗口），随ACK报文发送</p><ul><li>数据包在传送过程中丢失了<br>当发送端的某一段报文丢失后，发送端会一直收到1001这样的ACK；如果发送端主机连续三次收到同样的”1001”这样的应答，就会将对应的数据1001-2000重新发送；当成功接收到1001之后，再次返回的ACK就是6001了，接收端在之前就已经收到（2001-7000）了，被放到了接收端操作系统内核的接受缓冲区中。这种机制被称作快重传</li><li>数据包已经递达，ACK丢了<br>部分ACK丢失了不要紧，因为可以通过后续的ACK进行确认。</li></ul><h4 id="拥塞控制："><a href="#拥塞控制：" class="headerlink" title="拥塞控制："></a>拥塞控制：</h4><p>当网络拥塞时，减少数据的发送。</p><p>慢开始 、 拥塞避免 、快重传 和 快恢复</p><h4 id="停止等待协议"><a href="#停止等待协议" class="headerlink" title="停止等待协议"></a>停止等待协议</h4><p>也是为了实现可靠传输的，它的基本原理就是每发完一个分组就停止发送，等待对方确认。在收到确认后再发下一个分组</p><h3 id="TCP三次握手"><a href="#TCP三次握手" class="headerlink" title="TCP三次握手"></a>TCP三次握手</h3><p>TCP的几个状态 (SYN, FIN, ACK, PSH, RST, URG)</p><ul><li><p>SYN 是 TCP/IP 建立连接时使用的握手信号。在客户机和服务器之间建立正常的 TCP 网络连接时， 客户机首先发出一个 SYN 消息，服务器使用 SYN-ACK 应答表示接收到了这个消息，最后客户机再 以 ACK)消息响应。这样在客户机和服务器之间才能建立 起可靠的TCP连接，数据才可以在客户机和服务器之间传递。</p></li><li><p>FIN表示关闭连接，</p></li><li><p>ACK Acknowledgement[,在数据通信传输中，接收站发给发送站的一种传输控制 字符。它表示确认发来的数据已经接受无误。 ]</p><p>双方通信无误必须是两者互相发送信息都无误。传了 SYN，证明发送方到接收方的通道没有问题，但是接收方到发送方的通道还需要 ACK 信号来进行验证。</p><h4 id="TCP四次握手"><a href="#TCP四次握手" class="headerlink" title="TCP四次握手"></a>TCP四次握手</h4></li></ul><h3 id="为什么连接的时候是三次握手，关闭的时候却是四次握手？"><a href="#为什么连接的时候是三次握手，关闭的时候却是四次握手？" class="headerlink" title="为什么连接的时候是三次握手，关闭的时候却是四次握手？"></a>为什么连接的时候是三次握手，关闭的时候却是四次握手？</h3><p>三次握手的目的是建立可靠的通信信道，说到通讯，简单来说就是数据的发送与接收，而三次握手最主要的目的就是双方确认自己与对方的发送与接收是正常的。</p><p>任何一方都可以在数据传送结束后发出连接释放的通知，待对方确认后进入半关闭状态。当另一方也没 有数据再发送的时候，则发出连接释放通知，对方确认后就完全关闭了TCP连接。</p><p>举个例子:A 和 B 打电话，通话即将结束后，A 说“我没啥要说的了”，B回答“我知道了”，但是 B 可 能还会有要说的话，A 不能要求 B 跟着自己的节奏结束通话，于是 B 可能又巴拉巴拉说了一通，最后 B 说“我说完了”，A 回答“知道了”，这样通话才算结束。</p><h3 id="为什么TIME-WAIT状态需要经过2MSL-最大报文段生存时间-才能返回到CLOSE状态？"><a href="#为什么TIME-WAIT状态需要经过2MSL-最大报文段生存时间-才能返回到CLOSE状态？" class="headerlink" title="为什么TIME_WAIT状态需要经过2MSL(最大报文段生存时间)才能返回到CLOSE状态？"></a>为什么TIME_WAIT状态需要经过2MSL(最大报文段生存时间)才能返回到CLOSE状态？</h3><p>答：虽然按道理，四个报文都发送完毕，我们可以直接进入CLOSE状态了，但是我们必须假象网络是不可靠的，有可以最后一个ACK丢失。所以TIME_WAIT状态就是用来重发可能丢失的ACK报文。在Client发送出最后的ACK回复，但该ACK可能丢失。Server如果没有收到ACK，将不断重复发送FIN片段。所以Client不能立即关闭，它必须确认Server接收到了该ACK。Client会在发送出ACK之后进入到TIME_WAIT状态。Client会设置一个计时器，等待2MSL的时间。如果在该时间内再次收到FIN，那么Client会重发ACK并再次等待2MSL。所谓的2MSL是两倍的MSL(Maximum Segment Lifetime)。MSL指一个片段在网络中最大的存活时间，2MSL就是一个发送和一个回复所需的最大时间。如果直到2MSL，Client都没有再次收到FIN，那么Client推断ACK已经被成功接收，则结束TCP连接。</p><h3 id="http"><a href="#http" class="headerlink" title="http"></a>http</h3><h2 id="HTTP"><a href="#HTTP" class="headerlink" title="HTTP"></a>HTTP</h2><h3 id="报文构成"><a href="#报文构成" class="headerlink" title="报文构成"></a>报文构成</h3><ul><li>请求方法 </li><li>请求url</li><li>HTTP版本和协议 </li><li>报文头部</li><li>报文体</li></ul><h4 id="响应报文"><a href="#响应报文" class="headerlink" title="响应报文"></a>响应报文</h4><ul><li>状态行（HTTP版本 状态码 状态码原因）响应头部</li><li>响应内容</li></ul><h3 id="HTTP-状态码"><a href="#HTTP-状态码" class="headerlink" title="HTTP 状态码"></a>HTTP 状态码</h3><ul><li>1开头：信息状态码</li><li>2开头：成功状态码 </li><li>3开头：重定向状态码</li><li>4开头：客户端错误状态码 403 服务端收到请求单拒绝提供请求</li><li><p>5开头：服务端错误状态码 </p><h3 id="HTTP1-0和HTTP1-1的区别"><a href="#HTTP1-0和HTTP1-1的区别" class="headerlink" title="HTTP1.0和HTTP1.1的区别"></a>HTTP1.0和HTTP1.1的区别</h3></li><li><p>HTTP 1.1支持长连接和请求的流水线处理。HTTP 1.0规定浏览器与服务器只保持短暂的连接，浏览器的每次请求都需要与服务器建立一个TCP连接，服务器完成请求处理后立即断开TCP连接，服务器不跟踪每个客户也不记录过去的请求。</p></li><li>HTTP 1.1增加host字段</li><li>节约带宽</li></ul><h3 id="http-和-https-的区别"><a href="#http-和-https-的区别" class="headerlink" title="http 和 https 的区别"></a>http 和 https 的区别</h3><ul><li>https协议需要申请证书</li><li>http是超文本传输协议，信息是明文传输，https则是具有安全性的ssl加密传输协议。</li><li>http端口(80),https端口(443)。</li><li>http的连接很简单，是无状态的；HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议更加安全</li></ul><h4 id="https-优点-缺点"><a href="#https-优点-缺点" class="headerlink" title="https 优点 缺点"></a>https 优点 缺点</h4><ul><li>安全</li><li>可以认证用户和服务器，确保数据发送倒正确的用户上。</li><li>握手延迟高</li><li>部署成本高</li></ul><h3 id="GET和POST的区别"><a href="#GET和POST的区别" class="headerlink" title="GET和POST的区别"></a>GET和POST的区别</h3><ul><li>GET 通过URL 传递，POST放在request body</li><li>GET长度有限制</li><li>GET更不安全</li><li>GET只能进行URL编码，POST支持多种编码方式。</li><li>GET请求回浏览器主动Cache ，而POST 支持多组编码方式</li><li>GET 请求参数回完整保留在浏览历史记录里，POST不会被保留</li><li>本质都是TCP，链接</li><li>GET产生一个TCP数据包，POST产生两个数据包</li></ul><h2 id="IP-MAC地址"><a href="#IP-MAC地址" class="headerlink" title="IP MAC地址"></a>IP MAC地址</h2><ul><li>MAC是硬件地址,用来定位网络设备的位置的，主要有数据链路层负责。而IP地址是IP协议提供的统一地址格式，为互联网上每个网络和每一台主机分配一个逻辑地址以此来屏蔽物理地址的差异。</li></ul><h3 id="TCP-IP-数据链路交互过程。"><a href="#TCP-IP-数据链路交互过程。" class="headerlink" title="TCP/IP 数据链路交互过程。"></a>TCP/IP 数据链路交互过程。</h3><p>网络层等数据链蹭用mac地址作为通信目标，数据包达到网络等准备往数据链路层层发送的时候，首先会去自己的ARP缓存标，寻找目标IP的目标地址，就将IP的mac底池封装倒链路层数据保的包头。如果缓存没找找到，就会发起广播，所有收到广播的机器看这个IP是不是自己的，则以单ba的形式将自己MAC地址回复给请求的机器。</p><h1 id="数据库"><a href="#数据库" class="headerlink" title="数据库"></a>数据库</h1><h2 id="redis"><a href="#redis" class="headerlink" title="redis"></a>redis</h2><h3 id="与mongodb-数据库"><a href="#与mongodb-数据库" class="headerlink" title="与mongodb 数据库"></a>与mongodb 数据库</h3><ul><li>内存管理机制上，redis 全部存在内存，定期写入磁盘，当内存不够选择指定的LRU算法删除数据。MongoDB数据存在内存，由Linux 系统map实习，内存不够将热点放入内存其他存在磁盘。</li><li>支持的数据结构 HASH SET LIST</li></ul><h3 id="数据类型"><a href="#数据类型" class="headerlink" title="数据类型"></a>数据类型</h3><ul><li>字符串</li><li>列表</li><li>哈希</li><li>集合</li><li>有序集合</li></ul><h1 id="C"><a href="#C" class="headerlink" title="C++"></a>C++</h1><h2 id="虚函数以及多态"><a href="#虚函数以及多态" class="headerlink" title="虚函数以及多态"></a>虚函数以及多态</h2><p>多态的实现主要分为静态多态和动态多态，静态多态，静态多态主要是重装载，在编译的时候就已经确定；动态多态是用虚函数机制实现的，在运行期间动态绑定。</p><p>虚函数的实现：在有虚函数的表中，类的的最开始部分是一个虚函数表的指针，这个指针指向一个虚函数表，表中放了虚函数的地址，实际虚函数在代码段。当子类继承了父类的时候也会继承其函数表，当子类重写父类中虚函数时候，会将其继承到虚函数表中的地址替换为原来重新系的函数地址。使用了虚函数会增加访问内存开销，降低效率。</p><h2 id="析构函数-虚函数"><a href="#析构函数-虚函数" class="headerlink" title="析构函数 虚函数"></a>析构函数 虚函数</h2><p>基类的析构函数要是虚函数的原因是，如果基类指针指向派生类，基类的析构函数不是虚函数的话，是不会调用派生类的析构函数的，只会调用基类的析构函数</p><h2 id="关于虚函数的常见问题"><a href="#关于虚函数的常见问题" class="headerlink" title="关于虚函数的常见问题"></a>关于虚函数的常见问题</h2><h3 id="虚函数的代价"><a href="#虚函数的代价" class="headerlink" title="虚函数的代价"></a>虚函数的代价</h3><p>1）带有虚函数的每个类会产生一个虚函数表，用来存储虚成员函数的指针</p><p>2）带有虚函数的每个类都会有一个指向虚函数表的指针</p><p>3）不再是内敛函数，因为内敛函数可以在编译阶段进行替代，而虚函数表示等待，在运行阶段才能确定到达采用哪种函数，所以虚函数不是内敛函数</p><h3 id="那些函数不能是虚函数？"><a href="#那些函数不能是虚函数？" class="headerlink" title="那些函数不能是虚函数？"></a>那些函数不能是虚函数？</h3><p>1）构造函数：对象的虚函数表指针需要通过构造函数初始化</p><p>2）内联函数：内联函数可以在编译阶段进行函数体的替换，而虚函数需要在运行期间进行确定</p><p>3）静态函数：静态函数不属于对象而属于类，因为静态成员函数没有this指针，所以无法访问对象的虚表指针，也就</p><p>无法访问类的虚函数表，将静态函数设置成虚函数也就没有任何意义，所以c++语法不支持将静态函数设置成虚函数</p><p>4）友元函数：友元函数不属于类，也不能被继承，没有继承特性的函数没有虚函数的说法</p><p>5）类外的普通函数：类外普通函数不是类的成员函数，同样不具备继承特性，也就没有虚函数的说法</p><h3 id="虚函数和纯虚函数的区别？"><a href="#虚函数和纯虚函数的区别？" class="headerlink" title="虚函数和纯虚函数的区别？"></a>虚函数和纯虚函数的区别？</h3><p>1）纯虚函数只有定义，没有实现，虚函数既有定义，又有实现</p><p>2）含有纯虚函数的类不能定义对象，含有虚函数的类可以定义对象</p><h3 id="菱形继承的内存结构？如何解决菱形继承存在的问题？"><a href="#菱形继承的内存结构？如何解决菱形继承存在的问题？" class="headerlink" title="菱形继承的内存结构？如何解决菱形继承存在的问题？"></a>菱形继承的内存结构？如何解决菱形继承存在的问题？</h3><p> View Code</p><p>1）菱形继承的内存结构：现在有A，B，C，D四个类，B，C分别继承A类，D通过多重继承继承了BC两个类，现在D类中有两个getx()，D类不知道调用哪一个getx()</p><p>2）菱形继承的解决办法：虚继承</p><p>BC类都用Virtual标注，保证只有一个getx()被创建</p><p> View Code</p><h3 id="虚析构函数的作用？父类的析构函数为什么一定要设置成虚函数？"><a href="#虚析构函数的作用？父类的析构函数为什么一定要设置成虚函数？" class="headerlink" title="虚析构函数的作用？父类的析构函数为什么一定要设置成虚函数？"></a>虚析构函数的作用？父类的析构函数为什么一定要设置成虚函数？</h3><p>父类虚析构函数就是为了避免内存泄漏，防止子类内存得不到释放造成内存泄漏</p><p>1.当父类的析构函数不声明成虚析构函数时，当子类继承父类，父类指针指向子类对象，delete掉父类指针，只会调动父类的析构函数，而不会调用子类的析构函数，从而造成子类对象内存泄漏</p><p>2.当父类的析构函数声明成虚析构函数时，当子类继承父类，父类指针指向子类对象，delete掉父类指针，先调动父类的析构函数，然后调用子类的析构函数，不存在子类对象内存泄漏的问题</p><p>只要存在继承关系，则父类的虚函数必须定义成虚函数！</p><h3 id="构造函数和析构函数中为什么不可以调用虚函数？"><a href="#构造函数和析构函数中为什么不可以调用虚函数？" class="headerlink" title="构造函数和析构函数中为什么不可以调用虚函数？"></a>构造函数和析构函数中为什么不可以调用虚函数？</h3><p>背景知识：</p><p>1.构造子类对象时，首先调用父类构造函数初始化对象的父类部分，在执行父类的构造函数时，对象的子类部分都是未初始化的，实际上此时对象还不是一个子类对象</p><p>2.析构子类对象时，先析构子类部分，然后按照构造顺序逆序析构父类部分</p><p>所以在运行子类的构造和析构函数时，对象都是不完整的，为了适应这种不完整，编译器视对象类型为当前构造或析构函数所在类的类型，由此造成的结构就是：在父类的构造或析构函数中，会将子类对象当作父类对象看待</p><p>在这样的背景下</p><p>如果我们在父类的构造或析构函数中调用虚函数，调用的往往是当前类的虚函数，达不到多态的效果，跟普通函数调用没有区别</p><h3 id="构造函数为什么不能为虚函数？什么情况下析构函数必须为虚函数？"><a href="#构造函数为什么不能为虚函数？什么情况下析构函数必须为虚函数？" class="headerlink" title="构造函数为什么不能为虚函数？什么情况下析构函数必须为虚函数？"></a>构造函数为什么不能为虚函数？什么情况下析构函数必须为虚函数？</h3><p>1）因为虚函数表指针必须在构造函数中初始化，所以构造函数不能为虚函数！</p><p>2）当存在继承关系时，父类的析构函数必须为虚函数，这样在父类指针指向子类对象，delete父类指针时，子类对象才不会内存泄漏</p><h2 id="字节对齐"><a href="#字节对齐" class="headerlink" title="字节对齐"></a>字节对齐</h2><p>让宽度为2的基本数据类型（short等）都位于能被2整除的地址上，让宽度为4的基本数据类型（int等）都位于能被4整除的地址上，以此类推。这样，两个数中间就可能需要加入填充字节，所以整个结构体的sizeof值就增长了。</p><h3 id="字节对齐的细节和编译器实现相关，但一般而言，满足三个准则："><a href="#字节对齐的细节和编译器实现相关，但一般而言，满足三个准则：" class="headerlink" title="字节对齐的细节和编译器实现相关，但一般而言，满足三个准则："></a>字节对齐的细节和编译器实现相关，但一般而言，满足三个准则：</h3><p>1) 结构体变量的首地址能够被其最宽基本类型成员的大小所整除；<br>2) 结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal adding）<br>3) 结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节（trailing padding）</p><h2 id="C-中内存泄漏的几种情况"><a href="#C-中内存泄漏的几种情况" class="headerlink" title="C++中内存泄漏的几种情况"></a>C++中内存泄漏的几种情况</h2><ul><li>在类的构造函数和析构函数中没有匹配的调用new和delete函数</li><li>没有正确地清除嵌套的对象指针 </li><li>在释放对象数组时在delete中没有使用方括号</li><li>缺少拷贝构造函数</li><li>缺少重载赋值运算符</li><li>关于nonmodifying运算符重载的常见迷思</li><li>没有将基类的析构函数定义为虚函数</li></ul><h2 id="new和malloc的区别"><a href="#new和malloc的区别" class="headerlink" title="new和malloc的区别"></a>new和malloc的区别</h2><h4 id="属性"><a href="#属性" class="headerlink" title="属性"></a>属性</h4><p>new/delete是C++关键字，需要编译器支持。malloc/free是库函数，需要头文件支持。</p><h4 id="参数"><a href="#参数" class="headerlink" title="参数"></a>参数</h4><p>使用new操作符申请内存分配时无须指定内存块的大小，编译器会根据类型信息自行计算。而malloc则需要显式地指出所需内存的尺寸。</p><h4 id="返回类型"><a href="#返回类型" class="headerlink" title="返回类型"></a>返回类型</h4><p>new操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，无须进行类型转换，故new是符合类型安全性的操作符。而malloc内存分配成功则是返回void <em> ，需要通过强制类型转换将void</em>指针转换成我们需要的类型。</p><h4 id="分配失败"><a href="#分配失败" class="headerlink" title="分配失败"></a>分配失败</h4><p>new内存分配失败时，会抛出bac_alloc异常。malloc分配内存失败时返回NULL。</p><h4 id="自定义类型"><a href="#自定义类型" class="headerlink" title="自定义类型"></a>自定义类型</h4><p>new会先调用operator new函数，申请足够的内存（通常底层使用malloc实现）。然后调用类型的构造函数，初始化成员变量，最后返回自定义类型指针。delete先调用析构函数，然后调用operator delete函数释放内存（通常底层使用free实现）。</p><p>malloc/free是库函数，只能动态的申请和释放内存，无法强制要求其做自定义类型对象构造和析构工作。</p><h4 id="重载"><a href="#重载" class="headerlink" title="重载"></a>重载</h4><p>C++允许重载new/delete操作符，特别的，布局new的就不需要为对象分配内存，而是指定了一个地址作为内存起始区域，new在这段内存上为对象调用构造函数完成初始化工作，并返回此地址。而malloc不允许重载。</p><h4 id="内存区域"><a href="#内存区域" class="headerlink" title="内存区域"></a>内存区域</h4><p>new操作符从自由存储区（free store）上为对象动态分配内存空间，而malloc函数从堆上动态分配内存。自由存储区是C++基于new操作符的一个抽象概念，凡是通过new操作符进行内存申请，该内存即为自由存储区。而堆是操作系统中的术语，是操作系统所维护的一块特殊内存，用于程序的内存动态分配，C语言使用malloc从堆上分配内存，使用free释放已分配的对应内存。自由存储区不等于堆，如上所述，布局new就可以不位于堆中</p><h3 id="左值和右值的区别，右值引用的概念及其应用场景"><a href="#左值和右值的区别，右值引用的概念及其应用场景" class="headerlink" title="左值和右值的区别，右值引用的概念及其应用场景"></a>左值和右值的区别，右值引用的概念及其应用场景</h3><h4 id="左值-lvalue-："><a href="#左值-lvalue-：" class="headerlink" title="左值(lvalue)："></a>左值(lvalue)：</h4><p>非临时性对象的表达式。有名字，可以取地址。如：非匿名对象(包括变量)，函数返回的引用，const对象等都是左值。</p><h4 id="右值-rvalue-："><a href="#右值-rvalue-：" class="headerlink" title="右值(rvalue)："></a>右值(rvalue)：</h4><p>临时性对象的表达式，没有名字，临时生成的，不可取地址。如：立即数，函数的返回值。</p><h4 id="左右值转换"><a href="#左右值转换" class="headerlink" title="左右值转换"></a>左右值转换</h4><p>右值转化为左值 ：直接新建变量然后赋值就可以了。<br>int b=a+1；将a+1这个右值转变为左值</p><p>左值转化为右值： std::move()<br>move (a) ; 将a这个左值转变为了右值</p><h3 id="左值引用"><a href="#左值引用" class="headerlink" title="左值引用"></a>左值引用</h3><p>左值引用本质是指针常量，左值引用只能引用左值。</p><p>加 const 就可以常引用</p><h3 id="右值引用"><a href="#右值引用" class="headerlink" title="右值引用"></a>右值引用</h3><p>右值引用绑定到右值，绑定后本来会被销毁的右值的生存期会延长至与绑定到它的右值引用的生存期。</p><p>在汇编层面右值引用做的事情和常引用是相同的，即产生临时量来存储常量。但是，唯一 一点的区别是，右值引用可以进行读写操作，而常引用只能进行读操作。</p><h4 id="右值引用的用途"><a href="#右值引用的用途" class="headerlink" title="右值引用的用途"></a>右值引用的用途</h4><ul><li>避免拷贝，提高性能，实现move()</li><li>避免重载参数的复杂性，实现forward()</li></ul><h2 id="free与delete的区别"><a href="#free与delete的区别" class="headerlink" title="free与delete的区别"></a>free与delete的区别</h2><ol><li><p>delete 用于释放 new 分配的空间，free 有用释放 malloc 分配的空间</p></li><li><p>delete [] 用于释放 new [] 分配的空间</p></li><li><p>delete 释放空间的时候会调用 相应对象的析构函数</p><p> 顺便说一下new在分配空间的时候同时会调用对象的构造函数，对对象进行初始化，使用malloc则只是分配内存</p></li><li><p>调用free 之前需要检查 需要释放的指针是否为空，使用delete 释放内存则不需要检查指针是否为NULL</p></li><li><p>free 和 delete 不能混用，也就是说new 分配的内存空间最好不要使用使用free 来释放，malloc 分配的空间也不要使用 delete来释放</p></li></ol><h2 id="堆和栈的区别是什么"><a href="#堆和栈的区别是什么" class="headerlink" title="堆和栈的区别是什么"></a>堆和栈的区别是什么</h2><p>1、堆栈空间分配区别</p><p>栈（操作系统）：由操作系统（编译器）自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。</p><p>堆（操作系统）： 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收，分配方式倒是类似于链表。</p><p>2、堆栈缓存方式区别</p><p>栈使用的是一级缓存， 它们通常都是被调用时处于存储空间中，调用完毕立即释放。</p><p>堆则是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定（并不是一旦成为孤儿对象就能被回收）。所以调用这些对象的速度要相对来得低一些。</p><p>3、堆栈数据结构区别</p><p>堆（数据结构）：堆可以被看成是一棵树，如：堆排序。</p><p>栈（数据结构）：一种先进后出的数据结构。</p><h3 id="静态函数"><a href="#静态函数" class="headerlink" title="静态函数"></a>静态函数</h3><p>只能在本$CPP$里面使用。</p><h3 id="类的静态成员"><a href="#类的静态成员" class="headerlink" title="类的静态成员"></a>类的静态成员</h3><p>多个对象数据共享，安全</p><h2 id="cast转换"><a href="#cast转换" class="headerlink" title="cast转换"></a>cast转换</h2><ul><li>const_cast 将const 转为非 const</li><li>static_cast，隐式转换，用于多态向上转化</li></ul><h2 id="dynamic-cast"><a href="#dynamic-cast" class="headerlink" title="dynamic_cast"></a>dynamic_cast</h2><p>动态类型转换。用于虚函数的类</p><h2 id="reinterpret-cast"><a href="#reinterpret-cast" class="headerlink" title="reinterpret_cast"></a>reinterpret_cast</h2><p>啥都可以转换</p><h2 id="指针与引用"><a href="#指针与引用" class="headerlink" title="指针与引用"></a>指针与引用</h2><ul><li>指针有自己的空间大小是4</li><li>可以有const 指针</li><li>多级指针</li><li>++运算符</li><li>返回动态内存分类的对象或者内存必须使用指针<h2 id="virtual关键字的作用"><a href="#virtual关键字的作用" class="headerlink" title="virtual关键字的作用"></a>virtual关键字的作用</h2></li><li><p>在派生类中重新定义基类的方法</p></li><li><p>为多态基类声明virtual析构函数</p></li><li>抽象基类</li></ul><h2 id="resize-reserve"><a href="#resize-reserve" class="headerlink" title="resize reserve"></a>resize reserve</h2><ul><li>resize:</li><li><p>改变最大容量，不会生成元素</p><h2 id="智能指针"><a href="#智能指针" class="headerlink" title="智能指针"></a>智能指针</h2></li><li><p>auto_ptr,share_ptr,weak_ptr，unique_ptr</p></li></ul><p>1) unique_ptr 实现独占式拥有或严格拥有概念，保证同一时间内只有一个智能执政可以指向该对象。他对于避免资源泄露（例如“以new创建对象后因为发生异常而忘记调用delect”）特别有用<br>2) shared_ptr 实现共享式拥有概念，多个智能指针可以指向相同对象，该对象和其相关资源会在最后一个引用被销毁的时候释放。可以查看资源所有个数<br>3) weak_ptr 种一个种不控制对象生命周期的智能指针</p><p>智能指针的作用是管理一个指针，因为存在以下这种情况：申请的空间在函数结束是忘记释放，造成内存泄漏。使用智能指针可以很大程度上避免这个问题。因为智能指针就是个类，超出了类的作用域，类会自动析构函数，析构函数就会自动释放资源。所有智能指针的就算自动释放内存。</p><h2 id="静态函数与虚函数的区别"><a href="#静态函数与虚函数的区别" class="headerlink" title="静态函数与虚函数的区别"></a>静态函数与虚函数的区别</h2><p>静态函数在编译的时候就已经确定运行时机，虚函数在运行的时候动态绑定，调用回增加一次内存开销。</p><h2 id="重载-重写"><a href="#重载-重写" class="headerlink" title="重载 重写"></a>重载 重写</h2><ul><li>两个函数名一样，参数不一样</li><li>子类继承父类，父类种是虚函数</li></ul><h2 id="虚函数和多态"><a href="#虚函数和多态" class="headerlink" title="虚函数和多态"></a>虚函数和多态</h2><p>多态的实现分成静态多态和动态多态</p><ul><li>静态主要是重载，编译的时候已经确定</li><li>动态是用虚函数机制实现，在运行期间动态绑定。</li></ul><p>例子：一个父类类型的指针指向一个子类对象的时候，使用父类指针去调用子类种重写了的父类中的虚函数，会调用子类重写过后的函数在父类种声明为加了virtual关键子的函数，子类种重写时候不需要加virtual也是虚函数</p><p>虚函数的实现：在有虚函数的类中，类的最开始部分是一个虚函数表的指针，这个指针指向一个虚函数标，表中放了虚函数的地址，实际的虚函数在代码段种。当子类继承了父类的时候也会继承其虚函数表，当子类重写父类中的虚函数的时候，会将继承倒虚函数的地址替换为小红鞋写的函数地址，使用虚函数会增加访问内存开销，降低效率。</p><h2 id="new-delete-malloc-free-的区别"><a href="#new-delete-malloc-free-的区别" class="headerlink" title="new/delete malloc/free 的区别"></a>new/delete malloc/free 的区别</h2><p>后者必须指明申请内存空间大小，后者对于类，不会调用构造函数 和析构函数</p><h2 id="虚函数表具体是怎么实现运行时多态的？"><a href="#虚函数表具体是怎么实现运行时多态的？" class="headerlink" title="虚函数表具体是怎么实现运行时多态的？"></a>虚函数表具体是怎么实现运行时多态的？</h2><p>子类若重写父类虚函数，虚函数表中，函数地址会被替换，对于存在虚函数二点类的对象，在VS种，对象的对象模型的头部存放指向虚函数表的指针，通过该机制实现多态。</p><h1 id="操作系统"><a href="#操作系统" class="headerlink" title="操作系统"></a>操作系统</h1><h2 id="用户态与内核态"><a href="#用户态与内核态" class="headerlink" title="用户态与内核态"></a>用户态与内核态</h2><p>用户态和内核态是操作系统的两种运行级别，两者最大的区别就是特权级不同。用户态拥有最低的特权级，内核态拥有较高的特权级。运行在用户态的程序不能直接访问操作系统内核数据结构和程序。内核态和用户态之间的转换方式主要包括：系统调用，异常和中断。</p><h2 id="上下文切换"><a href="#上下文切换" class="headerlink" title="上下文切换"></a>上下文切换</h2><p>当前任务在执行完 CPU 时间片切换到另一个任务之前会先保存自己的状态，以便下次 再切换回这个任务时，可以再加载这个任务的状态。任务从保存到再加载的过程就是一次上下文切换。</p><h2 id="进程与线程的概念"><a href="#进程与线程的概念" class="headerlink" title="进程与线程的概念"></a>进程与线程的概念</h2><h3 id="进程"><a href="#进程" class="headerlink" title="进程"></a>进程</h3><ul><li>进程是对运行时程序的封装，是系统进行资源调度和分配的基本单位，实现了操作系统的并发</li></ul><h3 id="线程"><a href="#线程" class="headerlink" title="线程"></a>线程</h3><ul><li>是进程的子任务，是CPU调度和分派的基本单位。用于保证程序的实时性，实现了进程内部的并发。</li><li>线程是操作系统可识别的最小执行和调度单位。每个线程都肚子占用一个虚拟处理器，独自的寄存器组，指令计数器和处理器状态。</li><li>每个线程完成不同的任务，但是共享同一地址空间的。（动态内存，映射文件，目标代码），打开的文件列表和其他内核资源</li></ul><h3 id="区别-1"><a href="#区别-1" class="headerlink" title="区别"></a>区别</h3><ul><li>一个线程只能属于一个进程，一个进程多个线程，依赖关系。</li><li>进程在执行过程中拥有独立的内存单元，而多个线程共享进程的内存。</li><li>资源分配给进程，同一个进程的所有线程共享该进程的所有资源。同一进程中的多个线程共享代码段，数据段，扩展段。<strong>但是每个线程拥有自己的栈段，（用来存局部变量和临时变量）</strong></li><li>进程是资源分配的最小单位，线程是CPU调度的最小单位</li><li>系统开销，在创建或撤销进程时，系统都要为之分配或回收资源，如内存空间。线程切换只需保存或者设置少量寄存器的内容，不涉及存储器管理方面的操作，可见进程的切换开销比较大</li><li>通信，线程同步和通信容易实现，需要进程同步和互斥手段的辅助，以保存数据的一致性。在有的系统中线程的<strong>切换，通信，同步</strong> 无须系统内核的干预。</li><li>进程编程 简单可靠，创建开销大。</li><li>进程不会互相影响。</li><li>进程适用与多核，多机分布；线程适用于多核。</li></ul><h3 id="进程调度算法"><a href="#进程调度算法" class="headerlink" title="进程调度算法"></a>进程调度算法</h3><ul><li>最短工作优先（SJF）；</li><li>最短剩余时间优先（SRTF）；</li><li>最高响应比优先（HRRF）；</li><li>优先级调度（Priority）；</li><li>轮转调度（RR）。<h3 id="进程间通信方式"><a href="#进程间通信方式" class="headerlink" title="进程间通信方式"></a>进程间通信方式</h3></li><li>管道，系统IPC，套接字</li></ul><h4 id="普通管道PIPE"><a href="#普通管道PIPE" class="headerlink" title="普通管道PIPE"></a>普通管道PIPE</h4><h4 id="命名管道FIFO"><a href="#命名管道FIFO" class="headerlink" title="命名管道FIFO"></a>命名管道FIFO</h4><h4 id="系统IPC"><a href="#系统IPC" class="headerlink" title="系统IPC"></a>系统IPC</h4><ul><li>消息队列</li><li>信号量，计数器，用来控制多个进程对共享资源的访问，实现进程兼得互斥和同步。</li><li>信号</li><li>共享内存</li></ul><h3 id="线程间通信方式"><a href="#线程间通信方式" class="headerlink" title="线程间通信方式"></a>线程间通信方式</h3><ul><li>临界区，通过多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问</li><li>互斥量 采用互斥对象机制，只有拥有互斥对象的线程才有访问公共资源的权限</li><li>信号量，允许多个线程同时访问一个资源</li><li>事件 通知操作的方式来保证多线程同步</li></ul><h2 id="Linux-虚拟地址空间"><a href="#Linux-虚拟地址空间" class="headerlink" title="Linux 虚拟地址空间"></a>Linux 虚拟地址空间</h2><p>请求分页系统，请求分段系统和请求段页系统都是针对虚拟内存。</p><h3 id="好处"><a href="#好处" class="headerlink" title="好处"></a>好处</h3><ul><li>扩大地址空间</li><li>内存保护</li><li>公平内存分配</li><li>当进程通信时，可采用虚拟内存共享的方式实现</li><li>当不同的进程使用相同代码时比如库文件中的代码，物理内存中可以存储一分这样的代码，节省内存</li><li>虚拟内存很适合在多道程序设计系统中使用，许多程的片段同时保存在内存中，当一个程序等待他的一部分读入内存，可以把CPU交给另一个进程使用。内存中可以保留多个进程，系统的并发度提高</li><li>在程序分配连续内存空间的时候，只需要在虚拟内存空间分配连续空间，而不需要实际的物理内存的连续攻击</li></ul><h2 id="代价"><a href="#代价" class="headerlink" title="代价"></a>代价</h2><ul><li>管理的数据结构占用内存</li><li>虚拟地址到物理地址的转化，增加了指令的执行时间。</li><li>页面的换入还出需要磁盘I/O</li><li>一页一部分数据，浪费内存</li></ul><h2 id="并发-并行"><a href="#并发-并行" class="headerlink" title="并发 并行"></a>并发 并行</h2><ul><li>并发，运行</li><li>并发，交织运行，不能提高性能只能提高效率</li><li>并行，严格物理意义上的同时运行，多核CPU，两个程序分别运行在两个核，互不影响</li></ul><h2 id="OS缺页置换算法"><a href="#OS缺页置换算法" class="headerlink" title="OS缺页置换算法"></a>OS缺页置换算法</h2><ul><li>FIFO，置换最先调入内存的页面，即置换在内存中驻留时间最久的页面。按进入内存的 先后次序排成队列，从队尾进入，从队首删除。</li><li>LRU：置换最近一段时间最长时间未访问的页面。</li></ul><h2 id="死锁"><a href="#死锁" class="headerlink" title="死锁"></a>死锁</h2><h3 id="必要条件"><a href="#必要条件" class="headerlink" title="必要条件"></a>必要条件</h3><ul><li>互斥条件</li><li>请求和保持条件</li><li>不可剥夺条件</li><li>环路等待条件</li></ul><h2 id="解决方法"><a href="#解决方法" class="headerlink" title="解决方法"></a>解决方法</h2><ul><li>资源一次性分配</li><li>可剥夺资源</li><li>资源有序分配法</li></ul><h2 id="epoll"><a href="#epoll" class="headerlink" title="epoll"></a>epoll</h2><p>IO多路复用</p><h2 id="TCP和UDP可以同时监听相同的端口吗"><a href="#TCP和UDP可以同时监听相同的端口吗" class="headerlink" title="TCP和UDP可以同时监听相同的端口吗"></a>TCP和UDP可以同时监听相同的端口吗</h2><p>可以</p><p>但一台设备里，<br>tcp协议里port号必须有唯一性。<br>同样，<br>udp协议里port号必须有唯一性。</p><h2 id="COOKIE和SESSION有什么区别？"><a href="#COOKIE和SESSION有什么区别？" class="headerlink" title="COOKIE和SESSION有什么区别？"></a>COOKIE和SESSION有什么区别？</h2><p>cookie保存在客户端，session保存在服务器端，<br>cookie目的可以跟踪会话，也可以保存用户喜好或者保存用户名密码<br>session用来跟踪会话</p>]]></content>
<summary type="html">
<p>要失业了</p>
</summary>
<category term="学习笔记" scheme="http://yoursite.com/tags/%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/"/>
</entry>
<entry>
<title>P1084 疫情控制</title>
<link href="http://yoursite.com/2020/12/20/P1084/"/>
<id>http://yoursite.com/2020/12/20/P1084/</id>
<published>2020-12-20T02:47:00.000Z</published>
<updated>2020-12-25T14:30:48.000Z</updated>
<content type="html"><![CDATA[<p>给定一些障碍，用这些障碍来切断根节点到所有叶子节点的路径，可以移动障碍，求总时间最少</p><a id="more"></a><p>二分枚举时间显而易见。</p><p>每个军队显然越靠近根结点越优，于是我们倍增的往上跳就可以完成这一步。</p><p>然后我们检查一遍那些根结点的子树没有被覆盖。</p><ul><li>那些没有覆盖的子树，只能靠多余的节点来帮忙覆盖。</li><li>将可以进行这些操作的军队提取出来（倍增的往上跳别用它。）</li><li>然后再把需要覆盖的根结点的子树的也提取出来。</li></ul><p>贪心去思考这个问题，首先为了保证自己覆盖，我一定选择剩余路程最短来覆盖自己或者自己覆盖。即如果搜到自己的时候发现还没覆盖自己当然优先自己子树。</p><details> <summary>代码</summary><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><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><span class="line">111</span><br><span class="line">112</span><br><span class="line">113</span><br><span class="line">114</span><br><span class="line">115</span><br><span class="line">116</span><br><span class="line">117</span><br><span class="line">118</span><br><span class="line">119</span><br><span class="line">120</span><br><span class="line">121</span><br><span class="line">122</span><br><span class="line">123</span><br><span class="line">124</span><br><span class="line">125</span><br><span class="line">126</span><br><span class="line">127</span><br><span class="line">128</span><br><span class="line">129</span><br><span class="line">130</span><br><span class="line">131</span><br><span class="line">132</span><br><span class="line">133</span><br><span class="line">134</span><br><span class="line">135</span><br><span class="line">136</span><br><span class="line">137</span><br><span class="line">138</span><br><span class="line">139</span><br><span class="line">140</span><br><span class="line">141</span><br><span class="line">142</span><br><span class="line">143</span><br><span class="line">144</span><br></pre></td><td class="code"><pre><span class="line"></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><bits/stdc++.h></span></span></span><br><span class="line"></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> ll long long</span></span><br><span class="line"></span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> N = <span class="number">5e4</span> + <span class="number">10</span>;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">read</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> x = <span class="number">0</span>, f = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">char</span> c = getchar();</span><br><span class="line"> <span class="keyword">while</span> (c < <span class="string">'0'</span> || c > <span class="string">'9'</span>)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (c == <span class="string">'-'</span>)</span><br><span class="line"> f = <span class="number">-1</span>;</span><br><span class="line"> c = getchar();</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">while</span> (c >= <span class="string">'0'</span> && c <= <span class="string">'9'</span>)</span><br><span class="line"> x = (x << <span class="number">1</span>) + (x << <span class="number">3</span>) + c - <span class="string">'0'</span>, c = getchar();</span><br><span class="line"> <span class="keyword">return</span> x * f;</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="built_in">vector</span><pair<<span class="keyword">int</span>, <span class="keyword">int</span>>> g[N];</span><br><span class="line"></span><br><span class="line"><span class="keyword">int</span> f[N][<span class="number">20</span>];</span><br><span class="line">ll d[N][<span class="number">20</span>];</span><br><span class="line"><span class="keyword">int</span> be[N];</span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> n = <span class="built_in">read</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><br><span class="line"> <span class="keyword">int</span> u = <span class="built_in">read</span>(), v = <span class="built_in">read</span>(), w = <span class="built_in">read</span>();</span><br><span class="line"> g[u].push_back({v, w});</span><br><span class="line"> g[v].push_back({u, w});</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">int</span> m = <span class="built_in">read</span>();</span><br><span class="line"></span><br><span class="line"> <span class="function"><span class="built_in">vector</span><<span class="keyword">int</span>> <span class="title">z</span><span class="params">(m)</span></span>;</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"> z[i] = <span class="built_in">read</span>();</span><br><span class="line"> function<<span class="keyword">void</span>(<span class="keyword">int</span>, <span class="keyword">int</span>)> dfs1 = [&](<span class="keyword">int</span> x, <span class="keyword">int</span> fa) {</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">16</span>; i++)</span><br><span class="line"> {</span><br><span class="line"> f[x][i] = f[f[x][i - <span class="number">1</span>]][i - <span class="number">1</span>];</span><br><span class="line"> d[x][i] = d[x][i - <span class="number">1</span>] + d[f[x][i - <span class="number">1</span>]][i - <span class="number">1</span>];</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">auto</span> [to, w] : g[x])</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (to == fa)</span><br><span class="line"> <span class="keyword">continue</span>;</span><br><span class="line"> f[to][<span class="number">0</span>] = x;</span><br><span class="line"> d[to][<span class="number">0</span>] = w;</span><br><span class="line"> be[to] = x == <span class="number">1</span> ? to : be[x];</span><br><span class="line"> dfs1(to, x);</span><br><span class="line"> }</span><br><span class="line"> };</span><br><span class="line"></span><br><span class="line"> <span class="keyword">auto</span> check = [&](ll k) {</span><br><span class="line"> <span class="built_in">vector</span><pair<ll, <span class="keyword">int</span>>> tmp;</span><br><span class="line"> <span class="built_in">vector</span><pair<ll, <span class="keyword">int</span>>> need;</span><br><span class="line"> <span class="function"><span class="built_in">vector</span><<span class="keyword">int</span>> <span class="title">tag</span><span class="params">(n + <span class="number">1</span>)</span></span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i : z)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> u = i;</span><br><span class="line"> ll res = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> j = <span class="number">16</span>; j >= <span class="number">0</span>; j--)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (res + d[u][j] <= k && f[u][j])</span><br><span class="line"> res += d[u][j], u = f[u][j];</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span> (u == <span class="number">1</span>)</span><br><span class="line"> tmp.push_back({k - res, be[i]});</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> tag[u] = <span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"> function<<span class="keyword">void</span>(<span class="keyword">int</span>, <span class="keyword">int</span>)> dfs2 = [&](<span class="keyword">int</span> x, <span class="keyword">int</span> fa) {</span><br><span class="line"> <span class="keyword">int</span> o = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">int</span> cnt = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">auto</span> [to, w] : g[x])</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (to == fa)</span><br><span class="line"> <span class="keyword">continue</span>;</span><br><span class="line"> dfs2(to, x);</span><br><span class="line"> cnt++;</span><br><span class="line"> o &= tag[to];</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span> (tag[x] == <span class="number">0</span>)</span><br><span class="line"> {</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (!cnt)</span><br><span class="line"> tag[x] = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">if</span> (o == <span class="number">1</span>)</span><br><span class="line"> tag[x] = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> tag[x] = <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> };</span><br><span class="line"> dfs2(<span class="number">1</span>, <span class="number">0</span>);</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">auto</span> [to, w] : g[<span class="number">1</span>])</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (!tag[to])</span><br><span class="line"> need.push_back({w, to});</span><br><span class="line"> }</span><br><span class="line"> sort(tmp.<span class="built_in">begin</span>(), tmp.<span class="built_in">end</span>());</span><br><span class="line"> sort(need.<span class="built_in">begin</span>(), need.<span class="built_in">end</span>());</span><br><span class="line"> <span class="keyword">if</span> (need.<span class="built_in">size</span>() == <span class="number">0</span>)</span><br><span class="line"> <span class="keyword">return</span> <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">int</span> j = <span class="number">0</span>;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">auto</span> [dis, i] : tmp)</span><br><span class="line"> {</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (j >= need.<span class="built_in">size</span>())</span><br><span class="line"> <span class="keyword">return</span> <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">if</span> (!tag[i])</span><br><span class="line"> tag[i] = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">if</span> (dis >= need[j].first)</span><br><span class="line"> tag[need[j].second] = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">while</span> (j < need.<span class="built_in">size</span>() && tag[need[j].second])</span><br><span class="line"> j++;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span> (j >= need.<span class="built_in">size</span>())</span><br><span class="line"> <span class="keyword">return</span> <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"> };</span><br><span class="line"> dfs1(<span class="number">1</span>, <span class="number">0</span>);</span><br><span class="line"> <span class="comment">// cout << check(9) << endl;</span></span><br><span class="line"> ll l = <span class="number">0</span>, r = <span class="number">1e15</span>, ans = <span class="number">-1</span>;</span><br><span class="line"> <span class="keyword">while</span> (l <= r)</span><br><span class="line"> {</span><br><span class="line"> ll mid = (l + r) >> <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">if</span> (check(mid))</span><br><span class="line"> {</span><br><span class="line"> r = mid - <span class="number">1</span>;</span><br><span class="line"> ans = mid;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> l = mid + <span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="built_in">cout</span> << ans << <span class="built_in">endl</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure> </details>]]></content>
<summary type="html">
<p>给定一些障碍，用这些障碍来切断根节点到所有叶子节点的路径，可以移动障碍，求总时间最少</p>
</summary>
<category term="思维" scheme="http://yoursite.com/tags/%E6%80%9D%E7%BB%B4/"/>
</entry>
<entry>
<title>P3703 [SDOI2017]树点涂色</title>
<link href="http://yoursite.com/2020/12/20/P3703/"/>
<id>http://yoursite.com/2020/12/20/P3703/</id>
<published>2020-12-20T02:47:00.000Z</published>
<updated>2020-12-25T14:30:48.000Z</updated>
<content type="html"><![CDATA[<ul><li><p>1 x 表示把点 $x$ 到根节点的路径上所有的点染上一种没有用过的新颜色。</p></li><li><p>2 x y 求 $x$ 到 $y$ 的路径的权值。</p></li><li><p>3 x 在以 $x$ 为根的子树中选择一个点，使得这个点到根节点的路径权值最大，求最大权值。</p></li></ul><a id="more"></a><p>考虑$access$的时候，相当把$x$到根节点的东西染上一种颜色。</p><p>考虑树上差分$sum_{ij}=dis_i+dis_j-2\times dis_{lca_{ij}}$</p><p>现在考虑维护$dis_i$。</p><p>当$access(x)$的时候，如果断虚链，表示断开的子树的$dis+1$（由于此时断开的子树的$dis_x$多了颜色）,如果连上实链，表示断开的子树的$dis-1$。</p><details> <summary>代码</summary><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><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><span class="line">111</span><br><span class="line">112</span><br><span class="line">113</span><br><span class="line">114</span><br><span class="line">115</span><br><span class="line">116</span><br><span class="line">117</span><br><span class="line">118</span><br><span class="line">119</span><br><span class="line">120</span><br><span class="line">121</span><br><span class="line">122</span><br><span class="line">123</span><br><span class="line">124</span><br><span class="line">125</span><br><span class="line">126</span><br><span class="line">127</span><br><span class="line">128</span><br><span class="line">129</span><br><span class="line">130</span><br><span class="line">131</span><br><span class="line">132</span><br><span class="line">133</span><br><span class="line">134</span><br><span class="line">135</span><br><span class="line">136</span><br><span class="line">137</span><br><span class="line">138</span><br><span class="line">139</span><br><span class="line">140</span><br><span class="line">141</span><br><span class="line">142</span><br><span class="line">143</span><br><span class="line">144</span><br><span class="line">145</span><br><span class="line">146</span><br><span class="line">147</span><br><span class="line">148</span><br><span class="line">149</span><br><span class="line">150</span><br><span class="line">151</span><br><span class="line">152</span><br><span class="line">153</span><br><span class="line">154</span><br><span class="line">155</span><br><span class="line">156</span><br><span class="line">157</span><br><span class="line">158</span><br><span class="line">159</span><br><span class="line">160</span><br><span class="line">161</span><br><span class="line">162</span><br><span class="line">163</span><br><span class="line">164</span><br><span class="line">165</span><br><span class="line">166</span><br><span class="line">167</span><br><span class="line">168</span><br><span class="line">169</span><br><span class="line">170</span><br><span class="line">171</span><br><span class="line">172</span><br><span class="line">173</span><br><span class="line">174</span><br><span class="line">175</span><br><span class="line">176</span><br><span class="line">177</span><br><span class="line">178</span><br><span class="line">179</span><br><span class="line">180</span><br><span class="line">181</span><br><span class="line">182</span><br><span class="line">183</span><br><span class="line">184</span><br><span class="line">185</span><br><span class="line">186</span><br><span class="line">187</span><br><span class="line">188</span><br><span class="line">189</span><br><span class="line">190</span><br><span class="line">191</span><br><span class="line">192</span><br><span class="line">193</span><br><span class="line">194</span><br><span class="line">195</span><br><span class="line">196</span><br><span class="line">197</span><br><span class="line">198</span><br><span class="line">199</span><br><span class="line">200</span><br><span class="line">201</span><br><span class="line">202</span><br><span class="line">203</span><br><span class="line">204</span><br><span class="line">205</span><br><span class="line">206</span><br><span class="line">207</span><br><span class="line">208</span><br><span class="line">209</span><br><span class="line">210</span><br><span class="line">211</span><br><span class="line">212</span><br><span class="line">213</span><br><span class="line">214</span><br><span class="line">215</span><br><span class="line">216</span><br><span class="line">217</span><br><span class="line">218</span><br><span class="line">219</span><br><span class="line">220</span><br><span class="line">221</span><br><span class="line">222</span><br><span class="line">223</span><br><span class="line">224</span><br><span class="line">225</span><br><span class="line">226</span><br><span class="line">227</span><br><span class="line">228</span><br><span class="line">229</span><br><span class="line">230</span><br><span class="line">231</span><br><span class="line">232</span><br><span class="line">233</span><br><span class="line">234</span><br><span class="line">235</span><br><span class="line">236</span><br><span class="line">237</span><br><span class="line">238</span><br><span class="line">239</span><br><span class="line">240</span><br><span class="line">241</span><br><span class="line">242</span><br><span class="line">243</span><br><span class="line">244</span><br><span class="line">245</span><br><span class="line">246</span><br><span class="line">247</span><br><span class="line">248</span><br><span class="line">249</span><br><span class="line">250</span><br><span class="line">251</span><br><span class="line">252</span><br><span class="line">253</span><br><span class="line">254</span><br><span class="line">255</span><br><span class="line">256</span><br><span class="line">257</span><br><span class="line">258</span><br><span class="line">259</span><br><span class="line">260</span><br></pre></td><td class="code"><pre><span class="line"></span><br><span class="line"></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><bits/stdc++.h></span></span></span><br><span class="line"></span><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> N = <span class="number">1e5</span> + <span class="number">10</span>;</span><br><span class="line"></span><br><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">Segment</span></span></span><br><span class="line"><span class="class">{</span></span><br><span class="line"> <span class="keyword">int</span> mx[N << <span class="number">2</span>], tag[N << <span class="number">2</span>];</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">pushup</span><span class="params">(<span class="keyword">int</span> pos)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> mx[pos] = <span class="built_in">max</span>(mx[pos << <span class="number">1</span>], mx[pos << <span class="number">1</span> | <span class="number">1</span>]);</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">addtag</span><span class="params">(<span class="keyword">int</span> pos, <span class="keyword">int</span> w)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> mx[pos] += w;</span><br><span class="line"> tag[pos] += w;</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">pushdown</span><span class="params">(<span class="keyword">int</span> pos)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">if</span> (tag[pos])</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> &w = tag[pos];</span><br><span class="line"> addtag(pos << <span class="number">1</span>, w);</span><br><span class="line"> addtag(pos << <span class="number">1</span> | <span class="number">1</span>, w);</span><br><span class="line"> w = <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">update</span><span class="params">(<span class="keyword">int</span> ql, <span class="keyword">int</span> qr, <span class="keyword">int</span> w, <span class="keyword">int</span> pos, <span class="keyword">int</span> l, <span class="keyword">int</span> r)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">if</span> (ql <= l && r <= qr)</span><br><span class="line"> {</span><br><span class="line"> addtag(pos, w);</span><br><span class="line"> <span class="keyword">return</span>;</span><br><span class="line"> }</span><br><span class="line"> pushdown(pos);</span><br><span class="line"> <span class="keyword">int</span> mid = (l + r) >> <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">if</span> (ql <= mid)</span><br><span class="line"> update(ql, qr, w, pos << <span class="number">1</span>, l, mid);</span><br><span class="line"> <span class="keyword">if</span> (qr > mid)</span><br><span class="line"> update(ql, qr, w, pos << <span class="number">1</span> | <span class="number">1</span>, mid + <span class="number">1</span>, r);</span><br><span class="line"> pushup(pos);</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> ql, <span class="keyword">int</span> qr, <span class="keyword">int</span> pos, <span class="keyword">int</span> l, <span class="keyword">int</span> r)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">if</span> (ql <= l && r <= qr)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">return</span> mx[pos];</span><br><span class="line"> }</span><br><span class="line"> pushdown(pos);</span><br><span class="line"> <span class="keyword">int</span> mid = (l + r) >> <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">if</span> (qr <= mid)</span><br><span class="line"> <span class="keyword">return</span> query(ql, qr, pos << <span class="number">1</span>, l, mid);</span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">if</span> (ql > mid)</span><br><span class="line"> <span class="keyword">return</span> query(ql, qr, pos << <span class="number">1</span> | <span class="number">1</span>, mid + <span class="number">1</span>, r);</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">max</span>(query(ql, qr, pos << <span class="number">1</span>, l, mid), query(ql, qr, pos << <span class="number">1</span> | <span class="number">1</span>, mid + <span class="number">1</span>, r));</span><br><span class="line"> }</span><br><span class="line">} smt;</span><br><span class="line"></span><br><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">LCT</span></span></span><br><span class="line"><span class="class">{</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> ls son[pos][0]</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> rs son[pos][1]</span></span><br><span class="line"></span><br><span class="line"> <span class="keyword">int</span> fa[N], cnt[N], root, tcnt;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">int</span> son[N][<span class="number">2</span>];</span><br><span class="line"> <span class="keyword">int</span> rev[N];</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">pushup</span><span class="params">(<span class="keyword">int</span> pos)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> ;</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">bool</span> <span class="title">isroot</span><span class="params">(<span class="keyword">int</span> pos)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">return</span> pos != son[fa[pos]][<span class="number">0</span>] && pos != son[fa[pos]][<span class="number">1</span>];</span><br><span class="line"> }</span><br><span class="line"> <span class="comment">// void addtag(int pos)</span></span><br><span class="line"> <span class="comment">// {</span></span><br><span class="line"> <span class="comment">// rev[pos] ^= 1;</span></span><br><span class="line"> <span class="comment">// swap(son[pos][0], son[pos][1]);</span></span><br><span class="line"> <span class="comment">// }</span></span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">pushdown</span><span class="params">(<span class="keyword">int</span> pos)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> ;</span><br><span class="line"> <span class="comment">// if (rev[pos])</span></span><br><span class="line"> <span class="comment">// {</span></span><br><span class="line"> <span class="comment">// if (son[pos][1])</span></span><br><span class="line"> <span class="comment">// addtag(son[pos][1]);</span></span><br><span class="line"> <span class="comment">// if (son[pos][0])</span></span><br><span class="line"> <span class="comment">// addtag(son[pos][0]);</span></span><br><span class="line"> <span class="comment">// rev[pos] = 0;</span></span><br><span class="line"> <span class="comment">// }</span></span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="function"><span class="keyword">bool</span> <span class="title">isson</span><span class="params">(<span class="keyword">int</span> pos)</span> </span>{ <span class="keyword">return</span> pos == son[fa[pos]][<span class="number">1</span>]; }</span><br><span class="line"></span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">conect</span><span class="params">(<span class="keyword">int</span> x, <span class="keyword">int</span> d, <span class="keyword">int</span> y)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> son[x][d] = y;</span><br><span class="line"> fa[y] = 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">rotate</span><span class="params">(<span class="keyword">int</span> x)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">int</span> y = fa[x], z = fa[y], dx = isson(x), dy = isson(y);</span><br><span class="line"></span><br><span class="line"> fa[x] = z;</span><br><span class="line"> <span class="keyword">if</span> (!isroot(y))</span><br><span class="line"> son[z][dy] = x;</span><br><span class="line"> <span class="comment">//conect(z, dy, x);</span></span><br><span class="line"> conect(y, dx, son[x][dx ^ <span class="number">1</span>]);</span><br><span class="line"> conect(x, dx ^ <span class="number">1</span>, y);</span><br><span class="line"> pushup(y), pushup(x);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">int</span> st[N];</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">splay</span><span class="params">(<span class="keyword">int</span> x)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">int</span> top;</span><br><span class="line"> st[top = <span class="number">1</span>] = x;</span><br><span class="line"> <span class="keyword">int</span> u = x;</span><br><span class="line"> <span class="keyword">while</span> (!isroot(u))</span><br><span class="line"> u = fa[u], st[++top] = u;</span><br><span class="line"> <span class="keyword">while</span> (top)</span><br><span class="line"> pushdown(st[top--]);</span><br><span class="line"> <span class="keyword">while</span> (!isroot(x))</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> y = fa[x];</span><br><span class="line"> <span class="keyword">if</span> (isroot(y))</span><br><span class="line"> {</span><br><span class="line"> rotate(x);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">if</span> (isson(x) == isson(y))</span><br><span class="line"> rotate(y), rotate(x);</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> rotate(x), rotate(x);</span><br><span class="line"> }</span><br><span class="line"> pushup(x);</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">int</span> <span class="title">findrt</span><span class="params">(<span class="keyword">int</span> x)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">while</span> (son[x][<span class="number">0</span>])</span><br><span class="line"> x = son[x][<span class="number">0</span>];</span><br><span class="line"> <span class="keyword">return</span> x;</span><br><span class="line"> }</span><br><span class="line">} t;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">read</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> x = <span class="number">0</span>, f = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">char</span> c = getchar();</span><br><span class="line"> <span class="keyword">while</span> (c < <span class="string">'0'</span> || c > <span class="string">'9'</span>)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (c == <span class="string">'-'</span>)</span><br><span class="line"> f = <span class="number">-1</span>;</span><br><span class="line"> c = getchar();</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">while</span> (c >= <span class="string">'0'</span> && c <= <span class="string">'9'</span>)</span><br><span class="line"> x = (x << <span class="number">1</span>) + (x << <span class="number">3</span>) + c - <span class="string">'0'</span>, c = getchar();</span><br><span class="line"> <span class="keyword">return</span> x * f;</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="built_in">vector</span><<span class="keyword">int</span>> g[N];</span><br><span class="line"><span class="keyword">int</span> tot, siz[N], dfn[N];</span><br><span class="line"><span class="keyword">int</span> f[N][<span class="number">20</span>];</span><br><span class="line"><span class="keyword">int</span> dep[N];</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">lca</span><span class="params">(<span class="keyword">int</span> u, <span class="keyword">int</span> v)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">if</span> (dep[u] < dep[v])</span><br><span class="line"> swap(u, v);</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">19</span>; i >= <span class="number">0</span>; i--)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (dep[f[u][i]] >= dep[v])</span><br><span class="line"> u = f[u][i];</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span> (u == v)</span><br><span class="line"> <span class="keyword">return</span> v;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">19</span>; i >= <span class="number">0</span>; i--)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (f[u][i] != f[v][i])</span><br><span class="line"> u = f[u][i], v = f[v][i];</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> f[u][<span class="number">0</span>];</span><br><span class="line">}</span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">dfs</span><span class="params">(<span class="keyword">int</span> x, <span class="keyword">int</span> fa)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> t.fa[x] = fa;</span><br><span class="line"> f[x][<span class="number">0</span>] = fa;</span><br><span class="line"> dep[x] = dep[fa] + <span class="number">1</span>;</span><br><span class="line"> dfn[x] = ++tot;</span><br><span class="line"> siz[x] = <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">20</span>; i++)</span><br><span class="line"> f[x][i] = f[f[x][i - <span class="number">1</span>]][i - <span class="number">1</span>];</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> to : g[x])</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (to == fa)</span><br><span class="line"> <span class="keyword">continue</span>;</span><br><span class="line"> dfs(to, x);</span><br><span class="line"> siz[x] += siz[to];</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">access</span><span class="params">(<span class="keyword">int</span> x)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; x; i = x, x = t.fa[x])</span><br><span class="line"> {</span><br><span class="line"> t.splay(x);</span><br><span class="line"> <span class="keyword">int</span> o = t.son[x][<span class="number">1</span>];</span><br><span class="line"> <span class="keyword">if</span> (o)</span><br><span class="line"> {</span><br><span class="line"> smt.update(dfn[t.findrt(o)], dfn[t.findrt(o)] + siz[t.findrt(o)] - <span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>, tot);</span><br><span class="line"> }</span><br><span class="line"> t.son[x][<span class="number">1</span>] = i;</span><br><span class="line"> o = i;</span><br><span class="line"> <span class="keyword">if</span> (o)</span><br><span class="line"> {</span><br><span class="line"> <span class="comment">//cout << o << " " << t.findrt(o) << endl;</span></span><br><span class="line"> smt.update(dfn[t.findrt(o)], dfn[t.findrt(o)] + siz[t.findrt(o)] - <span class="number">1</span>, <span class="number">-1</span>, <span class="number">1</span>, <span class="number">1</span>, tot);</span><br><span class="line"> }</span><br><span class="line"> t.pushup(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">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> n = <span class="built_in">read</span>(), m = <span class="built_in">read</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><br><span class="line"> <span class="keyword">int</span> u = <span class="built_in">read</span>(), v = <span class="built_in">read</span>();</span><br><span class="line"> g[u].push_back(v);</span><br><span class="line"> g[v].push_back(u);</span><br><span class="line"> }</span><br><span class="line"> dfs(<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">1</span>; i <= n; i++)</span><br><span class="line"> smt.update(dfn[i], dfn[i] + siz[i] - <span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>, tot);</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><br><span class="line"> <span class="keyword">int</span> op = <span class="built_in">read</span>();</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (op == <span class="number">1</span>)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> x = <span class="built_in">read</span>();</span><br><span class="line"> access(x);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">if</span> (op == <span class="number">2</span>)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> x = <span class="built_in">read</span>(), y = <span class="built_in">read</span>();</span><br><span class="line"> <span class="keyword">int</span> o = lca(x, y);</span><br><span class="line"></span><br><span class="line"> <span class="keyword">int</span> res = smt.query(dfn[x], dfn[x], <span class="number">1</span>, <span class="number">1</span>, tot) + smt.query(dfn[y], dfn[y], <span class="number">1</span>, <span class="number">1</span>, tot) - <span class="number">2</span> * smt.query(dfn[o], dfn[o], <span class="number">1</span>, <span class="number">1</span>, tot) + <span class="number">1</span>;</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%d\n"</span>, res);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> x = <span class="built_in">read</span>();</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%d\n"</span>, smt.query(dfn[x], dfn[x] + siz[x] - <span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>, tot));</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure> </details>]]></content>
<summary type="html">
<ul>
<li><p>1 x 表示把点 $x$ 到根节点的路径上所有的点染上一种没有用过的新颜色。</p>
</li>
<li><p>2 x y 求 $x$ 到 $y$ 的路径的权值。</p>
</li>
<li><p>3 x 在以 $x$ 为根的子树中选择一个点，使得这个点到根节点的路径权值最大，求最大权值。</p>
</li>
</ul>
</summary>
<category term="LCT" scheme="http://yoursite.com/tags/LCT/"/>
</entry>
<entry>
<title>P7114 字符串匹配</title>
<link href="http://yoursite.com/2020/12/20/P7114/"/>
<id>http://yoursite.com/2020/12/20/P7114/</id>
<published>2020-12-20T02:47:00.000Z</published>
<updated>2020-12-25T14:31:10.000Z</updated>
<content type="html"><![CDATA[<p>求 $S = {(AB)}^iC$的方案数，其中 $F(A) \le F(C)$ 表示字符串 $S$ 中出现奇数次的字符的数量</p><a id="more"></a><p>枚举$(AB)^i$，对于$C$寻找符合条件的$AB$.</p><p>复杂度为$O(n(26+\log n))$</p><details> <summary>代码</summary><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><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></pre></td><td class="code"><pre><span class="line"></span><br><span class="line"></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><bits/stdc++.h></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line"></span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> N = <span class="number">2e6</span> + <span class="number">10</span>;</span><br><span class="line"></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> ll long long</span></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">getnext</span><span class="params">(<span class="keyword">char</span> *t, <span class="keyword">int</span> *nxt)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> nxt[<span class="number">0</span>] = <span class="number">-1</span>;</span><br><span class="line"> <span class="keyword">int</span> m = <span class="built_in">strlen</span>(t + <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>, j; i <= m; i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">for</span> (j = nxt[i - <span class="number">1</span>]; j >= <span class="number">0</span> && t[j + <span class="number">1</span>] != t[i]; j = nxt[j])</span><br><span class="line"> ;</span><br><span class="line"> nxt[i] = j + <span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="keyword">char</span> t[N], s[N];</span><br><span class="line"><span class="keyword">int</span> nxt[N];</span><br><span class="line"><span class="keyword">int</span> pre[N], suf[N], cnt[<span class="number">27</span>], len[N];</span><br><span class="line"><span class="keyword">int</span> to[<span class="number">27</span>];</span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> T;</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%d"</span>, &T);</span><br><span class="line"> <span class="keyword">while</span> (T--)</span><br><span class="line"> {</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%s"</span>, s + <span class="number">1</span>);</span><br><span class="line"> <span class="keyword">int</span> n = <span class="built_in">strlen</span>(s + <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">1</span>; i <= n; i++)</span><br><span class="line"> nxt[i] = <span class="number">0</span>, len[i] = <span class="number">1</span>;</span><br><span class="line"> getnext(s, nxt);</span><br><span class="line"> <span class="built_in">memset</span>(cnt, <span class="number">0</span>, <span class="keyword">sizeof</span>(cnt));</span><br><span class="line"> <span class="built_in">memset</span>(to, <span class="number">0</span>, <span class="keyword">sizeof</span>(to));</span><br><span class="line"> <span class="keyword">int</span> res = <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><br><span class="line"> <span class="keyword">int</span> o = s[i] - <span class="string">'a'</span>;</span><br><span class="line"> res -= cnt[o] & <span class="number">1</span>;</span><br><span class="line"> cnt[o]++;</span><br><span class="line"> res += cnt[o] & <span class="number">1</span>;</span><br><span class="line"> pre[i] = res;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="built_in">memset</span>(cnt, <span class="number">0</span>, <span class="keyword">sizeof</span>(cnt));</span><br><span class="line"> res = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = n; i >= <span class="number">1</span>; i--)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> o = s[i] - <span class="string">'a'</span>;</span><br><span class="line"> res -= cnt[o] & <span class="number">1</span>;</span><br><span class="line"> cnt[o]++;</span><br><span class="line"> res += cnt[o] & <span class="number">1</span>;</span><br><span class="line"> suf[i] = res;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> ll 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">2</span>; i < n; 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> j = pre[i - <span class="number">1</span>]; j <= <span class="number">26</span>; j++)</span><br><span class="line"> to[j]++;</span><br><span class="line"> ans += to[suf[i + <span class="number">1</span>]];</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> j = <span class="number">2</span> * i; j < n; j += i)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (((i % (j - nxt[j])) == <span class="number">0</span>) && ((j / (j - nxt[j])) > <span class="number">1</span>))</span><br><span class="line"> ans += to[suf[j + <span class="number">1</span>]];</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> <span class="keyword">break</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%lld\n"</span>, ans);</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure> </details>]]></content>
<summary type="html">
<p>求 $S = {(AB)}^iC$的方案数，其中 $F(A) \le F(C)$ 表示字符串 $S$ 中出现奇数次的字符的数量</p>
</summary>
</entry>
<entry>
<title>P2387 [NOI2014]魔法森林</title>
<link href="http://yoursite.com/2020/12/17/P2387/"/>
<id>http://yoursite.com/2020/12/17/P2387/</id>
<published>2020-12-17T02:47:00.000Z</published>
<updated>2020-12-25T14:30:48.000Z</updated>
<content type="html"><![CDATA[<p>给出一个$n$个点，$m$条边的无向图，每条边都有权值$a_i,b_i$ ，求一条从点$1$到点$n$的路径，使得这条路径上边的$a_i,b_i$ 最大值之和最小<br><a id="more"></a></p><p>限制$a$的最大值，然后动态维护$b$的最小生成树即可。</p><details> <summary>代码</summary><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><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><span class="line">111</span><br><span class="line">112</span><br><span class="line">113</span><br><span class="line">114</span><br><span class="line">115</span><br><span class="line">116</span><br><span class="line">117</span><br><span class="line">118</span><br><span class="line">119</span><br><span class="line">120</span><br><span class="line">121</span><br><span class="line">122</span><br><span class="line">123</span><br><span class="line">124</span><br><span class="line">125</span><br><span class="line">126</span><br><span class="line">127</span><br><span class="line">128</span><br><span class="line">129</span><br><span class="line">130</span><br><span class="line">131</span><br><span class="line">132</span><br><span class="line">133</span><br><span class="line">134</span><br><span class="line">135</span><br><span class="line">136</span><br><span class="line">137</span><br><span class="line">138</span><br><span class="line">139</span><br><span class="line">140</span><br><span class="line">141</span><br><span class="line">142</span><br><span class="line">143</span><br><span class="line">144</span><br><span class="line">145</span><br><span class="line">146</span><br><span class="line">147</span><br><span class="line">148</span><br><span class="line">149</span><br><span class="line">150</span><br><span class="line">151</span><br><span class="line">152</span><br><span class="line">153</span><br><span class="line">154</span><br><span class="line">155</span><br><span class="line">156</span><br><span class="line">157</span><br><span class="line">158</span><br><span class="line">159</span><br><span class="line">160</span><br><span class="line">161</span><br><span class="line">162</span><br><span class="line">163</span><br><span class="line">164</span><br><span class="line">165</span><br><span class="line">166</span><br><span class="line">167</span><br><span class="line">168</span><br><span class="line">169</span><br><span class="line">170</span><br><span class="line">171</span><br><span class="line">172</span><br><span class="line">173</span><br><span class="line">174</span><br><span class="line">175</span><br><span class="line">176</span><br><span class="line">177</span><br><span class="line">178</span><br><span class="line">179</span><br><span class="line">180</span><br><span class="line">181</span><br><span class="line">182</span><br><span class="line">183</span><br><span class="line">184</span><br><span class="line">185</span><br><span class="line">186</span><br><span class="line">187</span><br><span class="line">188</span><br><span class="line">189</span><br><span class="line">190</span><br><span class="line">191</span><br><span class="line">192</span><br><span class="line">193</span><br><span class="line">194</span><br><span class="line">195</span><br><span class="line">196</span><br><span class="line">197</span><br><span class="line">198</span><br><span class="line">199</span><br><span class="line">200</span><br><span class="line">201</span><br><span class="line">202</span><br><span class="line">203</span><br><span class="line">204</span><br><span class="line">205</span><br><span class="line">206</span><br><span class="line">207</span><br><span class="line">208</span><br><span class="line">209</span><br><span class="line">210</span><br><span class="line">211</span><br><span class="line">212</span><br><span class="line">213</span><br></pre></td><td class="code"><pre><span class="line"></span><br><span class="line"></span><br><span class="line"></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><bits/stdc++.h></span></span></span><br><span class="line"></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> ll long long</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> pii pair<span class="meta-string"><int, int></span></span></span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> N = <span class="number">1e6</span> + <span class="number">10</span>;</span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> mod = <span class="number">1e9</span> + <span class="number">7</span>;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">read</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> x = <span class="number">0</span>, f = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">char</span> c = getchar();</span><br><span class="line"> <span class="keyword">while</span> (c < <span class="string">'0'</span> || c > <span class="string">'9'</span>)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (c == <span class="string">'-'</span>)</span><br><span class="line"> f = <span class="number">-1</span>;</span><br><span class="line"> c = getchar();</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">while</span> (c >= <span class="string">'0'</span> && c <= <span class="string">'9'</span>)</span><br><span class="line"> x = (x << <span class="number">1</span>) + (x << <span class="number">3</span>) + c - <span class="string">'0'</span>, c = getchar();</span><br><span class="line"> <span class="keyword">return</span> x * f;</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">LCT</span></span></span><br><span class="line"><span class="class">{</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> ls son[pos][0]</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> rs son[pos][1]</span></span><br><span class="line"></span><br><span class="line"> <span class="keyword">int</span> fa[N], cnt[N], root, tcnt;</span><br><span class="line"> pii mx[N], val[N];</span><br><span class="line"> <span class="keyword">int</span> son[N][<span class="number">2</span>];</span><br><span class="line"> <span class="keyword">int</span> rev[N];</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">pushup</span><span class="params">(<span class="keyword">int</span> pos)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> mx[pos] = <span class="built_in">max</span>(<span class="built_in">max</span>(mx[rs], mx[ls]), val[pos]);</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">bool</span> <span class="title">isroot</span><span class="params">(<span class="keyword">int</span> pos)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">return</span> pos != son[fa[pos]][<span class="number">0</span>] && pos != son[fa[pos]][<span class="number">1</span>];</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">addtag</span><span class="params">(<span class="keyword">int</span> pos)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> rev[pos] ^= <span class="number">1</span>;</span><br><span class="line"> swap(son[pos][<span class="number">0</span>], son[pos][<span class="number">1</span>]);</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">pushdown</span><span class="params">(<span class="keyword">int</span> pos)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">if</span> (rev[pos])</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (son[pos][<span class="number">1</span>])</span><br><span class="line"> addtag(son[pos][<span class="number">1</span>]);</span><br><span class="line"> <span class="keyword">if</span> (son[pos][<span class="number">0</span>])</span><br><span class="line"> addtag(son[pos][<span class="number">0</span>]);</span><br><span class="line"> rev[pos] = <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="function"><span class="keyword">bool</span> <span class="title">isson</span><span class="params">(<span class="keyword">int</span> pos)</span> </span>{ <span class="keyword">return</span> pos == son[fa[pos]][<span class="number">1</span>]; }</span><br><span class="line"></span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">conect</span><span class="params">(<span class="keyword">int</span> x, <span class="keyword">int</span> d, <span class="keyword">int</span> y)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> son[x][d] = y;</span><br><span class="line"> fa[y] = 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">rotate</span><span class="params">(<span class="keyword">int</span> x)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">int</span> y = fa[x], z = fa[y], dx = isson(x), dy = isson(y);</span><br><span class="line"></span><br><span class="line"> fa[x] = z;</span><br><span class="line"> <span class="keyword">if</span> (!isroot(y))</span><br><span class="line"> son[z][dy] = x;</span><br><span class="line"> <span class="comment">//conect(z, dy, x);</span></span><br><span class="line"> conect(y, dx, son[x][dx ^ <span class="number">1</span>]);</span><br><span class="line"> conect(x, dx ^ <span class="number">1</span>, y);</span><br><span class="line"> pushup(y), pushup(x);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">int</span> st[N];</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">splay</span><span class="params">(<span class="keyword">int</span> x)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">int</span> top;</span><br><span class="line"> st[top = <span class="number">1</span>] = x;</span><br><span class="line"> <span class="keyword">int</span> u = x;</span><br><span class="line"> <span class="keyword">while</span> (!isroot(u))</span><br><span class="line"> u = fa[u], st[++top] = u;</span><br><span class="line"> <span class="keyword">while</span> (top)</span><br><span class="line"> pushdown(st[top--]);</span><br><span class="line"> <span class="keyword">while</span> (!isroot(x))</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> y = fa[x];</span><br><span class="line"> <span class="keyword">if</span> (isroot(y))</span><br><span class="line"> {</span><br><span class="line"> rotate(x);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">if</span> (isson(x) == isson(y))</span><br><span class="line"> rotate(y), rotate(x);</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> rotate(x), rotate(x);</span><br><span class="line"> }</span><br><span class="line"> pushup(x);</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">access</span><span class="params">(<span class="keyword">int</span> x)</span></span></span><br><span class="line"><span class="function"> </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>; x; i = x, x = fa[x])</span><br><span class="line"> {</span><br><span class="line"></span><br><span class="line"> splay(x), son[x][<span class="number">1</span>] = i, pushup(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">makeroot</span><span class="params">(<span class="keyword">int</span> x)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> access(x), splay(x), addtag(x); <span class="comment">// access 之后将没有右子树。然后把x变成根，把下面都翻转，这样x就是最小的元素了。</span></span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">int</span> <span class="title">findroot</span><span class="params">(<span class="keyword">int</span> x)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> access(x), splay(x);</span><br><span class="line"> <span class="keyword">while</span> (son[x][<span class="number">0</span>])</span><br><span class="line"> pushdown(x), x = son[x][<span class="number">0</span>];</span><br><span class="line"> <span class="comment">//splay(x);</span></span><br><span class="line"> <span class="keyword">return</span> x;</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">split</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="function"> </span>{</span><br><span class="line"> makeroot(x);</span><br><span class="line"> access(y);</span><br><span class="line"> splay(y);</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">bool</span> <span class="title">link</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="function"> </span>{</span><br><span class="line"> makeroot(x);</span><br><span class="line"> <span class="keyword">if</span> (findroot(y) == x)</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>; <span class="comment">//两点已经在同一子树中，再连边不合法</span></span><br><span class="line"> fa[x] = y;</span><br><span class="line"> <span class="keyword">return</span> <span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">bool</span> <span class="title">islink</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="function"> </span>{</span><br><span class="line"> makeroot(x);</span><br><span class="line"> <span class="keyword">if</span> (findroot(y) == x)</span><br><span class="line"> <span class="keyword">return</span> <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">bool</span> <span class="title">cut</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="function"> </span>{</span><br><span class="line"> makeroot(x);</span><br><span class="line"> <span class="keyword">if</span> (findroot(y) == x)</span><br><span class="line"> {</span><br><span class="line"> split(x, y);</span><br><span class="line"> <span class="keyword">if</span> (fa[x] == y && !son[x][<span class="number">1</span>])</span><br><span class="line"> {</span><br><span class="line"> fa[x] = <span class="number">0</span>;</span><br><span class="line"> son[y][<span class="number">0</span>] = <span class="number">0</span>; <span class="comment">//x在findroot(y)后被转到了根</span></span><br><span class="line"> pushup(y);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> <span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line">} t;</span><br><span class="line"></span><br><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">node</span></span></span><br><span class="line"><span class="class">{</span></span><br><span class="line"> <span class="keyword">int</span> u, v, a, b;</span><br><span class="line">} e[N];</span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> n = <span class="built_in">read</span>(), m = <span class="built_in">read</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><br><span class="line"> e[i].u = <span class="built_in">read</span>(), e[i].v = <span class="built_in">read</span>(), e[i].a = <span class="built_in">read</span>(), e[i].b = <span class="built_in">read</span>();</span><br><span class="line"> }</span><br><span class="line"> sort(e + <span class="number">1</span>, e + <span class="number">1</span> + m, [&](node x, node y) { <span class="keyword">return</span> x.a < y.a; });</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"> t.val[i + n] = {e[i].b, i};</span><br><span class="line"> <span class="keyword">int</span> ans = <span class="number">1e9</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><br><span class="line"> <span class="keyword">int</span> u = e[i].u, v = e[i].v, a = e[i].a, b = e[i].b;</span><br><span class="line"> <span class="keyword">if</span> (t.islink(u, v))</span><br><span class="line"> {</span><br><span class="line"> t.split(u, v);</span><br><span class="line"> pii o = t.mx[v];</span><br><span class="line"> <span class="keyword">if</span> (o.first > b)</span><br><span class="line"> {</span><br><span class="line"> t.cut(e[o.second].u, o.second + n);</span><br><span class="line"> t.cut(e[o.second].v, o.second + n);</span><br><span class="line"> t.link(u, i + n);</span><br><span class="line"> t.link(v, i + n);</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> {</span><br><span class="line"> t.link(u, i + n);</span><br><span class="line"> t.link(v, i + n);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span> (t.islink(<span class="number">1</span>, n))</span><br><span class="line"> {</span><br><span class="line"> t.split(<span class="number">1</span>, n);</span><br><span class="line"> <span class="comment">// cout << t.mx[n].first << endl;</span></span><br><span class="line"> ans = <span class="built_in">min</span>(ans, a + t.mx[n].first);</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span> (ans == <span class="number">1e9</span>)</span><br><span class="line"> <span class="built_in">cout</span> << <span class="number">-1</span> << <span class="built_in">endl</span>;</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> <span class="built_in">cout</span> << ans << <span class="built_in">endl</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure> </details>]]></content>
<summary type="html">
<p>给出一个$n$个点，$m$条边的无向图，每条边都有权值$a_i,b_i$ ，求一条从点$1$到点$n$的路径，使得这条路径上边的$a_i,b_i$ 最大值之和最小<br>
</summary>
<category term="LCT" scheme="http://yoursite.com/tags/LCT/"/>
</entry>
<entry>
<title>AT4132 [ARC097C] Sorted and Sorted</title>
<link href="http://yoursite.com/2020/12/06/ARC097C/"/>
<id>http://yoursite.com/2020/12/06/ARC097C/</id>
<published>2020-12-06T02:47:00.000Z</published>
<updated>2020-12-06T04:09:12.000Z</updated>
<content type="html"><![CDATA[<p>有 $2N$个球排成一列，其中有$N$个黑球与 $N$ 个白球。把 $1$ 到 $N$ 这 $N$个数字分别写到 $N$ 个黑球上；白球亦然。左起第 $i$ 个球上的写的数字是 $a_i$，颜色是 $c_i$。</p><p> $B$ 是黑球，为 $W$ 是白球。</p><p>定义一次操作为交换两个相邻的球。你需要求出最少的操作使得序列中</p><a id="more"></a><p>考虑一个数的交换次数就是他的逆序对，但是这里并没有确定比他小的数。无法直接计算可得</p><p>那么显然可以设$dp[i][j]$表示把前$i$个白球放好，前$j$个黑球，那么加入我放$i$这个白球，那么$i-1$个白球以及$j$个黑球就是比他小的，这样就可以计算出逆序对了。同理黑球也是。</p><ul><li>$i-1$个白球以及$j$个黑球就是比他小的可以预处理就解决了。</li></ul><details> <summary>代码</summary><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><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></pre></td><td class="code"><pre><span class="line"></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><bits/stdc++.h></span></span></span><br><span class="line"></span><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="function"></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"> vector<pair<char, int>> a(2 * n + 1);</span><br><span class="line"> vector<int> pw(n + 1), pb(n + 1);</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">2</span> * n; i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="built_in">cin</span> >> a[i].first >> a[i].second;</span><br><span class="line"> <span class="keyword">if</span> (a[i].first == <span class="string">'W'</span>)</span><br><span class="line"> pw[a[i].second] = i;</span><br><span class="line"> <span class="keyword">if</span> (a[i].first == <span class="string">'B'</span>)</span><br><span class="line"> pb[a[i].second] = i;</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="built_in">vector</span><<span class="built_in">vector</span><<span class="keyword">int</span>>> <span class="title">cw</span><span class="params">(<span class="number">2</span> * n + <span class="number">1</span>, <span class="built_in">vector</span><<span class="keyword">int</span>>(n + <span class="number">1</span>))</span></span>;</span><br><span class="line"> <span class="function"><span class="built_in">vector</span><<span class="built_in">vector</span><<span class="keyword">int</span>>> <span class="title">cb</span><span class="params">(<span class="number">2</span> * n + <span class="number">1</span>, <span class="built_in">vector</span><<span class="keyword">int</span>>(n + <span class="number">1</span>))</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">2</span> * 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"> {</span><br><span class="line"> cw[i][j] = cw[i - <span class="number">1</span>][j] + (a[i - <span class="number">1</span>].second > j && a[i - <span class="number">1</span>].first == <span class="string">'W'</span>);</span><br><span class="line"> cb[i][j] = cb[i - <span class="number">1</span>][j] + (a[i - <span class="number">1</span>].second > j && a[i - <span class="number">1</span>].first == <span class="string">'B'</span>);</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="built_in">vector</span><<span class="built_in">vector</span><<span class="keyword">int</span>>> <span class="title">dp</span><span class="params">(n + <span class="number">1</span>, <span class="built_in">vector</span><<span class="keyword">int</span>>(n + <span class="number">1</span>, <span class="number">1e9</span>))</span></span>;</span><br><span class="line"> dp[<span class="number">0</span>][<span class="number">0</span>] = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i <= 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"> {</span><br><span class="line"> <span class="keyword">int</span> x = pw[i], y = pb[j];</span><br><span class="line"> <span class="keyword">if</span> (i)</span><br><span class="line"> dp[i][j] = <span class="built_in">min</span>(dp[i][j], dp[i - <span class="number">1</span>][j] + cw[x][i] + cb[x][j]);</span><br><span class="line"> <span class="keyword">if</span> (j)</span><br><span class="line"> dp[i][j] = <span class="built_in">min</span>(dp[i][j], dp[i][j - <span class="number">1</span>] + cw[y][i] + cb[y][j]);</span><br><span class="line"> }</span><br><span class="line"> <span class="built_in">cout</span> << dp[n][n] << <span class="built_in">endl</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure> </details>]]></content>
<summary type="html">
<p>有 $2N$个球排成一列，其中有$N$个黑球与 $N$ 个白球。把 $1$ 到 $N$ 这 $N$个数字分别写到 $N$ 个黑球上；白球亦然。左起第 $i$ 个球上的写的数字是 $a_i$，颜色是 $c_i$。</p>
<p> $B$ 是黑球，为 $W$ 是白球。</p>
<p>定义一次操作为交换两个相邻的球。你需要求出最少的操作使得序列中</p>
</summary>
<category term="dp" scheme="http://yoursite.com/tags/dp/"/>
</entry>
<entry>
<title>CF603E - Pastoral Oddities</title>
<link href="http://yoursite.com/2020/12/06/CF603E/"/>
<id>http://yoursite.com/2020/12/06/CF603E/</id>
<published>2020-12-06T02:47:00.000Z</published>
<updated>2020-12-06T04:09:11.000Z</updated>
<content type="html"><![CDATA[<ul><li>给定一张 $n$个点的无向图，初始没有边。</li><li>依次加入$m$条带权的边，每次加入后询问是否存在一个边集，满足每个点的度数均为奇数。</li><li>若存在，则还需要最小化边集中的最大边权。</li><li>$n \le 10^5,m\leq 3\times 10^5 $</li></ul><a id="more"></a><p>考虑静态图，显然首先满足联通块点数为偶数。</p><p>考虑当前图也必须联通块是偶数点，（因为去边之后分裂成联通也要满足偶数点)。</p><p>最小化边集中的最大边权，考虑维护最小生成树。</p><p>如果纯静态，我们可以从叶子节点类似递推选择尽量少的边。这样显然是可以有解.</p><p>但是这个时候我们仍然没有选出最优解。</p><p>瞎$JB$乱画发现，删掉的边都是分裂成$奇+奇$的，我们不断地尝试删除当前森林中边权最大的边，联通块就会分裂，如果产生分裂成$奇+奇$，表示这个边不能删，这里的操作用大根堆以及懒惰记号表示。</p><p>然后用$LCT$子树维护一下奇数的联通块有多少。</p><details> <summary>代码</summary><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><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><span class="line">111</span><br><span class="line">112</span><br><span class="line">113</span><br><span class="line">114</span><br><span class="line">115</span><br><span class="line">116</span><br><span class="line">117</span><br><span class="line">118</span><br><span class="line">119</span><br><span class="line">120</span><br><span class="line">121</span><br><span class="line">122</span><br><span class="line">123</span><br><span class="line">124</span><br><span class="line">125</span><br><span class="line">126</span><br><span class="line">127</span><br><span class="line">128</span><br><span class="line">129</span><br><span class="line">130</span><br><span class="line">131</span><br><span class="line">132</span><br><span class="line">133</span><br><span class="line">134</span><br><span class="line">135</span><br><span class="line">136</span><br><span class="line">137</span><br><span class="line">138</span><br><span class="line">139</span><br><span class="line">140</span><br><span class="line">141</span><br><span class="line">142</span><br><span class="line">143</span><br><span class="line">144</span><br><span class="line">145</span><br><span class="line">146</span><br><span class="line">147</span><br><span class="line">148</span><br><span class="line">149</span><br><span class="line">150</span><br><span class="line">151</span><br><span class="line">152</span><br><span class="line">153</span><br><span class="line">154</span><br><span class="line">155</span><br><span class="line">156</span><br><span class="line">157</span><br><span class="line">158</span><br><span class="line">159</span><br><span class="line">160</span><br><span class="line">161</span><br><span class="line">162</span><br><span class="line">163</span><br><span class="line">164</span><br><span class="line">165</span><br><span class="line">166</span><br><span class="line">167</span><br><span class="line">168</span><br><span class="line">169</span><br><span class="line">170</span><br><span class="line">171</span><br><span class="line">172</span><br><span class="line">173</span><br><span class="line">174</span><br><span class="line">175</span><br><span class="line">176</span><br><span class="line">177</span><br><span class="line">178</span><br><span class="line">179</span><br><span class="line">180</span><br><span class="line">181</span><br><span class="line">182</span><br><span class="line">183</span><br><span class="line">184</span><br><span class="line">185</span><br><span class="line">186</span><br><span class="line">187</span><br><span class="line">188</span><br><span class="line">189</span><br><span class="line">190</span><br><span class="line">191</span><br><span class="line">192</span><br><span class="line">193</span><br><span class="line">194</span><br><span class="line">195</span><br><span class="line">196</span><br><span class="line">197</span><br><span class="line">198</span><br><span class="line">199</span><br><span class="line">200</span><br><span class="line">201</span><br><span class="line">202</span><br><span class="line">203</span><br><span class="line">204</span><br><span class="line">205</span><br><span class="line">206</span><br><span class="line">207</span><br><span class="line">208</span><br><span class="line">209</span><br><span class="line">210</span><br><span class="line">211</span><br><span class="line">212</span><br><span class="line">213</span><br><span class="line">214</span><br><span class="line">215</span><br><span class="line">216</span><br><span class="line">217</span><br><span class="line">218</span><br></pre></td><td class="code"><pre><span class="line"></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><bits/stdc++.h></span></span></span><br><span class="line"></span><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> N = <span class="number">4e5</span> + <span class="number">10</span>;</span><br><span class="line"></span><br><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">Edge</span></span></span><br><span class="line"><span class="class">{</span></span><br><span class="line"> <span class="keyword">int</span> u, v, w;</span><br><span class="line"> Edge(){};</span><br><span class="line">};</span><br><span class="line"></span><br><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">LCT</span></span></span><br><span class="line"><span class="class">{</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> ls son[pos][0]</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> rs son[pos][1]</span></span><br><span class="line"></span><br><span class="line"> <span class="keyword">int</span> fa[N], root, tcnt;</span><br><span class="line"> <span class="keyword">int</span> son[N][<span class="number">2</span>];</span><br><span class="line"> pair<<span class="keyword">int</span>, <span class="keyword">int</span>> mx[N], val[N];</span><br><span class="line"> <span class="keyword">int</span> exsiz[N], si[N], siz[N];</span><br><span class="line"> <span class="keyword">int</span> rev[N];</span><br><span class="line"> <span class="keyword">int</span> cnt = <span class="number">0</span>;</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">pushup</span><span class="params">(<span class="keyword">int</span> pos)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> mx[pos] = <span class="built_in">max</span>(val[pos], <span class="built_in">max</span>(mx[ls], mx[rs]));</span><br><span class="line"> siz[pos] = siz[ls] + siz[rs] + exsiz[pos] + si[pos];</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">bool</span> <span class="title">isroot</span><span class="params">(<span class="keyword">int</span> pos)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">return</span> pos != son[fa[pos]][<span class="number">0</span>] && pos != son[fa[pos]][<span class="number">1</span>];</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">addrev</span><span class="params">(<span class="keyword">int</span> pos)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> rev[pos] ^= <span class="number">1</span>;</span><br><span class="line"> swap(son[pos][<span class="number">0</span>], son[pos][<span class="number">1</span>]);</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">pushdown</span><span class="params">(<span class="keyword">int</span> pos)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (rev[pos])</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (son[pos][<span class="number">1</span>])</span><br><span class="line"> addrev(son[pos][<span class="number">1</span>]);</span><br><span class="line"> <span class="keyword">if</span> (son[pos][<span class="number">0</span>])</span><br><span class="line"> addrev(son[pos][<span class="number">0</span>]);</span><br><span class="line"> rev[pos] = <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="function"><span class="keyword">bool</span> <span class="title">isson</span><span class="params">(<span class="keyword">int</span> pos)</span> </span>{ <span class="keyword">return</span> pos == son[fa[pos]][<span class="number">1</span>]; }</span><br><span class="line"></span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">conect</span><span class="params">(<span class="keyword">int</span> x, <span class="keyword">int</span> d, <span class="keyword">int</span> y)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> son[x][d] = y;</span><br><span class="line"> fa[y] = 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">rorate</span><span class="params">(<span class="keyword">int</span> x)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">int</span> y = fa[x], z = fa[y], dx = isson(x), dy = isson(y);</span><br><span class="line"></span><br><span class="line"> fa[x] = z;</span><br><span class="line"> <span class="keyword">if</span> (!isroot(y))</span><br><span class="line"> son[z][dy] = x;</span><br><span class="line"> <span class="comment">//conect(z, dy, x);</span></span><br><span class="line"> conect(y, dx, son[x][dx ^ <span class="number">1</span>]);</span><br><span class="line"> conect(x, dx ^ <span class="number">1</span>, y);</span><br><span class="line"> pushup(y), pushup(x);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">int</span> st[N];</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">splay</span><span class="params">(<span class="keyword">int</span> x)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">int</span> top;</span><br><span class="line"> st[top = <span class="number">1</span>] = x;</span><br><span class="line"> <span class="keyword">int</span> u = x;</span><br><span class="line"> <span class="keyword">while</span> (!isroot(u))</span><br><span class="line"> u = fa[u], st[++top] = u;</span><br><span class="line"> <span class="keyword">while</span> (top)</span><br><span class="line"> pushdown(st[top--]);</span><br><span class="line"> <span class="keyword">while</span> (!isroot(x))</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> y = fa[x];</span><br><span class="line"> <span class="keyword">if</span> (isroot(y))</span><br><span class="line"> {</span><br><span class="line"> rorate(x);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">if</span> (isson(x) == isson(y))</span><br><span class="line"> rorate(y), rorate(x);</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> rorate(x), rorate(x);</span><br><span class="line"> }</span><br><span class="line"> pushup(x);</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">access</span><span class="params">(<span class="keyword">int</span> x)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; x; i = x, x = fa[x])</span><br><span class="line"> {</span><br><span class="line"> splay(x), exsiz[x] -= siz[i], exsiz[x] += siz[son[x][<span class="number">1</span>]], son[x][<span class="number">1</span>] = i, pushup(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">makeroot</span><span class="params">(<span class="keyword">int</span> x)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> access(x), splay(x), addrev(x); <span class="comment">// access 之后将没有右子树。然后把x变成根，把下面都翻转，这样x就是最小的元素了。</span></span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">int</span> <span class="title">findroot</span><span class="params">(<span class="keyword">int</span> x)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> access(x), splay(x);</span><br><span class="line"> <span class="keyword">while</span> (son[x][<span class="number">0</span>])</span><br><span class="line"> pushdown(x), x = son[x][<span class="number">0</span>];</span><br><span class="line"> splay(x);</span><br><span class="line"> <span class="keyword">return</span> x;</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">split</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="function"> </span>{</span><br><span class="line"> makeroot(x);</span><br><span class="line"> access(y);</span><br><span class="line"> splay(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">link</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="function"> </span>{</span><br><span class="line"> split(x, y);</span><br><span class="line"> cnt -= siz[x] & <span class="number">1</span>;</span><br><span class="line"> cnt -= siz[y] & <span class="number">1</span>;</span><br><span class="line"> fa[x] = y;</span><br><span class="line"> exsiz[y] += siz[x];</span><br><span class="line"> pushup(y);</span><br><span class="line"> cnt += siz[y] & <span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">cut</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="function"> </span>{</span><br><span class="line"> split(x, y);</span><br><span class="line"> fa[x] = <span class="number">0</span>;</span><br><span class="line"> son[y][<span class="number">0</span>] = <span class="number">0</span>;</span><br><span class="line"> cnt -= siz[y] & <span class="number">1</span>;</span><br><span class="line"> pushup(y);</span><br><span class="line"> cnt += siz[x] & <span class="number">1</span>;</span><br><span class="line"> cnt += siz[y] & <span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">init</span><span class="params">(<span class="keyword">int</span> n, <span class="keyword">int</span> m, <span class="built_in">vector</span><Edge> tmp)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">1</span>; i <= n; i++)</span><br><span class="line"> si[i] = <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 <= m; i++)</span><br><span class="line"> val[i + n] = mx[i + n] = {tmp[i].w, i};</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">solve</span><span class="params">(<span class="keyword">int</span> n, <span class="keyword">int</span> m, <span class="built_in">vector</span><Edge> tmp)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> cnt = n;</span><br><span class="line"> <span class="function"><span class="built_in">vector</span><<span class="keyword">int</span>> <span class="title">vis</span><span class="params">(m + <span class="number">1</span>)</span></span>;</span><br><span class="line"> priority_queue<pair<<span class="keyword">int</span>, <span class="keyword">int</span>>> q;</span><br><span class="line"> <span class="keyword">auto</span> add = [&](<span class="keyword">int</span> i) {</span><br><span class="line"> <span class="keyword">int</span> u = tmp[i].u, v = tmp[i].v, w = tmp[i].w;</span><br><span class="line"> <span class="keyword">bool</span> flag = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">if</span> (findroot(u) == findroot(v))</span><br><span class="line"> {</span><br><span class="line"> split(u, v);</span><br><span class="line"> <span class="keyword">auto</span> o = mx[v];</span><br><span class="line"> <span class="keyword">if</span> (o.first > w)</span><br><span class="line"> {</span><br><span class="line"> cut(n + o.second, tmp[o.second].u);</span><br><span class="line"> cut(n + o.second, tmp[o.second].v);</span><br><span class="line"> vis[o.second] = <span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> flag = <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><br><span class="line"> link(i + n, u), link(i + n, v);</span><br><span class="line"> q.push({tmp[i].w, i});</span><br><span class="line"> }</span><br><span class="line"> <span class="comment">// cout << cnt << "!!!" << endl;</span></span><br><span class="line"> <span class="keyword">if</span> (cnt)</span><br><span class="line"> <span class="keyword">return</span> <span class="number">-1</span>;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">while</span> (q.<span class="built_in">size</span>())</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> o = q.top().second;</span><br><span class="line"> q.pop();</span><br><span class="line"> <span class="keyword">if</span> (vis[o])</span><br><span class="line"> <span class="keyword">continue</span>;</span><br><span class="line"> cut(tmp[o].u, o + n);</span><br><span class="line"> cut(tmp[o].v, o + n);</span><br><span class="line"> <span class="comment">// cout << o << " " << cnt << endl;</span></span><br><span class="line"> <span class="keyword">if</span> (cnt)</span><br><span class="line"> {</span><br><span class="line"> link(tmp[o].u, o + n), link(tmp[o].v, o + n);</span><br><span class="line"> q.push({tmp[o].w, o});</span><br><span class="line"> <span class="keyword">return</span> tmp[o].w;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="keyword">return</span> <span class="number">-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 <= m; i++)</span><br><span class="line"> <span class="built_in">cout</span> << add(i) << <span class="built_in">endl</span>;</span><br><span class="line"> }</span><br><span class="line">} t;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> ios::sync_with_stdio(<span class="literal">false</span>);</span><br><span class="line"> <span class="built_in">cin</span>.tie(<span class="literal">nullptr</span>);</span><br><span class="line"> <span class="keyword">int</span> n, m;</span><br><span class="line"></span><br><span class="line"> <span class="built_in">cin</span> >> n >> m;</span><br><span class="line"> <span class="function"><span class="built_in">vector</span><Edge> <span class="title">e</span><span class="params">(m + <span class="number">1</span>)</span></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="built_in">cin</span> >> e[i].u >> e[i].v >> e[i].w;</span><br><span class="line"> t.init(n, m, e);</span><br><span class="line"> t.solve(n, m, e);</span><br><span class="line">}</span><br></pre></td></tr></table></figure> </details>]]></content>
<summary type="html">
<ul>
<li>给定一张 $n$个点的无向图，初始没有边。</li>
<li>依次加入$m$条带权的边，每次加入后询问是否存在一个边集，满足每个点的度数均为奇数。</li>
<li>若存在，则还需要最小化边集中的最大边权。</li>
<li>$n \le 10^5,m\leq 3\times 10^5 $</li>
</ul>
</summary>
<category term="LCT" scheme="http://yoursite.com/tags/LCT/"/>
</entry>
<entry>
<title>CF1139D Steps to One</title>
<link href="http://yoursite.com/2020/11/25/CF1139D/"/>
<id>http://yoursite.com/2020/11/25/CF1139D/</id>
<published>2020-11-25T02:47:00.000Z</published>
<updated>2020-12-06T05:33:04.000Z</updated>
<content type="html"><![CDATA[<p>给一个数列，每次随机选一个 $1$ 到 $m$之间的数加在数列末尾，数列中所有数的 $\gcd=1$ 时停止，求期望长度。</p><a id="more"></a><p>可以先把第一个加的数字确定。</p><p>$f[i]$表示从当前$\gcd=i$,变到$1$需要的期望步数。<br>$f[1]=0$</p><p>$f[i]=1+\frac{f[\gcd(i,j)]}{m}$</p><script type="math/tex; mode=display"> mf[i]=m+\sum_{x|i}f(x)\sum_{j=1}^m [\gcd(i,j)=x]\\ mf[i]=m+\sum_{x|i}f(x)\sum_{j=1}^m [\gcd(i,j)=x]\\ mf[i]=m+\sum_{x|i}f(x)\sum_{j=1}^{\frac{m}{i}} [\gcd(\frac{i}{x},j)=1]\\ mf[i]=m+\sum_{x|i}f(x)\sum_{d|\frac{i}{x}} \mu(d)\frac{m}{id}\\ (m-\frac{m}{i})f[i]=m+\sum_{x|i}f(x)\sum_{d|\frac{i}{x}} \mu(d)\frac{m}{id}[i \not=x]\\</script><p>分析下复杂度$\sum_{i=1}^m\sum_{j=1}^{\frac{m}{i}}D(j)=\sum_{i=1}^m\sum_{d=1}^{\frac{m}{i}}\frac{\frac{m}{i}}{d}=\sum_{i=1}^m\frac{m}{i}\log m=O(m\log^2 m)$</p><details> <summary>代码</summary><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><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></pre></td><td class="code"><pre><span class="line"></span><br><span class="line"></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><bits/stdc++.h></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> ll long long</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> pii pair<span class="meta-string"><int, int></span></span></span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> N = <span class="number">1e6</span> + <span class="number">10</span>;</span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> mod = <span class="number">1e9</span> + <span class="number">7</span>;</span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">inc</span><span class="params">(<span class="keyword">int</span> x, <span class="keyword">int</span> y)</span> </span>{ <span class="keyword">return</span> (x + y >= mod) ? (x + y - mod) : (x + y); }</span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">del</span><span class="params">(<span class="keyword">int</span> x, <span class="keyword">int</span> y)</span> </span>{ <span class="keyword">return</span> (x - y < <span class="number">0</span>) ? (x - y + mod) : (x - y); }</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">qpow</span><span class="params">(<span class="keyword">int</span> a, <span class="keyword">int</span> x, <span class="keyword">int</span> mo)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> res = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">while</span> (x)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (x & <span class="number">1</span>)</span><br><span class="line"> res = <span class="number">1l</span>l * a * res % mo;</span><br><span class="line"> a = <span class="number">1l</span>l * a * a % mo;</span><br><span class="line"> x >>= <span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> res;</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="keyword">int</span> pcnt, pr[N], npr[N];</span><br><span class="line"><span class="keyword">int</span> mu[N], usum[N];</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">Prime_init</span><span class="params">(<span class="keyword">int</span> X)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> npr[<span class="number">1</span>] = <span class="number">1</span>;</span><br><span class="line"> mu[<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 <= X; i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (!npr[i])</span><br><span class="line"> pr[++pcnt] = i, mu[i] = <span class="number">-1</span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> j = <span class="number">1</span>; j <= pcnt && pr[j] * i <= X; j++)</span><br><span class="line"> {</span><br><span class="line"> npr[pr[j] * i] = <span class="number">1</span>;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (i % pr[j] == <span class="number">0</span>)</span><br><span class="line"> {</span><br><span class="line"> mu[pr[j] * i] = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">break</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> {</span><br><span class="line"> mu[pr[j] * i] = mu[i] * (<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="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> m;</span><br><span class="line"> <span class="built_in">cin</span> >> m;</span><br><span class="line"> <span class="function"><span class="built_in">vector</span><<span class="built_in">vector</span><<span class="keyword">int</span>>> <span class="title">g</span><span class="params">(m + <span class="number">1</span>)</span></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">for</span> (<span class="keyword">int</span> j = i; j <= m; j += i)</span><br><span class="line"> g[j].push_back(i);</span><br><span class="line"> Prime_init(m);</span><br><span class="line"> <span class="keyword">auto</span> calc = [&](<span class="keyword">int</span> a, <span class="keyword">int</span> b) {</span><br><span class="line"> <span class="keyword">int</span> res = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> d : g[b])</span><br><span class="line"> {</span><br><span class="line"> res += mu[d] * (a / d);</span><br><span class="line"> }</span><br><span class="line"> <span class="comment">//cout << a << " " << b << " " << res << endl;</span></span><br><span class="line"> <span class="keyword">return</span> res;</span><br><span class="line"> };</span><br><span class="line"> <span class="function"><span class="built_in">vector</span><<span class="built_in">vector</span><<span class="keyword">int</span>>> <span class="title">z</span><span class="params">(m + <span class="number">1</span>)</span></span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">1</span>, j; i <= m; i = j + <span class="number">1</span>)</span><br><span class="line"> {</span><br><span class="line"> j = m / (m / i);</span><br><span class="line"> z[m / i].resize(m / i + <span class="number">1</span>);</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> k = <span class="number">1</span>; k <= m / i; k++)</span><br><span class="line"> {</span><br><span class="line"> z[m / i][k] = calc(m / i, k);</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="built_in">vector</span><<span class="keyword">int</span>> <span class="title">f</span><span class="params">(m + <span class="number">1</span>)</span></span>;</span><br><span class="line"> <span class="keyword">int</span> ans = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">2</span>; i <= m; i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> res = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> d : g[i])</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (d == i)</span><br><span class="line"> <span class="keyword">continue</span>;</span><br><span class="line"></span><br><span class="line"> res = inc(res, <span class="number">1l</span>l * f[d] * z[m / d][i / d] % mod);</span><br><span class="line"> }</span><br><span class="line"> f[i] = <span class="number">1l</span>l * (res + m) * qpow(m - m / i, mod - <span class="number">2</span>, mod) % mod;</span><br><span class="line"> <span class="comment">//cout << f[i] << endl;</span></span><br><span class="line"> ans = inc(ans, f[i]);</span><br><span class="line"> }</span><br><span class="line"> <span class="built_in">cout</span> << <span class="number">1l</span>l * (ans + m) * qpow(m, mod - <span class="number">2</span>, mod) % mod << <span class="built_in">endl</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure> </details>]]></content>
<summary type="html">
<p>给一个数列，每次随机选一个 $1$ 到 $m$之间的数加在数列末尾，数列中所有数的 $\gcd=1$ 时停止，求期望长度。</p>
</summary>
<category term="莫比乌斯反演" scheme="http://yoursite.com/tags/%E8%8E%AB%E6%AF%94%E4%B9%8C%E6%96%AF%E5%8F%8D%E6%BC%94/"/>
</entry>
<entry>
<title>CF702F T-Shirts</title>
<link href="http://yoursite.com/2020/11/20/CF702F/"/>
<id>http://yoursite.com/2020/11/20/CF702F/</id>
<published>2020-11-20T02:47:00.000Z</published>
<updated>2020-12-06T04:55:28.000Z</updated>
<content type="html"><![CDATA[<p>有 $n$ 种T恤，每种有价格 $c_i$和品质 $q_i$ 。</p><p>有 $m$ 个人要买 $T$ 恤，第 $i$ 个人有$v_i$元，每人每次都会买一件能买得起的 $q_i$最大的$T$恤。一个人只能买一种T恤一件，所有人之间都是独立的。</p><p>问最后每个人买了多少件 $T$ 恤？如果有多个 $q_i$ 最大的T恤，会从价格低的开始买。</p><a id="more"></a><p>考虑朴素暴力枚举人$O(nm)$无法优化。</p><p>考虑枚举衣服，先按品质排序，然后再价格为第二关键字。朴素考虑将所有$v_i\geq c_i$都$+1$，并且$v_i=v_i-c$。</p><p>这种区间修改就想到了$FHQ$,考虑$v_i>2c$的只要打上标记就好，相对位置不会变，即在平衡树上位置不会变，但是考虑$c\leq v_i\leq 2c$,要改变，这里可以暴力。</p><ul><li>$c\leq v_i\leq 2c$,$nv_i\leq v_i/2$。对于一个价格来说最多暴力改变$\log n$</li></ul><p>最后复杂度就可$O(n\log^2n)$</p><details> <summary>代码</summary><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><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><span class="line">111</span><br><span class="line">112</span><br><span class="line">113</span><br><span class="line">114</span><br><span class="line">115</span><br><span class="line">116</span><br><span class="line">117</span><br><span class="line">118</span><br><span class="line">119</span><br><span class="line">120</span><br><span class="line">121</span><br><span class="line">122</span><br><span class="line">123</span><br><span class="line">124</span><br><span class="line">125</span><br><span class="line">126</span><br><span class="line">127</span><br><span class="line">128</span><br><span class="line">129</span><br><span class="line">130</span><br><span class="line">131</span><br><span class="line">132</span><br><span class="line">133</span><br><span class="line">134</span><br><span class="line">135</span><br><span class="line">136</span><br><span class="line">137</span><br><span class="line">138</span><br><span class="line">139</span><br><span class="line">140</span><br><span class="line">141</span><br><span class="line">142</span><br><span class="line">143</span><br><span class="line">144</span><br><span class="line">145</span><br><span class="line">146</span><br><span class="line">147</span><br><span class="line">148</span><br><span class="line">149</span><br><span class="line">150</span><br><span class="line">151</span><br><span class="line">152</span><br><span class="line">153</span><br><span class="line">154</span><br><span class="line">155</span><br><span class="line">156</span><br><span class="line">157</span><br><span class="line">158</span><br><span class="line">159</span><br><span class="line">160</span><br><span class="line">161</span><br><span class="line">162</span><br><span class="line">163</span><br><span class="line">164</span><br><span class="line">165</span><br><span class="line">166</span><br><span class="line">167</span><br><span class="line">168</span><br><span class="line">169</span><br><span class="line">170</span><br><span class="line">171</span><br><span class="line">172</span><br><span class="line">173</span><br><span class="line">174</span><br><span class="line">175</span><br><span class="line">176</span><br><span class="line">177</span><br><span class="line">178</span><br><span class="line">179</span><br><span class="line">180</span><br><span class="line">181</span><br><span class="line">182</span><br><span class="line">183</span><br><span class="line">184</span><br><span class="line">185</span><br><span class="line">186</span><br><span class="line">187</span><br><span class="line">188</span><br><span class="line">189</span><br><span class="line">190</span><br><span class="line">191</span><br><span class="line">192</span><br><span class="line">193</span><br><span class="line">194</span><br><span class="line">195</span><br><span class="line">196</span><br><span class="line">197</span><br><span class="line">198</span><br><span class="line">199</span><br><span class="line">200</span><br><span class="line">201</span><br><span class="line">202</span><br><span class="line">203</span><br><span class="line">204</span><br><span class="line">205</span><br><span class="line">206</span><br><span class="line">207</span><br><span class="line">208</span><br><span class="line">209</span><br></pre></td><td class="code"><pre><span class="line"></span><br><span class="line"></span><br><span class="line"></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><bits/stdc++.h></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line"><span class="keyword">typedef</span> <span class="keyword">long</span> <span class="keyword">long</span> ll;</span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> pii pair<span class="meta-string"><int, int></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> mk make_pair</span></span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> N = <span class="number">1e6</span> + <span class="number">10</span>;</span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> mod = <span class="number">1e9</span> + <span class="number">7</span>;</span><br><span class="line"></span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> INF = <span class="number">1e9</span>;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">read</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> x = <span class="number">0</span>, f = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">char</span> c = getchar();</span><br><span class="line"> <span class="keyword">while</span> (c < <span class="string">'0'</span> || c > <span class="string">'9'</span>)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (c == <span class="string">'-'</span>)</span><br><span class="line"> f = <span class="number">-1</span>;</span><br><span class="line"> c = getchar();</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">while</span> (c >= <span class="string">'0'</span> && c <= <span class="string">'9'</span>)</span><br><span class="line"> x = (x << <span class="number">1</span>) + (x << <span class="number">3</span>) + c - <span class="string">'0'</span>, c = getchar();</span><br><span class="line"> <span class="keyword">return</span> x * f;</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="built_in">std</span>::mt19937 <span class="title">rnd</span><span class="params">(<span class="built_in">std</span>::chrono::steady_clock::now().time_since_epoch().count())</span></span>;</span><br><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">FHQ</span></span></span><br><span class="line"><span class="class">{</span></span><br><span class="line"> <span class="keyword">int</span> ls[N], rs[N], siz[N], key[N], val[N];</span><br><span class="line"> <span class="keyword">int</span> sum[N];</span><br><span class="line"> <span class="keyword">int</span> tag[N];</span><br><span class="line"> <span class="keyword">int</span> de[N];</span><br><span class="line"> <span class="keyword">int</span> id[N];</span><br><span class="line"> <span class="keyword">int</span> tcnt;</span><br><span class="line"> <span class="keyword">int</span> root;</span><br><span class="line"></span><br><span class="line"> <span class="function"><span class="keyword">int</span> <span class="title">Newnode</span><span class="params">(<span class="keyword">int</span> x, <span class="keyword">int</span> i)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"></span><br><span class="line"> siz[++tcnt] = <span class="number">1</span>;</span><br><span class="line"> val[tcnt] = x;</span><br><span class="line"> id[tcnt] = i;</span><br><span class="line"> key[tcnt] = rnd(); <span class="comment">//精髓所在</span></span><br><span class="line"> ls[tcnt] = rs[tcnt] = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">return</span> tcnt;</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">addtag</span><span class="params">(<span class="keyword">int</span> pos, <span class="keyword">int</span> w, <span class="keyword">int</span> c)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> sum[pos] += w;</span><br><span class="line"> tag[pos] += w;</span><br><span class="line"> val[pos] -= c;</span><br><span class="line"> de[pos] += c;</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">pushdown</span><span class="params">(<span class="keyword">int</span> pos)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">if</span> (tag[pos])</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (ls[pos])</span><br><span class="line"> addtag(ls[pos], tag[pos], <span class="number">0</span>);</span><br><span class="line"> <span class="keyword">if</span> (rs[pos])</span><br><span class="line"> addtag(rs[pos], tag[pos], <span class="number">0</span>);</span><br><span class="line"> tag[pos] = <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span> (de[pos])</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (ls[pos])</span><br><span class="line"> addtag(ls[pos], <span class="number">0</span>, de[pos]);</span><br><span class="line"> <span class="keyword">if</span> (rs[pos])</span><br><span class="line"> addtag(rs[pos], <span class="number">0</span>, de[pos]);</span><br><span class="line"> de[pos] = <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">pushup</span><span class="params">(<span class="keyword">int</span> pos)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="comment">//siz[pos] = siz[ls[pos]] + siz[rs[pos]] + 1;</span></span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">split</span><span class="params">(<span class="keyword">int</span> pos, <span class="keyword">int</span> v, <span class="keyword">int</span> &ll, <span class="keyword">int</span> &rr)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">if</span> (!pos)</span><br><span class="line"> {</span><br><span class="line"> ll = <span class="number">0</span>, rr = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">return</span>;</span><br><span class="line"> }</span><br><span class="line"> pushdown(pos);</span><br><span class="line"> <span class="keyword">if</span> (val[pos] <= v)</span><br><span class="line"> {</span><br><span class="line"> ll = pos;</span><br><span class="line"> split(rs[pos], v, rs[pos], rr);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> {</span><br><span class="line"> rr = pos;</span><br><span class="line"> split(ls[pos], v, ll, ls[pos]);</span><br><span class="line"> }</span><br><span class="line"> pushup(pos);</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">int</span> <span class="title">merge</span><span class="params">(<span class="keyword">int</span> l, <span class="keyword">int</span> r)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">if</span> (!l || !r)</span><br><span class="line"> <span class="keyword">return</span> l + r;</span><br><span class="line"> pushdown(l), pushdown(r);</span><br><span class="line"> ;</span><br><span class="line"> <span class="keyword">if</span> (key[l] < key[r])</span><br><span class="line"> {</span><br><span class="line"> rs[l] = merge(rs[l], r);</span><br><span class="line"> pushup(l);</span><br><span class="line"> <span class="keyword">return</span> l;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> {</span><br><span class="line"> ls[r] = merge(l, ls[r]);</span><br><span class="line"> pushup(r);</span><br><span class="line"> <span class="keyword">return</span> r;</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">insert</span><span class="params">(<span class="keyword">int</span> v, <span class="keyword">int</span> i)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">int</span> tmp = Newnode(v, i);</span><br><span class="line"> <span class="keyword">int</span> x, y;</span><br><span class="line"></span><br><span class="line"> split(root, v, x, y);</span><br><span class="line"></span><br><span class="line"> root = merge(merge(x, tmp), y);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">void</span> _insert(<span class="keyword">int</span> &rt, <span class="keyword">int</span> pos)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> x, y;</span><br><span class="line"></span><br><span class="line"> split(rt, val[pos], x, y);</span><br><span class="line"></span><br><span class="line"> rt = merge(merge(x, pos), y);</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">delet</span><span class="params">(<span class="keyword">int</span> v)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">int</span> x, y, z, tmp;</span><br><span class="line"> split(root, v, x, z);</span><br><span class="line"> split(tmp = x, v - <span class="number">1</span>, x, y);</span><br><span class="line"> root = merge(merge(x, merge(ls[y], rs[y])), z);</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line">} t;</span><br><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">node</span></span></span><br><span class="line"><span class="class">{</span></span><br><span class="line"> <span class="keyword">int</span> c, q;</span><br><span class="line">};</span><br><span class="line"><span class="built_in">vector</span><<span class="keyword">int</span>> tmp;</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> pos)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">if</span> (!pos)</span><br><span class="line"> <span class="keyword">return</span>;</span><br><span class="line"> tmp.push_back(pos);</span><br><span class="line"> t.pushdown(pos);</span><br><span class="line"> dfs(t.ls[pos]);</span><br><span class="line"> dfs(t.rs[pos]);</span><br><span class="line"> t.ls[pos] = <span class="number">0</span>;</span><br><span class="line"> t.rs[pos] = <span class="number">0</span>;</span><br><span class="line"> t.key[pos] = rnd();</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> n = <span class="built_in">read</span>();</span><br><span class="line"> <span class="function"><span class="built_in">vector</span><node> <span class="title">p</span><span class="params">(n)</span></span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i < n; i++)</span><br><span class="line"> {</span><br><span class="line"> p[i].c = <span class="built_in">read</span>(), p[i].q = <span class="built_in">read</span>();</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">int</span> m = <span class="built_in">read</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><br><span class="line"> t.insert(<span class="built_in">read</span>(), i);</span><br><span class="line"> }</span><br><span class="line"> sort(p.<span class="built_in">begin</span>(), p.<span class="built_in">end</span>(), [](node a, node b) { <span class="keyword">return</span> a.q == b.q ? a.c < b.c : a.q > b.q; });</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">auto</span> now : p)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> x, y, z;</span><br><span class="line"> <span class="keyword">int</span> c = now.c;</span><br><span class="line"> <span class="comment">// cout << t.val[1] << endl;</span></span><br><span class="line"> t.split(t.root, c - <span class="number">1</span>, x, y);</span><br><span class="line"> t.split(y, <span class="number">2</span> * c, y, z);</span><br><span class="line"> t.addtag(z, <span class="number">1</span>, c);</span><br><span class="line"> t.addtag(y, <span class="number">1</span>, c);</span><br><span class="line"> tmp.<span class="built_in">clear</span>();</span><br><span class="line"> <span class="comment">//cout << c << " " << y << endl;</span></span><br><span class="line"> dfs(y);</span><br><span class="line"></span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i : tmp)</span><br><span class="line"> {</span><br><span class="line"> <span class="comment">//cout << t.val[i] << " " << i << " " << x << endl;</span></span><br><span class="line"> t._insert(x, i);</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> t.root = t.merge(x, z);</span><br><span class="line"> }</span><br><span class="line"> tmp.<span class="built_in">clear</span>();</span><br><span class="line"> dfs(t.root);</span><br><span class="line"> <span class="function"><span class="built_in">vector</span><<span class="keyword">int</span>> <span class="title">ans</span><span class="params">(m + <span class="number">1</span>)</span></span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i : tmp)</span><br><span class="line"> {</span><br><span class="line"> ans[t.id[i]] = t.sum[i];</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="built_in">printf</span>(<span class="string">"%d "</span>, ans[i]);</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"\n"</span>);</span><br><span class="line">}</span><br></pre></td></tr></table></figure> </details>]]></content>
<summary type="html">
<p>有 $n$ 种T恤，每种有价格 $c_i$和品质 $q_i$ 。</p>
<p>有 $m$ 个人要买 $T$ 恤，第 $i$ 个人有$v_i$元，每人每次都会买一件能买得起的 $q_i$最大的$T$恤。一个人只能买一种T恤一件，所有人之间都是独立的。</p>
<p>问最后每个人买了多少件 $T$ 恤？如果有多个 $q_i$ 最大的T恤，会从价格低的开始买。</p>
</summary>
<category term="平衡树" scheme="http://yoursite.com/tags/%E5%B9%B3%E8%A1%A1%E6%A0%91/"/>
</entry>
<entry>
<title>SP11470 TTM - To the moon</title>
<link href="http://yoursite.com/2020/11/01/SP11470/"/>
<id>http://yoursite.com/2020/11/01/SP11470/</id>
<published>2020-11-01T02:47:00.000Z</published>
<updated>2020-11-04T05:10:09.000Z</updated>
<content type="html"><![CDATA[<p>可持续化线段树的区间加减。</p><a id="more"></a><p>如果用<strong>lazy</strong>标记的化，发现两个版本的线段树共用的节点不能修改值。</p><p>这时候标记永久化就上场了。</p><p>标记永久化既不需要下传标记，也不需要通过子节点更新自己。</p><ul><li>对于更新，更新一路上的<strong>值</strong>。然后在最底层完全覆盖的节点上打上标记。</li><li>对于查询，更新一路的<strong>标记</strong>,最后加上最底层的值。</li></ul><p>注意多思考细节就好了。</p><details> <summary>代码</summary><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><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><span class="line">111</span><br><span class="line">112</span><br><span class="line">113</span><br><span class="line">114</span><br><span class="line">115</span><br><span class="line">116</span><br><span class="line">117</span><br></pre></td><td class="code"><pre><span class="line"></span><br><span class="line"></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><bits/stdc++.h></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line"><span class="keyword">typedef</span> <span class="keyword">long</span> <span class="keyword">long</span> ll;</span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> pii pair<span class="meta-string"><int, int></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> mk make_pair</span></span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> N = <span class="number">1e5</span> + <span class="number">10</span>;</span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> mod = <span class="number">1e9</span> + <span class="number">7</span>;</span><br><span class="line"></span><br><span class="line"><span class="keyword">int</span> a[N];</span><br><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">SustainedTree</span></span></span><br><span class="line"><span class="class">{</span></span><br><span class="line"> <span class="keyword">int</span> scnt;</span><br><span class="line"> ll sum[N << <span class="number">5</span>], tag[N << <span class="number">5</span>];</span><br><span class="line"> <span class="keyword">int</span> ls[N << <span class="number">5</span>], rs[N << <span class="number">5</span>];</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> &pos, <span class="keyword">int</span> l, <span class="keyword">int</span> r)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> pos = ++scnt;</span><br><span class="line"> <span class="keyword">if</span> (l == r)</span><br><span class="line"> {</span><br><span class="line"> sum[pos] = a[l];</span><br><span class="line"> <span class="keyword">return</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">int</span> mid = (l + r) >> <span class="number">1</span>;</span><br><span class="line"> build(ls[pos], l, mid), build(rs[pos], mid + <span class="number">1</span>, r);</span><br><span class="line"> sum[pos] = sum[ls[pos]] + sum[rs[pos]];</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">update</span><span class="params">(<span class="keyword">int</span> &pos, <span class="keyword">int</span> pre, <span class="keyword">int</span> ql, <span class="keyword">int</span> qr, <span class="keyword">int</span> v, <span class="keyword">int</span> l, <span class="keyword">int</span> r)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> pos = ++scnt;</span><br><span class="line"> sum[pos] = sum[pre], tag[pos] = tag[pre], ls[pos] = ls[pre], rs[pos] = rs[pre];</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (ql <= l && r <= qr)</span><br><span class="line"> {</span><br><span class="line"> tag[pos] += v;</span><br><span class="line"> <span class="keyword">return</span>;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> sum[pos] += <span class="number">1l</span>l * v * (<span class="built_in">min</span>(qr, r) - <span class="built_in">max</span>(ql, l) + <span class="number">1</span>);</span><br><span class="line"></span><br><span class="line"> <span class="keyword">int</span> mid = (l + r) >> <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">if</span> (ql <= mid)</span><br><span class="line"> update(ls[pos], ls[pre], ql, qr, v, l, mid);</span><br><span class="line"> <span class="keyword">if</span> (qr > mid)</span><br><span class="line"> update(rs[pos], rs[pre], ql, qr, v, mid + <span class="number">1</span>, r);</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">query</span><span class="params">(<span class="keyword">int</span> pos, <span class="keyword">int</span> ql, <span class="keyword">int</span> qr, <span class="keyword">int</span> l, <span class="keyword">int</span> r, ll &res)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> res += <span class="number">1l</span>l * tag[pos] * (<span class="built_in">min</span>(qr, r) - <span class="built_in">max</span>(ql, l) + <span class="number">1</span>);</span><br><span class="line"> <span class="keyword">if</span> (ql <= l && r <= qr)</span><br><span class="line"> {</span><br><span class="line"></span><br><span class="line"> res += sum[pos];</span><br><span class="line"> <span class="keyword">return</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">int</span> mid = (l + r) >> <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">if</span> (ql <= mid)</span><br><span class="line"> query(ls[pos], ql, qr, l, mid, res);</span><br><span class="line"> <span class="keyword">if</span> (qr > mid)</span><br><span class="line"> query(rs[pos], ql, qr, mid + <span class="number">1</span>, r, res);</span><br><span class="line"> }</span><br><span class="line">} t;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">read</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> x = <span class="number">0</span>, f = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">char</span> c = getchar();</span><br><span class="line"> <span class="keyword">while</span> (c < <span class="string">'0'</span> || c > <span class="string">'9'</span>)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (c == <span class="string">'-'</span>)</span><br><span class="line"> f = <span class="number">-1</span>;</span><br><span class="line"> c = getchar();</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">while</span> (c >= <span class="string">'0'</span> && c <= <span class="string">'9'</span>)</span><br><span class="line"> x = (x << <span class="number">1</span>) + (x << <span class="number">3</span>) + c - <span class="string">'0'</span>, c = getchar();</span><br><span class="line"> <span class="keyword">return</span> x * f;</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="keyword">int</span> rt[N];</span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> n = <span class="built_in">read</span>(), m = <span class="built_in">read</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"> a[i] = <span class="built_in">read</span>();</span><br><span class="line"> t.build(rt[<span class="number">0</span>], <span class="number">1</span>, n);</span><br><span class="line"> <span class="keyword">int</span> now = <span class="number">0</span>;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">1</span>; i <= m; i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">char</span> s[<span class="number">5</span>];</span><br><span class="line"> <span class="built_in">scanf</span>(<span class="string">"%s"</span>, s);</span><br><span class="line"> <span class="keyword">if</span> (s[<span class="number">0</span>] == <span class="string">'B'</span>)</span><br><span class="line"> now = <span class="built_in">read</span>();</span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">if</span> (s[<span class="number">0</span>] == <span class="string">'C'</span>)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> l = <span class="built_in">read</span>(), r = <span class="built_in">read</span>(), d = <span class="built_in">read</span>();</span><br><span class="line"> t.update(rt[now + <span class="number">1</span>], rt[now], l, r, d, <span class="number">1</span>, n);</span><br><span class="line"> now++;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">if</span> (s[<span class="number">0</span>] == <span class="string">'Q'</span>)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> l = <span class="built_in">read</span>(), r = <span class="built_in">read</span>();</span><br><span class="line"> ll res = <span class="number">0</span>;</span><br><span class="line"> t.query(rt[now], l, r, <span class="number">1</span>, n, res);</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%lld\n"</span>, res);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">if</span> (s[<span class="number">0</span>] == <span class="string">'H'</span>)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> l = <span class="built_in">read</span>(), r = <span class="built_in">read</span>(), z = <span class="built_in">read</span>();</span><br><span class="line"> ll res = <span class="number">0</span>;</span><br><span class="line"> t.query(rt[z], l, r, <span class="number">1</span>, n, res);</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%lld\n"</span>, res);</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure> </details>]]></content>
<summary type="html">
<p>可持续化线段树的区间加减。</p>
</summary>
<category term="标记永久化" scheme="http://yoursite.com/tags/%E6%A0%87%E8%AE%B0%E6%B0%B8%E4%B9%85%E5%8C%96/"/>
</entry>
<entry>
<title>CF1430F Realistic Gameplay</title>
<link href="http://yoursite.com/2020/10/31/CF1430F/"/>
<id>http://yoursite.com/2020/10/31/CF1430F/</id>
<published>2020-10-31T02:47:00.000Z</published>
<updated>2020-11-04T05:54:53.000Z</updated>
<content type="html"><![CDATA[<p>有$n$波怪物，你有一把枪，枪的弹夹量为$k$，第$i,[l_i,r_i]$波怪物数量为$a_i$，使用子弹不费时间，但是你每次换弹都需要将弹夹（包括里面的子弹）扔掉，在尽量保证通关的情况下，需要的最多的子弹数为多少。</p><a id="more"></a><p>有几点需要明确:</p><ul><li>如果怪物之间有多出的时间，那么我可以选择换弹来达到最优的状态。</li><li>对于一波怪物你最多可以打出=$起始子弹+k(r[i]-l[i])$。</li><li>最优一定是一次不换弹，我们只需要减少换弹次数即可。</li><li>因为后面如果特别紧，这个时候就必须换，这样也可让后面更轻松。</li></ul><p>我们就可以预处理出每波进场需要的最少的子弹。考虑连在一起的怪物波，直接从后往前$dp$即可。(把后一次需要的子弹当成多出的怪物)。</p><p>然后就是贪心的要换子弹，就可以换子弹。</p><ul><li>当我带着$tmp$子弹进场。在我不浪费子弹并且可以杀完所有怪物的情况下，我最后剩余的子弹应该是$(k - (a[i] - tmp) \mod k) \mod k$</li></ul><p>然后贪心的模拟一遍即可。（连续部分可以选择合并起来模拟，也可以不合并）</p><details> <summary>代码</summary><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><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></pre></td><td class="code"><pre><span class="line"></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><bits/stdc++.h></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line"><span class="keyword">typedef</span> <span class="keyword">long</span> <span class="keyword">long</span> ll;</span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> pii pair<span class="meta-string"><int, int></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> mk make_pair</span></span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> N = <span class="number">1e6</span> + <span class="number">10</span>;</span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> mod = <span class="number">1e9</span> + <span class="number">7</span>;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">read</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> x = <span class="number">0</span>, f = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">char</span> c = getchar();</span><br><span class="line"> <span class="keyword">while</span> (c < <span class="string">'0'</span> || c > <span class="string">'9'</span>)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (c == <span class="string">'-'</span>)</span><br><span class="line"> f = <span class="number">-1</span>;</span><br><span class="line"> c = getchar();</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">while</span> (c >= <span class="string">'0'</span> && c <= <span class="string">'9'</span>)</span><br><span class="line"> x = (x << <span class="number">1</span>) + (x << <span class="number">3</span>) + c - <span class="string">'0'</span>, c = getchar();</span><br><span class="line"> <span class="keyword">return</span> x * f;</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> n = <span class="built_in">read</span>(), k = <span class="built_in">read</span>();</span><br><span class="line"> vector<ll> l(n + 1), r(n + 1), a(n + 1), f(n + 1);</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"> l[i] = <span class="built_in">read</span>(), r[i] = <span class="built_in">read</span>(), a[i] = <span class="built_in">read</span>();</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = n; i >= <span class="number">1</span>; i--)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (r[i] == l[i + <span class="number">1</span>])</span><br><span class="line"> {</span><br><span class="line"> f[i] = <span class="built_in">max</span>(<span class="number">0l</span>l, f[i + <span class="number">1</span>] + a[i] - (r[i] - l[i]) * k);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> {</span><br><span class="line"> f[i] = <span class="built_in">max</span>(<span class="number">0l</span>l, a[i] - (r[i] - l[i]) * k);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span> (f[i] > k)</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">puts</span>(<span class="string">"-1"</span>);</span><br><span class="line"> }</span><br><span class="line"> ll tmp = k, 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><br><span class="line"> ans += a[i];</span><br><span class="line"> <span class="keyword">if</span> (f[i] > tmp)</span><br><span class="line"> {</span><br><span class="line"> ans += tmp;</span><br><span class="line"> tmp = k;</span><br><span class="line"> }</span><br><span class="line"> tmp = (k - (a[i] - tmp) % k) % k;</span><br><span class="line"> }</span><br><span class="line"> <span class="built_in">cout</span> << ans << <span class="built_in">endl</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure> </details>]]></content>
<summary type="html">
<p>有$n$波怪物，你有一把枪，枪的弹夹量为$k$，第$i,[l_i,r_i]$波怪物数量为$a_i$，使用子弹不费时间，但是你每次换弹都需要将弹夹（包括里面的子弹）扔掉，在尽量保证通关的情况下，需要的最多的子弹数为多少。</p>
</summary>
<category term="思维" scheme="http://yoursite.com/tags/%E6%80%9D%E7%BB%B4/"/>
</entry>
<entry>
<title>2019 ICPC南昌 J.Summon</title>
<link href="http://yoursite.com/2020/10/30/ICPCNCJ/"/>
<id>http://yoursite.com/2020/10/30/ICPCNCJ/</id>
<published>2020-10-30T02:47:00.000Z</published>
<updated>2020-11-04T05:21:54.000Z</updated>
<content type="html"><![CDATA[<p>在环上涂颜色，不能出现给定颜色的顺时针顺序。（长度为=4)。<br><a id="more"></a></p><script type="math/tex; mode=display">\frac{1}{|G|}\sum_{f\in G}m^{m(f)}</script><p>变换一下就是</p><script type="math/tex; mode=display"> \frac{1}{n}\sum_{d|n}\phi(\frac{n}{d})f(d)</script><p>然后$f(d)$就表示，长度$d$的环符合 要求有几个（不用考虑选择）<br>刚开始觉得这题，用快速幂挺炫酷的，发现就是套路。转化成从某个状态走$d$步到某个状态的步数种类。</p><p>跟$POJ2888$一摸一样。</p><p>变成四进制。然后矩阵快速幂没了。</p><ul><li>注意预处理可以转移的进制。</li><li>常数优化。</li></ul><details> <summary>代码</summary><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><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><span class="line">111</span><br><span class="line">112</span><br><span class="line">113</span><br><span class="line">114</span><br><span class="line">115</span><br><span class="line">116</span><br><span class="line">117</span><br><span class="line">118</span><br><span class="line">119</span><br><span class="line">120</span><br><span class="line">121</span><br><span class="line">122</span><br><span class="line">123</span><br><span class="line">124</span><br><span class="line">125</span><br><span class="line">126</span><br><span class="line">127</span><br><span class="line">128</span><br><span class="line">129</span><br><span class="line">130</span><br><span class="line">131</span><br><span class="line">132</span><br><span class="line">133</span><br><span class="line">134</span><br><span class="line">135</span><br><span class="line">136</span><br><span class="line">137</span><br><span class="line">138</span><br><span class="line">139</span><br><span class="line">140</span><br><span class="line">141</span><br><span class="line">142</span><br><span class="line">143</span><br><span class="line">144</span><br><span class="line">145</span><br><span class="line">146</span><br><span class="line">147</span><br><span class="line">148</span><br><span class="line">149</span><br><span class="line">150</span><br><span class="line">151</span><br><span class="line">152</span><br><span class="line">153</span><br><span class="line">154</span><br><span class="line">155</span><br><span class="line">156</span><br><span class="line">157</span><br><span class="line">158</span><br><span class="line">159</span><br><span class="line">160</span><br><span class="line">161</span><br><span class="line">162</span><br><span class="line">163</span><br><span class="line">164</span><br><span class="line">165</span><br><span class="line">166</span><br><span class="line">167</span><br><span class="line">168</span><br><span class="line">169</span><br><span class="line">170</span><br><span class="line">171</span><br><span class="line">172</span><br><span class="line">173</span><br><span class="line">174</span><br><span class="line">175</span><br><span class="line">176</span><br><span class="line">177</span><br><span class="line">178</span><br><span class="line">179</span><br><span class="line">180</span><br><span class="line">181</span><br><span class="line">182</span><br><span class="line">183</span><br><span class="line">184</span><br><span class="line">185</span><br><span class="line">186</span><br><span class="line">187</span><br><span class="line">188</span><br><span class="line">189</span><br><span class="line">190</span><br><span class="line">191</span><br><span class="line">192</span><br><span class="line">193</span><br><span class="line">194</span><br><span class="line">195</span><br><span class="line">196</span><br><span class="line">197</span><br><span class="line">198</span><br><span class="line">199</span><br><span class="line">200</span><br><span class="line">201</span><br><span class="line">202</span><br><span class="line">203</span><br><span class="line">204</span><br><span class="line">205</span><br><span class="line">206</span><br><span class="line">207</span><br><span class="line">208</span><br><span class="line">209</span><br><span class="line">210</span><br><span class="line">211</span><br><span class="line">212</span><br><span class="line">213</span><br><span class="line">214</span><br><span class="line">215</span><br><span class="line">216</span><br><span class="line">217</span><br><span class="line">218</span><br></pre></td><td class="code"><pre><span class="line"></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><bits/stdc++.h></span></span></span><br><span class="line"></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line"><span class="keyword">typedef</span> <span class="keyword">long</span> <span class="keyword">long</span> ll;</span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> pii pair<span class="meta-string"><int, int></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> mk make_pair</span></span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> N = <span class="number">1e3</span> + <span class="number">10</span>;</span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> mod = <span class="number">998244353</span>;</span><br><span class="line"></span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> Z = <span class="number">64</span>;</span><br><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">Matrix</span></span></span><br><span class="line"><span class="class">{</span></span><br><span class="line"></span><br><span class="line"> <span class="keyword">int</span> row, col;</span><br><span class="line"> <span class="keyword">int</span> s[Z][Z];</span><br><span class="line"> Matrix()</span><br><span class="line"> { <span class="comment">//无参数构造函数</span></span><br><span class="line"> row = col = <span class="number">0</span>;</span><br><span class="line"> <span class="built_in">memset</span>(s, <span class="number">0</span>, <span class="keyword">sizeof</span>(s));</span><br><span class="line"> }</span><br><span class="line"> Matrix(<span class="keyword">int</span> n, <span class="keyword">int</span> m, <span class="keyword">int</span> x = <span class="number">0</span>) : row(n), col(m)</span><br><span class="line"> {</span><br><span class="line"> <span class="built_in">memset</span>(s, <span class="number">0</span>, <span class="keyword">sizeof</span>(s));</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"> s[i][j] = x;</span><br><span class="line"> } <span class="comment">//重载构造函数</span></span><br><span class="line"></span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">printp</span><span class="params">()</span></span></span><br><span class="line"><span class="function"> </span>{ <span class="comment">//输出一个矩阵</span></span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i < row; i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> j = <span class="number">0</span>; j < col; j++)</span><br><span class="line"> <span class="built_in">cout</span> << s[i][j] << <span class="string">" "</span>;</span><br><span class="line"> <span class="built_in">cout</span> << <span class="built_in">endl</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="comment">// void transpose()</span></span><br><span class="line"> <span class="comment">// { //矩阵的转置</span></span><br><span class="line"> <span class="comment">// Matrix y(col, row);</span></span><br><span class="line"> <span class="comment">// for (int i = 1; i <= row; i++)</span></span><br><span class="line"> <span class="comment">// {</span></span><br><span class="line"> <span class="comment">// for (int j = 1; j <= col; j++)</span></span><br><span class="line"> <span class="comment">// y.s[j][i] = s[i][j];</span></span><br><span class="line"> <span class="comment">// }</span></span><br><span class="line"> <span class="comment">// *this = y;</span></span><br><span class="line"> <span class="comment">// }</span></span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">identity</span><span class="params">()</span></span></span><br><span class="line"><span class="function"> </span>{ <span class="comment">//将该矩阵改成单位矩阵</span></span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i < row; i++)</span><br><span class="line"> s[i][i] = <span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="comment">// Matrix operator+(Matrix x)</span></span><br><span class="line"> <span class="comment">// { //重载+</span></span><br><span class="line"> <span class="comment">// Matrix y(row, col);</span></span><br><span class="line"> <span class="comment">// for (int i = 0; i <row; i++)</span></span><br><span class="line"> <span class="comment">// {</span></span><br><span class="line"> <span class="comment">// for (int j = 0; j < col; j++)</span></span><br><span class="line"> <span class="comment">// y.s[i][j] += s[i][j] + x.s[i][j], y.s[i][j] %= mod;</span></span><br><span class="line"> <span class="comment">// }</span></span><br><span class="line"> <span class="comment">// return y;</span></span><br><span class="line"> <span class="comment">// }</span></span><br><span class="line"> Matrix <span class="keyword">operator</span>*(Matrix x)</span><br><span class="line"> { <span class="comment">//重载*</span></span><br><span class="line"> <span class="function">Matrix <span class="title">y</span><span class="params">(row, x.col)</span></span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i < row; i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> j = <span class="number">0</span>; j < x.col; j++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> k = <span class="number">0</span>; k < col; k++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (!s[i][k] || !x.s[k][j])</span><br><span class="line"> <span class="keyword">continue</span>;</span><br><span class="line"> y.s[i][j] = (y.s[i][j] + <span class="number">1l</span>l * s[i][k] * x.s[k][j] % mod) % mod;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> y;</span><br><span class="line"> }</span><br><span class="line"> Matrix <span class="keyword">operator</span>*=(Matrix x)</span><br><span class="line"> { <span class="comment">//重载*=</span></span><br><span class="line"> <span class="keyword">return</span> *<span class="keyword">this</span> = *<span class="keyword">this</span> * x;</span><br><span class="line"> }</span><br><span class="line">} z[<span class="number">40</span>];</span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">qpow</span><span class="params">(<span class="keyword">int</span> a, <span class="keyword">int</span> x, <span class="keyword">int</span> mo)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> res = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">while</span> (x)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (x & <span class="number">1</span>)</span><br><span class="line"> res = <span class="number">1l</span>l * res * a % mod;</span><br><span class="line"> a = <span class="number">1l</span>l * a * a % mod;</span><br><span class="line"> x >>= <span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> res;</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="function">Matrix <span class="title">qpow</span><span class="params">(<span class="keyword">int</span> x)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="function">Matrix <span class="title">res</span><span class="params">(z[<span class="number">0</span>].row, z[<span class="number">0</span>].col)</span></span>;</span><br><span class="line"> res.identity();</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>; (<span class="number">1</span> << i) <= x; i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> ((<span class="number">1</span> << i) & x)</span><br><span class="line"> {</span><br><span class="line"> res = res * z[i];</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="keyword">return</span> res;</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="keyword">namespace</span> Polya</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">mult</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="function"> </span>{</span><br><span class="line"> <span class="keyword">return</span> <span class="number">1l</span>l * x * y % mod;</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">int</span> <span class="title">calc</span><span class="params">(<span class="keyword">int</span> x)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="comment">// dt.printp();</span></span><br><span class="line"> Matrix res = qpow(x);</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">0</span>; i < <span class="number">64</span>; i++)</span><br><span class="line"> ans = (ans + res.s[i][i]) % mod;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">return</span> ans;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">int</span> p[N], e[N];</span><br><span class="line"> <span class="keyword">int</span> cnt = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">int</span> ans = <span class="number">0</span>;</span><br><span class="line"> <span class="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> now, <span class="keyword">int</span> phi, <span class="keyword">int</span> n)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">if</span> (x > cnt)</span><br><span class="line"> {</span><br><span class="line"> ans = (ans + mult(phi % mod, calc(n / now))) % mod;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">return</span>;</span><br><span class="line"> }</span><br><span class="line"> dfs(x + <span class="number">1</span>, now, phi, n);</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">1</span>; i <= e[x]; i++)</span><br><span class="line"> {</span><br><span class="line"> phi *= (p[x] - (i == <span class="number">1</span>));</span><br><span class="line"> now *= p[x];</span><br><span class="line"> dfs(x + <span class="number">1</span>, now, phi, n);</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">solve</span><span class="params">(<span class="keyword">int</span> n)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> cnt = <span class="number">0</span>;</span><br><span class="line"> ans = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">int</span> tmp = n;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">2</span>; i * i <= n; i++)</span><br><span class="line"> <span class="keyword">if</span> (n % i == <span class="number">0</span>)</span><br><span class="line"> {</span><br><span class="line"> p[++cnt] = i;</span><br><span class="line"> e[cnt] = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">while</span> (n % i == <span class="number">0</span>)</span><br><span class="line"> {</span><br><span class="line"> n /= i;</span><br><span class="line"> e[cnt]++;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span> (n > <span class="number">1</span>)</span><br><span class="line"> {</span><br><span class="line"> p[++cnt] = n;</span><br><span class="line"> e[cnt] = <span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"> dfs(<span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>, tmp);</span><br><span class="line"> <span class="comment">//cout << ans << endl;</span></span><br><span class="line"> <span class="keyword">return</span> <span class="number">1l</span>l * ans * qpow(tmp % mod, mod - <span class="number">2</span>, mod) % mod;</span><br><span class="line"> }</span><br><span class="line">} <span class="comment">// namespace Polya</span></span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">read</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> x = <span class="number">0</span>, f = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">char</span> c = getchar();</span><br><span class="line"> <span class="keyword">while</span> (c < <span class="string">'0'</span> || c > <span class="string">'9'</span>)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (c == <span class="string">'-'</span>)</span><br><span class="line"> f = <span class="number">-1</span>;</span><br><span class="line"> c = getchar();</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">while</span> (c >= <span class="string">'0'</span> && c <= <span class="string">'9'</span>)</span><br><span class="line"> x = (x << <span class="number">1</span>) + (x << <span class="number">3</span>) + c - <span class="string">'0'</span>, c = getchar();</span><br><span class="line"> <span class="keyword">return</span> x * f;</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> n = <span class="built_in">read</span>(), m = <span class="built_in">read</span>();</span><br><span class="line"> <span class="function">Matrix <span class="title">tmp</span><span class="params">(<span class="number">64</span>, <span class="number">64</span>, <span class="number">0</span>)</span></span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i < <span class="number">64</span>; 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">64</span>; j++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (((j << <span class="number">2</span>) & <span class="number">63</span>) == ((i >> <span class="number">2</span>) << <span class="number">2</span>))</span><br><span class="line"> tmp.s[i][j] = <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">1</span>; i <= m; i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="function"><span class="built_in">vector</span><<span class="keyword">int</span>> <span class="title">a</span><span class="params">(<span class="number">4</span>)</span></span>;</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">4</span>; j++)</span><br><span class="line"> {</span><br><span class="line"> a[j] = <span class="built_in">read</span>();</span><br><span class="line"> }</span><br><span class="line"> tmp.s[a[<span class="number">0</span>] + (a[<span class="number">1</span>] << <span class="number">2</span>) + (a[<span class="number">2</span>] << <span class="number">4</span>)][a[<span class="number">1</span>] + (a[<span class="number">2</span>] << <span class="number">2</span>) + (a[<span class="number">3</span>] << <span class="number">4</span>)] = <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> z[<span class="number">0</span>] = tmp;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">1</span>; (<span class="number">1</span> << i) <= n; i++)</span><br><span class="line"> z[i] = z[i - <span class="number">1</span>] * z[i - <span class="number">1</span>];</span><br><span class="line"></span><br><span class="line"> <span class="built_in">cout</span> << Polya::solve(n) << <span class="built_in">endl</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure> </details>]]></content>
<summary type="html">
<p>在环上涂颜色，不能出现给定颜色的顺时针顺序。（长度为=4)。<br>
</summary>
<category term="置换群" scheme="http://yoursite.com/tags/%E7%BD%AE%E6%8D%A2%E7%BE%A4/"/>
</entry>
<entry>
<title>P3307 [SDOI2013]项链</title>
<link href="http://yoursite.com/2020/10/30/P3307/"/>
<id>http://yoursite.com/2020/10/30/P3307/</id>
<published>2020-10-30T02:47:00.000Z</published>
<updated>2020-11-04T05:10:09.000Z</updated>
<content type="html"><![CDATA[<ul><li><p>珠子=正三菱柱,三个面上面的数字$x$,必须满足$x\in [1,a]$，且珠子上面的数字的最大公约数要恰好为1。三棱柱可以选择翻转.</p></li><li><p>相邻的两个珠子必须不同。</p></li><li><p>两串项链如果能够经过旋转变成一样的，那么这两串项链就是相同的</p></li></ul><p>$n<=10^{14}，a<=10^7，T<=10$<br><a id="more"></a></p><p>好题！</p><p>首先算珠子种类，$s3$表示$3$个$\gcd=1$的个数，同理$s2,s1$。</p><p>$Burnside引理$</p><script type="math/tex; mode=display"> res=\frac{1}{3+3}(s3+3s2+2s1)</script><hr><p>然后之后$Polya$里的$m=res$</p><script type="math/tex; mode=display"> \frac{1}{n}\sum_{d|n}\varphi(\frac{n}{d})f(d)</script><p>这里矩阵快速幂就太大了。</p><ul><li><p>如果$i-1$与$1$不同则$f(i)=f(i-1)(m-2)$</p></li><li><p>如果$i-1$与$1$相同则$i-2$与$1$不同。 $f(i)=f(i-2)(m-1)$</p></li></ul><p>$x^2-(m-1)x-(m-2)=(x+1)(x-(m-1))=0$</p><p>$f(i)=a(-1)^i+b(m-1)^i,f(1)=0,f(2)=m(m-1)$</p><p>$f(1)$由于$1$与$1$相邻。所以为$0$。</p><script type="math/tex; mode=display">f(i)=(m-1)^i+(-1)^i(m-1)</script><hr><p>然后$dfs$一遍搜因数并且一遍处理欧拉函数。</p><p>BZOJ上的数据经过加强， n 可能是 $10^9+7$ 的倍数（没有逆元），而最后要除以 $n$ ，所以需要一些特殊的技巧。</p><ul><li>$MOD=(1e9+7)^2$</li><li>此时要用快速乘</li><li>答案等于在模 $10^9+7$ 意义下 $\frac{sum}{1e9+7}$ 除以 $\frac{n}{1e9+7}$ 的结果。</li><li>需要$exgcd$求$6$在$(1e9+7)^2$的逆元。</li></ul><details> <summary>代码</summary><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><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><span class="line">111</span><br><span class="line">112</span><br><span class="line">113</span><br><span class="line">114</span><br><span class="line">115</span><br><span class="line">116</span><br><span class="line">117</span><br><span class="line">118</span><br><span class="line">119</span><br><span class="line">120</span><br><span class="line">121</span><br><span class="line">122</span><br><span class="line">123</span><br><span class="line">124</span><br><span class="line">125</span><br><span class="line">126</span><br><span class="line">127</span><br><span class="line">128</span><br><span class="line">129</span><br><span class="line">130</span><br><span class="line">131</span><br><span class="line">132</span><br><span class="line">133</span><br><span class="line">134</span><br><span class="line">135</span><br><span class="line">136</span><br><span class="line">137</span><br><span class="line">138</span><br><span class="line">139</span><br><span class="line">140</span><br><span class="line">141</span><br><span class="line">142</span><br><span class="line">143</span><br><span class="line">144</span><br><span class="line">145</span><br><span class="line">146</span><br><span class="line">147</span><br><span class="line">148</span><br><span class="line">149</span><br><span class="line">150</span><br><span class="line">151</span><br><span class="line">152</span><br><span class="line">153</span><br></pre></td><td class="code"><pre><span class="line"></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><bits/stdc++.h></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line"><span class="keyword">typedef</span> <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="keyword">long</span> ll;</span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> pii pair<span class="meta-string"><ll, ll></span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> mk make_pair</span></span><br><span class="line"><span class="keyword">const</span> ll N = <span class="number">1e7</span> + <span class="number">10</span>;</span><br><span class="line"><span class="keyword">const</span> ll MOD = <span class="number">1000000007l</span>l;</span><br><span class="line"><span class="keyword">const</span> ll Inv61 = <span class="number">166666668l</span>l;</span><br><span class="line"><span class="keyword">const</span> ll Inv62 = <span class="number">833333345000000041l</span>l;</span><br><span class="line"></span><br><span class="line">ll mod;</span><br><span class="line">ll Inv6;</span><br><span class="line">ll O;</span><br><span class="line"><span class="function"><span class="keyword">inline</span> ll <span class="title">mult</span><span class="params">(ll x, ll y)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">if</span> (!O)</span><br><span class="line"> <span class="keyword">return</span> x * y % mod;</span><br><span class="line"> <span class="keyword">return</span> (x * y - (ll)((<span class="keyword">long</span> <span class="keyword">double</span>)x / mod * y) * mod + mod) % mod;</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="keyword">int</span> pcnt, pr[N], npr[N];</span><br><span class="line"><span class="keyword">int</span> mu[N], usum[N];</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">Prime_init</span><span class="params">(ll n)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> npr[<span class="number">1</span>] = <span class="number">1</span>;</span><br><span class="line"> mu[<span class="number">1</span>] = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">for</span> (ll i = <span class="number">1</span>; i <= n; i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (!npr[i])</span><br><span class="line"> pr[++pcnt] = i, mu[i] = <span class="number">-1</span>;</span><br><span class="line"> <span class="keyword">for</span> (ll j = <span class="number">1</span>; j <= pcnt && pr[j] * i <= n; j++)</span><br><span class="line"> {</span><br><span class="line"> npr[pr[j] * i] = <span class="number">1</span>;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (i % pr[j] == <span class="number">0</span>)</span><br><span class="line"> {</span><br><span class="line"> mu[pr[j] * i] = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">break</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> {</span><br><span class="line"> mu[pr[j] * i] = mu[i] * (<span class="number">-1</span>);</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span> (ll i = <span class="number">1</span>; i <= n; i++)</span><br><span class="line"> {</span><br><span class="line"> usum[i] = usum[i - <span class="number">1</span>] + mu[i];</span><br><span class="line"> }</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line">ll k;</span><br><span class="line">ll p[<span class="number">100</span>], e[<span class="number">100</span>];</span><br><span class="line">ll cnt;</span><br><span class="line">ll ans;</span><br><span class="line"><span class="function">ll <span class="title">qpow</span><span class="params">(ll a, ll x)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> ll res = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">while</span> (x)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (x & <span class="number">1</span>)</span><br><span class="line"> res = mult(res, a);</span><br><span class="line"> a = mult(a, a);</span><br><span class="line"> x >>= <span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> res;</span><br><span class="line">}</span><br><span class="line"><span class="function">ll <span class="title">calc</span><span class="params">(ll x)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">return</span> (qpow(k - <span class="number">1</span>, x) + mult((x & <span class="number">1</span> ? mod - <span class="number">1</span> : <span class="number">1</span>), (k - <span class="number">1</span>))) % mod;</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">dfs</span><span class="params">(ll x, ll now, ll phi, ll n)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">if</span> (x > cnt)</span><br><span class="line"> {</span><br><span class="line"> ans = (ans + mult(phi % mod, calc(n / now))) % mod;</span><br><span class="line"> <span class="comment">//cout << phi << " " << calc(n / now) << endl;</span></span><br><span class="line"> <span class="keyword">return</span>;</span><br><span class="line"> }</span><br><span class="line"> dfs(x + <span class="number">1</span>, now, phi, n);</span><br><span class="line"> <span class="keyword">for</span> (ll i = <span class="number">1</span>; i <= e[x]; i++)</span><br><span class="line"> {</span><br><span class="line"> phi *= (p[x] - (i == <span class="number">1</span>));</span><br><span class="line"> now *= p[x];</span><br><span class="line"> dfs(x + <span class="number">1</span>, now, phi, n);</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">solve</span><span class="params">(ll n)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> cnt = <span class="number">0</span>;</span><br><span class="line"> ll tmp = n;</span><br><span class="line"> <span class="keyword">for</span> (ll i = <span class="number">2</span>; i * i <= n; i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (n % i == <span class="number">0</span>)</span><br><span class="line"> {</span><br><span class="line"> ll o = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">while</span> (n % i == <span class="number">0</span>)</span><br><span class="line"> {</span><br><span class="line"> n /= i;</span><br><span class="line"> o++;</span><br><span class="line"> }</span><br><span class="line"> p[++cnt] = i;</span><br><span class="line"> e[cnt] = o;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span> (n > <span class="number">1</span>)</span><br><span class="line"> {</span><br><span class="line"> p[++cnt] = n;</span><br><span class="line"> e[cnt] = <span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"> dfs(<span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>, tmp);</span><br><span class="line">}</span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">init</span><span class="params">(ll n)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> k = <span class="number">2</span>;</span><br><span class="line"> <span class="keyword">for</span> (ll i = <span class="number">1</span>, j; i <= n; i = j + <span class="number">1</span>)</span><br><span class="line"> {</span><br><span class="line"> j = n / (n / i);</span><br><span class="line"> k = (k + mult(mult(mult(n / i, n / i), n / i + <span class="number">3</span>), (usum[j] - usum[i - <span class="number">1</span>] + mod) % mod)) % mod;</span><br><span class="line"> }</span><br><span class="line"> k = mult(Inv6, k);</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> ll T;</span><br><span class="line"> <span class="built_in">cin</span> >> T;</span><br><span class="line"> Prime_init(<span class="number">1e7</span>);</span><br><span class="line"> <span class="keyword">while</span> (T--)</span><br><span class="line"> {</span><br><span class="line"> ll n, a;</span><br><span class="line"> <span class="built_in">cin</span> >> n >> a;</span><br><span class="line"> ans = <span class="number">0</span>;</span><br><span class="line"></span><br><span class="line"> O = n % MOD ? <span class="number">0</span> : <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">if</span> (O)</span><br><span class="line"> mod = MOD * MOD, Inv6 = Inv62;</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> mod = MOD, Inv6 = Inv61;</span><br><span class="line"></span><br><span class="line"> init(a);</span><br><span class="line"> solve(n);</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (O)</span><br><span class="line"> ans = mult(ans / MOD, qpow(n / MOD, MOD - <span class="number">2</span>)) % MOD;</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> ans = mult(ans, qpow(n % MOD, MOD - <span class="number">2</span>));</span><br><span class="line"> <span class="built_in">cout</span> << ans << <span class="built_in">endl</span>;</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure> </details>]]></content>
<summary type="html">
<ul>
<li><p>珠子=正三菱柱,三个面上面的数字$x$,必须满足$x\in [1,a]$，且珠子上面的数字的最大公约数要恰好为1。三棱柱可以选择翻转.</p>
</li>
<li><p>相邻的两个珠子必须不同。</p>
</li>
<li><p>两串项链如果能够经过旋转变成一样的，那么这两串项链就是相同的</p>
</li>
</ul>
<p>$n&lt;=10^{14}，a&lt;=10^7，T&lt;=10$<br>
</summary>
<category term="置换群" scheme="http://yoursite.com/tags/%E7%BD%AE%E6%8D%A2%E7%BE%A4/"/>
</entry>
<entry>
<title>CF455D.Serega and Fun</title>
<link href="http://yoursite.com/2020/10/28/CF455D/"/>
<id>http://yoursite.com/2020/10/28/CF455D/</id>
<published>2020-10-28T02:47:00.000Z</published>
<updated>2020-11-28T07:44:29.000Z</updated>
<content type="html"><![CDATA[<p>给你一个序列，在线地支持两个操作：</p><ul><li><p>将一个区间循环移位。</p></li><li><p>查询一个区间中某个数出现的次数。</p></li></ul><a id="more"></a><p>两个方法</p><ul><li>分块 维护块内元素出现次数，修改和更新用双向队列都很显然。$O((n+m)\sqrt{n})=1700ms$</li><li>平衡树，第一个操作很好解决，对于第二个操作，首先我们只能维护$t_i$这个数字平衡树出现的相对位置，而<strong>不能维护绝对位置</strong>。但是我们可以通过一开始构造原序列的平衡树的映射，就可以知道某个值在原序列第几个位置，这里需要$O(\log n)$。我想知道$[1,r]$之间$i$出现了几次，平衡树上通过这个查询二分即可。总复杂度$O(n+m\log^2 n)=300ms$</li></ul><details> <summary>平衡树</summary><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><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><span class="line">111</span><br><span class="line">112</span><br><span class="line">113</span><br><span class="line">114</span><br><span class="line">115</span><br><span class="line">116</span><br><span class="line">117</span><br><span class="line">118</span><br><span class="line">119</span><br><span class="line">120</span><br><span class="line">121</span><br><span class="line">122</span><br><span class="line">123</span><br><span class="line">124</span><br><span class="line">125</span><br><span class="line">126</span><br><span class="line">127</span><br><span class="line">128</span><br><span class="line">129</span><br><span class="line">130</span><br><span class="line">131</span><br><span class="line">132</span><br><span class="line">133</span><br><span class="line">134</span><br><span class="line">135</span><br><span class="line">136</span><br><span class="line">137</span><br><span class="line">138</span><br><span class="line">139</span><br><span class="line">140</span><br><span class="line">141</span><br><span class="line">142</span><br><span class="line">143</span><br><span class="line">144</span><br><span class="line">145</span><br><span class="line">146</span><br><span class="line">147</span><br><span class="line">148</span><br><span class="line">149</span><br><span class="line">150</span><br><span class="line">151</span><br><span class="line">152</span><br><span class="line">153</span><br><span class="line">154</span><br><span class="line">155</span><br><span class="line">156</span><br><span class="line">157</span><br><span class="line">158</span><br><span class="line">159</span><br><span class="line">160</span><br><span class="line">161</span><br><span class="line">162</span><br><span class="line">163</span><br><span class="line">164</span><br><span class="line">165</span><br><span class="line">166</span><br><span class="line">167</span><br><span class="line">168</span><br><span class="line">169</span><br><span class="line">170</span><br><span class="line">171</span><br><span class="line">172</span><br><span class="line">173</span><br><span class="line">174</span><br><span class="line">175</span><br><span class="line">176</span><br><span class="line">177</span><br><span class="line">178</span><br><span class="line">179</span><br><span class="line">180</span><br><span class="line">181</span><br><span class="line">182</span><br><span class="line">183</span><br><span class="line">184</span><br><span class="line">185</span><br><span class="line">186</span><br><span class="line">187</span><br><span class="line">188</span><br><span class="line">189</span><br><span class="line">190</span><br><span class="line">191</span><br><span class="line">192</span><br><span class="line">193</span><br><span class="line">194</span><br><span class="line">195</span><br><span class="line">196</span><br><span class="line">197</span><br><span class="line">198</span><br><span class="line">199</span><br><span class="line">200</span><br><span class="line">201</span><br><span class="line">202</span><br><span class="line">203</span><br></pre></td><td class="code"><pre><span class="line"></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><bits/stdc++.h></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line"></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> pii pair<span class="meta-string"><int, int></span></span></span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> N = <span class="number">4e5</span> + <span class="number">10</span>;</span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> mod = <span class="number">1e9</span> + <span class="number">7</span>;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">read</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> x = <span class="number">0</span>, f = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">char</span> c = getchar();</span><br><span class="line"> <span class="keyword">while</span> (c < <span class="string">'0'</span> || c > <span class="string">'9'</span>)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (c == <span class="string">'-'</span>)</span><br><span class="line"> f = <span class="number">-1</span>;</span><br><span class="line"> c = getchar();</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">while</span> (c >= <span class="string">'0'</span> && c <= <span class="string">'9'</span>)</span><br><span class="line"> x = (x << <span class="number">1</span>) + (x << <span class="number">3</span>) + c - <span class="string">'0'</span>, c = getchar();</span><br><span class="line"> <span class="keyword">return</span> x * f;</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="built_in">std</span>::mt19937 <span class="title">rnd</span><span class="params">(<span class="built_in">std</span>::chrono::steady_clock::now().time_since_epoch().count())</span></span>;</span><br><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">FHQ</span></span></span><br><span class="line"><span class="class">{</span></span><br><span class="line"> <span class="keyword">int</span> ls[N], rs[N];</span><br><span class="line"> <span class="keyword">int</span> siz[N], key[N], val[N];</span><br><span class="line"> <span class="keyword">int</span> fa[N];</span><br><span class="line"> <span class="keyword">int</span> cor[N];</span><br><span class="line"> <span class="comment">// ll sum[N];</span></span><br><span class="line"> <span class="keyword">int</span> tcnt;</span><br><span class="line"> <span class="keyword">int</span> root;</span><br><span class="line"> <span class="function"><span class="keyword">int</span> <span class="title">Newnode</span><span class="params">(<span class="keyword">int</span> x)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> siz[++tcnt] = <span class="number">1</span>;</span><br><span class="line"> val[tcnt] = x;</span><br><span class="line"> key[tcnt] = rnd(); <span class="comment">//精髓所在</span></span><br><span class="line"></span><br><span class="line"> fa[tcnt] = tcnt;</span><br><span class="line"> ls[tcnt] = rs[tcnt] = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">return</span> tcnt;</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">pushup</span><span class="params">(<span class="keyword">int</span> pos)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> siz[pos] = siz[ls[pos]] + siz[rs[pos]] + <span class="number">1</span>;</span><br><span class="line"> <span class="comment">// sum[pos] = sum[ls[pos]] + sum[rs[pos]] + val[pos];</span></span><br><span class="line"> ls[pos] ? (fa[ls[pos]] = pos) : <span class="number">0</span>;</span><br><span class="line"> rs[pos] ? (fa[rs[pos]] = pos) : <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">split</span><span class="params">(<span class="keyword">int</span> pos, <span class="keyword">int</span> v, <span class="keyword">int</span> &ll, <span class="keyword">int</span> &rr)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">if</span> (!pos)</span><br><span class="line"> {</span><br><span class="line"> ll = <span class="number">0</span>, rr = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">return</span>;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (siz[ls[pos]] + <span class="number">1</span> <= v)</span><br><span class="line"> {</span><br><span class="line"> ll = pos;</span><br><span class="line"> split(rs[pos], v - siz[ls[pos]] - <span class="number">1</span>, rs[pos], rr);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> {</span><br><span class="line"> rr = pos;</span><br><span class="line"> split(ls[pos], v, ll, ls[pos]);</span><br><span class="line"> }</span><br><span class="line"> fa[ll] = ll, fa[rr] = rr; <span class="comment">//保证头节点</span></span><br><span class="line"> pushup(pos);</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">int</span> <span class="title">merge</span><span class="params">(<span class="keyword">int</span> l, <span class="keyword">int</span> r)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">if</span> (!l || !r)</span><br><span class="line"> <span class="keyword">return</span> l + r;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (key[l] < key[r])</span><br><span class="line"> {</span><br><span class="line"> rs[l] = merge(rs[l], r);</span><br><span class="line"> pushup(l);</span><br><span class="line"> <span class="keyword">return</span> l;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> {</span><br><span class="line"></span><br><span class="line"> ls[r] = merge(l, ls[r]);</span><br><span class="line"> pushup(r);</span><br><span class="line"> <span class="keyword">return</span> r;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="comment">// int find(int x)</span></span><br><span class="line"> <span class="comment">// {</span></span><br><span class="line"> <span class="comment">// return fa[x] == x ? x : find(fa[x]);</span></span><br><span class="line"> <span class="comment">// }</span></span><br><span class="line"> <span class="function"><span class="keyword">int</span> <span class="title">insert</span><span class="params">(<span class="keyword">int</span> &rt, <span class="keyword">int</span> x)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">int</span> pos = Newnode(x);</span><br><span class="line"> rt = merge(rt, pos);</span><br><span class="line"> <span class="keyword">return</span> pos;</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">int</span> <span class="title">kth</span><span class="params">(<span class="keyword">int</span> x)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">int</span> res = siz[ls[x]] + <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">while</span> (fa[x] != x)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (rs[fa[x]] == x)</span><br><span class="line"> {</span><br><span class="line"> res += siz[ls[fa[x]]] + <span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"> x = fa[x];</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> res;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line">} t;</span><br><span class="line"></span><br><span class="line"><span class="keyword">int</span> rt[N];</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">calc</span><span class="params">(<span class="keyword">int</span> k, <span class="keyword">int</span> r)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> o = rt[k];</span><br><span class="line"> <span class="keyword">int</span> res = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">while</span> (o)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (t.kth(t.cor[o]) <= r)</span><br><span class="line"> {</span><br><span class="line"> res += t.siz[t.ls[o]] + <span class="number">1</span>;</span><br><span class="line"> o = t.rs[o];</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> o = t.ls[o];</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> res;</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> l, <span class="keyword">int</span> r, <span class="keyword">int</span> k)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">return</span> calc(k, r) - calc(k, l - <span class="number">1</span>);</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">update</span><span class="params">(<span class="keyword">int</span> l, <span class="keyword">int</span> r)</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> a, b, c, d;</span><br><span class="line"> t.split(rt[<span class="number">0</span>], l - <span class="number">1</span>, a, b);</span><br><span class="line"> t.split(b, r - l + <span class="number">1</span>, b, d);</span><br><span class="line"> t.split(b, r - l, b, c);</span><br><span class="line"></span><br><span class="line"> <span class="keyword">int</span> k = t.val[c];</span><br><span class="line"> rt[<span class="number">0</span>] = t.merge(a, t.merge(c, t.merge(b, d)));</span><br><span class="line"> <span class="keyword">int</span> ls = calc(k, l - <span class="number">1</span>);</span><br><span class="line"> <span class="keyword">int</span> rs = calc(k, r);</span><br><span class="line"> <span class="comment">//cout << k << " " << ls << " " << rs << endl;</span></span><br><span class="line"></span><br><span class="line"> t.split(rt[k], ls, a, b);</span><br><span class="line"> t.split(b, rs - ls, b, d);</span><br><span class="line"> t.split(b, rs - ls - <span class="number">1</span>, b, c);</span><br><span class="line"></span><br><span class="line"> rt[k] = t.merge(a, t.merge(c, t.merge(b, d)));</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="keyword">int</span> a[N];</span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="comment">//freopen("1", "r", stdin);</span></span><br><span class="line"> <span class="keyword">int</span> n = <span class="built_in">read</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><br><span class="line"> a[i] = <span class="built_in">read</span>();</span><br><span class="line"> <span class="keyword">int</span> x = t.insert(rt[<span class="number">0</span>], a[i]);</span><br><span class="line"> <span class="keyword">int</span> y = t.insert(rt[a[i]], a[i]);</span><br><span class="line"> t.cor[x] = y;</span><br><span class="line"> t.cor[y] = x;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="keyword">int</span> lst = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">int</span> q = <span class="built_in">read</span>();</span><br><span class="line"> <span class="keyword">while</span> (q--)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> op = <span class="built_in">read</span>(), l = <span class="built_in">read</span>(), r = <span class="built_in">read</span>();</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (op == <span class="number">1</span>)</span><br><span class="line"> {</span><br><span class="line"> l = (l + lst - <span class="number">1</span>) % n + <span class="number">1</span>, r = (r + lst - <span class="number">1</span>) % n + <span class="number">1</span>;</span><br><span class="line"> <span class="comment">//cout << op << " " << l << " " << r << " " << endl;</span></span><br><span class="line"> <span class="keyword">if</span> (l > r)</span><br><span class="line"> swap(l, r);</span><br><span class="line"> <span class="keyword">if</span> (l == r)</span><br><span class="line"> <span class="keyword">continue</span>;</span><br><span class="line"> update(l, r);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> k = <span class="built_in">read</span>();</span><br><span class="line"> l = (l + lst - <span class="number">1</span>) % n + <span class="number">1</span>, r = (r + lst - <span class="number">1</span>) % n + <span class="number">1</span>, k = (k + lst - <span class="number">1</span>) % n + <span class="number">1</span>;</span><br><span class="line"> <span class="comment">// cout << op << " " << l << " " << r << " "</span></span><br><span class="line"> <span class="comment">// << " " << k << endl;</span></span><br><span class="line"> <span class="keyword">if</span> (l > r)</span><br><span class="line"> swap(l, r);</span><br><span class="line"></span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%d\n"</span>, lst = query(l, r, k));</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure> </details><details> <summary>分块</summary><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><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><span class="line">111</span><br><span class="line">112</span><br><span class="line">113</span><br><span class="line">114</span><br><span class="line">115</span><br><span class="line">116</span><br><span class="line">117</span><br><span class="line">118</span><br><span class="line">119</span><br><span class="line">120</span><br><span class="line">121</span><br><span class="line">122</span><br><span class="line">123</span><br><span class="line">124</span><br><span class="line">125</span><br><span class="line">126</span><br><span class="line">127</span><br><span class="line">128</span><br><span class="line">129</span><br><span class="line">130</span><br><span class="line">131</span><br><span class="line">132</span><br><span class="line">133</span><br><span class="line">134</span><br><span class="line">135</span><br><span class="line">136</span><br><span class="line">137</span><br><span class="line">138</span><br><span class="line">139</span><br><span class="line">140</span><br><span class="line">141</span><br><span class="line">142</span><br><span class="line">143</span><br><span class="line">144</span><br><span class="line">145</span><br><span class="line">146</span><br><span class="line">147</span><br><span class="line">148</span><br><span class="line">149</span><br><span class="line">150</span><br><span class="line">151</span><br><span class="line">152</span><br><span class="line">153</span><br><span class="line">154</span><br><span class="line">155</span><br><span class="line">156</span><br><span class="line">157</span><br><span class="line">158</span><br><span class="line">159</span><br><span class="line">160</span><br><span class="line">161</span><br><span class="line">162</span><br><span class="line">163</span><br><span class="line">164</span><br><span class="line">165</span><br><span class="line">166</span><br><span class="line">167</span><br><span class="line">168</span><br><span class="line">169</span><br><span class="line">170</span><br><span class="line">171</span><br><span class="line">172</span><br><span class="line">173</span><br><span class="line">174</span><br><span class="line">175</span><br><span class="line">176</span><br><span class="line">177</span><br><span class="line">178</span><br><span class="line">179</span><br><span class="line">180</span><br><span class="line">181</span><br><span class="line">182</span><br><span class="line">183</span><br><span class="line">184</span><br><span class="line">185</span><br><span class="line">186</span><br><span class="line">187</span><br><span class="line">188</span><br><span class="line">189</span><br><span class="line">190</span><br><span class="line">191</span><br><span class="line">192</span><br><span class="line">193</span><br><span class="line">194</span><br><span class="line">195</span><br><span class="line">196</span><br><span class="line">197</span><br><span class="line">198</span><br></pre></td><td class="code"><pre><span class="line"></span><br><span class="line"> <span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string"><bits/stdc++.h></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> ll long long</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> pii pair<span class="meta-string"><ll, int></span></span></span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> N = <span class="number">1e5</span> + <span class="number">10</span>;</span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> mod = <span class="number">1e9</span> + <span class="number">7</span>;</span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> M = <span class="number">400</span>;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">read</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="keyword">int</span> x = <span class="number">0</span>, f = <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">char</span> c = getchar();</span><br><span class="line"> <span class="keyword">while</span> (c < <span class="string">'0'</span> || c > <span class="string">'9'</span>)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">if</span> (c == <span class="string">'-'</span>)</span><br><span class="line"> f = <span class="number">-1</span>;</span><br><span class="line"> c = getchar();</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">while</span> (c >= <span class="string">'0'</span> && c <= <span class="string">'9'</span>)</span><br><span class="line"> x = (x << <span class="number">1</span>) + (x << <span class="number">3</span>) + c - <span class="string">'0'</span>, c = getchar();</span><br><span class="line"> <span class="keyword">return</span> x * f;</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">Bo</span></span></span><br><span class="line"><span class="class">{</span></span><br><span class="line"> <span class="keyword">int</span> block, tot, bl[N], br[N], fa[N];</span><br><span class="line"> <span class="keyword">int</span> cnt[M][N];</span><br><span class="line"> <span class="keyword">int</span> a[N];</span><br><span class="line"> <span class="built_in">deque</span><<span class="keyword">int</span>> q[M];</span><br><span class="line"> ll tag[N];</span><br><span class="line"></span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">replace</span><span class="params">(<span class="keyword">int</span> x, <span class="keyword">int</span> y, <span class="keyword">int</span> w)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> cnt[x][y] += w;</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> n)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> block = <span class="built_in">sqrt</span>(n);</span><br><span class="line"> tot = n / block + (n % block != <span class="number">0</span>);</span><br><span class="line"></span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">1</span>; i <= tot; i++)</span><br><span class="line"> bl[i] = (i - <span class="number">1</span>) * block + <span class="number">1</span>, br[i] = i * block;</span><br><span class="line"></span><br><span class="line"> br[tot] = n;</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"> fa[i] = (i - <span class="number">1</span>) / (block) + <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 <= tot; i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> j = bl[i]; j <= br[i]; j++)</span><br><span class="line"> {</span><br><span class="line"> q[i].push_back(a[j]);</span><br><span class="line"> replace(i, a[j], <span class="number">1</span>);</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">work</span><span class="params">(<span class="keyword">int</span> lx, <span class="keyword">int</span> rx, <span class="keyword">int</span> l, <span class="keyword">int</span> r)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"></span><br><span class="line"> <span class="built_in">stack</span><<span class="keyword">int</span>> le, ri;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">1</span>; i <= l - bl[lx]; i++)</span><br><span class="line"> {</span><br><span class="line"> le.push(q[lx].front());</span><br><span class="line"> q[lx].pop_front();</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 <= br[rx] - r; i++)</span><br><span class="line"> {</span><br><span class="line"> ri.push(q[rx].back());</span><br><span class="line"> q[rx].pop_back();</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">int</span> u = q[rx].back();</span><br><span class="line"> replace(rx, u, <span class="number">-1</span>);</span><br><span class="line"> q[rx].pop_back();</span><br><span class="line"> replace(lx, u, <span class="number">1</span>);</span><br><span class="line"> q[lx].push_front(u);</span><br><span class="line"> <span class="keyword">while</span> (!le.empty())</span><br><span class="line"> {</span><br><span class="line"> q[lx].push_front(le.top());</span><br><span class="line"> le.pop();</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">while</span> (!ri.empty())</span><br><span class="line"> {</span><br><span class="line"> q[rx].push_back(ri.top());</span><br><span class="line"> ri.pop();</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">calc</span><span class="params">(<span class="keyword">int</span> lx, <span class="keyword">int</span> rx, <span class="keyword">int</span> l, <span class="keyword">int</span> r, <span class="keyword">int</span> k)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"></span><br><span class="line"> <span class="built_in">stack</span><<span class="keyword">int</span>> le, ri;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">1</span>; i <= l - bl[lx]; i++)</span><br><span class="line"> {</span><br><span class="line"> le.push(q[lx].front());</span><br><span class="line"> q[lx].pop_front();</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 <= br[rx] - r; i++)</span><br><span class="line"> {</span><br><span class="line"> ri.push(q[rx].back());</span><br><span class="line"> q[rx].pop_back();</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">int</span> res = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> x : q[lx])</span><br><span class="line"> <span class="keyword">if</span> (x == k)</span><br><span class="line"> res++;</span><br><span class="line"> <span class="keyword">if</span> (lx != rx)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> x : q[rx])</span><br><span class="line"> <span class="keyword">if</span> (x == k)</span><br><span class="line"> res++;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="keyword">while</span> (!le.empty())</span><br><span class="line"> {</span><br><span class="line"> q[lx].push_front(le.top());</span><br><span class="line"> le.pop();</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">while</span> (!ri.empty())</span><br><span class="line"> {</span><br><span class="line"> q[rx].push_back(ri.top());</span><br><span class="line"> ri.pop();</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> res;</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">update</span><span class="params">(<span class="keyword">int</span> l, <span class="keyword">int</span> r)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">if</span> (fa[l] == fa[r])</span><br><span class="line"> {</span><br><span class="line"> work(fa[l], fa[l], l, r);</span><br><span class="line"> <span class="keyword">return</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">int</span> lx = fa[l], rx = fa[r];</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = lx; i < rx; i++)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> x = q[i].back();</span><br><span class="line"> q[i].pop_back();</span><br><span class="line"> replace(i, x, <span class="number">-1</span>);</span><br><span class="line"> q[i + <span class="number">1</span>].push_front(x);</span><br><span class="line"> replace(i + <span class="number">1</span>, x, <span class="number">1</span>);</span><br><span class="line"> }</span><br><span class="line"> work(lx, rx, l, r);</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> l, <span class="keyword">int</span> r, <span class="keyword">int</span> k)</span></span></span><br><span class="line"><span class="function"> </span>{</span><br><span class="line"> <span class="keyword">if</span> (fa[l] == fa[r])</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">return</span> calc(fa[l], fa[l], l, r, k);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">int</span> lx = fa[l], rx = fa[r];</span><br><span class="line"> <span class="keyword">int</span> res = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> i = lx + <span class="number">1</span>; i < rx; i++)</span><br><span class="line"> {</span><br><span class="line"> res += cnt[i][k];</span><br><span class="line"> }</span><br><span class="line"> res += calc(lx, rx, l, r, k);</span><br><span class="line"> <span class="keyword">return</span> res;</span><br><span class="line"> }</span><br><span class="line">} t;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>{</span><br><span class="line"> <span class="comment">// freopen("1", "r", stdin);</span></span><br><span class="line"> <span class="keyword">int</span> n = <span class="built_in">read</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"> t.a[i] = <span class="built_in">read</span>();</span><br><span class="line"> t.build(n);</span><br><span class="line"> <span class="keyword">int</span> q = <span class="built_in">read</span>();</span><br><span class="line"> <span class="keyword">int</span> lst = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">while</span> (q--)</span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> op = <span class="built_in">read</span>(), l = <span class="built_in">read</span>(), r = <span class="built_in">read</span>();</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (op == <span class="number">1</span>)</span><br><span class="line"> {</span><br><span class="line"> l = (l + lst - <span class="number">1</span>) % n + <span class="number">1</span>, r = (r + lst - <span class="number">1</span>) % n + <span class="number">1</span>;</span><br><span class="line"> <span class="comment">//cout << op << " " << l << " " << r << " " << endl;</span></span><br><span class="line"> <span class="keyword">if</span> (l > r)</span><br><span class="line"> swap(l, r);</span><br><span class="line"> <span class="keyword">if</span> (l == r)</span><br><span class="line"> <span class="keyword">continue</span>;</span><br><span class="line"> t.update(l, r);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> {</span><br><span class="line"> <span class="keyword">int</span> k = <span class="built_in">read</span>();</span><br><span class="line"> l = (l + lst - <span class="number">1</span>) % n + <span class="number">1</span>, r = (r + lst - <span class="number">1</span>) % n + <span class="number">1</span>, k = (k + lst - <span class="number">1</span>) % n + <span class="number">1</span>;</span><br><span class="line"> <span class="comment">// cout << op << " " << l << " " << r << " "</span></span><br><span class="line"> <span class="comment">// << " " << k << endl;</span></span><br><span class="line"> <span class="keyword">if</span> (l > r)</span><br><span class="line"> swap(l, r);</span><br><span class="line"></span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%d\n"</span>, lst = t.query(l, r, k));</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure> </details>]]></content>
<summary type="html">
<p>给你一个序列，在线地支持两个操作：</p>
<ul>
<li><p>将一个区间循环移位。</p>
</li>
<li><p>查询一个区间中某个数出现的次数。</p>
</li>
</ul>
</summary>
<category term="平衡树" scheme="http://yoursite.com/tags/%E5%B9%B3%E8%A1%A1%E6%A0%91/"/>
</entry>
</feed>