feed.xml

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
    <generator uri="https://gohugo.io/" version="0.130.0">Hugo</generator>
    <title>Weily&#39;s blog</title>
        <subtitle>I write, therefore I am.</subtitle>
            <link href="https://weilycoder.github.io/" rel="alternate" type="text/html" title="html" />
            <link href="https://weilycoder.github.io/feed.xml" rel="self" type="application/atom+xml" title="atom" />
    <updated>2024-12-30T16:05:56+08:00</updated>
        <author>
            <name>weily</name>
                <email>weily2009@outlook.com</email>
        </author>
    <id>https://weilycoder.github.io/</id>
        <entry>
            <title>Who I am</title>
            <link href="https://weilycoder.github.io/post/about/" rel="alternate" type="text/html"  hreflang="en" />
            <id>https://weilycoder.github.io/post/about/</id>
            <published>2024-06-01T00:35:21+08:00</published>
            <updated>2024-06-01T00:35:21+08:00</updated>
            <content type="html">
                &lt;p&gt;&lt;a
  class=&#34;gblog-markdown__link--raw&#34;
  href=&#34;https://badges.toozhao.com/stats/01HYYXADZH998DH2N5QTGZSZG1&#34;
&gt;&lt;img
  src=&#34;https://badges.toozhao.com/badges/01HYYXADZH998DH2N5QTGZSZG1/green.svg&#34;
  alt=&#34;Page Views Count&#34;
  
/&gt;&lt;/a&gt;
&lt;a
  class=&#34;gblog-markdown__link--raw&#34;
  href=&#34;https://codeforces.com/profile/weily&#34;
&gt;&lt;img
  src=&#34;https://cfrating.baoshuo.dev/rating?username=weily&amp;amp;style=flat&#34;
  alt=&#34;Codeforces Rating of @weily&#34;
  
/&gt;&lt;/a&gt;
&lt;a
  class=&#34;gblog-markdown__link--raw&#34;
  href=&#34;https://atcoder.jp/users/weily&#34;
&gt;&lt;img
  src=&#34;https://atrating.baoshuo.dev/rating?username=weily&amp;amp;style=flat&#34;
  alt=&#34;AtCoder Rating of @weily&#34;
  
/&gt;&lt;/a&gt;
&lt;a
  class=&#34;gblog-markdown__link--raw&#34;
  href=&#34;https://github.com/weilycoder&#34;
&gt;&lt;img
  src=&#34;https://img.shields.io/badge/github-weilycoder-blue?logo=github&#34;
  alt=&#34;github&#34;
  
/&gt;&lt;/a&gt;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;朝乾夕惕，功不唐捐。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;自我介绍&#34;
    &gt;
        自我介绍
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/about/#自我介绍&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 自我介绍&#34; href=&#34;#%e8%87%aa%e6%88%91%e4%bb%8b%e7%bb%8d&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;ul&gt;
&lt;li&gt;👋 Hi, I’m weily&lt;/li&gt;
&lt;li&gt;🇨🇳 来自中国的一名高中生&lt;/li&gt;
&lt;li&gt;👀 对数学和计算机科学很感兴趣&lt;/li&gt;
&lt;li&gt;🌱 现已考上&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;http://sdshiyan.jinan.cn/&#34;
&gt;山东省实验中学&lt;/a&gt;推荐生&lt;/li&gt;
&lt;li&gt;💞️ 正在学习算法竞赛（Olympiad in Informatics）&lt;/li&gt;
&lt;li&gt;📫 How to reach me &amp;hellip;
&lt;ul&gt;
&lt;li&gt;QQ: 1991809701 / 40726462&lt;/li&gt;
&lt;li&gt;e-mail: &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;mailto:weily2009@outlook.com&#34;
&gt;weily2009@outlook.com&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;luogu: &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://www.luogu.com/user/818693&#34;
&gt;wly09&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;⚡ 已成为 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://github.com/OI-wiki/OI-wiki&#34;
&gt;OI-wiki&lt;/a&gt; 贡献者！&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;另外，我在&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://www.cnblogs.com/weily09&#34;
&gt;博客园&lt;/a&gt;也会发布文章。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;声明&#34;
    &gt;
        声明
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/about/#声明&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 声明&#34; href=&#34;#%e5%a3%b0%e6%98%8e&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;ol start=&#34;0&#34;&gt;
&lt;li&gt;Page Views Count 是我的所有个人介绍页面公用的，而且大部分是我的访问。&lt;/li&gt;
&lt;li&gt;博客托管在 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://github.com&#34;
&gt;Github&lt;/a&gt; 提供的静态页面服务，网站构建使用 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://gohugo.io/&#34;
&gt;Hugo&lt;/a&gt;，主题风格来自 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://hugo-geekblog.geekdocs.de/&#34;
&gt;hugo-geekblog&lt;/a&gt;。&lt;/li&gt;
&lt;li&gt;博客文章使用 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://creativecommons.org/licenses/by-sa/4.0/&#34;
&gt;CC BY-SA 4.0&lt;/a&gt; 协议。&lt;/li&gt;
&lt;li&gt;数学公式由 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://www.mathjax.org/&#34;
&gt;MathJax&lt;/a&gt; 支持。&lt;/li&gt;
&lt;li&gt;学习时可能搬一些 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org&#34;
&gt;OI-Wiki&lt;/a&gt; 的内容，会注明。&lt;/li&gt;
&lt;/ol&gt;
            </content>   
                                <category scheme="https://weilycoder.github.io/tags/About" term="About" label="About" />
        </entry>
        <entry>
            <title>Floyd 算法</title>
            <link href="https://weilycoder.github.io/post/floyd/" rel="alternate" type="text/html"  hreflang="en" />
            <id>https://weilycoder.github.io/post/floyd/</id>
                    <author>
                        <name>weily</name>
                    </author>
            <published>2024-11-05T20:40:07+08:00</published>
            <updated>2024-11-05T20:40:07+08:00</updated>
            <content type="html">
                &lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;floyd-算法&#34;
    &gt;
        Floyd 算法
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/floyd/#floyd-算法&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor Floyd 算法&#34; href=&#34;#floyd-%e7%ae%97%e6%b3%95&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;用于求图中任意两点最短路算法。&lt;/p&gt;
&lt;p&gt;Floyd 算法本质是 dp。设 $i\to j$ 最短路为 $f_{i,j}$，初始置 $f_{i,j}$ 为 $i\to j$ 的边权；若 $i\to j$ 没有直接连边，置 $f_{i,j}$ 为 $+\infty$。&lt;/p&gt;
&lt;p&gt;枚举 $k$，检查 $i\to k\to j$ 是否比原有的路径长度短，即令&lt;/p&gt;
&lt;p&gt;$$
f_{i,j}\gets \min(f_{i,j},f_{i,k}+f_{k,j})
$$&lt;/p&gt;
&lt;p&gt;当 $k$ 遍历过所有点，全局最短路就确定了。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;4
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;k&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;k&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;      &lt;span class=&#34;n&#34;&gt;f&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;min&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;f&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;f&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;f&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]);&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;注意 Floyd 算法的枚举顺序是 $(k,i,j)$，更改枚举顺序会导致算法出错。&lt;/p&gt;
&lt;p&gt;值得一提，在&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://arxiv.org/pdf/1904.01210&#34;
&gt;这篇论文&lt;/a&gt;证明，对于 $(i,k,j)$ 的枚举顺序，算法最多跑 $2$ 遍即可得到正确结果；对于 $(i,j,k)$ 的枚举顺序，算法最多跑 $3$ 遍即可得到正确结果。&lt;/p&gt;
&lt;p&gt;不过，对单个变量的枚举顺序显然没有要求，正序倒序乱序显然都可以。&lt;/p&gt;
&lt;p&gt;特别地，假设枚举变量 $k$ 已经遍历且仅遍历了 $S$ 中的点，当前答案的意义就是：只经过 $S$ 中的点作为“中继”，任意两点的最短路。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;bitset-优化传递闭包&#34;
    &gt;
        bitset 优化传递闭包
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/floyd/#bitset-优化传递闭包&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor bitset 优化传递闭包&#34; href=&#34;#bitset-%e4%bc%98%e5%8c%96%e4%bc%a0%e9%80%92%e9%97%ad%e5%8c%85&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;计算任意两点是否可达。&lt;/p&gt;
&lt;p&gt;我们对 dp 数组的含义重新定义，初始若 $i\to j$ 有边，置 $f_{i,j}$ 为 $1$，否者置为 $0$，特别地，$i=j$ 时应置为 $1$。&lt;/p&gt;
&lt;p&gt;转移方程为：&lt;/p&gt;
&lt;p&gt;$$
f_{i,j}\gets f_{i,j}\cup(f_{i,k}\cap f_{k,j})
$$&lt;/p&gt;
&lt;p&gt;这里 $\cup$ 表示按位或；$\cap$ 表示按位与。&lt;/p&gt;
&lt;p&gt;考虑用 &lt;code&gt;bitset&lt;/code&gt; 优化。&lt;/p&gt;
&lt;p&gt;我们用 &lt;code&gt;bitset&lt;/code&gt; 数组作为 dp 数组，$f_i$ 是一个长 $N$ 的 &lt;code&gt;bitset&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;转移方程显然可以看成：&lt;/p&gt;
&lt;p&gt;$$
f_{i,j}=
\begin{cases}
f_{i,j}\cup f_{k,j},&amp;amp;\text{if }f_{i,k}=\text{true} \\
f_{i,j},&amp;amp;\text{otherwise}
\end{cases}
$$&lt;/p&gt;
&lt;p&gt;注意到若 $f_{i,k}$ 为真，则需遍历所有 $j$ 对 $f_{i,j}$ 和 $f_{k,j}$ 取或。&lt;/p&gt;
&lt;p&gt;这个过程可以用 &lt;code&gt;bitset&lt;/code&gt; 优化。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;3
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;k&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;k&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;f&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;f&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;|=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;f&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;由于 &lt;code&gt;bitset&lt;/code&gt; 实现上会压位，时间复杂度是 $O\left(\dfrac{N^3}{w}\right)$，$w$ 是计算机的位数，一般是 $32$ 或 $64$。&lt;/p&gt;
&lt;p&gt;开 O2 优化后，编译器可能会进行循环展开，这会使常数变为原来的 $\dfrac18\sim \dfrac14$。因此，Floyd 传递闭包的复杂度尽管是 $O(n^3)$，但常常可以跑过 $3000$ 左右的数据。&lt;/p&gt;

            </content>  
                                <category scheme="https://weilycoder.github.io/authors/weily" term="weily" label="weily" />  
                                <category scheme="https://weilycoder.github.io/tags/graph" term="graph" label="graph" />
        </entry>
        <entry>
            <title>拉格朗日插值</title>
            <link href="https://weilycoder.github.io/post/lag-interp/" rel="alternate" type="text/html"  hreflang="en" />
            <id>https://weilycoder.github.io/post/lag-interp/</id>
            <published>2024-11-05T11:21:12+08:00</published>
            <updated>2024-11-05T11:21:12+08:00</updated>
            <content type="html">
                &lt;blockquote&gt;
&lt;p&gt;内容基本来自 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org&#34;
&gt;OI-Wiki&lt;/a&gt;。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;插值是通过已知的、离散的数据点，推算未知的新数据点的方法。&lt;/p&gt;
&lt;p&gt;最普通地，可以将原数据点用线段连接，构成分段函数，叫做线性插值；C++ 20 开始，标准库实现了 &lt;a
  class=&#34;gblog-markdown__link--code&#34;
  href=&#34;https://zh.cppreference.com/w/cpp/numeric/lerp&#34;
&gt;&lt;code&gt;std::lerp&lt;/code&gt;&lt;/a&gt; 函数，用于线性插值。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;拉格朗日插值法&#34;
    &gt;
        拉格朗日插值法
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/lag-interp/#拉格朗日插值法&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 拉格朗日插值法&#34; href=&#34;#%e6%8b%89%e6%a0%bc%e6%9c%97%e6%97%a5%e6%8f%92%e5%80%bc%e6%b3%95&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;但是，我们通常对精度有更高的要求；一般的，已知 $n+1$ 个点 $(x_0,y_0),(x_1,y_1),\cdots,(x_n,y_n)$ &lt;strong&gt;通常&lt;/strong&gt;可以求出 $n$ 次多项式 $f(x)$ 满足 $f(x_i)=y_i,\forall i=0,1,\cdots,n$。&lt;/p&gt;
&lt;p&gt;最暴力地，我们可以使用高斯消元 $O(n^3)$ 计算 $f(x)$，单次插值可以 $O(n)$。&lt;/p&gt;
&lt;p&gt;朴素的拉格朗日插值无需计算具体的函数 $f(x)$，单次插值 $O(n^2)$，通过多项式技巧可以做到 $O(n\log^2 n)$。&lt;/p&gt;
&lt;p&gt;具体地，记原数据点为 $P_1(x_1,y_1),P_2(x_2,y_2),\cdots,P_n(x_n,y_n)$，它们在 $x$ 轴上的投影为 $P&amp;rsquo;_1(x_1,0),P&amp;rsquo;_2(x_2,0),\cdots,P&amp;rsquo;_n(x_n,0)$。&lt;/p&gt;
&lt;p&gt;考虑构造 $n$ 个函数，第 $i$ 个函数 $f_i(x)$ 过 $\begin{cases}P_j ,&amp;amp; j=i \\ P&amp;rsquo;_j ,&amp;amp; \text{otherwise}\end{cases}$。&lt;/p&gt;
&lt;p&gt;不妨令 $f_i(x)=a\cdot\prod_{j\ne i}(x-x_j)$，将 $P_i$ 代入，得 $a=\dfrac{y_i}{\prod_{j\ne i}(x_i-x_j)}$，于是&lt;/p&gt;
&lt;p&gt;$$
f_i(x)=y_i\cdot\dfrac{\prod_{j\ne i}(x-x_j)}{\prod_{j\ne i}(x_i-x_j)}=y_i\cdot\prod_{j\ne i}\dfrac{x-x_j}{x_i-x_j}
$$&lt;/p&gt;
&lt;p&gt;因此所求函数 $f(x)$ 即为：&lt;/p&gt;
&lt;p&gt;$$
f(x)=\sum_{i=1}^{n}y_i\cdot\prod_{j\ne i}\dfrac{x-x_j}{x_i-x_j}
$$&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;横坐标为连续整数的插值&#34;
    &gt;
        横坐标为连续整数的插值
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/lag-interp/#横坐标为连续整数的插值&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 横坐标为连续整数的插值&#34; href=&#34;#%e6%a8%aa%e5%9d%90%e6%a0%87%e4%b8%ba%e8%bf%9e%e7%bb%ad%e6%95%b4%e6%95%b0%e7%9a%84%e6%8f%92%e5%80%bc&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;例如，已知 $1\sim n+1$ 的点值，有：&lt;/p&gt;
&lt;p&gt;$$
f(x)=\sum\limits_{i=1}^{n+1}(-1)^{n+1-i}y_i\cdot\frac{\prod\limits_{j=1}^{n+1}(x-j)}{(i-1)!(n+1-i)!(x-i)}
$$&lt;/p&gt;
&lt;p&gt;预处理后线性。&lt;/p&gt;
            </content>   
                                <category scheme="https://weilycoder.github.io/tags/math" term="math" label="math" />
        </entry>
        <entry>
            <title>辛普森法求数值积分</title>
            <link href="https://weilycoder.github.io/post/simpson/" rel="alternate" type="text/html"  hreflang="en" />
            <id>https://weilycoder.github.io/post/simpson/</id>
            <published>2024-08-10T11:35:20+08:00</published>
            <updated>2024-08-10T11:35:20+08:00</updated>
            <content type="html">
                &lt;blockquote&gt;
&lt;p&gt;部分内容来自 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org&#34;
&gt;OI-Wiki&lt;/a&gt;。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;辛普森公式&#34;
    &gt;
        辛普森公式
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/simpson/#辛普森公式&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 辛普森公式&#34; href=&#34;#%e8%be%9b%e6%99%ae%e6%a3%ae%e5%85%ac%e5%bc%8f&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;首先，我们引入二次函数积分公式。&lt;/p&gt;
&lt;p&gt;对于二次函数&lt;/p&gt;
&lt;p&gt;$$
f(x)=ax^2+bx+c,
$$&lt;/p&gt;
&lt;p&gt;有&lt;/p&gt;
&lt;p&gt;$$
\int_{L}^{R} f(x)\text{d}x=\dfrac{R-L}{6}\left[f(L)+f(R)+4f\left(\dfrac{L+R}{2}\right)\right]
$$&lt;/p&gt;
&lt;p&gt;这里给出计算过程：&lt;/p&gt;
&lt;p&gt;先求出 $f(x)$ 的原函数：&lt;/p&gt;
&lt;p&gt;$$
F(x)=\int f(x)\text{d}x=\dfrac{a}{3}x^3+\dfrac{b}{2}x^2+cx+D
$$&lt;/p&gt;
&lt;p&gt;由牛顿-莱布尼茨公式，&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
\int_{L}^{R} f(x)\text{d}x
&amp;amp;=F(R)-F(L)\\
&amp;amp;=\dfrac{a}{3}(R^3-L^3)+\dfrac{b}{2}(R^2-L^2)+c(r-l)\\
&amp;amp;=(R-L)\left(\dfrac{a}{3}(L^2+LR+R^2)+\dfrac{b}{2}(L+R)+c\right)\\
&amp;amp;=\dfrac{R-L}{6}(2L^2+2LR+2R^2+3L+3R+6c)\\
&amp;amp;=\dfrac{R-L}{6}\left\{(aL^2+bL+c)+(aR^2+bR+c)+4\left[a\left(\dfrac{l+r}{2}\right)^2+b\left(\dfrac{l+r}{2}\right)+c\right]\right\}\\
&amp;amp;=\dfrac{R-L}{6}\left[f(L)+f(R)+4f\left(\dfrac{L+R}{2}\right)\right]
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;需要注意这里其实不要求 $a\ne 0$。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;自适应辛普森法&#34;
    &gt;
        自适应辛普森法
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/simpson/#自适应辛普森法&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 自适应辛普森法&#34; href=&#34;#%e8%87%aa%e9%80%82%e5%ba%94%e8%be%9b%e6%99%ae%e6%a3%ae%e6%b3%95&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;考虑使用二次函数拟合被积函数，将被积函数分成若干段，每段内使用辛普森公式求近似值。&lt;/p&gt;
&lt;p&gt;但是，如果我们不断细分，无疑会增大算量；如果细分的程度不够，又会影响精度。&lt;/p&gt;
&lt;p&gt;一般，我们先将函数分成几段，接下来对每段检查二次函数是否能良好拟合。&lt;/p&gt;
&lt;p&gt;具体地，对于函数的某一段 $[l,r]$，如果拟合 $[l,r]$ 的结果跟 $[l,\frac{l+r}{2}]$ 与 $[\frac{l+r}{2},r]$ 的和接近，那么认为拟合良好。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt; 1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 4
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 5
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 6
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 7
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 8
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 9
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;10
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;11
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;12
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;13
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;14
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;15
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;16
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;17
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kt&#34;&gt;double&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;simpson&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;double&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;l&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;double&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;r&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kt&#34;&gt;double&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;mid&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;l&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;r&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;/&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;r&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;l&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;f&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;l&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;f&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;mid&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;f&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;r&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;/&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kt&#34;&gt;double&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;asr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;double&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;l&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;double&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;r&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;double&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;eps&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;double&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;ans&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;step&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kt&#34;&gt;double&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;mid&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;l&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;r&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;/&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kt&#34;&gt;double&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;fl&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;simpson&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;l&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;mid&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;fr&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;simpson&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;mid&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;r&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;abs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;fl&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;fr&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;ans&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;15&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;eps&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;step&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;fl&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;fr&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;fl&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;fr&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;ans&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;/&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;15&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;asr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;l&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;mid&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;eps&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;/&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;fl&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;step&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;         &lt;span class=&#34;n&#34;&gt;asr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;mid&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;r&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;eps&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;/&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;fr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;step&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kt&#34;&gt;double&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;calc&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;double&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;l&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;double&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;r&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;double&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;eps&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;asr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;l&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;r&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;eps&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;simpson&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;l&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;r&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;12&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;其中 &lt;code&gt;15&lt;/code&gt; 是一个 Magic Number，在 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://doi.org/10.1145/321526.321537&#34;
&gt;https://doi.org/10.1145/321526.321537&lt;/a&gt; 给出了论述。&lt;/p&gt;
&lt;p&gt;需要指出，也存在一些病态函数，直接应用自适应辛普森法可能会出错。&lt;/p&gt;

            </content>   
                                <category scheme="https://weilycoder.github.io/tags/math" term="math" label="math" />
        </entry>
        <entry>
            <title>道高一尺 or 魔高一丈：浅谈交互库编写</title>
            <link href="https://weilycoder.github.io/post/interactive/" rel="alternate" type="text/html"  hreflang="en" />
            <id>https://weilycoder.github.io/post/interactive/</id>
                    <author>
                        <name>weily</name>
                    </author>
            <published>2024-08-04T14:22:57+08:00</published>
            <updated>2024-08-04T14:22:57+08:00</updated>
            <content type="html">
                &lt;p&gt;有些时候，为了实现特殊的需求，我们可能需要编写交互库，要求选手链接。&lt;/p&gt;
&lt;p&gt;常见的情景有：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;强制在线：一些题目不强制在线可能会被“乱搞”通过。例如可持久化数据结构有众所周知的离线做法。&lt;/li&gt;
&lt;li&gt;加速输入输出：一些题目为了要求严格线性可能需要 $10^8$ 以上的输入量，如此大的数据必须在内存生成并交换。&lt;/li&gt;
&lt;li&gt;限制操作：一些思维题不允许选手直接读取数据，而是要求选手做特定询问获取详细内容；或者可能限制操作次数。&lt;/li&gt;
&lt;li&gt;人机对抗：另一些思维题要求选手找到最优策略，那么可以要求选手通过接口与交互库对抗。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;既然交互库要链接选手的程序，就必须做好防范措施，避免选手使用不当操作 $\textcolor{green}{\text{AC}}$。&lt;/p&gt;
&lt;p&gt;本人才疏学浅，谈论的内容只是全局的一小部分，欢迎补充。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;hack-输出内容&#34;
    &gt;
        Hack 输出内容
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/interactive/#hack-输出内容&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor Hack 输出内容&#34; href=&#34;#hack-%e8%be%93%e5%87%ba%e5%86%85%e5%ae%b9&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;如果不要求选手进行输出，很多交互库可能只是简单输出 &lt;code&gt;Yes&lt;/code&gt; 或 &lt;code&gt;No&lt;/code&gt; 来告诉 Judger 结果是否正确。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;0x00&#34;
    &gt;
        0x00
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/interactive/#0x00&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 0x00&#34; href=&#34;#0x00&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;一个基本的素养是将除了 &lt;code&gt;main&lt;/code&gt; 函数和接口函数以外的函数或变量使用 &lt;code&gt;static&lt;/code&gt; 修饰，并且不使用 &lt;code&gt;#define&lt;/code&gt; 或 &lt;code&gt;using&lt;/code&gt;。防止出现奇怪问题或被选手猜中变量名。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;0x01&#34;
    &gt;
        0x01
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/interactive/#0x01&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 0x01&#34; href=&#34;#0x01&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;这里有一个显然的漏洞。众所周知，函数 &lt;code&gt;exit&lt;/code&gt; 可以让程序退出，不必返回主函数，选手自然可以输出 &lt;code&gt;Yes&lt;/code&gt; 后直接退出。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;4
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;5
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;solve&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(...)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;...&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;n&#34;&gt;cout&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;s&#34;&gt;&amp;#34;Yes&amp;#34;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;endl&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;n&#34;&gt;exit&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;0x02&#34;
    &gt;
        0x02
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/interactive/#0x02&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 0x02&#34; href=&#34;#0x02&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;最简单的方式是不告诉选手交互库评测时行为。&lt;/p&gt;
&lt;p&gt;不过，在部分题目中，这可能是无法避免的。&lt;/p&gt;
&lt;p&gt;一个简单的做法是利用析构函数，只要定义一个全局变量，程序退出时自然会进行析构。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;4
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;static&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;struct&lt;/span&gt; &lt;span class=&#34;nc&#34;&gt;E&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;code&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;o&#34;&gt;~&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;E&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;()&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;cout&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;code&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;endl&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;e&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;另一个高级的方法是使用 &lt;code&gt;atexit&lt;/code&gt; 注册函数，被注册的函数会在程序正常退出时被逆序调用。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;atexit&lt;/code&gt; 定义在 &lt;code&gt;&amp;lt;cstdlib&amp;gt;&lt;/code&gt;。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;4
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;5
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;6
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;7
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;8
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;...&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;static&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;code&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;main&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;()&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;...&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;auto&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;p&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[]{&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;cout&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;code&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;endl&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;n&#34;&gt;atexit&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;p&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;...&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;要注意的是以上两种方法只能在函数正常退出时输出；不过程序非正常退出时一定不会返回 &lt;code&gt;0&lt;/code&gt;，会出现 $\textcolor{purple}{\text{RE}}$。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;0x03&#34;
    &gt;
        0x03
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/interactive/#0x03&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 0x03&#34; href=&#34;#0x03&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;不过最近看到一个有趣的函数：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-cpp&#34; data-lang=&#34;cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;na&#34;&gt;[[noreturn]]&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;void&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;quick_exit&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;exit_code&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;noexcept&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这个函数也定义在 &lt;code&gt;&amp;lt;cstdlib&amp;gt;&lt;/code&gt;。顾名思义，这个函数可以使程序快速退出，不完全清理资源。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;4
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;5
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;6
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;7
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;cp&#34;&gt;#include&lt;/span&gt; &lt;span class=&#34;cpf&#34;&gt;&amp;lt;cstdlib&amp;gt;&lt;/span&gt;&lt;span class=&#34;cp&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;cp&#34;&gt;#include&lt;/span&gt; &lt;span class=&#34;cpf&#34;&gt;&amp;lt;iostream&amp;gt;&lt;/span&gt;&lt;span class=&#34;cp&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;cp&#34;&gt;&lt;/span&gt;&lt;span class=&#34;k&#34;&gt;using&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;namespace&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;std&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;static&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;struct&lt;/span&gt; &lt;span class=&#34;nc&#34;&gt;E&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;~&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;E&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;()&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;cout&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;s&#34;&gt;&amp;#34;clean&amp;#34;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;endl&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;e&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;main&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;()&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;quick_exit&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;尝试运行以上程序，你会发现不会输出任何东西。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;0x04&#34;
    &gt;
        0x04
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/interactive/#0x04&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 0x04&#34; href=&#34;#0x04&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;不过如果你知道 &lt;code&gt;quick_exit&lt;/code&gt;，一定会看到 &lt;code&gt;at_quick_exit&lt;/code&gt;，后者也定义在 &lt;code&gt;&amp;lt;cstdlib&amp;gt;&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;at_quick_exit&lt;/code&gt; 可以注册快速退出时执行的函数，不会在正常退出时调用。&lt;/p&gt;
&lt;p&gt;这段程序可能更加保险。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt; 1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 4
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 5
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 6
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 7
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 8
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 9
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;10
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;...&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;static&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;code&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;main&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;()&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;...&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;auto&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;p&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[]{&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;cout&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;code&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;endl&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;auto&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;q&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[]{&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;cout&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;s&#34;&gt;&amp;#34;at_quick_exit&amp;#34;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;endl&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;n&#34;&gt;atexit&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;p&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;n&#34;&gt;at_quick_exit&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;q&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;...&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;注意快速退出时不一定刷新缓冲区，需要手动刷新。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;0x06&#34;
    &gt;
        0x06
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/interactive/#0x06&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 0x06&#34; href=&#34;#0x06&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;我的朋友提醒了我 &lt;code&gt;close&lt;/code&gt; 函数的使用，一般地，我们可以使用 &lt;code&gt;close&lt;/code&gt; 函数干掉文件描述符 &lt;code&gt;1&lt;/code&gt;，使得交互库无法正常输出。更进一步，我们可以使用 &lt;code&gt;dup2&lt;/code&gt; 将 &lt;code&gt;dev/nul&lt;/code&gt; 绑定到描述符 &lt;code&gt;1&lt;/code&gt;。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;0xff&#34;
    &gt;
        0xff
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/interactive/#0xff&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 0xff&#34; href=&#34;#0xff&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;至此，在输出上直接做手脚可能比较困难，但选手程序和交互库毕竟被编译到同一程序，高手可以选择直接操作内存。&lt;/p&gt;
&lt;p&gt;参见 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://mcfxmcfx.blog.uoj.ac/blog/6519&#34;
&gt;部分交互题的通用 hack 方法&lt;/a&gt;，By &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://uoj.ac/user/profile/mcfxmcfx&#34;
&gt;mcfxmcfx&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;有灵感在记录罢。&lt;/p&gt;
            </content>  
                                <category scheme="https://weilycoder.github.io/authors/weily" term="weily" label="weily" />  
                                <category scheme="https://weilycoder.github.io/tags/misc" term="misc" label="misc" />
        </entry>
        <entry>
            <title>乘法逆元</title>
            <link href="https://weilycoder.github.io/post/inv/" rel="alternate" type="text/html"  hreflang="en" />
            <id>https://weilycoder.github.io/post/inv/</id>
            <published>2024-07-18T22:09:36+08:00</published>
            <updated>2024-07-18T22:09:36+08:00</updated>
            <content type="html">
                &lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;定义&#34;
    &gt;
        定义
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/inv/#定义&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 定义&#34; href=&#34;#%e5%ae%9a%e4%b9%89&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;若 $ax\equiv 1\pmod{p}$，则称 $x$ 是模 $p$ 意义下 $a$ 的乘法逆元，记作 $a^{-1}$。&lt;/p&gt;
&lt;p&gt;显然，它相当于模意义下 $a$ 的倒数。不那么严谨地说，模意义下除以 $a$ 就是乘 $a^{-1}$。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;在线单点求值&#34;
    &gt;
        在线单点求值
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/inv/#在线单点求值&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 在线单点求值&#34; href=&#34;#%e5%9c%a8%e7%ba%bf%e5%8d%95%e7%82%b9%e6%b1%82%e5%80%bc&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;扩展欧几里得法&#34;
    &gt;
        扩展欧几里得法
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/inv/#扩展欧几里得法&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 扩展欧几里得法&#34; href=&#34;#%e6%89%a9%e5%b1%95%e6%ac%a7%e5%87%a0%e9%87%8c%e5%be%97%e6%b3%95&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;由于求逆元相当于求 $ax+py=1$ 的一组整数解，所以可以使用扩展欧几里得法。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;4
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;5
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;6
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;7
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;8
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kt&#34;&gt;void&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;exgcd&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;a&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;b&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;&amp;amp;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;&amp;amp;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;y&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;b&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;y&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;n&#34;&gt;exgcd&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;b&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;a&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;b&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;y&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;n&#34;&gt;y&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;a&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;/&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;b&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;复杂度为 $O(\log a)$。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;快速幂法&#34;
    &gt;
        快速幂法
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/inv/#快速幂法&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 快速幂法&#34; href=&#34;#%e5%bf%ab%e9%80%9f%e5%b9%82%e6%b3%95&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;由费马小定理（$p$ 为质数）：&lt;/p&gt;
&lt;p&gt;$$
a^{p}\equiv a\pmod{p}
$$&lt;/p&gt;
&lt;p&gt;因此 $(a,p)=1$ 时，&lt;/p&gt;
&lt;p&gt;$$
a^{-1}\equiv a^{p-2}\pmod{p}
$$&lt;/p&gt;
&lt;p&gt;复杂度为 $\Theta(\log p)$。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;离线多点求值&#34;
    &gt;
        离线多点求值
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/inv/#离线多点求值&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 离线多点求值&#34; href=&#34;#%e7%a6%bb%e7%ba%bf%e5%a4%9a%e7%82%b9%e6%b1%82%e5%80%bc&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;1sim-n-的逆元&#34;
    &gt;
        $1\sim n$ 的逆元
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/inv/#1sim-n-的逆元&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor $1\sim n$ 的逆元&#34; href=&#34;#1sim-n-%e7%9a%84%e9%80%86%e5%85%83&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;首先，$1^{-1}\equiv 1\pmod p$；&lt;/p&gt;
&lt;p&gt;其次，考虑 $i^{-1}$，令 $k=\left\lfloor\dfrac{p}{i}\right\rfloor,j=p\bmod i$，有 $p=ki+j$，则模意义下有 $ki+j\equiv 0\pmod p$；两边同时乘 $i^{-1}j^{-1}$：&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
kj^{-1}+i^{-1}&amp;amp;\equiv 0&amp;amp;\pmod p\\
i^{-1}&amp;amp;\equiv -kj^{-1}&amp;amp;\pmod p\\
i^{-1}&amp;amp;\equiv -\left\lfloor\dfrac{p}{i}\right\rfloor(p\bmod i)^{-1}&amp;amp;\pmod p\\
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;递推即可，时间复杂度 $\Theta(n)$。&lt;/p&gt;
&lt;p&gt;注意到 $0^{-1}$ 未定义，因此对任意 $i\mid p$，$i^{-1}$ 同样未定义。&lt;/p&gt;
&lt;p&gt;注意到这种方法同样可以单点求逆元，现在已经证明其复杂度为 $O(\sqrt[3]{n\ln n})$，且 $\Omega(\dfrac{\ln n}{\ln\ln n})$，同时观察到可能是 $O(\log n)$ 的。&lt;/p&gt;
&lt;p&gt;&lt;img
  src=&#34;https://cdn.jsdelivr.net/gh/weilycoder/image_hosting@master/pmodn-5723a1e5b899a5d7.svg&#34;
  alt=&#34;&#34;
  
/&gt;&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;任意-n-个数的逆元&#34;
    &gt;
        任意 $n$ 个数的逆元
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/inv/#任意-n-个数的逆元&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 任意 $n$ 个数的逆元&#34; href=&#34;#%e4%bb%bb%e6%84%8f-n-%e4%b8%aa%e6%95%b0%e7%9a%84%e9%80%86%e5%85%83&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;给定序列 $a$，线性求序列中每个数的逆元。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;首先，求出 $a$ 的前缀积 $s$；&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;然后，使用快速幂或扩展欧几里得法求 $s_n$ 的逆元 $v_n$；&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;由 $v_{i}=v_{i+1}\cdot a_{i+1}$，可以递推出整个序列 $v$；&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;$a_{i}=s_{i}\cdot v_{i-1}$。&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;时间复杂度 $\Theta(n+\log p)$。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;预处理后快速求解&#34;
    &gt;
        预处理后快速求解
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/inv/#预处理后快速求解&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 预处理后快速求解&#34; href=&#34;#%e9%a2%84%e5%a4%84%e7%90%86%e5%90%8e%e5%bf%ab%e9%80%9f%e6%b1%82%e8%a7%a3&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;存在一种 $\Theta(p^{2/3})$ 预处理，在线 $\Theta(1)$ 查询的算法。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;farey-序列&#34;
    &gt;
        Farey 序列
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/inv/#farey-序列&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor Farey 序列&#34; href=&#34;#farey-%e5%ba%8f%e5%88%97&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;第 $i$ 个 Farey 序列记作 $F_i$，是把分母小于等于 $i$ 的所有最简真分数从小到大排成的序列；特别地，序列的首项是 $\dfrac{0}{1}$，末项为 $\dfrac{1}{1}$。&lt;/p&gt;
&lt;p&gt;$$
\begin{array}{lllllllllllll}
F_1=\bigg\{&amp;amp;\dfrac{0}{1},&amp;amp;&amp;amp;&amp;amp;&amp;amp;&amp;amp;&amp;amp;&amp;amp;&amp;amp;&amp;amp;&amp;amp;\dfrac{1}{1}&amp;amp;\bigg\}\\
F_2=\bigg\{&amp;amp;\dfrac{0}{1},&amp;amp;&amp;amp;&amp;amp;&amp;amp;&amp;amp;\dfrac{1}{2},&amp;amp;&amp;amp;&amp;amp;&amp;amp;&amp;amp;\dfrac{1}{1}&amp;amp;\bigg\}\\
F_3=\bigg\{&amp;amp;\dfrac{0}{1},&amp;amp;&amp;amp;&amp;amp;\dfrac{1}{3},&amp;amp;&amp;amp;\dfrac{1}{2},&amp;amp;&amp;amp;\dfrac{2}{3},&amp;amp;&amp;amp;&amp;amp;\dfrac{1}{1}&amp;amp;\bigg\}\\
F_4=\bigg\{&amp;amp;\dfrac{0}{1},&amp;amp;&amp;amp;\dfrac{1}{4},&amp;amp;\dfrac{1}{3},&amp;amp;&amp;amp;\dfrac{1}{2},&amp;amp;&amp;amp;\dfrac{2}{3},&amp;amp;\dfrac{3}{4},&amp;amp;&amp;amp;\dfrac{1}{1}&amp;amp;\bigg\}\\
F_5=\bigg\{&amp;amp;\dfrac{0}{1},&amp;amp;\dfrac{1}{5},&amp;amp;\dfrac{1}{4},&amp;amp;\dfrac{1}{3},&amp;amp;\dfrac{2}{5},&amp;amp;\dfrac{1}{2},&amp;amp;\dfrac{3}{5},&amp;amp;\dfrac{2}{3},&amp;amp;\dfrac{3}{4},&amp;amp;\dfrac{4}{5},&amp;amp;\dfrac{1}{1}&amp;amp;\bigg\}
\end{array}
$$&lt;/p&gt;
&lt;!-- &lt;div class=&#34;center-flex&#34;&gt;
  &lt;img src=&#34;https://cdn.jsdelivr.net/gh/weilycoder/image_hosting@master/202408022026646-72ea53848d5932dc.png&#34; style=&#34;margin:auto;&#34;/&gt;
&lt;/div&gt; --&gt;
&lt;p&gt;注意到 Farey 序列可以迭代生成，每次只需选择 $F_{n-1}$ 中每对相邻的 $\dfrac{a}{b},\dfrac{c}{d}$，满足 $b+d=n$，将 $\dfrac{a+c}{b+d}$ 放在中间即可。&lt;/p&gt;
&lt;p&gt;同时，Farey 序列有性质：$bc-ad=1$。&lt;/p&gt;
&lt;p&gt;我看到很多博客提到一个定理：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;对于任意整数 $n\le 2$ 和任意实数 $v\in [0,1]$，总能在 $F_{n−1}$ 找到 $\dfrac{x}{y}$ 满足 $\left|v−\dfrac{x}{y}\right|≤\dfrac{1}{yn}$ 。更强地，这个 $\dfrac{x}{y}$ 一定是 $v$ 序列中最接近 $v$ 的第一个分数。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;实际上，如果引入渐进分数，有另一个不等式：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;对实数 $x$ 与渐进分数 $\dfrac{p_k}{q_k}$ ，有
$$
\dfrac{1}{q_k(q_k+q_{k+1})}&amp;lt;\left|x-\frac{p_k}{q_k}\right|&amp;lt;\dfrac{1}{q_kq_{k+1}}
$$&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;这个不等式更紧一些，因为 $q_{k+1}$ 不会比 $n$ 更小。&lt;/p&gt;
&lt;p&gt;我们固定 $n$，对于 $a$ 令 $v=\dfrac{a}{p}$ 并找到 $\dfrac{x}{y}$ 满足 $\left|\dfrac{a}{p}-\dfrac{x}{y}\right|\le\dfrac{1}{yn}$。即 $|ay-px|\le\left\lfloor\dfrac{p}{n}\right\rfloor$。也就是说 $ay\equiv u\pmod p$，其中 $|u|\le \left\lfloor\dfrac{p}{n}\right\rfloor$。注意到 $a^{-1}=u^{-1}y\pmod p$，我们只需预处理 $O\left(\left\lfloor\dfrac{p}{n}\right\rfloor\right)$ 个数的逆元。&lt;/p&gt;
&lt;p&gt;注意到序列中 $\left\lfloor\dfrac{xn^2}{y}\right\rfloor$ 互不相同，我们开一个长 $n^2$ 的 $0/1$ 数组记录是否有 $\left\lfloor\dfrac{xn^2}{y}\right\rfloor$ 等于 $i$。将序列求前缀和即可 $O(1)$ 查大于或小于 $\dfrac{x}{y}$ 的的第一个数。&lt;/p&gt;

            </content>   
                                <category scheme="https://weilycoder.github.io/tags/math" term="math" label="math" />
        </entry>
        <entry>
            <title>珂朵莉树</title>
            <link href="https://weilycoder.github.io/post/odt/" rel="alternate" type="text/html"  hreflang="en" />
            <id>https://weilycoder.github.io/post/odt/</id>
            <published>2024-06-24T15:45:44+08:00</published>
            <updated>2024-06-24T15:45:44+08:00</updated>
            <content type="html">
                &lt;p&gt;珂朵莉树（Chtholly Tree），又名老司机树 ODT（Old Driver Tree）。起源自 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://codeforces.com/problemset/problem/896/C&#34;
&gt;CF896C&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;实际上，这种想法的本质是基于数据随机的「颜色段均摊」，而不是一种数据结构。&lt;/p&gt;
&lt;p&gt;使用 &lt;code&gt;set&lt;/code&gt; 实现的珂朵莉树的 &lt;code&gt;assign&lt;/code&gt;、&lt;code&gt;add&lt;/code&gt;、&lt;code&gt;sum&lt;/code&gt; 操作复杂度为 $O(n\log\log n)$.&lt;/p&gt;
&lt;p&gt;ODT 的核心思想是将值相同的区间合并为一个结点维护，只要有区间赋值的题目都可以用 ODT 骗分。&lt;/p&gt;
&lt;p&gt;ODT 在随机数据上表现良好，但是不保证数据随机时，会被构造数据卡到 T 飞。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;内容基本来自 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org&#34;
&gt;OI-Wiki&lt;/a&gt;。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;具体操作&#34;
    &gt;
        具体操作
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/odt/#具体操作&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 具体操作&#34; href=&#34;#%e5%85%b7%e4%bd%93%e6%93%8d%e4%bd%9c&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;节点声明&#34;
    &gt;
        节点声明
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/odt/#节点声明&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 节点声明&#34; href=&#34;#%e8%8a%82%e7%82%b9%e5%a3%b0%e6%98%8e&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;4
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;5
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;6
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;7
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;struct&lt;/span&gt; &lt;span class=&#34;nc&#34;&gt;Note_t&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;l&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;r&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;mutable&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;v&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;n&#34;&gt;Node_t&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;k&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;il&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;ir&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;iv&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;l&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;il&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;r&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;ir&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;v&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;iv&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kt&#34;&gt;bool&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;operator&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;k&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;Node_t&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;o&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;l&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;o&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;l&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;其中，&lt;code&gt;v&lt;/code&gt; 是附加数据。&lt;/p&gt;



&lt;blockquote class=&#34;gblog-hint note&#34;&gt;
  &lt;div class=&#34;gblog-hint__title flex align-center&#34;&gt;&lt;svg class=&#34;gblog-icon gblog_info_outline&#34;&gt;&lt;use xlink:href=&#34;#gblog_info_outline&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
      &lt;span&gt;Note&lt;/span&gt;&lt;/div&gt;
  &lt;div class=&#34;gblog-hint__text&#34;&gt;&lt;p&gt;&lt;code&gt;mutable&lt;/code&gt; 用于突破 &lt;code&gt;const&lt;/code&gt; 的限制，即使 &lt;code&gt;Note_t&lt;/code&gt; 被设为常量，仍能改变 &lt;code&gt;v&lt;/code&gt; 的值。&lt;/p&gt;
&lt;p&gt;这意味着，我们可以直接修改已经插入 &lt;code&gt;set&lt;/code&gt; 的元素的 &lt;code&gt;v&lt;/code&gt; 值，而不用将该元素取出后重新加入 &lt;code&gt;set&lt;/code&gt;。&lt;/p&gt;
&lt;/div&gt;
&lt;/blockquote&gt;

&lt;p&gt;接下来，我们定义一个 &lt;code&gt;set&lt;/code&gt; 存储节点。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;2
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;set&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;Node_t&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;odt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;typedef&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;set&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;Node_t&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;&amp;gt;::&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;iterator&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;iter&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;&lt;code&gt;iter&lt;/code&gt; 用于简化代码，如果题目支持 C++11，也可以使用 &lt;code&gt;auto&lt;/code&gt;。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;split&#34;
    &gt;
        split
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/odt/#split&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor split&#34; href=&#34;#split&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;&lt;code&gt;split&lt;/code&gt; 是核心操作之一，用于将包含 $x$ 的区间 $[l,r]$ 分裂为 $[l,x)$ 和 $[x,r]$，并返回后者的迭代器。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;4
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;5
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;6
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;7
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;8
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;9
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;iter&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;split&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;odt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;end&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;();&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;auto&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;it&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;--&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;odt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;upper_bound&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;Node_t&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;));&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;it&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&amp;gt;&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;l&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;it&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;l&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;it&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&amp;gt;&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;l&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;r&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;it&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&amp;gt;&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;r&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;v&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;it&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&amp;gt;&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;v&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;n&#34;&gt;odt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;erase&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;it&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;n&#34;&gt;odt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;insert&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;Node_t&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;l&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;v&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;});&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;odt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;insert&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;Node_t&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;r&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;v&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;).&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;first&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;assign&#34;
    &gt;
        assign
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/odt/#assign&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor assign&#34; href=&#34;#assign&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;&lt;code&gt;assign&lt;/code&gt; 是另一个核心操作，用于对区间赋值，可以降低节点数量，保证了 ODT 的时间复杂度。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;4
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;5
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kt&#34;&gt;void&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;assign&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;l&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;r&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;v&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;auto&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;itr&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;split&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;r&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;itl&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;split&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;l&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;n&#34;&gt;odt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;erase&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;itl&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;itr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;n&#34;&gt;odt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;insert&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;Node_t&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;l&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;r&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;v&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;));&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;



&lt;blockquote class=&#34;gblog-hint important&#34;&gt;
  &lt;div class=&#34;gblog-hint__title flex align-center&#34;&gt;&lt;svg class=&#34;gblog-icon gblog_error_outline&#34;&gt;&lt;use xlink:href=&#34;#gblog_error_outline&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
      &lt;span&gt;Important&lt;/span&gt;&lt;/div&gt;
  &lt;div class=&#34;gblog-hint__text&#34;&gt;&lt;p&gt;ODT 必须先 &lt;code&gt;split&lt;/code&gt; 右端点，再 &lt;code&gt;split&lt;/code&gt; 左端点，这和迭代器的失效有关。&lt;/p&gt;
&lt;p&gt;不这样做，代码会随机 $\textcolor{purple}{\text{RE}}$。&lt;/p&gt;
&lt;/div&gt;
&lt;/blockquote&gt;

&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;other&#34;
    &gt;
        other
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/odt/#other&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor other&#34; href=&#34;#other&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;参考代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;4
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;5
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;6
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kt&#34;&gt;void&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;assign&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;l&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;r&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;v&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;auto&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;itr&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;split&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;r&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;itl&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;split&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;l&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;itl&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;itr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;itl&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// Perform Operations here
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
            </content>   
                                <category scheme="https://weilycoder.github.io/tags/ds" term="ds" label="ds" />
        </entry>
        <entry>
            <title>小清新线段树</title>
            <link href="https://weilycoder.github.io/post/fresh_seg/" rel="alternate" type="text/html"  hreflang="en" />
            <id>https://weilycoder.github.io/post/fresh_seg/</id>
                    <author>
                        <name>weily</name>
                    </author>
            <published>2024-06-23T17:22:36+08:00</published>
            <updated>2024-06-23T17:22:36+08:00</updated>
            <content type="html">
                &lt;p&gt;通常来说，在使用线段树维护区间操作时，需要使操作在区间上能被快速计算，经典的区间加-区间求和是一个简单的例子。&lt;/p&gt;
&lt;p&gt;但是，这里也有一个看似难以维护的反例：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://vjudge.net/problem/bzoj-3211&#34;
&gt;&lt;strong&gt;bzoj 3211 花神游历各国&lt;/strong&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;维护一个序列 $A$，初始值为 $A=(a_1,a_2,a_3,\cdots,a_n)$，支持以下操作 $q$ 次：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;区间求和&lt;/li&gt;
&lt;li&gt;对区间每个数求平方根（向下取整）&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;$1\le n,q\le 1\times 10^5,0\le a_i\le 10^{12}.$&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;维护这种数据的线段树被称为小清新线段树。&lt;/p&gt;
&lt;p&gt;小清新线段树的概念由 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;http://jiruyi910387714.is-programmer.com/&#34;
&gt;$\textcolor{red}{\text{jiry_2}}$&lt;/a&gt; 提出，命名与 $\text{ZKW}$（重口味）线段树&lt;sup id=&#34;fnref:1&#34;&gt;&lt;a href=&#34;#fn:1&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;1&lt;/a&gt;&lt;/sup&gt; 相对。是一类结合势能分析以及懒标记应用的非传统线段树。&lt;/p&gt;
&lt;p&gt;区间求平方根显然很难在非叶节点上维护，我们考虑暴力。&lt;/p&gt;
&lt;p&gt;即，对于整个区间求平方根的操作，我们暴力地向它的两个子节点下传操作。&lt;/p&gt;
&lt;p&gt;这样做的时间复杂度有保证吗？有！&lt;/p&gt;
&lt;p&gt;由于只有开根操作，最终的结果非 $1$ 即 $0$；当区间内均为 $1$ 或 $0$ 时，我们无需对这个块再做处理。对于 $N&amp;gt;1$，所需的操作次数是 $O(\log\log n)$ 级别的。&lt;/p&gt;
&lt;p&gt;我们定义势能函数 $f(A)=\sum_{a\in A}c(a)$，其中 $c(a)$ 表示将 $a$ 降为 $0$ 或 $1$ 的次数。&lt;/p&gt;
&lt;p&gt;最劣情况下，结束时的势能 $f(A_e)=0$，而最开始要花费代价将势能升至 $f(A_s)=O(n\log\log \max a_i)$，因此维护区间平方根的总复杂度为 $O(n\log\log\max a_i)$.&lt;/p&gt;
&lt;p&gt;维护区间和的复杂度为 $O(q\log n)$.&lt;/p&gt;
&lt;p&gt;因此总的复杂度为 $O(q\log n+n\log\log\max a_i)$.&lt;/p&gt;
&lt;p&gt;这种思路也可以处理区间取欧拉函数、区间取模、区间整除、区间对一个数取 $\min$ 等抽象操作，具体实现和复杂度需要具体分析。&lt;/p&gt;
&lt;div class=&#34;footnotes&#34; role=&#34;doc-endnotes&#34;&gt;
&lt;hr&gt;
&lt;ol&gt;
&lt;li id=&#34;fn:1&#34;&gt;
&lt;p&gt;由清华大学张昆玮提出的一种非递归线段树，常数接近树状数组，码量相对较小，不过对懒标记有性质要求。&amp;#160;&lt;a href=&#34;#fnref:1&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/div&gt;
            </content>  
                                <category scheme="https://weilycoder.github.io/authors/weily" term="weily" label="weily" />  
                                <category scheme="https://weilycoder.github.io/tags/ds" term="ds" label="ds" />
        </entry>
        <entry>
            <title>生成函数</title>
            <link href="https://weilycoder.github.io/post/ogf/" rel="alternate" type="text/html"  hreflang="en" />
            <id>https://weilycoder.github.io/post/ogf/</id>
            <published>2024-06-23T13:30:48+08:00</published>
            <updated>2024-06-23T13:30:48+08:00</updated>
            <content type="html">
                &lt;p&gt;Useless Algorithms 之一。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;内容基本来自 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org&#34;
&gt;OI-Wiki&lt;/a&gt;。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;序列 $a$ 的普通生成函数定义为形式幂级数：&lt;/p&gt;
&lt;p&gt;$$
F(x)=\sum_{n}a_nx_n
$$&lt;/p&gt;
&lt;p&gt;$a$ 既可以是有穷序列，也可以是无穷序列。例如：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;序列 $a=\langle1,2,3\rangle$ 的生成函数是 $a+2x+3x^2$&lt;/li&gt;
&lt;li&gt;序列 $a=\langle1,1,1,\cdots\rangle$ 的生成函数是 $\sum_{n\ge 0}x^n=1+x+x^2+x^3+\cdots$&lt;/li&gt;
&lt;li&gt;序列 $a=\langle1,2,4,8,16,\cdots\rangle$ 的生成函数是 $\sum_{n\ge 0}2^nx^n$&lt;/li&gt;
&lt;li&gt;序列 $a=\langle1,3,5,7,9,\cdots\rangle$ 的生成函数是 $\sum_{n\ge 0}(2n+1)x^n$&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;简单来说，如果序列 $a$ 有通项公式，那么它的普通生成函数的系数就是通项公式。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;基本运算&#34;
    &gt;
        基本运算
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/ogf/#基本运算&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 基本运算&#34; href=&#34;#%e5%9f%ba%e6%9c%ac%e8%bf%90%e7%ae%97&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;设两个序列 $a,b$ 的生成函数分别是 $F(x),G(x)$。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;加减运算&#34;
    &gt;
        加减运算
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/ogf/#加减运算&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 加减运算&#34; href=&#34;#%e5%8a%a0%e5%87%8f%e8%bf%90%e7%ae%97&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;由&lt;/p&gt;
&lt;p&gt;$$
F(x)\pm G(x)=\sum_{n}(a_n\pm b_n)x^n
$$&lt;/p&gt;
&lt;p&gt;得到 $F(x)\pm G(x)$ 是序列 $\langle a_n\pm b_n\rangle$ 的生成函数&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;乘法运算卷积&#34;
    &gt;
        乘法运算（卷积）
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/ogf/#乘法运算卷积&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 乘法运算（卷积）&#34; href=&#34;#%e4%b9%98%e6%b3%95%e8%bf%90%e7%ae%97%e5%8d%b7%e7%a7%af&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;由&lt;/p&gt;
&lt;p&gt;$$
F(x)G(x)=\sum_{n}x^n\sum_{i=0}^{n}a_ib_{n-i}
$$&lt;/p&gt;
&lt;p&gt;我们知道 $F(x)G(x)$ 是 $\langle\sum_{i=0}^{n}a_ib_{n-i}\rangle$ 的生成函数。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;封闭形式及常见变形&#34;
    &gt;
        封闭形式及常见变形
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/ogf/#封闭形式及常见变形&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 封闭形式及常见变形&#34; href=&#34;#%e5%b0%81%e9%97%ad%e5%bd%a2%e5%bc%8f%e5%8f%8a%e5%b8%b8%e8%a7%81%e5%8f%98%e5%bd%a2&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;运用生成函数时，我们会适时将其化为封闭形式来便于化简。&lt;/p&gt;
&lt;p&gt;例如，$\langle 1,1,1,\cdots\rangle$ 的生成函数是&lt;/p&gt;
&lt;p&gt;$$
F(x)=\sum_{n\ge 0}x^n
$$&lt;/p&gt;
&lt;p&gt;我们发现&lt;/p&gt;
&lt;p&gt;$$
F(x)x+1=F(x)
$$&lt;/p&gt;
&lt;p&gt;解这个方程&lt;sup id=&#34;fnref:1&#34;&gt;&lt;a href=&#34;#fn:1&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;1&lt;/a&gt;&lt;/sup&gt;，&lt;/p&gt;
&lt;p&gt;$$
F(x)=\dfrac{1}{1-x}
$$&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;等比数列求和&#34;
    &gt;
        等比数列求和
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/ogf/#等比数列求和&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 等比数列求和&#34; href=&#34;#%e7%ad%89%e6%af%94%e6%95%b0%e5%88%97%e6%b1%82%e5%92%8c&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;考虑等比数列 $\langle1,p,p^2,p^3,\cdots\rangle$ 的生成函数 $F(x)=\sum_{n\ge 0}p^nx^n$，有&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
F(x)px+1&amp;amp;=F(x)\\
F(x)&amp;amp;=\dfrac{1}{1-px}
\end{aligned}
$$&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;导数&#34;
    &gt;
        导数
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/ogf/#导数&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 导数&#34; href=&#34;#%e5%af%bc%e6%95%b0&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;例如，数列 $\langle1,2,3,4,\cdots\rangle$ 的生成函数 $F(x)=\sum_{n\ge 0} (n+1)x^n$，根据导数知识，&lt;/p&gt;
&lt;p&gt;$$
(x^n)&amp;rsquo;=nx^{n-1}
$$
于是有&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
F(x)&amp;amp;=\sum_{n\ge 0}(n+1)x^n\\
&amp;amp;=\sum_{n\ge 1}nx^{n-1}\\
&amp;amp;=\sum_{n\ge 0}(x^n)&amp;rsquo;\\
&amp;amp;=\left(\dfrac{1}{1-x}\right)&amp;rsquo;\\
&amp;amp;=\dfrac{1}{(1-x)^2}
\end{aligned}
$$&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;牛顿二项式定理&#34;
    &gt;
        牛顿二项式定理
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/ogf/#牛顿二项式定理&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 牛顿二项式定理&#34; href=&#34;#%e7%89%9b%e9%a1%bf%e4%ba%8c%e9%a1%b9%e5%bc%8f%e5%ae%9a%e7%90%86&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;重新定义组合数运算：&lt;/p&gt;
&lt;p&gt;$$
\binom{r}{k}=\frac{r^{\underline{k}}}{k!}\quad(r\in\mathbf{C},k\in\mathbf{N})
$$&lt;/p&gt;
&lt;p&gt;注意 $r$ 的范围是复数域，$r^{\underline{k}}$ 是 $r$ 的下降阶乘幂&lt;sup id=&#34;fnref:2&#34;&gt;&lt;a href=&#34;#fn:2&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;2&lt;/a&gt;&lt;/sup&gt;。这时，对 $\alpha\in\mathbf{C}$，有&lt;/p&gt;
&lt;p&gt;$$
(1+x)^{\alpha}=\sum_{n\ge 0}\binom{\alpha}{n}x^n
$$&lt;/p&gt;
&lt;div class=&#34;footnotes&#34; role=&#34;doc-endnotes&#34;&gt;
&lt;hr&gt;
&lt;ol&gt;
&lt;li id=&#34;fn:1&#34;&gt;
&lt;p&gt;当然，你知道当且仅当级数收敛时才能这样变形，但是对于生成函数，我们往往默认 $x$ 取能让式子收敛的值&amp;#160;&lt;a href=&#34;#fnref:1&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id=&#34;fn:2&#34;&gt;
&lt;p&gt;定义为 $r^{\underline{k}}=r\cdot(r-1)\cdots(r-k+1)$，也写作 $(r)_k$&amp;#160;&lt;a href=&#34;#fnref:2&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/div&gt;
            </content>   
                                <category scheme="https://weilycoder.github.io/tags/math" term="math" label="math" />
        </entry>
        <entry>
            <title>Useless Algorithms</title>
            <link href="https://weilycoder.github.io/post/useless/" rel="alternate" type="text/html"  hreflang="en" />
            <id>https://weilycoder.github.io/post/useless/</id>
            <published>2024-06-21T16:23:26+08:00</published>
            <updated>2024-06-21T16:23:26+08:00</updated>
            <content type="html">
                &lt;blockquote&gt;
&lt;p&gt;If you know at least 3 of these things and you are not red — you are doing it wrong. Stop learning useless algorithms, go and solve some problems, learn how to use binary search.&lt;/p&gt;
&lt;p&gt;—— &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://codeforces.com/profile/Um_nik&#34;
&gt;$\textcolor{black}{\text{U}}\textcolor{red}{\text{m_nik}}$&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;本文来自 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://codeforces.com/blog/entry/92248&#34;
&gt;$\textcolor{black}{\text{U}}\textcolor{red}{\text{m_nik}}$ 的 CodeForces 博客&lt;/a&gt;，大多是一些强大复杂但是不一定有用的算法或数据结构。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/ds/li-chao-tree/&#34;
&gt;李超线段树&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/ds/seg-beats/&#34;
&gt;吉司机线段树&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/topic/rmq/#four-russian&#34;
&gt;RMQ in $O(n)\sim O(1)$&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/ds/treap/&#34;
&gt;Treap&lt;/a&gt; 以外的&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/ds/bst/&#34;
&gt;平衡二叉树&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/ds/lct/&#34;
&gt;动态树&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;小波树（&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://en.wikipedia.org/wiki/Wavelet_Tree&#34;
&gt;Wavelet tree&lt;/a&gt;）&lt;sup id=&#34;fnref:1&#34;&gt;&lt;a href=&#34;#fn:1&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;1&lt;/a&gt;&lt;/sup&gt;；&lt;/li&gt;
&lt;li&gt;归并树&lt;sup id=&#34;fnref:2&#34;&gt;&lt;a href=&#34;#fn:2&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;2&lt;/a&gt;&lt;/sup&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://en.wikipedia.org/wiki/Binomial_heap&#34;
&gt;二项堆&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://en.wikipedia.org/wiki/Fibonacci_heap&#34;
&gt;斐波那契堆&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/ds/leftist-tree/&#34;
&gt;左偏树&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/graph/dominator-tree/&#34;
&gt;支配树&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;3-connected components in $O(n)$ &lt;sup id=&#34;fnref:3&#34;&gt;&lt;a href=&#34;#fn:3&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;3&lt;/a&gt;&lt;/sup&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/graph/kth-path/&#34;
&gt;$k$ 短路&lt;/a&gt;&lt;sup id=&#34;fnref:4&#34;&gt;&lt;a href=&#34;#fn:4&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;4&lt;/a&gt;&lt;/sup&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/graph/graph-matching/general-match/&#34;
&gt;一般图最大匹配&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/graph/graph-matching/general-weight-match/&#34;
&gt;一般图最大权匹配&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/graph/flow/max-flow/#push-relabel-%E9%A2%84%E6%B5%81%E6%8E%A8%E8%BF%9B%E7%AE%97%E6%B3%95&#34;
&gt;网络流最大流-预流推进算法&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/graph/flow/min-cost/&#34;
&gt;多项式内的最小费用最大流&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/graph/dmst/&#34;
&gt;$O(E\log V)$ 的最小树形图&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/string/suffix-tree/&#34;
&gt;后缀树&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://en.wikipedia.org/wiki/Convex_hull_algorithms#On-line_and_dynamic_convex_hull_problems&#34;
&gt;在线二维凸包&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/geometry/convex-hull/#%E4%B8%89%E7%BB%B4%E5%87%B8%E5%8C%85&#34;
&gt;三维凸包&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/geometry/half-plane/&#34;
&gt;半平面交&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/geometry/triangulation/&#34;
&gt;Voronoi 图 / 三角剖分&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/math/poly/elementary-func/&#34;
&gt;多项式常见操作 (exp, log, sqrt, &amp;hellip;)&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/math/poly/ogf/&#34;
&gt;生成函数&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/math/poly/lagrange-inversion/&#34;
&gt;拉格朗日反演&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://codeforces.com/blog/entry/76447&#34;
&gt;That derivative magic&lt;/a&gt; by &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://codeforces.com/profile/Elegia&#34;
&gt;$\textcolor{red}{\text{Elegia}}$&lt;/a&gt;&lt;sup id=&#34;fnref1:3&#34;&gt;&lt;a href=&#34;#fn:3&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;3&lt;/a&gt;&lt;/sup&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://codeforces.com/blog/entry/92183&#34;
&gt;That new subset convolution derivative magic&lt;/a&gt; by &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://codeforces.com/profile/Elegia&#34;
&gt;$\textcolor{red}{\text{Elegia}}$&lt;/a&gt;&lt;sup id=&#34;fnref2:3&#34;&gt;&lt;a href=&#34;#fn:3&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;3&lt;/a&gt;&lt;/sup&gt;；&lt;/li&gt;
&lt;li&gt;&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org/misc/mo-algo-secondary-offline/&#34;
&gt;扫描线莫队 / 莫队二次离线&lt;/a&gt;；&lt;/li&gt;
&lt;li&gt;Matroid intersection&lt;sup id=&#34;fnref3:3&#34;&gt;&lt;a href=&#34;#fn:3&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;3&lt;/a&gt;&lt;/sup&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;div class=&#34;footnotes&#34; role=&#34;doc-endnotes&#34;&gt;
&lt;hr&gt;
&lt;ol&gt;
&lt;li id=&#34;fn:1&#34;&gt;
&lt;p&gt;在中文网上资料较少，这里保留英文名。&amp;#160;&lt;a href=&#34;#fnref:1&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id=&#34;fn:2&#34;&gt;
&lt;p&gt;在归并排序时将各级有序数组保留，可以用于解决区间第 $k$ 小问题。&amp;#160;&lt;a href=&#34;#fnref:2&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id=&#34;fn:3&#34;&gt;
&lt;p&gt;原文如此。&amp;#160;&lt;a href=&#34;#fnref:3&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&amp;#160;&lt;a href=&#34;#fnref1:3&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&amp;#160;&lt;a href=&#34;#fnref2:3&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&amp;#160;&lt;a href=&#34;#fnref3:3&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id=&#34;fn:4&#34;&gt;
&lt;p&gt;我擅自认为朴素 A* 不能被计算，因为它的复杂度不是最优的。&amp;#160;&lt;a href=&#34;#fnref:4&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/div&gt;
            </content>   
                                <category scheme="https://weilycoder.github.io/tags/misc" term="misc" label="misc" />
        </entry>
        <entry>
            <title>读入/输出优化</title>
            <link href="https://weilycoder.github.io/post/fastio/" rel="alternate" type="text/html"  hreflang="en" />
            <id>https://weilycoder.github.io/post/fastio/</id>
                    <author>
                        <name>weily</name>
                    </author>
            <published>2024-06-15T12:52:42+08:00</published>
            <updated>2024-06-15T12:52:42+08:00</updated>
            <content type="html">
                &lt;p&gt;本文所有代码默认 &lt;code&gt;#include &amp;lt;iostream&amp;gt;&lt;/code&gt; 且 &lt;code&gt;using namespace std;&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;帮 N 老师搞完 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://github.com/weilycoder/fastioForOI/blob/main/art.md&#34;
&gt;Fast IO&lt;/a&gt; 页面后有感而发，希望系统地写一下文件读入输出优化。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;读入输出优化原理&#34;
    &gt;
        读入/输出优化原理
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/fastio/#读入输出优化原理&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 读入/输出优化原理&#34; href=&#34;#%e8%af%bb%e5%85%a5%e8%be%93%e5%87%ba%e4%bc%98%e5%8c%96%e5%8e%9f%e7%90%86&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;cincout-的速度&#34;
    &gt;
        &lt;code&gt;cin/cout&lt;/code&gt; 的速度
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/fastio/#cincout-的速度&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor cin/cout 的速度&#34; href=&#34;#cincout-%e7%9a%84%e9%80%9f%e5%ba%a6&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;为啥 &lt;code&gt;cin/cout&lt;/code&gt; 那么慢？C++ 不是 C plus plus 吗？怎么 IO 速度反而变慢了？&lt;/p&gt;
&lt;p&gt;实际上，这是 C++ 为实现向下兼容做出的保守措施：&lt;code&gt;cin/cout&lt;/code&gt; 保证与 &lt;code&gt;printf/scanf&lt;/code&gt; 混用时是&lt;strong&gt;线程安全&lt;/strong&gt;的。&lt;/p&gt;
&lt;p&gt;即：如果你先调用 &lt;code&gt;cout&lt;/code&gt;，再调用 &lt;code&gt;printf&lt;/code&gt;，会保证前者先于后者输出；反之亦然。&lt;/p&gt;
&lt;p&gt;通常，我们认为，C++ 风格的输入输出是 C 风格的输入输出耗时的 3 倍左右（毕竟你带着小孩玩肯定不如自己玩爽）。&lt;/p&gt;
&lt;p&gt;因此，就有了第一种优化：&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h4 id=&#34;printfscanf-优化&#34;
    &gt;
        &lt;code&gt;printf/scanf&lt;/code&gt; 优化
    &lt;/h4&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/fastio/#printfscanf-优化&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor printf/scanf 优化&#34; href=&#34;#printfscanf-%e4%bc%98%e5%8c%96&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;既然 C++ 风格的输入输出慢，我不用他不就行了？&lt;/p&gt;
&lt;p&gt;我们可以用 &lt;code&gt;printf/scanf&lt;/code&gt; 替代 &lt;code&gt;cout/cin&lt;/code&gt;，达到加速读写的目的。&lt;/p&gt;
&lt;p&gt;不过 C 风格输入输出不够智能，需要在格式化字符串中指定输入类型，万一 &lt;code&gt;#define int long long&lt;/code&gt; 之后下意识用了 &lt;code&gt;%d&lt;/code&gt; 而不是 &lt;code&gt;%lld&lt;/code&gt;，那就应了那句老话：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;em&gt;十年 OI 一场空，不开 &lt;code&gt;long long&lt;/code&gt; 见祖宗。&lt;/em&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;不过 C 风格的输出应付浮点数比较方便。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h4 id=&#34;iossync_with_stdiofalse-优化&#34;
    &gt;
        &lt;code&gt;ios::sync_with_stdio(false)&lt;/code&gt; 优化
    &lt;/h4&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/fastio/#iossync_with_stdiofalse-优化&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor ios::sync_with_stdio(false) 优化&#34; href=&#34;#iossync_with_stdiofalse-%e4%bc%98%e5%8c%96&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;我还是想用 C++！&lt;/p&gt;
&lt;p&gt;但是慢怎么办？&lt;/p&gt;
&lt;p&gt;既然因为要兼顾 C 才慢，我不管 C 不就行了？&lt;/p&gt;
&lt;p&gt;函数 &lt;code&gt;ios::sync_with_stdio&lt;/code&gt; 可以设置标准 C++ 流是否与标准 C 流在每次输入/输出操作后同步。&lt;/p&gt;
&lt;p&gt;只要在&lt;strong&gt;进行 IO 操作之前&lt;/strong&gt;调用 &lt;code&gt;ios::sync_with_stdio(false)&lt;/code&gt;，即可使 C++ 摆脱 C。&lt;/p&gt;
&lt;p&gt;有关“同步”的内容可能实际更加复杂，参阅 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;%28https://zh.cppreference.com/w/cpp/io/ios_base/sync_with_stdio%29&#34;
&gt;cppreference&lt;/a&gt;。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h4 id=&#34;endlflushtie-优化&#34;
    &gt;
        &lt;code&gt;endl/flush/tie&lt;/code&gt; 优化
    &lt;/h4&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/fastio/#endlflushtie-优化&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor endl/flush/tie 优化&#34; href=&#34;#endlflushtie-%e4%bc%98%e5%8c%96&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;还是不够快！&lt;/p&gt;
&lt;p&gt;试试 &lt;code&gt;cin.tie(0)&lt;/code&gt;！&lt;/p&gt;
&lt;p&gt;默认情况下，&lt;code&gt;cin&lt;/code&gt; 和 &lt;code&gt;cout&lt;/code&gt; 是“绑定”在一起的，即，每次调用 &lt;code&gt;cin&lt;/code&gt;，会在读入数据前刷新 &lt;code&gt;cout&lt;/code&gt; 的缓冲流。&lt;/p&gt;
&lt;p&gt;多次刷新缓冲流最终会使程序变慢。&lt;/p&gt;
&lt;p&gt;使用 &lt;code&gt;cin.tie(0)&lt;/code&gt; 可以改变这一点，他会取消 &lt;code&gt;cin&lt;/code&gt; 和 &lt;code&gt;cout&lt;/code&gt; 的绑定。&lt;/p&gt;
&lt;p&gt;为了使程序不再主动进行不必要的刷新，我们需要使用 &lt;code&gt;&#39;\n&#39;&lt;/code&gt; 替代 &lt;code&gt;endl&lt;/code&gt;，后者在换行的同时会调用 &lt;code&gt;flush&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;但是！如果我们在做交互题，我们往往需要让程序刷新缓冲流。这时手动调用 &lt;code&gt;flush&lt;/code&gt; 即可。&lt;/p&gt;
&lt;p&gt;使用 &lt;code&gt;sync_with_stdio(false)&lt;/code&gt; + &lt;code&gt;tie(0)&lt;/code&gt; 后的 C++ 风格读入输出通常比 C 风格读入输出快一点。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;函数调用开销&#34;
    &gt;
        函数调用开销
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/fastio/#函数调用开销&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 函数调用开销&#34; href=&#34;#%e5%87%bd%e6%95%b0%e8%b0%83%e7%94%a8%e5%bc%80%e9%94%80&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;无论是 C++ 风格的读入输出，还是 C 风格的，都封装了多层函数，来应对复杂的读入输出环境。&lt;/p&gt;
&lt;p&gt;可是，实际上，OI 界的读入输出并没有那么复杂，这无疑是一种浪费。&lt;/p&gt;
&lt;p&gt;因此，我们可以调用更底层的 &lt;code&gt;getchar/putchar&lt;/code&gt; 来加快读写：&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h4 id=&#34;getcharputchar-优化&#34;
    &gt;
        &lt;code&gt;getchar/putchar&lt;/code&gt; 优化
    &lt;/h4&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/fastio/#getcharputchar-优化&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor getchar/putchar 优化&#34; href=&#34;#getcharputchar-%e4%bc%98%e5%8c%96&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt; 1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 4
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 5
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 6
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 7
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 8
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 9
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;10
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;11
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;12
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;13
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;14
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;inline&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;read&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;()&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;f&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kt&#34;&gt;char&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;c&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;getchar&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;();&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;c&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;sc&#34;&gt;&amp;#39;0&amp;#39;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;||&lt;/span&gt; &lt;span class=&#34;sc&#34;&gt;&amp;#39;9&amp;#39;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;c&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;c&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;getchar&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;())&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;c&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;sc&#34;&gt;&amp;#39;-&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;f&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*=&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(;&lt;/span&gt; &lt;span class=&#34;sc&#34;&gt;&amp;#39;0&amp;#39;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;c&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;c&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;sc&#34;&gt;&amp;#39;9&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;c&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;getchar&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;())&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;10&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;c&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;^&lt;/span&gt; &lt;span class=&#34;sc&#34;&gt;&amp;#39;0&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;f&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kt&#34;&gt;void&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;putchar&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;sc&#34;&gt;&amp;#39;-&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;10&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;putchar&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;^&lt;/span&gt; &lt;span class=&#34;sc&#34;&gt;&amp;#39;0&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;/&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;10&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;putchar&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;10&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;^&lt;/span&gt; &lt;span class=&#34;sc&#34;&gt;&amp;#39;0&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;如果保证读入的数是非负数，&lt;code&gt;read&lt;/code&gt; 可以进一步优化：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;4
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;5
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;6
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;7
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;8
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;9
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;inline&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;read&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;()&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;f&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kt&#34;&gt;char&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;c&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;getchar&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;();&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;c&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;sc&#34;&gt;&amp;#39;0&amp;#39;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;||&lt;/span&gt; &lt;span class=&#34;sc&#34;&gt;&amp;#39;9&amp;#39;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;c&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;c&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;getchar&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;())&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;c&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;sc&#34;&gt;&amp;#39;-&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;f&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*=&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(;&lt;/span&gt; &lt;span class=&#34;sc&#34;&gt;&amp;#39;0&amp;#39;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;c&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;c&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;sc&#34;&gt;&amp;#39;9&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;c&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;getchar&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;())&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;10&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;c&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;^&lt;/span&gt; &lt;span class=&#34;sc&#34;&gt;&amp;#39;0&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;f&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;同时，应考虑使用数组模拟栈防止递归开销：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;4
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;5
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;6
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;7
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;8
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;inline&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;void&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;long&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;long&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;static&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;sta&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;35&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;top&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;do&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;n&#34;&gt;sta&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;top&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;10&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;/=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;10&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;while&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;while&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;top&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;putchar&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;sta&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;--&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;top&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;sc&#34;&gt;&amp;#39;0&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;文件-io&#34;
    &gt;
        文件 IO
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/fastio/#文件-io&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 文件 IO&#34; href=&#34;#%e6%96%87%e4%bb%b6-io&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;众所周知，计算机中，离 CPU 越近，空间越小，读写越快。&lt;/p&gt;
&lt;p&gt;例如，硬盘离 CPU 最远，读写最慢，但是，硬盘可以轻松存储十几甚至几百几千 G 的大文件，并且断电后不丢失。&lt;/p&gt;
&lt;p&gt;内存离 CPU 很近，读写比硬盘快得多，可是，内存总共可能才 4G，OI 题中顶天让你用 1G；并且，内存数据在断电后会缓慢丢失。&lt;/p&gt;
&lt;p&gt;缓存离 CPU 更近，读写比内存还快，空间更小。一般，如果 CPU 认为一段内存可能会多次使用，就会将它加载到缓存，提高数据处理速度，有些算法“缓存命中率”高，就是说这种算法可以充分利用这种性质。计算机中有多级缓存，大小从 1K 到 1M 不等。&lt;/p&gt;
&lt;p&gt;寄存器可能离 CPU 最近，最多就十几个 64 位变量，速度最快，效率最高。&lt;/p&gt;
&lt;p&gt;为啥说这个？因为 &lt;code&gt;getchar/putchar&lt;/code&gt; 再底层，也是对硬盘操作，我们要尽量减少这样的操作。&lt;/p&gt;
&lt;p&gt;咋再减少？只有手动模拟一个巨大的缓冲区，一次读入/输出大量数据。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h4 id=&#34;freadfwrite-优化&#34;
    &gt;
        &lt;code&gt;fread/fwrite&lt;/code&gt; 优化
    &lt;/h4&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/fastio/#freadfwrite-优化&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor fread/fwrite 优化&#34; href=&#34;#freadfwrite-%e4%bc%98%e5%8c%96&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;4
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;5
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kt&#34;&gt;char&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;buf&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;20&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;p1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;p2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;cp&#34;&gt;#define gc()                                                                 \
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;cp&#34;&gt;  (p1 == p2 &amp;amp;&amp;amp; (p2 = (p1 = buf) + fread(buf, 1, 1 &amp;lt;&amp;lt; 20, stdin), p1 == p2)     \
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;cp&#34;&gt;       ? EOF                                                                 \
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;cp&#34;&gt;       : *p1++)&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;这段代码实现了名为 &lt;code&gt;buf&lt;/code&gt; 的读入缓冲区，一次从设备读入上百万个字符；并维护了缓冲区末尾指针 &lt;code&gt;p2&lt;/code&gt; 和当前指针 &lt;code&gt;p1&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;使用宏 &lt;code&gt;gc&lt;/code&gt; 从缓冲区获得字符。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;4
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;5
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kt&#34;&gt;char&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;pbuf&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;20&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;pp&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;pbuf&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kt&#34;&gt;void&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;pc&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;k&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;char&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;c&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;pp&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;pbuf&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;20&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;fwrite&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;pbuf&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;20&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;stdout&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;pp&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;pbuf&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;pp&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;c&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;这段代码维护了名为 &lt;code&gt;pbuf&lt;/code&gt; 的输出缓冲区，在缓冲区满时自动输出并清空。&lt;/p&gt;
&lt;p&gt;使用 &lt;code&gt;pc&lt;/code&gt; 向缓冲区写入字符。&lt;/p&gt;
&lt;p&gt;注意在结束程序前要使用 &lt;code&gt;fwrite(pbuf, 1, pp - pbuf, stdout)&lt;/code&gt; 手动清空一次。&lt;/p&gt;
&lt;p&gt;这种方式的具体实现：参见我的 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://github.com/weilycoder/fastioForOI&#34;
&gt;fastioForOI&lt;/a&gt; 项目。&lt;/p&gt;
            </content>  
                                <category scheme="https://weilycoder.github.io/authors/weily" term="weily" label="weily" />  
                                <category scheme="https://weilycoder.github.io/tags/misc" term="misc" label="misc" />
        </entry>
        <entry>
            <title>计算理论基础：P 问题、NP 问题和 NPC 问题</title>
            <link href="https://weilycoder.github.io/post/cc/" rel="alternate" type="text/html"  hreflang="en" />
            <id>https://weilycoder.github.io/post/cc/</id>
            <published>2024-06-07T23:26:50+08:00</published>
            <updated>2024-06-07T23:26:50+08:00</updated>
            <content type="html">
                &lt;blockquote&gt;
&lt;p&gt;部分内容来自 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org&#34;
&gt;OI-Wiki&lt;/a&gt;。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;时间复杂度&#34;
    &gt;
        时间复杂度
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/cc/#时间复杂度&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 时间复杂度&#34; href=&#34;#%e6%97%b6%e9%97%b4%e5%a4%8d%e6%9d%82%e5%ba%a6&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;大-o-表示法&#34;
    &gt;
        大 O 表示法
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/cc/#大-o-表示法&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 大 O 表示法&#34; href=&#34;#%e5%a4%a7-o-%e8%a1%a8%e7%a4%ba%e6%b3%95&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;如何衡量两个算法的优劣？&lt;/p&gt;
&lt;p&gt;通常来说，给定一个算法的运行过程，我们可以写出算法的基本操作数（加减乘除、比较判断、读写数组等）随数据规模变化的函数 $f(n)$。然而，算法的实现细节不同，函数的系数可能存在差异。甚至，我们所谓“基本操作”的用时差别也不能完全忽略。&lt;/p&gt;
&lt;p&gt;但是，我们发现，随着数据规模的不断扩大，这些细微差异的影响越来越小，考虑这些细枝末节的问题未免耽误大局。&lt;/p&gt;
&lt;p&gt;根据经验，线性函数的增长速度总比不上平方级别的；平方级别总比不上立方级别的；而只要是幂函数，最终总比不上指数函数的增长。&lt;/p&gt;
&lt;p&gt;于是，我们可以把 $2n^2,n(n-1),3n^2-6n+10$ 等等全归入 $n^2$ 级别；将 $n(n^2-n+1),\dfrac{n^3}{3}$ 等归入 $n^3$……&lt;/p&gt;
&lt;p&gt;更形式化地，我们有 &lt;strong&gt;大 $\Theta$ 表示法&lt;/strong&gt;：&lt;/p&gt;
&lt;p&gt;对于函数 $f(n),g(n)$，$f(n)=\Theta(g(n))$ 当且仅当 $\exists c_1,c_2,n_0\gt 0$，使 $\forall n\gt n_0,c_1\cdot g(n)\le f(n)\le c_2\cdot g(n).$&lt;/p&gt;
&lt;p&gt;需要注意，这里等号 $=$ 的含义更偏向属于号 $\in$。&lt;/p&gt;
&lt;p&gt;更多时候，我们对复杂度的要求并不严格，只需给出渐进上界，不关心其渐进下界。那么，我们有 &lt;strong&gt;大 O 表示法&lt;/strong&gt;：&lt;/p&gt;
&lt;p&gt;$f(n)=O(g(n))$，当且仅当 $\exists c,n_0$，使得 $\forall n \ge n_0,0\le f(n)\le c\cdot g(n)$。&lt;/p&gt;
&lt;p&gt;如果说 $\Theta$ 符号表示“严格等于”，$O$ 符号就表示“大于等于”。&lt;/p&gt;
&lt;p&gt;更多时候，尽管确定了渐进下界，鉴于输入习惯，我们仍使用 $O$ 而非 $\Theta$。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;常见复杂度级别&#34;
    &gt;
        常见复杂度级别
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/cc/#常见复杂度级别&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 常见复杂度级别&#34; href=&#34;#%e5%b8%b8%e8%a7%81%e5%a4%8d%e6%9d%82%e5%ba%a6%e7%ba%a7%e5%88%ab&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;&lt;img
  src=&#34;/Figure.webp&#34;
  alt=&#34;常见复杂度图像&#34;
  
/&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;&lt;strong&gt;注意：对于数值计算，OI 界常常直接用输入数据本身作为数据规模，但更科学的方法是使用数据的长度作为规模。这是 $O(n)$ 与 $O(\log n)$ 的差别，请联系上下文判断。&lt;/strong&gt;&lt;/em&gt;&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h4 id=&#34;常数级别-o1&#34;
    &gt;
        常数级别 $O(1)$
    &lt;/h4&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/cc/#常数级别-o1&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 常数级别 $O(1)$&#34; href=&#34;#%e5%b8%b8%e6%95%b0%e7%ba%a7%e5%88%ab-o1&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;意味着无论输入数据多大，运行时间都不会改变。&lt;/p&gt;
&lt;p&gt;在 OI 界，数的基本运算常被视作 $O(1)$ 的，因此常见于运用公式的计算，如 $\sum_{i=1}^{n}i=\frac{n(n+1)}{2}$，前者是 $O(n)$ 的，后者认为优化到了 $O(1)$；有些数据结构的单次查询复杂度也是 $O(1)$ 的（最简单的如数组）。&lt;/p&gt;
&lt;p&gt;不过，考虑到大整数的计算实际上不可能是常数级别，在数据增大时可能只是“伪常数”的。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h4 id=&#34;反阿克曼函数-oalphan&#34;
    &gt;
        反阿克曼函数 $O(\alpha(n))$
    &lt;/h4&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/cc/#反阿克曼函数-oalphan&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 反阿克曼函数 $O(\alpha(n))$&#34; href=&#34;#%e5%8f%8d%e9%98%bf%e5%85%8b%e6%9b%bc%e5%87%bd%e6%95%b0-oalphan&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;这是并查集的专利，是一个增速可以忽略不计的函数，$\text{R. E. Tarjan}$ 证明，$\forall n\le 2^{2^{10^{19729}}}$，都有 $\alpha(n)&amp;lt;5$。因此在非学界完全可以视为 $O(1)$。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h4 id=&#34;双对数-olog-log-n&#34;
    &gt;
        双对数 $O(\log \log n)$
    &lt;/h4&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/cc/#双对数-olog-log-n&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 双对数 $O(\log \log n)$&#34; href=&#34;#%e5%8f%8c%e5%af%b9%e6%95%b0-olog-log-n&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;对数的对数，在分析时几乎可以视为常数忽略。似乎很少见单纯 $O(\log \log n)$ 的算法，但是可以与其他组合。&lt;/p&gt;
&lt;p&gt;例如，埃氏筛的时间复杂度是 $O(n\log \log n)$ 的，这意味着其与线性筛 $O(n)$ 的复杂度相差极小，在小数据范围&lt;sup id=&#34;fnref:1&#34;&gt;&lt;a href=&#34;#fn:1&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;1&lt;/a&gt;&lt;/sup&gt;甚至可能更优。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h4 id=&#34;对数-olog-n&#34;
    &gt;
        对数 $O(\log n)$
    &lt;/h4&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/cc/#对数-olog-n&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 对数 $O(\log n)$&#34; href=&#34;#%e5%af%b9%e6%95%b0-olog-n&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;常见于每次迭代缩小一半规模的算法，例如二分搜索。另外，由于质数个数函数的估计为 $\pi(n)\sim \dfrac{n}{\ln n}$，涉及质数的算法可能也会出现对数。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;由于换底公式 $\log_{a}b=\dfrac{\log_{c}b}{\log_{c}a}$，对数底数的差别只是常数的差距；另外，由于 $\log n^k=k\log n$，在 $k$ 为常数时，同样是常数差距。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h4 id=&#34;对数的乘方-ologk-n&#34;
    &gt;
        对数的乘方 $O(\log^k n)$
    &lt;/h4&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/cc/#对数的乘方-ologk-n&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 对数的乘方 $O(\log^k n)$&#34; href=&#34;#%e5%af%b9%e6%95%b0%e7%9a%84%e4%b9%98%e6%96%b9-ologk-n&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;例如说，在 $O(\log n)$ 查询的数据结构上二分查找的复杂度是 $O(\log^2 n)$ 的；其他多重嵌套的数据结构的复杂度可能达到 $O(\log^k n)$。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h4 id=&#34;亚线性-onepsilon&#34;
    &gt;
        亚线性 $O(n^{\epsilon})$
    &lt;/h4&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/cc/#亚线性-onepsilon&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 亚线性 $O(n^{\epsilon})$&#34; href=&#34;#%e4%ba%9a%e7%ba%bf%e6%80%a7-onepsilon&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;使用根号分治思想的算法通常是 $O(\sqrt{n})$ 的，例如暴力因式分解，或者数论分块；&lt;/p&gt;
&lt;p&gt;基于期望的 Pollard-Rho 算法可以快速分解非平凡因子，时间复杂度是 $O(n^{1/4})$ 的；&lt;/p&gt;
&lt;p&gt;存在很多亚线性筛快速计算数论函数的前缀和，如杜教筛时间复杂度可达到 $O(n^{2/3})$。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h4 id=&#34;线性-on&#34;
    &gt;
        线性 $O(n)$
    &lt;/h4&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/cc/#线性-on&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 线性 $O(n)$&#34; href=&#34;#%e7%ba%bf%e6%80%a7-on&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;遍历数组的复杂度。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h4 id=&#34;幂多项式-onk&#34;
    &gt;
        幂（多项式） $O(n^k)$
    &lt;/h4&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/cc/#幂多项式-onk&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 幂（多项式） $O(n^k)$&#34; href=&#34;#%e5%b9%82%e5%a4%9a%e9%a1%b9%e5%bc%8f-onk&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;多见于 $k$ 重循环。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h4 id=&#34;指数-okn&#34;
    &gt;
        指数 $O(k^n)$
    &lt;/h4&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/cc/#指数-okn&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 指数 $O(k^n)$&#34; href=&#34;#%e6%8c%87%e6%95%b0-okn&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;多见于暴力搜索且不含剪枝，每次有 $k$ 个决策。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h4 id=&#34;阶乘-on&#34;
    &gt;
        阶乘 $O(n!)$
    &lt;/h4&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/cc/#阶乘-on&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 阶乘 $O(n!)$&#34; href=&#34;#%e9%98%b6%e4%b9%98-on&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;暴力搜索，如枚举全排列。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h4 id=&#34;onn&#34;
    &gt;
        $O(n^n)$
    &lt;/h4&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/cc/#onn&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor $O(n^n)$&#34; href=&#34;#onn&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;暴力搜索。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;啥是-mathsfp-问题&#34;
    &gt;
        啥是 $\mathsf{P}$ 问题
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/cc/#啥是-mathsfp-问题&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 啥是 $\mathsf{P}$ 问题&#34; href=&#34;#%e5%95%a5%e6%98%af-mathsfp-%e9%97%ae%e9%a2%98&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;用一句话来说，$\mathsf{P}$ 问题就是你的计算机（确定性图灵机）可以在 $O(n^k)$ 内跑出结果的问题，这里 $k$ 是与输入无关的常数。&lt;/p&gt;
&lt;p&gt;更正式地，复杂度类 $\mathsf{P}$ 表示可以由确定性图灵机在多项式时间内解决的&lt;strong&gt;判定问题&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;由于普遍认为多项式函数的增长速度是最大的仍能使人接受的增长，我们认为：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;一般来说，如果一个问题被归入 $\mathsf{P}$ 问题，我们认为它是快速、实用、高效的。&lt;/strong&gt;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;考虑 $f(x)=x^5,g(x)=2^x$，前者在最初高于后者，但后者在 $23$ 之后彻底反超。如果你做出 $\dfrac{f(x)}{g(x)}$ 和 $\dfrac{g(x)}{f(x)}$ 的图像，感受会更加深刻。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;啥是-mathsfnp-问题&#34;
    &gt;
        啥是 $\mathsf{NP}$ 问题
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/cc/#啥是-mathsfnp-问题&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 啥是 $\mathsf{NP}$ 问题&#34; href=&#34;#%e5%95%a5%e6%98%af-mathsfnp-%e9%97%ae%e9%a2%98&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;很多人在谈论 $\mathsf{NP}$ 问题时会将它与 $\mathsf{NPC}$ 问题或 $\mathsf{NP-hard}$ 问题混淆。&lt;/p&gt;
&lt;p&gt;有时，人们也以为，$\mathsf{NP}$ 指需要用超过多项式级别的算法解决问题（如 $O(k^n)$，即暴力搜索）&lt;/p&gt;
&lt;p&gt;$\mathsf{NP}$ 问题不是“非”多项式问题；$\mathsf{NP}$ 中的 N 的含义是“不确定的”，换句话说，$\mathsf{NP}$ 问题是非确定性图灵机可以在多项式的时间复杂度内解决的问题；或者说，若这类问题的答案可以由确定性图灵机在多项式时间内验证。&lt;/p&gt;
&lt;p&gt;有人可能会疑惑：什么叫验证答案？&lt;/p&gt;
&lt;p&gt;例如说，对 $25321938666092955675457495083563$ 分解质因数&lt;sup id=&#34;fnref:2&#34;&gt;&lt;a href=&#34;#fn:2&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;2&lt;/a&gt;&lt;/sup&gt;。这个问题目前没有多项式级别的算法&lt;sup id=&#34;fnref:3&#34;&gt;&lt;a href=&#34;#fn:3&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;3&lt;/a&gt;&lt;/sup&gt;。可是，如果我说算出这个数的标准素因数分解式是 $1979263111111333 \times 12793619263623311$：首先，验证质数是可以在多项式时间内完成的&lt;sup id=&#34;fnref:4&#34;&gt;&lt;a href=&#34;#fn:4&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;4&lt;/a&gt;&lt;/sup&gt;，其次，将两个大数相乘不是难事。你就可以相信，我给出的标准质因数分解式是正确的。&lt;/p&gt;
&lt;p&gt;也就是说，可以提交一定的证据，使确定性图灵机经过多项式时间后的验证后确定问题的答案是“YES”。&lt;/p&gt;
&lt;p&gt;显然 $\mathsf{P}$ 其实是 $\mathsf{NP}$ 的一个子集，由此你可以看到那些错误的理解有多么离谱。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;mathsfpmathsfnp&#34;
    &gt;
        $\mathsf{P}=\mathsf{NP}?$
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/cc/#mathsfpmathsfnp&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor $\mathsf{P}=\mathsf{NP}?$&#34; href=&#34;#mathsfpmathsfnp&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;这是计算理论至今悬而未决的问题，$\mathsf{P}$ 问题与 $\mathsf{NP}$ 问题这两个集合显然是包含关系，即 $\mathsf{P}\subseteq\mathsf{NP}$，因为能多项式地求解一个问题，必定也能在多项式时间内验证问题。但是，$\mathsf{P}$ 等于 $\mathsf{NP}$ 吗？换句话说，能快速地验证问题，就一定能快速地解决吗？&lt;/p&gt;
&lt;p&gt;在 2002 年对于 100 名研究者的调查中，61 人相信答案是否定的，9 人相信答案是肯定的，22 人不确定，而 8 人相信问题可能和现在所接受的公理独立，所以不可能证明或证否。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;mathsfnp-hard-问题&#34;
    &gt;
        $\mathsf{NP-hard}$ 问题
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/cc/#mathsfnp-hard-问题&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor $\mathsf{NP-hard}$ 问题&#34; href=&#34;#mathsfnp-hard-%e9%97%ae%e9%a2%98&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;这是对 $\mathsf{P}=\mathsf{NP}$ 问题解决的尝试。&lt;/p&gt;
&lt;p&gt;所谓 $\mathsf{NP-hard}$ 问题，就是说，所有 $\mathsf{NP}$ 问题可以在多项式时间内&lt;em&gt;规约&lt;/em&gt;到这个问题。&lt;/p&gt;
&lt;p&gt;那么，什么是“规约”？&lt;/p&gt;
&lt;p&gt;这个词语或许有些抽象，简单来说，就是通过一些代价将一个问题转化为另一个问题。&lt;/p&gt;
&lt;p&gt;例如说，可以通过计算树的欧拉序将不带修的 LCA 问题转化为 RMQ 问题。&lt;/p&gt;
&lt;p&gt;不过，$\mathsf{NP-hard}$ 一定是 $\mathsf{NP}$ 吗？&lt;/p&gt;
&lt;p&gt;这可不一定。例如，“子集和”的“前 $k$ 大”版本，即：给定 $n$ 个数和 $k(k\lt 2^n)$，判断这 $n$ 个数组成的相异的和的第 $k$ 大是否大于 $m$。&lt;/p&gt;
&lt;p&gt;由于“子集和”问题是 $\mathsf{NP-hard}$ 的，且后者可以“归约”到前者，因此前者也是 $\mathsf{NP-hard}$ 的。但由于 $k$ 是 $O(2^n)$ 级别的，前者不可能在多项式时间内验证，故前者只是 $\mathsf{NP-hard}$ 而不是 $\mathsf{NP}$ 问题。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;mathsfnpc-问题&#34;
    &gt;
        $\mathsf{NPC}$ 问题
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/cc/#mathsfnpc-问题&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor $\mathsf{NPC}$ 问题&#34; href=&#34;#mathsfnpc-%e9%97%ae%e9%a2%98&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;或者叫 $\mathsf{NP-complete}$ 问题。&lt;/p&gt;
&lt;p&gt;若一个问题既是 $\mathsf{NP}$ 问题，又是 $\mathsf{NP-hard}$ 的，则其是 $\mathsf{NPC}$ 问题。&lt;/p&gt;
&lt;p&gt;第一个被证明是 $\mathsf{NPC}$ 的问题是 $\text{SAT}$ 问题，即：给定若干布尔表达式，问，是否存在一种变量取值，使所有表达式的值均为 $\text{TRUE}$。&lt;/p&gt;
&lt;p&gt;值得一提，若限定每个表达式中变量的个数为 $k$，则成为 $k-\text{SAT}$ 问题；$2-\text{SAT}$ 存在多项式解，但 $3-\text{SAT}$ 是 $\mathsf{NPC}$ 问题。&lt;/p&gt;
&lt;p&gt;$\mathsf{P}=\mathsf{NP}$ 即 $\mathsf{NPC}$ 问题属于 $\mathsf{P}$。&lt;/p&gt;
&lt;p&gt;也就是说，若找到一个 $\mathsf{NPC}$ 问题的多项式解（或证明存在），即可说明 $\mathsf{P}=\mathsf{NP}$（事实上，只要是 $\mathsf{NP-hard}$ 问题就行）。&lt;/p&gt;
&lt;p&gt;这也是学界倾向于 $\mathsf{P}\ne \mathsf{NP}$ 的原因。想象一下，假如我们找到了一个算法在多项式内解决 $\mathsf{NPC}$ 问题，那么几乎所有问题都可解了。甚至优化算法的工作也可以交给算法。另一方面，由于目前的加密算法全都依赖于 $\mathsf{NPC}$ 问题的难解性，整个世界的通信可能将会崩溃。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;多项式真的更快吗&#34;
    &gt;
        多项式真的更快吗？
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/cc/#多项式真的更快吗&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 多项式真的更快吗？&#34; href=&#34;#%e5%a4%9a%e9%a1%b9%e5%bc%8f%e7%9c%9f%e7%9a%84%e6%9b%b4%e5%bf%ab%e5%90%97&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;不过，即使证明了 $\mathsf{P}=\mathsf{NP}$，更大的可能是我们什么也做不了。因为我们或许仍不能确定幂次的大小。即使真的给出了算法，$O(n^{100})$ 或许在现阶段与 $O(2^n)$ 没有差别。&lt;/p&gt;
&lt;p&gt;这是另一个话题，多项式实际上不一定比指数快，假如有一个算法的基本操作次数为 $T(n)=2^{1000}n^{2}$，它仍然是多项式的，甚至是 $O(n^2)$ 的，但实际上 $T&amp;rsquo;(n)=\dfrac{2^n}{1000}$ 可能更优。&lt;/p&gt;
&lt;div class=&#34;footnotes&#34; role=&#34;doc-endnotes&#34;&gt;
&lt;hr&gt;
&lt;ol&gt;
&lt;li id=&#34;fn:1&#34;&gt;
&lt;p&gt;在开满优化后，只筛质数，这个“小数据”可以高达 $2\times 10^8.$&amp;#160;&lt;a href=&#34;#fnref:1&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id=&#34;fn:2&#34;&gt;
&lt;p&gt;分解质因数不是判定问题，但也容易改为判定版本（如：$n$ 有超过 $2$ 个质因子）。这里说着简单，就直接用了。&amp;#160;&lt;a href=&#34;#fnref:2&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id=&#34;fn:3&#34;&gt;
&lt;p&gt;曾经提过，但还是再注一次，通常我们将数的长度看做输入规模，因此枚举质因数实际是指数级别的复杂度。&amp;#160;&lt;a href=&#34;#fnref:3&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id=&#34;fn:4&#34;&gt;
&lt;p&gt;ASK 算法是首个不依赖未证明猜想的多项式级别的素性测试算法；Miller-Rabin 尽管更早，但其确定性测试版本的正确性依赖于广义 Riemann 猜想。&amp;#160;&lt;a href=&#34;#fnref:4&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/div&gt;

            </content>   
                                <category scheme="https://weilycoder.github.io/tags/computation" term="computation" label="computation" />
        </entry>
        <entry>
            <title>计算理论基础：语言和图灵机</title>
            <link href="https://weilycoder.github.io/post/turing_machine/" rel="alternate" type="text/html"  hreflang="en" />
            <id>https://weilycoder.github.io/post/turing_machine/</id>
            <published>2024-06-06T08:01:28+08:00</published>
            <updated>2024-06-06T08:01:28+08:00</updated>
            <content type="html">
                &lt;blockquote&gt;
&lt;p&gt;内容基本来自 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org&#34;
&gt;OI-Wiki&lt;/a&gt;。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;什么是图灵机&#34;
    &gt;
        什么是图灵机
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/turing_machine/#什么是图灵机&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 什么是图灵机&#34; href=&#34;#%e4%bb%80%e4%b9%88%e6%98%af%e5%9b%be%e7%81%b5%e6%9c%ba&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;img src=&#34;/turing_machine_model.webp&#34; alt=&#34;图灵机模型&#34; style=&#34;float:right;width:40%&#34;&gt;
&lt;blockquote&gt;
&lt;p&gt;是的，我决定先讲图灵机而非语言&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;图灵机是图灵发明的一个数学模型；通常，它被描述为在一条两端都无限长的纸带上工作的一台机器。图灵机存有一个内部状态，每一个运行时间内，图灵机会根据当前纸带上的内容和内部状态，决定如何改变纸带内容、内部状态以及下一步向左或是向右。如果图灵机当前的状态没有规定如何处理纸带内容，那么图灵机“停机”，如果图灵机停机在预先设定好的状态中，就说图灵机“接受”了当前输入。&lt;/p&gt;
&lt;p&gt;更正式地，我们用一个七元组 $M=\langle Q,\Gamma,b,\Sigma,\delta,q_0,F\rangle$ 描述一个图灵机：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$Q$ 是一个有限非空的&lt;em&gt;状态集合&lt;/em&gt;；&lt;/li&gt;
&lt;li&gt;$\Gamma$ 是一个有限非空的&lt;em&gt;磁带字母表&lt;/em&gt;；&lt;/li&gt;
&lt;li&gt;$b\in \Gamma$ 是&lt;em&gt;空字符&lt;/em&gt;，在磁带上无限频繁地出现；&lt;/li&gt;
&lt;li&gt;$\Sigma\subseteq(\Gamma\setminus \{b\})$ 是&lt;em&gt;输入符号集&lt;/em&gt;，可以出现在初始磁带上作为输入的字符；&lt;/li&gt;
&lt;li&gt;$q_0\in Q$ 是&lt;em&gt;初始状态&lt;/em&gt;；&lt;/li&gt;
&lt;li&gt;$F\subseteq Q$ 是&lt;em&gt;接受状态&lt;/em&gt;，如果图灵机在某个接受状态停机，就说初始磁带上的内容被图灵机接受；&lt;/li&gt;
&lt;li&gt;$\delta: (Q\setminus F)\times \Gamma \not\to Q\times\Gamma\times\{\text{L},\text{R}\}$ 是一个被称作&lt;em&gt;转移函数&lt;/em&gt;的&lt;em&gt;偏函数&lt;sup id=&#34;fnref:1&#34;&gt;&lt;a href=&#34;#fn:1&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;1&lt;/a&gt;&lt;/sup&gt;&lt;/em&gt;，若 $\delta$ 在当前状态下未定义，图灵机停机。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;图灵机从初始状态与纸带起点起，每次根据当前的内部状态 $x$ 和当前磁针指向的纸带上的单元格中的字符 $y$ 进行操作：若 $\delta(x,y)$ 没有定义则停机，否则若 $\delta(x,y)=(a,b,c)$，则将内部状态修改为 $a$，将磁针指向的格子中的字符修改为 $b$，若 $c$ 为 $\text{L}$ 则向左移动一格，为 $\text{R}$ 则向右移动一格。一个不太常见的变体允许“无偏移”，通常用 $\text{N}$ 表示，作为方向集 $\{\text{L},\text{R}\}$ 的第三个元素。&lt;/p&gt;
&lt;p&gt;图灵机的输出用 $M(x)$ 表示，$M(x)=1$ 当且仅当 $M$ 接受 $x$；$M(x)=0$ 当且仅当 $M$ 在有限步内停机且 $M$ 不接受 $x$。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;语言&#34;
    &gt;
        语言
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/turing_machine/#语言&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 语言&#34; href=&#34;#%e8%af%ad%e8%a8%80&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;容易理解的是，对于输入符号集 $\Sigma$ 构成的串的集合 $\Sigma^{\ast}$，只有一部分（或者全部）可以让图灵机接受，这一部分构成 $\Sigma^{\ast}$ 的一个子集，记为 $L$。我们把集合 $L$ 称为字母表 $\Sigma^{\ast}$ 上的一个&lt;em&gt;语言&lt;/em&gt;。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;判定性问题&#34;
    &gt;
        判定性问题
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/turing_machine/#判定性问题&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 判定性问题&#34; href=&#34;#%e5%88%a4%e5%ae%9a%e6%80%a7%e9%97%ae%e9%a2%98&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;反过来说，给定一个字符集上的一个语言，要求图灵机接受所有属于这个语言的串，这种问题被称为&lt;em&gt;判定性问题&lt;/em&gt;。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;功能性问题&#34;
    &gt;
        功能性问题
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/turing_machine/#功能性问题&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 功能性问题&#34; href=&#34;#%e5%8a%9f%e8%83%bd%e6%80%a7%e9%97%ae%e9%a2%98&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;功能性问题的答案不止 YES/NO，可以是一个串或其他；例如，求两个数的和是一个功能性问题。&lt;/p&gt;
&lt;p&gt;判定问题也可以转化为一个功能性问题：求这个问题的指示函数。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;计算机器的局限&#34;
    &gt;
        计算机器的局限
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/turing_machine/#计算机器的局限&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 计算机器的局限&#34; href=&#34;#%e8%ae%a1%e7%ae%97%e6%9c%ba%e5%99%a8%e7%9a%84%e5%b1%80%e9%99%90&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;一个振奋人心的猜测是，对于所有问题（至少是判定问题），我们总能设计一个图灵机，使得这台图灵机可以解决这个问题。遗憾地是，将会看到，这个猜测是错误的。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;图灵机的编码&#34;
    &gt;
        图灵机的编码
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/turing_machine/#图灵机的编码&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 图灵机的编码&#34; href=&#34;#%e5%9b%be%e7%81%b5%e6%9c%ba%e7%9a%84%e7%bc%96%e7%a0%81&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;图灵机可以被自然数编码，即存在满射函数 $f:\mathbb{N}\to \mathbb{M}$。每个自然数都对应一个图灵机，每个图灵机都有无数个编码。因此，由图灵机构成的集合可以看做一个语言。&lt;/p&gt;
&lt;p&gt;$M_\alpha$ 表示自然数 $\alpha$ 编码的图灵机。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;通用图灵机&#34;
    &gt;
        通用图灵机
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/turing_machine/#通用图灵机&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 通用图灵机&#34; href=&#34;#%e9%80%9a%e7%94%a8%e5%9b%be%e7%81%b5%e6%9c%ba&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;存在一台图灵机 $\mathcal U$ 满足：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;若 $M_{\alpha}$ 在输入 $x$ 下在有限时间内停机，则 $\mathcal{U}(x, \alpha)=M_{\alpha}(x)$，否则 $\mathcal{U}(x, \alpha)$ 不会在有限时间内停机；&lt;/li&gt;
&lt;li&gt;如果对于任意 $x\in\{0, 1\}^\ast$，$M_\alpha$ 在输入 $x$ 下在 $T(|x|)$ 时间内停机，则对于任意 $x\in{0, 1}^\ast$，$\mathcal{U}(x, \alpha)$ 在 $O(T(|x|)\log T(|x|))$ 时间内停机。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;即：存在一台通用图灵机，它能模拟任何一台图灵机，且花费的时间只会比这台被模拟的图灵机慢其运行时间的对数。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;图灵不可计算问题&#34;
    &gt;
        图灵不可计算问题
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/turing_machine/#图灵不可计算问题&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 图灵不可计算问题&#34; href=&#34;#%e5%9b%be%e7%81%b5%e4%b8%8d%e5%8f%af%e8%ae%a1%e7%ae%97%e9%97%ae%e9%a2%98&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;有了以上两条知识，我们可以对“可计算性”给出一些解释。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;对于一个判定问题，若存在一个总是在有限步内停机且能够正确进行判定的图灵机，则这个问题是一个&lt;em&gt;图灵可计算&lt;/em&gt;的问题，否则这个问题是一个&lt;em&gt;图灵不可计算&lt;/em&gt;的问题。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;很多人听说过“停机问题”，那是一个经典的图灵不可计算问题；不过，构造并证明它图灵不可计算并非最简的证明方式。&lt;/p&gt;
&lt;p&gt;一个非常简短的说明如下：图灵机可以被自然数编码，因此图灵机的个数是可数无穷；而语言的个数（显然等价于二进制串集合的个数&lt;sup id=&#34;fnref:2&#34;&gt;&lt;a href=&#34;#fn:2&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;2&lt;/a&gt;&lt;/sup&gt;，即自然数的幂集中元素的个数）是不可数无穷。由于一个图灵机只能判定一个语言，故存在图灵不可计算的问题。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h4 id=&#34;停机问题&#34;
    &gt;
        停机问题
    &lt;/h4&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/turing_machine/#停机问题&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 停机问题&#34; href=&#34;#%e5%81%9c%e6%9c%ba%e9%97%ae%e9%a2%98&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;停机问题是一个经典的图灵不可计算问题：给定 $\alpha$ 和 $x$，判定 $M_{\alpha}$ 在输入为 $x$ 时是否会在有限步内停机。&lt;/p&gt;
&lt;p&gt;定义函数 $\mathsf{UC}:\{0,1\}^{\ast}\to \{0,1\}$ 为：
$$\mathsf{UC}(\alpha)=\begin{cases}0,&amp;amp;M_\alpha(\alpha)=1\\1,&amp;amp;\text{otherwise}\end{cases}$$&lt;/p&gt;
&lt;p&gt;先证 $\mathsf{UC}$ 函数是图灵不可计算的：若存在 $M_{\beta}$ 可以计算 $\mathsf{UC}$ 函数，则 $M_{\beta}(\beta)=\mathsf{UC}(\beta)$；但是由 $\mathsf{UC}$ 的定义，$\mathsf{UC}(\beta)=1\Leftrightarrow M_\beta(\beta)\ne 1$，矛盾！&lt;/p&gt;
&lt;p&gt;令 $M_{\mathsf{HALT}}$ 是一台可以解决停机问题的图灵机，$M_{\mathsf{HALT}}(x,\alpha)$ 的值是判定图灵机 $\alpha$ 是否会在输入 $x$ 时在有限步内停机。那么，可以构造一台计算 $\mathsf{UC}$ 的图灵机：$M_{\mathsf{UC}}$ 先调用 $M_{\mathsf{HALT}}$，若 $M_{\mathsf{HALT}}$ 输出 $0$，则输出 $1$；否则，使用通用图灵机模拟计算得到答案。由于$\mathsf{UC}$ 是图灵不可计算的，停机问题也是图灵不可计算的。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;其他型号的机器&#34;
    &gt;
        其他型号的机器
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/turing_machine/#其他型号的机器&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 其他型号的机器&#34; href=&#34;#%e5%85%b6%e4%bb%96%e5%9e%8b%e5%8f%b7%e7%9a%84%e6%9c%ba%e5%99%a8&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;为了更深入地研究问题，人们还设计了许多具有其他功能的机器，不过其中有一部分被证明与图灵机的计算能力相同。&lt;/p&gt;
&lt;p&gt;有趣的是，即使被设计得看似十分强大的机器，也无法解决自己的停机问题。私以为这具有逻辑上奇妙的美感。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;非确定性图灵机&#34;
    &gt;
        非确定性图灵机
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/turing_machine/#非确定性图灵机&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 非确定性图灵机&#34; href=&#34;#%e9%9d%9e%e7%a1%ae%e5%ae%9a%e6%80%a7%e5%9b%be%e7%81%b5%e6%9c%ba&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;非确定性图灵机与普通的图灵机相比，它的转移函数 $\delta$ 可以是多值的。一个很酷的解释是：非确定性图灵机在每次转移时将会“同时”进行若干种不同的转移——就像平行宇宙一样——从而在这些分支“并行”计算。如果“平行宇宙”中一个图灵机在接受状态停机，整台非确定性图灵机就看做接受了这个输入。&lt;/p&gt;
&lt;p&gt;另一个解释是：非确定性图灵机在每次转移时将会“运气极好”地选择将在最少步内接受并停机的分支。&lt;/p&gt;
&lt;p&gt;相对地，普通的图灵机也叫做确定性图灵机。&lt;/p&gt;
&lt;p&gt;实际上，任何确定性图灵机可以用迭代加深的形式在指数级时间模拟一台非确定性图灵机多项式时间内的行为。&lt;/p&gt;
&lt;p&gt;也有定义设定了显式拒绝状态，但是仅当非确定性图灵机在所有分支均拒绝时，才能认为整台非确定性图灵机拒绝。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;计算机&#34;
    &gt;
        计算机
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/turing_machine/#计算机&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 计算机&#34; href=&#34;#%e8%ae%a1%e7%ae%97%e6%9c%ba&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;图灵机与冯·诺依曼计算机解决问题的时间复杂度差别在多项式级别内。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;多磁带图灵机&#34;
    &gt;
        多磁带图灵机
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/turing_machine/#多磁带图灵机&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 多磁带图灵机&#34; href=&#34;#%e5%a4%9a%e7%a3%81%e5%b8%a6%e5%9b%be%e7%81%b5%e6%9c%ba&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;标准的图灵机只能在一条纸带上进行操作；对于一个 $k$ 带图灵机，其中一条纸带是只读的输入带，而剩下的 $k-1$ 条纸带可以进行读写，并且这 $k-1$ 条纸带中还有一条纸带用作输出。&lt;/p&gt;
&lt;p&gt;多带图灵机的纸带数必须是有限的。&lt;/p&gt;
&lt;p&gt;尽管多带图灵机直观上更加强大，实际上标准图灵机只需多二次（$n^2$）的时间即可模拟多带图灵机。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;概率图灵机&#34;
    &gt;
        概率图灵机
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/turing_machine/#概率图灵机&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 概率图灵机&#34; href=&#34;#%e6%a6%82%e7%8e%87%e5%9b%be%e7%81%b5%e6%9c%ba&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;概率图灵机拥有两个转移函数，在每次转移时以独立平等的概率（可以看做抛硬币）选择其中一个——但是没有平行宇宙！&lt;/p&gt;
&lt;p&gt;直观地，在给定的输入和指令状态机上，它可能具有不同的运行时间，或者它可能根本不停止；此外，它可以在一个执行中接受一个输入，而在另一个执行中拒绝相同的输入。&lt;/p&gt;
&lt;p&gt;OI 中，不少算法基于概率，比较经典的例如对大整数的 Miller-Rabin 算法。不过，我们一般可以对成功率进行估计。&lt;/p&gt;
&lt;p&gt;比较理想的情况是：机器可能接受不属于语言 $L$ 的串，但不拒绝属于 $L$ 的串，并且不会不停机；这样我们可以多次运行来保证正确性。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;谕示机&#34;
    &gt;
        谕示机
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/turing_machine/#谕示机&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 谕示机&#34; href=&#34;#%e8%b0%95%e7%a4%ba%e6%9c%ba&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;这种机器相比其他构造更有神秘色彩。谕示机定义了一个黑盒，它可以在一次运算时间内解决一个特定问题，这个问题可以是任何复杂度类，甚至是图灵不可计算问题。&lt;/p&gt;
&lt;p&gt;具有停机问题的预言机的机器可以确定特定的图灵机是否会在特定的输入上停止，但通常它不能确定与自身等效的机器是否会停止。&lt;/p&gt;
&lt;div class=&#34;footnotes&#34; role=&#34;doc-endnotes&#34;&gt;
&lt;hr&gt;
&lt;ol&gt;
&lt;li id=&#34;fn:1&#34;&gt;
&lt;p&gt;&lt;em&gt;partial function&lt;/em&gt;，是只对定义域的一个子集有定义的函数；翻译来自中文维基百科。&amp;#160;&lt;a href=&#34;#fnref:1&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id=&#34;fn:2&#34;&gt;
&lt;p&gt;任何语言都可以编码为 01 串。&amp;#160;&lt;a href=&#34;#fnref:2&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/div&gt;

            </content>   
                                <category scheme="https://weilycoder.github.io/tags/computation" term="computation" label="computation" />
        </entry>
        <entry>
            <title>辗转相除法和裴蜀定理</title>
            <link href="https://weilycoder.github.io/post/bezouts/" rel="alternate" type="text/html"  hreflang="en" />
            <id>https://weilycoder.github.io/post/bezouts/</id>
            <published>2024-06-05T09:04:35+08:00</published>
            <updated>2024-06-05T09:04:35+08:00</updated>
            <content type="html">
                &lt;p&gt;数论基础第二弹！&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;内容基本来自 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org&#34;
&gt;OI-Wiki&lt;/a&gt;。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;辗转相除法&#34;
    &gt;
        辗转相除法
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/bezouts/#辗转相除法&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 辗转相除法&#34; href=&#34;#%e8%be%97%e8%bd%ac%e7%9b%b8%e9%99%a4%e6%b3%95&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;又称欧几里得算法，算法关键在于&lt;/p&gt;
&lt;p&gt;$$
\gcd(a,b)=\gcd(b,a\bmod b).
$$&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;证：不妨设 $a&amp;gt;b,a=qb+r$，则 $r=a\bmod b$，设 $d\mid a,d\mid b$，则 $\dfrac{r}{d}=\dfrac{a}{d}-\dfrac{bk}{d}$。&lt;/p&gt;
&lt;p&gt;由上式，$\dfrac{r}{d}$ 为整数，即 $d\mid r$，所以对 $a,b$ 的公约数，也是 $b,r$ 的公约数。&lt;/p&gt;
&lt;p&gt;反过来，设 $d\mid b,d\mid r$，则 $\dfrac{a}{d}=\dfrac{r}{d}+\dfrac{bk}{d}$。&lt;/p&gt;
&lt;p&gt;显然 $\dfrac{a}{d}$ 是整数，即 $d\mid d$，故 $b,r$ 的公约数也是 $a,b$ 的公约数。&lt;/p&gt;
&lt;p&gt;既然公约数相同，那么最大公约数也相同。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;容易写出递归版：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;gcd&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;a&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;b&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;b&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;?&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;gcd&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;b&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;a&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;b&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;a&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;时间复杂度&#34;
    &gt;
        时间复杂度
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/bezouts/#时间复杂度&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 时间复杂度&#34; href=&#34;#%e6%97%b6%e9%97%b4%e5%a4%8d%e6%9d%82%e5%ba%a6&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;欧几里得算法的最坏时间复杂度为 $O(n)$，这里 $n$ 是输入数据在二进制下的长度。换句话说，复杂度是 $O(\log a)$（默认 $a,b$ 同阶）。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;证：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$a\lt b$ 时，下一次迭代到 $\gcd(b,a);$&lt;/li&gt;
&lt;li&gt;$a\ge b$ 时，下一次迭代到 $\gcd(b,a\bmod b)$，而 $a\bmod b$ 至少让 $a$ 折半，即该过程最多发生 $O(\log a)=O(n)$ 次。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;情况一发生后一定会发生情况二，故前者发生次数不多于后者发生次数。&lt;/p&gt;
&lt;p&gt;因此最多递归 $O(n)$ 次。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;欧几里得算法达到最坏时间复杂度仅当输入数据是斐波那契数列&lt;sup id=&#34;fnref:1&#34;&gt;&lt;a href=&#34;#fn:1&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;1&lt;/a&gt;&lt;/sup&gt;的相邻两项。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;更相减损术&#34;
    &gt;
        更相减损术
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/bezouts/#更相减损术&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 更相减损术&#34; href=&#34;#%e6%9b%b4%e7%9b%b8%e5%87%8f%e6%8d%9f%e6%9c%af&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;由于取模的时间常数高（尤其在高精运算中不可忽视），我们可以利用加减法代替乘除。&lt;/p&gt;
&lt;p&gt;更相减损术的核心是：
$$\gcd(a,b)=\gcd(b,a-b).$$&lt;/p&gt;
&lt;p&gt;注意到若 $a\gg b$，时间开销将不可接受，若能进行高效除以 $2$ 的操作（如位运算），可以进行优化。&lt;/p&gt;
&lt;p&gt;若 $2\mid a,2\mid b$，则 $\gcd(a,b)=2\gcd\left(\dfrac{a}{2},\dfrac{b}{2}\right);$&lt;/p&gt;
&lt;p&gt;不然，若 $2\mid a$（$2\mid b$ 同理），$\gcd(a,b)=\gcd\left(\dfrac{a}{2},b\right).$&lt;/p&gt;
&lt;p&gt;由于两次操作内 $a,b$ 之一必将减半，时间复杂度为 $O(\log a).$&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;裴蜀定理和扩展欧几里得算法&#34;
    &gt;
        裴蜀定理和扩展欧几里得算法
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/bezouts/#裴蜀定理和扩展欧几里得算法&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 裴蜀定理和扩展欧几里得算法&#34; href=&#34;#%e8%a3%b4%e8%9c%80%e5%ae%9a%e7%90%86%e5%92%8c%e6%89%a9%e5%b1%95%e6%ac%a7%e5%87%a0%e9%87%8c%e5%be%97%e7%ae%97%e6%b3%95&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;blockquote&gt;
&lt;p&gt;设 $a,b$ 是不全为零的整数，对任意整数 $x,y$，满足 $\gcd(a,b)\mid ax+by$，且存在整数 $x,y$，使得 $ax+by=\gcd(a,b).$&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;前者显然，后者构造即可，下面进行构造。&lt;/p&gt;
&lt;p&gt;不妨设 $a\ge b,\gcd(a,b)=1$，使用归纳法，若 $b=0$，此时 $a=1$，显然有一组解 $x=1,y=0;$&lt;/p&gt;
&lt;p&gt;不然，假设我们已知 $(a\bmod b,b)$ 为系数时的一组解 $(x_0,y_0)$，尝试推出 $(a,b)$ 为系数的一组解：&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
(a\bmod b)x_0+by_0&amp;amp;=1;\\
(a-\left\lfloor\dfrac{a}{b}\right\rfloor b)x_0+by_0&amp;amp;=1;\\
ax_0+b(y_0-\left\lfloor\dfrac{a}{b}\right\rfloor x_0)&amp;amp;=1.
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;故解为 $(x_0,y_0-\left\lfloor\dfrac{a}{b}\right\rfloor x_0)$，由数学归纳法，对任意 $\gcd(a,b)=1$，均能构造 $(x,y)$ 使 $ax+by=1$，进而原命题得证。&lt;/p&gt;
&lt;p&gt;裴蜀定理的逆定理也成立。&lt;/p&gt;
&lt;p&gt;容易写出代码：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;4
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;5
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;6
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;7
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;8
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;9
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;exgcd&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;a&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;b&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;y&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;!&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;b&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;y&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;a&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;d&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;exgcd&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;b&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;a&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;b&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;y&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;n&#34;&gt;y&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;a&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;/&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;b&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;d&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;由于函数在求最大公因数的过程中计算可行解，这种算法被称作扩展欧几里得算法。&lt;/p&gt;
&lt;p&gt;有时我们担心，扩展欧几里得算法给出的可行解过大，使得变量发生溢出；幸运的是，可以证明，上述算法给出的解满足 $|x|&amp;lt;b,|y|&amp;lt;a.$&lt;/p&gt;
&lt;p&gt;归纳法易证。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;裴蜀定理扩展&#34;
    &gt;
        裴蜀定理扩展
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/bezouts/#裴蜀定理扩展&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 裴蜀定理扩展&#34; href=&#34;#%e8%a3%b4%e8%9c%80%e5%ae%9a%e7%90%86%e6%89%a9%e5%b1%95&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;扩展一n-元一次不定方程&#34;
    &gt;
        扩展一：$n$ 元一次不定方程
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/bezouts/#扩展一n-元一次不定方程&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 扩展一：$n$ 元一次不定方程&#34; href=&#34;#%e6%89%a9%e5%b1%95%e4%b8%80n-%e5%85%83%e4%b8%80%e6%ac%a1%e4%b8%8d%e5%ae%9a%e6%96%b9%e7%a8%8b&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;裴蜀定理可以扩展到 $n$ 元，以三元为例，考虑三元一次不定方程 $ax+by+cz=d.$&lt;/p&gt;
&lt;p&gt;令 $ax+by=(a,b)w$，由二元裴蜀定理，对于所有的 $w\in\mathbb{Z}$，都存在 $a,b\in\mathbb{Z}$ 使等式成立。&lt;/p&gt;
&lt;p&gt;原方程变为 $(a,b)w+cz=d$，由二元裴蜀定理，方程有解当且仅当 $((a,b),c)\mid d$，即 $(a,b,c)\mid d$。&lt;/p&gt;
&lt;p&gt;运用一次扩展欧几里得算法可以构造出一组 $(w,z)$，进而构造一组 $(x,y,z)$。&lt;/p&gt;
&lt;p&gt;类似地，$n$ 元一次不定方程只需运用 $n-1$ 次扩展欧几里得算法即可得到一组解。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;扩展二不定方程的整数解&#34;
    &gt;
        扩展二：不定方程的整数解
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/bezouts/#扩展二不定方程的整数解&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 扩展二：不定方程的整数解&#34; href=&#34;#%e6%89%a9%e5%b1%95%e4%ba%8c%e4%b8%8d%e5%ae%9a%e6%96%b9%e7%a8%8b%e7%9a%84%e6%95%b4%e6%95%b0%e8%a7%a3&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;对于自然数 $a,b$ 和整数 $n$，$a,b$ 互质，考察不定方程&lt;/p&gt;
&lt;p&gt;$$
ax+by=n,
$$&lt;/p&gt;
&lt;p&gt;其中 $x,y$ 为自然数。若方程有解，简称为 $n$ 可以被 $a,b$ 表示。&lt;/p&gt;
&lt;p&gt;记 $C=ab-a-b$，则对任意整数 $n$，$n$ 和 $C-n$ 中，有且仅有一个可以被 $a,b$ 表示；$0$ 可被表示，$C$ 不可被表示；负数不可被表示，大于 $C$ 的数均可被表示。&lt;/p&gt;
&lt;p&gt;考虑证明。&lt;/p&gt;
&lt;p&gt;设方程的一组解为 $(x,y)$，其中 $0\le y\le a-1$，易知这样的 $y$ 是唯一的。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;证明大于 $C$ 的数均能被表示：当 $n&amp;gt;C$，
$$
ax=n-by\gt ab-a-b-by\ge ab-a-b-b(a-1)=-a,
$$&lt;/p&gt;
&lt;p&gt;即 $x&amp;gt;-1$，此时 $x$ 非负。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;证明 $C$ 不可被表示：反证法，设存在自然数 $x,y$ 使 $ax+by=ab-a-b$，则
$$
ab=a(x+1)+b(y+1)
$$&lt;/p&gt;
&lt;p&gt;由 $a,b$ 互质，$x+1$ 被 $b$ 整除，$y+1$ 被 $a$ 整除；故 $a$ 不大于 $y+1$，$b$ 不大于 $x+1$，故
$$
ab=a(x+1)+b(y+1)\ge 2ab,
$$&lt;/p&gt;
&lt;p&gt;矛盾！&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;证明若 $n$ 不可被表示，$C-n$ 可被表示：由于已限定 $0\le y\le a-1$，$x&amp;lt;0$，有
$$
C-n=ab-a-b-ax-by=a(-x-1)+b(a-1-y),
$$&lt;/p&gt;
&lt;p&gt;显然此时 $-x-1,a-1-y$ 均不小于零。&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;div class=&#34;footnotes&#34; role=&#34;doc-endnotes&#34;&gt;
&lt;hr&gt;
&lt;ol&gt;
&lt;li id=&#34;fn:1&#34;&gt;
&lt;p&gt;斐波那契数列，又称兔子数列，定义如下：$f_0=0,f_1=1,f_n=f_{n-1}+f_{n-2}(n&amp;gt;1).$&amp;#160;&lt;a href=&#34;#fnref:1&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/div&gt;
            </content>   
                                <category scheme="https://weilycoder.github.io/tags/math" term="math" label="math" />
        </entry>
        <entry>
            <title>数论基础笔记</title>
            <link href="https://weilycoder.github.io/post/number_theory/" rel="alternate" type="text/html"  hreflang="en" />
            <id>https://weilycoder.github.io/post/number_theory/</id>
            <published>2024-06-03T21:14:39+08:00</published>
            <updated>2024-06-03T21:14:39+08:00</updated>
            <content type="html">
                &lt;blockquote&gt;
&lt;p&gt;内容基本来自 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org&#34;
&gt;OI-Wiki&lt;/a&gt;。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;整除&#34;
    &gt;
        整除
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/number_theory/#整除&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 整除&#34; href=&#34;#%e6%95%b4%e9%99%a4&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;blockquote&gt;
&lt;p&gt;设 $a,b\in\mathbb{Z},a\ne 0.$ 若 $\exists q\in\mathbb{Z}$，使 $b=aq$，那么说 $b$ 可被 $a$ 整除，记作 $a\mid b$；$b$ 不被 $a$ 整除记作 $a\nmid b.$&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;整除的若干性质：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$a\mid b\Leftrightarrow -a\mid b\Leftrightarrow a\mid -b\Leftrightarrow |a|\mid |b|$&lt;/li&gt;
&lt;li&gt;$a\mid b\wedge b\mid c\Rightarrow a\mid c$&lt;/li&gt;
&lt;li&gt;$a\mid b\wedge a\mid c\Leftrightarrow \forall x,y\in\mathbb{Z},a\mid (xb+yc)$&lt;/li&gt;
&lt;li&gt;$a\mid b\wedge b\mid a\Leftrightarrow b=\pm a$&lt;/li&gt;
&lt;li&gt;设 $m=0$，那么 $a\mid b\Leftrightarrow ma\mid mb$&lt;/li&gt;
&lt;li&gt;设 $b\ne 0$，那么 $a\mid b\Rightarrow |a|\le |b|$&lt;/li&gt;
&lt;li&gt;设 $a\ne 0,b=qa+c$，那么 $a\mid b\Leftrightarrow a|c$&lt;/li&gt;
&lt;/ul&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;约数&#34;
    &gt;
        约数
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/number_theory/#约数&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 约数&#34; href=&#34;#%e7%ba%a6%e6%95%b0&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;blockquote&gt;
&lt;p&gt;若 $a\mid b$，则称 $b$ 是 $a$ 的倍数，$a$ 是 $b$ 的约数。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;$0$ 是所有非 $0$ 整数的倍数。对于整数 $b\ne 0$，$b$ 的约数只有有限个。&lt;/p&gt;
&lt;p&gt;平凡约数：对于整数 $b\ne 0$，$\pm 1,\pm b$ 是 $b$ 的平凡约数。当 $b=\pm 1$ 时，$b$ 只有两个平凡约数。&lt;/p&gt;
&lt;p&gt;对于整数 $b\ne 0$，$b$ 的其他约数称为真约数。&lt;/p&gt;
&lt;p&gt;约数的性质：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;设整数 $b\ne 0$，当 $d$ 遍历 $b$ 的全体约数时，$\dfrac{b}{d}$ 也遍历 $b$ 的全体约数。&lt;/li&gt;
&lt;li&gt;设整数 $b\gt 0$，当 $d$ 遍历 $b$ 的全体正约数时，$\dfrac{b}{d}$ 也遍历 $b$ 的全体正约数。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;具体问题中，一般约数指正约数。&lt;/strong&gt;&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;带余除法&#34;
    &gt;
        带余除法
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/number_theory/#带余除法&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 带余除法&#34; href=&#34;#%e5%b8%a6%e4%bd%99%e9%99%a4%e6%b3%95&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;blockquote&gt;
&lt;p&gt;设 $a,b\in \mathbb{Z},a\ne 0.$ 设 $d$ 为给定整数，那么，一定存在唯一整数对 $(q,r)$，满足 $b=qa+r,d\le r\lt |a|+d.$&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;无论 $d$ 取何值，$r$ 统称为余数，$a\mid b$ 等价于 $a\mid r$。&lt;/p&gt;
&lt;p&gt;一般情况，$d$ 取零，此时 $b=qa+r,0\le r\lt |a|$ 称为带余除法。这里的余数 $r$ 称为最小非负余数。&lt;/p&gt;
&lt;p&gt;余数还有几种常见取法：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;绝对最小余数，$d=-\dfrac{|a|}{2}$。&lt;/li&gt;
&lt;li&gt;最小正余数，$d=1$。&lt;/li&gt;
&lt;li&gt;一般只见于编程语言，不定义 $d$，而是令 $q=\left[\dfrac{b}{a}\right]$，这里 $[x]$ 表示 $x$ 向零取整。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;如果没有特殊说明，余数总指最小非负余数。&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;任一整数被正整数 $a$ 除后，余数一定是且仅是 $0$ 到 $(a-1)$ 这 $a$ 个数中的一个；&lt;/li&gt;
&lt;li&gt;相邻 $a$ 个整数被正整数 $a$ 除后，恰好取到上述 $a$ 个余数，特别地，一定有且仅有一个数被 $a$ 整除。&lt;/li&gt;
&lt;/ul&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;最大公约数和最小公倍数&#34;
    &gt;
        最大公约数和最小公倍数
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/number_theory/#最大公约数和最小公倍数&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 最大公约数和最小公倍数&#34; href=&#34;#%e6%9c%80%e5%a4%a7%e5%85%ac%e7%ba%a6%e6%95%b0%e5%92%8c%e6%9c%80%e5%b0%8f%e5%85%ac%e5%80%8d%e6%95%b0&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;blockquote&gt;
&lt;p&gt;一组整数的公约数，是指同时是这组数中每一个数的约数的数。$\pm 1$ 是任意一组整数的公约数。&lt;/p&gt;
&lt;p&gt;一组整数的最大公约数，是指所有公约数里面最大的一个。&lt;/p&gt;
&lt;p&gt;对不全为 $0$ 的整数 $a,b$，将其最大公约数记为 $\gcd(a,b)$，不引起歧义时可简写为 $(a,b)$。&lt;/p&gt;
&lt;p&gt;对不全为 $0$ 的整数 $a_1,\dots,a_n$，将其最大公约数记为 $\gcd(a_1,\dots,a_n)$，不引起歧义时可简写为 $(a_1,\dots,a_n)$。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;一般认为 $0$ 与 $0$ 的最大公约数不存在，但考虑函数实现，也可以定义为 $0$。C++ STL 的实现采用后者。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;一组整数的公倍数，是指同时是这组数中每一个数的倍数的数。$0$ 是任意一组整数的公倍数。&lt;/p&gt;
&lt;p&gt;一组整数的最小公倍数，是指所有正的公倍数里面，最小的一个数。&lt;/p&gt;
&lt;p&gt;对整数 $a,b$，将其最小公倍数记为 $\operatorname{lcm}(a,b)$，不引起歧义时可简写为 $[a,b]$。&lt;/p&gt;
&lt;p&gt;对整数 $a_1,\dots,a_n$，将其最小公倍数记为 $\operatorname{lcm}(a_1,\dots,a_n)$，不引起歧义时可简写为 $[a_1,\dots,a_n]$。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;最大公约数和最小公倍数有如下性质：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$(a_1,\dots,a_n)=(|a_1|,\dots,|a_n|)$；&lt;/li&gt;
&lt;li&gt;$(a,b)=(b,a)$；&lt;/li&gt;
&lt;li&gt;若 $a\ne 0$，则 $(a,0)=(a,a)=|a|$；&lt;/li&gt;
&lt;li&gt;$(bq+r,b)=(r,b)$；&lt;/li&gt;
&lt;li&gt;$(a_1,\dots,a_n)=((a_1,a_2),a_3,\dots,a_n)$；进而 $\forall 1\lt k\lt n-1,~(a_1,\dots,a_n)=((a_1,\dots,a_k),(a_{k+1},\dots,a_n))$；&lt;/li&gt;
&lt;li&gt;对不全为 $0$ 的整数 $a_1,\dots,a_n$ 和非零整数 $m$，$(ma_1,\dots,ma_n)=|m|(a_1,\dots,a_n)$；&lt;/li&gt;
&lt;li&gt;对不全为 $0$ 的整数 $a_1,\dots,a_n$，若 $(a_1,\dots,a_n)=d$，则 $(a_1/d,\dots,a_n/d)=1$；&lt;/li&gt;
&lt;li&gt;$(a^n,b^n)=(a,b)^n$；&lt;/li&gt;
&lt;li&gt;若 $b|ac,(a,b)=1$，则 $b\mid c$；&lt;/li&gt;
&lt;li&gt;若 $b|c,a|c,(a,b)=1$，则 $ab\mid c$；&lt;/li&gt;
&lt;li&gt;若 $(a,b)=1$，则 $(a,bc)=(a,c)$；&lt;/li&gt;
&lt;li&gt;若 $(a_i,b_j)=1,~\forall 1\leq i\leq n,1\leq j\leq m$，则 $\left(\prod_{i} a_i,\prod_{j} b_j\right)=1$；特别地，若 $(a,b)=1$，则 $(a^n,b^m)=1$；&lt;/li&gt;
&lt;li&gt;对整数 $a_1,\dots,a_n$，若 $\exists v\in \mathbb{Z},\prod_i a_i=v^m$，且 $(a_i,a_j)=1,\forall i\ne j$，则 $\forall 1\leq i\leq m,~\sqrt[m]{a_i}\in\mathbb{Z}$；&lt;/li&gt;
&lt;li&gt;$[a_1,\dots,a_n]=[|a_1|,\dots,|a_n|]$；&lt;/li&gt;
&lt;li&gt;$[a,b]=[b,a]$；&lt;/li&gt;
&lt;li&gt;若 $a\ne 0$，则 $[a,1]=[a,a]=|a|$；&lt;/li&gt;
&lt;li&gt;若 $a\mid b$，则 $[a,b]=|b|$；&lt;/li&gt;
&lt;li&gt;$[a_1,\dots,a_n]=[[a_1,a_2],a_3,\dots,a_n]$。进而 $\forall 1\lt k\lt n-1,~[a_1,\dots,a_n]=[[a_1,\dots,a_k],[a_{k+1},\dots,a_n]]$；&lt;/li&gt;
&lt;li&gt;若 $a_i\mid m,~\forall 1\leq i\leq n$，则 $[a_1,\dots,a_n]\mid m$；&lt;/li&gt;
&lt;li&gt;$[ma_1,\dots,ma_n]=|m|[a_1,\dots,a_n]$；&lt;/li&gt;
&lt;li&gt;$[a,b,c][ab,ba,ca]=[a,b][b,c][c,a]$；&lt;/li&gt;
&lt;li&gt;$[a^n,b^n]=[a,b]^n$；&lt;/li&gt;
&lt;li&gt;$(a,b)[a,b]=|ab|$；&lt;/li&gt;
&lt;li&gt;$(ab,bc,ca)[a,b,c]=|abc|$；&lt;/li&gt;
&lt;li&gt;$\dfrac{(a,b,c)^2}{(a,b)(b,c)(a,c)}=\dfrac{[a,b,c]^2}{[a,b][b,c][a,c]}$。&lt;/li&gt;
&lt;/ul&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;质数&#34;
    &gt;
        质数
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/number_theory/#质数&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 质数&#34; href=&#34;#%e8%b4%a8%e6%95%b0&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;blockquote&gt;
&lt;p&gt;设整数 $p\ne 0,\pm 1$，如果 $p$ 除了平凡约数外没有其他约数，称 $p$ 为质数；&lt;/p&gt;
&lt;p&gt;若整数 $a\ne 0,\pm 1$，如果 $a$ 不是质数，称 $a$ 为合数。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;$p$ 与 $-p$ 同为质数或同为合数。&lt;strong&gt;如果没有特殊说明，质数一般限定在正数。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;质数的其他性质可以参考我之前写的 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;/post/miller_rabin/&#34;
&gt;质数及素性判断&lt;/a&gt;，这里不再列出。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;算术基本定理&#34;
    &gt;
        算术基本定理
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/number_theory/#算术基本定理&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 算术基本定理&#34; href=&#34;#%e7%ae%97%e6%9c%af%e5%9f%ba%e6%9c%ac%e5%ae%9a%e7%90%86&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;算术基本引理&#34;
    &gt;
        算术基本引理
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/number_theory/#算术基本引理&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 算术基本引理&#34; href=&#34;#%e7%ae%97%e6%9c%af%e5%9f%ba%e6%9c%ac%e5%bc%95%e7%90%86&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;blockquote&gt;
&lt;p&gt;设 $p$ 为质数，$p\mid a_1a_2$，则 $p\mid a_1$ 和 $p\mid a_2$ 至少有一个成立。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;算术基本定理-1&#34;
    &gt;
        算术基本定理
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/number_theory/#算术基本定理-1&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 算术基本定理&#34; href=&#34;#%e7%ae%97%e6%9c%af%e5%9f%ba%e6%9c%ac%e5%ae%9a%e7%90%86-1&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;又称唯一分解定理。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;设正整数 $a$，必有
$$a=p_1p_2\dots p_s$$&lt;/p&gt;
&lt;p&gt;其中 $p_j(1\le j\le s)$ 是质数。在不计次序意义下，该表示唯一。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;标准素因数分解式&#34;
    &gt;
        标准素因数分解式
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/number_theory/#标准素因数分解式&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 标准素因数分解式&#34; href=&#34;#%e6%a0%87%e5%87%86%e7%b4%a0%e5%9b%a0%e6%95%b0%e5%88%86%e8%a7%a3%e5%bc%8f&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;在上述表示中，将相同的质数合并，
$$a=p_1^{\alpha_1}p_2^{\alpha_2}\dots p_s^{\alpha_s}(p_1\lt p_2\lt\dots\lt p_s),$$&lt;/p&gt;
&lt;p&gt;叫做正整数 $a$ 的标准质因数分解式。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;同余&#34;
    &gt;
        同余
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/number_theory/#同余&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 同余&#34; href=&#34;#%e5%90%8c%e4%bd%99&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;blockquote&gt;
&lt;p&gt;设整数 $m\ne0$。若 $m\mid(a-b)$，称 m 为 模数（模），$a$ 同余于 $b$ 模 $m$，$b$ 是 $a$ 对模 $m$ 的 剩余。记作 $a\equiv b\pmod m$。&lt;/p&gt;
&lt;p&gt;否则，$a$ 不同余于 $b$ 模 m，$b$ 不是 $a$ 对模 $m$ 的剩余。记作 $a\not\equiv b\pmod m$。&lt;/p&gt;
&lt;p&gt;这样的等式，称为模 $m$ 的同余式，简称同余式。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;同余是等价关系，换句话说，同余满足自反性&lt;sup id=&#34;fnref:1&#34;&gt;&lt;a href=&#34;#fn:1&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;1&lt;/a&gt;&lt;/sup&gt;、对称性&lt;sup id=&#34;fnref:2&#34;&gt;&lt;a href=&#34;#fn:2&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;2&lt;/a&gt;&lt;/sup&gt;、传递性&lt;sup id=&#34;fnref:3&#34;&gt;&lt;a href=&#34;#fn:3&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;3&lt;/a&gt;&lt;/sup&gt;。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;数论函数和积性函数&#34;
    &gt;
        数论函数和积性函数
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/number_theory/#数论函数和积性函数&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 数论函数和积性函数&#34; href=&#34;#%e6%95%b0%e8%ae%ba%e5%87%bd%e6%95%b0%e5%92%8c%e7%a7%af%e6%80%a7%e5%87%bd%e6%95%b0&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;数论函数指定义域是正整数的函数，因此也可以视为一个数列。&lt;/p&gt;
&lt;p&gt;积性函数是数论函数的一种，具有特殊的性质。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;若数论函数 $f(n)$ 满足 $f(1)=1$ 且 $\forall a,b\in\mathbb{N},(a,b)=1$ 都有 $f(ab)=f(a)f(b)$，称 $f(n)$ 为&lt;em&gt;积性函数&lt;/em&gt;；&lt;/p&gt;
&lt;p&gt;若数论函数 $f(n)$ 满足 $f(1)=1$ 且 $\forall a,b\in\mathbb{N}$ 都有 $f(ab)=f(a)f(b)$，称 $f(n)$ 为&lt;em&gt;完全积性函数&lt;/em&gt;。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;若 $f(n)$ 和 $g(n)$ 均为积性函数，则下列函数也是积性函数：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$h(n)=f(n^p);$&lt;/li&gt;
&lt;li&gt;$h(n)=f^p(n);$&lt;/li&gt;
&lt;li&gt;$h(n)=f(n)g(n);$&lt;/li&gt;
&lt;li&gt;$h(n)=\sum_{d\mid n}f(d)g\left(\dfrac{n}{d}\right).$&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;其中最后一个形式也记作 $h=f\ast g$，称 $h$ 是 $f$ 和 $g$ 的卷积。&lt;/p&gt;
&lt;div class=&#34;footnotes&#34; role=&#34;doc-endnotes&#34;&gt;
&lt;hr&gt;
&lt;ol&gt;
&lt;li id=&#34;fn:1&#34;&gt;
&lt;p&gt;自反性，即 $a\equiv a\pmod{m}.$&amp;#160;&lt;a href=&#34;#fnref:1&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id=&#34;fn:2&#34;&gt;
&lt;p&gt;对称性，即，若 $a\equiv b\pmod{m}$，则 $b\equiv a\pmod{m}.$&amp;#160;&lt;a href=&#34;#fnref:2&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id=&#34;fn:3&#34;&gt;
&lt;p&gt;传递性，即，若 $a\equiv b\pmod{m},b\equiv c\pmod{m}$，则 $a\equiv c\pmod{m}.$&amp;#160;&lt;a href=&#34;#fnref:3&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/div&gt;

            </content>   
                                <category scheme="https://weilycoder.github.io/tags/math" term="math" label="math" />
        </entry>
        <entry>
            <title>质数及素性判断</title>
            <link href="https://weilycoder.github.io/post/miller_rabin/" rel="alternate" type="text/html"  hreflang="en" />
            <id>https://weilycoder.github.io/post/miller_rabin/</id>
            <published>2024-06-01T21:56:39+08:00</published>
            <updated>2024-06-01T21:56:39+08:00</updated>
            <content type="html">
                &lt;blockquote&gt;
&lt;p&gt;$61$ 是个质数来着；&lt;/p&gt;
&lt;p&gt;$601$ 也是；&lt;/p&gt;
&lt;p&gt;$202406011$ 也是。&lt;/p&gt;
&lt;p&gt;&lt;em&gt;记于 2024 年 6 月 1 日，儿童节&lt;/em&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr&gt;
&lt;blockquote&gt;
&lt;p&gt;部分内容来自 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oi-wiki.org&#34;
&gt;OI-Wiki&lt;/a&gt;。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;质数的定义和若干性质&#34;
    &gt;
        质数的定义和若干性质
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/miller_rabin/#质数的定义和若干性质&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 质数的定义和若干性质&#34; href=&#34;#%e8%b4%a8%e6%95%b0%e7%9a%84%e5%ae%9a%e4%b9%89%e5%92%8c%e8%8b%a5%e5%b9%b2%e6%80%a7%e8%b4%a8&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;通常，我们在正整数上定义质数与合数：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;若正整数 $p\lt 2$ 除了 $1$ 和 $p$ 没有其他正约数，那么称 $p$ 为质数（或素数、不可约数）。&lt;/p&gt;
&lt;p&gt;若正整数 $a\gt 2$ 且 $a$ 不是质数，则称 $a$ 是合数。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;质数有几个值得一提的性质：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;对于合数 $a$，存在质数 $p\le\sqrt{a}$ 使 $p\mid a;$&lt;/li&gt;
&lt;li&gt;所有大于 $3$ 的质数都可表示为 $6n\pm 1;$&lt;/li&gt;
&lt;li&gt;质数有无穷多个。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;另外，在 OI 领域，我们常将答案对质数取模；有时也用大质数作哈希模数。&lt;/p&gt;
&lt;p&gt;我必须在此抱怨一句，不少人在取模数时简单的取自己的手机号或身份证号，我不是说这样不好，实际上我认为随机模数很好，只是这些数大都不是质数，哈希的冲突概率偏大，即使是随机数据也可能出现冲突，甚至多模数也难以补救。&lt;/p&gt;
&lt;p&gt;现在技术已可以快速生成一组固定多模哈希冲突的数据&lt;sup id=&#34;fnref:1&#34;&gt;&lt;a href=&#34;#fn:1&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;1&lt;/a&gt;&lt;/sup&gt;，不必大惊小怪，连 MD5 都已被破解，甚至可以制作可读的 MD5 冲突的 PDF。&lt;/p&gt;
&lt;p&gt;这里公布一些常见质数，OI 赛制中请尽量避免使用它们作为哈希：&lt;/p&gt;
&lt;p&gt;$10^5+3$, $2^{22}\times 5^2+1$, $2^{25}\times 5+1$, $2^{26}\times 7+1$, $2^{23}\times 7\times 17+1$, $10^9+7$, $10^9+9$, $2^{21}\times 479 + 1$, $2^{31}-1$, $2^{61}-1$, $10^{18}+3$.&lt;/p&gt;
&lt;p&gt;而在 CF 这类赛制中，大多情况必须避免固定模数哈希&lt;sup id=&#34;fnref:2&#34;&gt;&lt;a href=&#34;#fn:2&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;2&lt;/a&gt;&lt;/sup&gt;，必要时最好预先随机生成几百个大质数，每次用真随机数初始化梅森旋转，运行时随机选取五到六个质数。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;质数个数&#34;
    &gt;
        质数个数
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/miller_rabin/#质数个数&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 质数个数&#34; href=&#34;#%e8%b4%a8%e6%95%b0%e4%b8%aa%e6%95%b0&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;设 $\pi(x)$ 表示小于或等于 $x$ 的质数的数量，随着 $x$ 的增大，有 $\pi(x)\sim\dfrac{x}{\ln x}$。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h2 id=&#34;素性判定&#34;
    &gt;
        素性判定
    &lt;/h2&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/miller_rabin/#素性判定&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 素性判定&#34; href=&#34;#%e7%b4%a0%e6%80%a7%e5%88%a4%e5%ae%9a&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;暴力判断&#34;
    &gt;
        暴力判断
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/miller_rabin/#暴力判断&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 暴力判断&#34; href=&#34;#%e6%9a%b4%e5%8a%9b%e5%88%a4%e6%96%ad&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;枚举 $(1,\sqrt{n}]$ 内的整数：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;4
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;5
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;6
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kt&#34;&gt;bool&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;is_prime&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;long&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;long&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;long&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;long&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;p&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;p&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;p&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;p&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;p&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;      &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;false&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;true&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;进一步地，为了优化常数，如果 $2\nmid n$，则无需尝试偶数；&lt;/p&gt;
&lt;p&gt;更进一步地，由于大于 $3$ 的质数只能被表为 $6n\pm 1$，在试除 $2,3$ 后，只试除形如 $6n\pm 1$ 的数即可。&lt;/p&gt;
&lt;p&gt;这种方法是 $O(\sqrt{n})$ 的。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;筛法&#34;
    &gt;
        筛法
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/miller_rabin/#筛法&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 筛法&#34; href=&#34;#%e7%ad%9b%e6%b3%95&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;如果 $n$ 的范围不大（如 $\le 2\times 10^8$），我们当然可以用筛法标记范围内所有质数，以便快速查询。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;4
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;long&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;long&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;N&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;!&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;vis&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;long&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;long&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;N&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;      &lt;span class=&#34;n&#34;&gt;vis&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;true&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;这种方法是 $O(n)\sim O(1)$&lt;sup id=&#34;fnref:3&#34;&gt;&lt;a href=&#34;#fn:3&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;3&lt;/a&gt;&lt;/sup&gt; 的。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;素性测试&#34;
    &gt;
        素性测试
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/miller_rabin/#素性测试&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor 素性测试&#34; href=&#34;#%e7%b4%a0%e6%80%a7%e6%b5%8b%e8%af%95&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;那么，如果 $n$ 高达 $10^{18}$ 呢？高达 $10^{1000}$ 呢？&lt;/p&gt;
&lt;p&gt;我们常用的算法是&lt;strong&gt;素性测试：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;确定性测试：绝对确定一个数是否为素数。常见示例包括 Lucas–Lehmer 测试和椭圆曲线素性证明。&lt;/li&gt;
&lt;li&gt;概率性测试：通常比确定性测试快很多，但有可能（尽管概率很小）错误地将合数识别为质数（反之不会）。而通过测试但实际上是合数的数字则被称为&lt;strong&gt;伪素数&lt;/strong&gt;。有许多特定类型的伪素数，最常见的是费马伪素数，它们是满足费马小定理的合数。概率性测试的常见示例包括 Miller–Rabin 测试。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;在 OI 领域，概率性测试更为普遍。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;fermat-测试&#34;
    &gt;
        Fermat 测试
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/miller_rabin/#fermat-测试&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor Fermat 测试&#34; href=&#34;#fermat-%e6%b5%8b%e8%af%95&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;Fermat 测试基于著名的费马小定理，因此得名。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;对于质数 $p$，若 $(a,p)=1$，
$$a^{p-1}\equiv 1\pmod{p}.$$&lt;/p&gt;
&lt;p&gt;证：只需证对任意 $a$ 和质数 $p$，$a^p\equiv a$ 成立。考虑归纳法：&lt;/p&gt;
&lt;p&gt;显然 $1^{p}\equiv 1\pmod{p}$ 成立，假设对 $a\ge1$ 有 $a^p\equiv a$ 成立，则：
$$\begin{aligned}(a+1)^p&amp;amp;\equiv a^p+\binom{p}{1}a^{p-1}+\binom{p}{2}a^{p-2}+\cdots +\binom{p}{p-1}a+1\\&amp;amp;\equiv a+1\pmod{p}\\&amp;amp;&amp;amp;\blacksquare\end{aligned}$$&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;不难想到，对于给定的 $n$，我们不断随机选取 $1\lt a\lt n$，检验是否 $a^{n-1}\equiv 1\pmod{n}$，若有一个不满足，则 $n$ 不是质数，否则，$n$ 大概率是一个质数。&lt;/p&gt;
&lt;p&gt;做 $k$ 轮的时间复杂度为 $O(k\log n)$。&lt;/p&gt;
&lt;p&gt;遗憾地是，这种判别方式正确率不高，事实上，存在一类合数 $n$，对所有 $(a,n)=1$，都有 $a^{n-1}=1$ 成立，这种数叫做 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://oeis.org/A002997&#34;
&gt;Carmichael 数&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;容易证明，Carmichael 数有无穷个，$561=3\times 11\times 17$ 是最小的 Carmichael 数。&lt;/p&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;millerrabin-测试&#34;
    &gt;
        Miller–Rabin 测试
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/miller_rabin/#millerrabin-测试&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor Miller–Rabin 测试&#34; href=&#34;#millerrabin-%e6%b5%8b%e8%af%95&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;Miller–Rabin 素性测试是 Fermat 测试的改进，利用二次探测定理提高判定正确概率。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;对于奇质数 $p$，$x^2\equiv 1\pmod{p}$ 的解只有 $x\equiv 1\pmod{p}$ 和 $x\equiv -1\pmod{p}.$&lt;/p&gt;
&lt;p&gt;只需将方程移项，得 $(x-1)(x+1)=np$，由 $p$ 为奇质数，命题得证。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;我们设 $n-1=u\times 2^t$，先计算 $a^u$，若其与 $1$ 同余，则通过本轮测试；否则，将其平方直到与 $a^{n-1}$，若结果不为 $1$ 或过程中未出现 $-1$，本轮测试不通过。&lt;/p&gt;
&lt;p&gt;如此，我们得到一个较正确的素性测试：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt; 1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 2
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 3
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 4
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 5
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 6
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 7
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 8
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt; 9
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;10
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;11
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;12
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;13
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;14
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;15
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;16
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;17
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;18
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;19
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-Cpp&#34; data-lang=&#34;Cpp&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kt&#34;&gt;bool&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;millerRabin&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;||&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;u&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;t&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;while&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;!&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;u&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;u&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;&amp;gt;=&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;t&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;c1&#34;&gt;// test_time 为测试次数，建议设为不小于 8
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;  &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;test_time&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 无需检查 0, 1, -1
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;a&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;rand&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;()&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;v&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;quickPow&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;a&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;u&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;v&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;continue&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kt&#34;&gt;int&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;s&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;s&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;s&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;t&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;s&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;      &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;v&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;break&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;      &lt;span class=&#34;n&#34;&gt;v&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;long&lt;/span&gt; &lt;span class=&#34;kt&#34;&gt;long&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;v&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;v&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;s&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;t&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;false&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;true&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;进行 $k$ 轮测试的时间复杂度为 $O(k\log n)$。&lt;/p&gt;
&lt;p&gt;值得一提，若广义 Riemann 猜想（generalized Riemann hypothesis, GRH）成立，只需取 $[2,\min\{n-2,\lfloor2\ln^2 n\rfloor\}]$ 内所有整数测试即可&lt;strong&gt;确定&lt;/strong&gt; $n$ 的素性。那么，Miller–Rabin 测试可以看做一个多项式时间&lt;sup id=&#34;fnref:4&#34;&gt;&lt;a href=&#34;#fn:4&#34; class=&#34;footnote-ref&#34; role=&#34;doc-noteref&#34;&gt;4&lt;/a&gt;&lt;/sup&gt;内的素性判断算法。&lt;/p&gt;
&lt;p&gt;在 OI 领域，我们通常对 $[1,2^{64})$ 内的数进行测试。对于 $[1,2^{32})$ 内的数，测试 $\{2,7,61\}$ 即可；对于 $[1,2^{64})$ 内的数，测试 $\{2, 325, 9375, 28178, 450775, 9780504, 1795265022\}$ 即可。&lt;/p&gt;
&lt;p&gt;后者不好记，也可以改为 $\{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37\}$（前 $12$ 个质数）。&lt;/p&gt;
&lt;p&gt;注意测试时要全取一遍，不能只选小于 $n$ 的。&lt;/p&gt;
&lt;p&gt;另外，假设随机取 $k$ 个数作为基，那么错误的概率是 $4^{-k}$。&lt;/p&gt;
&lt;div style=&#34;padding: 25px;&#34; id=&#34;MillerRabinPrimeTest&#34;&gt;
  &lt;p&gt;这里有一个 js 实现的高精度素性测试，使用至少 10 个随机数作为基底：&lt;/p&gt;
  &lt;script src=&#34;/prime_test.js&#34;&gt;&lt;/script&gt;
  Number: &lt;input id=&#34;p&#34; type=&#34;text&#34; onkeyup=&#34;check()&#34; value=&#34;73&#34;&gt; &lt;input type=&#34;button&#34; value=&#34;check&#34; onclick=&#34;check(true)&#34;&gt;
  &lt;p id=&#34;ans&#34;&gt;Answer: is a Prime Number.&lt;/p&gt;
&lt;/div&gt;
&lt;div class=&#34;flex align-center gblog-post__anchorwrap&#34;&gt;
    &lt;h3 id=&#34;millerrabin-测试的基数选取&#34;
    &gt;
        Miller–Rabin 测试的基数选取
    &lt;/h3&gt;
    &lt;a data-clipboard-text=&#34;https://weilycoder.github.io/post/miller_rabin/#millerrabin-测试的基数选取&#34; class=&#34;gblog-post__anchor clip flex align-center&#34; aria-label=&#34;Anchor Miller–Rabin 测试的基数选取&#34; href=&#34;#millerrabin-%e6%b5%8b%e8%af%95%e7%9a%84%e5%9f%ba%e6%95%b0%e9%80%89%e5%8f%96&#34;&gt;
        &lt;svg class=&#34;gblog-icon gblog_link&#34;&gt;&lt;use xlink:href=&#34;#gblog_link&#34;&gt;&lt;/use&gt;&lt;/svg&gt;
    &lt;/a&gt;
&lt;/div&gt;
&lt;p&gt;上文所述的取固定数作为基，可以看作 Miller-Rabin 测试的确定性变体，可以在 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://miller-rabin.appspot.com/#&#34;
&gt;Deterministic variant of the Miller-Rabin primality test&lt;/a&gt; 了解更多信息。&lt;/p&gt;
&lt;p&gt;如果认为多轮测试的常数太大，可以选择随机选取基数，不要选取已知基数的前几项，因为一旦已知或被猜到，容易选择强伪素数进行攻击。例如，假如选择前 $8$ 个质数（而不是前 $12$ 个），那么以下合数都能通过测试：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$341550071728321 = 10670053 \times 32010157$&lt;/li&gt;
&lt;li&gt;$84983557412237221 = 206135341 \times 412270681$&lt;/li&gt;
&lt;li&gt;$230245660726188031 = 214831 \times 787711 \times 1360591$&lt;/li&gt;
&lt;li&gt;$1134931906634489281 = 753303361 \times 1506606721$&lt;/li&gt;
&lt;li&gt;$1144336081150073701 = 756417901 \times 1512835801$&lt;/li&gt;
&lt;li&gt;$1167748053436849501 = 764116501 \times 1528233001$&lt;/li&gt;
&lt;li&gt;$1646697619851137101 = 907385701 \times 1814771401$&lt;/li&gt;
&lt;li&gt;$3825123056546413051 = 149491 \times 747451 \times 34233211$&lt;/li&gt;
&lt;li&gt;$4265186605968234451 = 1032616411 \times 4130465641$&lt;/li&gt;
&lt;li&gt;$5474093792130026911 = 21319 \times 2238391 \times 114712159$&lt;/li&gt;
&lt;li&gt;$7033671664103127781 = 1875322861 \times 3750645721$&lt;/li&gt;
&lt;li&gt;$7361235187296010651 = 412339 \times 2061691 \times 8659099$&lt;/li&gt;
&lt;li&gt;$8276442534101054431 = 209431 \times 3560311 \times 11099791$&lt;/li&gt;
&lt;li&gt;$14688059738864848381 = 2709987061 \times 5419974121$&lt;/li&gt;
&lt;li&gt;$16043083915816662841 = 2832232681 \times 5664465361$&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;其中，$3825123056546413051$ 必须经过 $12$ 轮检验（即前 $12$ 个质数中只有 $37$ 认为它是合数）。&lt;/p&gt;
&lt;p&gt;本文中记录的基数选择经过验证，可以确保正确，不要轻易选择其他固定的基数组合。&lt;/p&gt;
&lt;p&gt;以上伪素数筛选自&lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://www.cecm.sfu.ca/Pseudoprimes/&#34;
&gt;伪素数表&lt;/a&gt;，其中约有 $1.1\times 10^8$ 个质数。&lt;/p&gt;
&lt;div class=&#34;footnotes&#34; role=&#34;doc-endnotes&#34;&gt;
&lt;hr&gt;
&lt;ol&gt;
&lt;li id=&#34;fn:1&#34;&gt;
&lt;p&gt;参阅 &lt;a
  class=&#34;gblog-markdown__link&#34;
  href=&#34;https://heltion.github.io/anti-hash/&#34;
&gt;https://heltion.github.io/anti-hash/&lt;/a&gt;&amp;#160;&lt;a href=&#34;#fnref:1&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id=&#34;fn:2&#34;&gt;
&lt;p&gt;CF 类赛制允许选手提交代码通过部分测试后锁定自己代码（不再编辑），在这之后选手可以查看他人代码并提交 Hack 数据，Hack 成功有奖励；神通广大的选手们可以快速破解如 &lt;code&gt;unordered&lt;/code&gt; 系列的哈希表、多模哈希，他们甚至通过估计评测时间破解使用时间作随机种子的代码。&amp;#160;&lt;a href=&#34;#fnref:2&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id=&#34;fn:3&#34;&gt;
&lt;p&gt;实际上，这段代码的时间复杂度为 $O(n\log\log n)$，不过也确实存在 $O(n)$ 筛出 $n$ 以内质数的算法。&amp;#160;&lt;a href=&#34;#fnref:3&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id=&#34;fn:4&#34;&gt;
&lt;p&gt;一般认为数据的规模为输入数字的位数；如果使用数据本身，这里时间复杂度为 $O(\log^3 n)$。&amp;#160;&lt;a href=&#34;#fnref:4&#34; class=&#34;footnote-backref&#34; role=&#34;doc-backlink&#34;&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/div&gt;
            </content>   
                                <category scheme="https://weilycoder.github.io/tags/math" term="math" label="math" />
        </entry>
</feed>