宇宙ツイッタラーXの憂鬱 2022-04-08T00:33:26+09:00 kenkoooo Hatena::Blog hatenablog://blog/8454420450081554074 ワクチンデマの根拠で挙げられているファイザー公式文書を読んだ hatenablog://entry/13574176438080819052 2022-04-08T00:33:26+09:00 2022-04-08T00:41:02+09:00 「ファイザーの公式文書でワクチンの有害性が指摘されている!」というデマツイートが流れてきたから、流石にそんなわけなくない?と思ってその公式文書として挙げられているPDFの当該箇所を読んでみたけど、英語かつ専門用語で思ったより難しかった…… https://cdn.pfizer.com/pfizercom/2020-11/C4591001_Clinical_Protocol_Nov2020.pdf よくデマの根拠とされている部分 8.3.5. Exposure During Pregnancy or Breastfeeding, and Occupational Exposure Exposur… <p>「<a class="keyword" href="http://d.hatena.ne.jp/keyword/%A5%D5%A5%A1%A5%A4%A5%B6%A1%BC">ファイザー</a>の公式文書でワクチンの有害性が指摘されている!」というデマツイートが流れてきたから、流石にそんなわけなくない?と思ってその公式文書として挙げられているPDFの当該箇所を読んでみたけど、英語かつ専門用語で思ったより難しかった……</p> <p><a href="https://cdn.pfizer.com/pfizercom/2020-11/C4591001_Clinical_Protocol_Nov2020.pdf">https://cdn.pfizer.com/pfizercom/2020-11/C4591001_Clinical_Protocol_Nov2020.pdf</a></p> <h1>よくデマの根拠とされている部分</h1> <blockquote><h2>8.3.5. Exposure During Pregnancy or Breastfeeding, and Occupational Exposure</h2> <p>Exposure to the study intervention under study during pregnancy or breastfeeding and occupational exposure are reportable to Pfizer Safety within 24 hours of investigator awareness.</p> <h3>8.3.5.1. Exposure During Pregnancy</h3> <p>An EDP occurs if:</p> <ul> <li><p>A female participant is found to be pregnant while receiving or after discontinuing study intervention.</p></li> <li><p>A male participant who is receiving or has discontinued study intervention exposes a female partner prior to or around the time of conception.</p></li> <li><p>A female is found to be pregnant while being exposed or having been exposed to study intervention due to environmental exposure. Below are examples of environmental exposure during pregnancy:</p> <ul> <li>A female family member or healthcare provider reports that she is pregnant after having been exposed to the study intervention by inhalation or skin contact.</li> <li>A male family member or healthcare provider who has been exposed to the study intervention by inhalation or skin contact then exposes his female partner prior to or around the time of conception.</li> </ul> </li> </ul> <p>The investigator must report EDP to Pfizer Safety within 24 hours of the investigator's awareness, irrespective of whether an SAE has occurred. The initial information submitted should include the anticipated date of delivery (see below for information related to termination of pregnancy).</p></blockquote> <p>(まず前提として、この文書は治験のやり方を書いたもので、何かの結果を報告するものではないはずです)</p> <p>たしかにこの辺りをDeepLとかに入れると「妊娠中の曝露は、以下のような場合に発生します: 女性参加者が、試験介入を受けている間、または試験介入を中止した後に妊娠していることが判明した場合...」と仰々しい感じになります。反ワクチン派の知人が「曝露が〜」という話をしていたのも多分これが根拠になっていたんですね。</p> <p>Exposure=曝露は普段の生活ではあまり馴染みがありませんが、曝露試験のことで、ワクチンの接種をした後にウイルスに曝し、ワクチンの安全性や有効性を評価する試験のことです。</p> <p>上記の部分は「妊婦に曝露試験をしてしまったことが判明した場合、<a class="keyword" href="http://d.hatena.ne.jp/keyword/%BD%C5%C6%C6">重篤</a>な有害事象 (SAE) が発生していなかったとしても24時間以内に Pfizer Safety に連絡しなさい」という治験のルールを説明したものですね。</p> kenkoooo Codeforces Round #773 (Div. 1) C. Anonymity Is Important hatenablog://entry/13574176438076066044 2022-03-24T00:40:20+09:00 2022-03-24T00:40:20+09:00 問題 https://codeforces.com/contest/1641/problem/C N要素の配列とQ個のクエリが来る。配列の各要素は0か1だが分からない。クエリは以下の3種類。 L番目からR番目が全て0である。 L番目からR番目のどれか1つ以上が1である。 j番目の数が1ならYES、0ならNO、その時点では確定していなければN/Aを出力。 解法 予め全て読み込んでおく。これらを3回全部見る。 クエリ再生1周目 クエリのうち、まずは「L番目からR番目が全て0である」というクエリだけ処理することにする。次の2種類の操作がサポートされた遅延セグメントツリーを用意する。 L番目からR番目… <h1>問題</h1> <p><a href="https://codeforces.com/contest/1641/problem/C">https://codeforces.com/contest/1641/problem/C</a></p> <p>N要素の配列とQ個のクエリが来る。配列の各要素は0か1だが分からない。クエリは以下の3種類。</p> <ul> <li>L番目からR番目が全て0である。</li> <li>L番目からR番目のどれか1つ以上が1である。</li> <li>j番目の数が1ならYES、0ならNO、その時点では確定していなければN/Aを出力。</li> </ul> <h1>解法</h1> <p>予め全て読み込んでおく。これらを3回全部見る。</p> <h2>クエリ再生1周目</h2> <p>クエリのうち、まずは「L番目からR番目が全て0である」というクエリだけ処理することにする。次の2種類の操作がサポートされた遅延セグメントツリーを用意する。</p> <ul> <li>L番目からR番目までをX以上ならXに書き換える。</li> <li>L番目からR番目までのうち最大値を取り出す。</li> </ul> <p>このセグメントツリーとクエリを使って、配列内の0の各要素について、その値が0と確定した時刻を記録することができる。</p> <h2>クエリ再生2周目</h2> <p>もう一度クエリを最初から全て見る。今度は「L番目からR番目のどれか1つ以上が1である」というクエリだけ処理することにする。L番目からR番目の中の0の要<a class="keyword" href="http://d.hatena.ne.jp/keyword/%C1%C7%BF%F4">素数</a>が最後までR-L個に満たなければ、このクエリによって1の要素は確定しないのでスルーして良い。L番目からR番目の要素に1の要素が1つだけあり、それがj番目と確定した場合、それ以外の0の要素が確定した時刻の最大値が分かる。その時刻かこのクエリ自体の時刻の大きいほうが、j番目が1と確定した時刻と言える。</p> <h2>クエリ再生3周目</h2> <p>今度は出力するクエリだけ処理することにする。クエリを2周したことで、各要素について、「0だと確定した時刻」「1だと確定した時刻」「何も確定していない」のいずれかが分かっている。指定された要素について、クエリ以前に確定していればYES/NOを、クエリの時点で確定していなければN/Aを出力する。</p> <h1>コード</h1> <pre class="code lang-rust" data-lang="rust" data-unlink><span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">collections</span><span class="synSpecial">::</span>BTreeSet; <span class="synStatement">use</span> <span class="synPreProc">lazy_segment_tree</span><span class="synSpecial">::</span>LazySegmentTree; <span class="synType">const</span> INF: <span class="synType">i64</span> <span class="synStatement">=</span> <span class="synConstant">1</span> <span class="synStatement">&lt;&lt;</span> <span class="synConstant">60</span>; <span class="synStatement">fn</span> <span class="synIdentifier">main</span>() { <span class="synStatement">let</span> (r, w) <span class="synStatement">=</span> (<span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdin</span>(), <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdout</span>()); <span class="synStatement">let</span> <span class="synType">mut</span> sc <span class="synStatement">=</span> <span class="synPreProc">IO</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(r.<span class="synIdentifier">lock</span>(), w.<span class="synIdentifier">lock</span>()); <span class="synStatement">let</span> n: <span class="synType">usize</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); <span class="synStatement">let</span> q: <span class="synType">usize</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); <span class="synStatement">let</span> <span class="synType">mut</span> seg <span class="synStatement">=</span> <span class="synPreProc">LazySegmentTree</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>( n, <span class="synStatement">||</span> <span class="synStatement">-</span>INF, <span class="synStatement">|</span><span class="synType">&amp;</span>left: <span class="synType">&amp;i64</span>, <span class="synType">&amp;</span>right: <span class="synType">&amp;i64</span><span class="synStatement">|</span> left.<span class="synIdentifier">max</span>(right), <span class="synStatement">|</span><span class="synType">&amp;</span>f: <span class="synType">&amp;Option</span><span class="synStatement">&lt;</span><span class="synType">i64</span><span class="synStatement">&gt;</span>, <span class="synType">&amp;</span>x: <span class="synType">&amp;i64</span><span class="synStatement">|</span> { <span class="synStatement">if</span> <span class="synStatement">let</span> <span class="synConstant">Some</span>(f) <span class="synStatement">=</span> f { f.<span class="synIdentifier">min</span>(x) } <span class="synStatement">else</span> { x } }, <span class="synStatement">|</span><span class="synType">&amp;</span>f: <span class="synType">&amp;Option</span><span class="synStatement">&lt;</span><span class="synType">i64</span><span class="synStatement">&gt;</span>, <span class="synType">&amp;</span>g: <span class="synType">&amp;Option</span><span class="synStatement">&lt;</span><span class="synType">i64</span><span class="synStatement">&gt;|</span> <span class="synStatement">match</span> (f, g) { (<span class="synConstant">Some</span>(x), <span class="synConstant">Some</span>(y)) <span class="synStatement">=&gt;</span> <span class="synConstant">Some</span>(x.<span class="synIdentifier">min</span>(y)), _ <span class="synStatement">=&gt;</span> f.<span class="synIdentifier">or</span>(g), }, <span class="synStatement">||</span> <span class="synConstant">None</span>, ); <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..n { seg.<span class="synIdentifier">set</span>(i, INF); } <span class="synStatement">let</span> <span class="synType">mut</span> non_zero <span class="synStatement">=</span> (<span class="synConstant">0</span>..n).<span class="synIdentifier">collect</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span>BTreeSet<span class="synStatement">&lt;</span>_<span class="synStatement">&gt;&gt;</span>(); <span class="synStatement">let</span> <span class="synType">mut</span> queries <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[]; <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..q { <span class="synStatement">let</span> t: <span class="synType">usize</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); <span class="synStatement">if</span> t <span class="synStatement">==</span> <span class="synConstant">0</span> { <span class="synStatement">let</span> l <span class="synStatement">=</span> sc.<span class="synIdentifier">usize0</span>(); <span class="synStatement">let</span> r: <span class="synType">usize</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); <span class="synStatement">let</span> x: <span class="synType">usize</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); queries.<span class="synIdentifier">push</span>((t, l, r, x)); <span class="synStatement">if</span> x <span class="synStatement">==</span> <span class="synConstant">0</span> { seg.<span class="synIdentifier">apply_range</span>(l..r, <span class="synConstant">Some</span>(i <span class="synStatement">as</span> <span class="synType">i64</span>)); <span class="synStatement">while</span> <span class="synStatement">let</span> <span class="synConstant">Some</span>(<span class="synType">&amp;</span>x) <span class="synStatement">=</span> non_zero.<span class="synIdentifier">range</span>(l..r).<span class="synIdentifier">next</span>() { <span class="synPreProc">assert!</span>(non_zero.<span class="synIdentifier">remove</span>(<span class="synType">&amp;</span>x)); } } } <span class="synStatement">else</span> { <span class="synStatement">let</span> j <span class="synStatement">=</span> sc.<span class="synIdentifier">usize0</span>(); queries.<span class="synIdentifier">push</span>((t, j, <span class="synConstant">0</span>, <span class="synConstant">0</span>)); } } <span class="synStatement">let</span> <span class="synType">mut</span> ans_one <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synConstant">false</span>; n]; <span class="synStatement">let</span> <span class="synType">mut</span> time <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[INF; n]; <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..q { <span class="synStatement">let</span> (t, l, r, x) <span class="synStatement">=</span> queries[i]; <span class="synStatement">if</span> t <span class="synStatement">==</span> <span class="synConstant">0</span> <span class="synStatement">&amp;&amp;</span> x <span class="synStatement">==</span> <span class="synConstant">1</span> { <span class="synStatement">let</span> min <span class="synStatement">=</span> <span class="synType">*</span>non_zero.<span class="synIdentifier">range</span>(l..).<span class="synIdentifier">next</span>().<span class="synIdentifier">unwrap</span>(); <span class="synStatement">let</span> max <span class="synStatement">=</span> <span class="synType">*</span>non_zero.<span class="synIdentifier">range</span>(..r).<span class="synIdentifier">next_back</span>().<span class="synIdentifier">unwrap</span>(); <span class="synStatement">if</span> min <span class="synStatement">==</span> max { <span class="synStatement">let</span> pos <span class="synStatement">=</span> min; <span class="synStatement">let</span> <span class="synType">mut</span> max <span class="synStatement">=</span> i <span class="synStatement">as</span> <span class="synType">i64</span>; <span class="synStatement">if</span> l <span class="synStatement">&lt;</span> pos { max <span class="synStatement">=</span> max.<span class="synIdentifier">max</span>(seg.<span class="synIdentifier">prod</span>(l..pos)); } <span class="synStatement">if</span> (pos <span class="synStatement">+</span> <span class="synConstant">1</span>) <span class="synStatement">&lt;</span> r { max <span class="synStatement">=</span> max.<span class="synIdentifier">max</span>(seg.<span class="synIdentifier">prod</span>((pos <span class="synStatement">+</span> <span class="synConstant">1</span>)..r)); } ans_one[pos] <span class="synStatement">=</span> <span class="synConstant">true</span>; time[pos] <span class="synStatement">=</span> time[pos].<span class="synIdentifier">min</span>(max); } } } <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..n { <span class="synStatement">let</span> zero_time <span class="synStatement">=</span> seg.<span class="synIdentifier">prod</span>(i..(i <span class="synStatement">+</span> <span class="synConstant">1</span>)); <span class="synStatement">if</span> zero_time <span class="synStatement">!=</span> INF { time[i] <span class="synStatement">=</span> zero_time; <span class="synPreProc">assert!</span>(<span class="synStatement">!</span>ans_one[i]); } } <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..q { <span class="synStatement">let</span> (t, j, _, _) <span class="synStatement">=</span> queries[i]; <span class="synStatement">if</span> t <span class="synStatement">==</span> <span class="synConstant">1</span> { <span class="synStatement">if</span> time[j] <span class="synStatement">&lt;=</span> i <span class="synStatement">as</span> <span class="synType">i64</span> { <span class="synStatement">if</span> ans_one[j] { sc.<span class="synIdentifier">write</span>(<span class="synConstant">&quot;YES</span><span class="synSpecial">\n</span><span class="synConstant">&quot;</span>); } <span class="synStatement">else</span> { sc.<span class="synIdentifier">write</span>(<span class="synConstant">&quot;NO</span><span class="synSpecial">\n</span><span class="synConstant">&quot;</span>); } } <span class="synStatement">else</span> { sc.<span class="synIdentifier">write</span>(<span class="synConstant">&quot;N/A</span><span class="synSpecial">\n</span><span class="synConstant">&quot;</span>); } } } } <span class="synStatement">pub</span> <span class="synStatement">mod</span> <span class="synIdentifier">lazy_segment_tree</span> { <span class="synStatement">type</span> <span class="synIdentifier">Range</span> <span class="synStatement">=</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">ops</span><span class="synSpecial">::</span>Range<span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;</span>; <span class="synStatement">pub</span> <span class="synStatement">struct</span> <span class="synIdentifier">LazySegmentTree</span><span class="synStatement">&lt;</span>S, Op, E, F, Mapping, Composition, Id<span class="synStatement">&gt;</span> { n: <span class="synType">usize</span>, size: <span class="synType">usize</span>, log: <span class="synType">usize</span>, data: <span class="synType">Vec</span><span class="synStatement">&lt;</span>S<span class="synStatement">&gt;</span>, lazy: <span class="synType">Vec</span><span class="synStatement">&lt;</span>F<span class="synStatement">&gt;</span>, op: Op, e: E, mapping: Mapping, composition: Composition, id: Id, } <span class="synStatement">impl&lt;</span>S, Op, E, F, Mapping, Composition, Id<span class="synStatement">&gt;</span> LazySegmentTree<span class="synStatement">&lt;</span>S, Op, E, F, Mapping, Composition, Id<span class="synStatement">&gt;</span> <span class="synStatement">where</span> S: <span class="synType">Clone</span>, E: <span class="synType">Fn</span>() <span class="synStatement">-&gt;</span> S, F: <span class="synType">Clone</span>, Op: <span class="synType">Fn</span>(<span class="synType">&amp;</span>S, <span class="synType">&amp;</span>S) <span class="synStatement">-&gt;</span> S, Mapping: <span class="synType">Fn</span>(<span class="synType">&amp;</span>F, <span class="synType">&amp;</span>S) <span class="synStatement">-&gt;</span> S, Composition: <span class="synType">Fn</span>(<span class="synType">&amp;</span>F, <span class="synType">&amp;</span>F) <span class="synStatement">-&gt;</span> F, Id: <span class="synType">Fn</span>() <span class="synStatement">-&gt;</span> F, { <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">new</span>( n: <span class="synType">usize</span>, e: E, op: Op, mapping: Mapping, composition: Composition, id: Id, ) <span class="synStatement">-&gt;</span> <span class="synType">Self</span> { <span class="synStatement">let</span> size <span class="synStatement">=</span> n.<span class="synIdentifier">next_power_of_two</span>() <span class="synStatement">as</span> <span class="synType">usize</span>; LazySegmentTree { n, size, log: size.<span class="synIdentifier">trailing_zeros</span>() <span class="synStatement">as</span> <span class="synType">usize</span>, data: <span class="synPreProc">vec!</span>[<span class="synIdentifier">e</span>(); <span class="synConstant">2</span> <span class="synStatement">*</span> size], lazy: <span class="synPreProc">vec!</span>[<span class="synIdentifier">id</span>(); size], e, op, mapping, composition, id, } } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">set</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, <span class="synType">mut</span> index: <span class="synType">usize</span>, value: S) { <span class="synPreProc">assert!</span>(index <span class="synStatement">&lt;</span> <span class="synConstant">self</span>.n); index <span class="synStatement">+=</span> <span class="synConstant">self</span>.size; <span class="synStatement">for</span> i <span class="synStatement">in</span> (<span class="synConstant">1</span>..<span class="synStatement">=</span><span class="synConstant">self</span>.log).<span class="synIdentifier">rev</span>() { <span class="synConstant">self</span>.<span class="synIdentifier">push</span>(index <span class="synStatement">&gt;&gt;</span> i); } <span class="synConstant">self</span>.data[index] <span class="synStatement">=</span> value; <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">1</span>..<span class="synStatement">=</span><span class="synConstant">self</span>.log { <span class="synConstant">self</span>.<span class="synIdentifier">update</span>(index <span class="synStatement">&gt;&gt;</span> i); } } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">get</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, <span class="synType">mut</span> index: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> S { <span class="synPreProc">assert!</span>(index <span class="synStatement">&lt;</span> <span class="synConstant">self</span>.n); index <span class="synStatement">+=</span> <span class="synConstant">self</span>.size; <span class="synStatement">for</span> i <span class="synStatement">in</span> (<span class="synConstant">1</span>..<span class="synStatement">=</span><span class="synConstant">self</span>.log).<span class="synIdentifier">rev</span>() { <span class="synConstant">self</span>.<span class="synIdentifier">push</span>(index <span class="synStatement">&gt;&gt;</span> i); } <span class="synConstant">self</span>.data[index].<span class="synIdentifier">clone</span>() } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">prod</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, range: Range) <span class="synStatement">-&gt;</span> S { <span class="synStatement">let</span> <span class="synType">mut</span> l <span class="synStatement">=</span> range.start; <span class="synStatement">let</span> <span class="synType">mut</span> r <span class="synStatement">=</span> range.end; <span class="synPreProc">assert!</span>(l <span class="synStatement">&lt;</span> r <span class="synStatement">&amp;&amp;</span> r <span class="synStatement">&lt;=</span> <span class="synConstant">self</span>.n); l <span class="synStatement">+=</span> <span class="synConstant">self</span>.size; r <span class="synStatement">+=</span> <span class="synConstant">self</span>.size; <span class="synStatement">for</span> i <span class="synStatement">in</span> (<span class="synConstant">1</span>..<span class="synStatement">=</span><span class="synConstant">self</span>.log).<span class="synIdentifier">rev</span>() { <span class="synStatement">if</span> ((l <span class="synStatement">&gt;&gt;</span> i) <span class="synStatement">&lt;&lt;</span> i) <span class="synStatement">!=</span> l { <span class="synConstant">self</span>.<span class="synIdentifier">push</span>(l <span class="synStatement">&gt;&gt;</span> i); } <span class="synStatement">if</span> ((r <span class="synStatement">&gt;&gt;</span> i) <span class="synStatement">&lt;&lt;</span> i) <span class="synStatement">!=</span> r { <span class="synConstant">self</span>.<span class="synIdentifier">push</span>(r <span class="synStatement">&gt;&gt;</span> i); } } <span class="synStatement">let</span> <span class="synType">mut</span> sum_l <span class="synStatement">=</span> (<span class="synConstant">self</span>.e)(); <span class="synStatement">let</span> <span class="synType">mut</span> sum_r <span class="synStatement">=</span> (<span class="synConstant">self</span>.e)(); <span class="synStatement">while</span> l <span class="synStatement">&lt;</span> r { <span class="synStatement">if</span> l <span class="synStatement">&amp;</span> <span class="synConstant">1</span> <span class="synStatement">!=</span> <span class="synConstant">0</span> { sum_l <span class="synStatement">=</span> (<span class="synConstant">self</span>.op)(<span class="synType">&amp;</span>sum_l, <span class="synType">&amp;</span><span class="synConstant">self</span>.data[l]); l <span class="synStatement">+=</span> <span class="synConstant">1</span>; } <span class="synStatement">if</span> r <span class="synStatement">&amp;</span> <span class="synConstant">1</span> <span class="synStatement">!=</span> <span class="synConstant">0</span> { r <span class="synStatement">-=</span> <span class="synConstant">1</span>; sum_r <span class="synStatement">=</span> (<span class="synConstant">self</span>.op)(<span class="synType">&amp;</span><span class="synConstant">self</span>.data[r], <span class="synType">&amp;</span>sum_r); } l <span class="synStatement">&gt;&gt;=</span> <span class="synConstant">1</span>; r <span class="synStatement">&gt;&gt;=</span> <span class="synConstant">1</span>; } (<span class="synConstant">self</span>.op)(<span class="synType">&amp;</span>sum_l, <span class="synType">&amp;</span>sum_r) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">all_prod</span>(<span class="synType">&amp;</span><span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> S { <span class="synConstant">self</span>.data[<span class="synConstant">1</span>].<span class="synIdentifier">clone</span>() } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">apply</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, <span class="synType">mut</span> index: <span class="synType">usize</span>, f: F) { <span class="synPreProc">assert!</span>(index <span class="synStatement">&lt;</span> <span class="synConstant">self</span>.n); index <span class="synStatement">+=</span> <span class="synConstant">self</span>.size; <span class="synStatement">for</span> i <span class="synStatement">in</span> (<span class="synConstant">1</span>..<span class="synStatement">=</span><span class="synConstant">self</span>.log).<span class="synIdentifier">rev</span>() { <span class="synConstant">self</span>.<span class="synIdentifier">push</span>(index <span class="synStatement">&gt;&gt;</span> i); } <span class="synConstant">self</span>.data[index] <span class="synStatement">=</span> (<span class="synConstant">self</span>.mapping)(<span class="synType">&amp;</span>f, <span class="synType">&amp;</span><span class="synConstant">self</span>.data[index]); <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">1</span>..<span class="synStatement">=</span><span class="synConstant">self</span>.log { <span class="synConstant">self</span>.<span class="synIdentifier">update</span>(index <span class="synStatement">&gt;&gt;</span> i); } } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">apply_range</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, range: Range, f: F) { <span class="synStatement">let</span> <span class="synType">mut</span> l <span class="synStatement">=</span> range.start; <span class="synStatement">let</span> <span class="synType">mut</span> r <span class="synStatement">=</span> range.end; <span class="synPreProc">assert!</span>(l <span class="synStatement">&lt;=</span> r <span class="synStatement">&amp;&amp;</span> r <span class="synStatement">&lt;=</span> <span class="synConstant">self</span>.n); <span class="synStatement">if</span> l <span class="synStatement">==</span> r { <span class="synStatement">return</span>; } l <span class="synStatement">+=</span> <span class="synConstant">self</span>.size; r <span class="synStatement">+=</span> <span class="synConstant">self</span>.size; <span class="synStatement">for</span> i <span class="synStatement">in</span> (<span class="synConstant">1</span>..<span class="synStatement">=</span><span class="synConstant">self</span>.log).<span class="synIdentifier">rev</span>() { <span class="synStatement">if</span> ((l <span class="synStatement">&gt;&gt;</span> i) <span class="synStatement">&lt;&lt;</span> i) <span class="synStatement">!=</span> l { <span class="synConstant">self</span>.<span class="synIdentifier">push</span>(l <span class="synStatement">&gt;&gt;</span> i); } <span class="synStatement">if</span> ((r <span class="synStatement">&gt;&gt;</span> i) <span class="synStatement">&lt;&lt;</span> i) <span class="synStatement">!=</span> r { <span class="synConstant">self</span>.<span class="synIdentifier">push</span>((r <span class="synStatement">-</span> <span class="synConstant">1</span>) <span class="synStatement">&gt;&gt;</span> i); } } { <span class="synStatement">let</span> <span class="synType">mut</span> l <span class="synStatement">=</span> l; <span class="synStatement">let</span> <span class="synType">mut</span> r <span class="synStatement">=</span> r; <span class="synStatement">while</span> l <span class="synStatement">&lt;</span> r { <span class="synStatement">if</span> l <span class="synStatement">&amp;</span> <span class="synConstant">1</span> <span class="synStatement">!=</span> <span class="synConstant">0</span> { <span class="synConstant">self</span>.<span class="synIdentifier">all_apply</span>(l, f.<span class="synIdentifier">clone</span>()); l <span class="synStatement">+=</span> <span class="synConstant">1</span>; } <span class="synStatement">if</span> r <span class="synStatement">&amp;</span> <span class="synConstant">1</span> <span class="synStatement">!=</span> <span class="synConstant">0</span> { r <span class="synStatement">-=</span> <span class="synConstant">1</span>; <span class="synConstant">self</span>.<span class="synIdentifier">all_apply</span>(r, f.<span class="synIdentifier">clone</span>()); } l <span class="synStatement">&gt;&gt;=</span> <span class="synConstant">1</span>; r <span class="synStatement">&gt;&gt;=</span> <span class="synConstant">1</span>; } } <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">1</span>..<span class="synStatement">=</span><span class="synConstant">self</span>.log { <span class="synStatement">if</span> ((l <span class="synStatement">&gt;&gt;</span> i) <span class="synStatement">&lt;&lt;</span> i) <span class="synStatement">!=</span> l { <span class="synConstant">self</span>.<span class="synIdentifier">update</span>(l <span class="synStatement">&gt;&gt;</span> i); } <span class="synStatement">if</span> ((r <span class="synStatement">&gt;&gt;</span> i) <span class="synStatement">&lt;&lt;</span> i) <span class="synStatement">!=</span> r { <span class="synConstant">self</span>.<span class="synIdentifier">update</span>((r <span class="synStatement">-</span> <span class="synConstant">1</span>) <span class="synStatement">&gt;&gt;</span> i); } } } <span class="synStatement">fn</span> <span class="synIdentifier">update</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, k: <span class="synType">usize</span>) { <span class="synConstant">self</span>.data[k] <span class="synStatement">=</span> (<span class="synConstant">self</span>.op)(<span class="synType">&amp;</span><span class="synConstant">self</span>.data[<span class="synConstant">2</span> <span class="synStatement">*</span> k], <span class="synType">&amp;</span><span class="synConstant">self</span>.data[<span class="synConstant">2</span> <span class="synStatement">*</span> k <span class="synStatement">+</span> <span class="synConstant">1</span>]); } <span class="synStatement">fn</span> <span class="synIdentifier">all_apply</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, k: <span class="synType">usize</span>, f: F) { <span class="synConstant">self</span>.data[k] <span class="synStatement">=</span> (<span class="synConstant">self</span>.mapping)(<span class="synType">&amp;</span>f, <span class="synType">&amp;</span><span class="synConstant">self</span>.data[k]); <span class="synStatement">if</span> k <span class="synStatement">&lt;</span> <span class="synConstant">self</span>.size { <span class="synConstant">self</span>.lazy[k] <span class="synStatement">=</span> (<span class="synConstant">self</span>.composition)(<span class="synType">&amp;</span>f, <span class="synType">&amp;</span><span class="synConstant">self</span>.lazy[k]); } } <span class="synStatement">fn</span> <span class="synIdentifier">push</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, k: <span class="synType">usize</span>) { <span class="synConstant">self</span>.<span class="synIdentifier">all_apply</span>(<span class="synConstant">2</span> <span class="synStatement">*</span> k, <span class="synConstant">self</span>.lazy[k].<span class="synIdentifier">clone</span>()); <span class="synConstant">self</span>.<span class="synIdentifier">all_apply</span>(<span class="synConstant">2</span> <span class="synStatement">*</span> k <span class="synStatement">+</span> <span class="synConstant">1</span>, <span class="synConstant">self</span>.lazy[k].<span class="synIdentifier">clone</span>()); <span class="synConstant">self</span>.lazy[k] <span class="synStatement">=</span> (<span class="synConstant">self</span>.id)(); } } } <span class="synStatement">pub</span> <span class="synStatement">struct</span> <span class="synIdentifier">IO</span><span class="synStatement">&lt;</span>R, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span>(R, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>BufWriter<span class="synStatement">&lt;</span>W<span class="synStatement">&gt;</span>); <span class="synStatement">impl&lt;</span>R: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">new</span>(r: R, w: W) <span class="synStatement">-&gt;</span> <span class="synType">Self</span> { <span class="synType">Self</span>(r, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synPreProc">BufWriter</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(w)) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">write</span><span class="synStatement">&lt;</span>S: <span class="synType">ToString</span><span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, s: S) { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write; <span class="synConstant">self</span>.<span class="synConstant">1</span>.<span class="synIdentifier">write_all</span>(s.<span class="synIdentifier">to_string</span>().<span class="synIdentifier">as_bytes</span>()).<span class="synIdentifier">unwrap</span>(); } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">read</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> T { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read; <span class="synStatement">let</span> buf <span class="synStatement">=</span> <span class="synConstant">self</span> .<span class="synConstant">0</span> .<span class="synIdentifier">by_ref</span>() .<span class="synIdentifier">bytes</span>() .<span class="synIdentifier">map</span>(<span class="synStatement">|</span>b<span class="synStatement">|</span> b.<span class="synIdentifier">unwrap</span>()) .<span class="synIdentifier">skip_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">==</span> <span class="synConstant">b' '</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">take_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">!=</span> <span class="synConstant">b' '</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">collect</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span>_<span class="synStatement">&gt;&gt;</span>(); <span class="synStatement">unsafe</span> { <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span><span class="synIdentifier">from_utf8_unchecked</span>(<span class="synType">&amp;</span>buf) } .<span class="synIdentifier">parse</span>() .<span class="synIdentifier">ok</span>() .<span class="synIdentifier">expect</span>(<span class="synConstant">&quot;Parse error.&quot;</span>) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">usize0</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">usize</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;</span>() <span class="synStatement">-</span> <span class="synConstant">1</span> } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">vec</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, n: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span> { (<span class="synConstant">0</span>..n).<span class="synIdentifier">map</span>(<span class="synStatement">|</span>_<span class="synStatement">|</span> <span class="synConstant">self</span>.<span class="synIdentifier">read</span>()).<span class="synIdentifier">collect</span>() } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">chars</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">char</span><span class="synStatement">&gt;</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">String</span><span class="synStatement">&gt;</span>().<span class="synIdentifier">chars</span>().<span class="synIdentifier">collect</span>() } } </pre> kenkoooo Educational Codeforces Round 121 (Rated for Div. 2) E. Black and White Tree hatenablog://entry/13574176438054858491 2022-01-21T02:39:56+09:00 2022-01-21T02:39:56+09:00 問題 https://codeforces.com/contest/1626/problem/E 木があります。いくつかの頂点が黒く塗られています。黒い頂点は必ず2つ以上あります。ある頂点に駒があるとき、黒い頂点を1つ選択することで、駒を選択した頂点の方向に1回動かすことができます。2回連続で同じ頂点を選択することができない時、頂点iに置かれた駒を適切に黒い頂点を選択することでいずれかの黒い頂点まで移動させることができるか求めてください。 解法 駒が置かれた頂点から見て同じ方向に2つ黒い頂点があるとき、これらを交互に選択することでその方向に連続で移動することができる。このことから、黒い頂点に移… <h1>問題</h1> <p><a href="https://codeforces.com/contest/1626/problem/E">https://codeforces.com/contest/1626/problem/E</a></p> <p>木があります。いくつかの頂点が黒く塗られています。黒い頂点は必ず2つ以上あります。ある頂点に駒があるとき、黒い頂点を1つ選択することで、駒を選択した頂点の方向に1回動かすことができます。2回連続で同じ頂点を選択することができない時、頂点iに置かれた駒を適切に黒い頂点を選択することでいずれかの黒い頂点まで移動させることができるか求めてください。</p> <h1>解法</h1> <p>駒が置かれた頂点から見て同じ方向に2つ黒い頂点があるとき、これらを交互に選択することでその方向に連続で移動することができる。このことから、黒い頂点に移動できない頂点たちは、黒い頂点に囲まれた領域にあり、かつ、その領域の外に黒い頂点はない。</p> <p><span itemscope itemtype="http://schema.org/Photograph"><img src="https://cdn-ak.f.st-hatena.com/images/fotolife/k/kenkoooo/20220121/20220121023933.png" alt="f:id:kenkoooo:20220121023933p:plain" width="361" height="211" loading="lazy" title="" class="hatena-fotolife" itemprop="image"></span></p> <h1>コード</h1> <pre class="code lang-rust" data-lang="rust" data-unlink><span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">collections</span><span class="synSpecial">::</span>{BTreeSet, VecDeque}; <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">time</span><span class="synSpecial">::</span>Instant; <span class="synStatement">fn</span> <span class="synIdentifier">main</span>() { <span class="synStatement">let</span> (r, w) <span class="synStatement">=</span> (<span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdin</span>(), <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdout</span>()); <span class="synStatement">let</span> <span class="synType">mut</span> sc <span class="synStatement">=</span> <span class="synPreProc">IO</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(r.<span class="synIdentifier">lock</span>(), w.<span class="synIdentifier">lock</span>()); <span class="synStatement">let</span> n: <span class="synType">usize</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); <span class="synStatement">let</span> color: <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">i64</span><span class="synStatement">&gt;</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">vec</span>(n); <span class="synStatement">let</span> <span class="synType">mut</span> graph <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synPreProc">vec!</span>[]; n]; <span class="synStatement">for</span> _ <span class="synStatement">in</span> <span class="synConstant">1</span>..n { <span class="synStatement">let</span> u <span class="synStatement">=</span> sc.<span class="synIdentifier">usize0</span>(); <span class="synStatement">let</span> v <span class="synStatement">=</span> sc.<span class="synIdentifier">usize0</span>(); graph[u].<span class="synIdentifier">push</span>(v); graph[v].<span class="synIdentifier">push</span>(u); } <span class="synStatement">let</span> a <span class="synStatement">=</span> (<span class="synConstant">0</span>..n).<span class="synIdentifier">find</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>i<span class="synStatement">|</span> color[i] <span class="synStatement">==</span> <span class="synConstant">1</span>).<span class="synIdentifier">unwrap</span>(); <span class="synStatement">let</span> dist_a <span class="synStatement">=</span> <span class="synIdentifier">bfs</span>(<span class="synType">&amp;</span>graph, a); <span class="synStatement">let</span> b <span class="synStatement">=</span> (<span class="synConstant">0</span>..n) .<span class="synIdentifier">filter</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>i<span class="synStatement">|</span> i <span class="synStatement">!=</span> a <span class="synStatement">&amp;&amp;</span> color[i] <span class="synStatement">==</span> <span class="synConstant">1</span>) .<span class="synIdentifier">min_by_key</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>i<span class="synStatement">|</span> dist_a[i]) .<span class="synIdentifier">unwrap</span>(); <span class="synStatement">let</span> dist_b <span class="synStatement">=</span> <span class="synIdentifier">bfs</span>(<span class="synType">&amp;</span>graph, b); <span class="synStatement">let</span> ab <span class="synStatement">=</span> dist_b[a]; <span class="synStatement">let</span> ans <span class="synStatement">=</span> <span class="synStatement">if</span> <span class="synStatement">let</span> <span class="synConstant">Some</span>(x) <span class="synStatement">=</span> (<span class="synConstant">0</span>..n).<span class="synIdentifier">find</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>i<span class="synStatement">|</span> dist_b[i] <span class="synStatement">+</span> dist_a[i] <span class="synStatement">==</span> ab <span class="synStatement">&amp;&amp;</span> color[i] <span class="synStatement">==</span> <span class="synConstant">0</span>) { <span class="synStatement">let</span> <span class="synType">mut</span> q <span class="synStatement">=</span> <span class="synPreProc">VecDeque</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(); q.<span class="synIdentifier">push_back</span>(x); <span class="synStatement">let</span> n <span class="synStatement">=</span> graph.<span class="synIdentifier">len</span>(); <span class="synStatement">let</span> <span class="synType">mut</span> dist <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[n; n]; dist[x] <span class="synStatement">=</span> <span class="synConstant">0</span>; <span class="synStatement">while</span> <span class="synStatement">let</span> <span class="synConstant">Some</span>(v) <span class="synStatement">=</span> q.<span class="synIdentifier">pop_front</span>() { <span class="synStatement">if</span> color[v] <span class="synStatement">==</span> <span class="synConstant">1</span> { <span class="synStatement">continue</span>; } <span class="synStatement">for</span> <span class="synType">&amp;</span>next <span class="synStatement">in</span> graph[v].<span class="synIdentifier">iter</span>() { <span class="synStatement">if</span> dist[next] <span class="synStatement">&gt;</span> dist[v] <span class="synStatement">+</span> <span class="synConstant">1</span> { dist[next] <span class="synStatement">=</span> dist[v] <span class="synStatement">+</span> <span class="synConstant">1</span>; q.<span class="synIdentifier">push_back</span>(next); } } } <span class="synStatement">let</span> reached <span class="synStatement">=</span> (<span class="synConstant">0</span>..n).<span class="synIdentifier">filter</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>i<span class="synStatement">|</span> color[i] <span class="synStatement">==</span> <span class="synConstant">1</span> <span class="synStatement">&amp;&amp;</span> dist[i] <span class="synStatement">&lt;</span> n).<span class="synIdentifier">count</span>(); <span class="synStatement">let</span> total <span class="synStatement">=</span> (<span class="synConstant">0</span>..n).<span class="synIdentifier">filter</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>i<span class="synStatement">|</span> color[i] <span class="synStatement">==</span> <span class="synConstant">1</span>).<span class="synIdentifier">count</span>(); <span class="synStatement">if</span> reached <span class="synStatement">!=</span> total { <span class="synPreProc">vec!</span>[<span class="synConstant">1</span>; n] } <span class="synStatement">else</span> { <span class="synStatement">let</span> <span class="synType">mut</span> ans <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synConstant">1</span>; n]; <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..n { <span class="synStatement">if</span> dist[i] <span class="synStatement">&lt;</span> n { ans[i] <span class="synStatement">=</span> <span class="synConstant">0</span>; } } <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..n { <span class="synStatement">if</span> graph[i].<span class="synIdentifier">iter</span>().<span class="synIdentifier">any</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>i<span class="synStatement">|</span> color[i] <span class="synStatement">==</span> <span class="synConstant">1</span>) { ans[i] <span class="synStatement">=</span> <span class="synConstant">1</span>; } <span class="synStatement">if</span> color[i] <span class="synStatement">==</span> <span class="synConstant">1</span> { ans[i] <span class="synStatement">=</span> <span class="synConstant">1</span>; } } <span class="synStatement">let</span> <span class="synType">mut</span> s <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synPreProc">BTreeSet</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(); n]; <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..n { <span class="synStatement">for</span> <span class="synType">&amp;</span>j <span class="synStatement">in</span> graph[i].<span class="synIdentifier">iter</span>() { <span class="synStatement">if</span> dist[i] <span class="synStatement">&lt;</span> n <span class="synStatement">&amp;&amp;</span> dist[j] <span class="synStatement">&lt;</span> n { s[i].<span class="synIdentifier">insert</span>(j); } } } <span class="synStatement">let</span> <span class="synType">mut</span> q <span class="synStatement">=</span> <span class="synPreProc">VecDeque</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(); <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..n { <span class="synStatement">if</span> s[i].<span class="synIdentifier">len</span>() <span class="synStatement">==</span> <span class="synConstant">1</span> <span class="synStatement">&amp;&amp;</span> color[i] <span class="synStatement">==</span> <span class="synConstant">0</span> { q.<span class="synIdentifier">push_back</span>(i); } } <span class="synStatement">while</span> <span class="synStatement">let</span> <span class="synConstant">Some</span>(i) <span class="synStatement">=</span> q.<span class="synIdentifier">pop_front</span>() { <span class="synStatement">let</span> next <span class="synStatement">=</span> s[i].<span class="synIdentifier">clone</span>(); <span class="synStatement">for</span> next <span class="synStatement">in</span> next { <span class="synPreProc">assert!</span>(s[next].<span class="synIdentifier">remove</span>(<span class="synType">&amp;</span>i)); <span class="synStatement">if</span> s[next].<span class="synIdentifier">len</span>() <span class="synStatement">==</span> <span class="synConstant">1</span> <span class="synStatement">&amp;&amp;</span> color[next] <span class="synStatement">==</span> <span class="synConstant">0</span> { q.<span class="synIdentifier">push_back</span>(next); } } s[i].<span class="synIdentifier">clear</span>(); } <span class="synStatement">for</span> v <span class="synStatement">in</span> <span class="synConstant">0</span>..n { <span class="synStatement">if</span> graph[v].<span class="synIdentifier">iter</span>().<span class="synIdentifier">all</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>i<span class="synStatement">|</span> color[i] <span class="synStatement">==</span> <span class="synConstant">0</span>) { <span class="synStatement">continue</span>; } <span class="synStatement">for</span> <span class="synType">&amp;</span>next <span class="synStatement">in</span> graph[v].<span class="synIdentifier">iter</span>() { <span class="synStatement">if</span> s[next].<span class="synIdentifier">is_empty</span>() { <span class="synIdentifier">dfs</span>(next, v, <span class="synType">&amp;</span>graph, <span class="synType">&amp;mut</span> ans); } } } <span class="synStatement">if</span> (<span class="synConstant">0</span>..n) .<span class="synIdentifier">filter</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>i<span class="synStatement">|</span> s[i].<span class="synIdentifier">len</span>() <span class="synStatement">&gt;=</span> <span class="synConstant">3</span>) .<span class="synIdentifier">any</span>(<span class="synStatement">|</span>v<span class="synStatement">|</span> graph[v].<span class="synIdentifier">iter</span>().<span class="synIdentifier">any</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>next<span class="synStatement">|</span> color[next] <span class="synStatement">==</span> <span class="synConstant">1</span>)) { <span class="synPreProc">vec!</span>[<span class="synConstant">1</span>; n] } <span class="synStatement">else</span> { ans } } } <span class="synStatement">else</span> { <span class="synPreProc">assert_eq!</span>(ab, <span class="synConstant">1</span>); <span class="synPreProc">vec!</span>[<span class="synConstant">1</span>; n] }; <span class="synStatement">for</span> (i, ans) <span class="synStatement">in</span> ans.<span class="synIdentifier">into_iter</span>().<span class="synIdentifier">enumerate</span>() { <span class="synStatement">if</span> i <span class="synStatement">&gt;</span> <span class="synConstant">0</span> { sc.<span class="synIdentifier">write</span>(<span class="synConstant">' '</span>); } sc.<span class="synIdentifier">write</span>(ans); } sc.<span class="synIdentifier">write</span>(<span class="synConstant">'</span><span class="synSpecial">\n</span><span class="synConstant">'</span>); } <span class="synStatement">fn</span> <span class="synIdentifier">dfs</span>(v: <span class="synType">usize</span>, p: <span class="synType">usize</span>, graph: <span class="synType">&amp;Vec</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;&gt;</span>, ans: <span class="synType">&amp;mut</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">i64</span><span class="synStatement">&gt;</span>) { ans[v] <span class="synStatement">=</span> <span class="synConstant">1</span>; <span class="synStatement">for</span> <span class="synType">&amp;</span>next <span class="synStatement">in</span> graph[v].<span class="synIdentifier">iter</span>() { <span class="synStatement">if</span> p <span class="synStatement">==</span> next { <span class="synStatement">continue</span>; } <span class="synIdentifier">dfs</span>(next, v, graph, ans); } } <span class="synStatement">fn</span> <span class="synIdentifier">bfs</span>(graph: <span class="synType">&amp;Vec</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;&gt;</span>, from: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;</span> { <span class="synStatement">let</span> <span class="synType">mut</span> q <span class="synStatement">=</span> <span class="synPreProc">VecDeque</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(); q.<span class="synIdentifier">push_back</span>(from); <span class="synStatement">let</span> n <span class="synStatement">=</span> graph.<span class="synIdentifier">len</span>(); <span class="synStatement">let</span> <span class="synType">mut</span> dist <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[n; n]; dist[from] <span class="synStatement">=</span> <span class="synConstant">0</span>; <span class="synStatement">while</span> <span class="synStatement">let</span> <span class="synConstant">Some</span>(v) <span class="synStatement">=</span> q.<span class="synIdentifier">pop_front</span>() { <span class="synStatement">for</span> <span class="synType">&amp;</span>next <span class="synStatement">in</span> graph[v].<span class="synIdentifier">iter</span>() { <span class="synStatement">if</span> dist[next] <span class="synStatement">&gt;</span> dist[v] <span class="synStatement">+</span> <span class="synConstant">1</span> { dist[next] <span class="synStatement">=</span> dist[v] <span class="synStatement">+</span> <span class="synConstant">1</span>; q.<span class="synIdentifier">push_back</span>(next); } } } dist } <span class="synStatement">pub</span> <span class="synStatement">struct</span> <span class="synIdentifier">ReRooting</span><span class="synStatement">&lt;</span>T, Identity, Merge, AddRoot<span class="synStatement">&gt;</span> { dp: <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span>T<span class="synStatement">&gt;&gt;</span>, ans: <span class="synType">Vec</span><span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span>, graph: <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;&gt;</span>, identity: Identity, merge: Merge, add_root: AddRoot, } <span class="synStatement">impl&lt;</span>T, Identity, Merge, AddRoot<span class="synStatement">&gt;</span> ReRooting<span class="synStatement">&lt;</span>T, Identity, Merge, AddRoot<span class="synStatement">&gt;</span> <span class="synStatement">where</span> T: <span class="synType">Clone</span>, Identity: <span class="synType">Fn</span>() <span class="synStatement">-&gt;</span> T, Merge: <span class="synType">Fn</span>(T, T) <span class="synStatement">-&gt;</span> T, AddRoot: <span class="synType">Fn</span>(T) <span class="synStatement">-&gt;</span> T, { <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">new</span>(n: <span class="synType">usize</span>, identity: Identity, merge: Merge, add_root: AddRoot) <span class="synStatement">-&gt;</span> <span class="synType">Self</span> { <span class="synType">Self</span> { dp: <span class="synPreProc">vec!</span>[<span class="synPreProc">vec!</span>[]; n], ans: <span class="synPreProc">vec!</span>[<span class="synIdentifier">identity</span>(); n], graph: <span class="synPreProc">vec!</span>[<span class="synPreProc">vec!</span>[]; n], identity, merge, add_root, } } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">add_edge</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, a: <span class="synType">usize</span>, b: <span class="synType">usize</span>) { <span class="synConstant">self</span>.graph[a].<span class="synIdentifier">push</span>(b); } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">build</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) { <span class="synConstant">self</span>.<span class="synIdentifier">dfs</span>(<span class="synConstant">0</span>, <span class="synConstant">0</span>); <span class="synConstant">self</span>.<span class="synIdentifier">dfs2</span>(<span class="synConstant">0</span>, <span class="synConstant">0</span>, (<span class="synConstant">self</span>.identity)()); } <span class="synStatement">fn</span> <span class="synIdentifier">dfs</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, v: <span class="synType">usize</span>, p: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> T { <span class="synStatement">let</span> <span class="synType">mut</span> sum <span class="synStatement">=</span> (<span class="synConstant">self</span>.identity)(); <span class="synStatement">let</span> deg <span class="synStatement">=</span> <span class="synConstant">self</span>.graph[v].<span class="synIdentifier">len</span>(); <span class="synConstant">self</span>.dp[v] <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[(<span class="synConstant">self</span>.identity)(); deg]; <span class="synStatement">let</span> next <span class="synStatement">=</span> <span class="synConstant">self</span>.graph[v].<span class="synIdentifier">clone</span>(); <span class="synStatement">for</span> (i, next) <span class="synStatement">in</span> next.<span class="synIdentifier">into_iter</span>().<span class="synIdentifier">enumerate</span>() { <span class="synStatement">if</span> next <span class="synStatement">==</span> p { <span class="synStatement">continue</span>; } <span class="synStatement">let</span> t <span class="synStatement">=</span> <span class="synConstant">self</span>.<span class="synIdentifier">dfs</span>(next, v); <span class="synConstant">self</span>.dp[v][i] <span class="synStatement">=</span> t.<span class="synIdentifier">clone</span>(); sum <span class="synStatement">=</span> (<span class="synConstant">self</span>.merge)(sum, t); } (<span class="synConstant">self</span>.add_root)(sum) } <span class="synStatement">fn</span> <span class="synIdentifier">dfs2</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, v: <span class="synType">usize</span>, p: <span class="synType">usize</span>, dp_p: T) { <span class="synStatement">for</span> (i, <span class="synType">&amp;</span>next) <span class="synStatement">in</span> <span class="synConstant">self</span>.graph[v].<span class="synIdentifier">iter</span>().<span class="synIdentifier">enumerate</span>() { <span class="synStatement">if</span> next <span class="synStatement">==</span> p { <span class="synConstant">self</span>.dp[v][i] <span class="synStatement">=</span> dp_p.<span class="synIdentifier">clone</span>(); } } <span class="synStatement">let</span> deg <span class="synStatement">=</span> <span class="synConstant">self</span>.graph[v].<span class="synIdentifier">len</span>(); <span class="synStatement">let</span> <span class="synType">mut</span> dp_l <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[(<span class="synConstant">self</span>.identity)(); deg <span class="synStatement">+</span> <span class="synConstant">1</span>]; <span class="synStatement">let</span> <span class="synType">mut</span> dp_r <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[(<span class="synConstant">self</span>.identity)(); deg <span class="synStatement">+</span> <span class="synConstant">1</span>]; <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..deg { dp_l[i <span class="synStatement">+</span> <span class="synConstant">1</span>] <span class="synStatement">=</span> (<span class="synConstant">self</span>.merge)(dp_l[i].<span class="synIdentifier">clone</span>(), <span class="synConstant">self</span>.dp[v][i].<span class="synIdentifier">clone</span>()); } <span class="synStatement">for</span> i <span class="synStatement">in</span> (<span class="synConstant">0</span>..deg).<span class="synIdentifier">rev</span>() { dp_r[i] <span class="synStatement">=</span> (<span class="synConstant">self</span>.merge)(dp_r[i <span class="synStatement">+</span> <span class="synConstant">1</span>].<span class="synIdentifier">clone</span>(), <span class="synConstant">self</span>.dp[v][i].<span class="synIdentifier">clone</span>()); } <span class="synConstant">self</span>.ans[v] <span class="synStatement">=</span> (<span class="synConstant">self</span>.add_root)(dp_l[deg].<span class="synIdentifier">clone</span>()); <span class="synStatement">let</span> next <span class="synStatement">=</span> <span class="synConstant">self</span>.graph[v].<span class="synIdentifier">clone</span>(); <span class="synStatement">for</span> (i, next) <span class="synStatement">in</span> next.<span class="synIdentifier">into_iter</span>().<span class="synIdentifier">enumerate</span>() { <span class="synStatement">if</span> next <span class="synStatement">==</span> p { <span class="synStatement">continue</span>; } <span class="synConstant">self</span>.<span class="synIdentifier">dfs2</span>( next, v, (<span class="synConstant">self</span>.add_root)((<span class="synConstant">self</span>.merge)(dp_l[i].<span class="synIdentifier">clone</span>(), dp_r[i <span class="synStatement">+</span> <span class="synConstant">1</span>].<span class="synIdentifier">clone</span>())), ); } } } <span class="synStatement">pub</span> <span class="synStatement">struct</span> <span class="synIdentifier">IO</span><span class="synStatement">&lt;</span>R, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span>(R, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>BufWriter<span class="synStatement">&lt;</span>W<span class="synStatement">&gt;</span>); <span class="synStatement">impl&lt;</span>R: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">new</span>(r: R, w: W) <span class="synStatement">-&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synIdentifier">IO</span>(r, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synPreProc">BufWriter</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(w)) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">write</span><span class="synStatement">&lt;</span>S: <span class="synType">ToString</span><span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, s: S) { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write; <span class="synConstant">self</span>.<span class="synConstant">1</span>.<span class="synIdentifier">write_all</span>(s.<span class="synIdentifier">to_string</span>().<span class="synIdentifier">as_bytes</span>()).<span class="synIdentifier">unwrap</span>(); } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">read</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> T { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read; <span class="synStatement">let</span> buf <span class="synStatement">=</span> <span class="synConstant">self</span> .<span class="synConstant">0</span> .<span class="synIdentifier">by_ref</span>() .<span class="synIdentifier">bytes</span>() .<span class="synIdentifier">map</span>(<span class="synStatement">|</span>b<span class="synStatement">|</span> b.<span class="synIdentifier">unwrap</span>()) .<span class="synIdentifier">skip_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">==</span> <span class="synConstant">b' '</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">take_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">!=</span> <span class="synConstant">b' '</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">collect</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span>_<span class="synStatement">&gt;&gt;</span>(); <span class="synStatement">unsafe</span> { <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span><span class="synIdentifier">from_utf8_unchecked</span>(<span class="synType">&amp;</span>buf) } .<span class="synIdentifier">parse</span>() .<span class="synIdentifier">ok</span>() .<span class="synIdentifier">expect</span>(<span class="synConstant">&quot;Parse error.&quot;</span>) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">usize0</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">usize</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;</span>() <span class="synStatement">-</span> <span class="synConstant">1</span> } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">vec</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, n: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span> { (<span class="synConstant">0</span>..n).<span class="synIdentifier">map</span>(<span class="synStatement">|</span>_<span class="synStatement">|</span> <span class="synConstant">self</span>.<span class="synIdentifier">read</span>()).<span class="synIdentifier">collect</span>() } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">chars</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">char</span><span class="synStatement">&gt;</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">String</span><span class="synStatement">&gt;</span>().<span class="synIdentifier">chars</span>().<span class="synIdentifier">collect</span>() } } </pre> kenkoooo ABC233 G - Strongest Takahashi hatenablog://entry/13574176438046176699 2021-12-26T00:55:48+09:00 2021-12-26T00:55:48+09:00 atcoder.jp 空行はスキップして良いという発想も大事だが、そもそも全ての長方形領域を列挙した O(N4) もそこまで大きくないというのに気付かなかった。 |rust| const INF: i64 = 1 << 60; fn main() { let (r, w) = (std::io::stdin(), std::io::stdout()); let mut sc = IO::new(r.lock(), w.lock()); let n: usize = sc.read(); let map: Vec<Vec<char>> = (0..n).map(|_| sc.chars()).c… <p><iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fatcoder.jp%2Fcontests%2Fabc233%2Ftasks%2Fabc233_g" title="G - Strongest Takahashi" class="embed-card embed-webcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 155px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://atcoder.jp/contests/abc233/tasks/abc233_g">atcoder.jp</a></cite></p> <p>空行はスキップして良いという発想も大事だが、そもそも全ての長方形領域を列挙した O(N<sup>4</sup>) もそこまで大きくないというのに気付かなかった。</p> <blockquote><p>|rust| const INF: i64 = 1 &lt;&lt; 60; fn main() { let (r, w) = (std::io::stdin(), std::io::stdout()); let mut sc = IO::new(r.lock(), w.lock());</p></blockquote> <pre><code>let n: usize = sc.read(); let map: Vec&lt;Vec&lt;char&gt;&gt; = (0..n).map(|_| sc.chars()).collect(); let mut dp = vec![vec![vec![vec![INF; n + 1]; n]; n + 1]; n]; let ans = calc(&amp;map, 0, n, 0, n, &amp;mut dp); println!("{}", ans); </code></pre> <p>}</p> <p>fn calc( map: &amp;Vec&lt;Vec<char>>, r_from: usize, r_to: usize, c_from: usize, c_to: usize, memo: &amp;mut Vec&lt;Vec&lt;Vec&lt;Vec<i64>>>>, ) -> i64 { let dr = r_to - r_from; let dc = c_to - c_from; if dr.min(dc) == 0 { return 0; } if memo[r_from][r_to][c_from][c_to] &lt; INF { return memo[r_from][r_to][c_from][c_to]; }</p> <pre><code>let mut min_cost = dr.max(dc) as i64; for i in r_from..r_to { if (c_from..c_to).all(|j| map[i][j] == '.') { let head = calc(map, r_from, i, c_from, c_to, memo); let tail = calc(map, i + 1, r_to, c_from, c_to, memo); min_cost = min_cost.min(head + tail); } } for j in c_from..c_to { if (r_from..r_to).all(|i| map[i][j] == '.') { let left = calc(map, r_from, r_to, c_from, j, memo); let right = calc(map, r_from, r_to, j + 1, c_to, memo); min_cost = min_cost.min(left + right); } } memo[r_from][r_to][c_from][c_to] = min_cost; min_cost </code></pre> <p>}</p> <p>pub struct IO&lt;R, W: std::io::Write>(R, std::io::BufWriter<W>);</p> <p>impl&lt;R: std::io::Read, W: std::io::Write> IO&lt;R, W> { pub fn new(r: R, w: W) -> IO&lt;R, W> { IO(r, std::io::BufWriter::new(w)) } pub fn write&lt;S: ToString>(&amp;mut self, s: S) { use std::io::Write; self.1.write_all(s.to_string().as_bytes()).unwrap(); } pub fn read&lt;T: std::str::FromStr>(&amp;mut self) -> T { use std::io::Read; let buf = self .0 .by_ref() .bytes() .map(|b| b.unwrap()) .skip_while(|&amp;b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t') .take_while(|&amp;b| b != b' ' &amp;&amp; b != b'\n' &amp;&amp; b != b'\r' &amp;&amp; b != b'\t') .collect::&lt;Vec&lt;<em>>>(); unsafe { std::str::from_utf8_unchecked(&amp;buf) } .parse() .ok() .expect("Parse error.") } pub fn usize0(&amp;mut self) -> usize { self.read::<usize>() - 1 } pub fn vec&lt;T: std::str::FromStr>(&amp;mut self, n: usize) -> Vec<T> { (0..n).map(|</em>| self.read()).collect() } pub fn chars(&amp;mut self) -> Vec<char> { self.read::<String>().chars().collect() } }</p> <p>||&lt;</p> kenkoooo Put "open" to your class and its method when you get a NullPointerException by mocking your class by Mockito. hatenablog://entry/13574176438040064843 2021-12-06T12:58:25+09:00 2021-12-06T12:58:25+09:00 Problem When you have MyClass and try to write a test by mocking MyClass as the following, you will get an NPE: MyClass: open class MyClass { fun createList(string: String): List<String> { return listOf("A", "B", "C", string) } } Mocking MyClass by Mockito: import org.junit.jupiter.api.Test import o… <h1>Problem</h1> <p>When you have MyClass and try to write a test by mocking MyClass as the following, you will get an NPE:</p> <h3>MyClass:</h3> <pre class="code lang-kotlin" data-lang="kotlin" data-unlink><span class="synType">open</span> <span class="synType">class</span> MyClass { <span class="synType">fun</span> createList(string: <span class="synType">String</span>): <span class="synType">List</span>&lt;<span class="synType">String</span>&gt; { <span class="synStatement">return</span> listOf(<span class="synConstant">&quot;A&quot;</span>, <span class="synConstant">&quot;B&quot;</span>, <span class="synConstant">&quot;C&quot;</span>, string) } } </pre> <h3>Mocking MyClass by Mockito:</h3> <pre class="code lang-kotlin" data-lang="kotlin" data-unlink><span class="synPreProc">import</span> org.junit.jupiter.api.Test <span class="synPreProc">import</span> org.mockito.kotlin.any <span class="synPreProc">import</span> org.mockito.kotlin.mock <span class="synPreProc">import</span> org.mockito.kotlin.whenever <span class="synType">class</span> TestMyClass { <span class="synIdentifier">@Test</span> <span class="synType">fun</span> testMyClass() { <span class="synType">val</span> mock = mock&lt;MyClass&gt;() whenever(mock.createList(any())).thenReturn(emptyList()) } } </pre> <h3>Exception you will get:</h3> <pre class="code log" data-lang="log" data-unlink>java.lang.NullPointerException: Parameter specified as non-null is null: method MyClass.createList, parameter string</pre> <h1>Solution: Put "open" not only to your class but also to the method</h1> <pre class="code lang-diff" data-lang="diff" data-unlink>open class MyClass { <span class="synIdentifier">+ open fun createList(string: String): List&lt;String&gt; {</span> <span class="synSpecial">- fun createList(string: String): List&lt;String&gt; {</span> return listOf(&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, string) } } </pre> kenkoooo 2021/11/21 hatenablog://entry/13574176438035261239 2021-11-22T00:59:04+09:00 2021-11-22T02:23:27+09:00 ARC129A - Smaller XOR atcoder.jp 頑張って桁DPをやっていて、解説を読んで崩れ落ちた… fn main() { let (r, w) = (std::io::stdin(), std::io::stdout()); let mut sc = IO::new(r.lock(), w.lock()); let n: i64 = sc.read(); let l: i64 = sc.read(); let r: i64 = sc.read(); let ans = solve(n, r) - solve(n, l - 1); println!("{}", ans); … <h1>ARC129A - Smaller XOR</h1> <p><iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fatcoder.jp%2Fcontests%2Farc129%2Ftasks%2Farc129_a" title="A - Smaller XOR" class="embed-card embed-webcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 155px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://atcoder.jp/contests/arc129/tasks/arc129_a">atcoder.jp</a></cite></p> <p>頑張って桁DPをやっていて、解説を読んで崩れ落ちた…</p> <pre class="code lang-rust" data-lang="rust" data-unlink><span class="synStatement">fn</span> <span class="synIdentifier">main</span>() { <span class="synStatement">let</span> (r, w) <span class="synStatement">=</span> (<span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdin</span>(), <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdout</span>()); <span class="synStatement">let</span> <span class="synType">mut</span> sc <span class="synStatement">=</span> <span class="synPreProc">IO</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(r.<span class="synIdentifier">lock</span>(), w.<span class="synIdentifier">lock</span>()); <span class="synStatement">let</span> n: <span class="synType">i64</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); <span class="synStatement">let</span> l: <span class="synType">i64</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); <span class="synStatement">let</span> r: <span class="synType">i64</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); <span class="synStatement">let</span> ans <span class="synStatement">=</span> <span class="synIdentifier">solve</span>(n, r) <span class="synStatement">-</span> <span class="synIdentifier">solve</span>(n, l <span class="synStatement">-</span> <span class="synConstant">1</span>); <span class="synPreProc">println!</span>(<span class="synConstant">&quot;{}&quot;</span>, ans); } <span class="synStatement">fn</span> <span class="synIdentifier">solve</span>(n: <span class="synType">i64</span>, max: <span class="synType">i64</span>) <span class="synStatement">-&gt;</span> <span class="synType">i64</span> { <span class="synStatement">let</span> <span class="synType">mut</span> dp <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synPreProc">vec!</span>[<span class="synPreProc">vec!</span>[<span class="synConstant">0</span>; <span class="synConstant">2</span>]; <span class="synConstant">2</span>]; <span class="synConstant">2</span>]; dp[<span class="synConstant">0</span>][<span class="synConstant">0</span>][<span class="synConstant">0</span>] <span class="synStatement">=</span> <span class="synConstant">1</span>; <span class="synStatement">for</span> pos <span class="synStatement">in</span> (<span class="synConstant">0</span>..<span class="synConstant">63</span>).<span class="synIdentifier">rev</span>() { <span class="synStatement">let</span> max_d <span class="synStatement">=</span> (max <span class="synStatement">&gt;&gt;</span> pos) <span class="synStatement">&amp;</span> <span class="synConstant">1</span>; <span class="synStatement">let</span> n_d <span class="synStatement">=</span> (n <span class="synStatement">&gt;&gt;</span> pos) <span class="synStatement">&amp;</span> <span class="synConstant">1</span>; <span class="synStatement">let</span> <span class="synType">mut</span> next <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synPreProc">vec!</span>[<span class="synPreProc">vec!</span>[<span class="synConstant">0</span>; <span class="synConstant">2</span>]; <span class="synConstant">2</span>]; <span class="synConstant">2</span>]; <span class="synStatement">for</span> started <span class="synStatement">in</span> <span class="synConstant">0</span>..<span class="synConstant">2</span> { <span class="synStatement">let</span> is_started <span class="synStatement">=</span> started <span class="synStatement">==</span> <span class="synConstant">1</span>; <span class="synStatement">for</span> lower <span class="synStatement">in</span> <span class="synConstant">0</span>..<span class="synConstant">2</span> { <span class="synStatement">let</span> is_lower <span class="synStatement">=</span> lower <span class="synStatement">==</span> <span class="synConstant">1</span>; <span class="synStatement">for</span> xor_lower <span class="synStatement">in</span> <span class="synConstant">0</span>..<span class="synConstant">2</span> { <span class="synStatement">for</span> next_digit <span class="synStatement">in</span> <span class="synConstant">0</span>..<span class="synConstant">2</span> { <span class="synStatement">let</span> next_started <span class="synStatement">=</span> <span class="synStatement">if</span> is_started <span class="synStatement">||</span> next_digit <span class="synStatement">==</span> <span class="synConstant">1</span> { <span class="synConstant">1</span> } <span class="synStatement">else</span> { <span class="synConstant">0</span> }; <span class="synStatement">let</span> next_lower <span class="synStatement">=</span> <span class="synStatement">if</span> is_lower <span class="synStatement">||</span> max_d <span class="synStatement">&gt;</span> next_digit { <span class="synConstant">1</span> } <span class="synStatement">else</span> { <span class="synConstant">0</span> }; <span class="synStatement">let</span> next_n_lower <span class="synStatement">=</span> <span class="synStatement">if</span> xor_lower <span class="synStatement">==</span> <span class="synConstant">1</span> <span class="synStatement">||</span> (next_digit <span class="synStatement">==</span> <span class="synConstant">1</span> <span class="synStatement">&amp;&amp;</span> n_d <span class="synStatement">==</span> <span class="synConstant">1</span>) { <span class="synConstant">1</span> } <span class="synStatement">else</span> { <span class="synConstant">0</span> }; <span class="synStatement">if</span> next_lower <span class="synStatement">!=</span> <span class="synConstant">1</span> <span class="synStatement">&amp;&amp;</span> max_d <span class="synStatement">&lt;</span> next_digit { <span class="synStatement">continue</span>; } <span class="synStatement">if</span> next_n_lower <span class="synStatement">!=</span> <span class="synConstant">1</span> <span class="synStatement">&amp;&amp;</span> next_digit <span class="synStatement">==</span> <span class="synConstant">1</span> { <span class="synStatement">continue</span>; } next[next_started][next_lower][next_n_lower] <span class="synStatement">+=</span> dp[started][lower][xor_lower]; } } } } dp <span class="synStatement">=</span> next; <span class="synComment">// eprintln!(&quot;{:?}&quot;, dp);</span> } <span class="synStatement">let</span> ans <span class="synStatement">=</span> dp[<span class="synConstant">1</span>][<span class="synConstant">0</span>][<span class="synConstant">1</span>] <span class="synStatement">+</span> dp[<span class="synConstant">1</span>][<span class="synConstant">1</span>][<span class="synConstant">1</span>]; ans } <span class="synStatement">pub</span> <span class="synStatement">struct</span> <span class="synIdentifier">IO</span><span class="synStatement">&lt;</span>R, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span>(R, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>BufWriter<span class="synStatement">&lt;</span>W<span class="synStatement">&gt;</span>); <span class="synStatement">impl&lt;</span>R: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">new</span>(r: R, w: W) <span class="synStatement">-&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synIdentifier">IO</span>(r, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synPreProc">BufWriter</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(w)) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">write</span><span class="synStatement">&lt;</span>S: <span class="synType">ToString</span><span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, s: S) { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write; <span class="synConstant">self</span>.<span class="synConstant">1</span>.<span class="synIdentifier">write_all</span>(s.<span class="synIdentifier">to_string</span>().<span class="synIdentifier">as_bytes</span>()).<span class="synIdentifier">unwrap</span>(); } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">read</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> T { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read; <span class="synStatement">let</span> buf <span class="synStatement">=</span> <span class="synConstant">self</span> .<span class="synConstant">0</span> .<span class="synIdentifier">by_ref</span>() .<span class="synIdentifier">bytes</span>() .<span class="synIdentifier">map</span>(<span class="synStatement">|</span>b<span class="synStatement">|</span> b.<span class="synIdentifier">unwrap</span>()) .<span class="synIdentifier">skip_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">==</span> <span class="synConstant">b' '</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">take_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">!=</span> <span class="synConstant">b' '</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">collect</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span>_<span class="synStatement">&gt;&gt;</span>(); <span class="synStatement">unsafe</span> { <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span><span class="synIdentifier">from_utf8_unchecked</span>(<span class="synType">&amp;</span>buf) } .<span class="synIdentifier">parse</span>() .<span class="synIdentifier">ok</span>() .<span class="synIdentifier">expect</span>(<span class="synConstant">&quot;Parse error.&quot;</span>) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">usize0</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">usize</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;</span>() <span class="synStatement">-</span> <span class="synConstant">1</span> } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">vec</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, n: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span> { (<span class="synConstant">0</span>..n).<span class="synIdentifier">map</span>(<span class="synStatement">|</span>_<span class="synStatement">|</span> <span class="synConstant">self</span>.<span class="synIdentifier">read</span>()).<span class="synIdentifier">collect</span>() } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">chars</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">char</span><span class="synStatement">&gt;</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">String</span><span class="synStatement">&gt;</span>().<span class="synIdentifier">chars</span>().<span class="synIdentifier">collect</span>() } } </pre> <h1>ARC129D - -1+2-1</h1> <p><iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fatcoder.jp%2Fcontests%2Farc129%2Ftasks%2Farc129_d" title="D - -1+2-1" class="embed-card embed-webcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 155px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://atcoder.jp/contests/arc129/tasks/arc129_d">atcoder.jp</a></cite></p> <p>面白かった。数列に対する操作を行う時、数列そのものの変化よりも、その数列の階差数列の変化を観察した方が分かりやすくなることがある。この問題はその逆バージョンで、与えられた数列が階差数列だとして、元の数列に対する変化がどのようなものか考えることで解ける。</p> <pre class="code lang-rust" data-lang="rust" data-unlink><span class="synStatement">fn</span> <span class="synIdentifier">main</span>() { <span class="synStatement">let</span> (r, w) <span class="synStatement">=</span> (<span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdin</span>(), <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdout</span>()); <span class="synStatement">let</span> <span class="synType">mut</span> sc <span class="synStatement">=</span> <span class="synPreProc">IO</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(r.<span class="synIdentifier">lock</span>(), w.<span class="synIdentifier">lock</span>()); <span class="synStatement">let</span> n: <span class="synType">usize</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); <span class="synStatement">let</span> a: <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">i64</span><span class="synStatement">&gt;</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">vec</span>(n); <span class="synStatement">if</span> a.<span class="synIdentifier">iter</span>().<span class="synIdentifier">sum</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">i64</span><span class="synStatement">&gt;</span>() <span class="synStatement">!=</span> <span class="synConstant">0</span> { <span class="synPreProc">println!</span>(<span class="synConstant">&quot;-1&quot;</span>); <span class="synStatement">return</span>; } <span class="synStatement">let</span> <span class="synType">mut</span> b <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synConstant">0</span>; n]; <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">1</span>..n { b[i] <span class="synStatement">=</span> b[i <span class="synStatement">-</span> <span class="synConstant">1</span>] <span class="synStatement">+</span> a[i <span class="synStatement">-</span> <span class="synConstant">1</span>]; } <span class="synPreProc">assert_eq!</span>(b[<span class="synConstant">0</span>], <span class="synConstant">0</span>); <span class="synPreProc">assert_eq!</span>(b[n <span class="synStatement">-</span> <span class="synConstant">1</span>] <span class="synStatement">+</span> a[n <span class="synStatement">-</span> <span class="synConstant">1</span>], <span class="synConstant">0</span>); <span class="synStatement">let</span> b_sum <span class="synStatement">=</span> b.<span class="synIdentifier">iter</span>().<span class="synIdentifier">sum</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">i64</span><span class="synStatement">&gt;</span>(); <span class="synStatement">if</span> b_sum <span class="synStatement">%</span> (n <span class="synStatement">as</span> <span class="synType">i64</span>) <span class="synStatement">!=</span> <span class="synConstant">0</span> { <span class="synPreProc">println!</span>(<span class="synConstant">&quot;-1&quot;</span>); <span class="synStatement">return</span>; } <span class="synStatement">let</span> one <span class="synStatement">=</span> b_sum <span class="synStatement">/</span> (n <span class="synStatement">as</span> <span class="synType">i64</span>); <span class="synStatement">for</span> b <span class="synStatement">in</span> b.<span class="synIdentifier">iter_mut</span>() { <span class="synType">*</span>b <span class="synStatement">-=</span> one; } <span class="synStatement">let</span> <span class="synType">mut</span> ans <span class="synStatement">=</span> <span class="synConstant">0</span>; <span class="synStatement">let</span> <span class="synType">mut</span> carry <span class="synStatement">=</span> <span class="synConstant">0</span>; <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..(<span class="synConstant">3</span> <span class="synStatement">*</span> n) { <span class="synStatement">if</span> b[i <span class="synStatement">%</span> n] <span class="synStatement">&gt;</span> <span class="synConstant">0</span> { carry <span class="synStatement">+=</span> b[i <span class="synStatement">%</span> n]; b[i <span class="synStatement">%</span> n] <span class="synStatement">=</span> <span class="synConstant">0</span>; } <span class="synStatement">else</span> { <span class="synStatement">let</span> t <span class="synStatement">=</span> carry.<span class="synIdentifier">min</span>(<span class="synStatement">-</span>b[i <span class="synStatement">%</span> n]); carry <span class="synStatement">-=</span> t; b[i <span class="synStatement">%</span> n] <span class="synStatement">+=</span> t; } ans <span class="synStatement">+=</span> carry; } <span class="synPreProc">println!</span>(<span class="synConstant">&quot;{}&quot;</span>, ans); } <span class="synStatement">pub</span> <span class="synStatement">struct</span> <span class="synIdentifier">IO</span><span class="synStatement">&lt;</span>R, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span>(R, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>BufWriter<span class="synStatement">&lt;</span>W<span class="synStatement">&gt;</span>); <span class="synStatement">impl&lt;</span>R: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">new</span>(r: R, w: W) <span class="synStatement">-&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synIdentifier">IO</span>(r, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synPreProc">BufWriter</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(w)) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">write</span><span class="synStatement">&lt;</span>S: <span class="synType">ToString</span><span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, s: S) { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write; <span class="synConstant">self</span>.<span class="synConstant">1</span>.<span class="synIdentifier">write_all</span>(s.<span class="synIdentifier">to_string</span>().<span class="synIdentifier">as_bytes</span>()).<span class="synIdentifier">unwrap</span>(); } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">read</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> T { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read; <span class="synStatement">let</span> buf <span class="synStatement">=</span> <span class="synConstant">self</span> .<span class="synConstant">0</span> .<span class="synIdentifier">by_ref</span>() .<span class="synIdentifier">bytes</span>() .<span class="synIdentifier">map</span>(<span class="synStatement">|</span>b<span class="synStatement">|</span> b.<span class="synIdentifier">unwrap</span>()) .<span class="synIdentifier">skip_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">==</span> <span class="synConstant">b' '</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">take_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">!=</span> <span class="synConstant">b' '</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">collect</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span>_<span class="synStatement">&gt;&gt;</span>(); <span class="synStatement">unsafe</span> { <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span><span class="synIdentifier">from_utf8_unchecked</span>(<span class="synType">&amp;</span>buf) } .<span class="synIdentifier">parse</span>() .<span class="synIdentifier">ok</span>() .<span class="synIdentifier">expect</span>(<span class="synConstant">&quot;Parse error.&quot;</span>) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">usize0</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">usize</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;</span>() <span class="synStatement">-</span> <span class="synConstant">1</span> } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">vec</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, n: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span> { (<span class="synConstant">0</span>..n).<span class="synIdentifier">map</span>(<span class="synStatement">|</span>_<span class="synStatement">|</span> <span class="synConstant">self</span>.<span class="synIdentifier">read</span>()).<span class="synIdentifier">collect</span>() } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">chars</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">char</span><span class="synStatement">&gt;</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">String</span><span class="synStatement">&gt;</span>().<span class="synIdentifier">chars</span>().<span class="synIdentifier">collect</span>() } } </pre> <h1>ARC129C - Multiple of 7</h1> <p><iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fatcoder.jp%2Fcontests%2Farc129%2Ftasks%2Farc129_c" title="C - Multiple of 7" class="embed-card embed-webcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 155px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://atcoder.jp/contests/arc129/tasks/arc129_c">atcoder.jp</a></cite></p> <p>「文字列の[l..r]を切り出して数としてみた時、これがxの倍数となっている」というのは [0..l]00000... と [0..r]000... を割ったあまりが等しいことを意味する。例えば1234567789の77の部分が7の倍数であるのは、1234560000と1234567700のあまりが等しいことと同値。これを見つけられずに謎の解法で殴り倒してしまった。</p> <pre class="code lang-rust" data-lang="rust" data-unlink><span class="synStatement">fn</span> <span class="synIdentifier">main</span>() { <span class="synStatement">let</span> (r, w) <span class="synStatement">=</span> (<span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdin</span>(), <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdout</span>()); <span class="synStatement">let</span> <span class="synType">mut</span> sc <span class="synStatement">=</span> <span class="synPreProc">IO</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(r.<span class="synIdentifier">lock</span>(), w.<span class="synIdentifier">lock</span>()); <span class="synStatement">let</span> n: <span class="synType">i64</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); <span class="synStatement">let</span> ans <span class="synStatement">=</span> <span class="synIdentifier">solve</span>(n); <span class="synStatement">for</span> ans <span class="synStatement">in</span> ans { sc.<span class="synIdentifier">write</span>(ans); } sc.<span class="synIdentifier">write</span>(<span class="synConstant">'</span><span class="synSpecial">\n</span><span class="synConstant">'</span>); } <span class="synStatement">fn</span> <span class="synIdentifier">solve</span>(n: <span class="synType">i64</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">i64</span><span class="synStatement">&gt;</span> { <span class="synStatement">let</span> <span class="synType">mut</span> c <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[]; <span class="synStatement">let</span> <span class="synType">mut</span> z <span class="synStatement">=</span> n; <span class="synStatement">while</span> z <span class="synStatement">&gt;</span> <span class="synConstant">0</span> { <span class="synStatement">let</span> x <span class="synStatement">=</span> (z <span class="synStatement">as</span> <span class="synType">f64</span> <span class="synStatement">+</span> <span class="synConstant">100.0</span>).<span class="synIdentifier">sqrt</span>() <span class="synStatement">as</span> <span class="synType">i64</span> <span class="synStatement">*</span> <span class="synConstant">2</span>; <span class="synStatement">for</span> k <span class="synStatement">in</span> (<span class="synConstant">1</span>..<span class="synStatement">=</span>x).<span class="synIdentifier">rev</span>() { <span class="synStatement">if</span> k <span class="synStatement">*</span> (k <span class="synStatement">-</span> <span class="synConstant">1</span>) <span class="synStatement">/</span> <span class="synConstant">2</span> <span class="synStatement">&lt;=</span> z { c.<span class="synIdentifier">push</span>(k); z <span class="synStatement">-=</span> k <span class="synStatement">*</span> (k <span class="synStatement">-</span> <span class="synConstant">1</span>) <span class="synStatement">/</span> <span class="synConstant">2</span>; <span class="synStatement">break</span>; } } } <span class="synPreProc">assert!</span>(c.<span class="synIdentifier">len</span>() <span class="synStatement">&lt;=</span> <span class="synConstant">7</span>, <span class="synConstant">&quot;n={} c={:?}&quot;</span>, n, c); <span class="synStatement">let</span> <span class="synType">mut</span> b <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[]; <span class="synStatement">for</span> (target, count) <span class="synStatement">in</span> c.<span class="synIdentifier">into_iter</span>().<span class="synIdentifier">enumerate</span>() { <span class="synStatement">let</span> target <span class="synStatement">=</span> target <span class="synStatement">as</span> <span class="synType">i64</span>; <span class="synStatement">let</span> count <span class="synStatement">=</span> <span class="synStatement">if</span> target <span class="synStatement">==</span> <span class="synConstant">0</span> { count <span class="synStatement">-</span> <span class="synConstant">1</span> } <span class="synStatement">else</span> { count }; <span class="synStatement">for</span> _ <span class="synStatement">in</span> <span class="synConstant">0</span>..count { b.<span class="synIdentifier">push</span>(target); } } b.<span class="synIdentifier">push</span>(<span class="synConstant">0</span>); b.<span class="synIdentifier">reverse</span>(); <span class="synStatement">let</span> n <span class="synStatement">=</span> b.<span class="synIdentifier">len</span>(); <span class="synStatement">let</span> <span class="synType">mut</span> ans <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[]; <span class="synStatement">let</span> <span class="synType">mut</span> pow10 <span class="synStatement">=</span> <span class="synConstant">1</span>; <span class="synStatement">for</span> i <span class="synStatement">in</span> (<span class="synConstant">1</span>..n).<span class="synIdentifier">rev</span>() { <span class="synStatement">let</span> prev <span class="synStatement">=</span> b[i <span class="synStatement">-</span> <span class="synConstant">1</span>]; <span class="synStatement">let</span> next <span class="synStatement">=</span> b[i]; <span class="synStatement">for</span> x <span class="synStatement">in</span> <span class="synConstant">1</span>.. { <span class="synPreProc">assert!</span>(x <span class="synStatement">&lt;</span> <span class="synConstant">10</span>); <span class="synStatement">if</span> (prev <span class="synStatement">+</span> x <span class="synStatement">*</span> pow10) <span class="synStatement">%</span> <span class="synConstant">7</span> <span class="synStatement">==</span> next { ans.<span class="synIdentifier">push</span>(x); <span class="synStatement">break</span>; } } pow10 <span class="synStatement">=</span> (pow10 <span class="synStatement">*</span> <span class="synConstant">10</span>) <span class="synStatement">%</span> <span class="synConstant">7</span>; } ans.<span class="synIdentifier">reverse</span>(); ans } <span class="synStatement">pub</span> <span class="synStatement">struct</span> <span class="synIdentifier">IO</span><span class="synStatement">&lt;</span>R, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span>(R, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>BufWriter<span class="synStatement">&lt;</span>W<span class="synStatement">&gt;</span>); <span class="synStatement">impl&lt;</span>R: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">new</span>(r: R, w: W) <span class="synStatement">-&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synIdentifier">IO</span>(r, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synPreProc">BufWriter</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(w)) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">write</span><span class="synStatement">&lt;</span>S: <span class="synType">ToString</span><span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, s: S) { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write; <span class="synConstant">self</span>.<span class="synConstant">1</span>.<span class="synIdentifier">write_all</span>(s.<span class="synIdentifier">to_string</span>().<span class="synIdentifier">as_bytes</span>()).<span class="synIdentifier">unwrap</span>(); } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">read</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> T { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read; <span class="synStatement">let</span> buf <span class="synStatement">=</span> <span class="synConstant">self</span> .<span class="synConstant">0</span> .<span class="synIdentifier">by_ref</span>() .<span class="synIdentifier">bytes</span>() .<span class="synIdentifier">map</span>(<span class="synStatement">|</span>b<span class="synStatement">|</span> b.<span class="synIdentifier">unwrap</span>()) .<span class="synIdentifier">skip_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">==</span> <span class="synConstant">b' '</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">take_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">!=</span> <span class="synConstant">b' '</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">collect</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span>_<span class="synStatement">&gt;&gt;</span>(); <span class="synStatement">unsafe</span> { <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span><span class="synIdentifier">from_utf8_unchecked</span>(<span class="synType">&amp;</span>buf) } .<span class="synIdentifier">parse</span>() .<span class="synIdentifier">ok</span>() .<span class="synIdentifier">expect</span>(<span class="synConstant">&quot;Parse error.&quot;</span>) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">usize0</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">usize</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;</span>() <span class="synStatement">-</span> <span class="synConstant">1</span> } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">vec</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, n: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span> { (<span class="synConstant">0</span>..n).<span class="synIdentifier">map</span>(<span class="synStatement">|</span>_<span class="synStatement">|</span> <span class="synConstant">self</span>.<span class="synIdentifier">read</span>()).<span class="synIdentifier">collect</span>() } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">chars</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">char</span><span class="synStatement">&gt;</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">String</span><span class="synStatement">&gt;</span>().<span class="synIdentifier">chars</span>().<span class="synIdentifier">collect</span>() } } </pre> kenkoooo 2021/11/17 hatenablog://entry/13574176438034009776 2021-11-18T02:09:39+09:00 2021-11-18T02:09:39+09:00 Codeforces Round #751 (Div. 1) C. Optimal Insertion codeforces.com とりあえずbはソートしても良いことが分かって、aに挿入された後のb全体で見てもソートされていることが分かる。すると、bを小さい順にaに挿入していくと、既に挿入されたbの値と後から挿入されるbの値はお互いに影響しないことが分かる。よって、各biの挿入は独立に考えてよく、biは挿入した際に増える反点数が最小であるような位置に挿入すれば良い。複数ある場合は一番前にすると無難。 use crate::fenwick_tree::FenwickTree; use crat… <h1><a class="keyword" href="http://d.hatena.ne.jp/keyword/Codeforces">Codeforces</a> Round #751 (Div. 1) C. Optimal Insertion</h1> <p><iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fcodeforces.com%2Fcontest%2F1601%2Fproblem%2FC" title="Problem - C - Codeforces" class="embed-card embed-webcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 155px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://codeforces.com/contest/1601/problem/C">codeforces.com</a></cite></p> <p>とりあえずbはソートしても良いことが分かって、aに挿入された後のb全体で見てもソートされていることが分かる。すると、bを小さい順にaに挿入していくと、既に挿入されたbの値と後から挿入されるbの値はお互いに影響しないことが分かる。よって、各biの挿入は独立に考えてよく、biは挿入した際に増える反点数が最小であるような位置に挿入すれば良い。複数ある場合は一番前にすると無難。</p> <pre class="code lang-rust" data-lang="rust" data-unlink><span class="synStatement">use</span> <span class="synPreProc">crate</span><span class="synSpecial">::</span><span class="synPreProc">fenwick_tree</span><span class="synSpecial">::</span>FenwickTree; <span class="synStatement">use</span> <span class="synPreProc">crate</span><span class="synSpecial">::</span><span class="synPreProc">lazy_segment_tree</span><span class="synSpecial">::</span>LazySegmentTree; <span class="synStatement">fn</span> <span class="synIdentifier">main</span>() { <span class="synStatement">let</span> (r, w) <span class="synStatement">=</span> (<span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdin</span>(), <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdout</span>()); <span class="synStatement">let</span> <span class="synType">mut</span> sc <span class="synStatement">=</span> <span class="synPreProc">IO</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(r.<span class="synIdentifier">lock</span>(), w.<span class="synIdentifier">lock</span>()); <span class="synStatement">let</span> t: <span class="synType">usize</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); <span class="synStatement">for</span> _ <span class="synStatement">in</span> <span class="synConstant">0</span>..t { <span class="synStatement">let</span> n: <span class="synType">usize</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); <span class="synStatement">let</span> m: <span class="synType">usize</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); <span class="synStatement">let</span> <span class="synType">mut</span> a <span class="synStatement">=</span> <span class="synType">Vec</span><span class="synSpecial">::</span><span class="synIdentifier">with_capacity</span>(n); <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..n { <span class="synStatement">let</span> x: <span class="synType">i64</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); a.<span class="synIdentifier">push</span>((x, i)); } <span class="synStatement">let</span> <span class="synType">mut</span> b: <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">i64</span><span class="synStatement">&gt;</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">vec</span>(m); a.<span class="synIdentifier">sort</span>(); b.<span class="synIdentifier">sort</span>(); <span class="synStatement">let</span> ans <span class="synStatement">=</span> <span class="synIdentifier">solve</span>(a, b); sc.<span class="synIdentifier">write</span>(ans); sc.<span class="synIdentifier">write</span>(<span class="synConstant">'</span><span class="synSpecial">\n</span><span class="synConstant">'</span>); } } <span class="synType">const</span> INF: <span class="synType">i64</span> <span class="synStatement">=</span> <span class="synConstant">1</span> <span class="synStatement">&lt;&lt;</span> <span class="synConstant">60</span>; <span class="synStatement">fn</span> <span class="synIdentifier">solve</span>(a: <span class="synType">Vec</span><span class="synStatement">&lt;</span>(<span class="synType">i64</span>, <span class="synType">usize</span>)<span class="synStatement">&gt;</span>, b: <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">i64</span><span class="synStatement">&gt;</span>) <span class="synStatement">-&gt;</span> <span class="synType">i64</span> { <span class="synStatement">let</span> n <span class="synStatement">=</span> a.<span class="synIdentifier">len</span>() <span class="synStatement">+</span> <span class="synConstant">1</span>; <span class="synStatement">let</span> <span class="synType">mut</span> min_seg <span class="synStatement">=</span> <span class="synPreProc">LazySegmentTree</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>( n, <span class="synStatement">||</span> (INF, n), <span class="synStatement">|</span><span class="synType">&amp;</span>s: <span class="synType">&amp;</span>(<span class="synType">i64</span>, <span class="synType">usize</span>), <span class="synType">&amp;</span>t: <span class="synType">&amp;</span>(<span class="synType">i64</span>, <span class="synType">usize</span>)<span class="synStatement">|</span> s.<span class="synIdentifier">min</span>(t), <span class="synStatement">|</span><span class="synType">&amp;</span>f, <span class="synType">&amp;</span>(x, i)<span class="synStatement">|</span> (f <span class="synStatement">+</span> x, i), <span class="synStatement">|</span><span class="synType">&amp;</span>f, <span class="synType">&amp;</span>g<span class="synStatement">|</span> f <span class="synStatement">+</span> g, <span class="synStatement">||</span> <span class="synConstant">0</span>, ); <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..n { min_seg.<span class="synIdentifier">set</span>(i, (<span class="synConstant">0</span>, i)); } <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..(n <span class="synStatement">-</span> <span class="synConstant">1</span>) { min_seg.<span class="synIdentifier">apply_range</span>((i <span class="synStatement">+</span> <span class="synConstant">1</span>)..n, <span class="synConstant">1</span>); } <span class="synStatement">let</span> <span class="synType">mut</span> cost <span class="synStatement">=</span> <span class="synConstant">0</span>; <span class="synStatement">let</span> <span class="synType">mut</span> a_cur <span class="synStatement">=</span> <span class="synConstant">0</span>; <span class="synStatement">let</span> <span class="synType">mut</span> b_cur <span class="synStatement">=</span> <span class="synConstant">0</span>; <span class="synStatement">while</span> a_cur <span class="synStatement">&lt;</span> a.<span class="synIdentifier">len</span>() { <span class="synStatement">let</span> <span class="synType">mut</span> tt <span class="synStatement">=</span> <span class="synConstant">0</span>; <span class="synStatement">while</span> b_cur <span class="synStatement">&lt;</span> b.<span class="synIdentifier">len</span>() <span class="synStatement">&amp;&amp;</span> b[b_cur] <span class="synStatement">&lt;</span> a[a_cur].<span class="synConstant">0</span> { b_cur <span class="synStatement">+=</span> <span class="synConstant">1</span>; tt <span class="synStatement">+=</span> <span class="synConstant">1</span>; } <span class="synStatement">if</span> tt <span class="synStatement">&gt;</span> <span class="synConstant">0</span> { <span class="synStatement">let</span> (x, _) <span class="synStatement">=</span> min_seg.<span class="synIdentifier">prod</span>(<span class="synConstant">0</span>..n); cost <span class="synStatement">+=</span> tt <span class="synStatement">*</span> x; } <span class="synStatement">let</span> <span class="synType">mut</span> next <span class="synStatement">=</span> a_cur; <span class="synStatement">while</span> next <span class="synStatement">&lt;</span> a.<span class="synIdentifier">len</span>() <span class="synStatement">&amp;&amp;</span> a[a_cur].<span class="synConstant">0</span> <span class="synStatement">==</span> a[next].<span class="synConstant">0</span> { next <span class="synStatement">+=</span> <span class="synConstant">1</span>; } <span class="synStatement">for</span> i <span class="synStatement">in</span> a_cur..next { <span class="synStatement">let</span> (_, i) <span class="synStatement">=</span> a[i]; min_seg.<span class="synIdentifier">apply_range</span>((i <span class="synStatement">+</span> <span class="synConstant">1</span>)..n, <span class="synStatement">-</span><span class="synConstant">1</span>); } <span class="synStatement">if</span> b_cur <span class="synStatement">&lt;</span> b.<span class="synIdentifier">len</span>() <span class="synStatement">&amp;&amp;</span> b[b_cur] <span class="synStatement">==</span> a[a_cur].<span class="synConstant">0</span> { <span class="synStatement">let</span> <span class="synType">mut</span> b_next <span class="synStatement">=</span> b_cur; <span class="synStatement">while</span> b_next <span class="synStatement">&lt;</span> b.<span class="synIdentifier">len</span>() <span class="synStatement">&amp;&amp;</span> b[b_cur] <span class="synStatement">==</span> b[b_next] { b_next <span class="synStatement">+=</span> <span class="synConstant">1</span>; } <span class="synStatement">let</span> count <span class="synStatement">=</span> b_next <span class="synStatement">-</span> b_cur; <span class="synStatement">let</span> (x, _) <span class="synStatement">=</span> min_seg.<span class="synIdentifier">prod</span>(<span class="synConstant">0</span>..n); cost <span class="synStatement">+=</span> x <span class="synStatement">*</span> count <span class="synStatement">as</span> <span class="synType">i64</span>; b_cur <span class="synStatement">=</span> b_next; } <span class="synStatement">for</span> i <span class="synStatement">in</span> a_cur..next { <span class="synStatement">let</span> (_, i) <span class="synStatement">=</span> a[i]; min_seg.<span class="synIdentifier">apply_range</span>(<span class="synConstant">0</span>..i, <span class="synConstant">1</span>); } a_cur <span class="synStatement">=</span> next; } <span class="synStatement">let</span> <span class="synType">mut</span> tt <span class="synStatement">=</span> b.<span class="synIdentifier">len</span>() <span class="synStatement">-</span> b_cur; <span class="synStatement">if</span> tt <span class="synStatement">&gt;</span> <span class="synConstant">0</span> { <span class="synStatement">let</span> (x, _) <span class="synStatement">=</span> min_seg.<span class="synIdentifier">prod</span>(<span class="synConstant">0</span>..n); cost <span class="synStatement">+=</span> tt <span class="synStatement">as</span> <span class="synType">i64</span> <span class="synStatement">*</span> x; } <span class="synStatement">let</span> <span class="synType">mut</span> bit <span class="synStatement">=</span> <span class="synPreProc">FenwickTree</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(n, <span class="synStatement">||</span> <span class="synConstant">0</span>); <span class="synStatement">let</span> <span class="synType">mut</span> s <span class="synStatement">=</span> <span class="synConstant">0</span>; <span class="synStatement">for</span> (_, i) <span class="synStatement">in</span> a { s <span class="synStatement">+=</span> bit.<span class="synIdentifier">sum</span>(i, n); bit.<span class="synIdentifier">add</span>(i, <span class="synConstant">1</span>); } cost <span class="synStatement">+</span> s } <span class="synStatement">pub</span> <span class="synStatement">mod</span> <span class="synIdentifier">fenwick_tree</span> { <span class="synSpecial">/// `FenwickTree` is a data structure that can efficiently update elements</span> <span class="synSpecial">/// and calculate prefix sums in a table of numbers.</span> <span class="synSpecial">/// [https://en.wikipedia.org/wiki/Fenwick_tree](https://en.wikipedia.org/wiki/Fenwick_tree)</span> <span class="synStatement">pub</span> <span class="synStatement">struct</span> <span class="synIdentifier">FenwickTree</span><span class="synStatement">&lt;</span>T, F<span class="synStatement">&gt;</span> { n: <span class="synType">usize</span>, data: <span class="synType">Vec</span><span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span>, initialize: F, } <span class="synStatement">impl&lt;</span>T, F<span class="synStatement">&gt;</span> FenwickTree<span class="synStatement">&lt;</span>T, F<span class="synStatement">&gt;</span> <span class="synStatement">where</span> T: <span class="synType">Copy</span> <span class="synStatement">+</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">ops</span><span class="synSpecial">::</span>AddAssign <span class="synStatement">+</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">ops</span><span class="synSpecial">::</span>Sub<span class="synStatement">&lt;</span>Output <span class="synStatement">=</span> T<span class="synStatement">&gt;</span>, F: <span class="synType">Fn</span>() <span class="synStatement">-&gt;</span> T, { <span class="synSpecial">/// Constructs a new `FenwickTree`. The size of `FenwickTree` should be specified by `size`.</span> <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">new</span>(size: <span class="synType">usize</span>, initialize: F) <span class="synStatement">-&gt;</span> FenwickTree<span class="synStatement">&lt;</span>T, F<span class="synStatement">&gt;</span> { FenwickTree { n: size <span class="synStatement">+</span> <span class="synConstant">1</span>, data: <span class="synPreProc">vec!</span>[<span class="synIdentifier">initialize</span>(); size <span class="synStatement">+</span> <span class="synConstant">1</span>], initialize, } } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">add</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, k: <span class="synType">usize</span>, value: T) { <span class="synStatement">let</span> <span class="synType">mut</span> x <span class="synStatement">=</span> k; <span class="synStatement">while</span> x <span class="synStatement">&lt;</span> <span class="synConstant">self</span>.n { <span class="synConstant">self</span>.data[x] <span class="synStatement">+=</span> value; x <span class="synStatement">|=</span> x <span class="synStatement">+</span> <span class="synConstant">1</span>; } } <span class="synSpecial">/// Returns a sum of range `[l, r)`</span> <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">sum</span>(<span class="synType">&amp;</span><span class="synConstant">self</span>, l: <span class="synType">usize</span>, r: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> T { <span class="synConstant">self</span>.<span class="synIdentifier">sum_one</span>(r) <span class="synStatement">-</span> <span class="synConstant">self</span>.<span class="synIdentifier">sum_one</span>(l) } <span class="synSpecial">/// Returns a sum of range `[0, k)`</span> <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">sum_one</span>(<span class="synType">&amp;</span><span class="synConstant">self</span>, k: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> T { <span class="synPreProc">assert!</span>(k <span class="synStatement">&lt;</span> <span class="synConstant">self</span>.n, <span class="synConstant">&quot;Cannot calculate for range [{}, {})&quot;</span>, k, <span class="synConstant">self</span>.n); <span class="synStatement">let</span> <span class="synType">mut</span> result <span class="synStatement">=</span> (<span class="synConstant">self</span>.initialize)(); <span class="synStatement">let</span> <span class="synType">mut</span> x <span class="synStatement">=</span> k <span class="synStatement">as</span> <span class="synType">i32</span> <span class="synStatement">-</span> <span class="synConstant">1</span>; <span class="synStatement">while</span> x <span class="synStatement">&gt;=</span> <span class="synConstant">0</span> { result <span class="synStatement">+=</span> <span class="synConstant">self</span>.data[x <span class="synStatement">as</span> <span class="synType">usize</span>]; x <span class="synStatement">=</span> (x <span class="synStatement">&amp;</span> (x <span class="synStatement">+</span> <span class="synConstant">1</span>)) <span class="synStatement">-</span> <span class="synConstant">1</span>; } result } } } <span class="synStatement">pub</span> <span class="synStatement">mod</span> <span class="synIdentifier">lazy_segment_tree</span> { <span class="synStatement">type</span> <span class="synIdentifier">Range</span> <span class="synStatement">=</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">ops</span><span class="synSpecial">::</span>Range<span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;</span>; <span class="synStatement">pub</span> <span class="synStatement">struct</span> <span class="synIdentifier">LazySegmentTree</span><span class="synStatement">&lt;</span>S, Op, E, F, Mapping, Composition, Id<span class="synStatement">&gt;</span> { n: <span class="synType">usize</span>, size: <span class="synType">usize</span>, log: <span class="synType">usize</span>, data: <span class="synType">Vec</span><span class="synStatement">&lt;</span>S<span class="synStatement">&gt;</span>, lazy: <span class="synType">Vec</span><span class="synStatement">&lt;</span>F<span class="synStatement">&gt;</span>, op: Op, e: E, mapping: Mapping, composition: Composition, id: Id, } <span class="synStatement">impl&lt;</span>S, Op, E, F, Mapping, Composition, Id<span class="synStatement">&gt;</span> LazySegmentTree<span class="synStatement">&lt;</span>S, Op, E, F, Mapping, Composition, Id<span class="synStatement">&gt;</span> <span class="synStatement">where</span> S: <span class="synType">Clone</span>, E: <span class="synType">Fn</span>() <span class="synStatement">-&gt;</span> S, F: <span class="synType">Clone</span>, Op: <span class="synType">Fn</span>(<span class="synType">&amp;</span>S, <span class="synType">&amp;</span>S) <span class="synStatement">-&gt;</span> S, Mapping: <span class="synType">Fn</span>(<span class="synType">&amp;</span>F, <span class="synType">&amp;</span>S) <span class="synStatement">-&gt;</span> S, Composition: <span class="synType">Fn</span>(<span class="synType">&amp;</span>F, <span class="synType">&amp;</span>F) <span class="synStatement">-&gt;</span> F, Id: <span class="synType">Fn</span>() <span class="synStatement">-&gt;</span> F, { <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">new</span>( n: <span class="synType">usize</span>, e: E, op: Op, mapping: Mapping, composition: Composition, id: Id, ) <span class="synStatement">-&gt;</span> <span class="synType">Self</span> { <span class="synStatement">let</span> size <span class="synStatement">=</span> n.<span class="synIdentifier">next_power_of_two</span>() <span class="synStatement">as</span> <span class="synType">usize</span>; LazySegmentTree { n, size, log: size.<span class="synIdentifier">trailing_zeros</span>() <span class="synStatement">as</span> <span class="synType">usize</span>, data: <span class="synPreProc">vec!</span>[<span class="synIdentifier">e</span>(); <span class="synConstant">2</span> <span class="synStatement">*</span> size], lazy: <span class="synPreProc">vec!</span>[<span class="synIdentifier">id</span>(); size], e, op, mapping, composition, id, } } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">set</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, <span class="synType">mut</span> index: <span class="synType">usize</span>, value: S) { <span class="synPreProc">assert!</span>(index <span class="synStatement">&lt;</span> <span class="synConstant">self</span>.n); index <span class="synStatement">+=</span> <span class="synConstant">self</span>.size; <span class="synStatement">for</span> i <span class="synStatement">in</span> (<span class="synConstant">1</span>..<span class="synStatement">=</span><span class="synConstant">self</span>.log).<span class="synIdentifier">rev</span>() { <span class="synConstant">self</span>.<span class="synIdentifier">push</span>(index <span class="synStatement">&gt;&gt;</span> i); } <span class="synConstant">self</span>.data[index] <span class="synStatement">=</span> value; <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">1</span>..<span class="synStatement">=</span><span class="synConstant">self</span>.log { <span class="synConstant">self</span>.<span class="synIdentifier">update</span>(index <span class="synStatement">&gt;&gt;</span> i); } } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">get</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, <span class="synType">mut</span> index: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> S { <span class="synPreProc">assert!</span>(index <span class="synStatement">&lt;</span> <span class="synConstant">self</span>.n); index <span class="synStatement">+=</span> <span class="synConstant">self</span>.size; <span class="synStatement">for</span> i <span class="synStatement">in</span> (<span class="synConstant">1</span>..<span class="synStatement">=</span><span class="synConstant">self</span>.log).<span class="synIdentifier">rev</span>() { <span class="synConstant">self</span>.<span class="synIdentifier">push</span>(index <span class="synStatement">&gt;&gt;</span> i); } <span class="synConstant">self</span>.data[index].<span class="synIdentifier">clone</span>() } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">prod</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, range: Range) <span class="synStatement">-&gt;</span> S { <span class="synStatement">let</span> <span class="synType">mut</span> l <span class="synStatement">=</span> range.start; <span class="synStatement">let</span> <span class="synType">mut</span> r <span class="synStatement">=</span> range.end; <span class="synPreProc">assert!</span>(l <span class="synStatement">&lt;</span> r <span class="synStatement">&amp;&amp;</span> r <span class="synStatement">&lt;=</span> <span class="synConstant">self</span>.n); l <span class="synStatement">+=</span> <span class="synConstant">self</span>.size; r <span class="synStatement">+=</span> <span class="synConstant">self</span>.size; <span class="synStatement">for</span> i <span class="synStatement">in</span> (<span class="synConstant">1</span>..<span class="synStatement">=</span><span class="synConstant">self</span>.log).<span class="synIdentifier">rev</span>() { <span class="synStatement">if</span> ((l <span class="synStatement">&gt;&gt;</span> i) <span class="synStatement">&lt;&lt;</span> i) <span class="synStatement">!=</span> l { <span class="synConstant">self</span>.<span class="synIdentifier">push</span>(l <span class="synStatement">&gt;&gt;</span> i); } <span class="synStatement">if</span> ((r <span class="synStatement">&gt;&gt;</span> i) <span class="synStatement">&lt;&lt;</span> i) <span class="synStatement">!=</span> r { <span class="synConstant">self</span>.<span class="synIdentifier">push</span>(r <span class="synStatement">&gt;&gt;</span> i); } } <span class="synStatement">let</span> <span class="synType">mut</span> sum_l <span class="synStatement">=</span> (<span class="synConstant">self</span>.e)(); <span class="synStatement">let</span> <span class="synType">mut</span> sum_r <span class="synStatement">=</span> (<span class="synConstant">self</span>.e)(); <span class="synStatement">while</span> l <span class="synStatement">&lt;</span> r { <span class="synStatement">if</span> l <span class="synStatement">&amp;</span> <span class="synConstant">1</span> <span class="synStatement">!=</span> <span class="synConstant">0</span> { sum_l <span class="synStatement">=</span> (<span class="synConstant">self</span>.op)(<span class="synType">&amp;</span>sum_l, <span class="synType">&amp;</span><span class="synConstant">self</span>.data[l]); l <span class="synStatement">+=</span> <span class="synConstant">1</span>; } <span class="synStatement">if</span> r <span class="synStatement">&amp;</span> <span class="synConstant">1</span> <span class="synStatement">!=</span> <span class="synConstant">0</span> { r <span class="synStatement">-=</span> <span class="synConstant">1</span>; sum_r <span class="synStatement">=</span> (<span class="synConstant">self</span>.op)(<span class="synType">&amp;</span><span class="synConstant">self</span>.data[r], <span class="synType">&amp;</span>sum_r); } l <span class="synStatement">&gt;&gt;=</span> <span class="synConstant">1</span>; r <span class="synStatement">&gt;&gt;=</span> <span class="synConstant">1</span>; } (<span class="synConstant">self</span>.op)(<span class="synType">&amp;</span>sum_l, <span class="synType">&amp;</span>sum_r) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">all_prod</span>(<span class="synType">&amp;</span><span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> S { <span class="synConstant">self</span>.data[<span class="synConstant">1</span>].<span class="synIdentifier">clone</span>() } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">apply</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, <span class="synType">mut</span> index: <span class="synType">usize</span>, f: F) { <span class="synPreProc">assert!</span>(index <span class="synStatement">&lt;</span> <span class="synConstant">self</span>.n); index <span class="synStatement">+=</span> <span class="synConstant">self</span>.size; <span class="synStatement">for</span> i <span class="synStatement">in</span> (<span class="synConstant">1</span>..<span class="synStatement">=</span><span class="synConstant">self</span>.log).<span class="synIdentifier">rev</span>() { <span class="synConstant">self</span>.<span class="synIdentifier">push</span>(index <span class="synStatement">&gt;&gt;</span> i); } <span class="synConstant">self</span>.data[index] <span class="synStatement">=</span> (<span class="synConstant">self</span>.mapping)(<span class="synType">&amp;</span>f, <span class="synType">&amp;</span><span class="synConstant">self</span>.data[index]); <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">1</span>..<span class="synStatement">=</span><span class="synConstant">self</span>.log { <span class="synConstant">self</span>.<span class="synIdentifier">update</span>(index <span class="synStatement">&gt;&gt;</span> i); } } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">apply_range</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, range: Range, f: F) { <span class="synStatement">let</span> <span class="synType">mut</span> l <span class="synStatement">=</span> range.start; <span class="synStatement">let</span> <span class="synType">mut</span> r <span class="synStatement">=</span> range.end; <span class="synPreProc">assert!</span>(l <span class="synStatement">&lt;=</span> r <span class="synStatement">&amp;&amp;</span> r <span class="synStatement">&lt;=</span> <span class="synConstant">self</span>.n); <span class="synStatement">if</span> l <span class="synStatement">==</span> r { <span class="synStatement">return</span>; } l <span class="synStatement">+=</span> <span class="synConstant">self</span>.size; r <span class="synStatement">+=</span> <span class="synConstant">self</span>.size; <span class="synStatement">for</span> i <span class="synStatement">in</span> (<span class="synConstant">1</span>..<span class="synStatement">=</span><span class="synConstant">self</span>.log).<span class="synIdentifier">rev</span>() { <span class="synStatement">if</span> ((l <span class="synStatement">&gt;&gt;</span> i) <span class="synStatement">&lt;&lt;</span> i) <span class="synStatement">!=</span> l { <span class="synConstant">self</span>.<span class="synIdentifier">push</span>(l <span class="synStatement">&gt;&gt;</span> i); } <span class="synStatement">if</span> ((r <span class="synStatement">&gt;&gt;</span> i) <span class="synStatement">&lt;&lt;</span> i) <span class="synStatement">!=</span> r { <span class="synConstant">self</span>.<span class="synIdentifier">push</span>((r <span class="synStatement">-</span> <span class="synConstant">1</span>) <span class="synStatement">&gt;&gt;</span> i); } } { <span class="synStatement">let</span> <span class="synType">mut</span> l <span class="synStatement">=</span> l; <span class="synStatement">let</span> <span class="synType">mut</span> r <span class="synStatement">=</span> r; <span class="synStatement">while</span> l <span class="synStatement">&lt;</span> r { <span class="synStatement">if</span> l <span class="synStatement">&amp;</span> <span class="synConstant">1</span> <span class="synStatement">!=</span> <span class="synConstant">0</span> { <span class="synConstant">self</span>.<span class="synIdentifier">all_apply</span>(l, f.<span class="synIdentifier">clone</span>()); l <span class="synStatement">+=</span> <span class="synConstant">1</span>; } <span class="synStatement">if</span> r <span class="synStatement">&amp;</span> <span class="synConstant">1</span> <span class="synStatement">!=</span> <span class="synConstant">0</span> { r <span class="synStatement">-=</span> <span class="synConstant">1</span>; <span class="synConstant">self</span>.<span class="synIdentifier">all_apply</span>(r, f.<span class="synIdentifier">clone</span>()); } l <span class="synStatement">&gt;&gt;=</span> <span class="synConstant">1</span>; r <span class="synStatement">&gt;&gt;=</span> <span class="synConstant">1</span>; } } <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">1</span>..<span class="synStatement">=</span><span class="synConstant">self</span>.log { <span class="synStatement">if</span> ((l <span class="synStatement">&gt;&gt;</span> i) <span class="synStatement">&lt;&lt;</span> i) <span class="synStatement">!=</span> l { <span class="synConstant">self</span>.<span class="synIdentifier">update</span>(l <span class="synStatement">&gt;&gt;</span> i); } <span class="synStatement">if</span> ((r <span class="synStatement">&gt;&gt;</span> i) <span class="synStatement">&lt;&lt;</span> i) <span class="synStatement">!=</span> r { <span class="synConstant">self</span>.<span class="synIdentifier">update</span>((r <span class="synStatement">-</span> <span class="synConstant">1</span>) <span class="synStatement">&gt;&gt;</span> i); } } } <span class="synStatement">fn</span> <span class="synIdentifier">update</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, k: <span class="synType">usize</span>) { <span class="synConstant">self</span>.data[k] <span class="synStatement">=</span> (<span class="synConstant">self</span>.op)(<span class="synType">&amp;</span><span class="synConstant">self</span>.data[<span class="synConstant">2</span> <span class="synStatement">*</span> k], <span class="synType">&amp;</span><span class="synConstant">self</span>.data[<span class="synConstant">2</span> <span class="synStatement">*</span> k <span class="synStatement">+</span> <span class="synConstant">1</span>]); } <span class="synStatement">fn</span> <span class="synIdentifier">all_apply</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, k: <span class="synType">usize</span>, f: F) { <span class="synConstant">self</span>.data[k] <span class="synStatement">=</span> (<span class="synConstant">self</span>.mapping)(<span class="synType">&amp;</span>f, <span class="synType">&amp;</span><span class="synConstant">self</span>.data[k]); <span class="synStatement">if</span> k <span class="synStatement">&lt;</span> <span class="synConstant">self</span>.size { <span class="synConstant">self</span>.lazy[k] <span class="synStatement">=</span> (<span class="synConstant">self</span>.composition)(<span class="synType">&amp;</span>f, <span class="synType">&amp;</span><span class="synConstant">self</span>.lazy[k]); } } <span class="synStatement">fn</span> <span class="synIdentifier">push</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, k: <span class="synType">usize</span>) { <span class="synConstant">self</span>.<span class="synIdentifier">all_apply</span>(<span class="synConstant">2</span> <span class="synStatement">*</span> k, <span class="synConstant">self</span>.lazy[k].<span class="synIdentifier">clone</span>()); <span class="synConstant">self</span>.<span class="synIdentifier">all_apply</span>(<span class="synConstant">2</span> <span class="synStatement">*</span> k <span class="synStatement">+</span> <span class="synConstant">1</span>, <span class="synConstant">self</span>.lazy[k].<span class="synIdentifier">clone</span>()); <span class="synConstant">self</span>.lazy[k] <span class="synStatement">=</span> (<span class="synConstant">self</span>.id)(); } } } <span class="synStatement">pub</span> <span class="synStatement">struct</span> <span class="synIdentifier">IO</span><span class="synStatement">&lt;</span>R, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span>(R, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>BufWriter<span class="synStatement">&lt;</span>W<span class="synStatement">&gt;</span>); <span class="synStatement">impl&lt;</span>R: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">new</span>(r: R, w: W) <span class="synStatement">-&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synIdentifier">IO</span>(r, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synPreProc">BufWriter</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(w)) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">write</span><span class="synStatement">&lt;</span>S: <span class="synType">ToString</span><span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, s: S) { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write; <span class="synConstant">self</span>.<span class="synConstant">1</span>.<span class="synIdentifier">write_all</span>(s.<span class="synIdentifier">to_string</span>().<span class="synIdentifier">as_bytes</span>()).<span class="synIdentifier">unwrap</span>(); } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">read</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> T { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read; <span class="synStatement">let</span> buf <span class="synStatement">=</span> <span class="synConstant">self</span> .<span class="synConstant">0</span> .<span class="synIdentifier">by_ref</span>() .<span class="synIdentifier">bytes</span>() .<span class="synIdentifier">map</span>(<span class="synStatement">|</span>b<span class="synStatement">|</span> b.<span class="synIdentifier">unwrap</span>()) .<span class="synIdentifier">skip_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">==</span> <span class="synConstant">b' '</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">take_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">!=</span> <span class="synConstant">b' '</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">collect</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span>_<span class="synStatement">&gt;&gt;</span>(); <span class="synStatement">unsafe</span> { <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span><span class="synIdentifier">from_utf8_unchecked</span>(<span class="synType">&amp;</span>buf) } .<span class="synIdentifier">parse</span>() .<span class="synIdentifier">ok</span>() .<span class="synIdentifier">expect</span>(<span class="synConstant">&quot;Parse error.&quot;</span>) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">usize0</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">usize</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;</span>() <span class="synStatement">-</span> <span class="synConstant">1</span> } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">vec</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, n: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span> { (<span class="synConstant">0</span>..n).<span class="synIdentifier">map</span>(<span class="synStatement">|</span>_<span class="synStatement">|</span> <span class="synConstant">self</span>.<span class="synIdentifier">read</span>()).<span class="synIdentifier">collect</span>() } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">chars</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">char</span><span class="synStatement">&gt;</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">String</span><span class="synStatement">&gt;</span>().<span class="synIdentifier">chars</span>().<span class="synIdentifier">collect</span>() } } </pre> kenkoooo 2021/11/16 hatenablog://entry/13574176438033647410 2021-11-16T23:18:49+09:00 2021-11-18T02:10:28+09:00 ABC155E - Payment atcoder.jp 桁DPは前の桁から、という思い込みがあって全然見えなかった…頭が固い…… const INF: usize = 1 << 60; fn main() { let (r, w) = (std::io::stdin(), std::io::stdout()); let mut sc = IO::new(r.lock(), w.lock()); let n: Vec<usize> = sc .read::<String>() .bytes() .map(|b| b as usize - b'0' as usize) .collect(); l… <h1>ABC155E - Payment</h1> <p><iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fatcoder.jp%2Fcontests%2Fabc155%2Ftasks%2Fabc155_e" title="E - Payment" class="embed-card embed-webcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 155px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://atcoder.jp/contests/abc155/tasks/abc155_e">atcoder.jp</a></cite></p> <p>桁DPは前の桁から、という思い込みがあって全然見えなかった…頭が固い……</p> <pre class="code lang-rust" data-lang="rust" data-unlink><span class="synType">const</span> INF: <span class="synType">usize</span> <span class="synStatement">=</span> <span class="synConstant">1</span> <span class="synStatement">&lt;&lt;</span> <span class="synConstant">60</span>; <span class="synStatement">fn</span> <span class="synIdentifier">main</span>() { <span class="synStatement">let</span> (r, w) <span class="synStatement">=</span> (<span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdin</span>(), <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdout</span>()); <span class="synStatement">let</span> <span class="synType">mut</span> sc <span class="synStatement">=</span> <span class="synPreProc">IO</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(r.<span class="synIdentifier">lock</span>(), w.<span class="synIdentifier">lock</span>()); <span class="synStatement">let</span> n: <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;</span> <span class="synStatement">=</span> sc .<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">String</span><span class="synStatement">&gt;</span>() .<span class="synIdentifier">bytes</span>() .<span class="synIdentifier">map</span>(<span class="synStatement">|</span>b<span class="synStatement">|</span> b <span class="synStatement">as</span> <span class="synType">usize</span> <span class="synStatement">-</span> <span class="synConstant">b'0'</span> <span class="synStatement">as</span> <span class="synType">usize</span>) .<span class="synIdentifier">collect</span>(); <span class="synStatement">let</span> <span class="synType">mut</span> dp <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synConstant">0</span>, INF]; <span class="synStatement">for</span> d <span class="synStatement">in</span> n.<span class="synIdentifier">into_iter</span>().<span class="synIdentifier">rev</span>() { <span class="synStatement">let</span> <span class="synType">mut</span> next <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[INF; <span class="synConstant">2</span>]; <span class="synStatement">for</span> carry <span class="synStatement">in</span> <span class="synConstant">0</span>..<span class="synConstant">2</span> { <span class="synStatement">let</span> pay <span class="synStatement">=</span> carry <span class="synStatement">+</span> d; <span class="synStatement">if</span> pay <span class="synStatement">&lt;</span> <span class="synConstant">10</span> { next[<span class="synConstant">0</span>] <span class="synStatement">=</span> next[<span class="synConstant">0</span>].<span class="synIdentifier">min</span>(dp[carry] <span class="synStatement">+</span> pay); } next[<span class="synConstant">1</span>] <span class="synStatement">=</span> next[<span class="synConstant">1</span>].<span class="synIdentifier">min</span>(dp[carry] <span class="synStatement">+</span> <span class="synConstant">10</span> <span class="synStatement">-</span> pay); } dp <span class="synStatement">=</span> next; } <span class="synStatement">let</span> ans <span class="synStatement">=</span> dp[<span class="synConstant">0</span>].<span class="synIdentifier">min</span>(dp[<span class="synConstant">1</span>] <span class="synStatement">+</span> <span class="synConstant">1</span>); <span class="synPreProc">println!</span>(<span class="synConstant">&quot;{}&quot;</span>, ans); } <span class="synStatement">pub</span> <span class="synStatement">struct</span> <span class="synIdentifier">IO</span><span class="synStatement">&lt;</span>R, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span>(R, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>BufWriter<span class="synStatement">&lt;</span>W<span class="synStatement">&gt;</span>); <span class="synStatement">impl&lt;</span>R: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">new</span>(r: R, w: W) <span class="synStatement">-&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synIdentifier">IO</span>(r, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synPreProc">BufWriter</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(w)) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">write</span><span class="synStatement">&lt;</span>S: <span class="synType">ToString</span><span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, s: S) { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write; <span class="synConstant">self</span>.<span class="synConstant">1</span>.<span class="synIdentifier">write_all</span>(s.<span class="synIdentifier">to_string</span>().<span class="synIdentifier">as_bytes</span>()).<span class="synIdentifier">unwrap</span>(); } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">read</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> T { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read; <span class="synStatement">let</span> buf <span class="synStatement">=</span> <span class="synConstant">self</span> .<span class="synConstant">0</span> .<span class="synIdentifier">by_ref</span>() .<span class="synIdentifier">bytes</span>() .<span class="synIdentifier">map</span>(<span class="synStatement">|</span>b<span class="synStatement">|</span> b.<span class="synIdentifier">unwrap</span>()) .<span class="synIdentifier">skip_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">==</span> <span class="synConstant">b' '</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">take_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">!=</span> <span class="synConstant">b' '</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">collect</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span>_<span class="synStatement">&gt;&gt;</span>(); <span class="synStatement">unsafe</span> { <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span><span class="synIdentifier">from_utf8_unchecked</span>(<span class="synType">&amp;</span>buf) } .<span class="synIdentifier">parse</span>() .<span class="synIdentifier">ok</span>() .<span class="synIdentifier">expect</span>(<span class="synConstant">&quot;Parse error.&quot;</span>) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">usize0</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">usize</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;</span>() <span class="synStatement">-</span> <span class="synConstant">1</span> } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">vec</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, n: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span> { (<span class="synConstant">0</span>..n).<span class="synIdentifier">map</span>(<span class="synStatement">|</span>_<span class="synStatement">|</span> <span class="synConstant">self</span>.<span class="synIdentifier">read</span>()).<span class="synIdentifier">collect</span>() } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">chars</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">char</span><span class="synStatement">&gt;</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">String</span><span class="synStatement">&gt;</span>().<span class="synIdentifier">chars</span>().<span class="synIdentifier">collect</span>() } } </pre> <h1>AGC037D - Sorting a Grid</h1> <p><iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fatcoder.jp%2Fcontests%2Fagc037%2Ftasks%2Fagc037_d" title="D - Sorting a Grid" class="embed-card embed-webcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 155px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://atcoder.jp/contests/agc037/tasks/agc037_d">atcoder.jp</a></cite></p> <p>各列ごとに順番にマッチングをしていくと終盤で詰んでしまわないか?というところから先に進まなかった。具体的に詰むような終盤の状態を構築しようとするとできないことはすぐに分かるので、具体例を考えてみるべきだった。</p> <pre class="code lang-rust" data-lang="rust" data-unlink><span class="synStatement">use</span> <span class="synPreProc">crate</span><span class="synSpecial">::</span><span class="synPreProc">dinitz</span><span class="synSpecial">::</span>Dinitz; <span class="synStatement">fn</span> <span class="synIdentifier">main</span>() { <span class="synStatement">let</span> (r, w) <span class="synStatement">=</span> (<span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdin</span>(), <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdout</span>()); <span class="synStatement">let</span> <span class="synType">mut</span> sc <span class="synStatement">=</span> <span class="synPreProc">IO</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(r.<span class="synIdentifier">lock</span>(), w.<span class="synIdentifier">lock</span>()); <span class="synStatement">let</span> n: <span class="synType">usize</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); <span class="synStatement">let</span> m: <span class="synType">usize</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); <span class="synStatement">let</span> <span class="synType">mut</span> a: <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;&gt;</span> <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synPreProc">vec!</span>[<span class="synConstant">0</span>; m]; n]; <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..n { <span class="synStatement">for</span> j <span class="synStatement">in</span> <span class="synConstant">0</span>..m { a[i][j] <span class="synStatement">=</span> sc.<span class="synIdentifier">usize0</span>(); } } <span class="synStatement">let</span> <span class="synType">mut</span> used <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synPreProc">vec!</span>[<span class="synConstant">false</span>; m]; n]; <span class="synStatement">let</span> <span class="synType">mut</span> edge_id <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synPreProc">vec!</span>[<span class="synConstant">0</span>; m]; n]; <span class="synStatement">let</span> <span class="synType">mut</span> columns <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[]; <span class="synStatement">for</span> _ <span class="synStatement">in</span> <span class="synConstant">0</span>..m { <span class="synStatement">let</span> <span class="synType">mut</span> graph <span class="synStatement">=</span> <span class="synPreProc">Dinitz</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(<span class="synConstant">2</span> <span class="synStatement">*</span> n <span class="synStatement">+</span> <span class="synConstant">2</span>); <span class="synStatement">let</span> source <span class="synStatement">=</span> <span class="synConstant">2</span> <span class="synStatement">*</span> n; <span class="synStatement">let</span> sink <span class="synStatement">=</span> <span class="synConstant">2</span> <span class="synStatement">*</span> n <span class="synStatement">+</span> <span class="synConstant">1</span>; <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..n { graph.<span class="synIdentifier">add_edge</span>(source, i, <span class="synConstant">1</span>); graph.<span class="synIdentifier">add_edge</span>(i <span class="synStatement">+</span> n, sink, <span class="synConstant">1</span>); } <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..n { <span class="synStatement">for</span> j <span class="synStatement">in</span> <span class="synConstant">0</span>..m { <span class="synStatement">if</span> used[i][j] { <span class="synStatement">continue</span>; } <span class="synStatement">let</span> target_row <span class="synStatement">=</span> a[i][j] <span class="synStatement">/</span> m; edge_id[i][j] <span class="synStatement">=</span> graph.g[i].<span class="synIdentifier">len</span>(); graph.<span class="synIdentifier">add_edge</span>(i, target_row <span class="synStatement">+</span> n, <span class="synConstant">1</span>); } } <span class="synStatement">let</span> flow <span class="synStatement">=</span> graph.<span class="synIdentifier">max_flow</span>(source, sink); <span class="synPreProc">assert_eq!</span>(flow <span class="synStatement">as</span> <span class="synType">usize</span>, n); <span class="synStatement">let</span> <span class="synType">mut</span> column <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[]; <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..n { <span class="synStatement">for</span> j <span class="synStatement">in</span> <span class="synConstant">0</span>..m { <span class="synStatement">if</span> used[i][j] { <span class="synStatement">continue</span>; } <span class="synStatement">let</span> ej <span class="synStatement">=</span> edge_id[i][j]; <span class="synStatement">if</span> graph.g[i][ej].cap <span class="synStatement">==</span> <span class="synConstant">0</span> { used[i][j] <span class="synStatement">=</span> <span class="synConstant">true</span>; column.<span class="synIdentifier">push</span>(a[i][j]); } } } <span class="synPreProc">assert_eq!</span>(column.<span class="synIdentifier">len</span>(), n); columns.<span class="synIdentifier">push</span>(column); } <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..n { <span class="synStatement">for</span> j <span class="synStatement">in</span> <span class="synConstant">0</span>..m { <span class="synStatement">if</span> j <span class="synStatement">&gt;</span> <span class="synConstant">0</span> { sc.<span class="synIdentifier">write</span>(<span class="synConstant">' '</span>); } sc.<span class="synIdentifier">write</span>(columns[j][i] <span class="synStatement">+</span> <span class="synConstant">1</span>); } sc.<span class="synIdentifier">write</span>(<span class="synConstant">'</span><span class="synSpecial">\n</span><span class="synConstant">'</span>); } <span class="synStatement">for</span> column <span class="synStatement">in</span> columns.<span class="synIdentifier">iter_mut</span>() { column.<span class="synIdentifier">sort</span>(); } <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..n { <span class="synStatement">for</span> j <span class="synStatement">in</span> <span class="synConstant">0</span>..m { <span class="synStatement">if</span> j <span class="synStatement">&gt;</span> <span class="synConstant">0</span> { sc.<span class="synIdentifier">write</span>(<span class="synConstant">' '</span>); } sc.<span class="synIdentifier">write</span>(columns[j][i] <span class="synStatement">+</span> <span class="synConstant">1</span>); } sc.<span class="synIdentifier">write</span>(<span class="synConstant">'</span><span class="synSpecial">\n</span><span class="synConstant">'</span>); } } <span class="synStatement">pub</span> <span class="synStatement">mod</span> <span class="synIdentifier">dinitz</span> { <span class="synType">const</span> INF: <span class="synType">i64</span> <span class="synStatement">=</span> <span class="synConstant">1</span> <span class="synStatement">&lt;&lt;</span> <span class="synConstant">60</span>; <span class="synStatement">pub</span> <span class="synStatement">struct</span> <span class="synIdentifier">Edge</span> { <span class="synStatement">pub</span> to: <span class="synType">usize</span>, <span class="synStatement">pub</span> rev: <span class="synType">usize</span>, <span class="synStatement">pub</span> is_reversed: <span class="synType">bool</span>, <span class="synStatement">pub</span> cap: <span class="synType">i64</span>, } <span class="synStatement">pub</span> <span class="synStatement">struct</span> <span class="synIdentifier">Dinitz</span> { <span class="synStatement">pub</span> g: <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span>Edge<span class="synStatement">&gt;&gt;</span>, } <span class="synStatement">impl</span> Dinitz { <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">new</span>(v: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> Dinitz { <span class="synStatement">let</span> <span class="synType">mut</span> g: <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span>Edge<span class="synStatement">&gt;&gt;</span> <span class="synStatement">=</span> <span class="synType">Vec</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(); <span class="synStatement">for</span> _ <span class="synStatement">in</span> <span class="synConstant">0</span>..v { g.<span class="synIdentifier">push</span>(<span class="synType">Vec</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>()); } Dinitz { g } } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">add_edge</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, from: <span class="synType">usize</span>, to: <span class="synType">usize</span>, cap: <span class="synType">i64</span>) { <span class="synStatement">let</span> to_len <span class="synStatement">=</span> <span class="synConstant">self</span>.g[to].<span class="synIdentifier">len</span>(); <span class="synStatement">let</span> from_len <span class="synStatement">=</span> <span class="synConstant">self</span>.g[from].<span class="synIdentifier">len</span>(); <span class="synConstant">self</span>.g[from].<span class="synIdentifier">push</span>(Edge { to, rev: to_len, is_reversed: <span class="synConstant">false</span>, cap, }); <span class="synConstant">self</span>.g[to].<span class="synIdentifier">push</span>(Edge { to: from, rev: from_len, is_reversed: <span class="synConstant">true</span>, cap: <span class="synConstant">0</span>, }); } <span class="synStatement">fn</span> <span class="synIdentifier">dfs</span>( <span class="synType">&amp;mut</span> <span class="synConstant">self</span>, v: <span class="synType">usize</span>, sink: <span class="synType">usize</span>, flow: <span class="synType">i64</span>, level: <span class="synType">&amp;</span>[<span class="synType">i32</span>], iter: <span class="synType">&amp;mut</span> [<span class="synType">usize</span>], ) <span class="synStatement">-&gt;</span> <span class="synType">i64</span> { <span class="synStatement">if</span> v <span class="synStatement">==</span> sink { <span class="synStatement">return</span> flow; } <span class="synStatement">while</span> iter[v] <span class="synStatement">&lt;</span> <span class="synConstant">self</span>.g[v].<span class="synIdentifier">len</span>() { <span class="synStatement">let</span> flow <span class="synStatement">=</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">cmp</span><span class="synSpecial">::</span><span class="synIdentifier">min</span>(flow, <span class="synConstant">self</span>.g[v][iter[v]].cap); <span class="synStatement">let</span> to <span class="synStatement">=</span> <span class="synConstant">self</span>.g[v][iter[v]].to; <span class="synStatement">if</span> flow <span class="synStatement">&gt;</span> <span class="synConstant">0</span> <span class="synStatement">&amp;&amp;</span> level[v] <span class="synStatement">&lt;</span> level[to] { <span class="synStatement">let</span> flowed <span class="synStatement">=</span> <span class="synConstant">self</span>.<span class="synIdentifier">dfs</span>(to, sink, flow, level, iter); <span class="synStatement">if</span> flowed <span class="synStatement">&gt;</span> <span class="synConstant">0</span> { <span class="synStatement">let</span> rev <span class="synStatement">=</span> <span class="synConstant">self</span>.g[v][iter[v]].rev; <span class="synConstant">self</span>.g[v][iter[v]].cap <span class="synStatement">-=</span> flowed; <span class="synConstant">self</span>.g[to][rev].cap <span class="synStatement">+=</span> flowed; <span class="synStatement">return</span> flowed; } } iter[v] <span class="synStatement">+=</span> <span class="synConstant">1</span>; } <span class="synConstant">0</span> } <span class="synStatement">fn</span> <span class="synIdentifier">bfs</span>(<span class="synType">&amp;</span><span class="synConstant">self</span>, s: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">i32</span><span class="synStatement">&gt;</span> { <span class="synStatement">let</span> v <span class="synStatement">=</span> <span class="synConstant">self</span>.g.<span class="synIdentifier">len</span>(); <span class="synStatement">let</span> <span class="synType">mut</span> level <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synStatement">-</span><span class="synConstant">1</span>; v]; level[s] <span class="synStatement">=</span> <span class="synConstant">0</span>; <span class="synStatement">let</span> <span class="synType">mut</span> deque <span class="synStatement">=</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">collections</span><span class="synSpecial">::</span><span class="synPreProc">VecDeque</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(); deque.<span class="synIdentifier">push_back</span>(s); <span class="synStatement">while</span> <span class="synStatement">let</span> <span class="synConstant">Some</span>(v) <span class="synStatement">=</span> deque.<span class="synIdentifier">pop_front</span>() { <span class="synStatement">for</span> e <span class="synStatement">in</span> <span class="synConstant">self</span>.g[v].<span class="synIdentifier">iter</span>() { <span class="synStatement">if</span> e.cap <span class="synStatement">&gt;</span> <span class="synConstant">0</span> <span class="synStatement">&amp;&amp;</span> level[e.to] <span class="synStatement">&lt;</span> <span class="synConstant">0</span> { level[e.to] <span class="synStatement">=</span> level[v] <span class="synStatement">+</span> <span class="synConstant">1</span>; deque.<span class="synIdentifier">push_back</span>(e.to); } } } level } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">max_flow</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, s: <span class="synType">usize</span>, t: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> <span class="synType">i64</span> { <span class="synStatement">let</span> v <span class="synStatement">=</span> <span class="synConstant">self</span>.g.<span class="synIdentifier">len</span>(); <span class="synStatement">let</span> <span class="synType">mut</span> flow: <span class="synType">i64</span> <span class="synStatement">=</span> <span class="synConstant">0</span>; <span class="synStatement">loop</span> { <span class="synStatement">let</span> level <span class="synStatement">=</span> <span class="synConstant">self</span>.<span class="synIdentifier">bfs</span>(s); <span class="synStatement">if</span> level[t] <span class="synStatement">&lt;</span> <span class="synConstant">0</span> { <span class="synStatement">return</span> flow; } <span class="synStatement">let</span> <span class="synType">mut</span> iter <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synConstant">0</span>; v]; <span class="synStatement">loop</span> { <span class="synStatement">let</span> f <span class="synStatement">=</span> <span class="synConstant">self</span>.<span class="synIdentifier">dfs</span>(s, t, INF, <span class="synType">&amp;</span>level, <span class="synType">&amp;mut</span> iter); <span class="synStatement">if</span> f <span class="synStatement">==</span> <span class="synConstant">0</span> { <span class="synStatement">break</span>; } flow <span class="synStatement">+=</span> f; } } } } } <span class="synStatement">pub</span> <span class="synStatement">struct</span> <span class="synIdentifier">IO</span><span class="synStatement">&lt;</span>R, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span>(R, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>BufWriter<span class="synStatement">&lt;</span>W<span class="synStatement">&gt;</span>); <span class="synStatement">impl&lt;</span>R: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">new</span>(r: R, w: W) <span class="synStatement">-&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synIdentifier">IO</span>(r, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synPreProc">BufWriter</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(w)) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">write</span><span class="synStatement">&lt;</span>S: <span class="synType">ToString</span><span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, s: S) { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write; <span class="synConstant">self</span>.<span class="synConstant">1</span>.<span class="synIdentifier">write_all</span>(s.<span class="synIdentifier">to_string</span>().<span class="synIdentifier">as_bytes</span>()).<span class="synIdentifier">unwrap</span>(); } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">read</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> T { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read; <span class="synStatement">let</span> buf <span class="synStatement">=</span> <span class="synConstant">self</span> .<span class="synConstant">0</span> .<span class="synIdentifier">by_ref</span>() .<span class="synIdentifier">bytes</span>() .<span class="synIdentifier">map</span>(<span class="synStatement">|</span>b<span class="synStatement">|</span> b.<span class="synIdentifier">unwrap</span>()) .<span class="synIdentifier">skip_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">==</span> <span class="synConstant">b' '</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">take_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">!=</span> <span class="synConstant">b' '</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">collect</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span>_<span class="synStatement">&gt;&gt;</span>(); <span class="synStatement">unsafe</span> { <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span><span class="synIdentifier">from_utf8_unchecked</span>(<span class="synType">&amp;</span>buf) } .<span class="synIdentifier">parse</span>() .<span class="synIdentifier">ok</span>() .<span class="synIdentifier">expect</span>(<span class="synConstant">&quot;Parse error.&quot;</span>) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">usize0</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">usize</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;</span>() <span class="synStatement">-</span> <span class="synConstant">1</span> } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">vec</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, n: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span> { (<span class="synConstant">0</span>..n).<span class="synIdentifier">map</span>(<span class="synStatement">|</span>_<span class="synStatement">|</span> <span class="synConstant">self</span>.<span class="synIdentifier">read</span>()).<span class="synIdentifier">collect</span>() } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">chars</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">char</span><span class="synStatement">&gt;</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">String</span><span class="synStatement">&gt;</span>().<span class="synIdentifier">chars</span>().<span class="synIdentifier">collect</span>() } } </pre> kenkoooo 2021/11/14 hatenablog://entry/13574176438032742782 2021-11-14T10:00:54+09:00 2021-11-14T12:08:00+09:00 ABC227G - Divisors of Binomial Coefficient atcoder.jp ついに区間篩を知らなかったことが仇に… ] の素数を求めながら ] の素因数分解もできるの、言われてみればそうなんだけど、すごい。 use crate::mod_int::ModInt; fn main() { let (r, w) = (std::io::stdin(), std::io::stdout()); let mut sc = IO::new(r.lock(), w.lock()); let n: usize = sc.read(); let k: usize = sc.re… <h1>ABC227G - Divisors of Binomial Coefficient</h1> <p><iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fatcoder.jp%2Fcontests%2Fabc227%2Ftasks%2Fabc227_g" title="G - Divisors of Binomial Coefficient" class="embed-card embed-webcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 155px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://atcoder.jp/contests/abc227/tasks/abc227_g">atcoder.jp</a></cite></p> <p>ついに<a class="keyword" href="http://d.hatena.ne.jp/keyword/%B6%E8%B4%D6">区間</a>篩を知らなかったことが仇に…</p> <p><img src="https://chart.apis.google.com/chart?cht=tx&chl=%20%5B2%2C%20X" alt=" [2, X"/>] の<a class="keyword" href="http://d.hatena.ne.jp/keyword/%C1%C7%BF%F4">素数</a>を求めながら <img src="https://chart.apis.google.com/chart?cht=tx&chl=%20%5BY%2C%20X%5E%7B2%7D" alt=" [Y, X^{2}"/>] の<a class="keyword" href="http://d.hatena.ne.jp/keyword/%C1%C7%B0%F8%BF%F4%CA%AC%B2%F2">素因数分解</a>もできるの、言われてみればそうなんだけど、すごい。</p> <pre class="code lang-rust" data-lang="rust" data-unlink><span class="synStatement">use</span> <span class="synPreProc">crate</span><span class="synSpecial">::</span><span class="synPreProc">mod_int</span><span class="synSpecial">::</span>ModInt; <span class="synStatement">fn</span> <span class="synIdentifier">main</span>() { <span class="synStatement">let</span> (r, w) <span class="synStatement">=</span> (<span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdin</span>(), <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdout</span>()); <span class="synStatement">let</span> <span class="synType">mut</span> sc <span class="synStatement">=</span> <span class="synPreProc">IO</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(r.<span class="synIdentifier">lock</span>(), w.<span class="synIdentifier">lock</span>()); <span class="synStatement">let</span> n: <span class="synType">usize</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); <span class="synStatement">let</span> k: <span class="synType">usize</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); <span class="synStatement">let</span> from <span class="synStatement">=</span> n <span class="synStatement">-</span> k <span class="synStatement">+</span> <span class="synConstant">1</span>; <span class="synStatement">let</span> to <span class="synStatement">=</span> n; <span class="synStatement">let</span> sq_n <span class="synStatement">=</span> (n <span class="synStatement">as</span> <span class="synType">f64</span>).<span class="synIdentifier">sqrt</span>() <span class="synStatement">as</span> <span class="synType">usize</span> <span class="synStatement">+</span> <span class="synConstant">1</span>; <span class="synStatement">let</span> l <span class="synStatement">=</span> k.<span class="synIdentifier">max</span>(sq_n); <span class="synStatement">let</span> <span class="synType">mut</span> divisors <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synPreProc">vec!</span>[]; l <span class="synStatement">+</span> <span class="synConstant">1</span>]; <span class="synStatement">let</span> <span class="synType">mut</span> divisors_big <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synPreProc">vec!</span>[]; k]; <span class="synStatement">for</span> p <span class="synStatement">in</span> <span class="synConstant">2</span>..<span class="synStatement">=</span>l { <span class="synStatement">if</span> divisors[p].<span class="synIdentifier">is_empty</span>() { <span class="synStatement">let</span> <span class="synType">mut</span> cur <span class="synStatement">=</span> p; <span class="synStatement">while</span> cur <span class="synStatement">&lt;=</span> l { divisors[cur].<span class="synIdentifier">push</span>(p); cur <span class="synStatement">+=</span> p; } <span class="synStatement">let</span> <span class="synType">mut</span> cur <span class="synStatement">=</span> (from <span class="synStatement">+</span> p <span class="synStatement">-</span> <span class="synConstant">1</span>) <span class="synStatement">/</span> p <span class="synStatement">*</span> p; <span class="synStatement">while</span> cur <span class="synStatement">&lt;=</span> to { divisors_big[cur <span class="synStatement">-</span> from].<span class="synIdentifier">push</span>(p); cur <span class="synStatement">+=</span> p; } } } <span class="synStatement">let</span> <span class="synType">mut</span> big_primes <span class="synStatement">=</span> <span class="synConstant">0</span>; <span class="synStatement">let</span> <span class="synType">mut</span> count <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synConstant">0</span>; l <span class="synStatement">+</span> <span class="synConstant">1</span>]; <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">1</span>..<span class="synStatement">=</span>k { <span class="synStatement">let</span> <span class="synType">mut</span> lower <span class="synStatement">=</span> i; <span class="synStatement">for</span> <span class="synType">&amp;</span>prime <span class="synStatement">in</span> divisors[i].<span class="synIdentifier">iter</span>() { <span class="synStatement">while</span> lower <span class="synStatement">%</span> prime <span class="synStatement">==</span> <span class="synConstant">0</span> { lower <span class="synStatement">/=</span> prime; count[prime] <span class="synStatement">-=</span> <span class="synConstant">1</span>; } } <span class="synStatement">let</span> <span class="synType">mut</span> upper <span class="synStatement">=</span> n <span class="synStatement">-</span> i <span class="synStatement">+</span> <span class="synConstant">1</span>; <span class="synStatement">for</span> <span class="synType">&amp;</span>prime <span class="synStatement">in</span> divisors_big[n <span class="synStatement">-</span> i <span class="synStatement">+</span> <span class="synConstant">1</span> <span class="synStatement">-</span> from].<span class="synIdentifier">iter</span>() { <span class="synStatement">while</span> upper <span class="synStatement">%</span> prime <span class="synStatement">==</span> <span class="synConstant">0</span> { upper <span class="synStatement">/=</span> prime; count[prime] <span class="synStatement">+=</span> <span class="synConstant">1</span>; } } <span class="synStatement">if</span> upper <span class="synStatement">&gt;</span> <span class="synConstant">1</span> { big_primes <span class="synStatement">+=</span> <span class="synConstant">1</span>; } } <span class="synStatement">let</span> <span class="synType">mut</span> ans <span class="synStatement">=</span> <span class="synPreProc">ModInt</span><span class="synSpecial">::</span><span class="synIdentifier">from</span>(<span class="synConstant">1</span>); <span class="synStatement">for</span> c <span class="synStatement">in</span> count { <span class="synPreProc">assert!</span>(c <span class="synStatement">&gt;=</span> <span class="synConstant">0</span>, <span class="synConstant">&quot;{}&quot;</span>, c); ans <span class="synStatement">*=</span> c <span class="synStatement">+</span> <span class="synConstant">1</span>; } ans <span class="synStatement">*=</span> <span class="synPreProc">ModInt</span><span class="synSpecial">::</span><span class="synIdentifier">from</span>(<span class="synConstant">2</span>).<span class="synIdentifier">pow</span>(big_primes); <span class="synPreProc">println!</span>(<span class="synConstant">&quot;{}&quot;</span>, ans.<span class="synIdentifier">value</span>()); } <span class="synStatement">pub</span> <span class="synStatement">mod</span> <span class="synIdentifier">mod_int</span> { <span class="synStatement">type</span> <span class="synIdentifier">ModInternalNum</span> <span class="synStatement">=</span> <span class="synType">i64</span>; <span class="synPreProc">thread_local!</span>( <span class="synType">static</span> MOD: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">cell</span><span class="synSpecial">::</span>RefCell<span class="synStatement">&lt;</span>ModInternalNum<span class="synStatement">&gt;</span> <span class="synStatement">=</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">cell</span><span class="synSpecial">::</span><span class="synPreProc">RefCell</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(<span class="synConstant">0</span>); ); <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">set_mod_int</span><span class="synStatement">&lt;</span>T: ToInternalNum<span class="synStatement">&gt;</span>(v: T) { MOD.<span class="synIdentifier">with</span>(<span class="synStatement">|</span>x<span class="synStatement">|</span> x.<span class="synIdentifier">replace</span>(v.<span class="synIdentifier">to_internal_num</span>())); } <span class="synStatement">fn</span> <span class="synIdentifier">modulo</span>() <span class="synStatement">-&gt;</span> ModInternalNum { <span class="synConstant">998244353</span> } <span class="synStatement">pub</span> <span class="synStatement">struct</span> <span class="synIdentifier">ModInt</span>(ModInternalNum); <span class="synStatement">impl</span> <span class="synType">Clone</span> <span class="synStatement">for</span> ModInt { <span class="synStatement">fn</span> <span class="synIdentifier">clone</span>(<span class="synType">&amp;</span><span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">Self</span> { <span class="synType">Self</span>(<span class="synConstant">self</span>.<span class="synConstant">0</span>) } } <span class="synStatement">impl</span> <span class="synType">Copy</span> <span class="synStatement">for</span> ModInt {} <span class="synStatement">impl</span> ModInt { <span class="synStatement">fn</span> <span class="synIdentifier">internal_new</span>(<span class="synType">mut</span> v: ModInternalNum) <span class="synStatement">-&gt;</span> <span class="synType">Self</span> { <span class="synStatement">let</span> m <span class="synStatement">=</span> <span class="synIdentifier">modulo</span>(); <span class="synStatement">if</span> v <span class="synStatement">&gt;=</span> m { v <span class="synStatement">%=</span> m; } <span class="synType">Self</span>(v) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">internal_pow</span>(<span class="synType">&amp;</span><span class="synConstant">self</span>, <span class="synType">mut</span> e: ModInternalNum) <span class="synStatement">-&gt;</span> <span class="synType">Self</span> { <span class="synStatement">let</span> <span class="synType">mut</span> result <span class="synStatement">=</span> <span class="synConstant">1</span>; <span class="synStatement">let</span> <span class="synType">mut</span> cur <span class="synStatement">=</span> <span class="synConstant">self</span>.<span class="synConstant">0</span>; <span class="synStatement">let</span> modulo <span class="synStatement">=</span> <span class="synIdentifier">modulo</span>(); <span class="synStatement">while</span> e <span class="synStatement">&gt;</span> <span class="synConstant">0</span> { <span class="synStatement">if</span> e <span class="synStatement">&amp;</span> <span class="synConstant">1</span> <span class="synStatement">==</span> <span class="synConstant">1</span> { result <span class="synStatement">*=</span> cur; result <span class="synStatement">%=</span> modulo; } e <span class="synStatement">&gt;&gt;=</span> <span class="synConstant">1</span>; cur <span class="synStatement">=</span> (cur <span class="synStatement">*</span> cur) <span class="synStatement">%</span> modulo; } <span class="synType">Self</span>(result) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">pow</span><span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span>(<span class="synType">&amp;</span><span class="synConstant">self</span>, e: T) <span class="synStatement">-&gt;</span> <span class="synType">Self</span> <span class="synStatement">where</span> T: ToInternalNum, { <span class="synConstant">self</span>.<span class="synIdentifier">internal_pow</span>(e.<span class="synIdentifier">to_internal_num</span>()) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">value</span>(<span class="synType">&amp;</span><span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> ModInternalNum { <span class="synConstant">self</span>.<span class="synConstant">0</span> } } <span class="synStatement">pub</span> <span class="synStatement">trait</span> <span class="synIdentifier">ToInternalNum</span> { <span class="synStatement">fn</span> <span class="synIdentifier">to_internal_num</span>(<span class="synType">&amp;</span><span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> ModInternalNum; } <span class="synStatement">impl</span> ToInternalNum <span class="synStatement">for</span> ModInt { <span class="synStatement">fn</span> <span class="synIdentifier">to_internal_num</span>(<span class="synType">&amp;</span><span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> ModInternalNum { <span class="synConstant">self</span>.<span class="synConstant">0</span> } } <span class="synPreProc">macro_rules!</span> impl_primitive { (<span class="synPreProc">$primitive</span>:ident) <span class="synStatement">=&gt;</span> { <span class="synStatement">impl</span> <span class="synType">From</span><span class="synStatement">&lt;</span><span class="synPreProc">$primitive</span><span class="synStatement">&gt;</span> <span class="synStatement">for</span> ModInt { <span class="synStatement">fn</span> <span class="synIdentifier">from</span>(v: <span class="synPreProc">$primitive</span>) <span class="synStatement">-&gt;</span> <span class="synType">Self</span> { <span class="synStatement">let</span> v <span class="synStatement">=</span> v <span class="synStatement">as</span> ModInternalNum; <span class="synType">Self</span><span class="synSpecial">::</span><span class="synIdentifier">internal_new</span>(v) } } <span class="synStatement">impl</span> ToInternalNum <span class="synStatement">for</span> <span class="synPreProc">$primitive</span> { <span class="synStatement">fn</span> <span class="synIdentifier">to_internal_num</span>(<span class="synType">&amp;</span><span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> ModInternalNum { <span class="synType">*</span><span class="synConstant">self</span> <span class="synStatement">as</span> ModInternalNum } } }; } <span class="synPreProc">impl_primitive!</span>(<span class="synType">u8</span>); <span class="synPreProc">impl_primitive!</span>(<span class="synType">u16</span>); <span class="synPreProc">impl_primitive!</span>(<span class="synType">u32</span>); <span class="synPreProc">impl_primitive!</span>(<span class="synType">u64</span>); <span class="synPreProc">impl_primitive!</span>(<span class="synType">usize</span>); <span class="synPreProc">impl_primitive!</span>(<span class="synType">i8</span>); <span class="synPreProc">impl_primitive!</span>(<span class="synType">i16</span>); <span class="synPreProc">impl_primitive!</span>(<span class="synType">i32</span>); <span class="synPreProc">impl_primitive!</span>(<span class="synType">i64</span>); <span class="synPreProc">impl_primitive!</span>(<span class="synType">isize</span>); <span class="synStatement">impl&lt;</span>T: ToInternalNum<span class="synStatement">&gt;</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">ops</span><span class="synSpecial">::</span>AddAssign<span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span> <span class="synStatement">for</span> ModInt { <span class="synStatement">fn</span> <span class="synIdentifier">add_assign</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, rhs: T) { <span class="synStatement">let</span> <span class="synType">mut</span> rhs <span class="synStatement">=</span> rhs.<span class="synIdentifier">to_internal_num</span>(); <span class="synStatement">let</span> m <span class="synStatement">=</span> <span class="synIdentifier">modulo</span>(); <span class="synStatement">if</span> rhs <span class="synStatement">&gt;=</span> m { rhs <span class="synStatement">%=</span> m; } <span class="synConstant">self</span>.<span class="synConstant">0</span> <span class="synStatement">+=</span> rhs; <span class="synStatement">if</span> <span class="synConstant">self</span>.<span class="synConstant">0</span> <span class="synStatement">&gt;=</span> m { <span class="synConstant">self</span>.<span class="synConstant">0</span> <span class="synStatement">-=</span> m; } } } <span class="synStatement">impl&lt;</span>T: ToInternalNum<span class="synStatement">&gt;</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">ops</span><span class="synSpecial">::</span>Add<span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span> <span class="synStatement">for</span> ModInt { <span class="synStatement">type</span> <span class="synIdentifier">Output</span> <span class="synStatement">=</span> ModInt; <span class="synStatement">fn</span> <span class="synIdentifier">add</span>(<span class="synConstant">self</span>, rhs: T) <span class="synStatement">-&gt;</span> <span class="synType">Self</span><span class="synSpecial">::</span>Output { <span class="synStatement">let</span> <span class="synType">mut</span> res <span class="synStatement">=</span> <span class="synConstant">self</span>; res <span class="synStatement">+=</span> rhs; res } } <span class="synStatement">impl&lt;</span>T: ToInternalNum<span class="synStatement">&gt;</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">ops</span><span class="synSpecial">::</span>SubAssign<span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span> <span class="synStatement">for</span> ModInt { <span class="synStatement">fn</span> <span class="synIdentifier">sub_assign</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, rhs: T) { <span class="synStatement">let</span> <span class="synType">mut</span> rhs <span class="synStatement">=</span> rhs.<span class="synIdentifier">to_internal_num</span>(); <span class="synStatement">let</span> m <span class="synStatement">=</span> <span class="synIdentifier">modulo</span>(); <span class="synStatement">if</span> rhs <span class="synStatement">&gt;=</span> m { rhs <span class="synStatement">%=</span> m; } <span class="synStatement">if</span> rhs <span class="synStatement">&gt;</span> <span class="synConstant">0</span> { <span class="synConstant">self</span>.<span class="synConstant">0</span> <span class="synStatement">+=</span> m <span class="synStatement">-</span> rhs; } <span class="synStatement">if</span> <span class="synConstant">self</span>.<span class="synConstant">0</span> <span class="synStatement">&gt;=</span> m { <span class="synConstant">self</span>.<span class="synConstant">0</span> <span class="synStatement">-=</span> m; } } } <span class="synStatement">impl&lt;</span>T: ToInternalNum<span class="synStatement">&gt;</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">ops</span><span class="synSpecial">::</span>Sub<span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span> <span class="synStatement">for</span> ModInt { <span class="synStatement">type</span> <span class="synIdentifier">Output</span> <span class="synStatement">=</span> <span class="synType">Self</span>; <span class="synStatement">fn</span> <span class="synIdentifier">sub</span>(<span class="synConstant">self</span>, rhs: T) <span class="synStatement">-&gt;</span> <span class="synType">Self</span><span class="synSpecial">::</span>Output { <span class="synStatement">let</span> <span class="synType">mut</span> res <span class="synStatement">=</span> <span class="synConstant">self</span>; res <span class="synStatement">-=</span> rhs; res } } <span class="synStatement">impl&lt;</span>T: ToInternalNum<span class="synStatement">&gt;</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">ops</span><span class="synSpecial">::</span>MulAssign<span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span> <span class="synStatement">for</span> ModInt { <span class="synStatement">fn</span> <span class="synIdentifier">mul_assign</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, rhs: T) { <span class="synStatement">let</span> <span class="synType">mut</span> rhs <span class="synStatement">=</span> rhs.<span class="synIdentifier">to_internal_num</span>(); <span class="synStatement">let</span> m <span class="synStatement">=</span> <span class="synIdentifier">modulo</span>(); <span class="synStatement">if</span> rhs <span class="synStatement">&gt;=</span> m { rhs <span class="synStatement">%=</span> m; } <span class="synConstant">self</span>.<span class="synConstant">0</span> <span class="synStatement">*=</span> rhs; <span class="synConstant">self</span>.<span class="synConstant">0</span> <span class="synStatement">%=</span> m; } } <span class="synStatement">impl&lt;</span>T: ToInternalNum<span class="synStatement">&gt;</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">ops</span><span class="synSpecial">::</span>Mul<span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span> <span class="synStatement">for</span> ModInt { <span class="synStatement">type</span> <span class="synIdentifier">Output</span> <span class="synStatement">=</span> <span class="synType">Self</span>; <span class="synStatement">fn</span> <span class="synIdentifier">mul</span>(<span class="synConstant">self</span>, rhs: T) <span class="synStatement">-&gt;</span> <span class="synType">Self</span><span class="synSpecial">::</span>Output { <span class="synStatement">let</span> <span class="synType">mut</span> res <span class="synStatement">=</span> <span class="synConstant">self</span>; res <span class="synStatement">*=</span> rhs; res } } <span class="synStatement">impl&lt;</span>T: ToInternalNum<span class="synStatement">&gt;</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">ops</span><span class="synSpecial">::</span>DivAssign<span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span> <span class="synStatement">for</span> ModInt { <span class="synStatement">fn</span> <span class="synIdentifier">div_assign</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, rhs: T) { <span class="synStatement">let</span> <span class="synType">mut</span> rhs <span class="synStatement">=</span> rhs.<span class="synIdentifier">to_internal_num</span>(); <span class="synStatement">let</span> m <span class="synStatement">=</span> <span class="synIdentifier">modulo</span>(); <span class="synStatement">if</span> rhs <span class="synStatement">&gt;=</span> m { rhs <span class="synStatement">%=</span> m; } <span class="synStatement">let</span> inv <span class="synStatement">=</span> <span class="synType">Self</span>(rhs).<span class="synIdentifier">internal_pow</span>(m <span class="synStatement">-</span> <span class="synConstant">2</span>); <span class="synConstant">self</span>.<span class="synConstant">0</span> <span class="synStatement">*=</span> inv.<span class="synIdentifier">value</span>(); <span class="synConstant">self</span>.<span class="synConstant">0</span> <span class="synStatement">%=</span> m; } } <span class="synStatement">impl&lt;</span>T: ToInternalNum<span class="synStatement">&gt;</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">ops</span><span class="synSpecial">::</span>Div<span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span> <span class="synStatement">for</span> ModInt { <span class="synStatement">type</span> <span class="synIdentifier">Output</span> <span class="synStatement">=</span> <span class="synType">Self</span>; <span class="synStatement">fn</span> <span class="synIdentifier">div</span>(<span class="synConstant">self</span>, rhs: T) <span class="synStatement">-&gt;</span> <span class="synType">Self</span><span class="synSpecial">::</span>Output { <span class="synStatement">let</span> <span class="synType">mut</span> res <span class="synStatement">=</span> <span class="synConstant">self</span>; res <span class="synStatement">/=</span> rhs; res } } } <span class="synStatement">pub</span> <span class="synStatement">struct</span> <span class="synIdentifier">IO</span><span class="synStatement">&lt;</span>R, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span>(R, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>BufWriter<span class="synStatement">&lt;</span>W<span class="synStatement">&gt;</span>); <span class="synStatement">impl&lt;</span>R: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">new</span>(r: R, w: W) <span class="synStatement">-&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synIdentifier">IO</span>(r, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synPreProc">BufWriter</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(w)) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">write</span><span class="synStatement">&lt;</span>S: <span class="synType">ToString</span><span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, s: S) { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write; <span class="synConstant">self</span>.<span class="synConstant">1</span>.<span class="synIdentifier">write_all</span>(s.<span class="synIdentifier">to_string</span>().<span class="synIdentifier">as_bytes</span>()).<span class="synIdentifier">unwrap</span>(); } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">read</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> T { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read; <span class="synStatement">let</span> buf <span class="synStatement">=</span> <span class="synConstant">self</span> .<span class="synConstant">0</span> .<span class="synIdentifier">by_ref</span>() .<span class="synIdentifier">bytes</span>() .<span class="synIdentifier">map</span>(<span class="synStatement">|</span>b<span class="synStatement">|</span> b.<span class="synIdentifier">unwrap</span>()) .<span class="synIdentifier">skip_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">==</span> <span class="synConstant">b' '</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">take_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">!=</span> <span class="synConstant">b' '</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">collect</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span>_<span class="synStatement">&gt;&gt;</span>(); <span class="synStatement">unsafe</span> { <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span><span class="synIdentifier">from_utf8_unchecked</span>(<span class="synType">&amp;</span>buf) } .<span class="synIdentifier">parse</span>() .<span class="synIdentifier">ok</span>() .<span class="synIdentifier">expect</span>(<span class="synConstant">&quot;Parse error.&quot;</span>) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">usize0</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">usize</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;</span>() <span class="synStatement">-</span> <span class="synConstant">1</span> } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">vec</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, n: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span> { (<span class="synConstant">0</span>..n).<span class="synIdentifier">map</span>(<span class="synStatement">|</span>_<span class="synStatement">|</span> <span class="synConstant">self</span>.<span class="synIdentifier">read</span>()).<span class="synIdentifier">collect</span>() } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">chars</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">char</span><span class="synStatement">&gt;</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">String</span><span class="synStatement">&gt;</span>().<span class="synIdentifier">chars</span>().<span class="synIdentifier">collect</span>() } } </pre> <h1>ARC067F - Yakiniku Restaurants</h1> <p><iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fatcoder.jp%2Fcontests%2Farc067%2Ftasks%2Farc067_d" title="F - Yakiniku Restaurants" class="embed-card embed-webcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 155px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://atcoder.jp/contests/arc067/tasks/arc067_d">atcoder.jp</a></cite></p> <p>[from, to) で利用できるものについて、N x N の2次元平面上にプロットしてみると、長方形領域の集合になっているという問題。直線上を移動する問題を2次元にプロットするところに発想の飛躍があるように感じたが、典型的な考え方かもしれない。ものにしたい。</p> <pre class="code lang-rust" data-lang="rust" data-unlink><span class="synStatement">use</span> <span class="synPreProc">crate</span><span class="synSpecial">::</span><span class="synPreProc">sparse_table</span><span class="synSpecial">::</span>SparseTable; <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">collections</span><span class="synSpecial">::</span>VecDeque; <span class="synStatement">fn</span> <span class="synIdentifier">main</span>() { <span class="synStatement">let</span> (r, w) <span class="synStatement">=</span> (<span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdin</span>(), <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdout</span>()); <span class="synStatement">let</span> <span class="synType">mut</span> sc <span class="synStatement">=</span> <span class="synPreProc">IO</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(r.<span class="synIdentifier">lock</span>(), w.<span class="synIdentifier">lock</span>()); <span class="synStatement">let</span> n: <span class="synType">usize</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); <span class="synStatement">let</span> m: <span class="synType">usize</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); <span class="synStatement">let</span> a: <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">i64</span><span class="synStatement">&gt;</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">vec</span>(n <span class="synStatement">-</span> <span class="synConstant">1</span>); <span class="synStatement">let</span> <span class="synType">mut</span> pos <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synConstant">0</span>; n]; <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">1</span>..n { pos[i] <span class="synStatement">=</span> pos[i <span class="synStatement">-</span> <span class="synConstant">1</span>] <span class="synStatement">+</span> a[i <span class="synStatement">-</span> <span class="synConstant">1</span>]; } <span class="synStatement">let</span> b: <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">i64</span><span class="synStatement">&gt;&gt;</span> <span class="synStatement">=</span> (<span class="synConstant">0</span>..n).<span class="synIdentifier">map</span>(<span class="synStatement">|</span>_<span class="synStatement">|</span> sc.<span class="synIdentifier">vec</span>(m)).<span class="synIdentifier">collect</span>(); <span class="synStatement">let</span> <span class="synType">mut</span> available <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synPreProc">vec!</span>[]; n]; <span class="synStatement">for</span> ticket_id <span class="synStatement">in</span> <span class="synConstant">0</span>..m { <span class="synStatement">let</span> b <span class="synStatement">=</span> (<span class="synConstant">0</span>..n).<span class="synIdentifier">map</span>(<span class="synStatement">|</span>j<span class="synStatement">|</span> (b[j][ticket_id], j)).<span class="synIdentifier">collect</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span>_<span class="synStatement">&gt;&gt;</span>(); <span class="synStatement">let</span> st <span class="synStatement">=</span> <span class="synPreProc">SparseTable</span><span class="synSpecial">::</span><span class="synIdentifier">from</span>(<span class="synType">&amp;</span>b, (<span class="synConstant">0</span>, n), <span class="synStatement">|</span>a, b<span class="synStatement">|</span> a.<span class="synIdentifier">max</span>(b)); <span class="synStatement">let</span> <span class="synType">mut</span> segments <span class="synStatement">=</span> <span class="synPreProc">VecDeque</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(); segments.<span class="synIdentifier">push_back</span>((<span class="synConstant">0</span>, n)); <span class="synStatement">while</span> <span class="synStatement">let</span> <span class="synConstant">Some</span>((from, to)) <span class="synStatement">=</span> segments.<span class="synIdentifier">pop_front</span>() { <span class="synStatement">let</span> (x, i) <span class="synStatement">=</span> st.<span class="synIdentifier">get</span>(from, to); available[from].<span class="synIdentifier">push</span>((i, ticket_id, x)); <span class="synStatement">if</span> from <span class="synStatement">&lt;</span> i { segments.<span class="synIdentifier">push_back</span>((from, i)); } <span class="synStatement">if</span> i <span class="synStatement">+</span> <span class="synConstant">1</span> <span class="synStatement">&lt;</span> to { segments.<span class="synIdentifier">push_back</span>((i <span class="synStatement">+</span> <span class="synConstant">1</span>, to)); } } } <span class="synStatement">let</span> <span class="synType">mut</span> ans <span class="synStatement">=</span> <span class="synConstant">0</span>; <span class="synStatement">let</span> <span class="synType">mut</span> events <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synPreProc">vec!</span>[]; n]; <span class="synStatement">for</span> from <span class="synStatement">in</span> <span class="synConstant">0</span>..n { <span class="synStatement">for</span> <span class="synType">&amp;</span>(i, ticket_id, x) <span class="synStatement">in</span> available[from].<span class="synIdentifier">iter</span>() { events[i].<span class="synIdentifier">push</span>((ticket_id, x)); } <span class="synStatement">let</span> <span class="synType">mut</span> tickets <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synConstant">0</span>; m]; <span class="synStatement">let</span> <span class="synType">mut</span> sum <span class="synStatement">=</span> <span class="synConstant">0</span>; <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..m { tickets[i] <span class="synStatement">=</span> b[from][i]; sum <span class="synStatement">+=</span> tickets[i]; } <span class="synStatement">for</span> to <span class="synStatement">in</span> from..n { <span class="synStatement">for</span> <span class="synType">&amp;</span>(i, x) <span class="synStatement">in</span> events[to].<span class="synIdentifier">iter</span>() { sum <span class="synStatement">-=</span> tickets[i]; tickets[i] <span class="synStatement">=</span> x; sum <span class="synStatement">+=</span> tickets[i]; } <span class="synStatement">let</span> d <span class="synStatement">=</span> pos[to] <span class="synStatement">-</span> pos[from]; ans <span class="synStatement">=</span> ans.<span class="synIdentifier">max</span>(sum <span class="synStatement">-</span> d); } } <span class="synPreProc">println!</span>(<span class="synConstant">&quot;{}&quot;</span>, ans); } <span class="synStatement">pub</span> <span class="synStatement">mod</span> <span class="synIdentifier">sparse_table</span> { <span class="synStatement">pub</span> <span class="synStatement">struct</span> <span class="synIdentifier">SparseTable</span><span class="synStatement">&lt;</span>T, F<span class="synStatement">&gt;</span> { data: <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span>T<span class="synStatement">&gt;&gt;</span>, op: F, } <span class="synStatement">impl&lt;</span>T, F<span class="synStatement">&gt;</span> SparseTable<span class="synStatement">&lt;</span>T, F<span class="synStatement">&gt;</span> <span class="synStatement">where</span> T: <span class="synType">Copy</span>, F: <span class="synType">Fn</span>(T, T) <span class="synStatement">-&gt;</span> T, { <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">from</span>(v: <span class="synType">&amp;</span>[T], init: T, op: F) <span class="synStatement">-&gt;</span> <span class="synType">Self</span> { <span class="synStatement">let</span> size <span class="synStatement">=</span> v.<span class="synIdentifier">len</span>().<span class="synIdentifier">next_power_of_two</span>(); <span class="synStatement">let</span> count <span class="synStatement">=</span> size.<span class="synIdentifier">trailing_zeros</span>() <span class="synStatement">as</span> <span class="synType">usize</span> <span class="synStatement">+</span> <span class="synConstant">1</span>; <span class="synStatement">let</span> <span class="synType">mut</span> data <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synPreProc">vec!</span>[init; size]; count]; <span class="synStatement">for</span> (i, v) <span class="synStatement">in</span> v.<span class="synIdentifier">iter</span>().<span class="synIdentifier">cloned</span>().<span class="synIdentifier">enumerate</span>() { data[<span class="synConstant">0</span>][i] <span class="synStatement">=</span> v; } <span class="synStatement">for</span> c <span class="synStatement">in</span> <span class="synConstant">1</span>..count { <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..size { <span class="synStatement">let</span> next <span class="synStatement">=</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">cmp</span><span class="synSpecial">::</span><span class="synIdentifier">min</span>(size <span class="synStatement">-</span> <span class="synConstant">1</span>, i <span class="synStatement">+</span> (<span class="synConstant">1</span> <span class="synStatement">&lt;&lt;</span> (c <span class="synStatement">-</span> <span class="synConstant">1</span>))); data[c][i] <span class="synStatement">=</span> <span class="synIdentifier">op</span>(data[c <span class="synStatement">-</span> <span class="synConstant">1</span>][i], data[c <span class="synStatement">-</span> <span class="synConstant">1</span>][next]); } } <span class="synType">Self</span> { data, op } } <span class="synSpecial">/// get the result for [l, r)</span> <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">get</span>(<span class="synType">&amp;</span><span class="synConstant">self</span>, l: <span class="synType">usize</span>, r: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> T { <span class="synPreProc">assert!</span>(l <span class="synStatement">&lt;</span> r); <span class="synStatement">let</span> length <span class="synStatement">=</span> r <span class="synStatement">-</span> l; <span class="synStatement">if</span> length <span class="synStatement">==</span> <span class="synConstant">1</span> { <span class="synStatement">return</span> <span class="synConstant">self</span>.data[<span class="synConstant">0</span>][l]; } <span class="synStatement">let</span> block_size <span class="synStatement">=</span> length.<span class="synIdentifier">next_power_of_two</span>() <span class="synStatement">&gt;&gt;</span> <span class="synConstant">1</span>; <span class="synStatement">let</span> c <span class="synStatement">=</span> block_size.<span class="synIdentifier">trailing_zeros</span>() <span class="synStatement">as</span> <span class="synType">usize</span>; <span class="synStatement">let</span> left <span class="synStatement">=</span> <span class="synConstant">self</span>.data[c][l]; <span class="synStatement">let</span> right <span class="synStatement">=</span> <span class="synConstant">self</span>.data[c][r <span class="synStatement">-</span> block_size]; (<span class="synConstant">self</span>.op)(left, right) } } } <span class="synStatement">pub</span> <span class="synStatement">struct</span> <span class="synIdentifier">IO</span><span class="synStatement">&lt;</span>R, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span>(R, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>BufWriter<span class="synStatement">&lt;</span>W<span class="synStatement">&gt;</span>); <span class="synStatement">impl&lt;</span>R: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">new</span>(r: R, w: W) <span class="synStatement">-&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synIdentifier">IO</span>(r, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synPreProc">BufWriter</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(w)) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">write</span><span class="synStatement">&lt;</span>S: <span class="synType">ToString</span><span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, s: S) { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write; <span class="synConstant">self</span>.<span class="synConstant">1</span>.<span class="synIdentifier">write_all</span>(s.<span class="synIdentifier">to_string</span>().<span class="synIdentifier">as_bytes</span>()).<span class="synIdentifier">unwrap</span>(); } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">read</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> T { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read; <span class="synStatement">let</span> buf <span class="synStatement">=</span> <span class="synConstant">self</span> .<span class="synConstant">0</span> .<span class="synIdentifier">by_ref</span>() .<span class="synIdentifier">bytes</span>() .<span class="synIdentifier">map</span>(<span class="synStatement">|</span>b<span class="synStatement">|</span> b.<span class="synIdentifier">unwrap</span>()) .<span class="synIdentifier">skip_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">==</span> <span class="synConstant">b' '</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">take_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">!=</span> <span class="synConstant">b' '</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">collect</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span>_<span class="synStatement">&gt;&gt;</span>(); <span class="synStatement">unsafe</span> { <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span><span class="synIdentifier">from_utf8_unchecked</span>(<span class="synType">&amp;</span>buf) } .<span class="synIdentifier">parse</span>() .<span class="synIdentifier">ok</span>() .<span class="synIdentifier">expect</span>(<span class="synConstant">&quot;Parse error.&quot;</span>) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">usize0</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">usize</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;</span>() <span class="synStatement">-</span> <span class="synConstant">1</span> } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">vec</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, n: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span> { (<span class="synConstant">0</span>..n).<span class="synIdentifier">map</span>(<span class="synStatement">|</span>_<span class="synStatement">|</span> <span class="synConstant">self</span>.<span class="synIdentifier">read</span>()).<span class="synIdentifier">collect</span>() } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">chars</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">char</span><span class="synStatement">&gt;</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">String</span><span class="synStatement">&gt;</span>().<span class="synIdentifier">chars</span>().<span class="synIdentifier">collect</span>() } } </pre> kenkoooo ABC223 G - Vertex Deletion hatenablog://entry/13574176438023624444 2021-10-18T01:46:46+09:00 2021-10-18T01:47:30+09:00 問題 atcoder.jp 解法 まず、木の最大マッチングは葉から貪欲に取っていくことで作れる。これは深さ優先探索で根付き木で (ある頂点vを含むサブツリーのマッチングの個数, vがマッチングに含まれているか) を再帰的に求めることで求まる。この要領で、全方位木DPをして、全ての頂点について、その頂点を含まない(含むかどうか決める前の)マッチングの個数を求める。 コード fn main() { let (r, w) = (std::io::stdin(), std::io::stdout()); let mut sc = IO::new(r.lock(), w.lock()); let n: … <div class="section"> <h3>問題</h3> <p><iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fatcoder.jp%2Fcontests%2Fabc223%2Ftasks%2Fabc223_g" title="G - Vertex Deletion" class="embed-card embed-webcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 155px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://atcoder.jp/contests/abc223/tasks/abc223_g">atcoder.jp</a></cite><br /> </p> </div> <div class="section"> <h3>解法</h3> <p>まず、木の最大マッチングは葉から貪欲に取っていくことで作れる。これは<a class="keyword" href="http://d.hatena.ne.jp/keyword/%BF%BC%A4%B5%CD%A5%C0%E8%C3%B5%BA%F7">深さ優先探索</a>で根付き木で (ある頂点vを含むサブツリーのマッチングの個数, vがマッチングに含まれているか) を<a class="keyword" href="http://d.hatena.ne.jp/keyword/%BA%C6%B5%A2">再帰</a>的に求めることで求まる。</p><p>この要領で、全方位木DPをして、全ての頂点について、その頂点を含まない(含むかどうか決める前の)マッチングの個数を求める。</p> </div> <div class="section"> <h3>コード</h3> <pre class="code lang-rust" data-lang="rust" data-unlink><span class="synStatement">fn</span> <span class="synIdentifier">main</span>() { <span class="synStatement">let</span> (r, w) <span class="synStatement">=</span> (<span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdin</span>(), <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synIdentifier">stdout</span>()); <span class="synStatement">let</span> <span class="synType">mut</span> sc <span class="synStatement">=</span> <span class="synPreProc">IO</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(r.<span class="synIdentifier">lock</span>(), w.<span class="synIdentifier">lock</span>()); <span class="synStatement">let</span> n: <span class="synType">usize</span> <span class="synStatement">=</span> sc.<span class="synIdentifier">read</span>(); <span class="synStatement">let</span> <span class="synType">mut</span> graph <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synPreProc">vec!</span>[]; n]; <span class="synStatement">for</span> _ <span class="synStatement">in</span> <span class="synConstant">1</span>..n { <span class="synStatement">let</span> a <span class="synStatement">=</span> sc.<span class="synIdentifier">usize0</span>(); <span class="synStatement">let</span> b <span class="synStatement">=</span> sc.<span class="synIdentifier">usize0</span>(); graph[a].<span class="synIdentifier">push</span>(b); graph[b].<span class="synIdentifier">push</span>(a); } <span class="synStatement">let</span> <span class="synType">mut</span> dp <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synPreProc">vec!</span>[]; n]; <span class="synStatement">let</span> (greedy, _) <span class="synStatement">=</span> <span class="synIdentifier">dfs</span>(<span class="synConstant">0</span>, <span class="synConstant">0</span>, <span class="synType">&amp;</span>graph, <span class="synType">&amp;mut</span> dp); <span class="synStatement">let</span> <span class="synType">mut</span> ans <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[<span class="synConstant">0</span>; n]; <span class="synIdentifier">dfs2</span>(<span class="synConstant">0</span>, <span class="synConstant">0</span>, <span class="synType">&amp;</span>graph, <span class="synType">&amp;mut</span> dp, (<span class="synConstant">0</span>, <span class="synConstant">false</span>), <span class="synType">&amp;mut</span> ans); <span class="synStatement">let</span> <span class="synType">mut</span> count <span class="synStatement">=</span> <span class="synConstant">0</span>; <span class="synStatement">for</span> ans <span class="synStatement">in</span> ans { <span class="synStatement">if</span> ans <span class="synStatement">==</span> greedy { count <span class="synStatement">+=</span> <span class="synConstant">1</span>; } } <span class="synPreProc">println!</span>(<span class="synConstant">&quot;{}&quot;</span>, count); } <span class="synStatement">fn</span> <span class="synIdentifier">dfs</span>( v: <span class="synType">usize</span>, p: <span class="synType">usize</span>, graph: <span class="synType">&amp;Vec</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;&gt;</span>, dp: <span class="synType">&amp;mut</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span>(<span class="synType">usize</span>, <span class="synType">bool</span>)<span class="synStatement">&gt;&gt;</span>, ) <span class="synStatement">-&gt;</span> (<span class="synType">usize</span>, <span class="synType">bool</span>) { <span class="synStatement">let</span> <span class="synType">mut</span> requested <span class="synStatement">=</span> <span class="synConstant">false</span>; <span class="synStatement">let</span> <span class="synType">mut</span> sum <span class="synStatement">=</span> <span class="synConstant">0</span>; <span class="synStatement">let</span> deg <span class="synStatement">=</span> graph[v].<span class="synIdentifier">len</span>(); dp[v] <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[(<span class="synConstant">0</span>, <span class="synConstant">false</span>); deg]; <span class="synStatement">for</span> (i, <span class="synType">&amp;</span>next) <span class="synStatement">in</span> graph[v].<span class="synIdentifier">iter</span>().<span class="synIdentifier">enumerate</span>() { <span class="synStatement">if</span> next <span class="synStatement">==</span> p { <span class="synStatement">continue</span>; } <span class="synStatement">let</span> (count, prev_requested) <span class="synStatement">=</span> <span class="synIdentifier">dfs</span>(next, v, graph, dp); sum <span class="synStatement">+=</span> count; requested <span class="synStatement">|=</span> prev_requested; dp[v][i] <span class="synStatement">=</span> (count, prev_requested); } <span class="synStatement">if</span> requested { (sum <span class="synStatement">+</span> <span class="synConstant">1</span>, <span class="synConstant">false</span>) } <span class="synStatement">else</span> { (sum, <span class="synConstant">true</span>) } } <span class="synStatement">fn</span> <span class="synIdentifier">dfs2</span>( v: <span class="synType">usize</span>, p: <span class="synType">usize</span>, graph: <span class="synType">&amp;Vec</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;&gt;</span>, dp: <span class="synType">&amp;mut</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span>(<span class="synType">usize</span>, <span class="synType">bool</span>)<span class="synStatement">&gt;&gt;</span>, dp_p: (<span class="synType">usize</span>, <span class="synType">bool</span>), ans: <span class="synType">&amp;mut</span> [<span class="synType">usize</span>], ) { <span class="synStatement">for</span> (i, <span class="synType">&amp;</span>next) <span class="synStatement">in</span> graph[v].<span class="synIdentifier">iter</span>().<span class="synIdentifier">enumerate</span>() { <span class="synStatement">if</span> next <span class="synStatement">==</span> p { dp[v][i] <span class="synStatement">=</span> dp_p; } } <span class="synStatement">let</span> deg <span class="synStatement">=</span> graph[v].<span class="synIdentifier">len</span>(); <span class="synStatement">let</span> <span class="synType">mut</span> left_dp <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[(<span class="synConstant">0</span>, <span class="synConstant">false</span>); deg <span class="synStatement">+</span> <span class="synConstant">1</span>]; <span class="synStatement">let</span> <span class="synType">mut</span> right_dp <span class="synStatement">=</span> <span class="synPreProc">vec!</span>[(<span class="synConstant">0</span>, <span class="synConstant">false</span>); deg <span class="synStatement">+</span> <span class="synConstant">1</span>]; <span class="synStatement">for</span> i <span class="synStatement">in</span> <span class="synConstant">0</span>..deg { <span class="synStatement">let</span> (p_count, p_requested) <span class="synStatement">=</span> left_dp[i]; <span class="synStatement">let</span> (dp_count, dp_requested) <span class="synStatement">=</span> dp[v][i]; left_dp[i <span class="synStatement">+</span> <span class="synConstant">1</span>] <span class="synStatement">=</span> (p_count <span class="synStatement">+</span> dp_count, p_requested <span class="synStatement">||</span> dp_requested); } <span class="synStatement">for</span> i <span class="synStatement">in</span> (<span class="synConstant">0</span>..deg).<span class="synIdentifier">rev</span>() { <span class="synStatement">let</span> (p_count, p_requested) <span class="synStatement">=</span> right_dp[i <span class="synStatement">+</span> <span class="synConstant">1</span>]; <span class="synStatement">let</span> (dp_count, dp_requested) <span class="synStatement">=</span> dp[v][i]; right_dp[i] <span class="synStatement">=</span> (p_count <span class="synStatement">+</span> dp_count, p_requested <span class="synStatement">||</span> dp_requested); } ans[v] <span class="synStatement">=</span> left_dp[deg].<span class="synConstant">0</span>; <span class="synStatement">for</span> (i, <span class="synType">&amp;</span>next) <span class="synStatement">in</span> graph[v].<span class="synIdentifier">iter</span>().<span class="synIdentifier">enumerate</span>() { <span class="synStatement">if</span> next <span class="synStatement">==</span> p { <span class="synStatement">continue</span>; } <span class="synStatement">let</span> (left_count, left_requested) <span class="synStatement">=</span> left_dp[i]; <span class="synStatement">let</span> (right_count, right_requested) <span class="synStatement">=</span> right_dp[i <span class="synStatement">+</span> <span class="synConstant">1</span>]; <span class="synStatement">let</span> add <span class="synStatement">=</span> <span class="synStatement">if</span> left_requested <span class="synStatement">||</span> right_requested { <span class="synConstant">1</span> } <span class="synStatement">else</span> { <span class="synConstant">0</span> }; <span class="synIdentifier">dfs2</span>( next, v, graph, dp, (left_count <span class="synStatement">+</span> right_count <span class="synStatement">+</span> add, add <span class="synStatement">!=</span> <span class="synConstant">1</span>), ans, ); } } <span class="synStatement">pub</span> <span class="synStatement">struct</span> <span class="synIdentifier">IO</span><span class="synStatement">&lt;</span>R, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span>(R, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>BufWriter<span class="synStatement">&lt;</span>W<span class="synStatement">&gt;</span>); <span class="synStatement">impl&lt;</span>R: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read, W: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write<span class="synStatement">&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">new</span>(r: R, w: W) <span class="synStatement">-&gt;</span> IO<span class="synStatement">&lt;</span>R, W<span class="synStatement">&gt;</span> { <span class="synIdentifier">IO</span>(r, <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span><span class="synPreProc">BufWriter</span><span class="synSpecial">::</span><span class="synIdentifier">new</span>(w)) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">write</span><span class="synStatement">&lt;</span>S: <span class="synType">ToString</span><span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, s: S) { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Write; <span class="synConstant">self</span>.<span class="synConstant">1</span>.<span class="synIdentifier">write_all</span>(s.<span class="synIdentifier">to_string</span>().<span class="synIdentifier">as_bytes</span>()).<span class="synIdentifier">unwrap</span>(); } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">read</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> T { <span class="synStatement">use</span> <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synPreProc">io</span><span class="synSpecial">::</span>Read; <span class="synStatement">let</span> buf <span class="synStatement">=</span> <span class="synConstant">self</span> .<span class="synConstant">0</span> .<span class="synIdentifier">by_ref</span>() .<span class="synIdentifier">bytes</span>() .<span class="synIdentifier">map</span>(<span class="synStatement">|</span>b<span class="synStatement">|</span> b.<span class="synIdentifier">unwrap</span>()) .<span class="synIdentifier">skip_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">==</span> <span class="synConstant">b' '</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">||</span> b <span class="synStatement">==</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">take_while</span>(<span class="synStatement">|</span><span class="synType">&amp;</span>b<span class="synStatement">|</span> b <span class="synStatement">!=</span> <span class="synConstant">b' '</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\n</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\r</span><span class="synConstant">'</span> <span class="synStatement">&amp;&amp;</span> b <span class="synStatement">!=</span> <span class="synConstant">b'</span><span class="synSpecial">\t</span><span class="synConstant">'</span>) .<span class="synIdentifier">collect</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">Vec</span><span class="synStatement">&lt;</span>_<span class="synStatement">&gt;&gt;</span>(); <span class="synStatement">unsafe</span> { <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span><span class="synIdentifier">from_utf8_unchecked</span>(<span class="synType">&amp;</span>buf) } .<span class="synIdentifier">parse</span>() .<span class="synIdentifier">ok</span>() .<span class="synIdentifier">expect</span>(<span class="synConstant">&quot;Parse error.&quot;</span>) } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">usize0</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">usize</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">usize</span><span class="synStatement">&gt;</span>() <span class="synStatement">-</span> <span class="synConstant">1</span> } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">vec</span><span class="synStatement">&lt;</span>T: <span class="synPreProc">std</span><span class="synSpecial">::</span><span class="synType">str</span><span class="synSpecial">::</span>FromStr<span class="synStatement">&gt;</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>, n: <span class="synType">usize</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span>T<span class="synStatement">&gt;</span> { (<span class="synConstant">0</span>..n).<span class="synIdentifier">map</span>(<span class="synStatement">|</span>_<span class="synStatement">|</span> <span class="synConstant">self</span>.<span class="synIdentifier">read</span>()).<span class="synIdentifier">collect</span>() } <span class="synStatement">pub</span> <span class="synStatement">fn</span> <span class="synIdentifier">chars</span>(<span class="synType">&amp;mut</span> <span class="synConstant">self</span>) <span class="synStatement">-&gt;</span> <span class="synType">Vec</span><span class="synStatement">&lt;</span><span class="synType">char</span><span class="synStatement">&gt;</span> { <span class="synConstant">self</span>.<span class="synIdentifier">read</span><span class="synSpecial">::</span><span class="synStatement">&lt;</span><span class="synType">String</span><span class="synStatement">&gt;</span>().<span class="synIdentifier">chars</span>().<span class="synIdentifier">collect</span>() } } </pre> </div> <div class="section"> <h3>コメント</h3> <p>全方位木DPは問題によって自由度が高いのでライブラリにしにくく感じる(一般にDPはライブラリにしにくい)ので、こうやって経験が積めるのは助かる。</p> </div> kenkoooo EC2 Amazon Linux を PostgreSQL インスタンスとして立ち上げる hatenablog://entry/26006613780323391 2021-06-27T01:17:55+09:00 2021-06-27T01:17:55+09:00 #!/bin/bash -xe amazon-linux-extras install postgresql11 -y yum install postgresql-server postgresql-devel postgresql-contrib -y postgresql-setup initdb systemctl enable postgresql.service --now sudo -u postgres createdb ${DatabaseName} sudo -u postgres psql -U postgres -c "CREATE ROLE ${DatabaseUse… <pre class="code bash" data-lang="bash" data-unlink>#!/bin/bash -xe amazon-linux-extras install postgresql11 -y yum install postgresql-server postgresql-devel postgresql-contrib -y postgresql-setup initdb systemctl enable postgresql.service --now sudo -u postgres createdb ${DatabaseName} sudo -u postgres psql -U postgres -c &#34;CREATE ROLE ${DatabaseUser} WITH LOGIN PASSWORD &#39;${DatabasePassword}&#39;&#34; sudo -u postgres psql -U postgres -c &#34;GRANT ALL PRIVILEGES ON DATABASE ${DatabaseName} TO ${DatabaseUser}&#34; echo &#39;host all all 0.0.0.0/0 password&#39; &gt; /var/lib/pgsql/data/pg_hba.conf echo &#39;local all all password&#39; &gt;&gt; /var/lib/pgsql/data/pg_hba.conf echo &#34;listen_addresses = &#39;*&#39;&#34; &gt;&gt; /var/lib/pgsql/data/postgresql.conf systemctl restart postgresql.service</pre> kenkoooo 2021/06/22 hatenablog://entry/26006613778626415 2021-06-22T09:59:47+09:00 2021-06-22T09:59:47+09:00 ずっと CloudFormation でアプリを作っていた。 <p>ずっと CloudFormation でアプリを作っていた。</p> kenkoooo 2021/06/20 hatenablog://entry/26006613778192548 2021-06-21T02:28:50+09:00 2021-06-21T02:28:50+09:00 kenkoooo.hatenablog.com kenkoooo.hatenablog.com kenkoooo.hatenablog.com kenkoooo.hatenablog.com kenkoooo.hatenablog.com kenkoooo.hatenablog.com AtCoder 1654 -> 1654 (+0) 橙diff: 84 -> 84 (+0) 黄diff: 162 -> 162 (+0) Project Euler 109 -> 109 (+0) 英語 Paolo from Tokyo を昼休みに観るなどしている。 睡眠 来週に向けて 競プロをやる。 <p><iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fkenkoooo.hatenablog.com%2Fentry%2F2021%2F06%2F16%2F220225" title="2021/06/14 - 宇宙ツイッタラーXの憂鬱" class="embed-card embed-blogcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 190px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://kenkoooo.hatenablog.com/entry/2021/06/16/220225">kenkoooo.hatenablog.com</a></cite><br /> <iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fkenkoooo.hatenablog.com%2Fentry%2F2021%2F06%2F16%2F220254" title="2021/06/15 - 宇宙ツイッタラーXの憂鬱" class="embed-card embed-blogcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 190px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://kenkoooo.hatenablog.com/entry/2021/06/16/220254">kenkoooo.hatenablog.com</a></cite><br /> <iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fkenkoooo.hatenablog.com%2Fentry%2F2021%2F06%2F16%2F220337" title="2021/06/16 - 宇宙ツイッタラーXの憂鬱" class="embed-card embed-blogcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 190px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://kenkoooo.hatenablog.com/entry/2021/06/16/220337">kenkoooo.hatenablog.com</a></cite><br /> <iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fkenkoooo.hatenablog.com%2Fentry%2F2021%2F06%2F21%2F022126" title="2021/06/17 - 宇宙ツイッタラーXの憂鬱" class="embed-card embed-blogcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 190px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://kenkoooo.hatenablog.com/entry/2021/06/21/022126">kenkoooo.hatenablog.com</a></cite><br /> <iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fkenkoooo.hatenablog.com%2Fentry%2F2021%2F06%2F21%2F022224" title="2021/06/18 - 宇宙ツイッタラーXの憂鬱" class="embed-card embed-blogcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 190px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://kenkoooo.hatenablog.com/entry/2021/06/21/022224">kenkoooo.hatenablog.com</a></cite><br /> <iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fkenkoooo.hatenablog.com%2Fentry%2F2021%2F06%2F21%2F022400" title="2021/06/19 - 宇宙ツイッタラーXの憂鬱" class="embed-card embed-blogcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 190px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://kenkoooo.hatenablog.com/entry/2021/06/21/022400">kenkoooo.hatenablog.com</a></cite><br /> </p> <div class="section"> <h3><a class="keyword" href="http://d.hatena.ne.jp/keyword/AtCoder">AtCoder</a></h3> <ul> <li>1654 -> 1654 (+0)</li> <li>橙diff: 84 -> 84 (+0)</li> <li>黄diff: 162 -> 162 (+0)</li> </ul> </div> <div class="section"> <h3><a class="keyword" href="http://d.hatena.ne.jp/keyword/Project%20Euler">Project Euler</a></h3> <ul> <li>109 -> 109 (+0)</li> </ul> </div> <div class="section"> <h3>英語</h3> <p>Paolo from Tokyo を昼休みに観るなどしている。</p> </div> <div class="section"> <h3>睡眠</h3> <p><span itemscope itemtype="http://schema.org/Photograph"><img src="https://cdn-ak.f.st-hatena.com/images/fotolife/k/kenkoooo/20210621/20210621022637.png" alt="f:id:kenkoooo:20210621022637p:plain" width="800" height="315" loading="lazy" title="" class="hatena-fotolife" itemprop="image"></span><br /> </p> </div> <div class="section"> <h3>来週に向けて</h3> <ul> <li>競プロをやる。</li> </ul> </div> kenkoooo 2021/06/19 hatenablog://entry/26006613778192154 2021-06-21T02:24:00+09:00 2021-06-21T02:24:38+09:00 AtCoder Problems で async function を受け取って async function を返すやつを作りたくなったので書いてみた。まあまあ大変だったが、これでよかったのかどうかもよくわからない。github.comserverless framework を使うために CloudFormation のドキュメントを読み続けている。 <p><a class="keyword" href="http://d.hatena.ne.jp/keyword/AtCoder">AtCoder</a> Problems で async function を受け取って async function を返すやつを作りたくなったので書いてみた。まあまあ大変だったが、これでよかったのかどうかもよくわからない。</p><p><iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fgithub.com%2Fkenkoooo%2FAtCoderProblems%2Fpull%2F988%2Ffiles" title="Refactor ranking APIs by kenkoooo · Pull Request #988 · kenkoooo/AtCoderProblems" class="embed-card embed-webcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 155px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://github.com/kenkoooo/AtCoderProblems/pull/988/files">github.com</a></cite></p><p>serverless framework を使うために CloudFormation のドキュメントを読み続けている。</p> kenkoooo 2021/06/18 hatenablog://entry/26006613778191980 2021-06-21T02:22:24+09:00 2021-06-21T02:22:24+09:00 NESエミュレータについて調べたが、かなり気合を入れないと完成しないことが分かった。今度にします。英語の勉強として Paolo from Tokyo を観た。 <p><a class="keyword" href="http://d.hatena.ne.jp/keyword/NES">NES</a><a class="keyword" href="http://d.hatena.ne.jp/keyword/%A5%A8%A5%DF%A5%E5%A5%EC%A1%BC%A5%BF">エミュレータ</a>について調べたが、かなり気合を入れないと完成しないことが分かった。今度にします。</p><p>英語の勉強として Paolo from Tokyo を観た。</p> kenkoooo 2021/06/17 hatenablog://entry/26006613778191893 2021-06-21T02:21:26+09:00 2021-06-21T02:21:26+09:00 riano_ 師匠とバチャhttps://kenkoooo.com/atcoder/#/contest/show/3f0552d8-2efb-4370-b9e4-f5e441fd3b1d全方位木DPようやく理解しました。 <p>riano_ 師匠とバチャ</p><p><a href="https://kenkoooo.com/atcoder/#/contest/show/3f0552d8-2efb-4370-b9e4-f5e441fd3b1d">https://kenkoooo.com/atcoder/#/contest/show/3f0552d8-2efb-4370-b9e4-f5e441fd3b1d</a></p><p>全方位木DPようやく理解しました。</p> kenkoooo Serverless Framework (CloudFormation) で PostgreSQL をインストールした EC2 インスタンスを起動する hatenablog://entry/26006613777692748 2021-06-19T19:32:07+09:00 2021-06-19T19:32:07+09:00 service: サービス名 provider: name: aws region: ap-northeast-1 iam: role: name: ロール名 statements: - Effect: "Allow" Action: - "ec2:RunInstances" resources: Resources: PostgreSQLInstance: Type: 'AWS::EC2::Instance' Properties: ImageId: ami-03179588b2f59f257 InstanceType: 't3a.nano' KeyName: キーペアの名前 BlockDe… <pre class="code lang-yaml" data-lang="yaml" data-unlink><span class="synIdentifier">service</span><span class="synSpecial">:</span> サービス名 <span class="synIdentifier">provider</span><span class="synSpecial">:</span> <span class="synIdentifier">name</span><span class="synSpecial">:</span> aws <span class="synIdentifier">region</span><span class="synSpecial">:</span> ap-northeast-1 <span class="synIdentifier">iam</span><span class="synSpecial">:</span> <span class="synIdentifier">role</span><span class="synSpecial">:</span> <span class="synIdentifier">name</span><span class="synSpecial">:</span> ロール名 <span class="synIdentifier">statements</span><span class="synSpecial">:</span> <span class="synStatement">- </span><span class="synIdentifier">Effect</span><span class="synSpecial">:</span> <span class="synConstant">&quot;Allow&quot;</span> <span class="synIdentifier">Action</span><span class="synSpecial">:</span> <span class="synStatement">- </span><span class="synConstant">&quot;ec2:RunInstances&quot;</span> <span class="synIdentifier">resources</span><span class="synSpecial">:</span> <span class="synIdentifier">Resources</span><span class="synSpecial">:</span> <span class="synIdentifier">PostgreSQLInstance</span><span class="synSpecial">:</span> <span class="synIdentifier">Type</span><span class="synSpecial">:</span> <span class="synConstant">'AWS::EC2::Instance'</span> <span class="synIdentifier">Properties</span><span class="synSpecial">:</span> <span class="synIdentifier">ImageId</span><span class="synSpecial">:</span> ami-03179588b2f59f257 <span class="synIdentifier">InstanceType</span><span class="synSpecial">:</span> <span class="synConstant">'t3a.nano'</span> <span class="synIdentifier">KeyName</span><span class="synSpecial">:</span> キーペアの名前 <span class="synIdentifier">BlockDeviceMappings</span><span class="synSpecial">:</span> <span class="synStatement">- </span><span class="synIdentifier">DeviceName</span><span class="synSpecial">:</span> /dev/xvda <span class="synIdentifier">Ebs</span><span class="synSpecial">:</span> <span class="synIdentifier">VolumeType</span><span class="synSpecial">:</span> <span class="synConstant">'gp3'</span> <span class="synIdentifier">VolumeSize</span><span class="synSpecial">:</span> <span class="synConstant">'30'</span> <span class="synIdentifier">Iops</span><span class="synSpecial">:</span> <span class="synConstant">'3000'</span> <span class="synIdentifier">UserData</span><span class="synSpecial">:</span> <span class="synIdentifier">Fn::Base64</span><span class="synSpecial">:</span> <span class="synType">!Sub</span> | <span class="synComment"> #!/bin/bash -xe</span> yum install postgresql-server postgresql-devel postgresql-contrib -y postgresql-setup initdb systemctl enable postgresql.service systemctl start postgresql.service sudo -u postgres createdb データベース名 sudo -u postgres psql -U postgres -c <span class="synConstant">&quot;CREATE ROLE ユーザー名 WITH LOGIN PASSWORD 'パスワード'&quot;</span> sudo -u postgres psql -U postgres -c <span class="synConstant">&quot;GRANT ALL PRIVILEGES ON DATABASE データベース名 TO ユーザー名&quot;</span> echo <span class="synConstant">'host all all 0.0.0.0/0 password'</span> &gt; /var/lib/pgsql/data/pg_hba.conf echo <span class="synConstant">'local all all password'</span> &gt;&gt; /var/lib/pgsql/data/pg_hba.conf echo <span class="synConstant">&quot;listen_addresses = '*'&quot;</span> &gt;&gt; /var/lib/pgsql/data/postgresql.conf systemctl restart postgresql.service </pre> kenkoooo 2021/06/16 hatenablog://entry/26006613776680094 2021-06-16T22:03:37+09:00 2021-06-16T22:03:37+09:00 YouTube で英語の動画をいくつか見た。こういうのは習慣化するのが大事。 <p><a class="keyword" href="http://d.hatena.ne.jp/keyword/YouTube">YouTube</a> で英語の動画をいくつか見た。こういうのは習慣化するのが大事。</p> kenkoooo 2021/06/15 hatenablog://entry/26006613776679841 2021-06-16T22:02:54+09:00 2021-06-16T22:02:54+09:00 じっくり目のコーディング業をした。 <p>じっくり目のコーディング業をした。</p> kenkoooo 2021/06/14 hatenablog://entry/26006613776679681 2021-06-16T22:02:25+09:00 2021-06-16T22:02:25+09:00 有給休暇(会社の祝日)なので誰にも邪魔されずに仕事をした。いや別に普段は邪魔されているわけではないのだが、ミーティングが入っているとその前後でじっくり腰を据えた作業ができなかったり体力を消耗したりするので、割と厳しい。 <p>有給休暇(会社の祝日)なので誰にも邪魔されずに仕事をした。いや別に普段は邪魔されているわけではないのだが、ミーティングが入っているとその前後でじっくり腰を据えた作業ができなかったり体力を消耗したりするので、割と厳しい。</p> kenkoooo 2021/06/13 振り返り hatenablog://entry/26006613775610318 2021-06-14T00:39:53+09:00 2021-06-14T00:39:53+09:00 kenkoooo.hatenablog.com kenkoooo.hatenablog.com kenkoooo.hatenablog.com kenkoooo.hatenablog.com kenkoooo.hatenablog.com kenkoooo.hatenablog.com AtCoder 1644 -> 1654 (+10) 橙diff: 83 -> 84 (+1) 黄diff: 160 -> 162 (+2) Project Euler 109 -> 109 (+0) 英語 無 睡眠 来週に向けて 睡眠時間が7時間を割ると顕著にパフォーマンスが落ちることが分かった。とにかく寝る… <p><iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fkenkoooo.hatenablog.com%2Fentry%2F2021%2F06%2F09%2F001506" title="2021/06/07 - 宇宙ツイッタラーXの憂鬱" class="embed-card embed-blogcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 190px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://kenkoooo.hatenablog.com/entry/2021/06/09/001506">kenkoooo.hatenablog.com</a></cite><br /> <iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fkenkoooo.hatenablog.com%2Fentry%2F2021%2F06%2F09%2F001548" title="2021/06/08 - 宇宙ツイッタラーXの憂鬱" class="embed-card embed-blogcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 190px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://kenkoooo.hatenablog.com/entry/2021/06/09/001548">kenkoooo.hatenablog.com</a></cite><br /> <iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fkenkoooo.hatenablog.com%2Fentry%2F2021%2F06%2F11%2F004948" title="2021/06/09 - 宇宙ツイッタラーXの憂鬱" class="embed-card embed-blogcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 190px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://kenkoooo.hatenablog.com/entry/2021/06/11/004948">kenkoooo.hatenablog.com</a></cite><br /> <iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fkenkoooo.hatenablog.com%2Fentry%2F2021%2F06%2F11%2F005245" title="2021/06/10 - 宇宙ツイッタラーXの憂鬱" class="embed-card embed-blogcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 190px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://kenkoooo.hatenablog.com/entry/2021/06/11/005245">kenkoooo.hatenablog.com</a></cite><br /> <iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fkenkoooo.hatenablog.com%2Fentry%2F2021%2F06%2F14%2F003411" title="2021/06/12 - 宇宙ツイッタラーXの憂鬱" class="embed-card embed-blogcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 190px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://kenkoooo.hatenablog.com/entry/2021/06/14/003411">kenkoooo.hatenablog.com</a></cite><br /> <iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fkenkoooo.hatenablog.com%2Fentry%2F2021%2F06%2F14%2F003458" title="2021/06/11 - 宇宙ツイッタラーXの憂鬱" class="embed-card embed-blogcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 190px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://kenkoooo.hatenablog.com/entry/2021/06/14/003458">kenkoooo.hatenablog.com</a></cite><br /> </p> <div class="section"> <h3><a class="keyword" href="http://d.hatena.ne.jp/keyword/AtCoder">AtCoder</a></h3> <ul> <li>1644 -> 1654 (+10)</li> <li>橙diff: 83 -> 84 (+1)</li> <li>黄diff: 160 -> 162 (+2)</li> </ul> </div> <div class="section"> <h3><a class="keyword" href="http://d.hatena.ne.jp/keyword/Project%20Euler">Project Euler</a></h3> <ul> <li>109 -> 109 (+0)</li> </ul> </div> <div class="section"> <h3>英語</h3> <p>無</p> </div> <div class="section"> <h3>睡眠</h3> <p><span itemscope itemtype="http://schema.org/Photograph"><img src="https://cdn-ak.f.st-hatena.com/images/fotolife/k/kenkoooo/20210614/20210614003837.png" alt="f:id:kenkoooo:20210614003837p:plain" width="800" height="319" loading="lazy" title="" class="hatena-fotolife" itemprop="image"></span><br /> </p> </div> <div class="section"> <h3>来週に向けて</h3> <ul> <li>睡眠時間が7時間を割ると顕著にパフォーマンスが落ちることが分かった。とにかく寝る。</li> <li><a class="keyword" href="http://d.hatena.ne.jp/keyword/Project%20Euler">Project Euler</a> と英語を重点的にやる。</li> </ul> </div> kenkoooo 2021/06/11 hatenablog://entry/26006613775609209 2021-06-14T00:34:58+09:00 2021-06-14T00:34:58+09:00 睡眠不足で分かりやすくパフォーマンスが落ちた。 <p>睡眠不足で分かりやすくパフォーマンスが落ちた。</p> kenkoooo 2021/06/12 hatenablog://entry/26006613775608897 2021-06-14T00:34:11+09:00 2021-06-14T00:34:11+09:00 ARCはCとDを飛ばしてEに行ったのが結果的に良かった。 <p>ARCはCとDを飛ばしてEに行ったのが結果的に良かった。</p> kenkoooo 2021/06/10 hatenablog://entry/26006613774485883 2021-06-11T00:52:45+09:00 2021-06-11T00:52:45+09:00 riano_ 師匠とバチャhttps://kenkoooo.com/atcoder/#/contest/show/e2ffc15a-21fd-47bf-b39d-caae70782f66atcoder.jp一見、数学者以外お断り証明問題に見えて、ゴリゴリの実装問題で面白い。D - Histogram Coloring解けたような気がするので、明日実装する。 <p>riano_ 師匠とバチャ</p><p><a href="https://kenkoooo.com/atcoder/#/contest/show/e2ffc15a-21fd-47bf-b39d-caae70782f66">https://kenkoooo.com/atcoder/#/contest/show/e2ffc15a-21fd-47bf-b39d-caae70782f66</a></p><p><iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fatcoder.jp%2Fcontests%2Fagc038%2Ftasks%2Fagc038_c" title="C - LCMs" class="embed-card embed-webcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 155px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://atcoder.jp/contests/agc038/tasks/agc038_c">atcoder.jp</a></cite></p><p>一見、数学者以外お断り証明問題に見えて、ゴリゴリの実装問題で面白い。</p><p><a href="https://atcoder.jp/contests/agc026/tasks/agc026_d">D - Histogram Coloring</a></p><p>解けたような気がするので、明日実装する。</p> kenkoooo 2021/06/09 hatenablog://entry/26006613774485326 2021-06-11T00:49:48+09:00 2021-06-11T00:49:48+09:00 <p>無</p> kenkoooo 2021/06/08 hatenablog://entry/26006613773756256 2021-06-09T00:15:48+09:00 2021-06-09T00:15:48+09:00 睡眠不足を解消した。仕事をちゃんとやってみた。 <p>睡眠不足を解消した。仕事をちゃんとやってみた。</p> kenkoooo 2021/06/07 hatenablog://entry/26006613773756076 2021-06-09T00:15:06+09:00 2021-06-09T00:15:06+09:00 睡眠不足で完全にダメ <p>睡眠不足で完全にダメ</p> kenkoooo 2021/06/06 振り返り hatenablog://entry/26006613773755934 2021-06-09T00:14:37+09:00 2021-06-09T00:14:37+09:00 kenkoooo.hatenablog.com kenkoooo.hatenablog.com kenkoooo.hatenablog.com kenkoooo.hatenablog.com kenkoooo.hatenablog.com kenkoooo.hatenablog.com AtCoder 1639 -> 1644 (+5) 橙diff: 83 -> 83 (+0) 黄diff: 160 -> 160 (+0) Project Euler 109 -> 109 (+0) 英語 Paolo from Tokyo 観始めた。 睡眠 <p><iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fkenkoooo.hatenablog.com%2Fentry%2F2021%2F06%2F01%2F155147" title="2021/05/31 - 宇宙ツイッタラーXの憂鬱" class="embed-card embed-blogcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 190px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://kenkoooo.hatenablog.com/entry/2021/06/01/155147">kenkoooo.hatenablog.com</a></cite><br /> <iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fkenkoooo.hatenablog.com%2Fentry%2F2021%2F06%2F03%2F004544" title="2021/06/01 - 宇宙ツイッタラーXの憂鬱" class="embed-card embed-blogcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 190px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://kenkoooo.hatenablog.com/entry/2021/06/03/004544">kenkoooo.hatenablog.com</a></cite><br /> <iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fkenkoooo.hatenablog.com%2Fentry%2F2021%2F06%2F03%2F004726" title="2021/06/02 - 宇宙ツイッタラーXの憂鬱" class="embed-card embed-blogcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 190px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://kenkoooo.hatenablog.com/entry/2021/06/03/004726">kenkoooo.hatenablog.com</a></cite><br /> <iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fkenkoooo.hatenablog.com%2Fentry%2F2021%2F06%2F04%2F020049" title="2021/06/03 - 宇宙ツイッタラーXの憂鬱" class="embed-card embed-blogcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 190px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://kenkoooo.hatenablog.com/entry/2021/06/04/020049">kenkoooo.hatenablog.com</a></cite><br /> <iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fkenkoooo.hatenablog.com%2Fentry%2F2021%2F06%2F05%2F122356" title="2021/06/04 - 宇宙ツイッタラーXの憂鬱" class="embed-card embed-blogcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 190px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://kenkoooo.hatenablog.com/entry/2021/06/05/122356">kenkoooo.hatenablog.com</a></cite><br /> <iframe src="https://hatenablog-parts.com/embed?url=https%3A%2F%2Fkenkoooo.hatenablog.com%2Fentry%2F2021%2F06%2F09%2F000545" title="2021/06/05 - 宇宙ツイッタラーXの憂鬱" class="embed-card embed-blogcard" scrolling="no" frameborder="0" style="display: block; width: 100%; height: 190px; max-width: 500px; margin: 10px 0px;"></iframe><cite class="hatena-citation"><a href="https://kenkoooo.hatenablog.com/entry/2021/06/09/000545">kenkoooo.hatenablog.com</a></cite></p><p></p> <div class="section"> <h3><a class="keyword" href="http://d.hatena.ne.jp/keyword/AtCoder">AtCoder</a></h3> <ul> <li>1639 -> 1644 (+5)</li> <li>橙diff: 83 -> 83 (+0)</li> <li>黄diff: 160 -> 160 (+0)</li> </ul> </div> <div class="section"> <h3><a class="keyword" href="http://d.hatena.ne.jp/keyword/Project%20Euler">Project Euler</a></h3> <ul> <li>109 -> 109 (+0)</li> </ul> </div> <div class="section"> <h3>英語</h3> <p>Paolo from Tokyo 観始めた。</p> </div> <div class="section"> <h3>睡眠</h3> <p><span itemscope itemtype="http://schema.org/Photograph"><img src="https://cdn-ak.f.st-hatena.com/images/fotolife/k/kenkoooo/20210609/20210609001420.png" alt="f:id:kenkoooo:20210609001420p:plain" title="" class="hatena-fotolife" itemprop="image"></span></p> </div> kenkoooo 2021/06/05 hatenablog://entry/26006613773753396 2021-06-09T00:05:45+09:00 2021-06-09T00:05:45+09:00 serverless を使って Lambda と S3 のウェブサービスを作れるようになった。 <p>serverless を使って Lambda と S3 の<a class="keyword" href="http://d.hatena.ne.jp/keyword/%A5%A6%A5%A7%A5%D6%A5%B5%A1%BC%A5%D3%A5%B9">ウェブサービス</a>を作れるようになった。</p> kenkoooo 2021/06/04 hatenablog://entry/26006613772357576 2021-06-05T12:23:56+09:00 2021-06-05T12:23:56+09:00 典型90を始めた。 <p>典型90を始めた。</p> kenkoooo