<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>dianhsuのblog</title>
    <link>https://www.dianhsu.com/</link>
    <copyright>All rights reserved 2026, Dian Hsu</copyright>
    <lastBuildDate>Tue, 22 Sep 2026 05:33:20 GMT</lastBuildDate>
    <generator>Hexo</generator>
    <image>
      <url>https://gravatar.loli.net/avatar/691c0f6ff8700a3f4cc036d75b4cb4d1?s=400</url>
      <title>dianhsuのblog</title>
      <link>https://www.dianhsu.com/</link>
    </image>
    <atom:link href="https://www.dianhsu.com/rss2.xml" rel="self" type="application/rss+xml"/>
    <item>
      <title>武功山徒步</title>
      <link>https://www.dianhsu.com/2025/09/02/wugong-mountains/</link>
      <description>
        <![CDATA[<p>徒步回来已经过去了两周，想起来应该把上次武功山徒步的图片整理一下，做一个记录。并且想在博客里面测试一些图片和视频的支持功能，比如：</p>
<ol>
<li>HDR 图片支持</li>
<li>LivePhoto支持</li>
<li>视频支持</li>
</ol>
<p>这篇文章里面有大量高清原图和视频，使用数据流量的话请谨慎访问（富哥随意）。</p>]]>
      </description>
      <author>Dian Hsu</author>
      <category domain="https://www.dianhsu.com/categories/%E6%97%85%E6%B8%B8/">旅游</category>
      <category domain="https://www.dianhsu.com/tags/%E5%BE%92%E6%AD%A5/">徒步</category>
      <category domain="https://www.dianhsu.com/tags/%E6%97%85%E6%B8%B8/">旅游</category>
      <category domain="https://www.dianhsu.com/tags/%E6%88%B7%E5%A4%96/">户外</category>
      <category domain="https://www.dianhsu.com/tags/%E6%91%84%E5%BD%B1/">摄影</category>
      <pubDate>Tue, 02 Sep 2025 15:04:30 GMT</pubDate>
      <content:encoded>
        <![CDATA[<p>徒步回来已经过去了两周，想起来应该把上次武功山徒步的图片整理一下，做一个记录。并且想在博客里面测试一些图片和视频的支持功能，比如：</p><ol><li>HDR 图片支持</li><li>LivePhoto支持</li><li>视频支持</li></ol><p>这篇文章里面有大量高清原图和视频，使用数据流量的话请谨慎访问（富哥随意）。</p><span id="more"></span><hr /><p>我们走的是反穿武功山的路线，前一天晚上到达萍乡，第一天早上5点多起床，7点准时从龙山村出发。前面走得比较慢，接近11点才走到发云界。很多人在发云界观景台旁边拍照，并且还有一波人背着西瓜上山了，也是🐮。在到发云界的路上，有两匹给发云界送货的骡子。出门旅游看到自己的真实写照 😦 。</p><p><img src="https://cdn.dianhsu.com/static/DSC_0978.JPG" alt="发云界观景台" /><br /><img src="https://cdn.dianhsu.com/static/DSC_0864.JPG" alt="上山的骡子" /><br /><img src="https://cdn.dianhsu.com/static/DSC_0963.JPG" alt="山上垒的石头" /></p><figure class="live-photo-figure" data-alt="绝望坡"><div data-live-photo data-photo-src="https://cdn.dianhsu.com/static/IMG_20250818_151156.avif" data-video-src="https://cdn.dianhsu.com/static/VID_20250818_151156.mov" data-width-percent="90"></div><figcaption aria-hidden="true" class="image-caption" style="margin-top: 4px">绝望坡</figcaption></figure><p><img src="https://cdn.dianhsu.com/static/DSC_0930.JPG" alt="途中风景1" /><br /><img src="https://cdn.dianhsu.com/static/DSC_0959.JPG" alt="途中风景2" /><br /><img src="https://cdn.dianhsu.com/static/DSC_0972.JPG" alt="途中风景3" /><br /><img src="https://cdn.dianhsu.com/static/DSC_1008.JPG" alt="途中风景4" /><br /><img src="https://cdn.dianhsu.com/static/DSC_1142.JPG" alt="第一天傍晚的日落" /><br /><img src="https://cdn.dianhsu.com/static/DSC_1188.JPG" alt="第二天早晨的日出" /></p><figure class="live-photo-figure" data-alt="刚下金顶"><div data-live-photo data-photo-src="https://cdn.dianhsu.com/static/IMG_20250819_065725.avif" data-video-src="https://cdn.dianhsu.com/static/VID_20250819_065724.mov" data-width-percent="90"></div><figcaption aria-hidden="true" class="image-caption" style="margin-top: 4px">刚下金顶</figcaption></figure><figure class="live-photo-figure" data-alt="草木界"><div data-live-photo data-photo-src="https://cdn.dianhsu.com/static/IMG_20250819_081819.avif" data-video-src="https://cdn.dianhsu.com/static/VID_20250819_081819.mov" data-width-percent="90"></div><figcaption aria-hidden="true" class="image-caption" style="margin-top: 4px">草木界</figcaption></figure><p><img src="https://cdn.dianhsu.com/static/IMG_20250819_085055.jpeg" alt="云雾中的草木界" /></p><figure class="post-video-figure" data-width-percent="90" style="width:90%;max-width:1200px;margin:1.2em auto;text-align:center;"><video controls playsinline preload="metadata" style="width:100%;height:auto;display:block;border-radius:4px;background:#000;" title="无人机看草木界"><source src="https://cdn.dianhsu.com/static/VID_20250819_080604.mp4">Your browser does not support the video tag.</video><figcaption aria-hidden="true" class="image-caption" style="margin-top:4px;">无人机看草木界</figcaption></figure>]]>
      </content:encoded>
    </item>
    <item>
      <title>提问的智慧</title>
      <link>https://www.dianhsu.com/2024/01/14/how-to-ask-questions-the-smart-way/</link>
      <description>
        <![CDATA[<h1 id="提问的智慧"><a class="markdownIt-Anchor" href="#提问的智慧"></a> 提问的智慧</h1>
<p><strong>How To Ask Questions The Smart]]>
      </description>
      <author>Dian Hsu</author>
      <category domain="https://www.dianhsu.com/categories/%E6%9D%82%E8%B0%88/">杂谈</category>
      <category domain="https://www.dianhsu.com/tags/%E6%B2%9F%E9%80%9A%E6%8A%80%E5%B7%A7/">沟通技巧</category>
      <category domain="https://www.dianhsu.com/tags/%E6%8F%90%E9%97%AE/">提问</category>
      <pubDate>Sun, 14 Jan 2024 17:13:05 GMT</pubDate>
      <content:encoded>
        <![CDATA[<h1 id="提问的智慧"><a class="markdownIt-Anchor" href="#提问的智慧"></a> 提问的智慧</h1><p><strong>How To Ask Questions The Smart Way</strong></p><p>Copyright © 2001,2006,2014 Eric S. Raymond, Rick Moen</p><p>本指南英文版版权为 Eric S. Raymond, Rick Moen 所有。</p><p>原文网址：<a href="http://www.catb.org/~esr/faqs/smart-questions.html">http://www.catb.org/~esr/faqs/smart-questions.html</a></p><p>Copyleft 2001 by D.H.Grand(nOBODY/Ginux), 2010 by Gasolin, 2015 by Ryan Wu</p><p>本中文指南是基于原文 3.10 版以及 2010 年由 <a href="https://github.com/gasolin">Gasolin</a> 所翻译版本的最新翻译；</p><p>协助指出翻译问题，<strong>请<a href="https://github.com/ryanhanwu/How-To-Ask-Questions-The-Smart-Way/issues/new">发 issue</a>，或直接<a href="https://github.com/ryanhanwu/How-To-Ask-Questions-The-Smart-Way/compare">发 pull request</a> 给我。</strong></p><p>本文另有<a href="https://github.com/ryanhanwu/How-To-Ask-Questions-The-Smart-Way/blob/main/README.md">繁體中文版</a>。</p><h2 id="原文版本历史"><a class="markdownIt-Anchor" href="#原文版本历史"></a> <a href="https://github.com/ryanhanwu/How-To-Ask-Questions-The-Smart-Way/blob/main/history.md">原文版本历史</a></h2><h2 id="目录"><a class="markdownIt-Anchor" href="#目录"></a> 目录</h2><ul><li><a href="#%E6%8F%90%E9%97%AE%E7%9A%84%E6%99%BA%E6%85%A7">提问的智慧</a><ul><li><a href="#%E5%8E%9F%E6%96%87%E7%89%88%E6%9C%AC%E5%8E%86%E5%8F%B2">原文版本历史</a></li><li><a href="#%E7%9B%AE%E5%BD%95">目录</a></li><li><a href="#%E5%A3%B0%E6%98%8E">声明</a></li><li><a href="#%E7%AE%80%E4%BB%8B">简介</a></li><li><a href="#%E5%9C%A8%E6%8F%90%E9%97%AE%E4%B9%8B%E5%89%8D">在提问之前</a></li><li><a href="#%E5%BD%93%E4%BD%A0%E6%8F%90%E9%97%AE%E6%97%B6">当你提问时</a><ul><li><a href="#%E6%85%8E%E9%80%89%E6%8F%90%E9%97%AE%E7%9A%84%E8%AE%BA%E5%9D%9B">慎选提问的论坛</a></li><li><a href="#stack-overflow">Stack Overflow</a></li><li><a href="#%E7%BD%91%E7%AB%99%E5%92%8C-irc-%E8%AE%BA%E5%9D%9B">网站和 IRC 论坛</a></li><li><a href="#%E7%AC%AC%E4%BA%8C%E6%AD%A5%E4%BD%BF%E7%94%A8%E9%A1%B9%E7%9B%AE%E9%82%AE%E4%BB%B6%E5%88%97%E8%A1%A8">第二步，使用项目邮件列表</a></li><li><a href="#%E4%BD%BF%E7%94%A8%E6%9C%89%E6%84%8F%E4%B9%89%E4%B8%94%E6%8F%8F%E8%BF%B0%E6%98%8E%E7%A1%AE%E7%9A%84%E6%A0%87%E9%A2%98">使用有意义且描述明确的标题</a></li><li><a href="#%E4%BD%BF%E9%97%AE%E9%A2%98%E5%AE%B9%E6%98%93%E5%9B%9E%E5%A4%8D">使问题容易回复</a></li><li><a href="#%E4%BD%BF%E7%94%A8%E6%B8%85%E6%99%B0%E6%AD%A3%E7%A1%AE%E7%B2%BE%E5%87%86%E4%B8%94%E5%90%88%E4%B9%8E%E8%AF%AD%E6%B3%95%E7%9A%84%E8%AF%AD%E5%8F%A5">使用清晰、正确、精准且合乎语法的语句</a></li><li><a href="#%E4%BD%BF%E7%94%A8%E6%98%93%E4%BA%8E%E8%AF%BB%E5%8F%96%E4%B8%94%E6%A0%87%E5%87%86%E7%9A%84%E6%96%87%E4%BB%B6%E6%A0%BC%E5%BC%8F%E5%8F%91%E9%80%81%E9%97%AE%E9%A2%98">使用易于读取且标准的文件格式发送问题</a></li><li><a href="#%E7%B2%BE%E7%A1%AE%E5%9C%B0%E6%8F%8F%E8%BF%B0%E9%97%AE%E9%A2%98%E5%B9%B6%E8%A8%80%E4%B9%8B%E6%9C%89%E7%89%A9">精确地描述问题并言之有物</a></li><li><a href="#%E8%AF%9D%E4%B8%8D%E5%9C%A8%E5%A4%9A%E8%80%8C%E5%9C%A8%E7%B2%BE">话不在多而在精</a></li><li><a href="#%E5%88%AB%E5%8A%A8%E8%BE%84%E5%A3%B0%E7%A7%B0%E6%89%BE%E5%88%B0-bug">别动辄声称找到 Bug</a></li><li><a href="#%E4%BD%8E%E5%A3%B0%E4%B8%8B%E6%B0%94%E4%B8%8D%E8%83%BD%E4%BB%A3%E6%9B%BF%E4%BD%A0%E7%9A%84%E5%8A%9F%E8%AF%BE">低声下气不能代替你的功课</a></li><li><a href="#%E6%8F%8F%E8%BF%B0%E9%97%AE%E9%A2%98%E7%97%87%E7%8A%B6%E8%80%8C%E9%9D%9E%E4%BD%A0%E7%9A%84%E7%8C%9C%E6%B5%8B">描述问题症状而非你的猜测</a></li><li><a href="#%E6%8C%89%E5%8F%91%E7%94%9F%E6%97%B6%E9%97%B4%E5%85%88%E5%90%8E%E5%88%97%E5%87%BA%E9%97%AE%E9%A2%98%E7%97%87%E7%8A%B6">按发生时间先后列出问题症状</a></li><li><a href="#%E6%8F%8F%E8%BF%B0%E7%9B%AE%E6%A0%87%E8%80%8C%E4%B8%8D%E6%98%AF%E8%BF%87%E7%A8%8B">描述目标而不是过程</a></li><li><a href="#%E5%88%AB%E8%A6%81%E6%B1%82%E4%BD%BF%E7%94%A8%E7%A7%81%E4%BA%BA%E7%94%B5%E9%82%AE%E5%9B%9E%E5%A4%8D">别要求使用私人电邮回复</a></li><li><a href="#%E6%B8%85%E6%A5%9A%E6%98%8E%E7%A1%AE%E5%9C%B0%E8%A1%A8%E8%BE%BE%E4%BD%A0%E7%9A%84%E9%97%AE%E9%A2%98%E4%BB%A5%E5%8F%8A%E9%9C%80%E6%B1%82">清楚明确地表达你的问题以及需求</a></li><li><a href="#%E8%AF%A2%E9%97%AE%E6%9C%89%E5%85%B3%E4%BB%A3%E7%A0%81%E7%9A%84%E9%97%AE%E9%A2%98%E6%97%B6">询问有关代码的问题时</a></li><li><a href="#%E5%88%AB%E6%8A%8A%E8%87%AA%E5%B7%B1%E5%AE%B6%E5%BA%AD%E4%BD%9C%E4%B8%9A%E7%9A%84%E9%97%AE%E9%A2%98%E8%B4%B4%E4%B8%8A%E6%9D%A5">别把自己家庭作业的问题贴上来</a></li><li><a href="#%E5%8E%BB%E6%8E%89%E6%97%A0%E6%84%8F%E4%B9%89%E7%9A%84%E6%8F%90%E9%97%AE%E5%8F%A5">去掉无意义的提问句</a></li><li><a href="#%E5%8D%B3%E4%BD%BF%E4%BD%A0%E5%BE%88%E6%80%A5%E4%B9%9F%E4%B8%8D%E8%A6%81%E5%9C%A8%E6%A0%87%E9%A2%98%E5%86%99%E7%B4%A7%E6%80%A5">即使你很急也不要在标题写<code>紧急</code></a></li><li><a href="#%E7%A4%BC%E5%A4%9A%E4%BA%BA%E4%B8%8D%E6%80%AA%E8%80%8C%E4%B8%94%E6%9C%89%E6%97%B6%E8%BF%98%E5%BE%88%E6%9C%89%E5%B8%AE%E5%8A%A9">礼多人不怪，而且有时还很有帮助</a></li><li><a href="#%E9%97%AE%E9%A2%98%E8%A7%A3%E5%86%B3%E5%90%8E%E5%8A%A0%E4%B8%AA%E7%AE%80%E7%9F%AD%E7%9A%84%E8%A1%A5%E5%85%85%E8%AF%B4%E6%98%8E">问题解决后，加个简短的补充说明</a></li></ul></li><li><a href="#%E5%A6%82%E4%BD%95%E8%A7%A3%E8%AF%BB%E7%AD%94%E6%A1%88">如何解读答案</a><ul><li><a href="#rtfm-%E5%92%8C-stfw%E5%A6%82%E4%BD%95%E7%9F%A5%E9%81%93%E4%BD%A0%E5%B7%B2%E5%AE%8C%E5%85%A8%E6%90%9E%E7%A0%B8%E4%BA%86">RTFM 和 STFW：如何知道你已完全搞砸了</a></li><li><a href="#%E5%A6%82%E6%9E%9C%E8%BF%98%E6%98%AF%E6%90%9E%E4%B8%8D%E6%87%82">如果还是搞不懂</a></li><li><a href="#%E5%A4%84%E7%90%86%E6%97%A0%E7%A4%BC%E7%9A%84%E5%9B%9E%E5%BA%94">处理无礼的回应</a></li></ul></li><li><a href="#%E5%A6%82%E4%BD%95%E9%81%BF%E5%85%8D%E6%89%AE%E6%BC%94%E5%A4%B1%E8%B4%A5%E8%80%85">如何避免扮演失败者</a></li><li><a href="#%E4%B8%8D%E8%AF%A5%E9%97%AE%E7%9A%84%E9%97%AE%E9%A2%98">不该问的问题</a></li><li><a href="#%E5%A5%BD%E9%97%AE%E9%A2%98%E4%B8%8E%E8%A0%A2%E9%97%AE%E9%A2%98">好问题与蠢问题</a></li><li><a href="#%E5%A6%82%E6%9E%9C%E5%BE%97%E4%B8%8D%E5%88%B0%E5%9B%9E%E7%AD%94">如果得不到回答</a></li><li><a href="#%E5%A6%82%E4%BD%95%E6%9B%B4%E5%A5%BD%E5%9C%B0%E5%9B%9E%E7%AD%94%E9%97%AE%E9%A2%98">如何更好地回答问题</a></li><li><a href="#%E7%9B%B8%E5%85%B3%E8%B5%84%E6%BA%90">相关资源</a></li><li><a href="#%E9%B8%A3%E8%B0%A2">鸣谢</a></li></ul></li></ul><h2 id="声明"><a class="markdownIt-Anchor" href="#声明"></a> 声明</h2><p>许多项目在他们网站的帮助文档中链接了本指南。这很好，这正是我们想要的用途。但如果你是该项目管理员并试图创建指向本指南的超链接，请在超链接附近的显著位置注明：</p><p><strong>本指南不提供此项目的实际支持服务！</strong></p><p>我们已经深刻领教到缺少上述声明所带来的痛苦：我们将不停地被那些认为发布这本指南就意味着有责任解决世上所有技术问题的傻瓜苦苦纠缠。</p><p>如果你因寻求某些帮助而阅读本指南，并在离开时还觉得可以从本文作者这里得到直接帮助，那你就是我们之前说的那些傻瓜之一。别问我们问题，我们只会忽略你。我们在这本指南中想教你如何从那些真正懂得你所遇到的软件或硬件问题的人处取得协助，而 99% 的情况下那不会是我们。除非你确定本指南的作者之一刚好是你所遇到的问题领域的专家，否则请不要打扰我们，这样大家都会开心一点。</p><h2 id="简介"><a class="markdownIt-Anchor" href="#简介"></a> 简介</h2><p>在<a href="http://www.catb.org/~esr/faqs/hacker-howto.html">黑客</a>的世界里，你所提技术问题的解答的好坏, 很大程度上取决于你提问的方式与此问题的难度。本指南将教你如何正确地提问以获得你满意的答案。</p><p>现在开源（Open Source）软件已经相当盛行，您通常可以从其他更有经验的用户那里获得与黑客一样好的答案，这是件<strong>好事</strong>；和黑客相比，用户们往往对那些新手常遇到的问题更宽容一些。尽管如此，以我们在此推荐的方式对待这些有经验的用户通常也是从他们那里获得有用答案的最有效方式。</p><p>首先你应该明白，黑客们喜爱有挑战性的问题，或者能激发他们思维的好问题。如果我们并非如此，那我们也不会成为你想询问的对象。如果你给了我们一个值得反复咀嚼玩味的好问题，我们自会对你感激不尽。好问题是激励，是厚礼。好问题可以提高我们的理解力，而且通常会暴露我们以前从没意识到或者思考过的问题。对黑客而言，“好问题！”是诚挚的大力称赞。</p><p>尽管如此，黑客们有着蔑视或傲慢面对简单问题的坏名声，这有时让我们看起来对新手、无知者似乎较有敌意，但其实不是那样的。</p><p>我们不讳言我们对那些不愿思考、或者在发问前不做他们该做的事的人的蔑视。那些人是时间杀手 —— 他们只想索取，从不付出，消耗我们可用在更有趣的问题或更值得回答的人身上的时间。我们称这样的人为 <code>失败者（loser）</code> （由于历史原因，我们有时把它拼作 <code>lusers</code>）。</p><p>我们意识到许多人只是想使用我们写的软件，他们对学习技术细节没有兴趣。对大多数人而言，电脑只是种工具，是种达到目的的手段而已。他们有自己的生活并且有更要紧的事要做。我们认可这点，也从不指望每个人都对这些让我们着迷的技术问题感兴趣。尽管如此，我们只为那些真正有兴趣并愿意积极参与问题解决的人调整回答问题的风格。这点不会变，也不该变：否则，我们就是在最擅长的事情上降低效率。</p><p>我们（在很大程度上）是自愿的，从繁忙的生活中抽出时间来解答疑惑，而且时常被提问淹没。所以我们无情地滤掉一些话题，特别是拋弃那些看起来像失败者的家伙，以便更高效地利用时间来回答<code>赢家（winner）</code>的问题。</p><p>如果你厌恶我们的态度，高高在上，或过于傲慢，不妨也设身处地想想。我们并没有要求你向我们屈服 —— 事实上，我们大多数人非常乐意与你平等地交流，只要你付出小小努力来满足基本要求，我们就会欢迎你加入我们的文化。但让我们帮助那些不愿意帮助自己的人是没有效率的。无知没有关系，但装白痴就是不行。</p><p>所以，你不必在技术上很在行才能吸引我们的注意，但你必须表现出能引导你变得在行的特质 —— 机敏、有想法、善于观察、乐于主动参与解决问题。如果你做不到这些使你与众不同的事情，我们建议你花点钱找家商业公司签个技术支持服务合同，而不是要求黑客个人无偿地帮助你。</p><p>如果你决定向我们求助，当然你也不希望被视为失败者，更不愿成为失败者中的一员。能立刻得到快速并有效答案的最好方法，就是像赢家那样提问 —— 聪明、自信、有解决问题的思路，只是偶尔在特定的问题上需要获得一点帮助。</p><p>（欢迎对本指南提出改进意见。你可以把你的建议发送至 <a href="esr@thyrsus.com">esr@thyrsus.com</a> 或 <a href="respond-auto@linuxmafia.com">respond-auto@linuxmafia.com</a>。然而请注意，本文并非<a href="http://www.ietf.org/rfc/rfc1855.txt">网络礼节</a>的通用指南，而我们通常会拒绝无助于在技术论坛得到有用答案的建议）。</p><h2 id="在提问之前"><a class="markdownIt-Anchor" href="#在提问之前"></a> 在提问之前</h2><p>在你准备要通过电子邮件、新闻群组或者聊天室提出技术问题前，请先做到以下事情：</p><ol><li>尝试在你准备提问的论坛的旧文章中搜索答案。</li><li>尝试上网搜索以找到答案。</li><li>尝试阅读手册以找到答案。</li><li>尝试阅读常见问题文件（FAQ）以找到答案。</li><li>尝试自己检查或试验以找到答案。</li><li>向你身边的强者朋友打听以找到答案。</li><li>如果你是程序开发者，请尝试阅读源代码以找到答案。</li></ol><p>当你提出问题的时候，请先表明你已经做了上述的努力；这将有助于树立你并不是一个不劳而获且浪费别人的时间的提问者。如果你能一并表达在做了上述努力的过程中所<strong>学到</strong>的东西会更好，因为我们更乐于回答那些表现出能从答案中学习的人的问题。</p><p>运用某些策略，比如先用 Google 搜索你所遇到的各种错误信息（搜索 <a href="http://groups.google.com/">Google 论坛</a>和网页），这样很可能直接就找到了能解决问题的文件或邮件列表线索。即使没有结果，在邮件列表或新闻组寻求帮助时加上一句 <code>我在 Google 中搜过下列句子但没有找到什么有用的东西</code> 也是件好事，即使它只是表明了搜索引擎不能提供哪些帮助。这么做（加上搜索过的字串）也让遇到相似问题的其他人能被搜索引擎引导到你的提问来。</p><p>别着急，不要指望几秒钟的 Google 搜索就能解决一个复杂的问题。在向专家求助之前，再阅读一下常见问题文件（FAQ）、放轻松、坐得舒服一些，再花点时间思考一下这个问题。相信我们，他们能从你的提问看出你做了多少阅读与思考，如果你是有备而来，将更有可能得到解答。不要将所有问题一股脑拋出，只因你的第一次搜索没有找到答案（或者找到太多答案）。</p><p>准备好你的问题，再将问题仔细地思考过一遍，因为草率的发问只能得到草率的回答，或者根本得不到任何答案。越是能表现出在寻求帮助前你为解决问题所付出的努力，你越有可能得到实质性的帮助。</p><p>小心别问错了问题。如果你的问题基于错误的假设，某个普通黑客（J. Random Hacker）多半会一边在心里想着<code>蠢问题…</code>，一边用无意义的字面解释来答复你，希望着你会从问题的回答（而非你想得到的答案）中汲取教训。</p><p>绝不要自以为<strong>够格</strong>得到答案，你没有；你并没有。毕竟你没有为这种服务支付任何报酬。你将会是自己去<strong>挣到</strong>一个答案，靠提出有内涵的、有趣的、有思维激励作用的问题 —— 一个有潜力能贡献社区经验的问题，而不仅仅是被动地从他人处索取知识。</p><p>另一方面，表明你愿意在找答案的过程中做点什么是一个非常好的开端。<code>谁能给点提示？</code>、<code>我的这个例子里缺了什么？</code>以及<code>我应该检查什么地方</code>比<code>请把我需要的确切的过程贴出来</code>更容易得到答复。因为你表现出只要有人能指个正确方向，你就有完成它的能力和决心。</p><h2 id="当你提问时"><a class="markdownIt-Anchor" href="#当你提问时"></a> 当你提问时</h2><h3 id="慎选提问的论坛"><a class="markdownIt-Anchor" href="#慎选提问的论坛"></a> 慎选提问的论坛</h3><p>小心选择你要提问的场合。如果你做了下述的事情，你很可能被忽略掉或者被看作失败者：</p><ul><li>在与主题不合的论坛上贴出你的问题。</li><li>在探讨进阶技术问题的论坛张贴非常初级的问题；反之亦然。</li><li>在太多的不同新闻群组上重复转贴同样的问题（cross-post）。</li><li>向既非熟人也没有义务解决你问题的人发送私人电邮。</li></ul><p>黑客会剔除掉那些搞错场合的问题，以保护他们沟通的渠道不被无关的东西淹没。你不会想让这种事发生在自己身上的。</p><p>因此，第一步是找到对的论坛。再说一次，Google 和其它搜索引擎还是你的朋友，用它们来找到与你遭遇到困难的软硬件问题最相关的网站。通常那儿都有常见问题（FAQ）、邮件列表及相关说明文件的链接。如果你的努力（包括<strong>阅读</strong> FAQ）都没有结果，网站上也许还有报告 Bug（Bug-reporting）的流程或链接，如果是这样，链过去看看。</p><p>向陌生的人或论坛发送邮件最可能是风险最大的事情。举例来说，别假设一个提供丰富内容的网页的作者会想充当你的免费顾问。不要对你的问题是否会受到欢迎做太乐观的估计 —— 如果你不确定，那就向别处发送，或者压根别发。</p><p>在选择论坛、新闻群组或邮件列表时，别太相信它的名字，先看看 FAQ 或者许可书以弄清楚你的问题是否切题。发文前先翻翻已有的话题，这样可以让你感受一下那里的文化。事实上，事先在新闻组或邮件列表的历史记录中搜索与你问题相关的关键词是个极好的主意，也许这样就找到答案了。即使没有，也能帮助你归纳出更好的问题。</p><p>别像机关枪似的一次“扫射”所有的帮助渠道，这就像大喊大叫一样会使人不快。要一个一个地来。</p><p>搞清楚你的主题！最典型的错误之一是在某种致力于跨平台可移植的语言、套件或工具的论坛中提关于 Unix 或 Windows 操作系统程序界面的问题。如果你不明白为什么这是大错，最好在搞清楚这之间差异之前什么也别问。</p><p>一般来说，在仔细挑选的公共论坛中提问，会比在私有论坛中提同样的问题更容易得到有用的回答。有几个理由可以支持这点，一是看潜在的回复者有多少，二是看观众有多少。黑客较愿意回答那些能帮助到许多人的问题。</p><p>可以理解的是，老练的黑客和一些热门软件的作者正在接受过多的错发信息。就像那根最后压垮骆驼背的稻草一样，你的加入也有可能使情况走向极端 —— 已经好几次了，一些热门软件的作者由于涌入其私人邮箱的大量不堪忍受的无用邮件而不再提供支持。</p><h3 id="stack-overflow"><a class="markdownIt-Anchor" href="#stack-overflow"></a> Stack Overflow</h3><p>搜索，<em>然后</em>在 Stack Exchange 问。</p><p>近年来，Stack Exchange 社区已经成为回答技术及其他问题的主要渠道，尤其是那些开放源码的项目。</p><p>因为 Google 索引是即时的，在看 Stack Exchange 之前先在 Google 搜索。有很高的几率某人已经问了一个类似的问题，而且 Stack Exchange 网站们往往会是搜索结果中最前面几个。如果你在 Google 上没有找到任何答案，你再到特定相关主题的网站去找。用标签（Tag）搜索能让你更缩小你的搜索结果。</p><p>如果你还是找不到任何对你的问题有用的内容，请把你的问题发在与它最相关的网站上。提问的时候请善用格式化工具，尤其注意为代码添加格式，并且添加相关的标签（特别是编程语言、操作系统或库/包的名称）。当有人要求你提供更多相关信息时，请编辑你的贴子来补充它们[译注：而不是发一个回帖或回答！]。如果你觉得一个答案对你有帮助，点击向上的箭头来为它投票；如果一个答案提供了问题的正确解决方案，点击投票按钮下方的对勾来将它标记为正解。</p><p>Stack Exchange 已经成长到<a href="https://stackexchange.com/sites">超过一百个网站</a>，以下是最常用的几个站：</p><ul><li>Super User 是问一些通用的电脑问题，如果你的问题跟代码或是写程序无关，只是一些网络连线之类的，请到这里。</li><li>Stack Overflow 是问写程序有关的问题。</li><li>Server Fault 是问服务器和网管相关的问题。</li></ul><h3 id="网站和-irc-论坛"><a class="markdownIt-Anchor" href="#网站和-irc-论坛"></a> 网站和 IRC 论坛</h3><p>本地的用户群组（user group），或者你所用的 Linux 发行版本也许正在宣传他们的网页论坛或 IRC 频道，并提供新手帮助（在一些非英语国家，新手论坛很可能还是邮件列表），这些都是开始提问的好地方，特别是当你觉得遇到的也许只是相对简单或者很普通的问题时。有广告赞助的 IRC 频道是公开欢迎提问的地方，通常可以即时得到回应。</p><p>事实上，如果程序出的问题只发生在特定 Linux 发行版提供的版本（这很常见），最好先去该发行版的论坛或邮件列表中提问，再到程序本身的论坛或邮件列表提问。（否则）该项目的黑客可能仅仅回复“使用<strong>我们的</strong>版本”。</p><p>在任何论坛发文以前，先确认一下有没有搜索功能。如果有，就试着搜索一下问题的几个关键词，也许这会有帮助。如果在此之前你已做过通用的网页搜索（你也该这样做），还是再搜索一下论坛，搜索引擎有可能没来得及索引此论坛的全部内容。</p><p>通过论坛或 IRC 频道来提供用户支持服务有增长的趋势，电子邮件则大多为项目开发者间的交流而保留。所以最好先在论坛或 IRC 中寻求与该项目相关的协助。</p><p>在使用 IRC 的时候，首先最好不要发布很长的问题描述，有些人称之为频道洪水。最好通过一句话的问题描述来开始聊天。</p><h3 id="第二步使用项目邮件列表"><a class="markdownIt-Anchor" href="#第二步使用项目邮件列表"></a> 第二步，使用项目邮件列表</h3><p>当某个项目提供开发者邮件列表时，要向列表而不是其中的个别成员提问，即使你确信他能最好地回答你的问题。查一查项目的文件和首页，找到项目的邮件列表并使用它。有几个很好的理由支持我们采用这种办法：</p><ul><li>任何好到需要向个别开发者提出的问题，也将对整个项目群组有益。反之，如果你认为自己的问题对整个项目群组来说太愚蠢，那这也不能成为骚扰个别开发者的理由。</li><li>向列表提问可以分散开发者的负担，个别开发者（尤其是项目领导人）也许太忙以至于没法回答你的问题。</li><li>大多数邮件列表都会被存档，那些被存档的内容将被搜索引擎索引。如果你向列表提问并得到解答，将来其他人可以通过网页搜索找到你的问题和答案，也就不用再次发问了。</li><li>如果某些问题经常被问到，开发者可以利用此信息来改进说明文件或软件本身，以使其更清楚。如果只是私下提问，就没有人能看到最常见问题的完整场景。</li></ul><p>如果一个项目既有“用户”也有“开发者”（或“黑客”）邮件列表或论坛，而你又不会动到那些源代码，那么就向“用户”列表或论坛提问。不要假设自己会在开发者列表中受到欢迎，那些人多半会将你的提问视为干扰他们开发的噪音。</p><p>然而，如果你<strong>确信</strong>你的问题很特别，而且在“用户”列表或论坛中几天都没有回复，可以试试前往“开发者”列表或论坛发问。建议你在张贴前最好先暗地里观察几天以了解那里的行事方式（事实上这是参与任何私有或半私有列表的好主意）</p><p>如果你找不到一个项目的邮件列表，而只能查到项目维护者的电子邮件地址，尽管向他发信。即使是在这种情况下，也别假设（项目）邮件列表不存在。在你的电子邮件中，请陈述你已经试过但没有找到合适的邮件列表，也提及你不反对将自己的邮件转发给他人（许多人认为，即使没什么秘密，私人电子邮件也不应该被公开。通过允许将你的电子邮件转发他人，你给了相应人员处置你邮件的选择）。</p><h3 id="使用有意义且描述明确的标题"><a class="markdownIt-Anchor" href="#使用有意义且描述明确的标题"></a> 使用有意义且描述明确的标题</h3><p>在邮件列表、新闻群组或论坛中，大约 50 字以内的标题是抓住资深专家注意力的好机会。别用喋喋不休的<code>帮帮忙</code>、<code>跪求</code>、<code>急</code>（更别说<code>救命啊！！！！</code>这样让人反感的话，用这种标题会被条件反射式地忽略）来浪费这个机会。不要妄想用你的痛苦程度来打动我们，而应该是在这点空间中使用极简单扼要的描述方式来提出问题。</p><p>一个好标题范例是<code>目标 —— 差异</code>式的描述，许多技术支持组织就是这样做的。在<code>目标</code>部分指出是哪一个或哪一组东西有问题，在<code>差异</code>部分则描述与期望的行为不一致的地方。</p><blockquote><p>蠢问题：救命啊！我的笔记本电脑不能正常显示了！</p></blockquote><blockquote><p>聪明问题：<a href="http://X.org">X.org</a> 6.8.1 的鼠标指针会变形，某牌显卡 MV1005 芯片组。</p></blockquote><blockquote><p>更聪明问题：<a href="http://X.org">X.org</a> 6.8.1 的鼠标指针，在某牌显卡 MV1005 芯片组环境下 - 会变形。</p></blockquote><p>编写<code>目标 —— 差异</code> 式描述的过程有助于你组织对问题的细致思考。是什么被影响了？ 仅仅是鼠标指针或者还有其它图形？只在 <a href="http://X.org">X.org</a> 的 X 版中出现？或只是出现在 6.8.1 版中？ 是针对某牌显卡芯片组？或者只是其中的 MV1005 型号？ 一个黑客只需瞄一眼就能够立即明白你的环境<strong>和</strong>你遇到的问题。</p><p>总而言之，请想像一下你正在一个只显示标题的存档讨论串（Thread）索引中查寻。让你的标题更好地反映问题，可使下一个搜索类似问题的人能够关注这个讨论串，而不用再次提问相同的问题。</p><p>如果你想在回复中提出问题，记得要修改内容标题，以表明你是在问一个问题， 一个看起来像 <code>Re: 测试</code> 或者 <code>Re: 新 bug</code> 的标题很难引起足够重视。另外，在不影响连贯性之下，适当引用并删减前文的内容，能给新来的读者留下线索。</p><p>对于讨论串，不要直接点击回复来开始一个全新的讨论串，这将限制你的观众。因为有些邮件阅读程序，比如 mutt ，允许用户按讨论串排序并通过折叠讨论串来隐藏消息，这样做的人永远看不到你发的消息。</p><p>仅仅改变标题还不够。mutt 和其它一些邮件阅读程序还会检查邮件标题以外的其它信息，以便为其指定讨论串。所以宁可发一个全新的邮件。</p><p>在网页论坛上，好的提问方式稍有不同，因为讨论串与特定的信息紧密结合，并且通常在讨论串外就看不到里面的内容，故通过回复提问，而非改变标题是可接受的。不是所有论坛都允许在回复中出现分离的标题，而且这样做了基本上没有人会去看。不过，通过回复提问，这本身就是暧昧的做法，因为它们只会被正在查看该标题的人读到。所以，除非你<strong>只想</strong>在该讨论串当前活跃的人群中提问，不然还是另起炉灶比较好。</p><h3 id="使问题容易回复"><a class="markdownIt-Anchor" href="#使问题容易回复"></a> 使问题容易回复</h3><p>以<code>请将你的回复发送到……</code>来结束你的问题多半会使你得不到回答。如果你觉得花几秒钟在邮件客户端设置一下回复地址都麻烦，我们也觉得花几秒钟思考你的问题更麻烦。如果你的邮件程序不支持这样做，<a href="http://linuxmafia.com/faq/Mail/muas.html">换个好点的</a>；如果是操作系统不支持这种邮件程序，也换个好点的。</p><p>在论坛，要求通过电子邮件回复是非常无礼的，除非你认为回复的信息可能比较敏感（有人会为了某些未知的原因，只让你而不是整个论坛知道答案）。如果你只是想在有人回复讨论串时得到电子邮件提醒，可以要求网页论坛发送给你。几乎所有论坛都支持诸如<code>追踪此讨论串</code>、<code>有回复时发送邮件提醒</code>等功能。</p><h3 id="a-name使用清晰-正确-精准且合乎语法的语句使用清晰-正确-精准且合乎语法的语句a"><a class="markdownIt-Anchor" href="#a-name使用清晰-正确-精准且合乎语法的语句使用清晰-正确-精准且合乎语法的语句a"></a> <a name="使用清晰、正确、精准且合乎语法的语句">使用清晰、正确、精准且合乎语法的语句</a></h3><p>我们从经验中发现，粗心的提问者通常也会粗心地写程序与思考（我敢打包票）。回答粗心大意者的问题很不值得，我们宁愿把时间耗在别处。</p><p>正确的拼写、标点符号和大小写是很重要的。一般来说，如果你觉得这样做很麻烦，不想在乎这些，那我们也觉得麻烦，不想在乎你的提问。花点额外的精力斟酌一下字句，用不着太僵硬与正式 —— 事实上，黑客文化很看重能准确地使用非正式、俚语和幽默的语句。但它<strong>必须很</strong>准确，而且有迹象表明你是在思考和关注问题。</p><p>正确地拼写、使用标点和大小写，不要将<code>its</code>混淆为<code>it's</code>，<code>loose</code>搞成<code>lose</code>或者将<code>discrete</code>弄成<code>discreet</code>。不要<strong>全部用大写</strong>，这会被视为无礼的大声嚷嚷（全部小写也好不到哪去，因为不易阅读。<a href="http://en.wikipedia.org/wiki/Alan_Cox">Alan Cox</a> 也许可以这样做，但你不行）。</p><p>更白话的说，如果你写得像是个半文盲[译注：<a href="http://zh.wikipedia.org/wiki/%E5%B0%8F%E7%99%BD">小白</a>]，那多半得不到理睬。也不要使用即时通信中的简写或<a href="http://zh.wikipedia.org/wiki/%E7%81%AB%E6%98%9F%E6%96%87">火星文</a>，如将<code>的</code>简化为<code>d</code>会使你看起来像一个为了少打几个键而省字的小白。更糟的是，如果像个小孩似地鬼画符那绝对是在找死，可以肯定没人会理你（或者最多是给你一大堆指责与挖苦）。</p><p>如果在使用非母语的论坛提问，你可以犯点拼写和语法上的小错，但决不能在思考上马虎（没错，我们通常能弄清两者的分别）。同时，除非你知道回复者使用的语言，否则请使用英语书写。繁忙的黑客一般会直接删除用他们看不懂的语言写的消息。在网络上英语是通用语言，用英语书写可以将你的问题在尚未被阅读就被直接删除的可能性降到最低。</p><p>如果英文是你的外语（Second language），提示潜在回复者你有潜在的语言困难是很好的：<br />[译注：以下附上原文以供使用]</p><blockquote><p>English is not my native language; please excuse typing errors.</p></blockquote><ul><li>英文不是我的母语，请原谅我的错字或语法。</li></ul><blockquote><p>If you speak $LANGUAGE, please email/PM me;<br />I may need assistance translating my question.</p></blockquote><ul><li>如果你说<strong>某语言</strong>，请向我发电邮/私信；</li><li>我需要有人协助我翻译我的问题。</li></ul><blockquote><p>I am familiar with the technical terms,<br />but some slang expressions and idioms are difficult for me.</p></blockquote><ul><li>我对技术名词很熟悉，但对于俗语或是特别用法不甚了解。</li></ul><blockquote><p>I’ve posted my question in $LANGUAGE and English.<br />I’ll be glad to translate responses, if you only use one or the other.</p></blockquote><ul><li>我把我的问题用<strong>某语言</strong>和英文写出来。</li><li>如果你只用其中的一种语言回答，我会乐意将回复翻译成为你使用的语言。</li></ul><h3 id="使用易于读取且标准的文件格式发送问题"><a class="markdownIt-Anchor" href="#使用易于读取且标准的文件格式发送问题"></a> 使用易于读取且标准的文件格式发送问题</h3><p>如果你人为地将问题搞得难以阅读，它多半会被忽略，人们更愿读易懂的问题，所以：</p><ul><li>使用纯文字而不是 HTML (<a href="http://archive.birdhouse.org/etc/evilmail.html">关闭 HTML</a> 并不难）。</li><li>使用 MIME 附件通常是可以的，前提是真正有内容（譬如附带的源代码或 patch），而不仅仅是邮件程序生成的模板（譬如只是信件内容的拷贝）。</li><li>不要发送一段文字只是一行句子但自动换行后会变成多行的邮件（这使得回复部分内容非常困难）。设想你的读者是在 80 个字符宽的终端机上阅读邮件，最好设置你的换行分割点小于 80 字。</li><li>但是，对一些特殊的文件<strong>不要</strong>设置固定宽度（譬如日志文件拷贝或会话记录）。数据应该原样包含，让回复者有信心他们看到的是和你看到的一样的东西。</li><li>在英语论坛中，不要使用<code>Quoted-Printable</code> MIME 编码发送消息。这种编码对于张贴非 ASCII 语言可能是必须的，但很多邮件程序并不支持这种编码。当它们处理换行时，那些文本中四处散布的<code>=20</code>符号既难看也分散注意力，甚至有可能破坏内容的语意。</li><li>绝对，<strong>永远</strong>不要指望黑客们阅读使用封闭格式编写的文档，像微软公司的 Word 或 Excel 文件等。大多数黑客对此的反应就像有人将还在冒热气的猪粪倒在你家门口时你的反应一样。即便他们能够处理，他们也很厌恶这么做。</li><li>如果你从使用 Windows 的电脑发送电子邮件，关闭微软愚蠢的<code>智能引号</code>功能 （从[选项] &gt; [校订] &gt; [自动校正选项]，勾选掉<code>智能引号</code>单选框），以免在你的邮件中到处散布垃圾字符。</li><li>在论坛，勿滥用<code>表情符号</code>和<code>HTML</code>功能（当它们提供时）。一两个表情符号通常没有问题，但花哨的彩色文本倾向于使人认为你是个无能之辈。过滥地使用表情符号、色彩和字体会使你看来像个傻笑的小姑娘。这通常不是个好主意，除非你只是对性而不是对答案感兴趣。</li></ul><p>如果你使用图形用户界面的邮件程序（如微软公司的 Outlook 或者其它类似的），注意它们的默认设置不一定满足这些要求。大多数这类程序有基于选单的<code>查看源代码</code>命令，用它来检查发送文件夹中的邮件，以确保发送的是纯文本文件同时没有一些奇怪的字符。</p><h3 id="精确地描述问题并言之有物"><a class="markdownIt-Anchor" href="#精确地描述问题并言之有物"></a> 精确地描述问题并言之有物</h3><ul><li>仔细、清楚地描述你的问题或 Bug 的症状。</li><li>描述问题发生的环境（机器配置、操作系统、应用程序、以及相关的信息），提供经销商的发行版和版本号（如：<code>Fedora Core 4</code>、<code>Slackware 9.1</code>等）。</li><li>描述在提问前你是怎样去研究和理解这个问题的。</li><li>描述在提问前为确定问题而采取的诊断步骤。</li><li>描述最近做过什么可能相关的硬件或软件变更。</li><li>尽可能地提供一个可以<code>重现这个问题的可控环境</code>的方法。</li></ul><p>尽量去揣测一个黑客会怎样反问你，在你提问之前预先将黑客们可能提出的问题回答一遍。</p><p>以上几点中，当你报告的是你认为可能在代码中的问题时，给黑客一个可以重现你的问题的环境尤其重要。当你这么做时，你得到有效的回答的机会和速度都会大大的提升。</p><p><a href="http://www.chiark.greenend.org.uk/~sgtatham/">Simon Tatham</a> 写过一篇名为《<a href="http://www.chiark.greenend.org.uk/~sgtatham/bugs-cn.html">如何有效地报告Bug</a>》的出色文章。强力推荐你也读一读。</p><h3 id="话不在多而在精"><a class="markdownIt-Anchor" href="#话不在多而在精"></a> 话不在多而在精</h3><p>你需要提供精确有内容的信息。这并不是要求你简单的把成堆的出错代码或者资料完全转录到你的提问中。如果你有庞大而复杂的测试样例能重现程序挂掉的情境，尽量将它剪裁得越小越好。</p><p>这样做的用处至少有三点。<br />第一，表现出你为简化问题付出了努力，这可以使你得到回答的机会增加；<br />第二，简化问题使你更有可能得到<strong>有用</strong>的答案；<br />第三，在精炼你的 bug 报告的过程中，你很可能就自己找到了解决方法或权宜之计。</p><h3 id="别动辄声称找到-bug"><a class="markdownIt-Anchor" href="#别动辄声称找到-bug"></a> 别动辄声称找到 Bug</h3><p>当你在使用软件中遇到问题，除非你非常、<strong>非常</strong>的有根据，不要动辄声称找到了 Bug。提示：除非你能提供解决问题的源代码补丁，或者提供回归测试来表明前一版本中行为不正确，否则你都多半不够完全确信。这同样适用在网页和文件，如果你（声称）发现了文件的<code>Bug</code>，你应该能提供相应位置的修正或替代文件。</p><p>请记得，还有其他许多用户没遇到你发现的问题，否则你在阅读文件或搜索网页时就应该发现了（你在抱怨前<a href="#%E5%9C%A8%E6%8F%90%E9%97%AE%E4%B9%8B%E5%89%8D">已经做了这些，是吧</a>？）。这也意味着很有可能是你弄错了而不是软件本身有问题。</p><p>编写软件的人总是非常辛苦地使它尽可能完美。如果你声称找到了 Bug，也就是在质疑他们的能力，即使你是对的，也有可能会冒犯到其中某部分人。当你在标题中嚷嚷着有<code>Bug</code>时，这尤其严重。</p><p>提问时，即使你私下非常确信已经发现一个真正的 Bug，最好写得像是<strong>你</strong>做错了什么。如果真的有 Bug，你会在回复中看到这点。这样做的话，如果真有 Bug，维护者就会向你道歉，这总比你惹恼别人然后欠别人一个道歉要好一点。</p><h3 id="低声下气不能代替你的功课"><a class="markdownIt-Anchor" href="#低声下气不能代替你的功课"></a> 低声下气不能代替你的功课</h3><p>有些人明白他们不该粗鲁或傲慢的提问并要求得到答复，但他们选择另一个极端 —— 低声下气：<code>我知道我只是个可悲的新手，一个失败者，但...</code>。这既使人困扰，也没有用，尤其是伴随着与实际问题含糊不清的描述时更令人反感。</p><p>别用原始灵长类动物的把戏来浪费你我的时间。取而代之的是，尽可能清楚地描述背景条件和你的问题情况。这比低声下气更好地定位了你的位置。</p><p>有时网页论坛会设有专为新手提问的版面，如果你真的认为遇到了初学者的问题，到那去就是了，但一样别那么低声下气。</p><h3 id="描述问题症状而非你的猜测"><a class="markdownIt-Anchor" href="#描述问题症状而非你的猜测"></a> 描述问题症状而非你的猜测</h3><p>告诉黑客们你认为问题是怎样造成的并没什么帮助。（如果你的推断如此有效，还用向别人求助吗？），因此要确信你原原本本告诉了他们问题的症状，而不是你的解释和理论；让黑客们来推测和诊断。如果你认为陈述自己的猜测很重要，清楚地说明这只是你的猜测，并描述为什么它们不起作用。</p><p><strong>蠢问题</strong></p><blockquote><p>我在编译内核时接连遇到 SIG11 错误，<br />我怀疑某条飞线搭在主板的走线上了，这种情况应该怎样检查最好？</p></blockquote><p><strong>聪明问题</strong></p><blockquote><p>我的组装电脑是 FIC-PA2007 主机板搭载 AMD K6/233 CPU（威盛 Apollo VP2 芯片组），<br />256MB Corsair PC133 SDRAM 内存，在编译内核时，从开机 20 分钟以后就频频产生 SIG11 错误，<br />但是在头 20 分钟内从没发生过相同的问题。重新启动也没有用，但是关机一晚上就又能工作 20 分钟。<br />所有内存都换过了，没有效果。相关部分的标准编译记录如下…</p></blockquote><p>由于以上这点似乎让许多人觉得难以配合，这里有句话可以提醒你：<code>所有的诊断专家都来自密苏里州。</code> 美国国务院的官方座右铭则是：<code>让我看看</code>（出自国会议员 Willard D. Vandiver 在 1899 年时的讲话：<code>我来自一个出产玉米，棉花，牛蒡和民主党人的国家，滔滔雄辩既不能说服我，也不会让我满意。我来自密苏里州，你必须让我看看。</code>） 针对诊断者而言，这并不是一种怀疑，而只是一种真实而有用的需求，以便让他们看到的是与你看到的原始证据尽可能一致的东西，而不是你的猜测与归纳的结论。所以，大方地展示给我们看吧！</p><h3 id="按发生时间先后列出问题症状"><a class="markdownIt-Anchor" href="#按发生时间先后列出问题症状"></a> 按发生时间先后列出问题症状</h3><p>问题发生前的一系列操作，往往就是对找出问题最有帮助的线索。因此，你的说明里应该包含你的操作步骤，以及机器和软件的反应，直到问题发生。在命令行处理的情况下，提供一段操作记录（例如运行脚本工具所生成的），并引用相关的若干行（如 20 行）记录会非常有帮助。</p><p>如果挂掉的程序有诊断选项（如 -v 的详述开关），试着选择这些能在记录中增加调试信息的选项。记住，<code>多</code>不等于<code>好</code>。试着选取适当的调试级别以便提供有用的信息而不是让读者淹没在垃圾中。</p><p>如果你的说明很长（如超过四个段落），在开头简述问题，接下来再按时间顺序详述会有所帮助。这样黑客们在读你的记录时就知道该注意哪些内容了。</p><h3 id="描述目标而不是过程"><a class="markdownIt-Anchor" href="#描述目标而不是过程"></a> 描述目标而不是过程</h3><p>如果你想弄清楚如何做某事（而不是报告一个 Bug），在开头就描述你的目标，然后才陈述重现你所卡住的特定步骤。</p><p>经常寻求技术帮助的人在心中有个更高层次的目标，而他们在自以为能达到目标的特定道路上被卡住了，然后跑来问该怎么走，但没有意识到这条路本身就有问题。结果要费很大的劲才能搞定。</p><p><strong>蠢问题</strong></p><blockquote><p>我怎样才能从某绘图程序的颜色选择器中取得十六进制的 RGB 值？</p></blockquote><p><strong>聪明问题</strong></p><blockquote><p>我正试着用替换一幅图片的色码（color table）成自己选定的色码，我现在知道的唯一方法是编辑每个色码区块（table slot），<br />但却无法从某绘图程序的颜色选择器取得十六进制的 RGB 值。</p></blockquote><p>第二种提问法比较聪明，你可能得到像是<code>建议采用另一个更合适的工具</code>的回复。</p><h3 id="别要求使用私人电邮回复"><a class="markdownIt-Anchor" href="#别要求使用私人电邮回复"></a> 别要求使用私人电邮回复</h3><p>黑客们认为问题的解决过程应该公开、透明，此过程中如果更有经验的人注意到不完整或者不当之处，最初的回复才能够、也应该被纠正。同时，作为提供帮助者可以得到一些奖励，奖励就是他的能力和学识被其他同行看到。</p><p>当你要求私下回复时，这个过程和奖励都被中止。别这样做，让<strong>回复者</strong>来决定是否私下回答 —— 如果他真这么做了，通常是因为他认为问题编写太差或者太肤浅，以至于不可能使其他人产生兴趣。</p><p>这条规则存在一条有限的例外，如果你确信提问可能会引来大量雷同的回复时，那么这个神奇的提问句会是<code>向我发电邮，我将为论坛归纳这些回复</code>。试着将邮件列表或新闻群组从洪水般的雷同回复中解救出来是非常有礼貌的 —— 但你必须信守诺言。</p><h3 id="清楚明确地表达你的问题以及需求"><a class="markdownIt-Anchor" href="#清楚明确地表达你的问题以及需求"></a> 清楚明确地表达你的问题以及需求</h3><p>漫无边际的提问是近乎无休无止的时间黑洞。最有可能给你有用答案的人通常也正是最忙的人（他们忙是因为要亲自完成大部分工作）。这样的人对无节制的时间黑洞相当厌恶，所以他们也倾向于厌恶那些漫无边际的提问。</p><p>如果你明确表述需要回答者做什么（如提供指点、发送一段代码、检查你的补丁、或是其他等等），就最有可能得到有用的答案。因为这会定出一个时间和精力的上限，便于回答者能集中精力来帮你。这么做很棒。</p><p>要理解专家们所处的世界，请把专业技能想像为充裕的资源，而回复的时间则是稀缺的资源。你要求他们奉献的时间越少，你越有可能从真正专业而且很忙的专家那里得到解答。</p><p>所以，界定一下你的问题，使专家花在辨识你的问题和回答所需要付出的时间减到最少，这技巧对你获得有用的答案相当有帮助 —— 但这技巧通常和简化问题有所区别。因此，问<code>我想更好地理解 X，可否指点一下哪有好一点说明？</code>通常比问<code>你能解释一下 X 吗？</code>更好。如果你的代码不能运作，通常请别人看看哪里有问题，比要求别人替你改正要明智得多。</p><h3 id="询问有关代码的问题时"><a class="markdownIt-Anchor" href="#询问有关代码的问题时"></a> 询问有关代码的问题时</h3><p>如果没有提示别人应该从何入手，别要求他人帮你调试有问题的代码。张贴几百行的代码，然后说一声：<code>它不能工作</code>会让你完全被忽略。只贴几十行代码，然后说一句：<code>在第七行以后，我期待它显示 &lt;x&gt;，但实际出现的是 &lt;y&gt;</code>比较有可能让你得到回应。</p><p>最有效描述程序问题的方法是提供最精简的 Bug 展示测试用例（bug-demonstrating test case）。什么是最精简的测试用例？那是问题的缩影；一小个程序片段能<strong>刚好</strong>展示出程序的异常行为，而不包含其他令人分散注意力的内容。怎么制作最精简的测试用例？如果你知道哪一行或哪一段代码会造成异常的行为，复制下来并加入足够重现这个状况的代码（例如，足以让这段代码能被编译/直译/被应用程序处理）。如果你无法将问题缩减到一个特定区块，就复制一份代码并移除不影响产生问题行为的部分。总之，测试用例越小越好（查看<a href="#%E8%AF%9D%E4%B8%8D%E5%9C%A8%E5%A4%9A%E8%80%8C%E5%9C%A8%E7%B2%BE">话不在多而在精</a>一节）。</p><p>一般而言，要得到一段相当精简的测试用例并不太容易，但永远先尝试这样做是一个好习惯。这种方式可以帮助你了解如何自行解决这个问题 —— 而且即使你的尝试不成功，黑客们也会看到你在尝试取得答案的过程中付出了努力，这可以让他们更愿意与你合作。</p><p>如果你只是想让别人帮忙审查（Review）一下代码，在信的开头就要说出来，并且一定要提到你认为哪一部分特别需要关注以及为什么。</p><h3 id="别把自己家庭作业的问题贴上来"><a class="markdownIt-Anchor" href="#别把自己家庭作业的问题贴上来"></a> 别把自己家庭作业的问题贴上来</h3><p>黑客们很擅长分辨哪些问题是家庭作业式的问题；因为我们中的大多数都曾自己解决这类问题。同样，这些问题得由<strong>你</strong>来搞定，你会从中学到东西。你可以要求给点提示，但别要求得到完整的解决方案。</p><p>如果你怀疑自己碰到了一个家庭作业式的问题，但仍然无法解决，试试在用户群组，论坛或（最后一招）在项目的<strong>用户</strong>邮件列表或论坛中提问。尽管黑客们<strong>会</strong>看出来，但一些有经验的用户也许仍会给你一些提示。</p><h3 id="去掉无意义的提问句"><a class="markdownIt-Anchor" href="#去掉无意义的提问句"></a> 去掉无意义的提问句</h3><p>避免用无意义的话结束提问，例如<code>有人能帮我吗？</code>或者<code>这有答案吗？</code>。</p><p>首先：如果你对问题的描述不是很好，这样问更是画蛇添足。</p><p>其次：由于这样问是画蛇添足，黑客们会很厌烦你 —— 而且通常会用逻辑上正确，但毫无意义的回答来表示他们的蔑视， 例如：<code>没错，有人能帮你</code>或者<code>不，没答案</code>。</p><p>一般来说，避免用 <code>是或否</code>、<code>对或错</code>、<code>有或没有</code>类型的问句，除非你想得到<a href="https://strcat.de/questions-with-yes-or-no-answers.html">是或否类型的回答</a>。</p><h3 id="即使你很急也不要在标题写紧急"><a class="markdownIt-Anchor" href="#即使你很急也不要在标题写紧急"></a> 即使你很急也不要在标题写<code>紧急</code></h3><p>这是你的问题，不是我们的。宣称<code>紧急</code>极有可能事与愿违：大多数黑客会直接删除无礼和自私地企图即时引起关注的问题。更严重的是，<code>紧急</code>这个字（或是其他企图引起关注的标题）通常会被垃圾信过滤器过滤掉 —— 你希望能看到你问题的人可能永远也看不到。</p><p>有半个例外的情况是，如果你是在一些很高调，会使黑客们兴奋的地方，也许值得这样去做。在这种情况下，如果你有时间压力，也很有礼貌地提到这点，人们也许会有兴趣回答快一点。</p><p>当然，这风险很大，因为黑客们兴奋的点多半与你的不同。譬如从 NASA 国际空间站（International Space Station）发这样的标题没有问题，但用自我感觉良好的慈善行为或政治原因发肯定不行。事实上，张贴诸如<code>紧急：帮我救救这个毛茸茸的小海豹！</code>肯定让你被黑客忽略或惹恼他们，即使他们认为毛茸茸的小海豹很重要。</p><p>如果你觉得这点很不可思议，最好再把这份指南剩下的内容多读几遍，直到你弄懂了再发文。</p><h3 id="礼多人不怪而且有时还很有帮助"><a class="markdownIt-Anchor" href="#礼多人不怪而且有时还很有帮助"></a> 礼多人不怪，而且有时还很有帮助</h3><p>彬彬有礼，多用<code>请</code>和<code>谢谢您的关注</code>，或<code>谢谢你的关照</code>。让大家都知道你对他们花时间免费提供帮助心存感激。</p><p>坦白说，这一点并没有比使用清晰、正确、精准且合乎语法和避免使用专用格式重要（也不能取而代之）。黑客们一般宁可读有点唐突但技术上鲜明的 Bug 报告，而不是那种有礼但含糊的报告。（如果这点让你不解，记住我们是按问题能教给我们什么来评价问题的价值的）</p><p>然而，如果你有一串的问题待解决，客气一点肯定会增加你得到有用回应的机会。</p><p>（我们注意到，自从本指南发布后，从资深黑客那里得到的唯一严重缺陷反馈，就是对预先道谢这一条。一些黑客觉得<code>先谢了</code>意味着事后就不用再感谢任何人的暗示。我们的建议是要么先说<code>先谢了</code>，<strong>然后</strong>事后再对回复者表示感谢，或者换种方式表达感激，譬如用<code>谢谢你的关注</code>或<code>谢谢你的关照</code>。）</p><h3 id="问题解决后加个简短的补充说明"><a class="markdownIt-Anchor" href="#问题解决后加个简短的补充说明"></a> 问题解决后，加个简短的补充说明</h3><p>问题解决后，向所有帮助过你的人发个说明，让他们知道问题是怎样解决的，并再一次向他们表示感谢。如果问题在新闻组或者邮件列表中引起了广泛关注，应该在那里贴一个说明比较恰当。</p><p>最理想的方式是向最初提问的话题回复此消息，并在标题中包含<code>已修正</code>，<code>已解决</code>或其它同等含义的明显标记。在人来人往的邮件列表里，一个看见讨论串<code>问题 X</code>和<code>问题 X - 已解决</code>的潜在回复者就明白不用再浪费时间了（除非他个人觉得<code>问题 X</code>有趣），因此可以利用此时间去解决其它问题。</p><p>补充说明不必很长或是很深入；简单的一句<code>你好，原来是网线出了问题！谢谢大家 – Bill</code>比什么也不说要来的好。事实上，除非结论真的很有技术含量，否则简短可爱的小结比长篇大论更好。说明问题是怎样解决的，但大可不必将解决问题的过程复述一遍。</p><p>对于有深度的问题，张贴调试记录的摘要是有帮助的。描述问题的最终状态，说明是什么解决了问题，在此<strong>之后</strong>才指明可以避免的盲点。避免盲点的部分应放在正确的解决方案和其它总结材料之后，而不要将此信息搞成侦探推理小说。列出那些帮助过你的名字，会让你交到更多朋友。</p><p>除了有礼貌和有内涵以外，这种类型的补充也有助于他人在邮件列表/新闻群组/论坛中搜索到真正解决你问题的方案，让他们也从中受益。</p><p>至少，这种补充有助于让每位参与协助的人因问题的解决而从中得到满足感。如果你自己不是技术专家或者黑客，那就相信我们，这种感觉对于那些你向他们求助的大师或者专家而言，是非常重要的。问题悬而未决会让人灰心；黑客们渴望看到问题被解决。好人有好报，满足他们的渴望，你会在下次提问时尝到甜头。</p><p>思考一下怎样才能避免他人将来也遇到类似的问题，自问写一份文件或加个常见问题（FAQ）会不会有帮助。如果是的话就将它们发给维护者。</p><p>在黑客中，这种良好的后继行动实际上比传统的礼节更为重要，也是你如何透过善待他人而赢得声誉的方式，这是非常有价值的资产。</p><h2 id="如何解读答案"><a class="markdownIt-Anchor" href="#如何解读答案"></a> 如何解读答案</h2><p><a id="rtfm"></a></p><h3 id="rtfm-和-stfw如何知道你已完全搞砸了"><a class="markdownIt-Anchor" href="#rtfm-和-stfw如何知道你已完全搞砸了"></a> RTFM 和 STFW：如何知道你已完全搞砸了</h3><p>有一个古老而神圣的传统：如果你收到<code>RTFM（Read The Fucking Manual）</code>的回应，回答者认为你<strong>应该去读他妈的手册</strong>。当然，基本上他是对的，你应该去读一读。</p><p>RTFM 有一个年轻的亲戚。如果你收到<code>STFW（Search The Fucking Web）</code>的回应，回答者认为你<strong>应该到他妈的网上搜索</strong>。那人多半也是对的，去搜索一下吧。（更温和一点的说法是 <strong><a href="http://lmgtfy.com/">Google 是你的朋友</a></strong>！）</p><p>在论坛，你也可能被要求去爬爬论坛的旧文。事实上，有人甚至可能热心地为你提供以前解决此问题的讨论串。但不要依赖这种关照，提问前应该先搜索一下旧文。</p><p>通常，用这两句之一回答你的人会给你一份包含你需要内容的手册或者一个网址，而且他们打这些字的时候也正在读着。这些答复意味着回答者认为：</p><ul><li><strong>你需要的信息非常容易获得</strong>；</li><li><strong>你自己去搜索这些信息比灌给你，能让你学到更多</strong>。</li></ul><p>你不应该因此不爽；<strong>依照黑客的标准，他已经表示了对你一定程度的关注，而没有对你的要求视而不见</strong>。你应该对他祖母般的慈祥表示感谢。</p><h3 id="如果还是搞不懂"><a class="markdownIt-Anchor" href="#如果还是搞不懂"></a> 如果还是搞不懂</h3><p>如果你看不懂回应，别立刻要求对方解释。像你以前试着自己解决问题时那样（利用手册，FAQ，网络，身边的高手），先试着去搞懂他的回应。如果你真的需要对方解释，记得表现出你已经从中学到了点什么。</p><p>比方说，如果我回答你：<code>看来似乎是 zentry 卡住了；你应该先清除它。</code>，然后，这是一个<strong>很糟的</strong>后续问题回应：<code>zentry 是什么？</code> <strong>好</strong>的问法应该是这样：<code>哦~~~我看过说明了但是只有 -z 和 -p 两个参数中提到了 zentries，而且还都没有清楚的解释如何清除它。你是指这两个中的哪一个吗？还是我看漏了什么？</code></p><h3 id="处理无礼的回应"><a class="markdownIt-Anchor" href="#处理无礼的回应"></a> 处理无礼的回应</h3><p>很多黑客圈子中看似无礼的行为并不是存心冒犯。相反，它是直截了当，一针见血式的交流风格，这种风格更注重解决问题，而不是使人感觉舒服而却模模糊糊。</p><p>如果你觉得被冒犯了，试着平静地反应。如果有人真的做了出格的事，邮件列表、新闻群组或论坛中的前辈多半会招呼他。如果这<strong>没有</strong>发生而你却发火了，那么你发火对象的言语可能在黑客社区中看起来是正常的，而<strong>你</strong>将被视为有错的一方，这将伤害到你获取信息或帮助的机会。</p><p>另一方面，你偶尔真的会碰到无礼和无聊的言行。与上述相反，对真正的冒犯者狠狠地打击，用犀利的语言将其驳得体无完肤都是可以接受的。然而，在行事之前一定要非常非常的有根据。纠正无礼的言论与开始一场毫无意义的口水战仅一线之隔，黑客们自己莽撞地越线的情况并不鲜见。如果你是新手或外人，避开这种莽撞的机会并不高。如果你想得到的是信息而不是消磨时光，这时最好不要把手放在键盘上以免冒险。</p><p>（有些人断言很多黑客都有轻度的自闭症或亚斯伯格综合症，缺少用于润滑人类社会<strong>正常</strong>交往所需的神经。这既可能是真也可能是假的。如果你自己不是黑客，兴许你认为我们脑袋有问题还能帮助你应付我们的古怪行为。只管这么干好了，我们不在乎。我们<strong>喜欢</strong>我们现在这个样子，并且通常对病患标记都有站得住脚的怀疑。）</p><p>Jeff Bigler 的观察总结和这个相关也值得一读 (<strong><a href="http://www.mit.edu/~jcb/tact.html">tact filters</a></strong>)。</p><p>在下一节，我们会谈到另一个问题，当<strong>你</strong>行为不当时所会受到的<code>冒犯</code>。</p><h2 id="如何避免扮演失败者"><a class="markdownIt-Anchor" href="#如何避免扮演失败者"></a> 如何避免扮演失败者</h2><p>在黑客社区的论坛中，你以本指南所描述的或类似的方式，可能会有那么几次搞砸了。而你会在公开场合中被告知你是如何搞砸的，也许攻击的言语中还会带点夹七夹八的颜色。</p><p>这种事发生以后，你能做的最糟糕的事莫过于哀嚎你的遭遇、宣称被言语攻击、要求道歉、高声尖叫、憋闷气、威胁诉诸法律、向其雇主报怨、不去关马桶盖等等。相反地，你该这么做：</p><p>熬过去，这很正常。事实上，它是有益健康且合理的。</p><p>社区的标准不会自行维持，它们是通过参与者积极而<strong>公开地</strong>执行来维持的。不要哭嚎所有的批评都应该通过私下的邮件传送，它不是这样运作的。当有人评论你的一个说法有误或者提出不同看法时，坚持声称受到个人攻击也毫无益处，这些都是失败者的态度。</p><p>也有其它的黑客论坛，受过高礼节要求的误导，禁止参与者张贴任何对别人帖子挑毛病的消息，并声称<code>如果你不想帮助用户就闭嘴。</code> 结果造成有想法的参与者纷纷离开，这么做只会使它们沦为毫无意义的唠叨与无用的技术论坛。</p><p>夸张的讲法是：你要的是“友善”（以上述方式）还是有用？两个里面挑一个。</p><p>记着：当黑客说你搞砸了，并且（无论多么刺耳）告诉你别再这样做时，他正在为关心<strong>你</strong>和<strong>他的社区</strong>而行动。对他而言，不理你并将你从他的生活中滤掉更简单。如果你无法做到感谢，至少要表现得有点尊严，别大声哀嚎，也别因为自己是个有戏剧性超级敏感的灵魂和自以为有资格的新来者，就指望别人像对待脆弱的洋娃娃那样对你。</p><p>有时候，即使你没有搞砸（或者只是在他的想像中你搞砸了），有些人也会无缘无故地攻击你本人。在这种情况下，抱怨倒是<strong>真的</strong>会把问题搞砸。</p><p>这些来找麻烦的人要么是毫无办法但自以为是专家的不中用家伙，要么就是测试你是否真会搞砸的心理专家。其它读者要么不理睬，要么用自己的方式对付他们。这些来找麻烦的人在给他们自己找麻烦，这点你不用操心。</p><p>也别让自己卷入口水战，最好不要理睬大多数的口水战 —— 当然，这是在你检验它们只是口水战，并且未指出你有搞砸的地方，同时也没有巧妙地将问题真正的答案藏于其后（这也是有可能的）。</p><h2 id="不该问的问题"><a class="markdownIt-Anchor" href="#不该问的问题"></a> 不该问的问题</h2><p>以下是几个经典蠢问题，以及黑客没回答时心中所想的：</p><p>问题：<a href="#q1">我能在哪找到 X 程序或 X 资源？</a></p><p>问题：<a href="#q2">我怎样用 X 做 Y？</a></p><p>问题：<a href="#q3">如何设定我的 shell 提示？</a></p><p>问题：<a href="#q4">我可以用 Bass-o-matic 文件转换工具将 AcmeCorp 文件转换为 TeX 格式吗？</a></p><p>问题：<a href="#q5">我的程序/设定/SQL 语句没有用</a></p><p>问题：<a href="#q6">我的 Windows 电脑有问题，你能帮我吗？</a></p><p>问题：<a href="#q7">我的程序不会动了，我认为系统工具 X 有问题</a></p><p>问题：<a href="#q8">我在安装 Linux（或者 X ）时有问题，你能帮我吗？</a></p><p>问题：<a href="#q9">我怎么才能破解 root 帐号/窃取 OP 特权/读别人的邮件呢？</a></p><hr /><p><a id="q1"></a></p><blockquote><p>问题：我能在哪找到 X 程序或 X 资源？</p></blockquote><p>回答：就在我找到它的地方啊，白痴 —— 搜索引擎的那一头。天哪！难道还有人不会用 <a href="https://www.google.com">Google</a> 吗？</p><p><a id="q2"></a></p><blockquote><p>问题：我怎样用 X 做 Y？</p></blockquote><p>回答：如果你想解决的是 Y ，提问时别给出可能并不恰当的方法。这种问题说明提问者不但对 X 完全无知，也对 Y 要解决的问题糊涂，还被特定形势禁锢了思维。最好忽略这种人，等他们把问题搞清楚了再说。</p><p><a id="q3"></a></p><blockquote><p>问题：如何设定我的 shell 提示？？</p></blockquote><p>回答：如果你有足够的智慧提这个问题，你也该有足够的智慧去 <a href="#RTFM">RTFM</a>，然后自己去找出来。</p><p><a id="q4"></a></p><blockquote><p>问题：我可以用 Bass-o-matic 文件转换工具将 AcmeCorp 文件转换为 TeX 格式吗？</p></blockquote><p>回答：试试看就知道了。如果你试过，你就知道了答案，就不用浪费我的时间了。</p><p><a id="q5"></a></p><blockquote><p>问题：我的{程序/设定/SQL 语句}没有用</p></blockquote><p>回答：这不算是问题吧，我对要我问你二十个问题才找得出你真正问题的问题没兴趣 —— 我有更有意思的事要做呢。在看到这类问题的时候，我的反应通常不外如下三种</p><ul><li>你还有什么要补充的吗？</li><li>真糟糕，希望你能搞定。</li><li>这关我屁事？</li></ul><p><a id="q6"></a></p><blockquote><p>问题：我的 Windows 电脑有问题，你能帮我吗？</p></blockquote><p>回答：能啊，扔掉微软的垃圾，换个像 Linux 或 BSD 的开源操作系统吧。</p><p>注意：如果程序有官方版 Windows 或者与 Windows 有互动（如 Samba），你<strong>可以</strong>问与 Windows 相关的问题，只是别对问题是由 Windows 操作系统而不是程序本身造成的回复感到惊讶， 因为 Windows 一般来说实在太烂，这种说法通常都是对的。</p><p><a id="q7"></a></p><blockquote><p>问题：我的程序不会动了，我认为系统工具 X 有问题</p></blockquote><p>回答：你完全有可能是第一个注意到被成千上万用户反复使用的系统调用与函数库文件有明显缺陷的人，更有可能的是你完全没有根据。不同凡响的说法需要不同凡响的证据，当你这样声称时，你必须有清楚而详尽的缺陷说明文件作后盾。</p><p><a id="q8"></a></p><blockquote><p>问题：我在安装 Linux（或者 X ）时有问题，你能帮我吗？</p></blockquote><p>回答：不能，我只有亲自在你的电脑上动手才能找到毛病。还是去找你当地的 Linux 使用群组者寻求实际的指导吧（你能在<a href="http://www.linux.org/groups/index.html">这儿</a>找到用户群组的清单）。</p><p>注意：如果安装问题与某 Linux 的发行版有关，在它的邮件列表、论坛或本地用户群组中提问也许是恰当的。此时，应描述问题的准确细节。在此之前，先用 <code>Linux</code> 和<strong>所有</strong>被怀疑的硬件作关键词仔细搜索。</p><p><a id="q9"></a></p><blockquote><p>问题：我怎么才能破解 root 帐号/窃取 OP 特权/读别人的邮件呢？</p></blockquote><p>回答：想要这样做，说明了你是个卑鄙小人；想找个黑客帮你，说明你是个白痴！</p><h2 id="好问题与蠢问题"><a class="markdownIt-Anchor" href="#好问题与蠢问题"></a> 好问题与蠢问题</h2><p>最后，我将透过举一些例子，来说明怎样聪明的提问；同一个问题的两种问法被放在一起，一种是愚蠢的，另一种才是明智的。</p><p><strong>蠢问题</strong>：</p><blockquote><p>我可以在哪儿找到关于 Foonly Flurbamatic 的资料？</p></blockquote><p>这种问法无非想得到 <a href="#RTFM">STFW</a> 这样的回答。</p><p><strong>聪明问题</strong>：</p><blockquote><p>我用 Google 搜索过 “Foonly Flurbamatic 2600”，但是没找到有用的结果。谁知道上哪儿去找对这种设备编程的资料？</p></blockquote><p>这个问题已经 STFW 过了，看起来他真的遇到了麻烦。</p><p><strong>蠢问题</strong>：</p><blockquote><p>我从 foo 项目找来的源码没法编译。它怎么这么烂？</p></blockquote><p>他觉得都是别人的错，这个傲慢自大的提问者。</p><p><strong>聪明问题</strong>：</p><blockquote><p>foo 项目代码在 Nulix 6.2 版下无法编译通过。我读过了 FAQ，但里面没有提到跟 Nulix 有关的问题。这是我编译过程的记录，我有什么做的不对的地方吗？</p></blockquote><p>提问者已经指明了环境，也读过了 FAQ，还列出了错误，并且他没有把问题的责任推到别人头上，他的问题值得被关注。</p><p><strong>蠢问题</strong>：</p><blockquote><p>我的主机板有问题了，谁来帮我？</p></blockquote><p>某黑客对这类问题的回答通常是：<code>好的，还要帮你拍拍背和换尿布吗？</code>，然后按下删除键。</p><p><strong>聪明问题</strong>：</p><blockquote><p>我在 S2464 主机板上试过了 X 、 Y 和 Z ，但没什么作用，我又试了 A 、 B 和 C 。请注意当我尝试 C 时的奇怪现象。显然 florbish 正在 grommicking，但结果出人意料。通常在 Athlon MP 主机板上引起 grommicking 的原因是什么？有谁知道接下来我该做些什么测试才能找出问题？</p></blockquote><p>这个家伙，从另一个角度来看，值得去回答他。他表现出了解决问题的能力，而不是坐等天上掉答案。</p><p>在最后一个问题中，注意<code>告诉我答案</code>和<code>给我启示，指出我还应该做什么诊断工作</code>之间微妙而又重要的区别。</p><p>事实上，后一个问题源自于 2001 年 8 月在 Linux 内核邮件列表（lkml）上的一个真实的提问。我（Eric）就是那个提出问题的人。我在 Tyan S2464 主板上观察到了这种无法解释的锁定现象，列表成员们提供了解决这一问题的重要信息。</p><p>通过我的提问方法，我给了别人可以咀嚼玩味的东西；我设法让人们很容易参与并且被吸引进来。我显示了自己具备和他们同等的能力，并邀请他们与我共同探讨。通过告诉他们我所走过的弯路，以避免他们再浪费时间，我也表明了对他们宝贵时间的尊重。</p><p>事后，当我向每个人表示感谢，并且赞赏这次良好的讨论经历的时候，一个 Linux 内核邮件列表的成员表示，他觉得我的问题得到解决并非由于我是这个列表中的<strong>名</strong>人，而是因为我用了正确的方式来提问。</p><p>黑客从某种角度来说是拥有丰富知识但缺乏人情味的家伙；我相信他是对的，如果我<strong>像</strong>个乞讨者那样提问，不论我是谁，一定会惹恼某些人或者被他们忽视。他建议我记下这件事，这直接导致了本指南的出现。</p><h2 id="如果得不到回答"><a class="markdownIt-Anchor" href="#如果得不到回答"></a> 如果得不到回答</h2><p>如果仍得不到回答，请不要以为我们觉得无法帮助你。有时只是看到你问题的人不知道答案罢了。没有回应不代表你被忽视，虽然不可否认这种差别很难区分。</p><p>总的来说，简单地重复张贴问题是个很糟的点子。这将被视为无意义的喧闹。有点耐心，知道你问题答案的人可能生活在不同的时区，可能正在睡觉，也有可能你的问题一开始就没有组织好。</p><p>你可以通过其他渠道获得帮助，这些渠道通常更适合初学者的需要。</p><p>有许多网上的以及本地的用户群组，由热情的软件爱好者（即使他们可能从没亲自写过任何软件）组成。通常人们组建这样的团体来互相帮助并帮助新手。</p><p>另外，你可以向很多商业公司寻求帮助，不论公司大还是小。别为要付费才能获得帮助而感到沮丧！毕竟，假使你的汽车发动机汽缸密封圈爆掉了 —— 完全可能如此 —— 你还得把它送到修车铺，并且为维修付费。就算软件没花费你一分钱，你也不能强求技术支持总是免费的。</p><p>对像是 Linux 这种大众化的软件，每个开发者至少会对应到上万名用户。根本不可能由一个人来处理来自上万名用户的求助电话。要知道，即使你要为这些协助付费，和你所购买的同类软件相比，你所付出的也是微不足道的（通常封闭源代码软件的技术支持费用比开源软件的要高得多，且内容也没那么丰富）。</p><h2 id="如何更好地回答问题"><a class="markdownIt-Anchor" href="#如何更好地回答问题"></a> 如何更好地回答问题</h2><p><strong>态度和善一点。</strong> 问题带来的压力常使人显得无礼或愚蠢，其实并不是这样。</p><p><strong>对初犯者私下回复。</strong> 对那些坦诚犯错之人没有必要当众羞辱，一个真正的新手也许连怎么搜索或在哪找常见问题都不知道。</p><p><strong>如果你不确定，一定要说出来！</strong> 一个听起来权威的错误回复比没有还要糟，别因为听起来像个专家很好玩，就给别人乱指路。要谦虚和诚实，给提问者与同行都树个好榜样。</p><p><strong>如果帮不了忙，也别妨碍他。</strong> 不要在实际步骤上开玩笑，那样也许会毁了提问者的设置 —— 有些可怜的呆瓜会把它当成真的指令。</p><p><strong>试探性的反问以引出更多的细节。</strong> 如果你做得好，提问者可以学到点东西 —— 你也可以。试试将蠢问题转变成好问题，别忘了我们都曾是新手。</p><p>尽管对那些懒虫抱怨一声 RTFM 是正当的，但能给出文档的链接（即使只是建议个 Google 搜索关键词）会更好。</p><p><strong>如果你决定回答，就请给出好的答案。</strong> 当别人正在用错误的工具或方法时别建议笨拙的权宜之计（workaround），应推荐更好的工具，重新界定问题。</p><p><strong>正面地回答问题！</strong> 如果这个提问者已经很深入的研究而且也表明已经试过 X 、 Y 、 Z 、 A 、 B 、 C 但没得到结果，回答 <code>试试看 A 或是 B</code> 或者 <code>试试 X 、 Y 、 Z 、 A 、 B 、 C</code> 并附上一个链接一点用都没有。</p><p><strong>帮助你的社区从问题中学习。</strong> 当回复一个好问题时，问问自己<code>如何修改相关文件或常见问题文件以免再次解答同样的问题？</code>，接着再向文件维护者发一份补丁。</p><p>如果你在研究一番后才作出了回答，<strong>展现你的技巧而不是直接端出结果</strong>。毕竟<code>授人以鱼不如授人以渔</code>。</p><h2 id="相关资源"><a class="markdownIt-Anchor" href="#相关资源"></a> 相关资源</h2><p>如果你需要个人电脑、Unix 系统和网络如何运作的基础知识，参阅 <a href="http://en.tldp.org/HOWTO/Unix-and-Internet-Fundamentals-HOWTO/">Unix 系统和网络基本原理</a>。</p><p>当你发布软件或补丁时，试着按<a href="http://en.tldp.org/HOWTO/Software-Release-Practice-HOWTO/index.html">软件发布实践</a>操作。</p><h2 id="鸣谢"><a class="markdownIt-Anchor" href="#鸣谢"></a> 鸣谢</h2><p>Evelyn Mitchel 贡献了一些愚蠢问题例子并启发了编写<code>如何更好地回答问题</code>这一节， Mikhail Ramendik 贡献了一些特别有价值的建议和改进。</p>]]>
      </content:encoded>
    </item>
    <item>
      <title>如何打造一个舒适的算法竞赛编程环境</title>
      <link>https://www.dianhsu.com/2023/12/30/algorithm-env/</link>
      <description>
        <![CDATA[<p>从开始接触算法竞赛到现在堪堪入门算法竞赛以来，写算法题的平台改变了很多次，但是追求舒适、方便、快捷的开发环境的想法从来没有改变过。<br]]>
      </description>
      <author>Dian Hsu</author>
      <category domain="https://www.dianhsu.com/categories/Tool/">Tool</category>
      <category domain="https://www.dianhsu.com/tags/Algorithm/">Algorithm</category>
      <category domain="https://www.dianhsu.com/tags/Tool/">Tool</category>
      <category domain="https://www.dianhsu.com/tags/Shell/">Shell</category>
      <category domain="https://www.dianhsu.com/tags/Rust/">Rust</category>
      <category domain="https://www.dianhsu.com/tags/VSCode/">VSCode</category>
      <category domain="https://www.dianhsu.com/tags/Container/">Container</category>
      <category domain="https://www.dianhsu.com/tags/DevContainer/">DevContainer</category>
      <pubDate>Sat, 30 Dec 2023 07:27:12 GMT</pubDate>
      <content:encoded>
        <![CDATA[<p>从开始接触算法竞赛到现在堪堪入门算法竞赛以来，写算法题的平台改变了很多次，但是追求舒适、方便、快捷的开发环境的想法从来没有改变过。<br />最开始的时候用的是CodeBlocks，这个IDE可以生成template，但是并没有很好的LSP支持。后来对编程环境熟悉一些之后，就没用这种开发方式了。<br />之后很长的一段时间，开发环境换到了Vim，主要是用SpaceVim + coc-clangd + Copilot，这种方式在Linux和macOS上面的体验还不错，但是在Windows下面体验效果很差，主要是因为Windows下面的GNU C++的编译器的环境有点不太方便。因为没有办法统一三端的体验，后面也放弃了这种开发方式。<br />现在的开发方式主要依赖VSCode + DevContainer + clangd + Copilot。VSCode提供了丰富的插件，可以依旧使用Vim和JetBrains的键位习惯。DevContainer提供了一个跨平台统一的开发环境，无论是Windows、Linux还是macOS，都拥有一致的开发体验。</p><h2 id="环境搭建"><a class="markdownIt-Anchor" href="#环境搭建"></a> 环境搭建</h2><p>之前做了一个Algorithm的竞赛用Repo，链接在这<sup id="fnref:2" class="footnote-ref"><a href="#fn:2" rel="footnote"><span class="hint--top hint--rounded" aria-label="https://github.com/dianhsu/algorithm">[2]</span></a></sup>。<br />里面的文件夹结构如下图所示。<br /><img src="https://cdn.dianhsu.com/img/2023-12-30-15-35-24.png" alt="参考文件夹布局" /></p><p>下面介绍一下具体的文件和文件夹用途</p><ul><li>📂<code>.devcontainer/</code>: Dev Container的配置文件夹。<ul><li>📄<code>devcontainer.json</code>: Dev Container的配置文件。</li><li>📄<code>Dockerfile</code>: Dev Container用到的自定义容器的配置文件，如果使用官方的容器就不需要定义这个文件。</li></ul></li><li>📂<code>.vscode/</code>: VSCode工作区配置文件。<ul><li>📄<code>cpp.code-snippets</code>: VSCode 各个语言的代码块，可以输入缩写补充完整的代码块。</li><li>📄<code>launch.json</code>: VSCode Debug &amp; Run的配置文件。</li><li>📄<code>tasks.json</code>: VSCode 自定义任务。</li></ul></li><li>📂<code>scripts</code>: 自定义的一些脚本。<ul><li>📂<code>linux</code>: Linux下面的脚本。<ul><li>📄<code>run.sh</code>: 这个脚本是在Linux下运行所有测试样例。</li></ul></li><li>📂<code>windows</code>: Windows下面的脚本。<ul><li>📄<code>run.ps1</code>: 这个脚本是在Windows下运行所有测试样例。</li></ul></li></ul></li><li>📄<code>.clangd</code>: clangd配置文件。</li><li>📄<code>.editorconfig</code>: EditorConfig配置文件。</li><li>📄<code>.gitattributes</code>: Git配置文件。</li><li>📄<code>.gitignore</code>: Git Ignore文件，可以设定<code>git add</code>的时候，默认不包含的文件。</li><li>📄<code>README.md</code>: Read Me。</li><li>📄<code>sol.cpp</code>: C++语言的一个模板文件。</li></ul><h3 id="dev-container-相关环境"><a class="markdownIt-Anchor" href="#dev-container-相关环境"></a> Dev Container 相关环境</h3><p>Dev Container相关的环境主要是配置Code编译、运行的系统环境。在 algorithm<sup id="fnref:2" class="footnote-ref"><a href="#fn:2" rel="footnote"><span class="hint--top hint--rounded" aria-label="https://github.com/dianhsu/algorithm">[2]</span></a></sup>中，主要配置文件是<code>.devcontainer/devcontainer.json</code>和<code>.devcontainer/Dockerfile</code>。</p><p><code>.devcontainer/devcontainer.json</code>的文件内容如下所示。</p><figure><div class="code-wrapper"><pre class="line-numbers language-json5" data-language="json5" data-start="1"><code class="language-json5">&#x2F;&#x2F; For format details, see https:&#x2F;&#x2F;aka.ms&#x2F;devcontainer.json. For config options, see the&#x2F;&#x2F; README at: https:&#x2F;&#x2F;github.com&#x2F;devcontainers&#x2F;templates&#x2F;tree&#x2F;main&#x2F;src&#x2F;ubuntu&#123;    &quot;name&quot;: &quot;Algorithm&quot;, &#x2F;&#x2F; 定义Dev Container名称    &#x2F;&#x2F; Or use a Dockerfile or Docker Compose file. More info: https:&#x2F;&#x2F;containers.dev&#x2F;guide&#x2F;dockerfile    &quot;build&quot;: &#123;        &quot;dockerfile&quot;: &quot;Dockerfile&quot; &#x2F;&#x2F; 定义自定义的Dockerfile路径    &#125;,    &quot;remoteUser&quot;: &quot;root&quot;,     &quot;customizations&quot;: &#123;        &quot;vscode&quot;: &#123;            &quot;extensions&quot;: [ &#x2F;&#x2F; 定义VSCode的工作区插件                &quot;github.vscode-github-actions&quot;,                &quot;GitHub.copilot&quot;,                &quot;EditorConfig.EditorConfig&quot;,                &quot;vadimcn.vscode-lldb&quot;,                &quot;llvm-vs-code-extensions.vscode-clangd&quot;,                &quot;SanaAjani.taskrunnercode&quot;            ]        &#125;    &#125;,    &quot;overrideCommand&quot;: false &#x2F;&#x2F; 启动容器的时候，不Override容器的启动命令&#125;</code></pre></div></figure><p>插件<code>SanaAjani.taskrunnercode</code>的用途是可以在侧边栏直接鼠标点击运行<code>.vscode/tasks.json</code>里面的任务。</p><p>接下来看一下Dockerfile。</p><figure><div class="code-wrapper"><pre class="line-numbers language-Dockerfile" data-language="Dockerfile" data-start="1"><code class="language-Dockerfile"># 导入基础镜像GCCFROM gcc# 导入基础镜像Clang# FROM silkeh&#x2F;clang# 更新包数据库RUN apt-get update# 安装必要的软件包RUN apt-get install -y gdb build-essential curl sed unzip git jq libssl-dev ca-certificatesRUN mkdir ~&#x2F;tool &amp;&amp; mkdir ~&#x2F;tool&#x2F;bin# 安装ccsRUN curl -L $(curl -s https:&#x2F;&#x2F;api.github.com&#x2F;repos&#x2F;dianhsu-official&#x2F;ccs&#x2F;releases&#x2F;latest | jq &quot;.assets[0].browser_download_url&quot; | cut -d &#39;&quot;&#39; -f 2) -o dist.zip &amp;&amp; unzip dist.zip &amp;&amp; rm dist.zip &amp;&amp; mv ccs ~&#x2F;tool&#x2F;bin&#x2F;ccs &amp;&amp; chmod +x ~&#x2F;tool&#x2F;bin&#x2F;ccs# 安装clangdRUN curl -L $(curl -s https:&#x2F;&#x2F;api.github.com&#x2F;repos&#x2F;clangd&#x2F;clangd&#x2F;releases&#x2F;latest | jq &quot;.assets[0].browser_download_url&quot; | cut -d &#39;&quot;&#39; -f 2) -o dist.zip &amp;&amp; unzip dist.zip &amp;&amp; rm dist.zip &amp;&amp; mv clangd_*&#x2F; ~&#x2F;tool&#x2F;clangd# 如果想用zsh的话，可以把下面的注释取消掉。# RUN apt-get install -y zsh# RUN apt-get install -y git zsh \#     &amp;&amp; git clone https:&#x2F;&#x2F;github.com&#x2F;ohmyzsh&#x2F;ohmyzsh.git ~&#x2F;.oh-my-zsh \#     &amp;&amp; cp ~&#x2F;.oh-my-zsh&#x2F;templates&#x2F;zshrc.zsh-template ~&#x2F;.zshrc \#     &amp;&amp; usermod -s &#x2F;bin&#x2F;zsh rootRUN ln -s ~&#x2F;tool&#x2F;clangd&#x2F;bin&#x2F;clangd &#x2F;usr&#x2F;bin&#x2F;clangdRUN ln -s ~&#x2F;tool&#x2F;bin&#x2F;ccs &#x2F;usr&#x2F;bin&#x2F;ccsRUN apt autoremove -y \    &amp;&amp; apt clean -y \    &amp;&amp; rm -rf &#x2F;var&#x2F;lib&#x2F;apt&#x2F;lists&#x2F;*CMD [&quot;&#x2F;usr&#x2F;bin&#x2F;ccs&quot;, &quot;-w&quot;, &quot;&#x2F;workspaces&#x2F;algorithm&quot;, &quot;-v&quot;, &quot;-t&quot;, &quot;&#x2F;workspaces&#x2F;algorithm&#x2F;sol.cpp&quot;, &quot;-o&quot;]</code></pre></div></figure><p>ccs<sup id="fnref:1" class="footnote-ref"><a href="#fn:1" rel="footnote"><span class="hint--top hint--rounded" aria-label="https://github.com/dianhsu-official/ccs">[1]</span></a></sup>的主要功能是解析样例和生成模板代码。ccs的Usage如下所示。ccs需要搭配Competitive Companion<sup id="fnref:3" class="footnote-ref"><a href="#fn:3" rel="footnote"><span class="hint--top hint--rounded" aria-label="https://github.com/jmerle/competitive-companion">[3]</span></a></sup>，本质上ccs是一个简单的web服务器，Competitive Companion将解析好的样例和题目信息发送到ccs，ccs根据这些题目信息生成样例文件。至于模板文件则是通过ccs的执行参数中的templates来生成的。目前阶段，ccs生成模板代码只是简单copy文件，后来我想可以进行一些字符替换，比如替换时间和用户名什么的。</p><figure><div class="code-wrapper"><pre class="line-numbers language-none" data-start="1"><code class="language-none">Usage: ccs [OPTIONS]Options:  -w, --workspace &lt;WORKSPACE&gt;  store the workspace path [default: ]  -t, --templates &lt;TEMPLATES&gt;  templates: src&#x2F;main.rs, src&#x2F;model.rs, src&#x2F;template.rs [default: ]  -o, --open-by-vscode         allow open by vscode  -p, --port &lt;PORT&gt;            server port [default: 27121]  -v, --verbose                verbose mode  -h, --help                   Print help  -V, --version                Print version</code></pre></div></figure><p>因为我的代码文件夹会默认挂载到容器中的<code>/workspaces/algorithm</code>目录下，所以我把工作区目录设定为<code>/workspace/algorithm</code>，生成的代码就会在代码文件夹里面了，<code>templates</code>是模板代码的路径，如果需要设定多个模板代码，可以用逗号隔开多个路径就可以了。</p><p>dev container相关的配置主要就是这些了，接下来介绍下VSCode相关的配置。</p><h3 id="vscode相关的配置"><a class="markdownIt-Anchor" href="#vscode相关的配置"></a> VSCode相关的配置</h3><p>VSCode相关的配置主要定义了如何编写、编译、运行、测试和Debug代码文件的一些策略和命令。</p><p><code>.vscode/cpp.code-snippets</code>文件中，我定义了一个代码块，如下所示。</p><figure><div class="code-wrapper"><pre class="line-numbers language-json5" data-language="json5" data-start="1"><code class="language-json5">&#123;&#x2F;&#x2F; Place your algorithm 工作区 snippets here. Each snippet is defined under a snippet name and has a scope, prefix, body and &#x2F;&#x2F; description. Add comma separated ids of the languages where the snippet is applicable in the scope field. If scope &#x2F;&#x2F; is left empty or omitted, the snippet gets applied to all languages. The prefix is what is &#x2F;&#x2F; used to trigger the snippet and the body will be expanded and inserted. Possible variables are: &#x2F;&#x2F; $1, $2 for tab stops, $0 for the final cursor position, and $&#123;1:label&#125;, $&#123;2:another&#125; for placeholders. &#x2F;&#x2F; Placeholders with the same ids are connected.&#x2F;&#x2F; Example:&#x2F;&#x2F; &quot;Print to console&quot;: &#123;&#x2F;&#x2F; &quot;scope&quot;: &quot;javascript,typescript&quot;,&#x2F;&#x2F; &quot;prefix&quot;: &quot;log&quot;,&#x2F;&#x2F; &quot;body&quot;: [&#x2F;&#x2F; &quot;console.log(&#39;$1&#39;);&quot;,&#x2F;&#x2F; &quot;$2&quot;&#x2F;&#x2F; ],&#x2F;&#x2F; &quot;description&quot;: &quot;Log output to console&quot;&#x2F;&#x2F; &#125;&quot;Disjoint Union&quot;: &#123;&quot;scope&quot;: &quot;cpp&quot;,&quot;prefix&quot;: &quot;dsu&quot;,&quot;body&quot;: [&quot;class DSU &#123;&quot;,&quot;public:&quot;,&quot;  vector&lt;int&gt; fa;&quot;,&quot;  vector&lt;int&gt; size;&quot;,&quot;  DSU(int n): fa(n), sz(n, 1) &#123;&quot;,&quot;    iota(fa.begin(), fa.end(), 0);&quot;,&quot;  &#125;&quot;,&quot;  int tf(int x) &#123;&quot;,&quot;    if (fa[x] &#x3D;&#x3D; x) &#123;&quot;,&quot;       return x;&quot;,&quot;    &#125;&quot;,&quot;    return fa[x] &#x3D; tf(fa[x]);&quot;,&quot;  &#125;&quot;,&quot;  void mg(int x, int y) &#123;&quot;,&quot;    int a &#x3D; tf(x);&quot;,&quot;    int b &#x3D; tf(y);&quot;,&quot;    if (a &#x3D;&#x3D; b) &#123;&quot;,&quot;      return;&quot;,&quot;    &#125;&quot;,&quot;    if (size[a] &lt; size[b]) &#123;&quot;,&quot;      swap(a, b);&quot;,&quot;    &#125;&quot;,&quot;    fa[b] &#x3D; a;&quot;,&quot;    size[a] +&#x3D; size[b];&quot;,&quot;  &#125;&quot;,&quot;&#125;;&quot;]&#125;&#125;</code></pre></div></figure><p>当在C++源文件中输入<code>dsu</code>的时候，就会有个代码段的提示。选中这个提示，就会有对应的代码段插入到C++的源文件当中。<br /><img src="https://cdn.dianhsu.com/img/2023-12-30-16-27-53.png" alt="代码段提示" /></p><p><code>.vscode/launch.json</code>中定义的是debug文件的配置，参考文件内容如下所示。</p><figure><div class="code-wrapper"><pre class="line-numbers language-json5" data-language="json5" data-start="1"><code class="language-json5">&#123;    &#x2F;&#x2F; 使用 IntelliSense 了解相关属性。     &#x2F;&#x2F; 悬停以查看现有属性的描述。    &#x2F;&#x2F; 欲了解更多信息，请访问: https:&#x2F;&#x2F;go.microsoft.com&#x2F;fwlink&#x2F;?linkid&#x3D;830387    &quot;version&quot;: &quot;0.2.0&quot;,    &quot;configurations&quot;: [        &#123;            &quot;type&quot;: &quot;lldb&quot;,            &quot;request&quot;: &quot;launch&quot;,            &quot;name&quot;: &quot;Build &amp; Run (C++)&quot;,            &quot;program&quot;: &quot;$&#123;fileDirname&#125;&#x2F;run.elf&quot;,            &quot;args&quot;: [],            &quot;cwd&quot;: &quot;$&#123;fileDirname&#125;&quot;,            &quot;preLaunchTask&quot;: &quot;build cpp&quot;, &#x2F;&#x2F; debug之前先运行build cpp的task，这个task定义在.vscode&#x2F;tasks.json中            &quot;stdio&quot;: &quot;$&#123;fileDirname&#125;&#x2F;01.i.txt&quot;, &#x2F;&#x2F; 重定向标准输入到对应文件目录下的 01.i.txt，如果需要debug其他的文件，就需要手动改一改了        &#125;    ]&#125;</code></pre></div></figure><p>这个launch需要当前焦点窗口在题目所在的目录的C++ Source文件上面。在执行<code>Build &amp; Run (C++)</code>之前，需要先运行<code>build cpp</code>这个task，一方面是需要保证本地有<code>run.elf</code>这个文件，另一方面是为了保证<code>run.elf</code>是最新的状态。可以在VSCode中打上断点，然后通过Build &amp; Run进行Debug。</p><p>接下来看一下<code>.vscode/tasks.json</code>里面的文件内容。</p><figure><div class="code-wrapper"><pre class="line-numbers language-json5" data-language="json5" data-start="1"><code class="language-json5">&#123;    &#x2F;&#x2F; See https:&#x2F;&#x2F;go.microsoft.com&#x2F;fwlink&#x2F;?LinkId&#x3D;733558    &#x2F;&#x2F; for the documentation about the tasks.json format    &quot;version&quot;: &quot;2.0.0&quot;,    &quot;tasks&quot;: [        &#123;            &quot;label&quot;: &quot;build cpp&quot;,   &#x2F;&#x2F; 生成elf的task            &quot;type&quot;: &quot;shell&quot;,            &quot;linux&quot;: &#123;                &quot;command&quot;: &quot;g++&quot;,                &quot;args&quot;: [                    &quot;-g&quot;,                    &quot;$&#123;file&#125;&quot;,                    &quot;-o&quot;,                    &quot;$&#123;fileDirname&#125;&#x2F;run.elf&quot;                ],            &#125;,            &quot;options&quot;: &#123;                &quot;cwd&quot;: &quot;$&#123;fileDirname&#125;&quot;            &#125;,            &quot;problemMatcher&quot;: []        &#125;,        &#123;            &quot;label&quot;: &quot;run cpp&quot;,     &#x2F;&#x2F; 本地运行所有测试样例的task            &quot;type&quot;: &quot;shell&quot;,            &quot;linux&quot;: &#123;                &quot;command&quot;: &quot;$&#123;workspaceFolder&#125;&#x2F;scripts&#x2F;linux&#x2F;run.sh .&#x2F;run.elf&quot;            &#125;,            &quot;options&quot;: &#123;                &quot;cwd&quot;: &quot;$&#123;fileDirname&#125;&quot;            &#125;,            &quot;dependsOn&quot;: [                &quot;build cpp&quot;            ],            &quot;problemMatcher&quot;: []        &#125;    ]&#125;</code></pre></div></figure><p>目前的所有的Task都是根据Linux环境设定的。<code>build cpp</code>主要是生成可执行文件，<code>run cpp</code>是通过脚本<code>scripts/linux/run.sh</code>运行测试样例。</p><p><code>scripts/linux/run.sh</code>的文件内容如下所示。</p><figure><div class="code-wrapper"><pre class="line-numbers language-bash" data-language="bash" data-start="1"><code class="language-bash"># $1: executable filefor i in &#96;ls *.i.txt&#96;; do    id&#x3D;&#96;echo $i | cut -d&#39;.&#39; -f1&#96;    echo -n &quot;Running test case $id ... &quot;    $1 &lt; $i &gt; $id.a.txt # 重定向stdio到 $i，重定向stdout到 $id.a.txt    cnt&#x3D;&#96;diff -Z $id.o.txt $id.a.txt | wc -l&#96;   # 统计输出文件和期望输出的不同的行数    if [ $cnt -gt 0 ]; then        echo -e &quot;\033[0;31mFailed\033[0m.&quot; # 输出红色的 Failed        code --diff $id.o.txt $id.a.txt     # 通过VSCode来显示输入文件和期望输出的比较    else        echo -e &quot;\033[0;32mPassed\033[0m.&quot;  # 输出绿色的 Passed    fidone</code></pre></div></figure><p>点击左下角的<code>run cpp</code>这个task的运行效果如下图所示。<code>xx.o.txt</code>是样例输出，<code>xx.a.txt</code>是程序的输出，下图中的Code没写相关的逻辑，所以程序的输出是空白的。<br /><img src="https://cdn.dianhsu.com/img/2023-12-30-16-44-10.png" alt="运行效果" /></p><p>主要的配置文件已经介绍完毕，其余的Git、EditorConfig和clangd相关的配置文件则需要根据个人需求进行配置。</p><h2 id="参考"><a class="markdownIt-Anchor" href="#参考"></a> 参考</h2><section class="footnotes"><div class="footnote-list"><ol><li><span id="fn:1" class="footnote-text"><span><a href="https://github.com/dianhsu-official/ccs">https://github.com/dianhsu-official/ccs</a><a href="#fnref:1" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:2" class="footnote-text"><span><a href="https://github.com/dianhsu/algorithm">https://github.com/dianhsu/algorithm</a><a href="#fnref:2" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:3" class="footnote-text"><span><a href="https://github.com/jmerle/competitive-companion">https://github.com/jmerle/competitive-companion</a><a href="#fnref:3" rev="footnote" class="footnote-backref"> ↩</a></span></span></li></ol></div></section>]]>
      </content:encoded>
    </item>
    <item>
      <title>Dev Container：也许是一种比虚拟机更方便的虚拟开发环境</title>
      <link>https://www.dianhsu.com/2023/06/07/devcontainer/</link>
      <description>
        <![CDATA[<h2 id="dev-container介绍"><a class="markdownIt-Anchor" href="#dev-container介绍"></a> Dev Container介绍</h2>
<p>之前在用Vagrant<sup id="fnref:4"]]>
      </description>
      <author>Dian Hsu</author>
      <category domain="https://www.dianhsu.com/categories/%E5%B7%A5%E5%85%B7/">工具</category>
      <category domain="https://www.dianhsu.com/tags/%E8%99%9A%E6%8B%9F%E7%8E%AF%E5%A2%83/">虚拟环境</category>
      <category domain="https://www.dianhsu.com/tags/Docker/">Docker</category>
      <pubDate>Wed, 07 Jun 2023 05:03:59 GMT</pubDate>
      <content:encoded>
        <![CDATA[<h2 id="dev-container介绍"><a class="markdownIt-Anchor" href="#dev-container介绍"></a> Dev Container介绍</h2><p>之前在用Vagrant<sup id="fnref:4" class="footnote-ref"><a href="#fn:4" rel="footnote"><span class="hint--top hint--rounded" aria-label="https://www.vagrantup.com/">[4]</span></a></sup> + VirtualBox的虚拟环境进行OpenWrt编译，因为Vagrant + VirtualBox的方式可以在Windows上面提供一个可分发的、独立的Linux开发环境，可以很方便地在多个不同的桌面环境下使用完全相同的开发环境。但是使用Vagrant + VirtualBox的虚拟开发环境也存在一些问题，这些问题主要有：</p><ol><li>虚拟机启动比较慢，Vagrant偶尔不能获取到VirtualBox的状态。此外虚拟机偶尔不能正常关机，需要使用强制关机的方式才可以关机。</li><li>虚拟机运行过程中占用的系统资源（CPU核心数、内存）比较多。如果电脑配置不太高，运行虚拟机的同时运行其他程序会感觉到一些卡顿。</li><li>虚拟机的镜像文件比较大，通常是几GB到十几GB的大小，在多个桌面环境下进行安装，对网络的要求比较高。</li></ol><p>考虑到Vagrant + VirtualBox的这些不足，因为Vagrant也支持Docker作为Provider，尝试使用Docker容器代替VirtualBox这个Provider。Docker Container和虚拟机都是在于底层硬件隔离的环境中部署应用程序的方式，这两种方式方式的区别，主要在于隔离的级别不同。Docker Container相对于虚拟机的隔离级别比较低，所以Docker Container的容器比较轻巧、打包的容量比较小并且启动速度比较快。</p><p><img src="https://cdn.dianhsu.com/img/2023-06-07-19-06-21.png" alt="Virtual Machines 和 Containers 的对比" /></p><p>在使用Docker作为Vagrant的Provider之后，考虑到常用的编辑器和IDE均对Docker已有支持，在使用Docker的情况下，就不再使用Vagrant来管理Container了。Visual Studio Code提供了一种对使用Docker作为开发环境更友好的方式——Dev Container<sup id="fnref:1" class="footnote-ref"><a href="#fn:1" rel="footnote"><span class="hint--top hint--rounded" aria-label="https://code.visualstudio.com/docs/devcontainers/containers">[1]</span></a></sup><sup id="fnref:2" class="footnote-ref"><a href="#fn:2" rel="footnote"><span class="hint--top hint--rounded" aria-label="https://containers.dev/">[2]</span></a></sup>，这里就使用Visual Studio Code + Dev Container的方式进行介绍。</p><h2 id="dev-container安装及使用"><a class="markdownIt-Anchor" href="#dev-container安装及使用"></a> Dev Container安装及使用</h2><p>首先下载并安装Visual Studio Code和Docker Engine，Visual Studio Code的下载地址是：<a href="https://code.visualstudio.com/#alt-downloads">https://code.visualstudio.com/#alt-downloads</a>，Docker Engine的下载地址是：<a href="https://docs.docker.com/engine/install/">https://docs.docker.com/engine/install/</a>，在支持Docker Desktop的平台上，也可以选择安装Docker Desktop。</p><p>在安装好Visual Studio Code和Docker Engine之后，使用Visual Studio Code打开目标项目的工作目录，点击Visual Studio Code界面左下角的启动远程连接的按钮，启动远程连接的按钮如下图所示：<br /><img src="https://cdn.dianhsu.com/img/2023-06-07-20-24-18.png" alt="启动远程连接的按钮" /></p><p>点击启动远程连接的按钮之后，就会出现远程连接的选项界面，这里点击选项<code>添加开发容器配置文件...</code>。</p><p><img src="https://cdn.dianhsu.com/img/2023-06-07-20-26-13.png" alt="远程连接选项" /></p><p>在接下来的步骤中依次选择需要的容器的操作系统、容器的操作系统版本以及容器中附带的软件。这里我选择的是Ubuntu(Jammy)并且不安装任何附加软件。点击确定之后，在当前Visual Studio Code打开的项目的根目录下会生成一个<code>.devcontainer</code>的文件夹，在这个文件夹中包含一个<code>devcontainer.json</code>文件，文件的内容如下所示：</p><figure><div class="code-wrapper"><pre class="line-numbers language-json5" data-language="json5" data-start="1"><code class="language-json5">&#x2F;&#x2F; For format details, see https:&#x2F;&#x2F;aka.ms&#x2F;devcontainer.json. For config options, see the&#x2F;&#x2F; README at: https:&#x2F;&#x2F;github.com&#x2F;devcontainers&#x2F;templates&#x2F;tree&#x2F;main&#x2F;src&#x2F;ubuntu&#123;&quot;name&quot;: &quot;Ubuntu&quot;,&#x2F;&#x2F; Or use a Dockerfile or Docker Compose file. More info: https:&#x2F;&#x2F;containers.dev&#x2F;guide&#x2F;dockerfile&quot;image&quot;: &quot;mcr.microsoft.com&#x2F;devcontainers&#x2F;base:jammy&quot;&#x2F;&#x2F; Features to add to the dev container. More info: https:&#x2F;&#x2F;containers.dev&#x2F;features.&#x2F;&#x2F; &quot;features&quot;: &#123;&#125;,&#x2F;&#x2F; Use &#39;forwardPorts&#39; to make a list of ports inside the container available locally.&#x2F;&#x2F; &quot;forwardPorts&quot;: [],&#x2F;&#x2F; Use &#39;postCreateCommand&#39; to run commands after the container is created.&#x2F;&#x2F; &quot;postCreateCommand&quot;: &quot;uname -a&quot;,&#x2F;&#x2F; Configure tool-specific properties.&#x2F;&#x2F; &quot;customizations&quot;: &#123;&#125;,&#x2F;&#x2F; Uncomment to connect as root instead. More info: https:&#x2F;&#x2F;aka.ms&#x2F;dev-containers-non-root.&#x2F;&#x2F; &quot;remoteUser&quot;: &quot;root&quot;&#125;</code></pre></div></figure><p>这样，我们项目就拥有了一个Dev Container基础环境。接下来，我们从容器中打开我们项目的工作目录。点击左下角启动远程连接的按钮，在远程连接的选项界面出现了一个新的选项<code>在容器中重新打开</code>，我们点击这个选项。</p><p><img src="https://cdn.dianhsu.com/img/2023-06-07-20-36-35.png" alt="新的选项“在容器中重新打开”出现" /></p><p>左下角远程连接变成<code>开发容器:xxx</code>之后，就代表已经从容器中打开了当前项目。此时打开终端，就可以看到当前目录为<code>/workspaces/&lt;项目目录名称&gt;/</code>，因为容器会自动挂在当前项目目录到<code>/workspaces/</code>中。到这里，我们就可以愉快地在容器中进行软件开发啦。😊</p><p><img src="https://cdn.dianhsu.com/img/2023-06-07-20-42-37.png" alt="通过Dev Container打开项目" /></p><h2 id="基于dev-container的codeforces竞赛环境配置"><a class="markdownIt-Anchor" href="#基于dev-container的codeforces竞赛环境配置"></a> 基于Dev Container的Codeforces竞赛环境配置</h2><p>这里演示下用Dev Container进行Codeforces竞赛环境配置。首先在桌面上创建一个名叫<code>algorithm</code>的文件夹，之后我们Codeforces的代码都放在这里了。接下来用Visual Studio Code打开这个目录。</p><p>这里我们想自定义容器镜像，就不使用Dev Container创建配置文件的工具了，而是选择手动创建这些文件。在<code>algorithm</code>目录下创建一个名为<code>.devcontainer</code>的文件夹，在<code>.devcontainer</code>目录中创建两个空白文件，文件名为<code>devcontainer.json</code>和<code>Dockerfile</code>文件。</p><p><code>.devcontainer/devcontainer.json</code>的文件内容如下所示：</p><blockquote><p>这里的配置文件中多了<code>build</code>键和<code>mounts</code>键，少了一个<code>image</code>键。<br /><code>build</code>键是代表我们的容器环境是从本地的Dockerfile构建的，上面的配置文件中拥有的<code>image</code>键代表的是从远端拉取容器镜像。<br /><code>mounts</code>键是挂载卷到容器的某个目录，这里是挂载了cf-tool的配置文件目录，即使容器销毁，下次打开容器依旧可以用之前写好的配置文件。<br />详细的配置文件可以参考官方的references<sup id="fnref:7" class="footnote-ref"><a href="#fn:7" rel="footnote"><span class="hint--top hint--rounded" aria-label="https://containers.dev/implementors/json_reference/">[7]</span></a></sup>。</p></blockquote><figure><div class="code-wrapper"><pre class="line-numbers language-json5" data-language="json5" data-start="1"><code class="language-json5">&#x2F;&#x2F; For format details, see https:&#x2F;&#x2F;aka.ms&#x2F;devcontainer.json. For config options, see the&#x2F;&#x2F; README at: https:&#x2F;&#x2F;github.com&#x2F;devcontainers&#x2F;templates&#x2F;tree&#x2F;main&#x2F;src&#x2F;ubuntu&#123;&quot;name&quot;: &quot;Algorithm&quot;,&#x2F;&#x2F; Or use a Dockerfile or Docker Compose file. More info: https:&#x2F;&#x2F;containers.dev&#x2F;guide&#x2F;dockerfile&quot;build&quot;: &#123;&quot;dockerfile&quot;: &quot;Dockerfile&quot;&#125;,&quot;mounts&quot;: [&#123;&quot;source&quot;: &quot;cf-volume&quot;,&quot;target&quot;: &quot;&#x2F;root&#x2F;.cf&#x2F;&quot;,&quot;type&quot;: &quot;volume&quot;&#125;],&#x2F;&#x2F; Features to add to the dev container. More info: https:&#x2F;&#x2F;containers.dev&#x2F;features.&#x2F;&#x2F; &quot;features&quot;: &#123;&#125;,&#x2F;&#x2F; Use &#39;forwardPorts&#39; to make a list of ports inside the container available locally.&#x2F;&#x2F; &quot;forwardPorts&quot;: [],&#x2F;&#x2F; Use &#39;postCreateCommand&#39; to run commands after the container is created.&#x2F;&#x2F; &quot;postCreateCommand&quot;: &quot;uname -a&quot;,&#x2F;&#x2F; Configure tool-specific properties.&#x2F;&#x2F; &quot;customizations&quot;: &#123;&#125;,&#x2F;&#x2F; Uncomment to connect as root instead. More info: https:&#x2F;&#x2F;aka.ms&#x2F;dev-containers-non-root.&quot;remoteUser&quot;: &quot;root&quot;&#125;</code></pre></div></figure><p><code>.devcontainer/Dockerfile</code>的文件内容如下所示：</p><blockquote><p>这里设置容器所需要的镜像，作为一个C++选手，自然要选择带了GCC的容器了。虽然可以用Ubuntu的镜像安装GCC，但是Ubuntu的源中的GCC版本落后于GNU官方提供的GCC容器<sup id="fnref:3" class="footnote-ref"><a href="#fn:3" rel="footnote"><span class="hint--top hint--rounded" aria-label="https://hub.docker.com/_/gcc">[3]</span></a></sup>，所以这里直接选择的就是GCC的容器。其他语言的选手，可以在Docker Hub<sup id="fnref:6" class="footnote-ref"><a href="#fn:6" rel="footnote"><span class="hint--top hint--rounded" aria-label="https://hub.docker.com/">[6]</span></a></sup>或者其他的平台寻找适合自己的基础镜像。<br />接下来安装cf-tool就可以了</p></blockquote><figure><div class="code-wrapper"><pre class="line-numbers language-Dockerfile" data-language="Dockerfile" data-start="1"><code class="language-Dockerfile"># 导入基础镜像GCCFROM gcc# 更新包数据库RUN apt-get update# 安装必要的软件包RUN apt-get install -y gdb build-essential curl sed unzip# 安装cf-toolRUN curl -L $(curl -s https:&#x2F;&#x2F;api.github.com&#x2F;repos&#x2F;dianhsu&#x2F;cf-tool&#x2F;releases&#x2F;latest | grep &#x2F;cf_linux_x64.zip | cut -d &#39;&quot;&#39; -f 4) -o dist.zip &amp;&amp; unzip dist.zip &amp;&amp; rm dist.zip &amp;&amp; mv cf &#x2F;usr&#x2F;bin&#x2F;cf &amp;&amp; chmod a+x &#x2F;usr&#x2F;bin&#x2F;cf</code></pre></div></figure><p>填写好上面两个文件之后，看到的文件结构和文件内容如下图所示：</p><p><img src="https://cdn.dianhsu.com/img/2023-06-07-21-02-21.png" alt="创建文件之后的效果" /></p><p>接下来点击Visual Studio Code左下角的远程连接按钮，从远程连接选项中选择<code>在容器中重新打开</code>，就可以从容器中打开<code>algorithm</code>目录了，我们从命令行运行了一下<code>cf-tool</code><sup id="fnref:5" class="footnote-ref"><a href="#fn:5" rel="footnote"><span class="hint--top hint--rounded" aria-label="https://github.com/dianhsu/cf-tool">[5]</span></a></sup>工具，效果如下图所示。<br /><img src="https://cdn.dianhsu.com/img/2023-06-07-21-00-04.png" alt="从容器打开项目文件夹" /></p><p><code>algorithm</code>目录已经挂载到容器中的<code>/workspaces/algorithm</code>处。为了在不打开容器的时候也可以访问提交的代码，最好将代码放在<code>algorithm</code>当中。在上面这样的环境设置下，容器销毁之后，容器中<code>/root/.cf/</code>和<code>/workspaces/algorithm/</code>这两个目录依旧存在，而只有<code>/workspaces/algorithm/</code>可以在宿机中直接访问。<code>/root/.cf/</code>这个目录，也就是<code>cf-volume</code>可以在Docker的Volumes里面看到，这个目录只有挂载到容器中才能访问，不可以通过宿机直接访问。</p><p><img src="https://cdn.dianhsu.com/img/2023-06-07-21-21-52.png" alt="Docker的Volumes" /></p><h3 id="tips"><a class="markdownIt-Anchor" href="#tips"></a> Tips</h3><p>使用Dev Container作为Codeforces竞赛环境的Tips：</p><ul><li>可以在项目目录下写几个tasks方便编译、运行、调试和提交代码。</li><li>可以一边写代码，一边玩游戏了，不卡🤣🤣🤣。</li><li>容器镜像的管理工作流可以根据自己的喜好选择，可以选择本地构建，也可以选择远程自动构建并托管到Docker Hub之类的平台上。</li></ul><p>作为一个工具控，对更加便利、高效的开发环境的追求是没有止境的，欢迎大家po一下自己的开发方式，感谢🎉🎉🎉。</p><h2 id="参考"><a class="markdownIt-Anchor" href="#参考"></a> 参考</h2><section class="footnotes"><div class="footnote-list"><ol><li><span id="fn:1" class="footnote-text"><span><a href="https://code.visualstudio.com/docs/devcontainers/containers">https://code.visualstudio.com/docs/devcontainers/containers</a><a href="#fnref:1" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:2" class="footnote-text"><span><a href="https://containers.dev/">https://containers.dev/</a><a href="#fnref:2" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:3" class="footnote-text"><span><a href="https://hub.docker.com/_/gcc">https://hub.docker.com/_/gcc</a><a href="#fnref:3" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:4" class="footnote-text"><span><a href="https://www.vagrantup.com/">https://www.vagrantup.com/</a><a href="#fnref:4" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:5" class="footnote-text"><span><a href="https://github.com/dianhsu/cf-tool">https://github.com/dianhsu/cf-tool</a><a href="#fnref:5" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:6" class="footnote-text"><span><a href="https://hub.docker.com/">https://hub.docker.com/</a><a href="#fnref:6" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:7" class="footnote-text"><span><a href="https://containers.dev/implementors/json_reference/">https://containers.dev/implementors/json_reference/</a><a href="#fnref:7" rev="footnote" class="footnote-backref"> ↩</a></span></span></li></ol></div></section>]]>
      </content:encoded>
    </item>
    <item>
      <title>Vagrant：一款方便、快捷虚拟机管理工具</title>
      <link>https://www.dianhsu.com/2023/04/17/vagrant/</link>
      <description>
        <![CDATA[<p>最近在编译OpenWrt，因为Windows下面无法交叉编译，装个虚拟机临时用一用。下载Archlinux的时候，发现一个好用的虚拟机管理工具——vagrant。vagrant主要有以下几个功能：</p>
<ul>
<li>可以零配置新建一个虚拟机环境，省去了繁杂的配置过程]]>
      </description>
      <author>Dian Hsu</author>
      <category domain="https://www.dianhsu.com/categories/%E5%B7%A5%E5%85%B7/">工具</category>
      <category domain="https://www.dianhsu.com/tags/%E8%99%9A%E6%8B%9F%E7%8E%AF%E5%A2%83/">虚拟环境</category>
      <category domain="https://www.dianhsu.com/tags/vagrant/">vagrant</category>
      <pubDate>Mon, 17 Apr 2023 08:04:50 GMT</pubDate>
      <content:encoded>
        <![CDATA[<p>最近在编译OpenWrt，因为Windows下面无法交叉编译，装个虚拟机临时用一用。下载Archlinux的时候，发现一个好用的虚拟机管理工具——vagrant。vagrant主要有以下几个功能：</p><ul><li>可以零配置新建一个虚拟机环境，省去了繁杂的配置过程<figure><div class="code-wrapper"><pre class="line-numbers language-bash" data-language="bash" data-start="1"><code class="language-bash">vagrant init archlinux&#x2F;archlinux # 新建一个Vagrantfile配置文件，并配置os为Archlinuxvagrant up # 下载镜像、配置虚拟机和启动虚拟机</code></pre></div></figure></li><li>快速连接虚拟机<figure><div class="code-wrapper"><pre class="line-numbers language-bash" data-language="bash" data-start="1"><code class="language-bash">vagrant ssh # 连接Vagrantfile管理的虚拟机</code></pre></div></figure></li><li>打包虚拟机镜像，并分发<figure><div class="code-wrapper"><pre class="line-numbers language-bash" data-language="bash" data-start="1"><code class="language-bash">vagrant package --base &quot;my-algorithm-virtualmachine&quot; --output algorithm.box # 将虚拟机打包成box文件，可以托管到Vagrant cloud</code></pre></div></figure></li></ul><p>vagrant提供了虚拟机创建、管理、链接和打包的功能，给虚拟机使用了提供了极大的便利。</p><h2 id="vagrant的安装sup-idfnref1-classfootnote-refa-hreffn1-relfootnotespan-classhint-top-hint-rounded-aria-labelhttpsdeveloperhashicorpcomvagrantdocsinstallation1spanasup"><a class="markdownIt-Anchor" href="#vagrant的安装sup-idfnref1-classfootnote-refa-hreffn1-relfootnotespan-classhint-top-hint-rounded-aria-labelhttpsdeveloperhashicorpcomvagrantdocsinstallation1spanasup"></a> Vagrant的安装<sup id="fnref:1" class="footnote-ref"><a href="#fn:1" rel="footnote"><span class="hint--top hint--rounded" aria-label="https://developer.hashicorp.com/vagrant/docs/installation">[1]</span></a></sup></h2><p>Vagrant安装前，需要配置好虚拟机环境（Provider），如：VirtualBox、VMware Workspace、QEMU等，这里用的是VirtualBox。在Windows下使用VirtualBox的时候，需要关掉Hyper-V。Windows 10可以在Powershell中使用以下命令关闭Hyper-V。</p><figure><div class="code-wrapper"><pre class="line-numbers language-ps1" data-language="ps1" data-start="1"><code class="language-ps1">Disable-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V-All</code></pre></div></figure><p>如果是Windows 11用户，可以在Powershell中使用以下命令关闭Hyper-V。</p><figure><div class="code-wrapper"><pre class="line-numbers language-ps1" data-language="ps1" data-start="1"><code class="language-ps1">bcdedit &#x2F;set hypervisorlaunchtype off</code></pre></div></figure><p>装好VirtualBox之后，从Vagrant的下载页面<sup id="fnref:2" class="footnote-ref"><a href="#fn:2" rel="footnote"><span class="hint--top hint--rounded" aria-label="https://developer.hashicorp.com/vagrant/downloads">[2]</span></a></sup>下载Vagrant的安装文件并安装好Vagrant。</p><p>安装成功之后，当在Powershell中执行<code>vagrant version</code>后，会出现以下内容。</p><figure><div class="code-wrapper"><pre class="line-numbers language-none" data-start="1"><code class="language-none">Installed Version: 2.3.4Latest Version: 2.3.4You&#39;re running an up-to-date version of Vagrant!</code></pre></div></figure><h2 id="vagrant的使用"><a class="markdownIt-Anchor" href="#vagrant的使用"></a> Vagrant的使用</h2><p>安装好vagrant之后，新建一个vagrantfile可以在当前目录下执行以下命令。</p><figure><div class="code-wrapper"><pre class="line-numbers language-bash" data-language="bash" data-start="1"><code class="language-bash">vagrant init archlinux&#x2F;archlinux</code></pre></div></figure><p>当执行<code>vagrant up</code>命令的时候，vagrant会从本地寻找<code>archlinux/archlinux</code>这个名称的box。如果本地box列表中不存在这个名称的box的话，vagrant会自动从vagrant cloud<sup id="fnref:3" class="footnote-ref"><a href="#fn:3" rel="footnote"><span class="hint--top hint--rounded" aria-label="https://app.vagrantup.com/boxes/search">[3]</span></a></sup>下载这个box。在使用的过程中，可以先去vagrant cloud搜索一下自己的Provider的镜像。<br />当虚拟机启动完成之后，就可以通过<code>vagrant ssh</code>连接到此虚拟机了。<br />另外，正常关闭虚拟机，使用<code>vagrant halt</code>命令。删除虚拟机，使用<code>vagrant destroy</code>命令。</p><p>总结一下：</p><ul><li><code>vagrant init &lt;box name&gt;</code> 创建虚拟机配置文件，如果需要编辑网络、内存和硬盘等设置，可以在这一步之后，修改Vagrantfile配置文件，详细的配置文件设置可以参考官方文档中Vagrantfile<sup id="fnref:4" class="footnote-ref"><a href="#fn:4" rel="footnote"><span class="hint--top hint--rounded" aria-label="https://app.vagrantup.com/boxes/search">[4]</span></a></sup>这一页。</li><li><code>vagrant up</code> 下载虚拟机镜像，执行虚拟机配置并启动虚拟机。</li><li><code>vagrant ssh</code> 通过ssh连接到虚拟机</li><li><code>vagrant halt</code> 关闭虚拟机</li><li><code>vagrant destroy</code> 删除虚拟机</li></ul><h2 id="安利自己的codeforces环境"><a class="markdownIt-Anchor" href="#安利自己的codeforces环境"></a> 安利自己的Codeforces环境</h2><p>每次换了电脑，或者重装系统之后，重新配一套Codeforces环境确实也很麻烦。了解vagrant之后，使用vagrant搭建了一套Codeforces用的虚拟环境。</p><p>使用方法：</p><figure><div class="code-wrapper"><pre class="line-numbers language-bash" data-language="bash" data-start="1"><code class="language-bash">vagrant init dianhsu&#x2F;archlinuxvagrant up</code></pre></div></figure><p>这套环境是基于ArchLinux的镜像的，里面主要安装的软件如下所示：</p><ul><li>vim9 + SpaceVim<sup id="fnref:5" class="footnote-ref"><a href="#fn:5" rel="footnote"><span class="hint--top hint--rounded" aria-label="https://spacevim.org/">[5]</span></a></sup> + coc<sup id="fnref:9" class="footnote-ref"><a href="#fn:9" rel="footnote"><span class="hint--top hint--rounded" aria-label="https://github.com/neoclide/coc.nvim">[9]</span></a></sup>（Vim配置环境）</li><li>nvm<sup id="fnref:6" class="footnote-ref"><a href="#fn:6" rel="footnote"><span class="hint--top hint--rounded" aria-label="https://github.com/nvm-sh/nvm">[6]</span></a></sup>（NodeJs版本管理器）</li><li>cf-tool<sup id="fnref:7" class="footnote-ref"><a href="#fn:7" rel="footnote"><span class="hint--top hint--rounded" aria-label="https://github.com/dianhsu/cf-tool">[7]</span></a></sup>（Codeforces命令行工具）</li><li>oh-my-zsh<sup id="fnref:8" class="footnote-ref"><a href="#fn:8" rel="footnote"><span class="hint--top hint--rounded" aria-label="https://ohmyz.sh/">[8]</span></a></sup></li></ul><h2 id="参考"><a class="markdownIt-Anchor" href="#参考"></a> 参考</h2><section class="footnotes"><div class="footnote-list"><ol><li><span id="fn:1" class="footnote-text"><span><a href="https://developer.hashicorp.com/vagrant/docs/installation">https://developer.hashicorp.com/vagrant/docs/installation</a><a href="#fnref:1" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:2" class="footnote-text"><span><a href="https://developer.hashicorp.com/vagrant/downloads">https://developer.hashicorp.com/vagrant/downloads</a><a href="#fnref:2" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:3" class="footnote-text"><span><a href="https://app.vagrantup.com/boxes/search">https://app.vagrantup.com/boxes/search</a><a href="#fnref:3" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:4" class="footnote-text"><span><a href="https://app.vagrantup.com/boxes/search">https://app.vagrantup.com/boxes/search</a><a href="#fnref:4" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:5" class="footnote-text"><span><a href="https://spacevim.org/">https://spacevim.org/</a><a href="#fnref:5" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:6" class="footnote-text"><span><a href="https://github.com/nvm-sh/nvm">https://github.com/nvm-sh/nvm</a><a href="#fnref:6" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:7" class="footnote-text"><span><a href="https://github.com/dianhsu/cf-tool">https://github.com/dianhsu/cf-tool</a><a href="#fnref:7" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:8" class="footnote-text"><span><a href="https://ohmyz.sh/">https://ohmyz.sh/</a><a href="#fnref:8" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:9" class="footnote-text"><span><a href="https://github.com/neoclide/coc.nvim">https://github.com/neoclide/coc.nvim</a><a href="#fnref:9" rev="footnote" class="footnote-backref"> ↩</a></span></span></li></ol></div></section>]]>
      </content:encoded>
    </item>
    <item>
      <title>Codeforces Round 826 (Div.3)</title>
      <link>https://www.dianhsu.com/2022/10/12/cf1741/</link>
      <description>
        <![CDATA[<h1 id="a-compare-t-shirt-sizes"><a class="markdownIt-Anchor" href="#a-compare-t-shirt-sizes"></a> A. Compare T-Shirt]]>
      </description>
      <author>Dian Hsu</author>
      <category domain="https://www.dianhsu.com/categories/Codeforces/">Codeforces</category>
      <category domain="https://www.dianhsu.com/tags/%E7%AE%97%E6%B3%95/">算法</category>
      <category domain="https://www.dianhsu.com/tags/Codeforces/">Codeforces</category>
      <pubDate>Wed, 12 Oct 2022 02:45:30 GMT</pubDate>
      <content:encoded>
        <![CDATA[<h1 id="a-compare-t-shirt-sizes"><a class="markdownIt-Anchor" href="#a-compare-t-shirt-sizes"></a> A. Compare T-Shirt Sizes</h1><p><strong>题目大意</strong></p><p>给你两个T恤的尺码，问你两个T恤的尺码的大小关系。尺码是有三种主要类型SML，分别代表Small，Medium，Large。SML的大小关系是S &lt; M &lt; L。Small和Large两种类型的尺码，可以在前面加上若干个X。X越多，对于S类型就越小，对于L类型就越大。</p><p><strong>题解</strong></p><p>主要是分类型讨论，然后判断大小关系。</p><ol><li>如果两个T恤的类型字符串完全相同：那么这两个T恤的尺码大小相同。</li><li>如果两个T恤的类型字符串不同：<ol><li>如果两个T恤的主要类型（SML）相同：<ol><li>S类型的T恤，X的个数越多，尺码越小。</li><li>L类型的T恤，X的个数越多，尺码越大。</li></ol></li><li>如果两个T恤的主要类型不同：<ol><li>第一件T恤尺寸大于第二件T恤尺寸的条件是：<ol><li>第一件T恤的主要类型是L</li><li>第一件T恤的主要类型是M，第二件T恤的主要类型是S</li></ol></li><li>其他情况是第一件T恤尺寸小于第二件T恤尺寸。</li></ol></li></ol></li></ol><p><strong>参考代码</strong></p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">#include &lt;bits&#x2F;stdc++.h&gt;using namespace std;int main()&#123;  int t;  cin &gt;&gt; t;  while(t--)&#123;    string a, b;    cin &gt;&gt; a &gt;&gt; b;    if(a &#x3D;&#x3D; b) cout &lt;&lt; &quot;&#x3D;\n&quot;;    else&#123;      if(a.back() &#x3D;&#x3D; b.back())&#123;        if(a.back() &#x3D;&#x3D; &#39;S&#39;)&#123;          cout &lt;&lt; (a.length() &gt; b.length() ? &quot;&lt;&quot; : &quot;&gt;&quot;) &lt;&lt; endl;        &#125;else&#123;          cout &lt;&lt; (a.length() &gt; b.length() ? &quot;&gt;&quot; : &quot;&lt;&quot;) &lt;&lt; endl;        &#125;      &#125;else if(a.back() &#x3D;&#x3D; &#39;L&#39; or (a.back() &#x3D;&#x3D; &#39;M&#39; and b.back() &#x3D;&#x3D; &#39;S&#39;))&#123;        cout &lt;&lt; &quot;&gt;&quot; &lt;&lt; endl;      &#125;else&#123;        cout &lt;&lt; &quot;&lt;&quot; &lt;&lt; endl;      &#125;    &#125;  &#125;  return 0;&#125;</code></pre></div></figure><h1 id="b-funny-permutation"><a class="markdownIt-Anchor" href="#b-funny-permutation"></a> B. Funny Permutation</h1><p><strong>题目大意</strong></p><p>给你一个长度为n，构造一个元素为1到n的排列p，使得这个排列满足以下条件：</p><ol><li>对于任意的i，都有 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>p</mi><mi>i</mi></msub><mo mathvariant="normal">≠</mo><mi>i</mi></mrow><annotation encoding="application/x-tex">p_i \neq i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal">p</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel"><span class="mrel"><span class="mord vbox"><span class="thinbox"><span class="rlap"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="inner"><span class="mrel"></span></span><span class="fix"></span></span></span></span></span><span class="mrel">=</span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.65952em;vertical-align:0em;"></span><span class="mord mathnormal">i</span></span></span></span>。</li><li>对于任意一个i，都有 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi mathvariant="normal">∣</mi><msub><mi>p</mi><mi>i</mi></msub><mo>−</mo><msub><mi>p</mi><mrow><mi>i</mi><mo>−</mo><mn>1</mn></mrow></msub><mi mathvariant="normal">∣</mi><mo>=</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">| p_i - p_{i - 1} | = 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">∣</span><span class="mord"><span class="mord mathnormal">p</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">p</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.311664em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">i</span><span class="mbin mtight">−</span><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.208331em;"><span></span></span></span></span></span></span><span class="mord">∣</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> 或者 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi mathvariant="normal">∣</mi><msub><mi>p</mi><mi>i</mi></msub><mo>−</mo><msub><mi>p</mi><mrow><mi>i</mi><mo>+</mo><mn>1</mn></mrow></msub><mi mathvariant="normal">∣</mi><mo>=</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">| p_i - p_{i + 1} | = 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">∣</span><span class="mord"><span class="mord mathnormal">p</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">p</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.311664em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">i</span><span class="mbin mtight">+</span><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.208331em;"><span></span></span></span></span></span></span><span class="mord">∣</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span></li></ol><p><strong>题解</strong></p><ol><li>如果n为偶数，那么可以直接构造一个递减的排列， <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mo separator="true">,</mo><mi>n</mi><mo>−</mo><mn>1</mn><mo separator="true">,</mo><mi>n</mi><mo>−</mo><mn>2</mn><mo separator="true">,</mo><mo>…</mo><mo separator="true">,</mo><mn>2</mn><mo separator="true">,</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">n, n - 1, n - 2, \dots, 2, 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7777700000000001em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">n</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.8388800000000001em;vertical-align:-0.19444em;"></span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.8388800000000001em;vertical-align:-0.19444em;"></span><span class="mord">2</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="minner">…</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">2</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">1</span></span></span></span>。逆序之后因为偶数是放在奇数编号的位置，奇数都放在偶数编号位置，所以满足条件1。</li><li>如果n为奇数，那么可以将前面三个元素移动到末尾，<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn><mo separator="true">,</mo><mn>5</mn><mo separator="true">,</mo><mn>6</mn><mo separator="true">,</mo><mo>…</mo><mo separator="true">,</mo><mi>n</mi><mo>−</mo><mn>1</mn><mo separator="true">,</mo><mi>n</mi><mo separator="true">,</mo><mn>1</mn><mo separator="true">,</mo><mn>2</mn><mo separator="true">,</mo><mn>3</mn></mrow><annotation encoding="application/x-tex">4, 5, 6, \dots, n - 1, n, 1, 2, 3</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8388800000000001em;vertical-align:-0.19444em;"></span><span class="mord">4</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">5</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">6</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="minner">…</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.8388800000000001em;vertical-align:-0.19444em;"></span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal">n</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">2</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">3</span></span></span></span>。如果n等于3，那么无法构造出一个满足两个条件的排列，所以输出-1。</li></ol><p><strong>参考代码</strong></p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">#include &lt;bits&#x2F;stdc++.h&gt; using namespace std; int main()&#123;  int t;  cin &gt;&gt; t;  while(t--)&#123;    int n;    cin &gt;&gt; n;    if(n &amp; 1)&#123;      if(n &#x3D;&#x3D; 3) cout &lt;&lt; -1 &lt;&lt; endl;      else&#123;        for(int i &#x3D; 4; i &lt;&#x3D; n; ++i) cout &lt;&lt; i &lt;&lt; &quot; &quot;;        cout &lt;&lt; &quot;1 2 3&quot; &lt;&lt; endl;      &#125;    &#125;else&#123;      for(int i &#x3D; n; i &gt;&#x3D; 1; --i)&#123;         cout &lt;&lt; i &lt;&lt; &quot; &quot;;      &#125;      cout &lt;&lt; endl;    &#125;  &#125;  return 0;&#125;</code></pre></div></figure><h1 id="c-minimize-the-thickness"><a class="markdownIt-Anchor" href="#c-minimize-the-thickness"></a> C. Minimize the Thickness</h1><p><strong>题目大意</strong></p><p>给你一个长度为n的序列<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>a</mi></mrow><annotation encoding="application/x-tex">a</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">a</span></span></span></span>，序列中每个数都是正整数。现在需要将序列且分成若干个连续子序列。</p><ul><li>每个子序列的和相同</li><li>原本的序列中的每个数，都必须在某个子序列中，并且仅在一个子序列中</li></ul><p>然后让你求一个分割方法，使得分割之后的子序列中最长的子序列的长度（ans）最小。</p><p><strong>题解</strong></p><p>初始化<code>ans = n</code>。通过枚举第一个子序列的长度，枚举第一个子序列的和<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>S</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">S_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.83333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.05764em;">S</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.05764em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>。然后对于每个<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>S</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">S_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.83333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.05764em;">S</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.05764em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>，检查将序列分割成每个子序列和均为<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>S</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">S_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.83333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.05764em;">S</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.05764em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>的情况是否存在，如果存在，那么将这种分割方法的最长长度<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>l</mi><mi>e</mi><msub><mi>n</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">len_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="mord mathnormal">e</span><span class="mord"><span class="mord mathnormal">n</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>更新到结果当中，<code>ans = min(ans, len);</code>。</p><p><strong>参考代码</strong></p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">#include &lt;bits&#x2F;stdc++.h&gt;using namespace std;int main()&#123;  int t;  cin &gt;&gt; t;  while(t--)&#123;    int n;    cin &gt;&gt; n;    vector&lt;int&gt; arr(n + 1, 0);    vector&lt;int&gt; sum(n + 1, 0);    for(int i &#x3D; 1; i &lt;&#x3D; n; ++i)&#123;      cin &gt;&gt; arr[i];      sum[i] &#x3D; sum[i - 1] + arr[i];    &#125;    int ans &#x3D; n;    for(int i &#x3D; 1; i &lt;&#x3D; n; ++i)&#123;      int ts &#x3D; sum[i];      if(sum[n] % ts &#x3D;&#x3D; 0)&#123;        int cnt &#x3D; 0;        int len &#x3D; i;        int pre &#x3D; 0;        for(int j &#x3D; 1; j &lt;&#x3D; n; ++j)&#123;          if(sum[j] % ts &#x3D;&#x3D; 0)&#123;            ++cnt;            len &#x3D; max(len, j - pre);            pre &#x3D; j;          &#125;        &#125;        if(cnt &gt;&#x3D; sum[n] &#x2F; ts)&#123;          ans &#x3D; min(ans, len);        &#125;      &#125;    &#125;    cout &lt;&lt; ans &lt;&lt; endl;  &#125;  return 0;&#125;</code></pre></div></figure><h1 id="d-masha-and-a-beautiful-tree"><a class="markdownIt-Anchor" href="#d-masha-and-a-beautiful-tree"></a> D. Masha and a Beautiful Tree</h1><p><strong>题目大意</strong></p><p>给你一个有 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mn>2</mn><mi>n</mi></msup></mrow><annotation encoding="application/x-tex">2^n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.664392em;vertical-align:0em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.664392em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span></span></span></span></span></span></span> 个叶子节点的满二叉树，数上的每个叶子节点上面都有一个值，这些值从左到右构成了一个从 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> 到 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mn>2</mn><mi>n</mi></msup></mrow><annotation encoding="application/x-tex">2^n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.664392em;vertical-align:0em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.664392em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span></span></span></span></span></span></span> 的一个排列。<br />每次操作，你可以选择一个非叶子节点，交换其左右孩子子树。<br />问能否通过这样的操作，使得叶子节点上面的数值，从左到右构成一个递增的排列。如果能构成这样的排列，求最少的操作次数。</p><p><strong>题解</strong></p><p>可以从最深的节点开始考虑，在每个节点上标记他的子树的叶子节点的最小值和最大值区间，如果每个非叶子节点的左子树的叶子节点的最小值和最大值区间和右子树的叶子节点的最小值和最大值区间重叠，那么就不能将这个子树的叶子节点通过操作转化成一个连续递增的排列。如果这个非叶子节点的左子树的最大值小于右子树的最小值，那么就不需要交换这个节点的左子树和右子树。如果这个非叶子节点的左子树的最小值大于右子树的最大值，那么就需要在这个节点上进行一次左子树和右子树的交换。</p><p><strong>参考代码</strong></p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">#include &lt;bits&#x2F;stdc++.h&gt;using namespace std;int main()&#123;  int t;  cin &gt;&gt; t;  while(t--)&#123;    int n;    cin &gt;&gt; n;    vector&lt;int&gt; arr(n);    for(auto&amp; it: arr)&#123;      cin &gt;&gt; it;      --it;    &#125;    auto&amp;&amp; dfs &#x3D; [&amp;](auto&amp;&amp; self, int l, int r) -&gt; tuple&lt;int, int, int&gt;&#123;      if(l &#x3D;&#x3D; r)&#123;        return &#123;arr[l], arr[r], 0&#125;;      &#125;      auto [ll, lr, lo] &#x3D; self(self, l, (l + r) &#x2F; 2);      auto [rl, rr, ro] &#x3D; self(self, (l + r) &#x2F; 2 + 1, r);      int ml &#x3D; min(ll, rl), mr &#x3D; max(lr, rr);      int mo &#x3D; 0;      if(lo &#x3D;&#x3D; -1 or ro &#x3D;&#x3D; -1)&#123;        return &#123;ml, mr, -1&#125;;      &#125;      else mo &#x3D; lo + ro;      if(ll &gt; rr)&#123;        return &#123;ml, mr, mo + 1&#125;;      &#125;else if(lr &lt; rl)&#123;        return &#123;ml, mr, mo&#125;;      &#125;else&#123;        return &#123;ml, mr, -1&#125;;      &#125;    &#125;;    auto [x, y, v] &#x3D; dfs(dfs, 0, n - 1);    cout &lt;&lt; v &lt;&lt; endl;  &#125;  return 0;&#125;</code></pre></div></figure><h1 id="e-sending-a-sequence-over-the-network"><a class="markdownIt-Anchor" href="#e-sending-a-sequence-over-the-network"></a> E. Sending a Sequence Over the Network</h1><p><strong>题目大意</strong></p><p>给你一个长度为n序列seq，问你能不能将序列seq分割成若干段，使得每段的左边或者右边伴随一个子段的长度。</p><p><strong>题解</strong></p><p>这个题目采用动态规划。<code>dp[i]</code>代表长度为i的前缀是否满足这样的分割条件。初始化dp为false，dp[0]为true。对于每个位置i，分别假定seq[i]为序列在i左边的序列长度，或者序列在i右边的序列长度。</p><p>那么转移方式就是：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">if(arr[i] &lt; i) dp[i] |&#x3D; dp[i - arr[i] - 1];if(arr[i] + i &lt;&#x3D; n) dp[i + arr[i]] |&#x3D; dp[i - 1];</code></pre></div></figure><p>最后检查<code>dp[n]</code>是否为true。</p><p><strong>参考代码</strong></p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">#include &lt;bits&#x2F;stdc++.h&gt;using namespace std;int main() &#123;  int t;  cin &gt;&gt; t;  while(t--)&#123;    int n;    cin &gt;&gt; n;    vector&lt;int&gt; arr(n + 1, 0);    for(int i &#x3D; 1; i &lt;&#x3D; n; ++i)&#123;      cin &gt;&gt; arr[i];    &#125;    vector&lt;int&gt; dp(n + 1, 0);    dp[0] &#x3D; 1;    for(int i &#x3D; 1; i &lt;&#x3D; n; ++i)&#123;      if(arr[i] &lt; i)&#123;        dp[i] &#x3D; dp[i] | dp[i - arr[i] - 1];      &#125;      if(arr[i] + i &lt;&#x3D; n)&#123;        dp[i + arr[i]] &#x3D; dp[i + arr[i]] | dp[i - 1];      &#125;    &#125;    cout &lt;&lt; (dp[n] ? &quot;YES&quot; : &quot;NO&quot;) &lt;&lt; endl;  &#125;  return 0;&#125;</code></pre></div></figure><h1 id="f-multi-colored-segments"><a class="markdownIt-Anchor" href="#f-multi-colored-segments"></a> F. Multi-Colored Segments</h1><p><strong>题目大意</strong></p><p>有n条带有颜色线段 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>I</mi><mi>n</mi><mi>t</mi><mi>e</mi><mi>r</mi><mi>v</mi><mi>a</mi><mi>l</mi><mo stretchy="false">(</mo><msub><mi>l</mi><mi>i</mi></msub><mo separator="true">,</mo><msub><mi>r</mi><mi>i</mi></msub><mo separator="true">,</mo><msub><mi>c</mi><mi>i</mi></msub><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">Interval(l_i, r_i, c_i)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.07847em;">I</span><span class="mord mathnormal">n</span><span class="mord mathnormal">t</span><span class="mord mathnormal">e</span><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="mord mathnormal" style="margin-right:0.03588em;">v</span><span class="mord mathnormal">a</span><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.01968em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.02778em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">c</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span> , 对于每条线段，问离他最近的不同颜色的线段的距离。如果它与不同颜色线段相交，那么结果为0。</p><p><strong>题解</strong></p><p>考虑使用线段树来解决这个问题。线段树中的每个节点需要保存它所对应的区间的覆盖长度。线段树还需要具有以下功能：</p><ul><li>将一个覆盖区间插入线段树</li><li>将一个覆盖区间从线段树中移除</li><li>查询区间内的覆盖长度</li><li>查询区间内的被覆盖的最左端点</li><li>查询区间内的被覆盖的最右端点</li></ul><p>然后，开始动手写这个题<br />首先把所有的区间按照颜色分类，然后把所有的区间都放入线段树当中。<br />对于每个颜色，将此颜色的所有覆盖区间从线段树中移除。然后对于当前颜色的每一条覆盖区间，分别求当前区间覆盖的长度、当前区间左边的被覆盖的最右端点和当前区间右侧被覆盖的最左端点。最后将当前颜色的所有覆盖区间插入到线段树当中。</p><p>最后，需要注意的是，在处理线段树的时候，需要将区间的端点进行离散化。因为如果用动态开点的线段树会mle，别问我为什么会知道。</p><p><strong>参考代码</strong></p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">#include &lt;bits&#x2F;stdc++.h&gt;using namespace std;#define b2e(...) begin(__VA_ARGS__), end(__VA_ARGS__)#define initIO()                                                               \  ios::sync_with_stdio(false);                                                 \  cin.tie(nullptr);                                                            \  cout.tie(nullptr);                                                           \  cout &lt;&lt; fixed &lt;&lt; setprecision(10)#define debug(x...)                                                            \  do &#123;                                                                         \    cout &lt;&lt; &quot;\033[32;1m&quot; &lt;&lt; #x &lt;&lt; &quot; -&gt; &quot;;                                      \    rd_debug(x);                                                               \  &#125; while (0)void rd_debug() &#123; cout &lt;&lt; &quot;\033[39;0m&quot; &lt;&lt; endl; &#125;template &lt;class T, class... Ts&gt; void rd_debug(const T &amp;arg, const Ts &amp;...args) &#123;  cout &lt;&lt; arg &lt;&lt; &quot; &quot;;  rd_debug(args...);&#125;#define PF(x) ((x) * (x))#define LF(x) ((x)*PF(x))typedef long long ll;typedef unsigned long long ull;typedef pair&lt;int, int&gt; PII;typedef pair&lt;ll, ll&gt; PLL;const double eps &#x3D; 1e-6;const int MOD &#x3D; 1e9 + 7;const int inf &#x3D; 0x3f3f3f3f;const ll infl &#x3D; 0x3f3f3f3f3f3f3f3fll;#define LEFT (node[cur].l)#define RIGHT (node[cur].r)#define MID ((l + r) &gt;&gt; 1)struct Node &#123;  int l, r;  int lazy;  int len;&#125;;struct Seg &#123;  Seg() : node(2) &#123;  &#125;  void add(int cur, int l, int r, int st, int ed, int tv) &#123;    if (ed &lt; l or r &lt; st)      return;    if (st &lt;&#x3D; l &amp;&amp; r &lt;&#x3D; ed) &#123;      node[cur].lazy +&#x3D; tv;      if (node[cur].lazy &gt; 0) &#123;        node[cur].len &#x3D; r - l + 1;      &#125; else &#123;        node[cur].len &#x3D; 0;        if (LEFT)          node[cur].len +&#x3D; node[LEFT].len;        if (RIGHT)          node[cur].len +&#x3D; node[RIGHT].len;      &#125;      return;    &#125;    if (!LEFT) &#123;      LEFT &#x3D; node.size();      node.push_back(&#123;0, 0, 0, 0&#125;);    &#125;    if (!RIGHT) &#123;      RIGHT &#x3D; node.size();      node.push_back(&#123;0, 0, 0, 0&#125;);    &#125;    add(LEFT, l, MID, st, ed, tv);    add(RIGHT, MID + 1, r, st, ed, tv);    if (node[cur].lazy &gt; 0) &#123;      node[cur].len &#x3D; r - l + 1;    &#125; else &#123;      node[cur].len &#x3D; node[LEFT].len + node[RIGHT].len;    &#125;  &#125;  auto query(int cur, int l, int r, int st, int ed) -&gt; int &#123;    if (ed &lt; l or r &lt; st)      return 0;    if (node[cur].lazy) &#123;      return min(r, ed) - max(l, st) + 1;    &#125;    if(node[cur].len &#x3D;&#x3D; 0)      return 0;    if (st &lt;&#x3D; l &amp;&amp; r &lt;&#x3D; ed) &#123;      return node[cur].len;    &#125;    int ret &#x3D; 0;    if (LEFT)      ret +&#x3D; query(LEFT, l, MID, st, ed);    if (RIGHT)      ret +&#x3D; query(RIGHT, MID + 1, r, st, ed);    return ret;  &#125;  auto queryPosL(int cur, int l, int r, int st, int ed) -&gt; int &#123;    if (ed &lt; l or r &lt; st)      return -1;    if (node[cur].lazy) &#123;      return max(l, st);    &#125;    if(node[cur].len &#x3D;&#x3D; 0) return -1;    if (st &lt;&#x3D; l &amp;&amp; r &lt;&#x3D; ed) &#123;      if (node[cur].lazy &gt; 0)        return l;      if (LEFT) &#123;        int ret &#x3D; queryPosL(LEFT, l, MID, st, ed);        if (ret !&#x3D; -1)          return ret;      &#125;      if (RIGHT) &#123;        int ret &#x3D; queryPosL(RIGHT, MID + 1, r, st, ed);        if (ret !&#x3D; -1)          return ret;      &#125;      return -1;    &#125;    int ret &#x3D; -1;    if (LEFT)      ret &#x3D; queryPosL(LEFT, l, MID, st, ed);    if (ret !&#x3D; -1)      return ret;    if (RIGHT)      ret &#x3D; queryPosL(RIGHT, MID + 1, r, st, ed);    return ret;  &#125;  auto queryPosR(int cur, int l, int r, int st, int ed) -&gt; int &#123;    if (ed &lt; l or r &lt; st)      return -1;    if (node[cur].lazy) &#123;      return min(r, ed);    &#125;    if(node[cur].len &#x3D;&#x3D; 0) return -1;    if (st &lt;&#x3D; l &amp;&amp; r &lt;&#x3D; ed) &#123;      if (node[cur].lazy &gt; 0)        return r;      if (RIGHT) &#123;        int ret &#x3D; queryPosR(RIGHT, MID + 1, r, st, ed);        if (ret !&#x3D; -1)          return ret;      &#125;      if (LEFT) &#123;        int ret &#x3D; queryPosR(LEFT, l, MID, st, ed);        if (ret !&#x3D; -1)          return ret;      &#125;      return -1;    &#125;    int ret &#x3D; -1;    if (RIGHT)      ret &#x3D; queryPosR(RIGHT, MID + 1, r, st, ed);    if (ret !&#x3D; -1)      return ret;    if (LEFT)      ret &#x3D; queryPosR(LEFT, l, MID, st, ed);    return ret;  &#125;  vector&lt;Node&gt; node;&#125;;int main() &#123;  initIO();  int t;  cin &gt;&gt; t;  Seg seg;  while (t--) &#123;    int n;    cin &gt;&gt; n;    map&lt;int, vector&lt;tuple&lt;int, int, int&gt;&gt;&gt; mp;    vector&lt;int&gt; ans(n, inf);    vector&lt;int&gt; pos;    for (int i &#x3D; 0; i &lt; n; i++) &#123;      int l, r, h;      cin &gt;&gt; l &gt;&gt; r &gt;&gt; h;      mp[h].push_back(&#123;l, r, i&#125;);      pos.push_back(l);      pos.push_back(r);    &#125;    sort(pos.begin(), pos.end());    pos.erase(unique(pos.begin(), pos.end()), pos.end());    auto&amp;&amp; getPos &#x3D; [&amp;](int x) -&gt; int&#123;      return lower_bound(pos.begin(), pos.end(), x) - pos.begin() + 1;    &#125;;    for(auto&amp; [h, v]: mp)&#123;      for(auto&amp; [l, r, i]: v)&#123;        seg.add(1, 1, pos.size(), getPos(l), getPos(r), 1);      &#125;    &#125;    for(auto&amp; [h, v] : mp) &#123;      for (auto &amp;[l, r, i] : v) &#123;        seg.add(1, 1, pos.size(), getPos(l), getPos(r), -1);      &#125;      for (auto &amp;[l, r, i] : v) &#123;        int qs &#x3D; seg.query(1, 1, pos.size(), getPos(l), getPos(r));        if (qs &gt; 0) &#123;          ans[i] &#x3D; 0;        &#125; else &#123;          int ql &#x3D; seg.queryPosL(1, 1, pos.size(), getPos(r) + 1, pos.size());          if (ql !&#x3D; -1) &#123;            ans[i] &#x3D; min(ans[i], pos[ql - 1] - r);          &#125;          int qr &#x3D; seg.queryPosR(1, 1, pos.size(), 1, getPos(l) - 1);          if (qr !&#x3D; -1) &#123;            ans[i] &#x3D; min(ans[i], l - pos[qr - 1]);          &#125;        &#125;      &#125;      for (auto &amp;[l, r, i] : v) &#123;        seg.add(1, 1, pos.size(), getPos(l), getPos(r), 1);      &#125;    &#125;    for(auto&amp; [h, v] : mp) &#123;      for (auto &amp;[l, r, i] : v) &#123;        seg.add(1, 1, pos.size(), getPos(l), getPos(r), -1);      &#125;    &#125;    for (auto &amp;it : ans) &#123;      cout &lt;&lt; it &lt;&lt; &quot; &quot;;    &#125;    cout &lt;&lt; &#39;\n&#39;;  &#125;  return 0;&#125;</code></pre></div></figure><h1 id="g-multi-colored-segments"><a class="markdownIt-Anchor" href="#g-multi-colored-segments"></a> G. Multi-Colored Segments</h1><p><strong>题目大意</strong></p><p>K住在一个有<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">n</span></span></span></span>个节点的m条边的无向联通图的编号为<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span>的点。晚上，他有<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>f</mi></mrow><annotation encoding="application/x-tex">f</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord mathnormal" style="margin-right:0.10764em;">f</span></span></span></span>个朋友要从他家返回各自的家。有 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi></mrow><annotation encoding="application/x-tex">k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span></span></span></span>（ <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi><mo>&lt;</mo><mn>6</mn></mrow><annotation encoding="application/x-tex">k &lt; 6</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.73354em;vertical-align:-0.0391em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">&lt;</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">6</span></span></span></span> ）个朋友没有车，这<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi></mrow><annotation encoding="application/x-tex">k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span></span></span></span>个人将会步行回家，如果没有其他人载他一程。其他有车的朋友可以载无限个朋友，但是有车的朋友回家的时候，只会走从K的家到他家的最短的一条路径。K希望你帮他算一下，最少有多少朋友需要步行回家。</p><p><strong>题解</strong></p><p>首先将没有车的朋友给他编号，分别是<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0</mn><mo separator="true">,</mo><mn>1</mn><mo separator="true">,</mo><mn>2</mn><mo separator="true">,</mo><mo>…</mo><mo separator="true">,</mo><mi>k</mi><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">0, 1, 2, \dots, k - 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">2</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="minner">…</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span>。因为<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi></mrow><annotation encoding="application/x-tex">k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span></span></span></span>比较小，我们就可以用<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mn>2</mn><mi>k</mi></msup></mrow><annotation encoding="application/x-tex">2^k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.849108em;vertical-align:0em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.849108em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.03148em;">k</span></span></span></span></span></span></span></span></span></span></span>个状态来代表每个有车的人回家的途中，可以捎上哪些朋友。<br />然后通过bfs来计算每个有车的人回家途中可以走的路线长度和每条路线可以捎的朋友的状态。</p><p>最后使用背包，根据每个有车的人能捎带的朋友的状态，来统计多个有车的人能捎的朋友的最大数量。从而得到需要步行回家的朋友的最少数量。</p><p><strong>参考代码</strong></p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">#include &lt;bits&#x2F;stdc++.h&gt;using namespace std;#define b2e(...) begin(__VA_ARGS__), end(__VA_ARGS__)#define initIO()                                                               \  ios::sync_with_stdio(false);                                                 \  cin.tie(nullptr);                                                            \  cout.tie(nullptr);                                                           \  cout &lt;&lt; fixed &lt;&lt; setprecision(10)#define debug(x...)                                                            \  do &#123;                                                                         \    cout &lt;&lt; &quot;\033[32;1m&quot; &lt;&lt; #x &lt;&lt; &quot; -&gt; &quot;;                                      \    rd_debug(x);                                                               \  &#125; while (0)void rd_debug() &#123; cout &lt;&lt; &quot;\033[39;0m&quot; &lt;&lt; endl; &#125;template &lt;class T, class... Ts&gt; void rd_debug(const T &amp;arg, const Ts &amp;...args) &#123;  cout &lt;&lt; arg &lt;&lt; &quot; &quot;;  rd_debug(args...);&#125;#define PF(x) ((x) * (x))#define LF(x) ((x)*PF(x))typedef long long ll;typedef unsigned long long ull;typedef pair&lt;int, int&gt; PII;typedef pair&lt;ll, ll&gt; PLL;const double eps &#x3D; 1e-6;const int MOD &#x3D; 1e9 + 7;const int inf &#x3D; 0x3f3f3f3f;const ll infl &#x3D; 0x3f3f3f3f3f3f3f3fll;int main() &#123;  initIO();  int t;  cin &gt;&gt; t;  while (t--) &#123;    int n, m;    cin &gt;&gt; n &gt;&gt; m;    vector&lt;vector&lt;int&gt;&gt; g(n + 1);    for (int i &#x3D; 0; i &lt; m; ++i) &#123;      int x, y;      cin &gt;&gt; x &gt;&gt; y;      g[x].push_back(y);      g[y].push_back(x);    &#125;    int f;    cin &gt;&gt; f;    vector&lt;int&gt; location(f + 1);    for (int i &#x3D; 1; i &lt;&#x3D; f; ++i)      cin &gt;&gt; location[i];    vector&lt;int&gt; noBike, hasBike;    vector&lt;int&gt; vis(f + 1, 1);    int h;    cin &gt;&gt; h;    for(int i &#x3D; 0; i &lt; h; ++i)&#123;      int tv;      cin &gt;&gt; tv;      noBike.push_back(location[tv]);      vis[tv] &#x3D; 0;    &#125;    for(int i &#x3D; 1; i &lt;&#x3D; f; ++i)&#123;      if(vis[i])&#123;        hasBike.push_back(location[i]);      &#125;    &#125;    vector&lt;int&gt; dis(n + 1, inf);    dis[1] &#x3D; 0;    vector flag(n + 1, vector&lt;int&gt;(1 &lt;&lt; h, 0));    flag[1][0] &#x3D; 1;    queue&lt;int&gt; q;    q.push(1);    while (!q.empty()) &#123;      auto cur &#x3D; q.front();      q.pop();      for (auto &amp;v : g[cur]) &#123;        if (dis[v] &gt; dis[cur] + 1) &#123;          dis[v] &#x3D; dis[cur] + 1;          for(int j &#x3D; 0; j &lt; (1 &lt;&lt; h); ++j)&#123;            if(flag[cur][j])&#123;              int tv &#x3D; j;              flag[v][tv] &#x3D; 1;              for(int k &#x3D; 0; k &lt; h; ++k)&#123;                if(v &#x3D;&#x3D; noBike[k])&#123;                  tv |&#x3D; (1 &lt;&lt; k);                &#125;              &#125;              flag[v][tv] &#x3D; 1;            &#125;          &#125;          q.push(v);        &#125; else if (dis[v] &#x3D;&#x3D; dis[cur] + 1) &#123;          for(int j &#x3D; 0; j &lt; (1 &lt;&lt; h); ++j)&#123;            if(flag[cur][j])&#123;              flag[v][j] &#x3D; 1;              int tv &#x3D; j;              for(int k &#x3D; 0; k &lt; h; ++k)&#123;                if(v &#x3D;&#x3D; noBike[k])&#123;                  tv |&#x3D; (1 &lt;&lt; k);                &#125;              &#125;              flag[v][tv] &#x3D; 1;            &#125;          &#125;        &#125;      &#125;    &#125;    vector&lt;int&gt; dp(1 &lt;&lt; h, 0);    dp[0] &#x3D; 1;    int ans &#x3D; 0;    for(auto&amp; idx: hasBike)&#123;      for(int j &#x3D; (1 &lt;&lt; h) - 1; j &gt;&#x3D; 0; --j)&#123;        if(dp[j])&#123;          for(int k &#x3D; 0; k &lt; (1 &lt;&lt; h); ++k)&#123;            if(flag[idx][k])&#123;              dp[j | k] &#x3D; 1;            &#125;          &#125;        &#125;      &#125;    &#125;    for(int i &#x3D; 0; i &lt; (1 &lt;&lt; h); ++i) if(dp[i]) ans &#x3D; max(ans, __builtin_popcount(i));    cout &lt;&lt; h - ans &lt;&lt; endl;  &#125;  return 0;&#125;</code></pre></div></figure>]]>
      </content:encoded>
    </item>
    <item>
      <title>MIT 6.1810 Operating System Engineering</title>
      <link>https://www.dianhsu.com/2022/09/11/6-1810/</link>
      <description>
        <![CDATA[<blockquote>
<p>Reference: <a]]>
      </description>
      <author>Dian Hsu</author>
      <category domain="https://www.dianhsu.com/categories/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/">操作系统</category>
      <category domain="https://www.dianhsu.com/tags/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/">操作系统</category>
      <category domain="https://www.dianhsu.com/tags/%E5%AE%9E%E9%AA%8C/">实验</category>
      <pubDate>Sun, 11 Sep 2022 15:32:17 GMT</pubDate>
      <content:encoded>
        <![CDATA[<blockquote><p>Reference: <a href="https://pdos.csail.mit.edu/6.1810/2022/index.html">https://pdos.csail.mit.edu/6.1810/2022/index.html</a></p></blockquote><p>6.1810 是MIT的著名的操作系统课程6.828的后续版本，主要区别是6.828基于x86指令集，6.1810基于risc-v指令集。之前做6.828的时候，因为太菜了，实在是做不下去🥺，一度弃坑。趁着毕业之前还有很多时间，再来一遍，争取这次能够做完这套课程。</p><h1 id="实验环境设置"><a class="markdownIt-Anchor" href="#实验环境设置"></a> 实验环境设置</h1><p>我平常的开发设备是MacBook M1，按照Tools<sup id="fnref:1" class="footnote-ref"><a href="#fn:1" rel="footnote"><span class="hint--top hint--rounded" aria-label="[Tools](https://pdos.csail.mit.edu/6.1810/2022/tools.html)">[1]</span></a></sup>中的macOS的工具安装方法，安装了risc-v的cross compile编译工具之后，发现并不能编译成功。多次尝试未果之后，果断放弃，选择拥抱远端环境。这次就没有像上次一样用阿里云的服务器了，这次用的是GitHub提供的Codespaces<sup id="fnref:2" class="footnote-ref"><a href="#fn:2" rel="footnote"><span class="hint--top hint--rounded" aria-label="[Codespaces](https://github.com/codespaces)">[2]</span></a></sup>。这套环境，可以很方便在不同设备上进行使用，可以选择用本地的vscode，也可以选择用浏览器版本的vscode，还可以用ssh连接端口使用vim，超级方便🤣。唯一的不好的地方就是网络差的时候用起来有点卡。</p><p>按照Tools<sup id="fnref:1" class="footnote-ref"><a href="#fn:1" rel="footnote"><span class="hint--top hint--rounded" aria-label="[Tools](https://pdos.csail.mit.edu/6.1810/2022/tools.html)">[1]</span></a></sup>中提供的步骤，在Codespaces<sup id="fnref:2" class="footnote-ref"><a href="#fn:2" rel="footnote"><span class="hint--top hint--rounded" aria-label="[Codespaces](https://github.com/codespaces)">[2]</span></a></sup>中安装必要的环境和工具。</p><figure><div class="code-wrapper"><pre class="line-numbers language-bash" data-language="bash" data-start="1"><code class="language-bash">sudo apt-get update &amp;&amp; sudo apt-get upgrade -ysudo apt-get install -y git build-essential gdb-multiarch qemu-system-misc gcc-riscv64-linux-gnu binutils-riscv64-linux-gnu </code></pre></div></figure><h1 id="lab-xv6-and-unix-utilities"><a class="markdownIt-Anchor" href="#lab-xv6-and-unix-utilities"></a> Lab: Xv6 and Unix utilities</h1><p>这是第一个Lab，主要是熟悉下环境，然后编写几个命令行小工具。</p><h2 id="sleepeasy"><a class="markdownIt-Anchor" href="#sleepeasy"></a> sleep(easy)</h2><p>在xv6中实现UNIX当中的sleep函数。</p><p><code>user/sleep.c</code>的代码实现如下</p><figure><div class="code-wrapper"><pre class="line-numbers language-c" data-language="c" data-start="1"><code class="language-c">&#x2F;*    filename: user&#x2F;sleep.c*&#x2F;#include &quot;kernel&#x2F;types.h&quot;#include &quot;user&#x2F;user.h&quot;int main(int argc, char *argv[])&#123;    if(argc !&#x3D; 2)&#123;        exit(0);    &#125;    &#x2F;&#x2F; atoi 是将字符串转换成数字，定义在user&#x2F;user.h中    int n &#x3D; atoi(argv[1]);    sleep(n);    exit(0);&#125;</code></pre></div></figure><p>实现完成之后，需要在<code>Makefile</code>文件中添加上这个文件生成的执行文件。</p><figure><div class="code-wrapper"><pre class="line-numbers language-Makefile" data-language="Makefile" data-start="1"><code class="language-Makefile">UPROGS&#x3D;\$U&#x2F;_grind\$U&#x2F;_wc\$U&#x2F;_zombie\$U&#x2F;_sleep\  # 新增此行</code></pre></div></figure><p>然后在命令行中执行<code>./grade-lab-util sleep</code>来检查是否正确。</p><p>参考的commit: <a href="https://github.com/dianhsu/xv6-riscv/commit/eee6ab6d5a3c7df8f9f0fff1ac036ae38105ab3a">https://github.com/dianhsu/xv6-riscv/commit/eee6ab6d5a3c7df8f9f0fff1ac036ae38105ab3a</a></p><h2 id="pingpongeasy"><a class="markdownIt-Anchor" href="#pingpongeasy"></a> pingpong(easy)</h2><p>在xv6中实现UNIX当中的pingpong函数。</p><figure><div class="code-wrapper"><pre class="line-numbers language-c" data-language="c" data-start="1"><code class="language-c">#include &quot;kernel&#x2F;types.h&quot;#include &quot;user&#x2F;user.h&quot;int main(int argc, char* argv[])&#123;    char buf[16];    int p_p2c[2], p_c2p[2];    if(pipe(p_p2c) &lt; 0)&#123;        exit(1);    &#125;    if(pipe(p_c2p) &lt; 0)&#123;        exit(1);    &#125;    if(fork() &gt; 0)&#123;        close(p_p2c[0]);        close(p_c2p[1]);        write(p_p2c[1], &quot;p&quot;, 1);        read(p_c2p[0], buf, 1);         fprintf(2, &quot;%d: received pong\n&quot;, getpid());        close(p_p2c[1]);        close(p_c2p[0]);        wait(0);    &#125;else&#123;        close(p_p2c[1]);        close(p_c2p[0]);        read(p_p2c[0], buf, 1);        fprintf(2, &quot;%d: received ping\n&quot;, getpid());        write(p_c2p[1], &quot;p&quot;, 1);        close(p_p2c[0]);        close(p_c2p[1]);        exit(0);    &#125;    exit(0);&#125;</code></pre></div></figure><p>实现完成之后，需要在<code>Makefile</code>文件中添加上这个文件生成的执行文件。</p><figure><div class="code-wrapper"><pre class="line-numbers language-Makefile" data-language="Makefile" data-start="1"><code class="language-Makefile">UPROGS&#x3D;\$U&#x2F;_grind\$U&#x2F;_wc\$U&#x2F;_zombie\$U&#x2F;_sleep\      $U&#x2F;_pingpong\ # 新增此行</code></pre></div></figure><h2 id="primesmoderate"><a class="markdownIt-Anchor" href="#primesmoderate"></a> primes(moderate)</h2><figure><div class="code-wrapper"><pre class="line-numbers language-c" data-language="c" data-start="1"><code class="language-c">#include &quot;kernel&#x2F;types.h&quot;#include &quot;user&#x2F;user.h&quot;int isPrime(int v)&#123;    for(int i &#x3D; 2; i * i &lt;&#x3D; v; ++i)&#123;        if(v % i &#x3D;&#x3D; 0)&#123;            return 0;        &#125;    &#125;    return 1;&#125;int main()&#123;    int p[2];    int c[2];    if(pipe(p) &lt; 0)&#123;        exit(1);    &#125;    if(pipe(c) &lt; 0)&#123;        exit(1);    &#125;    if(fork() &gt; 0)&#123;        close(p[0]);        close(c[1]);        char buf[8];        for(int i &#x3D; 2; i &lt;&#x3D; 35; ++i)&#123;            buf[0] &#x3D; i;            write(p[1], buf, 1);        &#125;        close(p[1]);        while(read(c[0], buf, 1) !&#x3D; 0)&#123;            fprintf(2, &quot;prime %d\n&quot;, (int)buf[0]);        &#125;        close(c[0]);        wait(0);    &#125;else&#123;        close(p[1]);        close(c[0]);        char buf[8];        while(read(p[0], buf, 1) !&#x3D; 0)&#123;            int v &#x3D; buf[0];            if(isPrime(v))&#123;                if(fork() &#x3D;&#x3D; 0)&#123;                    write(c[1], buf, 1);                        close(c[1]);                    exit(0);                &#125;                wait(0);            &#125;            if(v &#x3D;&#x3D; 35) break;        &#125;        close(p[0]);        close(c[1]);        exit(0);    &#125;    exit(0);&#125;</code></pre></div></figure><h2 id="findmoderate"><a class="markdownIt-Anchor" href="#findmoderate"></a> find(moderate)</h2><figure><div class="code-wrapper"><pre class="line-numbers language-c" data-language="c" data-start="1"><code class="language-c">#include &quot;kernel&#x2F;types.h&quot;#include &quot;kernel&#x2F;stat.h&quot;#include &quot;kernel&#x2F;fs.h&quot;#include &quot;user&#x2F;user.h&quot;void checkAndShow(char* path, char* name)&#123;    static char buf[DIRSIZ + 1];    char *p;    &#x2F;&#x2F; Find first character after last slash.    for(p&#x3D;path+strlen(path); p &gt;&#x3D; path &amp;&amp; *p !&#x3D; &#39;&#x2F;&#39;; p--);    p++;    &#x2F;&#x2F; Return blank-padded name.    if(strlen(p) &gt;&#x3D; DIRSIZ) return;    memmove(buf, p, strlen(p));    memset(buf+strlen(p), &#39; &#39;, DIRSIZ-strlen(p));    for(int i &#x3D; 0; ; ++i)&#123;        if(p[i] &#x3D;&#x3D; &#39;\0&#39; &amp;&amp; name[i] &#x3D;&#x3D; &#39;\0&#39;)&#123;            printf(&quot;%s\n&quot;, path);            break;        &#125;else if(p[i] &#x3D;&#x3D; &#39;\0&#39; || name[i] &#x3D;&#x3D; &#39;\0&#39;)&#123;            break;        &#125;else if(p[i] !&#x3D; name[i])&#123;            break;        &#125;    &#125;&#125;void find(char* program, char *path, char* name)&#123;    char buf[512], *p;    int fd;    struct dirent de;    struct stat st;    if((fd &#x3D; open(path, 0)) &lt; 0)&#123;        fprintf(2, &quot;%s: cannot open %s\n&quot;, program, path);        return;    &#125;    if(fstat(fd, &amp;st) &lt; 0)&#123;        fprintf(2, &quot;%s: cannot stat %s\n&quot;, program, path);        close(fd);        return;    &#125;    switch(st.type)&#123;        case T_FILE:            if(strlen(path) + 1 + DIRSIZ + 1 &gt; sizeof buf)&#123;                printf(&quot;%s: path too long\n&quot;, program);                break;            &#125;            checkAndShow(path, name);            break;        case T_DIR:            if(strlen(path) + 1 + DIRSIZ + 1 &gt; sizeof buf)&#123;                printf(&quot;%s: path too long\n&quot;, program);                break;            &#125;            strcpy(buf, path);            p &#x3D; buf + strlen(buf);            *p++ &#x3D; &#39;&#x2F;&#39;;            while(read(fd, &amp;de, sizeof(de)) &#x3D;&#x3D; sizeof(de))&#123;                if(de.inum &#x3D;&#x3D; 0)&#123;                    continue;                &#125;                memmove(p, de.name, DIRSIZ);                p[DIRSIZ] &#x3D; 0;                if(stat(buf, &amp;st) &lt; 0)&#123;                    printf(&quot;%s: cannot stat %s\n&quot;, program, buf);                    continue;                &#125;                if(st.type &#x3D;&#x3D; T_DIR &amp;&amp; (p[0] &#x3D;&#x3D; &#39;.&#39; &amp;&amp; (p[1] &#x3D;&#x3D; &#39;\0&#39; || (p[1] &#x3D;&#x3D; &#39;.&#39; &amp;&amp; p[2] &#x3D;&#x3D; &#39;\0&#39;))))&#123;                    continue;                &#125;else&#123;                    find(program, buf, name);                &#125;            &#125;            break;    &#125;    close(fd);&#125;int main(int argc, char* argv[])&#123;    if(argc &#x3D;&#x3D; 2)&#123;        find(argv[0], &quot;.&quot;, argv[1]);        exit(0);    &#125;    if(argc !&#x3D; 3)&#123;        exit(0);    &#125;    char *dir &#x3D; argv[1];    char *name &#x3D; argv[2];    find(argv[0], dir, name);    exit(0);&#125;</code></pre></div></figure><h2 id="xargsmoderate"><a class="markdownIt-Anchor" href="#xargsmoderate"></a> xargs(moderate)</h2><figure><div class="code-wrapper"><pre class="line-numbers language-c" data-language="c" data-start="1"><code class="language-c">#include &quot;kernel&#x2F;param.h&quot;#include &quot;kernel&#x2F;types.h&quot;#include &quot;kernel&#x2F;stat.h&quot;#include &quot;user&#x2F;user.h&quot;#define MAXLEN 1024char *argvs[MAXARG + 1];char buf[512];char argBuf[MAXLEN];int main(int argc,  char* argv[])&#123;    if(argc &lt;&#x3D; 1)&#123;        exit(0);    &#125;    int idx &#x3D; 0;    argvs[idx] &#x3D; 0;    while(idx + 1 &lt; argc)&#123;        argvs[idx] &#x3D; argv[idx + 1];        ++idx;        argvs[idx] &#x3D; 0;    &#125;    int cnt &#x3D; 0;    int pos &#x3D; 0;    while((cnt &#x3D; read(0, buf, sizeof(buf))) &gt; 0)&#123;        if(pos + cnt &gt;&#x3D; MAXLEN) exit(0);        memmove(argBuf + pos, buf, cnt);        pos +&#x3D; cnt;    &#125;    for(int i &#x3D; 0; i &lt; pos; ++i)&#123;        if(i &#x3D;&#x3D; 0 || argBuf[i - 1] &#x3D;&#x3D; &#39;\0&#39;)&#123;            if(idx &gt;&#x3D; MAXARG) exit(0);            argvs[idx++] &#x3D; argBuf + i;        &#125;        if(argBuf[i] &#x3D;&#x3D; &#39;\n&#39;) argBuf[i] &#x3D; &#39;\0&#39;;    &#125;    int pid;    if((pid &#x3D; fork()) &gt; 0)&#123;        wait(0);    &#125;else&#123;        exec(argvs[0], argvs);        exit(0);    &#125;    exit(0);&#125;</code></pre></div></figure><h1 id="lab-system-calls"><a class="markdownIt-Anchor" href="#lab-system-calls"></a> Lab: system calls</h1><h2 id="system-call-tracing-moderate"><a class="markdownIt-Anchor" href="#system-call-tracing-moderate"></a> System call tracing (moderate)</h2><blockquote><p>In this assignment you will add a system call tracing feature that may help you when debugging later labs. You’ll create a new trace system call that will control tracing. It should take one argument, an integer “mask”, whose bits specify which system calls to trace. For example, to trace the fork system call, a program calls <code>trace(1 &lt;&lt; SYS_fork)</code>, where <code>SYS_fork</code> is a syscall number from <code>kernel/syscall.h</code>. You have to modify the xv6 kernel to print out a line when each system call is about to return, if the system call’s number is set in the mask. The line should contain the process id, the name of the system call and the return value; you don’t need to print the system call arguments. The trace system call should enable tracing for the process that calls it and any children that it subsequently forks, but should not affect other processes.</p></blockquote><p>In this task, we are going to design a trace program in order to trace the system calls. The trace program will take one argument, an integer “mask”, whose bits specify which system calls to trace. The other arguments will be the program to be traced and the arguments of traced program. For example, in the first case(<code>trace 32 grep hello README</code>), the program will trace the <code>read</code> system call, due to the <code>1 &lt;&lt; SYS_read</code> in <code>kernel/syscall.h</code> is 32. The <code>grep</code> is the running program, <code>hello</code> and <code>README</code> will pass to <code>grep</code> as arguments.</p><h3 id="step1-add-a-system-call-named-trace"><a class="markdownIt-Anchor" href="#step1-add-a-system-call-named-trace"></a> Step1. Add a system call named <code>trace</code></h3><p>In <code>user/user.h</code>, we add a system call named <code>trace</code>:</p><figure><div class="code-wrapper"><pre class="line-numbers language-c" data-language="c" data-start="1"><code class="language-c">&#x2F;&#x2F; other system callsint trace(int);&#x2F;&#x2F; other system calls</code></pre></div></figure><p>and we modify <code>user/usys.pl</code> to add the system call:</p><figure><div class="code-wrapper"><pre class="line-numbers language-perl" data-language="perl" data-start="1"><code class="language-perl">entry(&quot;trace&quot;);</code></pre></div></figure><p>In <code>kernel/syscall.h</code>, we define a new system call named <code>trace</code>:</p><figure><div class="code-wrapper"><pre class="line-numbers language-c" data-language="c" data-start="1"><code class="language-c">#define SYS_trace 22</code></pre></div></figure><p>In <code>kernel/proc.h</code>, we add a mask flag in <code>struct proc</code>:</p><figure><div class="code-wrapper"><pre class="line-numbers language-c" data-language="c" data-start="1"><code class="language-c">struct proc&#123;    &#x2F;&#x2F; other fields    int mask;&#125;</code></pre></div></figure><p>In <code>kernel/sysproc.c</code>, we add the implementation of <code>trace</code>, we use <code>argint</code> to get the mask and set it to the current process:</p><figure><div class="code-wrapper"><pre class="line-numbers language-c" data-language="c" data-start="1"><code class="language-c">uint64sys_trace(void)&#123;  int mask;  if(argint(0, &amp;mask) &lt; 0)&#123;    return -1;  &#125;  myproc()-&gt;mask &#x3D; mask;  return 0;&#125;</code></pre></div></figure><p>In <code>kernel/proc.c</code>, we modify the <code>fork</code> function, we copy the mask from the parent process to the child process:</p><figure><div class="code-wrapper"><pre class="line-numbers language-c" data-language="c" data-start="1"><code class="language-c">int fork(void)&#123;    &#x2F;&#x2F; other code    np-&gt;sz &#x3D; p-&gt;sz;    np-&gt;mask &#x3D; p-&gt;mask;    &#x2F;&#x2F; other code&#125;</code></pre></div></figure><p>Finally, we print system calls usage in <code>kernel/syscall.c</code>, and we should create a system call name array in <code>kernel/syscall.c</code>:</p><figure><div class="code-wrapper"><pre class="line-numbers language-c" data-language="c" data-start="1"><code class="language-c">static uint64 (*syscalls[])(void) &#x3D; &#123;&#x2F;&#x2F; other system calls[SYS_trace]   sys_trace,&#x2F;&#x2F; other system calls&#125;;extern int sys_trace(void);static char* syscall_name[] &#x3D; &#123;&quot;&quot;,&quot;fork&quot;,&quot;exit&quot;,&quot;wait&quot;,&quot;pipe&quot;,&quot;read&quot;,&quot;kill&quot;,&quot;exec&quot;,&quot;fstat&quot;,&quot;chdir&quot;,&quot;dup&quot;,&quot;getpid&quot;,&quot;sbrk&quot;,&quot;sleep&quot;,&quot;uptime&quot;,&quot;open&quot;,&quot;write&quot;,&quot;mknod&quot;,&quot;unlink&quot;,&quot;link&quot;,&quot;mkdir&quot;,&quot;close&quot;,&quot;trace&quot;,&#125;;voidsyscall(void)&#123;    int num;    struct proc *p &#x3D; myproc();    num &#x3D; p-&gt;trapframe-&gt;a7;    if(num &gt; 0 &amp;&amp; num &lt; NELEM(syscalls) &amp;&amp; syscalls[num]) &#123;        p-&gt;trapframe-&gt;a0 &#x3D; syscalls[num]();        if((p-&gt;mask &gt;&gt; num) &amp; 1)&#123;            &#x2F;&#x2F; if the system call is traced, print the system call name and return value.            printf(&quot;%d: syscall %s -&gt; %d\n&quot;, p-&gt;pid, syscall_name[num], p-&gt;trapframe-&gt;a0);        &#125;    &#125; else &#123;        printf(&quot;%d %s: unknown sys call %d\n&quot;,                p-&gt;pid, p-&gt;name, num);        p-&gt;trapframe-&gt;a0 &#x3D; -1;    &#125;&#125;</code></pre></div></figure><p><strong>Commit:</strong> <a href="https://github.com/dianhsu/xv6-riscv/commit/25048b45071e4331a7374c75b9ef076877c56d91">https://github.com/dianhsu/xv6-riscv/commit/25048b45071e4331a7374c75b9ef076877c56d91</a></p><h1 id="faqs"><a class="markdownIt-Anchor" href="#faqs"></a> FAQs</h1><h2 id="in-linux-environment-make-report-error-winfinite-recursion"><a class="markdownIt-Anchor" href="#in-linux-environment-make-report-error-winfinite-recursion"></a> In Linux environment, make report error: <code>-Winfinite-recursion</code>?</h2><p>solve: add <code>-Wno-infinite-recursion</code> to <code>Makefile</code>.</p><figure><div class="code-wrapper"><pre class="line-numbers language-Makefile" data-language="Makefile" data-start="1"><code class="language-Makefile">CFLAGS &#x3D; -Wall -Werror -O -fno-omit-frame-pointer -ggdb -Wno-infinite-recursion</code></pre></div></figure><h1 id="references"><a class="markdownIt-Anchor" href="#references"></a> References</h1><section class="footnotes"><div class="footnote-list"><ol><li><span id="fn:1" class="footnote-text"><span><a href="https://pdos.csail.mit.edu/6.1810/2022/tools.html">Tools</a><a href="#fnref:1" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:2" class="footnote-text"><span><a href="https://github.com/codespaces">Codespaces</a><a href="#fnref:2" rev="footnote" class="footnote-backref"> ↩</a></span></span></li></ol></div></section>]]>
      </content:encoded>
    </item>
    <item>
      <title>数据库</title>
      <link>https://www.dianhsu.com/2022/08/28/database/</link>
      <description>
        <![CDATA[<h1 id="数据库的三范式是什么"><a class="markdownIt-Anchor" href="#数据库的三范式是什么"></a>]]>
      </description>
      <author>Dian Hsu</author>
      <category domain="https://www.dianhsu.com/categories/%E9%9D%A2%E8%AF%95/">面试</category>
      <category domain="https://www.dianhsu.com/tags/%E9%9D%A2%E8%AF%95/">面试</category>
      <category domain="https://www.dianhsu.com/tags/%E5%85%AB%E8%82%A1%E6%96%87/">八股文</category>
      <category domain="https://www.dianhsu.com/tags/%E6%95%B0%E6%8D%AE%E5%BA%93/">数据库</category>
      <pubDate>Sun, 28 Aug 2022 06:28:40 GMT</pubDate>
      <content:encoded>
        <![CDATA[<h1 id="数据库的三范式是什么"><a class="markdownIt-Anchor" href="#数据库的三范式是什么"></a> 数据库的三范式是什么？</h1><ul><li>第一范式：强调的是列的原子性，即数据库表的每一列都是不可分割的原子数据项。</li><li>第二范式：要求实体的属性完全依赖于主关键字。所谓完全 依赖是指不能存在仅依赖主关键字一部分的属性。</li><li>第三范式：任何非主属性不依赖于其它非主属性。</li></ul><h1 id="mysql-支持哪些存储引擎"><a class="markdownIt-Anchor" href="#mysql-支持哪些存储引擎"></a> MySQL 支持哪些存储引擎?</h1><p>MySQL 支持多种存储引擎,比如 InnoDB,MyISAM,Memory,Archive 等等。在大多数的情况下,直接选择使用 InnoDB 引擎都是最合适的,InnoDB 也是 MySQL 的默认存储引擎。</p><p>MyISAM 和 InnoDB 的区别有哪些：</p><ul><li>InnoDB 支持事务，MyISAM 不支持</li><li>InnoDB 支持外键，而 MyISAM 不支持</li><li>InnoDB 是聚集索引，数据文件是和索引绑在一起的，必须要有主键，通过主键索引效率很高；<br />MyISAM 是非聚集索引，数据文件是分离的，索引保存的是数据文件的指针，主键索引和辅助索引是独立的。</li><li>Innodb 不支持全文索引，而 MyISAM 支持全文索引，查询效率上 MyISAM 要高；</li><li>InnoDB 不保存表的具体行数，MyISAM 用一个变量保存了整个表的行数。</li><li>MyISAM 采用表级锁(table-level locking)；InnoDB 支持行级锁(row-level locking)和表级锁，默认为行级锁。</li></ul><h1 id="超键-候选键-主键-外键分别是什么"><a class="markdownIt-Anchor" href="#超键-候选键-主键-外键分别是什么"></a> 超键、候选键、主键、外键分别是什么？</h1><ul><li>超键：在关系中能唯一标识元组的属性集称为关系模式的超键。一个属性可以为作为一个超键，多个属性组合在一起也可以作为一个超键。超键包含候选键和主键。</li><li>候选键：是最小超键，即没有冗余元素的超键。</li><li>主键：数据库表中对储存数据对象予以唯一和完整标识的数据列或属性的组合。一个数据列只能有一个主键，且主键的取值不能缺失，即不能为空值（Null）。</li><li>外键：在一个表中存在的另一个表的主键称此表的外键。</li></ul><h1 id="sql-约束有哪几种"><a class="markdownIt-Anchor" href="#sql-约束有哪几种"></a> SQL 约束有哪几种？</h1><ul><li>NOT NULL: 用于控制字段的内容一定不能为空（NULL）。</li><li>UNIQUE: 控件字段内容不能重复，一个表允许有多个 Unique 约束。</li><li>PRIMARY KEY: 也是用于控件字段内容不能重复，但它在一个表只允许出现一个。</li><li>FOREIGN KEY: 用于预防破坏表之间连接的动作，也能防止非法数据插入外键列，因为它必须是它指向的那个表中的值之一。</li><li>CHECK: 用于控制字段的值范围。</li></ul><h1 id="mysql-中的-varchar-和-char-有什么区别"><a class="markdownIt-Anchor" href="#mysql-中的-varchar-和-char-有什么区别"></a> MySQL 中的 varchar 和 char 有什么区别？</h1><p>char 是一个定长字段,假如申请了<code>char(10)</code>的空间,那么无论实际存储多少内容.该字段都占用 10 个字符,而 varchar 是变长的,也就是说申请的只是最大长度,占用的空间为实际字符长度+1,最后一个字符存储使用了多长的空间。<br />在检索效率上来讲，char &gt; varchar，因此在使用中，如果确定某个字段的值的长度，可以使用char，否则应该尽量使用varchar，例如存储用户MD5加密之后的密码，应该使用char。</p><h1 id="mysql中in和exists区别"><a class="markdownIt-Anchor" href="#mysql中in和exists区别"></a> MySQL中in和exists区别</h1><p>MySQL中的in语句是把外表和内表做hash连接，而exists语句是对外表做loop循环，每次loop循环再对内表进行查询。一直大家都认为exists比in语句的效率更高，而这个说法是不准确的。这个是要区分环境的。</p><p>如果查询的两个表大小相当，那么用in和exists差别不大。如果两个表中一个较小，一个较大，则子查询表大的用exists，子查询表小的用in。<br /><code>not in</code> 和 <code>not exists</code>：如果查询语句使用了<code>not in</code>，那么内外表都进行全表扫描，没有用到索引；而<code>not exists</code>的子查询依然能从用到表上的索引。所以无论哪个表大，用<code>not exists</code>都比<code>not in</code>要快。</p><h1 id="drop-delete与truncate的区别"><a class="markdownIt-Anchor" href="#drop-delete与truncate的区别"></a> drop、delete与truncate的区别</h1><table><thead><tr><th></th><th>Delete</th><th>Truncate</th><th>Drop</th></tr></thead><tbody><tr><td>类型</td><td>属于DML</td><td>属于DDL</td><td>属于DDL</td></tr><tr><td>回滚</td><td>可回滚</td><td>不可回滚</td><td>不可回滚</td></tr><tr><td>删除内容</td><td>表结构还在，删除表的全部或者一部分数据</td><td>表结构还在，删除表的所有数据</td><td>从数据库中删除表，所有的数据行，索引和权限也会被删除</td></tr><tr><td>删除速度</td><td>删除速度慢，需要逐行删除</td><td>删除速度快</td><td>删除速度快</td></tr></tbody></table><h1 id="什么是存储过程有哪些优缺点"><a class="markdownIt-Anchor" href="#什么是存储过程有哪些优缺点"></a> 什么是存储过程？有哪些优缺点？</h1><p>储存过程是一些预编译的SQL语句。</p><ol><li>更加直白的理解：存储过程可以说是一个记录集，它是由一些T-SQL语句组成的代码块，这些T-SQL语句代码就像一个方法一样实现一些功能（对单表或多表的增删），然后再给这个代码块取一个名字，在用到这个功能的时候调用他就行了。</li><li>存储过程是一个预编译的代码块，执行效率比较高，一个存储过程代替大量T-SQL语句，可以降低网络通信量，提高通信效率，可以一定程度上确保数据安全。</li></ol><h1 id="mysql执行查询的过程"><a class="markdownIt-Anchor" href="#mysql执行查询的过程"></a> MySQL执行查询的过程</h1><ol><li>客户端通过TCP连接发送连接请求到MySQL连接器，连接器会对该请求进行权限验证及连接资源分配</li><li>查缓存。（当判断缓存是否命中时，MySQL不会进行解析查询语句，而是直接使用SQL语句和客户端发送过来的其他原始信息。所以，任何字符上的不同，例如空格、注解等都会导致缓存的不命中。）</li><li>语法分析（SQL语法是否写错了）。如何把语句给到预处理器，检查数据表和数据列是否存在，解析别名看是否存在歧义。</li><li>优化。是否使用索引，生成执行计划。</li><li>交给执行器，将数据保存到结果集中，同时会逐步将数据缓存到查询缓存中，最红将结果集返回给客户端。</li></ol><p><img src="https://cdn.dianhsu.com/img/2022-08-14-20-46-50.png" alt="MySQL执行查询的过程" /></p><p>更新语句执行会复杂一点，需要检查表是否含排他锁，写binlog，刷盘，是否执行commit。</p><h1 id="事务"><a class="markdownIt-Anchor" href="#事务"></a> 事务</h1><h2 id="什么是数据库事务"><a class="markdownIt-Anchor" href="#什么是数据库事务"></a> 什么是数据库事务</h2><p>事务时一个不可分割的数据库操作序列，也是数据库并发控制的基本单位，其执行结果必须是数据库从一种一致性状态变到另一种一致性状态。事务是逻辑上的一组操作，要么都执行，要么都不执行。</p><p>事务最经典的例子就是转账了。</p><p>假如小明要给小红转账1000元，这个转账就会涉及到两个关键操作就是：将小明的余额减少1000元，将小红的余额增加1000元。万一在这两个操作之间突然出现错误比如银行系统崩溃，导致小明的余额减少但是小红的余额没有增加，这样就不对了。事务就是保证这两个关键操作要么都成功，要么都要失败。</p><h2 id="介绍一下事务的四个特征"><a class="markdownIt-Anchor" href="#介绍一下事务的四个特征"></a> 介绍一下事务的四个特征</h2><p>事务就是一组原子性的操作，这些操作要么全部发生，要么全部不发生。事务把数据库从一种一致性状态转换到另外一种一致性状态。</p><ul><li>原子性。事务是数据库的逻辑工作单位，事务中包含的个操作要么都做、要么都不做。</li><li>一致性。事务执行的结果必须是使数据库从一个一致性状态转变成另外一个一致性状态。因此当数据库中只包含成功事务提交的结果时，就说明数据库处于一致性状态。如果数据库系统运行时发生故障，有些事务尚未完成就被迫中断，这些未完成事务对数据库所做的修改有一部分已写入物理数据库，这时数据库就处于一种不正确的状态，或者说是不一致状态。</li><li>隔离性。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对其他并发事务时隔离的，并发执行的各个事务之间不能相互干扰。</li><li>持久性。指一个事务一旦提交，它对数据库中的数据的改变就应该是永久性的。接下来其他的操作或故障不应该对其执行结果有任何影响。</li></ul><h2 id="说一下mysql的四种隔离级别"><a class="markdownIt-Anchor" href="#说一下mysql的四种隔离级别"></a> 说一下MySQL的四种隔离级别</h2><ul><li>READ UNCOMMITTED （读未提交）<br />在该隔离级别，所有事务都可以看到其他未提交事务的执行结果。本隔离级别很少用于实际应用，因为它的性能也不比其他的级别好多少。读取未提交的数据，也称之为脏读（Dirty Read）。</li><li>READ COMMITTED （读已提交）<br />这是大多数数据库系统的默认隔离级别（但不是MySQL默认的）。它满足了隔离的简单定义：一个事务只能看到已经提交事务所做的改变，这种隔离级别也支持所谓的不可重复读，因为同一事务的其他实例在该实例处理其间可能会有新的commit，所以同一select可能返回不同的结果。</li><li>REPEATABLE READ （可重复读）<br />这是MySQL的默认事务隔离级别，它确保同一事务的多个实例在并发读取数据时，会看到同样的数据行。不过理论上，这会导致另一个棘手的问题：幻读（Phantom Read）。</li><li>SERIALIZABLE （串行化）<br />通过强制事务排序，使之不可能相互冲突，从而解决幻读问题。简言之，它是每个读的数据行上加上共享锁。在这个级别，可能导致大量的超时现象和锁竞争。</li></ul><table><thead><tr><th>隔离级别</th><th>脏读</th><th>不可重复读</th><th>幻读</th></tr></thead><tbody><tr><td>READ UNCOMMITTED</td><td>✅</td><td>✅</td><td>✅</td></tr><tr><td>READ COMMITTED</td><td>❌</td><td>✅</td><td>✅</td></tr><tr><td>REPEATABLE READ</td><td>❌</td><td>❌</td><td>✅</td></tr><tr><td>SERIALIZABLE</td><td>❌</td><td>❌</td><td>❌</td></tr></tbody></table><p>MySQL 默认采用的 REPEATABLE READ 隔离级别，Oracle默认采用的 READ COMMITTED。<br />事务隔离机制的实现基于锁机制和并发调度。其中并发调度使用的是MVVC（多版本并发控制），通过保存修改的旧版本信息来支持并发一致性读和回滚操作。<br />因为隔离级别越低，事务请求的锁越少，所以大部分数据库系统的隔离级别都是READ COMMITTED（读取提交内容），但是你要知道的是InnoDB存储引擎默认使用REPEATABLE READ（可重复读）并不会有任何性能损失。<br />InnoDB存储引擎在分布式事务的情况下一般会用到SERIALIZABLE（可串行化）隔离级别。</p><h2 id="什么是脏读幻读不可重复读"><a class="markdownIt-Anchor" href="#什么是脏读幻读不可重复读"></a> 什么是脏读？幻读？不可重复读？</h2><ul><li>脏读：事务A读取了事务B更新的数据，然后B回滚操作，那么A读取到的数据是脏数据。</li><li>不可重复读：事务A多次读取同一数据，事务B在事务A多次读取的过程中，对数据做了更新并提交，导致事务A多次读取同一数据时，结果不一致。</li><li>幻读：系统管理员A将数据库中所有学生的成绩从具体分数改成ABCDE等级，但是系统管理员B就在这个时候插入一条具体分数的记录，当系统管理员A改结束后发现还有一条记录没有改过来，就像发生幻觉一样，这就叫幻读。</li></ul><p>不可重复读侧重于修改，幻读侧重于新增和删除（多了或者少了行），脏读诗一个书屋回滚影响另外一个事务。</p><h2 id="事务的实现原理"><a class="markdownIt-Anchor" href="#事务的实现原理"></a> 事务的实现原理</h2><p>事务是基于重做日志文件（redo log）和回滚日志（undo log）实现的。</p><p>每提交一个事务必须先将该事务的所有日志写入到重做日志文件进行持久化，数据库就可以通过重做日志来保证事务的原子性和持久性。</p><p>每当有修改事务时，还会产生undo log，如果需要回滚，则根据undo log的反向语句进行逻辑操作，比如insert一条记录就delete一条记录，undo log主要是实现数据库的一致性。</p><h2 id="mysql日志介绍一下"><a class="markdownIt-Anchor" href="#mysql日志介绍一下"></a> MySQL日志介绍一下</h2><p>InnoDB事务日志包括redo log和undo log。<br />undo log 指事务开始之前，在操作任何数据之前，需要将需要操作的数据备份到一个地方。redo log指事务中操作的任何数据，将最新的数据备份到一个地方。</p><p>事务日志的目的：实例或者介质失败，事务日志文件就能派上用场。</p><p><strong>redo log</strong><br />redo log不是随着事务的提交才写入的，而是在实物的执行过程中，就开始写入redo log中。具体的落盘策略可以进行配置。放置在发生故障的时间点，尚有脏页未写入磁盘，在重启MySQL服务的时候，根据redo log进行重做，从而达到事务的未入磁盘数据进行持久化这一特性。redo log是为了实现事务的持久化而出现的产物。</p><p><img src="https://cdn.dianhsu.com/img/2022-08-14-22-16-23.png" alt="Redo log" /></p><p><strong>undo log</strong><br />undo log用来回滚行记录到某个版本。事务未提交之前，undo 保存了未提交之前的版本数据，undo log中的数据可以作数据的旧版本快照供其他并发事务进行快照读。是为了实现事务的原子性而出现的产物，在MySQL InnoDB存储引擎中用来实现多版本并发控制。</p><p><img src="https://cdn.dianhsu.com/img/2022-08-14-22-21-12.png" alt="Undo log" /></p><h2 id="什么是mysql的binlog"><a class="markdownIt-Anchor" href="#什么是mysql的binlog"></a> 什么是MySQL的binlog</h2><p>MySQL的binlog是记录所有数据库表结构变更（例如CREATE、ALTER TABLE）以及表数据修改（INSERT、UPDATE和DELETE）的二进制日志。binlog不会记录SELECT和SHOW这类操作，因为这类操作对数据本身没有修改，但你可以通过查询通用日志来查看MySQL执行过的所有语句。</p><p>MySQL的binlog以事件形式记录，还包含语句执行的消耗的时间，MySQL的二进制日志是事务安全型的。binlog的主要目的是复制和恢复。</p><p>binlog有三种格式，各有优缺点：</p><ul><li>statement: 基于SQL语句的模式，某些语句和函数如UUID、LOAD DATA INFILE等在复制过程可能导致数据不一致甚至出错。</li><li>row: 基于行的模式，记录的是行的变化，很安全。但是binlog会比其他两种模式大很多，在一些大表中清楚大量数据时在binlog中会生成很多条语句，可能导致从库延迟变大。</li><li>mixed: 混合模式，根据语句来选择是statement还是row。</li></ul><h2 id="隔离级别是如何实现的"><a class="markdownIt-Anchor" href="#隔离级别是如何实现的"></a> 隔离级别是如何实现的</h2><p>事务的隔离机制主要是依赖锁机制和MVCC（多版本并发控制）实现的，读已提交和可重复读可以通过MVCC实现，串行化可以通过锁机制实现。</p><h2 id="什么是mvcc"><a class="markdownIt-Anchor" href="#什么是mvcc"></a> 什么是MVCC</h2><p>MVCC，即多版本并发控制。MVCC的实现，是通过保存数据在某个时间点的快照来实现的。根据事务的开始的时间不同，每个事物对同一张表，同一个时刻看到的数据可能是不同的。</p><h2 id="mvcc的实现原理"><a class="markdownIt-Anchor" href="#mvcc的实现原理"></a> MVCC的实现原理</h2><p>对于InnoDB，聚簇索引记录中包含3个隐藏的列：</p><ul><li>ROW ID: 隐藏的自增ID，如果表没有主键，InnoDB会自动按照ROW ID产生一个聚集索引数。</li><li>事务ID: 记录最后一次修改该记录的事务ID。</li><li>回滚指针: 指向这条记录的上一个版本。</li></ul><p>我们拿上面的例子，对应解释下MVCC的实现原理，如下图：<br /><img src="https://cdn.dianhsu.com/img/2022-08-14-22-49-51.png" alt="MVCC实现原理" /><br />如图，首先insert语句向表t1中插入了一条数据，a字段为1，b字段为1，ROW ID也为1，事务ID假设为1，回滚指针假设为NULL。当执行update t1 set b=666 where a=1时，大致步骤如下：</p><ul><li>数据库会先对满足a=1的行加排他锁；</li><li>然后将原纪录复制到undo表空间中；</li><li>修改b字段的值为666，修改事务ID为2；</li><li>并通过隐藏的回滚指针指向undo log中的历史记录；</li><li>事务提交，释放前面对满足a=1的行所加的排他锁；</li></ul><p>因此可以总结出MVCC实现的原理大致是：<br />InnoDB每一行数据都有一个隐藏的回滚指针，用于指向该行修改前的最后一个历史版本，这个历史版本存放在undo log中。如果要执行更新操作，会将原纪录放入undo log中，并通过隐藏的回滚指针指向undo log中的原纪录。其它事务此时需要查询时，就是查询undo log中这行数据的最后一个历史版本。</p><p>MVCC最大的好处就是读不加锁，读写不冲突，极大地增加了MySQL的并发性。通过MVCC，保证了事务ACID中的I（隔离性）特性。</p><h1 id="锁"><a class="markdownIt-Anchor" href="#锁"></a> 锁</h1><h2 id="为什么要加锁"><a class="markdownIt-Anchor" href="#为什么要加锁"></a> 为什么要加锁?</h2><p>当多个用户并发地存取数据时，在数据库中就会产生多个事务同时存取同一数据的情况。若对并发的操作不加控制就可能会读取和存储不正常的数据，破坏数据库的一致性。</p><p>在多用户环境下保证数据库的完整性和一致性。</p><h2 id="按照锁的粒度来分类数据库锁有哪些"><a class="markdownIt-Anchor" href="#按照锁的粒度来分类数据库锁有哪些"></a> 按照锁的粒度来分类，数据库锁有哪些</h2><p>在关系型数据库中，可以按照锁的粒度把数据库锁分为行级锁（InnoDB引擎）、表级锁（MyISAM引擎）和页级锁（BDB引擎）。</p><p><strong>行级锁</strong></p><ul><li>行级锁是MySQL中锁定粒度最细的一种锁，表示只针对当前操作的行进行加锁。行级锁能大大减少数据库操作的冲突。其加锁粒度最小，但加锁的开销也最大。行级锁分为共享锁和排他锁。</li><li>开销大，加锁慢；会出现死锁；锁定粒度最小，发生锁冲突的概率最低，并发度也最高。</li></ul><p><strong>表级锁</strong></p><ul><li>表级锁是MySQL中锁定粒度最大的一种锁，表示对当前操作的整张表加锁，它实现简单，资源消耗较少，被大部分MySQL引擎支持。最常使用的MyISAM与InnoDB都支持表级锁定。表级锁定分为表共享读锁（共享锁）与表独占写锁（排他锁）。</li><li>开销小，加锁快；不会出现死锁；锁定粒度大，发出锁冲突的概率最高，并发度最低。</li></ul><p><strong>页级锁</strong></p><ul><li>页级锁是MySQL中锁定粒度介于行级锁和表级锁中间的一种锁。表级锁速度快，但冲突多，行级锁冲突少，但速度慢。所以取了折中的页级，一次锁定相邻的一组记录，BDB支持页级锁</li><li>开销和加锁时间介于表级锁和行级锁中间；会出现死锁；锁定粒度介于表级锁和行级锁中间，并发度一般。</li></ul><p><strong>MyISAM和InnoDB存储引擎使用的锁</strong></p><ul><li>MyISAM采用的是表级锁（table-level locking）。</li><li>InnoDB支持行级锁和表级锁，默认为行级锁。</li></ul><h2 id="从锁的类别上面划分mysql都有哪些锁"><a class="markdownIt-Anchor" href="#从锁的类别上面划分mysql都有哪些锁"></a> 从锁的类别上面划分MySQL都有哪些锁</h2><p>从锁的类别上面来讲，有共享锁和排他锁</p><ul><li>共享锁：又叫做读锁。当用户要进行数据的读取时，对数据加上共享锁。共享锁可以同时加上多个。</li><li>排他锁：又叫做写锁。当用户要进行数据的写入时，对数据加上排他锁。排他锁只可以加上一个，它和其他的排他锁、共享锁都互斥。</li></ul><h2 id="数据库的乐观锁和悲观锁"><a class="markdownIt-Anchor" href="#数据库的乐观锁和悲观锁"></a> 数据库的乐观锁和悲观锁</h2><p>数据库管理系统（DBMS）中的并发控制的任务是确保在多个事务同时存取数据库中同一数据时不破坏事务的隔离性和统一性以及数据库的统一性。乐观并发控制（乐观锁）和悲观并发控制（悲观锁）是并发控制主要采用的技术手段。</p><ul><li>悲观锁：假定会发生并发冲突，屏蔽一切可能违反数据完整性的操作。在查询完数据的时候就把事务锁起来，直到提交事务。实现方式：使用数据库的锁机制</li><li>乐观锁：假设不会发生并发冲突，只在提交操作时检查是否违反数据的完整性。在修改数据的时候，把事务锁起来，通过version的方式来进行锁定。实现方式：一般会使用版本号机制或者CAS算法实现。</li></ul><p><strong>两种锁的使用场景</strong></p><p>从上面对两种锁的介绍，我们知道两种锁各有优缺点，不可认为一种好于另一种，像乐观锁适用于写比较少的情况，即冲突真的很少发生，这样可以省去锁的开销，加大了系统的整个吞吐量。</p><p>但如果是多写的情况，一般会经常产生冲突，这就会导致上层应用会不断进行retry，这样反倒是降低了性能，所以一般多写的场景下用悲观锁多一些。</p><h2 id="innodb引擎的行锁是怎么实现的"><a class="markdownIt-Anchor" href="#innodb引擎的行锁是怎么实现的"></a> InnoDB引擎的行锁是怎么实现的</h2><p>InnoDB是基于索引来完成行锁<br />例：<code>select * from tab_with_index where id = 1 for update;</code><br /><code>for update</code>可以根据条件来完成行锁锁定，并且<code>id</code>是有索引键的列，如果<code>id</code>不是索引键那么InnoDB将完成表锁，并发将无从谈起。</p><h2 id="什么是死锁怎么解决"><a class="markdownIt-Anchor" href="#什么是死锁怎么解决"></a> 什么是死锁，怎么解决</h2><p>死锁是两个或者多个事务在同一个资源上相互占用，并请求对方锁定的资源，从而导致恶性循环的现象</p><p>常见的解决死锁的方法</p><ul><li>如果不同程序会并发存取多个表，尽量约定以相同的顺序访问表，可以大大降低死锁机会。</li><li>在同一个事务中，尽可能做到一次锁定所需要的所有资源，减少死锁产生概率。</li><li>对于非常容易产生死锁的业务部分，可以尝试使用升级锁定颗粒度，通过表级锁定减少死锁产生的概率。</li></ul><p>如果业务处理不好可以用分布式事务锁或者使用乐观锁</p><h2 id="隔离级别与锁的关系"><a class="markdownIt-Anchor" href="#隔离级别与锁的关系"></a> 隔离级别与锁的关系</h2><p>在 Read Uncommitted级别下，读取数据不需要加共享锁，这样就不会跟被修改的数据上的排他锁冲突。<br />在 Read Committed级别下，读操作需要加共享锁，但是语句执行完之后释放共享锁。<br />在 Repeatable Read级别下，读操作需要加共享锁，但是在事务提交之前并不释放共享锁，这就是必须等待事务执行完毕之后才释放共享锁。<br />在Serializable级别下，因为该级别锁定整个范围的键，并一直持有锁，直到事务完成。</p><h2 id="优化锁方面的建议"><a class="markdownIt-Anchor" href="#优化锁方面的建议"></a> 优化锁方面的建议</h2><ul><li>使用较低的隔离级别</li><li>设计索引，尽量使用索引去访问数据，加锁更加准确，从而减少锁冲突</li><li>选择合理的事务大小，给记录显示加锁时，最好一次性请求足够级别的所。例如，修改数据的话，最好申请排他锁，而不是先申请共享锁，修改时再申请排他锁，这样会导致死锁</li><li>不同的程序访问一组表的时候，应尽量约定一个相同的顺序访问各个表，对于一个表而言，尽可能的固定顺序访问表中的行，这样会大大减少死锁的机会。</li><li>尽量使用相等的条件访问数据，这样可以避免间隙锁对并发插入的影响。</li><li>不要申请超过实际需要的锁级别</li><li>数据查询的时候不是必要，不要使用加锁。MySQL的MVCC可以实现事务的查询而不用加锁，优化事务性能：MVCC只在 读已提交 和 可重复读 两种隔离级别</li><li>对于特定的事务，可以使用表锁来提高处理速度或者减少死锁的可能。</li></ul><h1 id="分库分表"><a class="markdownIt-Anchor" href="#分库分表"></a> 分库分表</h1><h2 id="为什么要分库分表"><a class="markdownIt-Anchor" href="#为什么要分库分表"></a> 为什么要分库分表</h2><p><strong>分表</strong><br />比如你单表都几千万数据了，你确定你能扛得住吗？绝对不行，单表数据量太大，会极大影响你的sql执行的性能，到了后面你的sql可能就跑的很慢了。一般来说，就以我的经验来看，单表到几百万的时候，性能就会相对差一些了，你就得分表了。<br />分表就是把一个表的数据放到多个表中，然后查询的时候你就查一个表。比如按照用户id来分表，将一个用户的数据就放在一个表中。然后操作的时候你对一个用户就操作那个表就好了。这样可以控制每个表的数据量在可控的范围内，比如每个表就固定200万以内。</p><p><strong>分库</strong><br />分库就是你的一个库一般我们经验而言，最多支撑到并发2000，一定要扩容了，而且一个健康的单库并发值你最好保持在每秒1000左右，不要太大。那么你就可以通过将一个库的数据拆分到多个库当中，访问的时候就访问一个库就好了。</p><p>这就是所谓的分库分表。</p><h1 id="参考"><a class="markdownIt-Anchor" href="#参考"></a> 参考</h1><section class="footnotes"><div class="footnote-list"><ol><li><span id="fn:1" class="footnote-text"><span><a href="https://zhuanlan.zhihu.com/p/403656116">MySQL八股文连环45问（背诵版）</a><a href="#fnref:1" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:2" class="footnote-text"><span><a href="https://www.nowcoder.com/discuss/985275">MySQL八股文背诵版</a><a href="#fnref:2" rev="footnote" class="footnote-backref"> ↩</a></span></span></li></ol></div></section>]]>
      </content:encoded>
    </item>
    <item>
      <title>一个ARM-NEON的demo</title>
      <link>https://www.dianhsu.com/2022/08/17/neon-test/</link>
      <description>
        <![CDATA[<p>之前和炮姐聊天的时候，打开了新世界的大门。手边有一台Macbook Pro M1，就用这台设备写了一个简单的demo。Apple M1 chip 支持ARMv8-a指令集，同时支持NEON拓展指令集。 测试数据基于google benchmark。</p>
<h1]]>
      </description>
      <author>Dian Hsu</author>
      <category domain="https://www.dianhsu.com/categories/C-C/">C/C++</category>
      <category domain="https://www.dianhsu.com/tags/ISA/">ISA</category>
      <category domain="https://www.dianhsu.com/tags/NEON/">NEON</category>
      <category domain="https://www.dianhsu.com/tags/C-C/">C/C++</category>
      <pubDate>Wed, 17 Aug 2022 05:02:20 GMT</pubDate>
      <content:encoded>
        <![CDATA[<p>之前和炮姐聊天的时候，打开了新世界的大门。手边有一台Macbook Pro M1，就用这台设备写了一个简单的demo。Apple M1 chip 支持ARMv8-a指令集，同时支持NEON拓展指令集。 测试数据基于google benchmark。</p><h1 id="rgb-deinterleaving"><a class="markdownIt-Anchor" href="#rgb-deinterleaving"></a> RGB deinterleaving</h1><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">#include &quot;benchmark&#x2F;benchmark.h&quot;#include &quot;arm_neon.h&quot;void rgb_deinterleave_c(uint8_t *r, uint8_t *g, uint8_t *b, uint8_t *rgb, int len_color) &#123;    &#x2F;*     * Take the elements of &quot;rgb&quot; and store the individual colors &quot;r&quot;, &quot;g&quot;, and &quot;b&quot;.     *&#x2F;    for (int i&#x3D;0; i &lt; len_color; i++) &#123;        r[i] &#x3D; rgb[3*i];        g[i] &#x3D; rgb[3*i+1];        b[i] &#x3D; rgb[3*i+2];    &#125;&#125;void rgb_deinterleave_neon(uint8_t *r, uint8_t *g, uint8_t *b, uint8_t *rgb, int len_color) &#123;    &#x2F;*     * Take the elements of &quot;rgb&quot; and store the individual colors &quot;r&quot;, &quot;g&quot;, and &quot;b&quot;     *&#x2F;    int num8x16 &#x3D; len_color &#x2F; 16;    uint8x16x3_t intlv_rgb;    for (int i&#x3D;0; i &lt; num8x16; i++) &#123;        intlv_rgb &#x3D; vld3q_u8(rgb+3*16*i);        vst1q_u8(r+16*i, intlv_rgb.val[0]);        vst1q_u8(g+16*i, intlv_rgb.val[1]);        vst1q_u8(b+16*i, intlv_rgb.val[2]);    &#125;&#125;#define LEN_COLOR 1000uint8_t r[LEN_COLOR], g[LEN_COLOR], b[LEN_COLOR], rgb[LEN_COLOR * 3];void testC(benchmark::State&amp; state)&#123;    for(auto _ : state)&#123;        rgb_deinterleave_c(r, g, b, rgb, LEN_COLOR);    &#125;&#125;BENCHMARK(testC);void testNeon(benchmark::State&amp; state)&#123;    for(auto _ : state)&#123;        rgb_deinterleave_neon(r, g, b, rgb, LEN_COLOR);    &#125;&#125;BENCHMARK(testNeon);BENCHMARK_MAIN();&#x2F;*Run on (8 X 24.1206 MHz CPU s)CPU Caches:  L1 Data 64 KiB  L1 Instruction 128 KiB  L2 Unified 4096 KiB (x8)Load Average: 2.51, 2.79, 2.99-----------------------------------------------------Benchmark           Time             CPU   Iterations-----------------------------------------------------testC            1928 ns         1927 ns       350642testNeon          396 ns          395 ns      1768137*&#x2F;</code></pre></div></figure><h1 id="accumulate-array"><a class="markdownIt-Anchor" href="#accumulate-array"></a> Accumulate Array</h1><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">#include &quot;benchmark&#x2F;benchmark.h&quot;#include &quot;arm_neon.h&quot;float brr[4] &#x3D; &#123;0, 0, 0, 0&#125;;float add_result_neon(float* arr, int len)&#123;    float32x4_t tmp &#x3D; vld1q_f32(brr);    int num &#x3D; len &#x2F; 4;    for(int i &#x3D; 0; i &lt; num; ++i)&#123;        float32x4_t flv &#x3D; vld1q_f32(arr + i * 4);        tmp +&#x3D; flv;    &#125;    float res &#x3D; 0;    vst1q_f32(brr, tmp);    for(float i : brr)&#123;        res +&#x3D; i;    &#125;    return res;&#125;float add_result_c(float* arr, int len)&#123;    float res &#x3D; 0;    for(int i &#x3D; 0; i &lt; len; ++i)&#123;        res +&#x3D; arr[i];    &#125;    return res;&#125;#define LEN 1000float arr[LEN];void testC(benchmark::State&amp; state)&#123;    for(auto _: state)&#123;        add_result_c(arr, LEN);    &#125;&#125;void testNeon(benchmark::State&amp; state)&#123;    for(auto _: state)&#123;        add_result_neon(arr, LEN);    &#125;&#125;BENCHMARK(testC);BENCHMARK(testNeon);BENCHMARK_MAIN();&#x2F;*Run on (8 X 24.1212 MHz CPU s)CPU Caches:  L1 Data 64 KiB  L1 Instruction 128 KiB  L2 Unified 4096 KiB (x8)Load Average: 4.72, 4.17, 3.73-----------------------------------------------------Benchmark           Time             CPU   Iterations-----------------------------------------------------testC            3428 ns         3422 ns       203604testNeon          873 ns          872 ns       79435*&#x2F;</code></pre></div></figure>]]>
      </content:encoded>
    </item>
    <item>
      <title>八股文收集</title>
      <link>https://www.dianhsu.com/2022/07/23/eight-legged-essay/</link>
      <description>
        <![CDATA[<h1 id="c"><a class="markdownIt-Anchor" href="#c"></a> C++</h1>
<h2 id="虚函数"><a class="markdownIt-Anchor" href="#虚函数"></a> 虚函数</h2>
<h3]]>
      </description>
      <author>Dian Hsu</author>
      <category domain="https://www.dianhsu.com/categories/%E9%9D%A2%E8%AF%95/">面试</category>
      <category domain="https://www.dianhsu.com/tags/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/">操作系统</category>
      <category domain="https://www.dianhsu.com/tags/C/">C++</category>
      <category domain="https://www.dianhsu.com/tags/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/">计算机网络</category>
      <category domain="https://www.dianhsu.com/tags/Redis/">Redis</category>
      <category domain="https://www.dianhsu.com/tags/%E6%95%B0%E6%8D%AE%E5%BA%93%E5%8E%9F%E7%90%86/">数据库原理</category>
      <category domain="https://www.dianhsu.com/tags/%E8%BD%AF%E4%BB%B6%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F/">软件设计模式</category>
      <category domain="https://www.dianhsu.com/tags/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BB%84%E6%88%90%E5%8E%9F%E7%90%86/">计算机组成原理</category>
      <category domain="https://www.dianhsu.com/tags/%E7%BC%96%E8%AF%91%E5%8E%9F%E7%90%86/">编译原理</category>
      <pubDate>Sat, 23 Jul 2022 01:41:22 GMT</pubDate>
      <content:encoded>
        <![CDATA[<h1 id="c"><a class="markdownIt-Anchor" href="#c"></a> C++</h1><h2 id="虚函数"><a class="markdownIt-Anchor" href="#虚函数"></a> 虚函数</h2><h3 id="虚函数纯虚函数和虚析构函数-sup-idfnref1-classfootnote-refa-hreffn1-relfootnotespan-classhint-top-hint-rounded-aria-labelc岗位面试真题宝典httpswwwnowcodercomissuetutorialtutorialid100691spanasup"><a class="markdownIt-Anchor" href="#虚函数纯虚函数和虚析构函数-sup-idfnref1-classfootnote-refa-hreffn1-relfootnotespan-classhint-top-hint-rounded-aria-labelc岗位面试真题宝典httpswwwnowcodercomissuetutorialtutorialid100691spanasup"></a> 虚函数，纯虚函数和虚析构函数 <sup id="fnref:1" class="footnote-ref"><a href="#fn:1" rel="footnote"><span class="hint--top hint--rounded" aria-label="[C++岗位面试真题宝典](https://www.nowcoder.com/issue/tutorial?tutorialId=10069)">[1]</span></a></sup></h3><ul><li><p>C++ 中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。如果调用非虚函数，则无论实际对象是什么类型，都执行基类类型所定义的函数。非虚函数总是在编译时根据调用该函数的对象，引用或指针的类型而确定。如果调用虚函数，则直到运行时才能确定调用哪个函数，运行的虚函数是引用所绑定或指针所指向的对象所属类型定义的版本。虚函数必须是基类的非静态成员函数。虚函数的作用是实现动态联编，也就是在程序的运行阶段动态地选择合适的成员函数，在定义了虚函数后，可以在基类的派生类中对虚函数重新定义，在派生类中重新定义的函数应与虚函数具有相同的形参个数和形参类型。以实现统一的接口，不同定义过程。如果在派生类中没有对虚函数重新定义，则它继承其基类的虚函数。</p>  <figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">class Person&#123;    public:        &#x2F;&#x2F;虚函数        virtual void GetName()&#123;            cout&lt;&lt;&quot;PersonName:xiaosi&quot;&lt;&lt;endl;        &#125;;&#125;;class Student:public Person&#123;    public:        void GetName()&#123;            cout&lt;&lt;&quot;StudentName:xiaosi&quot;&lt;&lt;endl;        &#125;;&#125;;int main()&#123;    &#x2F;&#x2F;指针    Person *person &#x3D; new Student();    &#x2F;&#x2F;基类调用子类的函数    person-&gt;GetName();&#x2F;&#x2F;StudentName:xiaosi&#125;</code></pre></div></figure><p>虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。在这个表中，主是要一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数。</p></li><li><p>纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加<code>=0</code>（<code>virtual void GetName() = 0</code>）。在很多情况下，基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。为了解决上述问题，将函数定义为纯虚函数，则编译器要求在派生类中必须予以重写以实现多态性。同时含有纯虚拟函数的类称为抽象类，它不能生成对象。这样就很好地解决了上述两个问题。将函数定义为纯虚函数能够说明，该函数为后代类型提供了可以覆盖的接口，但是这个类中的函数绝不会调用。声明了纯虚函数的类是一个抽象类。所以，用户不能创建类的实例，只能创建它的派生类的实例。必须在继承类中重新声明函数（不要后面的＝0）否则该派生类也不能实例化，而且它们在抽象类中往往没有定义。定义纯虚函数的目的在于，使派生类仅仅只是继承函数的接口。纯虚函数的意义，让所有的类对象（主要是派生类对象）都可以执行纯虚函数的动作，但类无法为纯虚函数提供一个合理的缺省实现。所以类纯虚函数的声明就是在告诉子类的设计者，“你必须提供一个纯虚函数的实现，但我不知道你会怎样实现它”。</p>  <figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">&#x2F;&#x2F;抽象类class Person&#123;    public:        &#x2F;&#x2F;纯虚函数        virtual void GetName()&#x3D;0;&#125;;class Student:public Person&#123;    public:        Student()&#123;        &#125;;        void GetName()&#123;            cout&lt;&lt;&quot;StudentName:xiaosi&quot;&lt;&lt;endl;        &#125;;&#125;;int main()&#123;    Student student;&#125;</code></pre></div></figure></li></ul><h3 id="引入虚函数带来的问题sup-idfnref4-classfootnote-refa-hreffn4-relfootnotespan-classhint-top-hint-rounded-aria-label为什么-c-中使用虚函数时会影响效率httpswwwzhihucomquestion22958966answer231956124spanasup"><a class="markdownIt-Anchor" href="#引入虚函数带来的问题sup-idfnref4-classfootnote-refa-hreffn4-relfootnotespan-classhint-top-hint-rounded-aria-label为什么-c-中使用虚函数时会影响效率httpswwwzhihucomquestion22958966answer231956124spanasup"></a> 引入虚函数带来的问题<sup id="fnref:4" class="footnote-ref"><a href="#fn:4" rel="footnote"><span class="hint--top hint--rounded" aria-label="[为什么 C++ 中使用虚函数时会影响效率？](https://www.zhihu.com/question/22958966/answer/23195612)">[4]</span></a></sup></h3><p>虚函数影响效率有两点原因，第一，Cache命中率不够好，一般函数可能编译后的指令就在当前函数地址附近，这样很可能在调用前目标函数代码已经被载入指令cache. 但是虚拟函数不在cache中的概率高。而且一调函数就可能在cache中载入虚函数表，如果这个虚函数又调用其它的虚函数，那么可能又得载入到cache中导致cache被占用，指令和数据的cache命中率下降。 第二点编译器不好优化。因为编译器只知道你要调用的是一个不确定的地址处的函数，没法知道更多细节，也就没法替你做更多优化。</p><h2 id="c-sort-函数的实现"><a class="markdownIt-Anchor" href="#c-sort-函数的实现"></a> C++ sort 函数的实现</h2><blockquote><p>Reference: <a href="https://en.wikipedia.org/wiki/Introsort">https://en.wikipedia.org/wiki/Introsort</a></p></blockquote><p><a href="https://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/include/bits/stl_algo.h">libstdc++</a> 和 <a href="https://github.com/llvm/llvm-project/blob/main/libcxx/include/__algorithm/sort.h">libc++</a> 中的 sort函数的实现中，主体部分是使用了 Introsort 算法。</p><p>内省排序（英语：Introsort）是由David Musser在1997年设计的排序算法。这个排序算法首先从快速排序开始，当递归深度超过一定深度（深度为排序元素数量的对数值）后转为堆排序。采用这个方法，内省排序既能在常规数据集上实现快速排序的高性能，又能在最坏情况下仍保持 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>O</mi><mo stretchy="false">(</mo><mi>n</mi><mi>log</mi><mo>⁡</mo><mi>n</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">O(n\log n)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mop">lo<span style="margin-right:0.01389em;">g</span></span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal">n</span><span class="mclose">)</span></span></span></span> 的时间复杂度。由于这两种算法都属于比较排序算法，所以内省排序也是一个比较排序算法。</p><h2 id="c11141720新特性"><a class="markdownIt-Anchor" href="#c11141720新特性"></a> C++11/14/17/20新特性</h2><h3 id="c11新特性"><a class="markdownIt-Anchor" href="#c11新特性"></a> C++11新特性</h3><h4 id="智能指针"><a class="markdownIt-Anchor" href="#智能指针"></a> 智能指针</h4><h5 id="unique_ptr"><a class="markdownIt-Anchor" href="#unique_ptr"></a> unique_ptr</h5><blockquote><p>为动态申请的内存提供异常安全<br />将动态申请内存的所有权传递给某个函数(不能给复制，只能移动)<br />从某个函数返回动态申请内存的所有权<br />在容器中保存指针</p></blockquote><p>在那些要不是为了避免不安全的异常问题（以及为了保证指针所指向的对象都被正确地删除释放），我们不可以使用内建指针的情况下，我们可以在容器中保存unique_ptr以代替内建指针</p><h5 id="shared_ptr-weak_ptr"><a class="markdownIt-Anchor" href="#shared_ptr-weak_ptr"></a> shared_ptr &amp; weak_ptr</h5><p>当 shared_ref_cnt 被减为0时，自动释放 ptr 指针所指向的对象。当 shared_ref_cnt 与 weak_ref_cnt 都变成0时，才释放 ptr_manage 对象。<br />如此以来，只要有相关联的 shared_ptr 存在，对象就存在。weak_ptr 不影响对象的生命周期。当用 weak_ptr 访问对象时，对象有可能已被释放了，要先 lock()。<br />weak_ptr可以保存一个“弱引用”，指向一个已经用shared_ptr进行管理的对象。为了访问这个对象，一个weak_ptr可以通过shared_ptr的构造函数或者是weak_ptr的成员函数lock()转化为一个shared_ptr。当最后一个指向这个对象的shared_ptr退出其生命周期并且这个对象被释放之后，将无法从指向这个对象的weak_ptr获得一个shared_ptr指针，shared_ptr的构造函数会抛出异常，而weak_ptr::lock也会返回一个空指针。</p><h6 id="weak_ptr防止循环引用"><a class="markdownIt-Anchor" href="#weak_ptr防止循环引用"></a> weak_ptr防止循环引用</h6><p>众所周知，shared_ptr可能造成循环引用问题，那么weak_ptr是怎么解决循环引用问题的呢？看一个例子</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">class A &#123;public:    shared_ptr&lt;B&gt; ab;    &#x2F;&#x2F; 这里可以加上构造／析构函数看下是否能够被调用&#125;;class B &#123;public:    shared_ptr&lt;A&gt; ba;    &#x2F;&#x2F; 这里可以加上构造／析构函数看下是否能够被调用&#125;;shared_ptr&lt;A&gt; spa &#x3D; make_shared&lt;A&gt;();  &#x2F;&#x2F; 定义一个A对象shared_ptr&lt;B&gt; spb &#x3D; make_shared&lt;B&gt;();  &#x2F;&#x2F; 定义一个A对象spa.ab &#x3D; spb; &#x2F;&#x2F;shared_ptr计数成员_Sp_counted_base浅拷贝，use ref＋＋spb.ba &#x3D; spa;</code></pre></div></figure><p>显然，由于A、B互相引用，都无法释放，造成内存泄漏(示例参考自blog)</p><p>怎样打破这种循环引用？cppreference的说法是</p><blockquote><p>std::weak_ptr 的另一用法是打断 std::shared_ptr 所管理的对象组成的环状引用。若这种环被孤立（例如无指向环中的外部共享指针），则 shared_ptr 引用计数无法抵达零，而内存被泄露。能令环中的指针之一为弱指针以避免此情况。</p></blockquote><h5 id="implement-a-simple-smart-pointer-shared_ptr"><a class="markdownIt-Anchor" href="#implement-a-simple-smart-pointer-shared_ptr"></a> Implement a simple smart pointer (shared_ptr)</h5><p>It’s designed with two classes. The first is <code>ReferenceCount</code>, it’s used to count the reference number of the object. The second is <code>MySharedPtr</code>, it’s used to manage the object. The <code>MySharedPtr</code> class has a pointer to the <code>ReferenceCount</code> class. When the <code>MySharedPtr</code> class is created, it will create a <code>ReferenceCount</code> class and set the reference number to 1. When the <code>MySharedPtr</code> class is copied, it will increase the reference number of the <code>ReferenceCount</code> class. When the <code>MySharedPtr</code> class is deleted, it will decrease the reference number of the <code>ReferenceCount</code> class. When the reference number of the <code>ReferenceCount</code> class is 0, it will delete the object and the <code>ReferenceCount</code> class.</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">#include &lt;algorithm&gt;#include &lt;iostream&gt;#include &lt;mutex&gt;using namespace std;class ReferenceCount&#123;public:    explicit ReferenceCount(int ref &#x3D; 1): cnt(ref)&#123;    &#125;    void add_ref()&#123;        ++cnt;    &#125;    void remove_ref()&#123;        --cnt;    &#125;    [[nodiscard]] unsigned get() const&#123;        return cnt;    &#125;private:    unsigned int cnt;&#125;;template&lt;typename T&gt;class MySharedPtr&#123;public:    explicit MySharedPtr(T* argPtr): targetPtr(argPtr), cntPtr(new ReferenceCount())&#123;&#125;    MySharedPtr(): targetPtr(nullptr), cntPtr(nullptr)&#123;&#125;    MySharedPtr(const MySharedPtr&amp; argSharedPtr): targetPtr(argSharedPtr.targetPtr), cntPtr(argSharedPtr.cntPtr)&#123;        m1.lock();        if(cntPtr)&#123;            cntPtr-&gt;add_ref();        &#125;        m1.unlock();    &#125;    ~MySharedPtr()&#123;        m1.lock();        if(cntPtr)&#123;            cntPtr-&gt;remove_ref();        &#125;        if(!cntPtr-&gt;get())&#123;            delete targetPtr;            delete cntPtr;            targetPtr &#x3D; nullptr;            cntPtr &#x3D; nullptr;        &#125;        m1.unlock();    &#125;    T* getTargetPtr()&#123;        return targetPtr;    &#125;    ReferenceCount* getReferenceCountPtr()&#123;        return cntPtr;    &#125;    T&amp; operator * ()&#123;        return *targetPtr;    &#125;    T* operator -&gt; ()&#123;        return targetPtr;    &#125;private:    mutex m1;    T* targetPtr;    ReferenceCount *cntPtr;&#125;;int main()&#123;    auto ptr &#x3D; new pair&lt;int, int&gt;&#123;1, 2&#125;;    MySharedPtr&lt;pair&lt;int, int&gt;&gt; ptr1(ptr);    MySharedPtr&lt;pair&lt;int, int&gt;&gt; ptr2(ptr1);    cout &lt;&lt; ptr2-&gt;first &lt;&lt; endl;    cout &lt;&lt; (*ptr2).second &lt;&lt; endl;    return 0;&#125;</code></pre></div></figure><h4 id="右值引用与移动构造函数"><a class="markdownIt-Anchor" href="#右值引用与移动构造函数"></a> 右值引用与移动构造函数</h4><h3 id="c14新特性-sup-idfnref2-classfootnote-refa-hreffn2-relfootnotespan-classhint-top-hint-rounded-aria-labelc14新特性的所有知识点全在这儿啦httpssegmentfaultcoma11900000234414272spanasup"><a class="markdownIt-Anchor" href="#c14新特性-sup-idfnref2-classfootnote-refa-hreffn2-relfootnotespan-classhint-top-hint-rounded-aria-labelc14新特性的所有知识点全在这儿啦httpssegmentfaultcoma11900000234414272spanasup"></a> C++14新特性 <sup id="fnref:2" class="footnote-ref"><a href="#fn:2" rel="footnote"><span class="hint--top hint--rounded" aria-label="[C++14新特性的所有知识点全在这儿啦！](https://segmentfault.com/a/1190000023441427)">[2]</span></a></sup></h3><h4 id="函数返回值类型推导"><a class="markdownIt-Anchor" href="#函数返回值类型推导"></a> 函数返回值类型推导</h4><p>C++14 对函数返回类型推导规则做了优化，先看一段代码：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">#include &lt;iostream&gt;using namespace std;auto func(int i)&#123;    return i;&#125;int main()&#123;    cout &lt;&lt; func(4) &lt;&lt; endl;    return 0;&#125;</code></pre></div></figure><p>使用C++11编译：</p><figure><div class="code-wrapper"><pre class="line-numbers language-bash" data-language="bash" data-start="1"><code class="language-bash">~&#x2F;test$ g++ test.cc -std&#x3D;c++11test.cc:5:16: error: ‘func’ function uses ‘auto’ type specifier without trailing return type auto func(int i) &#123;                ^test.cc:5:16: note: deduced return type only available with -std&#x3D;c++14 or -std&#x3D;gnu++14</code></pre></div></figure><p>上面的代码使用 C++11 是不能通过编译的，通过编译器输出的信息也可以看见这个特性需要到 C++14 才被支持。</p><p>返回值类型推导也可以用在模板中：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">#include &lt;iostream&gt;using namespace std;template&lt;typename T&gt;auto func(T t)&#123; return t; &#125;int main()&#123;    cout &lt;&lt; func(4) &lt;&lt; endl;    cout &lt;&lt; func(3.4) &lt;&lt; endl;    return 0;&#125;</code></pre></div></figure><p><strong>注意</strong></p><ol><li>函数内如果有多个return语句，它们必须返回相同类型，否则编译失败。 <figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">auto func(bool flag)&#123;    if(flag) return 1;    else return 2.3; &#x2F;&#x2F; error&#125;&#x2F;&#x2F; inconsistent deduction for auto return type: &#39;int&#39; and then &#39;double&#39;</code></pre></div></figure></li><li>如果return语句返回初始化列表，返回值类型推导也失败。 <figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">auto func()&#123;    return &#123;1, 2, 3&#125;;   &#x2F;&#x2F; error returning initializer list&#125;</code></pre></div></figure></li><li>如果函数是虚函数，不能使用返回类型推导。 <figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">struct A&#123;    &#x2F;&#x2F; error: virtual function cannot have deduced return type    virtual auto func() &#123; return 1; &#125;&#125;</code></pre></div></figure></li><li>返回类型推导可以在前向声明中，但是在使用他们之前，翻译单元中必须能够得到函数定义。 <figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">auto f();       &#x2F;&#x2F; declared, not yet defined.auto f() &#123; return 42; &#125;     &#x2F;&#x2F; defined, return type is intint main()&#123;    cout &lt;&lt; f() &lt;&lt; endl;&#125;</code></pre></div></figure></li><li>返回类型推导可以用在递归函数中，但是递归调用必须以至少一个返回语句作为先导，以便编译器推导出返回类型。 <figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">auto sum(int i)&#123;    if(i &#x3D;&#x3D; 1) return i;    else return sum(i - 1) + i;&#125;</code></pre></div></figure></li></ol><h4 id="lambda参数auto"><a class="markdownIt-Anchor" href="#lambda参数auto"></a> lambda参数auto</h4><p>在C++11中，lambda表达式参数需要使用具体的类型声明：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">auto f &#x3D; [](int a) &#123; return a; &#125;</code></pre></div></figure><p>在C++14中，对此进行优化，lambda表达式参数可以直接是auto：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">auto f &#x3D; [](auto a)&#123; return a; &#125;cout &lt;&lt; f(1) &lt;&lt; endl;cout &lt;&lt; f(2.3f) &lt;&lt; endl;</code></pre></div></figure><h4 id="变量模板"><a class="markdownIt-Anchor" href="#变量模板"></a> 变量模板</h4><p>C++14支持变量模板：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">template&lt;class T&gt;constexpr T pi &#x3D; T(3.1415926535897932385L);int main()&#123;    cout &lt;&lt; pi(int) &lt;&lt; endl;    cout &lt;&lt; pi(double) &lt;&lt; endl;&#125;</code></pre></div></figure><h4 id="别名模板"><a class="markdownIt-Anchor" href="#别名模板"></a> 别名模板</h4><p>C++14 也支持别名模板</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">template&lt;typename T, typename U&gt;struct A&#123;    T t;    U u;&#125;;template&lt;typename T&gt;using B &#x3D; A&lt;T, int&gt;;int main()&#123;    B&lt;double&gt; b;    b.t &#x3D; 10;    b.u &#x3D; 20;    cout &lt;&lt; b.t &lt;&lt; endl;    cout &lt;&lt; b.u &lt;&lt; endl;    return 0;&#125;</code></pre></div></figure><h4 id="constexpr的限制"><a class="markdownIt-Anchor" href="#constexpr的限制"></a> constexpr的限制</h4><p>C++14 相较于 C++11 对 constexpr 减少了一些限制：</p><ol><li>C++11 中constexpr函数可以递归使用，在 C++14 中可以使用局部变量和循环<figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">constexpr int factorial(int n)&#123;  &#x2F;&#x2F; C++14 和 C++11 均可     return n &lt;&#x3D; 1 ? 1 : (n * factorial(n - 1));&#125;</code></pre></div></figure>在 C++14 中可以这样做：<figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">constexpr int factorial(int n)&#123;  &#x2F;&#x2F; C++11 中不可以， C++14 中可以     int ret &#x3D; 0;     for(int i &#x3D; 0; i &lt; n; ++i)&#123;         ret +&#x3D; i;     &#125;     return ret;&#125;</code></pre></div></figure></li><li>C++11 中 constexpr 函数必须把所有的东西都放在一个单独的return语句中，而constexpr则无此限制：<figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">constexpr int func(bool flag)&#123;   &#x2F;&#x2F; C++14 和 C++11 均可     return 0;&#125;</code></pre></div></figure>在 C++14 中可以这样：<figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">constexpr int func(bool flag)&#123;   &#x2F;&#x2F; C++11 中不可以， C++14 中可以     if(flag) return 1;     else return 0;&#125;</code></pre></div></figure></li></ol><h4 id="deprecated-标记"><a class="markdownIt-Anchor" href="#deprecated-标记"></a> [[deprecated]] 标记</h4><p>C++14 中增加了 deprecated 标记，修饰类、变量、函数等，当程序中使用了被其修饰的代码的时候，编译时会产生警告，用来提示开发者该标记修饰的内容将来可能会被移除，尽量不要使用。</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">struct [[deprecated]] A &#123;&#125;;int main()&#123;    A a;    return 0;&#125;</code></pre></div></figure><p>当编译时，会出现如下警告：</p><figure><div class="code-wrapper"><pre class="line-numbers language-bash" data-language="bash" data-start="1"><code class="language-bash">~&#x2F;test$ g++ test.cc -std&#x3D;c++14test.cc: In function ‘int main()’:test.cc:11:7: warning: ‘A’ is deprecated [-Wdeprecated-declarations]     A a;       ^test.cc:6:23: note: declared here struct [[deprecated]] A &#123;</code></pre></div></figure><h4 id="二进制字面量与整形字面量分隔符"><a class="markdownIt-Anchor" href="#二进制字面量与整形字面量分隔符"></a> 二进制字面量与整形字面量分隔符</h4><p>C++14 引入了二进制字面量，也引入了分隔符。</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int a &#x3D; 0b0001&#39;0010&#39;1010;double b &#x3D; 3.14&#39;1234&#39;1234&#39;1234;</code></pre></div></figure><h4 id="stdmake_unique"><a class="markdownIt-Anchor" href="#stdmake_unique"></a> std::make_unique</h4><p>我们都知道 C++11 中有std::make_shared，却没有std::make_unique，在 C++14 中已经完善。</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">struct A &#123;&#125;;std::unique_ptr&lt;A&gt; ptr &#x3D; std::make_unique&lt;A&gt;();</code></pre></div></figure><h4 id="stdmake_timed_mutex-与-stdshared_lock"><a class="markdownIt-Anchor" href="#stdmake_timed_mutex-与-stdshared_lock"></a> std::make_timed_mutex 与 std::shared_lock</h4><p>C++14 通过 std::make_timed_mutex 与 std::shared_lock 来实现读写锁，保证多个线程可以同时读，写操作不可以同时和读操作一起进行。<br />实现方式如下：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">struct ThreadSafe&#123;    mutable std::make_timed_mutex mutex_;    int value_;    ThreadSafe()&#123;        value_ &#x3D; 0;    &#125;    int get() const &#123;        std::shared_lock&lt;std::shared_timed_mutex&gt; loc(mutex_);        return value_;    &#125;    void increase() &#123;        std::unique_lock&lt;std::shared_timed_mutex&gt; lock(mutex_);        value_ +&#x3D; 1;    &#125;&#125;</code></pre></div></figure><p>timed锁可以带来超时时间。</p><h4 id="stdinteger_sequence"><a class="markdownIt-Anchor" href="#stdinteger_sequence"></a> std::integer_sequence ⭐</h4><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">template&lt;typename T, T... ints&gt;void print_sequence(std::integer_sequence&lt;T, ints...&gt; int_seq)&#123;    std::cout &lt;&lt; &quot;the sequence of size &quot; &lt;&lt; int_seq.size() &lt;&lt; &quot;: &quot;;    ((std::cout &lt;&lt; ints &lt;&lt; &quot; &quot;), ...);    stdcout &lt;&lt; &quot;\n&quot;;&#125;</code></pre></div></figure><p>std::integer_sequence 和 std::tuple 的配合使用：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">template &lt;std::size_t... Is, typename F, typename T&gt;auto map_filter_tuple(F f, T&amp; t)&#123;    return std::make_tuple(f(std::get&lt;Is&gt;(t))...);&#125;template &lt;std::size_t... Is, typename F, typename T&gt;auto map_filter_tuple(std::index_sequence&lt;Is...&gt;, F f, T&amp; t)&#123;    return std::make_tuple(f(std::get&lt;Is&gt;(t))...);&#125;template &lt;typename S, typename F, typename T&gt;auto map_filter_tuple(F&amp;&amp; f, T&amp; t)&#123;    return map_filter_tuple(S&#123;&#125;, std::forward&lt;F&gt;(f), t);&#125;</code></pre></div></figure><h4 id="stdexchange"><a class="markdownIt-Anchor" href="#stdexchange"></a> std::exchange</h4><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">&#x2F;&#x2F; exchange 的实现template&lt;class T, class U &#x3D; T&gt;constexpr T exchange(T&amp; obj, U&amp;&amp; new_value)&#123;    T old_value &#x3D; std::move(obj);    obj &#x3D; std::forward&lt;T&gt;(new_value);    return old_value;&#125;&#x2F;&#x2F; new_value 的值给了 obj，而没有对 new_value 赋值。int main()&#123;    std::vector&lt;int&gt; v;    std::exchange(v, &#123;1, 2, 3, 4&#125;);    cout &lt;&lt; v.size() &lt;&lt; endl;    for(int a: v)&#123;        cout &lt;&lt; a &lt;&lt; &quot; &quot;;    &#125;    return 0;&#125;</code></pre></div></figure><h4 id="stdquoted"><a class="markdownIt-Anchor" href="#stdquoted"></a> std::quoted</h4><p>C++14 引入 std::quoted 用于给字符串添加双引号</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main()&#123;    string str &#x3D; &quot;hello world&quot;;    cout &lt;&lt; str &lt;&lt; endl;    cout &lt;&lt; std::quoted(str) &lt;&lt; endl;    return 0;&#125;</code></pre></div></figure><h3 id="c17新特性-sup-idfnref3-classfootnote-refa-hreffn3-relfootnotespan-classhint-top-hint-rounded-aria-labelc17新特性httpssegmentfaultcoma11900000234567663spanasup"><a class="markdownIt-Anchor" href="#c17新特性-sup-idfnref3-classfootnote-refa-hreffn3-relfootnotespan-classhint-top-hint-rounded-aria-labelc17新特性httpssegmentfaultcoma11900000234567663spanasup"></a> C++17新特性 <sup id="fnref:3" class="footnote-ref"><a href="#fn:3" rel="footnote"><span class="hint--top hint--rounded" aria-label="[C++17新特性](https://segmentfault.com/a/1190000023456766)">[3]</span></a></sup></h3><h4 id="构造函数模板推导"><a class="markdownIt-Anchor" href="#构造函数模板推导"></a> 构造函数模板推导</h4><p>在 C++17 前构造一个模板类对象需要指明类型：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">pair&lt;int, double&gt; p(1, 2.2);    &#x2F;&#x2F; before C++17</code></pre></div></figure><p>C++17 就不需要特殊指定，直接可以推导出类型：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">pair p(1, 2.2); &#x2F;&#x2F; C++17 自动推导vector v &#x3D; &#123;1, 2, 3&#125;;   &#x2F;&#x2F; C++17</code></pre></div></figure><h4 id="结构化绑定"><a class="markdownIt-Anchor" href="#结构化绑定"></a> 结构化绑定 ⭐</h4><p>通过结构化绑定，对于<code>tuple</code>、<code>map</code> 等类型，获取相应值会方便很多</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">std::tuple&lt;int, double&gt; func()&#123;    return std::tuple(1, 2.2);&#125;int main()&#123;    auto [i, d] &#x3D; func();    cout &lt;&lt; i &lt;&lt; endl;    cout &lt;&lt; d &lt;&lt; endl;&#125;</code></pre></div></figure><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">void f()&#123;    map&lt;int, string&gt; m &#x3D; &#123;&#123;0, &quot;a&quot;&#125;, &#123;1, &quot;b&quot;&#125;&#125;;    for(const auto&amp; [i, s]: m)&#123;        cout &lt;&lt; i &lt;&lt; &quot; &quot; &lt;&lt; s &lt;&lt; endl;    &#125;&#125;int main()&#123;    std::pair a(1, 2.3f);    auto [i, f] &#x3D; a;    cout &lt;&lt; i &lt;&lt; endl;    cout &lt;&lt; f &lt;&lt; endl;    return 0;&#125;</code></pre></div></figure><p>引用的结构化绑定还可以改变对象的值</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main()&#123;    std::pair a(1, 2.3f);    auto&amp; [i, f] &#x3D; a;    i &#x3D; 2;    cout &lt;&lt; a.first &lt;&lt; endl;&#125;</code></pre></div></figure><p><em>注意结构化绑定不能应用于constexpr</em></p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">constexpr auto [x, y] &#x3D; std::pair(1, 2.3f); &#x2F;&#x2F; compile error, C++20 可以</code></pre></div></figure><p>结构化绑定不仅可以绑定 pair 和 tuple ，还可以绑定数组和结构体等。</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int array[3] &#x3D; &#123;1, 2, 3&#125;;auto [a, b, c] &#x3D; array;cout &lt;&lt; a &lt;&lt; &quot; &quot; &lt;&lt; b &lt;&lt; &quot; &quot; &lt;&lt; c &lt;&lt; endl;&#x2F;&#x2F; 注意这里的struct的成员一定是要public的struct Point&#123;    int x, y;&#125;;Point func()&#123;    return &#123;1, 2&#125;;&#125;const auto [x, y] &#x3D; func();</code></pre></div></figure><p>这里其实可以实现自定义类的结构化绑定，代码如下：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">&#x2F;&#x2F; 需要实现相关的tuple_size和tuple_element和get&lt;N&gt;方法。class Entry&#123;public:    void Init()&#123;        name_ &#x3D; &quot;name&quot;;        age_ &#x3D; 10;    &#125;    std::string GetName() const &#123; return name_; &#125;    int GetAge() const &#123; return age_; &#125;private:    std::string name_;    int age_;&#125;template &lt;size_t I&gt;auto get(const Entry&amp; e)&#123;    if constexpr (I &#x3D;&#x3D; 0) return e.GetName();    else if constexpr(I &#x3D;&#x3D; 1) return e.GetAge();&#125;namespace std&#123;    template&lt;&gt; struct tuple_size&lt;Entry&gt; : integral_constant&lt;size_t, 2&gt;&#123;&#125;;    template&lt;&gt; struct tuple_element&lt;0, Entry&gt; &#123; using type &#x3D; std::string; &#125;;    template&lt;&gt; struct tuple_element&lt;1, Entry&gt; &#123; using type &#x3D; int; &#125;;&#125;int main()&#123;    Entry e;    e.Init();    auto [name, age] &#x3D; e;    cout &lt;&lt; name &lt;&lt; &quot; &quot; &lt;&lt; age &lt;&lt; endl; &#x2F;&#x2F; name 10    return 0;&#125;</code></pre></div></figure><h4 id="if-switch-语句初始化"><a class="markdownIt-Anchor" href="#if-switch-语句初始化"></a> if-switch 语句初始化</h4><p>C++17 前if语句需要这样写代码：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int a &#x3D; GetValue();if(a &lt; 101)&#123;    cout &lt;&lt; a;&#125;</code></pre></div></figure><p>C++17 之后可以这样：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">&#x2F;&#x2F; if (init; condition)if(int a &#x3D; GetValue(); a &lt; 101)&#123;    cout &lt;&lt; a;&#125;string str &#x3D; &quot;Hi World&quot;;if(auto [pos, size] &#x3D; pair(str.find(&quot;Hi&quot;), str.size()); pos !&#x3D; string::npos)&#123;    std::cout &lt;&lt; pos &lt;&lt; &quot; Hello, size is &quot; &lt;&lt; size;&#125;</code></pre></div></figure><p>使用这种方式可以尽可能约束作用域，让代码更简洁，可读性略有下降，但是还好</p><h4 id="内联变量"><a class="markdownIt-Anchor" href="#内联变量"></a> 内联变量</h4><p>C++17 前只有内联函数，现在有了内联变量，我们印象中 C++ 类的静态成员变量在头文件中是不能初始化的，但是有了内联变量，就可以达到此目的了：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">&#x2F;&#x2F; header filestruct A &#123;    static const int value;&#125;inline int const A::value &#x3D; 10;&#x2F;&#x2F; &#x3D;&#x3D;&#x3D;&#x3D;&#x3D;&#x3D;&#x3D;&#x3D;&#x3D; 或者 &#x3D;&#x3D;&#x3D;&#x3D;&#x3D;&#x3D;&#x3D;&#x3D;&#x3D;&#x3D;&#x3D;struct A &#123;    inline static const int value &#x3D; 10;&#125;</code></pre></div></figure><h4 id="折叠表达式"><a class="markdownIt-Anchor" href="#折叠表达式"></a> 折叠表达式</h4><p>C++17 引入了折叠表达式使可变模板编程更方便：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">template &lt;typename ... Ts&gt;auto sum(Ts ... ts)&#123;    return (ts + ...);&#125;int a &#x3D; &#123;sum(1, 2, 3, 4, 5)&#125;;   &#x2F;&#x2F; 15std::string a&#123;&quot;hello &quot;&#125;;std::string b&#123;&quot;world&quot;&#125;;cout &lt;&lt; sum(a, b) &lt;&lt; endl;      &#x2F;&#x2F; hello world</code></pre></div></figure><h4 id="constexpr-lambda-表达式"><a class="markdownIt-Anchor" href="#constexpr-lambda-表达式"></a> constexpr lambda 表达式</h4><p>C++17 前 lambda 表达式只能在运行时使用，C++17引入了constexpr lambda表达式，可以用于在编译期进行计算。</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main()&#123;     &#x2F;&#x2F; C++17可编译    constexpr auto lamb &#x3D; [](int n)&#123; return n * n; &#125;;    static_assert(lamb(3) &#x3D;&#x3D; 9, &quot;a&quot;);&#125;</code></pre></div></figure><p><strong>注意</strong>：constexpr函数有如下限制：<br />函数体不能包含汇编语句、goto语句、label、try块、静态变量、线程局部存储、没有初始化的普通变量，不能动态分配内存，不能有new、delete等，不能虚函数。</p><h4 id="namespace嵌套"><a class="markdownIt-Anchor" href="#namespace嵌套"></a> namespace嵌套</h4><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">namespace A&#123;    namespace B&#123;        namespace C&#123;            void func();        &#125;    &#125;&#125;&#x2F;&#x2F; C++17，更方便更舒适namespace A::B::C &#123;    void func();&#125;</code></pre></div></figure><h4 id="__has_include预处理表达式"><a class="markdownIt-Anchor" href="#__has_include预处理表达式"></a> __has_include预处理表达式</h4><p>可以判断是否有某个头文件，代码可能会在不同编译器下工作，不同编译器的可用头文件有可能不同，所以可以用此来判断：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">#if defined __has_include#if __has_include(&lt;charconv&gt;)#define has_charconv 1#include &lt;charconv&gt;#endif#endifstd::optional&lt;int&gt; ConvertToInt(const std::string&amp; str)&#123;    int value&#123;&#125;;#ifdef has_charconv    const auto last &#x3D; str.data() + str.size();    const auto res &#x3D; std::from_chars(str.data(), last, value);    if(res.ec &#x3D;&#x3D; std::errc&#123;&#125; and res.ptr &#x3D;&#x3D; last) return value;#else    &#x2F;&#x2F; alternative implementation...    &#x2F;&#x2F; 其他的实现方式#endif    return std::nullopt;&#125;</code></pre></div></figure><h4 id="在lambda表达式中用this捕获对象副本"><a class="markdownIt-Anchor" href="#在lambda表达式中用this捕获对象副本"></a> 在lambda表达式中用*this捕获对象副本</h4><p>正常情况下，lambda表达式中访问类的成员变量需要捕获this，但是这里捕获的是this指针，指向的是对象的引用，正常情况下可能没问题，但是如果多线程情况下，函数的作用域超过了对象的作用域，对象已经被析构，还访问了成员变量，就会有问题。</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">struct A&#123;    int a;    void func()&#123;        auto f &#x3D; [this]&#123;            cout &lt;&lt; a &lt;&lt; endl;        &#125;;        f();    &#125;&#125;;int main()&#123;    A a;    a.func();    return 0;&#125;</code></pre></div></figure><p>所以 C++17 增加了新特性，捕获*this，不持有this指针，而是持有对象的拷贝，这样生命周期就与对象的生命周期不相关了。</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">struct A&#123;    int a;    void func()&#123;        auto f &#x3D; [*this]&#123;            cout &lt;&lt; a &lt;&lt; endl;        &#125;;        f();    &#125;&#125;;int main()&#123;    A a;    a.func();    return 0;&#125;</code></pre></div></figure><h4 id="新增attribute"><a class="markdownIt-Anchor" href="#新增attribute"></a> 新增Attribute</h4><p>我们可能平时在项目中见过__declspec、attribute, #pragma指示符，使用它们来给编译器提供一些额外的信息，来产生一些优化或特定的代码，也可以给其他开发者一些提示信息。<br />例如：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">struct A &#123; short f[3]; &#125; __attribute__((aligned(8)));void fatal() __attribute__((noreturn));</code></pre></div></figure><p>在C++11和C++14中有更方便的方法：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">[[carries_dependency]] 让编译期跳过不必要的内存栅栏指令[[noreturn]] 函数不会返回[[deprecated]] 函数将弃用的警告[[noreturn]] void terminate() noexcept;[[deprecated(&quot;use new func instead&quot;)]] void func() &#123;&#125;</code></pre></div></figure><p>C++17又新增了三个:<br />[[fallthrough]]，用在switch提示可以直接落下去，不需要break，让编译器忽略警告。</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">switch (i) &#123;    case 1:        xxx;    &#x2F;&#x2F; warning    case 2:        xxx;        [[fallthrough]];    &#x2F;&#x2F; 消除警告    case 3:        xxx;        break;&#125;</code></pre></div></figure><p>使得编译器和其他开发者都可以理解开发者的意图。</p><p>[[nodiscard]]：表示修饰的内容不能被忽略，可用于修饰函数，标明返回值一定要被处理。</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">[[nodiscard]] int func();void F()&#123;    func(); &#x2F;&#x2F; warning 没有处理函数返回值&#125;</code></pre></div></figure><p>[[maybe_unused]]：提示编译器修饰的内容可能暂时没有使用，避免产生警告。</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">void func1() &#123;&#125;[[maybe_unused]] void func2() &#123;&#125;    &#x2F;&#x2F; 消除警告void func3() &#123;    int x &#x3D; 1;    [[maybe_unused]] int y &#x3D; 2;     &#x2F;&#x2F; 消除警告&#125;</code></pre></div></figure><h4 id="字符串转换"><a class="markdownIt-Anchor" href="#字符串转换"></a> 字符串转换 ⭐</h4><p>新增from_chars函数和to_chars函数，直接看代码：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">#include &lt;charconv&gt;int main()&#123;    const std::string str&#123;&quot;123456098&quot;&#125;;    int value &#x3D; 0;    const auto res &#x3D; std::from_chars(str.data(), str.data() + 4, value);    if (res.ec &#x3D;&#x3D; std::errc())&#123;        cout &lt;&lt; value &lt;&lt; &quot;, distance &quot; &lt;&lt; res.ptr - str.data() &lt;&lt; endl;    &#125;else if(res.ec &#x3D;&#x3D; std::errc::invalid_argument)&#123;        cout &lt;&lt; &quot;invalid&quot; &lt;&lt; endl;    &#125;    str &#x3D; std::string(&quot;12.34&quot;);    double val &#x3D; 0;    const auto format &#x3D; std::chars_format::general;    res &#x3D; std::from_chars(str.data(), str.data() + str.size(), value, format);    str &#x3D; std::string(&quot;xxxxxxxx&quot;);    const int v &#x3D; 1234;    res &#x3D; std::to_chars(str.data(), str.data() + str.size(), v);    cout &lt;&lt; str &lt;&lt; &quot;, filled &quot; &lt;&lt; res.ptr - str.data() &lt;&lt; &quot; characters \n&quot;;    &#x2F;&#x2F; 1234xxx, filled 4 characters.&#125;</code></pre></div></figure><h4 id="stdvariant"><a class="markdownIt-Anchor" href="#stdvariant"></a> std::variant</h4><p>C++17增加了std::variant实现类似union的功能，但却比union更高级，举个例子union里面不能有string这种类型，但std::variant却可以，还可以支持更多复杂类型，如map等，看代码：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main()&#123; &#x2F;&#x2F; C++17可编译    std::variant&lt;int, std::string&gt; var(&quot;hello&quot;);    cout &lt;&lt; var.index() &lt;&lt; endl;    var &#x3D; 123;    cout &lt;&lt; var.index() &lt;&lt; endl;    try&#123;        var &#x3D; &quot;world&quot;;        std::string str &#x3D; std::get&lt;std::string&gt;(var);   &#x2F;&#x2F;通过类型获取值        var &#x3D; 3;        int i &#x3D; std::get&lt;0&gt;(var);   &#x2F;&#x2F; 通过index获取值        cout &lt;&lt; str &lt;&lt; endl;        cout &lt;&lt; i &lt;&lt; endl;    &#125;catch(...)&#123;        &#x2F;&#x2F; xxx    &#125;    return 0;&#125;</code></pre></div></figure><p>注意：一般情况下variant的第一个类型要有对应的构造函数，否则编译失败：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">struct A&#123;    A(int i) &#123;&#125;&#125;;int main()&#123;    std::variant&lt;A, int&gt; var;   &#x2F;&#x2F; 编译失败&#125;</code></pre></div></figure><p>如何避免这种情况，可以使用std::monostate来打个桩，模拟一个空状态。</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">std::variant&lt;std::monostate, A&gt; var;    &#x2F;&#x2F; 可以编译成功</code></pre></div></figure><h4 id="stdoptional"><a class="markdownIt-Anchor" href="#stdoptional"></a> std::optional</h4><p>我们有时候可能会有需求，让函数返回一个对象，如下：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">struct A &#123;&#125;;A func()&#123;    if(flag) return A();    else &#123;        &#x2F;&#x2F; 异常情况下，怎么返回异常值，想返回一个空    &#125;&#125;</code></pre></div></figure><p>有一种方法是返回对象指针，异常情况下就可以返回nullptr啦，但是这就涉及到了内存管理，也许你会使用智能指针，但是这里更方便的方法就是std::optional啦。</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">std::optional&lt;int&gt; StoI(const std::string&amp; s)&#123;    try&#123;        return std::stoi(s);    &#125;catch(...)&#123;        return std::nullopt;    &#125;&#125;void func()&#123;    std::string s&#123;&quot;123&quot;&#125;;    std::optional&lt;int&gt; o &#x3D; StoI(s);    if(o)&#123;        cout &lt;&lt; *o &lt;&lt; endl;    &#125;else&#123;        cout &lt;&lt; &quot;error&quot; &lt;&lt; endl;    &#125;&#125;</code></pre></div></figure><h4 id="stdany"><a class="markdownIt-Anchor" href="#stdany"></a> std::any ⭐</h4><p>C++17引入了any可以用来存储任何类型的单个值，见代码：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main()&#123;     &#x2F;&#x2F; C++17可编译    std::any a &#x3D; 1;    cout &lt;&lt; a.type().name() &lt;&lt; &quot; &quot; &lt;&lt; std::any_cast&lt;int&gt;(a) &lt;&lt; endl;    a &#x3D; 2.2f;    cout &lt;&lt; a.type().name() &lt;&lt; &quot; &quot; &lt;&lt; std::any_cast&lt;double&gt;(a) &lt;&lt; endl;    a.reset();    if(a.has_value())&#123;        cout &lt;&lt; a.type().name();    &#125;    a &#x3D; std::string(&quot;a&quot;);    cout &lt;&lt; a.type().name() &lt;&lt; &quot; &quot; &lt;&lt; std::any_cast&lt;std::string&gt;(a) &lt;&lt; endl;&#125;</code></pre></div></figure><h4 id="stdapply"><a class="markdownIt-Anchor" href="#stdapply"></a> std::apply</h4><p>使用std::apply可以将tuple展开作为函数参数传入，见代码：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int add(int first, int second) &#123; return first + second; &#125;auto add_lambda &#x3D; [](auto first, auto second) &#123; return first + second; &#125;int main()&#123;    std::cout &lt;&lt; std::apply(add, std::pair(1, 2)) &lt;&lt; &quot;\n&quot;;    std::cout &lt;&lt; add(std::pair(1, 2)) &lt;&lt; &quot;\n&quot;;    std::cout &lt;&lt; std::apply(add_lambda, std::tuple(2.0f, 3.0f)) &lt;&lt; &quot;\n&quot;;&#125;</code></pre></div></figure><h4 id="stdmake_from_tuple"><a class="markdownIt-Anchor" href="#stdmake_from_tuple"></a> std::make_from_tuple</h4><p>使用make_from_tuple可以将tuple展开作为构造函数参数</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">struct Foo&#123;    Foo(int first, int second, int third)&#123;        std::cout &lt;&lt; first &lt;&lt; &quot; &quot; &lt;&lt; second &lt;&lt; &quot; &quot; &lt;&lt; third &lt;&lt; std::endl;    &#125;&#125;;int main()&#123;    auto tuple &#x3D; std::make_tuple(42, 3.14f, 0);    std::make_from_tuple&lt;Foo&gt;(std::move(tuple));&#125;</code></pre></div></figure><h4 id="stdstring_view"><a class="markdownIt-Anchor" href="#stdstring_view"></a> std::string_view</h4><p>通常我们传递一个string的时候，会触发对象的拷贝操作，大字符串的拷贝赋值操作会触发堆的内存分配，很影响运行效率，有了string_view就可以避免拷贝操作，平时传递过程中传递string_view即可。</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">void func(std::string_view stv) &#123; cout &lt;&lt; stv &lt;&lt; endl; &#125;int main()&#123;    std::string str &#x3D; &quot;Hello World&quot;;    std::cout &lt;&lt; str &lt;&lt; std::endl;    std::string_view stv(str.c_str(), str.size());    cout &lt;&lt; stv &lt;&lt; endl;    func(stv);    return 0;&#125;</code></pre></div></figure><h4 id="as_const"><a class="markdownIt-Anchor" href="#as_const"></a> as_const</h4><p>C++17使用as_const可以将左值转成const类型</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">std::string str &#x3D; &quot;string&quot;;const std::string&amp; constStr &#x3D; std::as_const(str);</code></pre></div></figure><h4 id="file_system"><a class="markdownIt-Anchor" href="#file_system"></a> file_system</h4><p>C++17正式将file_system纳入到标准之中，提供了关于文件的大多数功能，基本上应有尽有，这里举几个简单例子</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">namespace fs &#x3D; std::filesystem;fs::create_directory(dir_path);fs::copy_file(src, dst, fs::copy_options::skip_existing);fs::exists(filename);fs::current_path(err_code);</code></pre></div></figure><h4 id="stdshared_mutex"><a class="markdownIt-Anchor" href="#stdshared_mutex"></a> std::shared_mutex</h4><p>C++17引入了shared_mutex，可以实现读写锁</p><h3 id="c20新特性"><a class="markdownIt-Anchor" href="#c20新特性"></a> C++20新特性</h3><h1 id="操作系统"><a class="markdownIt-Anchor" href="#操作系统"></a> 操作系统</h1><h2 id="进程-线程和协程sup-idfnref5-classfootnote-refa-hreffn5-relfootnotespan-classhint-top-hint-rounded-aria-label面试必考-进程和线程的区别httpszhuanlanzhihucomp1144533095spanasup"><a class="markdownIt-Anchor" href="#进程-线程和协程sup-idfnref5-classfootnote-refa-hreffn5-relfootnotespan-classhint-top-hint-rounded-aria-label面试必考-进程和线程的区别httpszhuanlanzhihucomp1144533095spanasup"></a> 进程、线程和协程<sup id="fnref:5" class="footnote-ref"><a href="#fn:5" rel="footnote"><span class="hint--top hint--rounded" aria-label="[面试必考 | 进程和线程的区别](https://zhuanlan.zhihu.com/p/114453309)">[5]</span></a></sup></h2><p><strong>进程</strong><br />进程是并发执行的程序在执行过程中的分配和资源管理的最小单位，是一个动态概念，竞争计算机系统资源的基本单位。<br /><strong>线程</strong><br />线程是进程的一个执行单元，是进程内的调度实体。比进程更小的独立运行单位。线程也被称为轻量级进程。<br /><strong>协程</strong><br />协程是一种用户态的轻量级线程，协程的调度完全由用户控制。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。</p><h3 id="进程和线程区别"><a class="markdownIt-Anchor" href="#进程和线程区别"></a> 进程和线程区别</h3><p><strong>地址空间</strong><br />线程共享本进程的地址空间，而进程之间是独立的地址空间。<br /><strong>资源</strong><br />线程共享本进程的资源如内存，I/O，CPU等，不利于资源的管理和保护，而进程之间的资源是独立的，能够很好的进行资源管理和保护。<br /><strong>健壮性</strong><br />多进程要比多线程健壮，一个进程崩溃之后，在保护模式下不会对其他的进程产生影响，但是一个线程崩溃整个进程都死掉。<br /><strong>执行过程</strong><br />每个独立的进程有一个程序运行的入口，循序执行序列和程序出口，执行开销大。<br />但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个现成的执行控制，执行开销小。<br /><strong>可并发性</strong><br />两者均可并发执行。<br /><strong>切换时</strong><br />进程切换时，消耗的资源大，效率不高。所以涉及到频繁的切换时，使用线程要好于进程。同样如果要求同时进行并且又要共享某些变量的并发操作，只能用线程不能用进程。</p><p><strong>其他</strong><br />线程是处理器调度的最小单位，进程不是。</p><h3 id="协程与线程进行比较"><a class="markdownIt-Anchor" href="#协程与线程进行比较"></a> 协程与线程进行比较？</h3><ol><li>一个线程可以拥有多个协程，一个进程也可以单独拥有多个协程，这样python中则能使用多核CPU。</li><li>线程进程都是同步机制，而协程则是异步</li><li>协程能保留上一次调用时的状态，每次过程重入时，就相当于进入上一次调用的状态</li></ol><h3 id="进程间通信的方式"><a class="markdownIt-Anchor" href="#进程间通信的方式"></a> 进程间通信的方式</h3><p><strong>无名管道</strong><br />速度慢，容量有限，只有父子进程能够通信。<br /><strong>FIFO（有名管道）</strong><br />去除了管道只能在父子进程中使用的限制<br /><strong>消息队列</strong></p><p><strong>信号量</strong></p><p><strong>共享内存</strong></p><h2 id="什么是僵尸进程"><a class="markdownIt-Anchor" href="#什么是僵尸进程"></a> 什么是僵尸进程？</h2><p>一个子进程结束后，它的父进程并没有等待它（调用wait或者waitpid），那么这个子进程将成为一个僵尸进程。僵尸进程是一个已经死亡的进程，但是并没有真正被销毁。它已经放弃了几乎所有内存空间，没有任何可执行代码，也不能被调度，仅仅在进程表中保留一个位置，记载该进程的进程ID、终止状态以及资源利用信息(CPU时间，内存使用量等等)供父进程收集，除此之外，僵尸进程不再占有任何内存空间。这个僵尸进程可能会一直留在系统中直到系统重启。</p><p>危害：占用进程号，而系统所能使用的进程号是有限的；占用内存。</p><p>以下情况不会产生僵尸进程：</p><ul><li>该进程的父进程先结束了。每个进程结束的时候，系统都会扫描是否存在子进程，如果有则用Init进程接管，成为该进程的父进程，并且会调用wait等待其结束。</li><li>父进程调用wait或者waitpid等待子进程结束（需要每隔一段时间查询子进程是否结束）。wait系统调用会使父进程暂停执行，直到它的一个子进程结束为止。waitpid则可以加入<code>WNOHANG</code>(wait-no-hang)选项，如果没有发现结束的子进程，就会立即返回，不会将调用waitpid的进程阻塞。同时，waitpid还可以选择是等待任一子进程（同wait），还是等待指定pid的子进程，还是等待同一进程组下的任一子进程，还是等待组ID等于pid的任一子进程；</li><li>子进程结束时，系统会产生<code>SIGCHLD</code>(signal-child)信号，可以注册一个信号处理函数，在该函数中调用waitpid，等待所有结束的子进程（注意：一般都需要循环调用waitpid，因为在信号处理函数开始执行之前，可能已经有多个子进程结束了，而信号处理函数只执行一次，所以要循环调用将所有结束的子进程回收）；</li><li>也可以用<code>signal(SIGCLD, SIG_IGN)</code>(signal-ignore)通知内核，表示忽略<code>SIGCHLD</code>信号，那么子进程结束后，内核会进行回收。</li></ul><h2 id="什么是孤儿进程"><a class="markdownIt-Anchor" href="#什么是孤儿进程"></a> 什么是孤儿进程？</h2><p>一个父进程已经结束了，但是它的子进程还在运行，那么这些子进程将成为孤儿进程。孤儿进程会被Init（进程ID为1）接管，当这些孤儿进程结束时由Init完成状态收集工作。</p><h2 id="什么是io多路复用怎么实现"><a class="markdownIt-Anchor" href="#什么是io多路复用怎么实现"></a> 什么是IO多路复用？怎么实现？</h2><p>IO多路复用（IO Multiplexing）是指单个进程/线程就可以同时处理多个IO请求。</p><p>实现原理：用户将想要监视的文件描述符（File Descriptor）添加到select/poll/epoll函数中，由内核监视，函数阻塞。一旦有文件描述符就绪（读就绪或写就绪），或者超时（设置timeout），函数就会返回，然后该进程可以进行相应的读/写操作。</p><h3 id="selectpollepoll三者的区别"><a class="markdownIt-Anchor" href="#selectpollepoll三者的区别"></a> select/poll/epoll三者的区别？</h3><ul><li><code>select</code>：将文件描述符放入一个集合中，调用select时，将这个集合从用户空间拷贝到内核空间（缺点1：每次都要复制，<strong>开销大</strong>），由内核根据就绪状态修改该集合的内容。（缺点2）<strong>集合大小有限制</strong>，32位机默认是1024（64位：2048）；采用水平触发机制。select函数返回后，需要通过遍历这个集合，找到就绪的文件描述符（缺点3：<strong>轮询的方式效率较低</strong>），当文件描述符的数量增加时，效率会线性下降；</li><li><code>poll</code>：和select几乎没有区别，区别在于文件描述符的存储方式不同，poll采用链表的方式存储，没有最大存储数量的限制；</li><li><code>epoll</code>：通过内核和用户空间共享内存，避免了不断复制的问题；支持的同时连接数上限很高（1G左右的内存支持10W左右的连接数）；文件描述符就绪时，采用回调机制，避免了轮询（回调函数将就绪的描述符添加到一个链表中，执行epoll_wait时，返回这个链表）；支持水平触发和边缘触发，采用边缘触发机制时，只有活跃的描述符才会触发回调函数。</li></ul><p>总结，区别主要在于：</p><ul><li>一个线程/进程所能打开的最大连接数</li><li>文件描述符传递方式（是否复制）</li><li>水平触发 or 边缘触发</li><li>查询就绪的描述符时的效率（是否轮询）</li></ul><h3 id="什么时候使用selectpoll什么时候使用epoll"><a class="markdownIt-Anchor" href="#什么时候使用selectpoll什么时候使用epoll"></a> 什么时候使用select/poll，什么时候使用epoll？</h3><p>当连接数较多并且有很多的不活跃连接时，epoll的效率比其它两者高很多；但是当连接数较少并且都十分活跃的情况下，由于epoll需要很多回调，因此性能可能低于其它两者。</p><h3 id="什么是文件描述符"><a class="markdownIt-Anchor" href="#什么是文件描述符"></a> 什么是文件描述符？</h3><p>文件描述符在形式上是一个非负整数。实际上，它是一个索引值，指向内核为每一个进程所维护的该进程打开文件的记录表。当程序打开一个现有文件或者创建一个新文件时，内核向进程返回一个文件描述符。</p><p>内核通过文件描述符来访问文件。文件描述符指向一个文件。</p><h2 id="缺页中断"><a class="markdownIt-Anchor" href="#缺页中断"></a> 缺页中断</h2><ul><li>缺页异常：malloc和mmap函数在分配内存时只是建立了进程虚拟地址空间，并没有分配虚拟内存对应的物理内存。当进程访问这些没有建立映射关系的虚拟内存时，处理器自动触发一个缺页异常，引发缺页中断。</li><li>缺页中断：缺页异常后将产生一个缺页中断，此时操作系统会根据页表中的外存地址在外存中找到所缺的一页，将其调入内存。</li></ul><h2 id="说说静态库和动态库的区别是什么sup-idfnref1-classfootnote-refa-hreffn1-relfootnotespan-classhint-top-hint-rounded-aria-labelc岗位面试真题宝典httpswwwnowcodercomissuetutorialtutorialid100691spanasup"><a class="markdownIt-Anchor" href="#说说静态库和动态库的区别是什么sup-idfnref1-classfootnote-refa-hreffn1-relfootnotespan-classhint-top-hint-rounded-aria-labelc岗位面试真题宝典httpswwwnowcodercomissuetutorialtutorialid100691spanasup"></a> 说说静态库和动态库的区别是什么<sup id="fnref:1" class="footnote-ref"><a href="#fn:1" rel="footnote"><span class="hint--top hint--rounded" aria-label="[C++岗位面试真题宝典](https://www.nowcoder.com/issue/tutorial?tutorialId=10069)">[1]</span></a></sup></h2><ol><li>静态库代码装载的速度快，执行速度略比动态库快。</li><li>动态库更加节省内存，可执行文件体积比静态库小很多。</li><li>静态库是在编译时加载，动态库是在运行时加载。</li><li>生成的静态链接库，Windows下以.lib为后缀，Linux下以.a为后缀。生成的动态链接库，Windows下以.dll为后缀，Linux下以.so为后缀。</li></ol><h3 id="虚拟内存"><a class="markdownIt-Anchor" href="#虚拟内存"></a> 虚拟内存</h3><p>操作系统为每一个进程分配一个独立的地址空间，这就是虚拟内存。虚拟内存与物理内存存在映射关系，通过页表寻址完成虚拟地址和物理地址的转换。</p><h4 id="为什么要用虚拟内存"><a class="markdownIt-Anchor" href="#为什么要用虚拟内存"></a> 为什么要用虚拟内存</h4><p>因为早期的内存分配方法存在以下问题：</p><ol><li>进程地址空间不隔离。会导致数据被随意修改。</li><li>内存使用效率低。</li><li>程序运行的地址不确定。操作系统随机为进程分配内存空间，所以程序运行的地址是不确定的。</li></ol><h4 id="使用虚拟内存的好处"><a class="markdownIt-Anchor" href="#使用虚拟内存的好处"></a> 使用虚拟内存的好处</h4><ol><li>扩大地址空间。每个进程独占一个4G空间，虽然真实物理内存没那么多。</li><li>内存保护：防止不同进程对物理内存的争夺和践踏，可以对特定内存地址提供写保护，防止恶意篡改。</li><li>可以实现内存共享，方便进程通信。</li><li>可以避免内存碎片，虽然物理内存可能不连续，但映射到虚拟内存上可以连续。</li></ol><h2 id="什么是死锁"><a class="markdownIt-Anchor" href="#什么是死锁"></a> 什么是死锁？</h2><p>在两个或者多个并发进程中，每个进程持有某种资源而又等待其它进程释放它们现在保持着的资源，在未改变这种状态之前都不能向前推进，称这一组进程产生了死锁(deadlock)。</p><h2 id="死锁产生的必要条件"><a class="markdownIt-Anchor" href="#死锁产生的必要条件"></a> 死锁产生的必要条件？</h2><ul><li><strong>互斥</strong>：一个资源一次只能被一个进程使用；</li><li><strong>占有并等待</strong>：一个进程至少占有一个资源，并在等待另一个被其它进程占用的资源；</li><li><strong>非抢占</strong>：已经分配给一个进程的资源不能被强制性抢占，只能由进程完成任务之后自愿释放；</li><li><strong>循环等待</strong>：若干进程之间形成一种头尾相接的环形等待资源关系，该环路中的每个进程都在等待下一个进程所占有的资源。</li></ul><h2 id="有哪些页面置换算法"><a class="markdownIt-Anchor" href="#有哪些页面置换算法"></a> 有哪些页面置换算法？</h2><p>在程序运行过程中，如果要访问的页面不在内存中，就发生缺页中断从而将该页调入内存中。此时如果内存已无空闲空间，系统必须从内存中调出一个页面到磁盘中来腾出空间。页面置换算法的主要目标是使页面置换频率最低（也可以说缺页率最低）。</p><ul><li><strong>最佳页面置换算法</strong>OPT（Optimal replacement algorithm）：置换以后不需要或者最远的将来才需要的页面，是一种理论上的算法，是最优策略；</li><li><strong>先进先出</strong>FIFO：置换在内存中驻留时间最长的页面。缺点：有可能将那些经常被访问的页面也被换出，从而使缺页率升高；</li><li><strong>第二次机会算法</strong>SCR：按FIFO选择某一页面，若其访问位为1，给第二次机会，并将访问位置0；</li><li><strong>时钟算法</strong> Clock：SCR中需要将页面在链表中移动（第二次机会的时候要将这个页面从链表头移到链表尾），时钟算法使用环形链表，再使用一个指针指向最老的页面，避免了移动页面的开销；</li><li><strong>最近未使用算法</strong>NRU（Not Recently Used）：检查访问位R、修改位M，优先置换R=M=0，其次是（R=0, M=1）；</li><li><strong>最近最少使用算法</strong>LRU（Least Recently Used）：置换出未使用时间最长的一页；实现方式：维护时间戳，或者维护一个所有页面的链表。当一个页面被访问时，将这个页面移到链表表头。这样就能保证链表表尾的页面是最近最久未访问的。</li><li><strong>最不经常使用算法</strong>LFU（Least Frequently Used）：置换出访问次数最少的页面</li></ul><h1 id="计算机网络"><a class="markdownIt-Anchor" href="#计算机网络"></a> 计算机网络</h1><h2 id="什么是三次握手-three-way-handshake"><a class="markdownIt-Anchor" href="#什么是三次握手-three-way-handshake"></a> 什么是三次握手 (three-way handshake)？</h2><ul><li>第一次握手：Client将SYN置1，随机产生一个初始序列号seq发送给Server，进入SYN_SENT状态；</li><li>第二次握手：Server收到Client的SYN=1之后，知道客户端请求建立连接，将自己的SYN置1，ACK置1，产生一个acknowledge number=sequence number+1，并随机产生一个自己的初始序列号，发送给客户端；进入SYN_RCVD状态；</li><li>第三次握手：客户端检查acknowledge number是否为序列号+1，ACK是否为1，检查正确之后将自己的ACK置为1，产生一个acknowledge number=服务器发的序列号+1，发送给服务器；进入ESTABLISHED状态；服务器检查ACK为1和acknowledge number为序列号+1之后，也进入ESTABLISHED状态；完成三次握手，连接建立。</li></ul><p><img src="https://cdn.dianhsu.com/img/2022-08-08-17-14-55.png" alt="TCP三次握手" /></p><h2 id="什么是四次挥手"><a class="markdownIt-Anchor" href="#什么是四次挥手"></a> 什么是四次挥手？</h2><ul><li>第一次挥手：Client将FIN置为1，发送一个序列号seq给Server；进入FIN_WAIT_1状态</li><li>第二次挥手：Server收到FIN之后，发送一个ACK=1，acknowledge number=收到的序列号+1；进入CLOSE_WAIT状态。此时客户端已经没有要发送的数据了，但仍可以接受服务器发来的数据</li><li>第三次挥手：Server将FIN置1，发送一个序列号给Client；进入LAST_ACK状态</li><li>第四次挥手：Client收到服务器的FIN后，进入TIME_WAIT状态；接着将ACK置1，发送一个acknowledge number=序列号+1给服务器；服务器收到后，确认acknowledge number后，变为CLOSED状态，不再向客户端发送数据。客户端等待2*MSL（报文段最长寿命）时间后，也进入CLOSED状态。完成四次挥手</li></ul><p><img src="https://cdn.dianhsu.com/img/2022-08-08-17-15-48.png" alt="TCP四次挥手" /></p><h2 id="tcp与udp"><a class="markdownIt-Anchor" href="#tcp与udp"></a> TCP与UDP</h2><ul><li>TCP是面向连接的，UDP是无连接的</li><li>TCP是可靠的，UDP不可靠</li><li>TCP只支持点对点通信，UDP支持一对一、一对多、多对一、多对多</li><li>TCP是面向字节流的，UDP是面向报文的</li><li>TCP有拥塞控制机制，UDP没有。网络出现的拥塞不会使源主机的发送速率降低，这对某些实时应用是很重要的，比如媒体通信，游戏</li><li>TCP首部开销（20字节）比UDP首部开销（8字节）要大</li><li>UDP的主机不需要维持复杂的连接状态表</li></ul><h2 id="拥塞控制"><a class="markdownIt-Anchor" href="#拥塞控制"></a> 拥塞控制</h2><p>拥塞控制主要由四个算法组成：慢启动（Slow Start）、拥塞避免（Congestion voidance）、快重传 （Fast Retransmit）、快恢复（Fast Recovery）</p><ol><li>慢启动：刚开始发送数据时，先把拥塞窗口（congestion window）设置为一个最大报文段MSS的数值，每收到一个新的确认报文之后，就把拥塞窗口加1个MSS。这样每经过一个传输轮次（或者说是每经过一个往返时间RTT），拥塞窗口的大小就会加倍</li><li>拥塞避免：当拥塞窗口的大小达到慢开始门限(slow start threshold)时，开始执行拥塞避免算法，拥塞窗口大小不再指数增加，而是线性增加，即每经过一个传输轮次只增加1MSS.</li><li>快重传：快重传要求接收方在收到一个失序的报文段后就立即发出重复确认（为的是使发送方及早知道有报文段没有到达对方）而不要等到自己发送数据时捎带确认。快重传算法规定，发送方只要一连收到三个重复确认就应当立即重传对方尚未收到的报文段，而不必继续等待设置的重传计时器时间到期。</li><li>快恢复：当发送方连续收到三个重复确认时，就把慢开始门限减半，然后执行拥塞避免算法。不执行慢开始算法的原因：因为如果网络出现拥塞的话就不会收到好几个重复的确认，所以发送方认为现在网络可能没有出现拥塞。<br />也有的快重传是把开始时的拥塞窗口cwnd值再增大一点，即等于 <code>ssthresh + 3*MSS</code> 。这样做的理由是：既然发送方收到三个重复的确认，就表明有三个分组已经离开了网络。这三个分组不再消耗网络的资源而是停留在接收方的缓存中。可见现在网络中减少了三个分组。因此可以适当把拥塞窗口扩大些。</li></ol><h2 id="tcp如何保证传输的可靠性"><a class="markdownIt-Anchor" href="#tcp如何保证传输的可靠性"></a> TCP如何保证传输的可靠性</h2><ul><li>数据包校验</li><li>对失序数据包重新排序（TCP报文具有序列号）</li><li>丢弃重复数据</li><li>应答机制：接收方收到数据之后，会发送一个确认（通常延迟几分之一秒）；</li><li>超时重发：发送方发出数据之后，启动一个定时器，超时未收到接收方的确认，则重新发送这个数据；</li><li>流量控制：确保接收端能够接收发送方的数据而不会缓冲区溢出</li></ul><h2 id="https-通讯流程sup-idfnref6-classfootnote-refa-hreffn6-relfootnotespan-classhint-top-hint-rounded-aria-labelhttps-详解一附带最精美详尽的-https-原理图httpssegmentfaultcoma11900000214946766spanasup"><a class="markdownIt-Anchor" href="#https-通讯流程sup-idfnref6-classfootnote-refa-hreffn6-relfootnotespan-classhint-top-hint-rounded-aria-labelhttps-详解一附带最精美详尽的-https-原理图httpssegmentfaultcoma11900000214946766spanasup"></a> HTTPS 通讯流程<sup id="fnref:6" class="footnote-ref"><a href="#fn:6" rel="footnote"><span class="hint--top hint--rounded" aria-label="[HTTPS 详解一：附带最精美详尽的 HTTPS 原理图](https://segmentfault.com/a/1190000021494676)">[6]</span></a></sup></h2><p><img src="https://cdn.dianhsu.com/img/2022-09-12-17-54-45.png" alt="HTTPS加密、解密、验证及数据传输过程" /><br />看上去眼花缭乱，不要怕，且听我细细道来。HTTPS的整个通信阶段可以分为两大阶段：证书验证阶段和数据传输阶段，数据传输阶段又可以分为非对称加密阶段和对称加密阶段。具体流程按图中的序号讲解如下：</p><ol><li>客户端请求HTTPS网址，然后连接到Server的443端口（HTTPS默认的端口，类似于HTTP的80端口）。</li><li>采用HTTPS协议的服务器必须要有一套数字CA（Certification Authority）证书，证书是需要申请的，并由专门的数字证书认证机构（CA）通过非常严格的审核之后颁发的电子证书（当然了是要钱的，安全级别越高价格越贵）。颁发证书的同时会产生一个私钥和公钥。私钥由服务端自己保存，不可泄露。公钥则是附带在证书的信息中，可以公开的。证书本身也附带了一个证书电子签名，这个签名用来验证证书的完整性和真实性，可以防止证书被篡改。</li><li>服务器响应客户端请求，将证书传递给客户端，证书中包含公钥和大量其他信息，比如证书颁发机构信息、公司信息和证书有效期等。Chrome浏览器点击地址栏的锁标志再点击证书就可以看到证书的详细信息了。<br /><img src="https://cdn.dianhsu.com/img/2022-09-12-18-04-50.png" alt="B站CA证书" /></li><li>客户端解析证书并对其进行验证。如果证书不是由可信机构颁布，或者证书中的域名与实际域名不一致，或者证书已经过期，就会向访问者显示一个警告，由其选择是否还要继续通信，就像下面这样：<br /><img src="https://cdn.dianhsu.com/img/2022-09-12-18-06-49.png" alt="浏览器安全警告" /><br />如果证书没有问题，客户端就会从服务器证书中取出服务器的公钥A。然后客户端还会生成一个随机码KEY，并使用公钥A将其加密。</li><li>客户端把加密后的随机码KEY发送给服务器，作为后面对称加密的密钥。</li><li>服务器在收到随机KEY之后，会使用私钥B将其解密。经过以上这些步骤，客户端和服务器终于建立了安全连接，完美解决了对称加密的密钥泄露问题，接下来就可以用对称加密愉快地进行通信了。</li><li>服务器使用密钥（随机码KEY）对数据进行对称加密并发送给客户端，客户端使用相同的密钥（随机码KEY）解密数据。</li><li>双方使用对称加密愉快地传输所有数据。</li></ol><h1 id="redis"><a class="markdownIt-Anchor" href="#redis"></a> Redis</h1><h2 id="redis的数据类型"><a class="markdownIt-Anchor" href="#redis的数据类型"></a> Redis的数据类型</h2><ul><li>String：字符串类型，最简单的类型</li><li>Hash：类似于Map的一种结构。</li><li>List：有序列表。</li><li>Set：无序集合。</li><li>ZSet：带权值的无序集合，即每个ZSet元素还另有一个数字代表权值，集合通过权值进行排序。</li></ul><h2 id="redis数据持久化"><a class="markdownIt-Anchor" href="#redis数据持久化"></a> Redis数据持久化</h2><p>为了能够重用Redis数据，或者防止系统故障，我们需要将Redis中的数据写入到磁盘空间中，即持久化。<br />Redis提供了两种不同的持久化方法可以将数据存储在磁盘中，一种叫快照RDB，另一种叫只追加文件AOF。</p><h3 id="rdb"><a class="markdownIt-Anchor" href="#rdb"></a> RDB</h3><p>在指定的时间间隔内将内存中的数据集快照写入磁盘(Snapshot)，它恢复时是将快照文件直接读到内存里。<br />优势：适合大规模的数据恢复；对数据完整性和一致性要求不高<br />劣势：在一定间隔时间做一次备份，所以如果Redis意外down掉的话，就会丢失最后一次快照后的所有修改。</p><h3 id="aof"><a class="markdownIt-Anchor" href="#aof"></a> AOF</h3><p>以日志的形式来记录每个写操作，将Redis执行过的所有写指令记录下来(读操作不记录)，只许追加文件但不可以改写文件，Redis启动之初会读取该文件重新构建数据，换言之，Redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作。<br />AOF采用文件追加方式，文件会越来越大，为避免出现此种情况，新增了重写机制，当AOF文件的大小超过所设定的阈值时， Redis就会启动AOF文件的内容压缩，只保留可以恢复数据的最小指令集.。</p><h4 id="优势"><a class="markdownIt-Anchor" href="#优势"></a> 优势</h4><ul><li>每修改同步：appendfsync always 同步持久化，每次发生数据变更会被立即记录到磁盘，性能较差但数据完整性比较好</li><li>每秒同步：appendfsync everysec 异步操作，每秒记录，如果一秒内宕机，有数据丢失</li><li>不同步：appendfsync no 从不同步</li></ul><h4 id="劣势"><a class="markdownIt-Anchor" href="#劣势"></a> 劣势</h4><p>相同数据集的数据而言AOF文件要远大于RDB文件，恢复速度慢于RDB<br />AOF运行效率要慢于RDB，每秒同步策略效率较好，不同步效率和RDB相同</p><h2 id="简述缓存雪崩"><a class="markdownIt-Anchor" href="#简述缓存雪崩"></a> 简述缓存雪崩</h2><p>缓存雪崩指缓存中一大批数据到过期时间，而从缓存中删除。但该批数据查询数据量巨大，查询全部走数据库，造成数据库压力过大。</p><h1 id="软件设计模式"><a class="markdownIt-Anchor" href="#软件设计模式"></a> 软件设计模式</h1><h2 id="说说什么是单例设计模式如何实现"><a class="markdownIt-Anchor" href="#说说什么是单例设计模式如何实现"></a> 说说什么是单例设计模式，如何实现</h2><h3 id="单例模式定义"><a class="markdownIt-Anchor" href="#单例模式定义"></a> 单例模式定义</h3><p>保证一个类仅有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。<br />那么我们就必须保证：</p><ul><li>该类不能被复制。</li><li>该类不能被公开的创造。<br />那么对于C++来说，它的构造函数，拷贝构造函数和赋值函数都不能被公开调用。</li></ul><h3 id="单例模式实现方式"><a class="markdownIt-Anchor" href="#单例模式实现方式"></a> 单例模式实现方式</h3><p>单例模式通常有两种模式，分别为懒汉式单例和饿汉式单例。两种模式实现方式分别如下：</p><ul><li>懒汉式设计模式实现方式（2种）<ul><li>静态指针 + 用到时初始化</li><li>局部静态变量</li></ul></li><li>饿汉式设计模式（2种）<ul><li>直接定义静态对象</li><li>静态指针 + 类外初始化时new空间实现</li></ul></li></ul><h1 id="编译原理"><a class="markdownIt-Anchor" href="#编译原理"></a> 编译原理</h1><h2 id="cc程序编译从代码到可执行程序"><a class="markdownIt-Anchor" href="#cc程序编译从代码到可执行程序"></a> C/C++程序编译从代码到可执行程序</h2><p>C++和C语言类似，一个C++程序从源码到执行文件，有四个过程，预编译、编译、汇编、链接。</p><ul><li>预编译：这个过程主要的处理操作如下：<ul><li>将所有的#define删除，并且展开所有的宏定义</li><li>处理所有的条件预编译指令，如#if、#ifdef</li><li>处理#include预编译指令，将被包含的文件插入到该预编译指令的位置。</li><li>过滤所有的注释</li><li>添加行号和文件名标识。</li></ul></li><li>编译：这个过程主要的处理操作如下：<ul><li>词法分析：将源代码的字符序列分割成一系列的记号。</li><li>语法分析：对记号进行语法分析，产生语法树。</li><li>语义分析：判断表达式是否有意义。</li><li>代码优化：</li><li>目标代码生成：生成汇编代码。</li><li>目标代码优化：</li></ul></li><li>汇编：这个过程主要是将汇编代码转变成机器可以执行的指令。</li><li>链接：将不同的源文件产生的目标文件进行链接，从而形成一个可以执行的程序。<br />链接分为静态链接和动态链接。<br />静态链接，是在链接的时候就已经把要调用的函数或者过程链接到了生成的可执行文件中，就算你在去把静态库删除也不会影响可执行程序的执行；生成的静态链接库，Windows下以.lib为后缀，Linux下以.a为后缀。<br />而动态链接，是在链接的时候没有把调用的函数代码链接进去，而是在执行的过程中，再去找要链接的函数，生成的可执行文件中没有函数代码，只包含函数的重定位信息，所以当你删除动态库时，可执行程序就不能运行。生成的动态链接库，Windows下以.dll为后缀，Linux下以.so为后缀。</li></ul><h1 id="参考"><a class="markdownIt-Anchor" href="#参考"></a> 参考</h1><section class="footnotes"><div class="footnote-list"><ol><li><span id="fn:1" class="footnote-text"><span><a href="https://www.nowcoder.com/issue/tutorial?tutorialId=10069">C++岗位面试真题宝典</a><a href="#fnref:1" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:2" class="footnote-text"><span><a href="https://segmentfault.com/a/1190000023441427">C++14新特性的所有知识点全在这儿啦！</a><a href="#fnref:2" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:3" class="footnote-text"><span><a href="https://segmentfault.com/a/1190000023456766">C++17新特性</a><a href="#fnref:3" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:4" class="footnote-text"><span><a href="https://www.zhihu.com/question/22958966/answer/23195612">为什么 C++ 中使用虚函数时会影响效率？</a><a href="#fnref:4" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:5" class="footnote-text"><span><a href="https://zhuanlan.zhihu.com/p/114453309">面试必考 | 进程和线程的区别</a><a href="#fnref:5" rev="footnote" class="footnote-backref"> ↩</a></span></span></li><li><span id="fn:6" class="footnote-text"><span><a href="https://segmentfault.com/a/1190000021494676">HTTPS 详解一：附带最精美详尽的 HTTPS 原理图</a><a href="#fnref:6" rev="footnote" class="footnote-backref"> ↩</a></span></span></li></ol></div></section>]]>
      </content:encoded>
    </item>
    <item>
      <title>2022年秋天的面试经历</title>
      <link>https://www.dianhsu.com/2022/07/22/autumn-interviews/</link>
      <description>
        <![CDATA[<p>今年的秋招来的格外的早，7月中旬一些大厂的提前批已经开放了。从实习春招开始，就感觉到了今年的就业形势将会非常严峻。尽管实习春招的时候，拿到了微软的暑假实习offer。但是保险起见，还是需要投一投其他公司。一方面没有成功转正，也不至于毕业即失业；另外一方面也看看有没有更好的机会。</p>]]>
      </description>
      <author>Dian Hsu</author>
      <category domain="https://www.dianhsu.com/categories/%E9%9D%A2%E8%AF%95/">面试</category>
      <category domain="https://www.dianhsu.com/tags/%E5%AD%97%E8%8A%82%E8%B7%B3%E5%8A%A8/">字节跳动</category>
      <category domain="https://www.dianhsu.com/tags/%E6%AF%94%E5%BF%83/">比心</category>
      <category domain="https://www.dianhsu.com/tags/%E4%BD%B3%E6%9C%9F%E6%8A%95%E8%B5%84/">佳期投资</category>
      <category domain="https://www.dianhsu.com/tags/%E8%B6%8B%E5%8A%BF%E7%A7%91%E6%8A%80/">趋势科技</category>
      <pubDate>Fri, 22 Jul 2022 12:23:14 GMT</pubDate>
      <content:encoded>
        <![CDATA[<p>今年的秋招来的格外的早，7月中旬一些大厂的提前批已经开放了。从实习春招开始，就感觉到了今年的就业形势将会非常严峻。尽管实习春招的时候，拿到了微软的暑假实习offer。但是保险起见，还是需要投一投其他公司。一方面没有成功转正，也不至于毕业即失业；另外一方面也看看有没有更好的机会。</p><span id="more"></span><h1 id="20220718-字节跳动后端-技术中台一面"><a class="markdownIt-Anchor" href="#20220718-字节跳动后端-技术中台一面"></a> 2022.07.18 字节跳动（后端-技术中台）一面</h1><blockquote><p>秋天的第一场面试，比往常寄的格外早一些</p></blockquote><p>面试的细节已经忘记了，回忆几个当时没回答出来的问题</p><ul><li>智能指针</li><li>写一个shell脚本，分割IP地址</li><li>Redis</li><li>MySQL</li></ul><h1 id="20220720-比心pc客户端一面"><a class="markdownIt-Anchor" href="#20220720-比心pc客户端一面"></a> 2022.07.20 比心（PC客户端）一面</h1><blockquote><p>最短面试，15分钟</p></blockquote><p>比心的面试过程比较简短，双方都没有开摄像头，就像电话面试一样，一直在聊C++方面的一些东西。比较有印象的几个问题：</p><ul><li>虚函数带来的一些问题</li><li>C++模板定义为什么不能和实现分开放</li></ul><h1 id="20220722-佳期投资后端一面"><a class="markdownIt-Anchor" href="#20220722-佳期投资后端一面"></a> 2022.07.22 佳期投资（后端）一面</h1><blockquote><p>大概面了80分钟的样子</p></blockquote><ul><li><p>首先是自我介绍</p></li><li><p>然后面试官在</p><ul><li>C++<ul><li>C++14/17/20的新特性</li><li>智能指针</li></ul></li><li>操作系统<ul><li>缺页中断</li><li>L1/L2/L3 cache的访问时间和容量</li><li>CPU线程上下文切换</li></ul></li><li>计算机网络<ul><li>TCP和UDP</li><li>拥塞控制</li><li>TCP版本兼容</li></ul></li><li>编译原理<ul><li>程序编译过程</li><li>静态链接库和动态链接库</li></ul></li><li>Redis<ul><li>Redis数据结构</li></ul></li></ul><p>等方面，各问了几个问题。刚开始提的问题比较简单，但是面试官在每个问题之后，几乎都追问了一下。</p></li><li><p>最后，来一道算法题，这道题是Codeforces上面的原题<a href="https://codeforces.com/contest/280/problem/C">Game on Tree</a>，面试官一开始没有说数据范围，我就问了一下，他说：有个小数据<code>n=10</code>，还有个<code>n=1e5</code>的数据，你可以先花10分钟想想<code>n=1e5</code>的数据怎么写，没想出来再写个<code>n=10</code>的。然后我并没有想出这个题的结论，最后写了个<code>n=10</code>的思路。</p></li></ul><p>写完算法题之后，我感觉应该后面没有其他问题了，就问了一下算法题<code>n=1e5</code>数据的解法。</p><h1 id="20220722-小结"><a class="markdownIt-Anchor" href="#20220722-小结"></a> 2022.07.22 小结</h1><p>秋招面试开始一周之后，面了三场，三场全凉。秋招的面试过程中的计算机基础相关的问题问的广度和深度都大幅超过春招。接下来会好好准备八股文：</p><ul><li>Level 1: C++，操作系统，计算机网络</li><li>Level 2: Redis，计算机组成原理，软件设计模式</li><li>Level 3: 数据库原理（不涉及具体数据库，如：MySQL，PostgreSQL），编译原理</li></ul><h1 id="20220725-字节跳动后端-基础架构一面"><a class="markdownIt-Anchor" href="#20220725-字节跳动后端-基础架构一面"></a> 2022.07.25 字节跳动（后端-基础架构）一面</h1><blockquote><p>面试时间大概50分钟，面试了10分钟的时候，面试官才知道面的是秋招而不是实习。。。（也不知道字节内部是怎么沟通的</p></blockquote><ul><li>虚函数用途，实现，缺陷</li><li>程序内存分布空间</li><li>进程、线程和协程</li><li>数据库事物隔离级别（寄</li><li>InnoDB MyISAM区别（寄</li><li>算法题：给你一个字符串，让你插入若干个字符到字符串的左侧，使得字符串变成回文字符串，求插入的字符的最少数目。<ul><li>“aabbcc” 返回 <code>5</code></li><li>“aaaaaa” 返回 <code>0</code></li><li>“aabaaaa” 返回 <code>2</code></li></ul></li></ul><h1 id="20220811-趋势科技-一面"><a class="markdownIt-Anchor" href="#20220811-趋势科技-一面"></a> 2022.08.11 趋势科技 一面</h1><blockquote><p>面试时间大概40分钟</p></blockquote><ul><li>问了下本科和研究生之间的gap</li><li>写了个tail，遗憾的是我对系统API不了解，没有写出来</li><li>漫谈技术</li></ul><h1 id="20220831-欢乐互娱-一面"><a class="markdownIt-Anchor" href="#20220831-欢乐互娱-一面"></a> 2022.08.31 欢乐互娱 一面</h1><blockquote><p>面试时间大概40分钟</p></blockquote><ul><li>自我介绍</li><li>介绍一下项目</li><li>算法题1：寻找树上两个节点的最近公共祖先</li><li>算法题2：一个数组中连续子段和为k的子段数目</li><li>算法题3：求两个链表的相交节点</li><li>算法题4：判断平面上两个平行坐标轴的矩形是否相交</li><li>unodered_map 和 map</li><li>智能指针</li><li>覆盖和重载</li><li>虚函数</li><li>三次握手和四次挥手</li><li>心跳包</li><li>TCP和UDP</li><li>虚拟内存</li><li>指针的空间占用</li><li>long int的长度</li><li>linux</li><li>sort函数的实现</li></ul><h1 id="20220907-安贤量化-一面"><a class="markdownIt-Anchor" href="#20220907-安贤量化-一面"></a> 2022.09.07 安贤量化 一面</h1><blockquote><p>面试时间大概50分钟</p></blockquote><ul><li>自我介绍</li><li>操作系统相关<ul><li>进程、线程和协程</li><li>缺页中断</li><li>页面置换算法</li><li>写一个LRU，可以用任何标准库，参考相关文档</li><li>如何优化磁盘IO</li></ul></li><li>计算机网络相关<ul><li>HTTPS与HTTP的区别</li><li>ssl/tls 握手流程</li><li>如何实现中间人攻击</li></ul></li><li>C++相关<ul><li>智能指针<ul><li><code>unique_ptr</code>的实现</li></ul></li><li>模板元编程</li><li>多态实现</li><li>右值引用</li><li>C++异常处理，基于系统调用的处理方式</li></ul></li><li>数据结构相关<ul><li>跳表，B树和Hash</li><li>B树和红黑树</li></ul></li><li>杂项<ul><li>最近在看什么书</li><li>平时通过什么途径学习新的技术</li><li>有哪些反爬虫策略，如何突破这些反爬虫策略</li></ul></li></ul><h1 id="20220920-安贤量化-二面"><a class="markdownIt-Anchor" href="#20220920-安贤量化-二面"></a> 2022.09.20 安贤量化 二面</h1><blockquote><p>面试时间大概50分钟</p></blockquote><p>面试官刚开始说了一下面试流程，他说：这次面试大概有45分钟，首先我们聊一下项目，然后问一点基础问题，再写一点代码，最后留一点时间，看看你那边有没有什么问题。</p><p>所以第一部分就是我介绍我自己的项目。这次介绍，我把重点放在暑假实习的内容上面，虽然暑假实习的内容工作内容并不是一个单独的项目。但是我在暑假实习的时候，做了一些富有个人特色的内容，于是拿出来讲了大概10分钟的样子。然后面试官在这部分问了几个小问题，一个是问C++和C#我使用的时候的区别，另外一个是问了一下异步相关的内容。</p><p>第二部分主要是两方面。第一方面他问了一下我的研究方向和相关的工作，我主要是讲了一下FPGA加速Transformer的相关的内容。第二方面他问了一下数据结构，主要问了一下堆怎么实现，还有哪些操作。这个也是一个蛮基础的问题。</p><p>第三部分Coding。题目是这样，给定一个数组，数组中有一些浮点数，比如：[2.0, 3.2, 4.0, 3.0, 2.0, 3.5, 5.0, 4.0, 4.0]，然后定义这个数组中一个指标 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>F</mi><mo>=</mo><mo stretchy="false">(</mo><msub><mi>A</mi><mi>l</mi></msub><mo>−</mo><msub><mi>A</mi><mi>r</mi></msub><mo stretchy="false">)</mo><mi mathvariant="normal">/</mi><msub><mi>A</mi><mi>l</mi></msub><mo stretchy="false">(</mo><mi>l</mi><mo>≤</mo><mi>r</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">F=(A_l - A_r) / A_l (l \leq r)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.68333em;vertical-align:0em;"></span><span class="mord mathnormal" style="margin-right:0.13889em;">F</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal">A</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.33610799999999996em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.01968em;">l</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">A</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mclose">)</span><span class="mord">/</span><span class="mord"><span class="mord mathnormal">A</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.33610799999999996em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.01968em;">l</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">≤</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="mclose">)</span></span></span></span>，这个数组中最大的 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>F</mi><mn>1</mn></msub></mrow><annotation encoding="application/x-tex">F_1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.83333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.13889em;">F</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.13889em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 称为最大回撤。然后第二大回撤 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>F</mi><mn>2</mn></msub></mrow><annotation encoding="application/x-tex">F_2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.83333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.13889em;">F</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.13889em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 是和最大回撤不重叠的最大回撤，以此类推。现在要求你写一个函数，输入一个数组，输出这个数组中的第三大回撤。这部分我写了一个还看得过去的解法，在和面试官讲解的时候，我还说了自己做的不足和可以优化的地方。</p><p>第四部分反问环节，这部分我就问了一个问题，就是面试总共有几轮，面试官回答了一下面试的流程，总共三轮技术面，一轮行为面试。</p><h1 id="20220923-深信服-一面"><a class="markdownIt-Anchor" href="#20220923-深信服-一面"></a> 2022.09.23 深信服 一面</h1><blockquote><p>面试时间大概25分钟</p></blockquote><ol><li>自我介绍</li><li>项目介绍</li><li>写个题吧：<a href="https://leetcode.cn/problems/longest-increasing-subsequence/">最长递增子序列</a></li><li>再写个题把：<a href="https://leetcode.cn/problems/diameter-of-binary-tree/">二叉树的直径</a></li><li>问了下实验室里面研究方向，然后发现我的研究方向并不熟悉，于是就没再问了。</li><li>问了下平时刷题的平台和cf的分数</li><li>问个题：在 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mi>a</mi><mo separator="true">,</mo><mi>b</mi><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[a, b]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord mathnormal">a</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal">b</span><span class="mclose">]</span></span></span></span> 区间内，有多少个数与 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>m</mi></mrow><annotation encoding="application/x-tex">m</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">m</span></span></span></span> 互质（<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn><mo>≤</mo><mi>a</mi><mo>≤</mo><mi>b</mi><mo>≤</mo><mn>1</mn><msup><mn>0</mn><mn>9</mn></msup><mo separator="true">,</mo><mn>1</mn><mo>≤</mo><mi>m</mi><mo>≤</mo><mn>1</mn><msup><mn>0</mn><mn>9</mn></msup></mrow><annotation encoding="application/x-tex">1 \leq a \leq b \leq 10^9, 1 \leq m \leq 10^9</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.78041em;vertical-align:-0.13597em;"></span><span class="mord">1</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">≤</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.7719400000000001em;vertical-align:-0.13597em;"></span><span class="mord mathnormal">a</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">≤</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.83041em;vertical-align:-0.13597em;"></span><span class="mord mathnormal">b</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">≤</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1.008548em;vertical-align:-0.19444em;"></span><span class="mord">1</span><span class="mord"><span class="mord">0</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141079999999999em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">9</span></span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">1</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">≤</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.7719400000000001em;vertical-align:-0.13597em;"></span><span class="mord mathnormal">m</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">≤</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.8141079999999999em;vertical-align:0em;"></span><span class="mord">1</span><span class="mord"><span class="mord">0</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141079999999999em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">9</span></span></span></span></span></span></span></span></span></span></span>）。</li><li>介绍下AC自动机吧</li></ol><p><em>To be continued…</em></p>]]>
      </content:encoded>
    </item>
    <item>
      <title>Codeforces Round 797 (Div. 3)</title>
      <link>https://www.dianhsu.com/2022/06/08/cf1690/</link>
      <description>
        <![CDATA[<blockquote>
<p>比赛链接： <a href="https://codeforces.com/contest/1690">https://codeforces.com/contest/1690</a></p>
</blockquote>
<h1]]>
      </description>
      <author>Dian Hsu</author>
      <category domain="https://www.dianhsu.com/categories/Codeforces/">Codeforces</category>
      <category domain="https://www.dianhsu.com/tags/%E7%AE%97%E6%B3%95/">算法</category>
      <category domain="https://www.dianhsu.com/tags/Codeforces/">Codeforces</category>
      <category domain="https://www.dianhsu.com/tags/%E8%B4%AA%E5%BF%83/">贪心</category>
      <category domain="https://www.dianhsu.com/tags/%E7%8F%82%E6%9C%B5%E8%8E%89%E6%A0%91/">珂朵莉树</category>
      <category domain="https://www.dianhsu.com/tags/%E7%BD%AE%E6%8D%A2%E7%8E%AF/">置换环</category>
      <category domain="https://www.dianhsu.com/tags/%E5%89%8D%E7%BC%80%E5%92%8C/">前缀和</category>
      <pubDate>Wed, 08 Jun 2022 01:04:16 GMT</pubDate>
      <content:encoded>
        <![CDATA[<blockquote><p>比赛链接： <a href="https://codeforces.com/contest/1690">https://codeforces.com/contest/1690</a></p></blockquote><h1 id="a-print-a-pedestal-codeforces-logo"><a class="markdownIt-Anchor" href="#a-print-a-pedestal-codeforces-logo"></a> <a href="https://codeforces.com/contest/1690/problem/A">A. Print a Pedestal (Codeforces logo?)</a></h1><h2 id="题目解析"><a class="markdownIt-Anchor" href="#题目解析"></a> 题目解析</h2><p>如果 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">n</span></span></span></span> 能够被 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>3</mn></mrow><annotation encoding="application/x-tex">3</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">3</span></span></span></span> 整除，我们就可以构造一个高度为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mi>h</mi><mo>−</mo><mn>1</mn><mo separator="true">,</mo><mi>h</mi><mo separator="true">,</mo><mi>h</mi><mo>−</mo><mn>2</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(h - 1, h, h - 2)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord mathnormal">h</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal">h</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal">h</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">2</span><span class="mclose">)</span></span></span></span> 的领奖台。且 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>3</mn><mi>h</mi><mo>−</mo><mn>3</mn><mo>=</mo><mi>n</mi></mrow><annotation encoding="application/x-tex">3h - 3 = n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.77777em;vertical-align:-0.08333em;"></span><span class="mord">3</span><span class="mord mathnormal">h</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">3</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">n</span></span></span></span> 。</p><p>如果 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">n</span></span></span></span> 除以 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>3</mn></mrow><annotation encoding="application/x-tex">3</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">3</span></span></span></span> 的余数不为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0</mn></mrow><annotation encoding="application/x-tex">0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span> ，那么我们就从高到低把领奖台高度 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo>+</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">+1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.72777em;vertical-align:-0.08333em;"></span><span class="mord">+</span><span class="mord">1</span></span></span></span>，这样就仍然保持了领奖台单调性。</p><h2 id="参考代码"><a class="markdownIt-Anchor" href="#参考代码"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;  int t;  cin &gt;&gt; t;  while(t--)&#123;    int n;    cin &gt;&gt; n;    int avg &#x3D; (n - 6) &#x2F; 3;    int x1 &#x3D; 3, x2 &#x3D; 2, x3 &#x3D; 1;    int delta &#x3D; n - 6 - avg * 3;    if(delta &#x3D;&#x3D; 2) x1++, x2++;    else if(delta &#x3D;&#x3D; 1) x1++;    x1+&#x3D; avg, x2 +&#x3D; avg, x3 +&#x3D; avg;    cout &lt;&lt; x2 &lt;&lt; &quot; &quot; &lt;&lt; x1 &lt;&lt; &quot; &quot; &lt;&lt; x3 &lt;&lt; endl;  &#125;  return 0;&#125;</code></pre></div></figure><h1 id="b-array-decrements"><a class="markdownIt-Anchor" href="#b-array-decrements"></a> <a href="https://codeforces.com/contest/1690/problem/B">B. Array Decrements</a></h1><h2 id="题目解析-2"><a class="markdownIt-Anchor" href="#题目解析-2"></a> 题目解析</h2><p>要求 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>a</mi></mrow><annotation encoding="application/x-tex">a</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">a</span></span></span></span> 数组转化到 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>b</mi></mrow><annotation encoding="application/x-tex">b</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal">b</span></span></span></span> 数组。<br />首先确保对于所有的 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.65952em;vertical-align:0em;"></span><span class="mord mathnormal">i</span></span></span></span> ，均满足 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>a</mi><mi>i</mi></msub><mo>≥</mo><msub><mi>b</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">a_i \geq b_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7859700000000001em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">≥</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>。</p><p>设定需要执行的操作次数是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>d</mi><mi>e</mi><mi>l</mi><mi>t</mi><mi>a</mi></mrow><annotation encoding="application/x-tex">delta</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal">d</span><span class="mord mathnormal">e</span><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="mord mathnormal">t</span><span class="mord mathnormal">a</span></span></span></span>，那么 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>d</mi><mi>e</mi><mi>l</mi><mi>t</mi><mi>a</mi></mrow><annotation encoding="application/x-tex">delta</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal">d</span><span class="mord mathnormal">e</span><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="mord mathnormal">t</span><span class="mord mathnormal">a</span></span></span></span> 需要满足以下两个条件：</p><ul><li>如果 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>b</mi><mi>i</mi></msub><mo mathvariant="normal">≠</mo><mn>0</mn></mrow><annotation encoding="application/x-tex">b_i \neq 0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel"><span class="mrel"><span class="mord vbox"><span class="thinbox"><span class="rlap"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="inner"><span class="mrel"></span></span><span class="fix"></span></span></span></span></span><span class="mrel">=</span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span> ，那么 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>d</mi><mi>e</mi><mi>l</mi><mi>t</mi><mi>a</mi><mo>=</mo><msub><mi>a</mi><mi>i</mi></msub><mo>−</mo><msub><mi>b</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">delta = a_i - b_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal">d</span><span class="mord mathnormal">e</span><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="mord mathnormal">t</span><span class="mord mathnormal">a</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.73333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 。</li><li>如果 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>b</mi><mi>i</mi></msub><mo>=</mo><mn>0</mn></mrow><annotation encoding="application/x-tex">b_i = 0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span> ，那么 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>d</mi><mi>e</mi><mi>l</mi><mi>t</mi><mi>a</mi><mo>≥</mo><msub><mi>a</mi><mi>i</mi></msub><mo>−</mo><msub><mi>b</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">delta \geq a_i - b_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.83041em;vertical-align:-0.13597em;"></span><span class="mord mathnormal">d</span><span class="mord mathnormal">e</span><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="mord mathnormal">t</span><span class="mord mathnormal">a</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">≥</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.73333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 。</li></ul><h2 id="参考代码-2"><a class="markdownIt-Anchor" href="#参考代码-2"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;  fastIO();  int t;  cin &gt;&gt; t;  while(t--)&#123;    int n;    cin &gt;&gt; n;    vector&lt;int&gt; arr(n), brr(n);    for(auto&amp; it: arr) cin &gt;&gt; it;    for(auto&amp; it: brr) cin &gt;&gt; it;    int delta &#x3D; inf;    bool ok &#x3D; true;    int mx &#x3D; 0;    for(int i &#x3D; 0; i &lt; n; ++i)&#123;      if(brr[i] &#x3D;&#x3D; 0)&#123;        mx &#x3D; max(mx, arr[i]);      &#125;else&#123;        int d &#x3D; arr[i] - brr[i];        if(d &gt;&#x3D; 0)&#123;          if(delta &#x3D;&#x3D; inf)&#123;            delta &#x3D; d;          &#125;else if(delta !&#x3D; d)&#123;            ok &#x3D; false;            break;          &#125;        &#125;else&#123;          ok &#x3D; false;          break;        &#125;      &#125;    &#125;    if(delta &lt; mx) ok &#x3D; false;    cout &lt;&lt; (ok ? &quot;YES&quot;: &quot;NO&quot;) &lt;&lt; endl;  &#125;  return 0;&#125;</code></pre></div></figure><h1 id="c-restoring-the-duration-of-tasks"><a class="markdownIt-Anchor" href="#c-restoring-the-duration-of-tasks"></a> <a href="https://codeforces.com/contest/1690/problem/C">C. Restoring the Duration of Tasks</a></h1><h2 id="题目解析-3"><a class="markdownIt-Anchor" href="#题目解析-3"></a> 题目解析</h2><ul><li>如果 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi><mo>=</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">i = 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.65952em;vertical-align:0em;"></span><span class="mord mathnormal">i</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span>，那么 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>t</mi><mi>a</mi><mi>s</mi><msub><mi>k</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">task_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord mathnormal">t</span><span class="mord mathnormal">a</span><span class="mord mathnormal">s</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 的实际开始时间是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>t</mi><mi>a</mi><mi>s</mi><msub><mi>k</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">task_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord mathnormal">t</span><span class="mord mathnormal">a</span><span class="mord mathnormal">s</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 的到达时间，即 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>s</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">s_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 。</li><li>如果 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi><mo mathvariant="normal">≠</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">i \neq 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">i</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel"><span class="mrel"><span class="mord vbox"><span class="thinbox"><span class="rlap"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="inner"><span class="mrel"></span></span><span class="fix"></span></span></span></span></span><span class="mrel">=</span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> ，那么 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>t</mi><mi>a</mi><mi>s</mi><msub><mi>k</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">task_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord mathnormal">t</span><span class="mord mathnormal">a</span><span class="mord mathnormal">s</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 的实际开始时间是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>t</mi><mi>a</mi><mi>s</mi><msub><mi>k</mi><mrow><mi>i</mi><mo>−</mo><mn>1</mn></mrow></msub></mrow><annotation encoding="application/x-tex">task_{i - 1}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.902771em;vertical-align:-0.208331em;"></span><span class="mord mathnormal">t</span><span class="mord mathnormal">a</span><span class="mord mathnormal">s</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.311664em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">i</span><span class="mbin mtight">−</span><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.208331em;"><span></span></span></span></span></span></span></span></span></span> 的结束时间和 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>t</mi><mi>a</mi><mi>s</mi><msub><mi>k</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">task_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord mathnormal">t</span><span class="mord mathnormal">a</span><span class="mord mathnormal">s</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 的开始时间的最大值，即 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>max</mi><mo>⁡</mo><mo stretchy="false">(</mo><msub><mi>s</mi><mi>i</mi></msub><mo separator="true">,</mo><msub><mi>f</mi><mrow><mi>i</mi><mo>−</mo><mn>1</mn></mrow></msub><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">\max(s_i, f_{i - 1})</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mop">max</span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.10764em;">f</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.311664em;"><span style="top:-2.5500000000000003em;margin-left:-0.10764em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">i</span><span class="mbin mtight">−</span><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.208331em;"><span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span> 。</li></ul><h2 id="参考代码-3"><a class="markdownIt-Anchor" href="#参考代码-3"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;  fastIO();  int t;  cin &gt;&gt; t;  while(t--)&#123;    int n;    cin &gt;&gt; n;    vector&lt;int&gt; srr(n), frr(n);    for(auto&amp; it: srr) cin &gt;&gt; it;    for(auto&amp; it: frr) cin &gt;&gt; it;    vector&lt;int&gt; ans(n);    for(int i &#x3D; 0; i &lt; n; ++i)&#123;      if(i)&#123;        ans[i] &#x3D; frr[i] - max(srr[i], frr[i - 1]);      &#125;else&#123;        ans[i] &#x3D; frr[i] - srr[i];      &#125;    &#125;    for(auto&amp; it: ans) cout &lt;&lt; it &lt;&lt; &quot; &quot;;    cout &lt;&lt; endl;  &#125;  return 0;&#125;</code></pre></div></figure><h1 id="d-black-and-white-stripe"><a class="markdownIt-Anchor" href="#d-black-and-white-stripe"></a> <a href="https://codeforces.com/contest/1690/problem/D">D. Black and White Stripe</a></h1><h2 id="题目解析-4"><a class="markdownIt-Anchor" href="#题目解析-4"></a> 题目解析</h2><p>统计前缀内 <code>B</code> 字符的数目，然后找到一个长度为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi></mrow><annotation encoding="application/x-tex">k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span></span></span></span> 的区间，区间内 <code>B</code> 字符的数目最多。</p><h2 id="参考代码-4"><a class="markdownIt-Anchor" href="#参考代码-4"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;  fastIO();  int t;  cin &gt;&gt; t;  while(t--)&#123;    int n, k;    cin &gt;&gt; n &gt;&gt; k;    string s;    cin &gt;&gt; s;    vector&lt;int&gt; ans(n + 1, 0);  &#x2F;&#x2F; B 字符的前缀数目    for(int i &#x3D; 0; i &lt; n; ++i)&#123;      if(s[i] &#x3D;&#x3D; &#39;B&#39;)&#123;        ans[i + 1] &#x3D; ans[i] + 1;      &#125;else&#123;        ans[i + 1] &#x3D; ans[i];      &#125;    &#125;    int res &#x3D; inf;    for(int i &#x3D; k; i &lt;&#x3D; n; ++i)&#123;      int cnt &#x3D; ans[i] - ans[i - k];  &#x2F;&#x2F; 区间内 B 字符的数目      res &#x3D; min(res, k - cnt);    &#125;    cout &lt;&lt; res &lt;&lt; endl;  &#125;  return 0;&#125;</code></pre></div></figure><h1 id="e-price-maximization"><a class="markdownIt-Anchor" href="#e-price-maximization"></a> <a href="https://codeforces.com/contest/1690/problem/E">E. Price Maximization</a></h1><h2 id="题目解析-5"><a class="markdownIt-Anchor" href="#题目解析-5"></a> 题目解析</h2><p>两个物品（ <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>a</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">a_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> , <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>a</mi><mi>j</mi></msub></mrow><annotation encoding="application/x-tex">a_j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.716668em;vertical-align:-0.286108em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.311664em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.05724em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></span></span></span></span> ）一起打包的cost是</p><p class='katex-block'><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mo stretchy="false">⌊</mo><mfrac><mrow><msub><mi>a</mi><mi>i</mi></msub><mo>+</mo><msub><mi>a</mi><mi>j</mi></msub></mrow><mi>k</mi></mfrac><mo stretchy="false">⌋</mo><mo>=</mo><mo stretchy="false">⌊</mo><mfrac><msub><mi>a</mi><mi>i</mi></msub><mi>k</mi></mfrac><mo stretchy="false">⌋</mo><mo>+</mo><mo stretchy="false">⌊</mo><mfrac><msub><mi>a</mi><mi>j</mi></msub><mi>k</mi></mfrac><mo stretchy="false">⌋</mo><mo>+</mo><mo stretchy="false">⌊</mo><mfrac><mrow><msub><mi>a</mi><mi>i</mi></msub><mtext> </mtext><mo lspace="0.22em" rspace="0.22em"><mrow><mi mathvariant="normal">m</mi><mi mathvariant="normal">o</mi><mi mathvariant="normal">d</mi></mrow></mo><mtext> </mtext><mi>k</mi><mo>+</mo><msub><mi>a</mi><mi>j</mi></msub><mtext> </mtext><mo lspace="0.22em" rspace="0.22em"><mrow><mi mathvariant="normal">m</mi><mi mathvariant="normal">o</mi><mi mathvariant="normal">d</mi></mrow></mo><mtext> </mtext><mi>k</mi></mrow><mi>k</mi></mfrac><mo stretchy="false">⌋</mo></mrow><annotation encoding="application/x-tex">\lfloor\frac{a_i + a_j}{k}\rfloor = \lfloor\frac{a_i}{k}\rfloor + \lfloor\frac{a_j}{k}\rfloor + \lfloor\frac{a_i \bmod k + a_j \bmod k}{k}\rfloor</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.9463300000000001em;vertical-align:-0.686em;"></span><span class="mopen">⌊</span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.26033em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.311664em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.05724em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mclose">⌋</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1.7935599999999998em;vertical-align:-0.686em;"></span><span class="mopen">⌊</span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.1075599999999999em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mclose">⌋</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:1.7935599999999998em;vertical-align:-0.686em;"></span><span class="mopen">⌊</span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.1075599999999999em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.311664em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.05724em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mclose">⌋</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:2.05744em;vertical-align:-0.686em;"></span><span class="mopen">⌊</span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.37144em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin"><span class="mord"><span class="mord mathrm">m</span><span class="mord mathrm">o</span><span class="mord mathrm">d</span></span></span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.311664em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.05724em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin"><span class="mord"><span class="mord mathrm">m</span><span class="mord mathrm">o</span><span class="mord mathrm">d</span></span></span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mclose">⌋</span></span></span></span></span></p><p>首先计算所有的 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">⌊</mo><mfrac><msub><mi>a</mi><mi>i</mi></msub><mi>k</mi></mfrac><mo stretchy="false">⌋</mo></mrow><annotation encoding="application/x-tex">\lfloor\frac{a_i}{k}\rfloor</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.095em;vertical-align:-0.345em;"></span><span class="mopen">⌊</span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.7114919999999999em;"><span style="top:-2.6550000000000002em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.03148em;">k</span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.4101em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathnormal mtight">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3280857142857143em;"><span style="top:-2.357em;margin-left:0em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.143em;"><span></span></span></span></span></span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mclose">⌋</span></span></span></span> 。<br />剩余的 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">⌊</mo><mfrac><mrow><msub><mi>a</mi><mi>i</mi></msub><mtext> </mtext><mo lspace="0.22em" rspace="0.22em"><mrow><mi mathvariant="normal">m</mi><mi mathvariant="normal">o</mi><mi mathvariant="normal">d</mi></mrow></mo><mtext> </mtext><mi>k</mi><mo>+</mo><msub><mi>a</mi><mi>j</mi></msub><mtext> </mtext><mo lspace="0.22em" rspace="0.22em"><mrow><mi mathvariant="normal">m</mi><mi mathvariant="normal">o</mi><mi mathvariant="normal">d</mi></mrow></mo><mtext> </mtext><mi>k</mi></mrow><mi>k</mi></mfrac><mo stretchy="false">⌋</mo></mrow><annotation encoding="application/x-tex">\lfloor\frac{a_i \bmod k + a_j \bmod k}{k}\rfloor</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.338428em;vertical-align:-0.345em;"></span><span class="mopen">⌊</span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.993428em;"><span style="top:-2.6550000000000002em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.03148em;">k</span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.50732em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathnormal mtight">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3280857142857143em;"><span style="top:-2.357em;margin-left:0em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.143em;"><span></span></span></span></span></span></span><span class="mspace mtight" style="margin-right:0.3252777777777778em;"></span><span class="mbin mtight"><span class="mord mtight"><span class="mord mathrm mtight">m</span><span class="mord mathrm mtight">o</span><span class="mord mathrm mtight">d</span></span></span><span class="mspace mtight" style="margin-right:0.3252777777777778em;"></span><span class="mord mathnormal mtight" style="margin-right:0.03148em;">k</span><span class="mbin mtight">+</span><span class="mord mtight"><span class="mord mathnormal mtight">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3280857142857143em;"><span style="top:-2.357em;margin-left:0em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight" style="margin-right:0.05724em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2818857142857143em;"><span></span></span></span></span></span></span><span class="mspace mtight" style="margin-right:0.3252777777777778em;"></span><span class="mbin mtight"><span class="mord mtight"><span class="mord mathrm mtight">m</span><span class="mord mathrm mtight">o</span><span class="mord mathrm mtight">d</span></span></span><span class="mspace mtight" style="margin-right:0.3252777777777778em;"></span><span class="mord mathnormal mtight" style="margin-right:0.03148em;">k</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mclose">⌋</span></span></span></span> 先处理 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>a</mi><mi>i</mi></msub><mtext> </mtext><mo lspace="0.22em" rspace="0.22em"><mrow><mi mathvariant="normal">m</mi><mi mathvariant="normal">o</mi><mi mathvariant="normal">d</mi></mrow></mo><mtext> </mtext><mi>k</mi><mo>=</mo><msub><mi>b</mi><mi>i</mi></msub><mo stretchy="false">(</mo><mn>0</mn><mo>≤</mo><msub><mi>b</mi><mi>i</mi></msub><mo>&lt;</mo><mi>k</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">a_i \bmod k = b_i (0 \leq b_i &lt; k)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin"><span class="mord"><span class="mord mathrm">m</span><span class="mord mathrm">o</span><span class="mord mathrm">d</span></span></span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord">0</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">≤</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">&lt;</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="mclose">)</span></span></span></span> 之后，需要解决的问题就变成了下面这个：</p><p>对于 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>b</mi></mrow><annotation encoding="application/x-tex">b</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal">b</span></span></span></span> 的任意一个排列, 求 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msubsup><mo>∑</mo><mrow><mi>i</mi><mo>=</mo><mn>1</mn></mrow><mfrac><mi>n</mi><mn>2</mn></mfrac></msubsup><mo stretchy="false">⌊</mo><mfrac><mrow><msub><mi>b</mi><mrow><mn>2</mn><mi>i</mi><mo>−</mo><mn>1</mn></mrow></msub><mo>+</mo><msub><mi>b</mi><mrow><mn>2</mn><mi>i</mi></mrow></msub></mrow><mi>k</mi></mfrac><mo stretchy="false">⌋</mo></mrow><annotation encoding="application/x-tex">\sum_{i = 1}^{\frac{n}{2}} \lfloor \frac{b_{2i-1} + b_{2i}}{k} \rfloor</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.41468em;vertical-align:-0.345em;"></span><span class="mop"><span class="mop op-symbol small-op" style="position:relative;top:-0.0000050000000000050004em;">∑</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.06968em;"><span style="top:-2.7231360000000002em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">i</span><span class="mrel mtight">=</span><span class="mord mtight">1</span></span></span></span><span style="top:-3.5856000000000003em;margin-right:0.05em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mopen nulldelimiter sizing reset-size3 size6"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.6915428571428572em;"><span style="top:-2.656em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mtight"><span class="mord mtight">2</span></span></span></span><span style="top:-3.2255000000000003em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line mtight" style="border-bottom-width:0.049em;"></span></span><span style="top:-3.384em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.344em;"><span></span></span></span></span></span><span class="mclose nulldelimiter sizing reset-size3 size6"></span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.27686399999999994em;"><span></span></span></span></span></span></span><span class="mopen">⌊</span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.937873em;"><span style="top:-2.6550000000000002em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.03148em;">k</span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.451765em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathnormal mtight">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.32808571428571426em;"><span style="top:-2.357em;margin-left:0em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mtight"><span class="mord mtight">2</span><span class="mord mathnormal mtight">i</span><span class="mbin mtight">−</span><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.20252142857142857em;"><span></span></span></span></span></span></span><span class="mbin mtight">+</span><span class="mord mtight"><span class="mord mathnormal mtight">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3280857142857143em;"><span style="top:-2.357em;margin-left:0em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mtight"><span class="mord mtight">2</span><span class="mord mathnormal mtight">i</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.143em;"><span></span></span></span></span></span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mclose">⌋</span></span></span></span> 的最大值。显然 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">⌊</mo><mfrac><mrow><msub><mi>b</mi><mrow><mn>2</mn><mi>i</mi><mo>−</mo><mn>1</mn></mrow></msub><mo>+</mo><msub><mi>b</mi><mrow><mn>2</mn><mi>i</mi></mrow></msub></mrow><mi>k</mi></mfrac><mo stretchy="false">⌋</mo><mo stretchy="false">(</mo><mn>0</mn><mo>≤</mo><msub><mi>b</mi><mrow><mn>2</mn><mi>i</mi><mo>−</mo><mn>1</mn></mrow></msub><mo separator="true">,</mo><msub><mi>b</mi><mrow><mn>2</mn><mi>i</mi></mrow></msub><mo>&lt;</mo><mi>k</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">\lfloor \frac{b_{2i - 1} + b_{2i}}{k} \rfloor (0 \leq b_{2i-1}, b_{2i} &lt; k)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.282873em;vertical-align:-0.345em;"></span><span class="mopen">⌊</span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.937873em;"><span style="top:-2.6550000000000002em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.03148em;">k</span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.451765em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathnormal mtight">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.32808571428571426em;"><span style="top:-2.357em;margin-left:0em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mtight"><span class="mord mtight">2</span><span class="mord mathnormal mtight">i</span><span class="mbin mtight">−</span><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.20252142857142857em;"><span></span></span></span></span></span></span><span class="mbin mtight">+</span><span class="mord mtight"><span class="mord mathnormal mtight">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3280857142857143em;"><span style="top:-2.357em;margin-left:0em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mtight"><span class="mord mtight">2</span><span class="mord mathnormal mtight">i</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.143em;"><span></span></span></span></span></span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mclose">⌋</span><span class="mopen">(</span><span class="mord">0</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">≤</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.902771em;vertical-align:-0.208331em;"></span><span class="mord"><span class="mord mathnormal">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.311664em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">2</span><span class="mord mathnormal mtight">i</span><span class="mbin mtight">−</span><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.208331em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">2</span><span class="mord mathnormal mtight">i</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">&lt;</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="mclose">)</span></span></span></span> 的值只能为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0</mn></mrow><annotation encoding="application/x-tex">0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span> 或者 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span>。</p><p>可以通过贪心来使得 满足 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>b</mi><mi>i</mi></msub><mo>+</mo><msub><mi>b</mi><mrow><mi>i</mi><mo>+</mo><mn>1</mn></mrow></msub><mo>≥</mo><mi>k</mi></mrow><annotation encoding="application/x-tex">b_{i} + b_{i+1} \geq k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">i</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.902771em;vertical-align:-0.208331em;"></span><span class="mord"><span class="mord mathnormal">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.311664em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">i</span><span class="mbin mtight">+</span><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.208331em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">≥</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span></span></span></span> 的组数越多越好。</p><h2 id="参考代码-5"><a class="markdownIt-Anchor" href="#参考代码-5"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;  fastIO();  int t;  cin &gt;&gt; t;  while(t--)&#123;    int n, k;    cin &gt;&gt; n &gt;&gt; k;    multiset&lt;int&gt; ms;    ll ans &#x3D; 0;    vector&lt;int&gt; arr(n);    for(int i &#x3D; 0; i &lt; n; ++i)&#123;      int tv;      cin &gt;&gt; tv;      ans +&#x3D; tv &#x2F; k;      ms.insert(tv % k);      arr[i] &#x3D; tv % k;    &#125;    sort(itr(arr));    for(int i &#x3D; 0; i &lt; n; ++i)&#123;      if(ms.count(arr[i]))&#123;        ms.extract(arr[i]);        auto pos &#x3D; ms.lower_bound(k - arr[i]);        if(pos !&#x3D; ms.end())&#123;          ++ans;          ms.erase(pos);        &#125;      &#125;    &#125;    cout &lt;&lt; ans &lt;&lt; endl;  &#125;  return 0;&#125;</code></pre></div></figure><h1 id="f-shifting-string"><a class="markdownIt-Anchor" href="#f-shifting-string"></a> <a href="https://codeforces.com/contest/1690/problem/F">F. Shifting String</a></h1><h2 id="题目解析-6"><a class="markdownIt-Anchor" href="#题目解析-6"></a> 题目解析</h2><p>首先计算每个置换环所包含的位置和顺序。<br />然后暴力处理每个置换环，找到操作之后若干次之后满足当前置换环的状态和初始状态相同的最小的操作次数 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>o</mi><msub><mi>p</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">op_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">o</span><span class="mord"><span class="mord mathnormal">p</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>。<br />最后求所有 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>o</mi><msub><mi>p</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">op_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">o</span><span class="mord"><span class="mord mathnormal">p</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 的最小公倍数。</p><h2 id="参考代码-6"><a class="markdownIt-Anchor" href="#参考代码-6"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;  fastIO();  int t;  cin &gt;&gt; t;  while(t--)&#123;    int n;    cin &gt;&gt; n;    string s;    cin &gt;&gt; s;    vector&lt;int&gt; arr(n);    for(auto&amp; it: arr)&#123;      cin &gt;&gt; it;      --it;    &#125;    map&lt;int, vector&lt;int&gt;&gt; mp; &#x2F;&#x2F;置换环的首位和位置数组    vector&lt;int&gt; vis(n, 0);    for(int i &#x3D; 0; i &lt; n; ++i)&#123;      if(vis[i] &#x3D;&#x3D; 0)&#123;        mp[i] &#x3D; &#123;i&#125;;        vis[i] &#x3D; 1;        int cur &#x3D; arr[i];        while(cur !&#x3D; i)&#123;          mp[i].push_back(cur);          vis[cur] &#x3D; 1;          cur &#x3D; arr[cur];        &#125;      &#125;    &#125;    vector&lt;ll&gt; nex; &#x2F;&#x2F; 置换环的操作次数    for(auto&amp; [k, vec]: mp)&#123;      string tmp;      for(auto&amp; pos: vec)&#123;        tmp +&#x3D; s[pos];      &#125;      tmp &#x3D; tmp + tmp;      int len &#x3D; vec.size();      for(int i &#x3D; 1; i &lt; vec.size(); ++i)&#123;        if(tmp.substr(i, len) &#x3D;&#x3D; tmp.substr(0, len))&#123;          len &#x3D; i;          break;        &#125;      &#125;      nex.push_back(len);    &#125;    ll res &#x3D; 1;    for(auto&amp; it: nex) res &#x3D; lcm(res, it);    cout &lt;&lt; res &lt;&lt; endl;  &#125;  return 0;&#125;</code></pre></div></figure><h1 id="g-count-the-trains"><a class="markdownIt-Anchor" href="#g-count-the-trains"></a> <a href="https://codeforces.com/contest/1690/problem/G">G. Count the Trains</a></h1><h2 id="题目解析-7"><a class="markdownIt-Anchor" href="#题目解析-7"></a> 题目解析</h2><p>一个区间合并和拆分问题。</p><p>首先想到了用<a href="http://oi-wiki.com/ds/odt/">珂学</a>来解决这道问题。</p><p>假设有一组数据 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>10</mn><mo separator="true">,</mo><mn>12</mn><mo separator="true">,</mo><mn>11</mn><mo separator="true">,</mo><mn>9</mn><mo separator="true">,</mo><mn>12</mn><mo separator="true">,</mo><mn>6</mn><mo separator="true">,</mo><mn>9</mn></mrow><annotation encoding="application/x-tex">10, 12, 11, 9, 12, 6, 9</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8388800000000001em;vertical-align:-0.19444em;"></span><span class="mord">1</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">1</span><span class="mord">2</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">1</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">9</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">1</span><span class="mord">2</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">6</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">9</span></span></span></span>，如下图所示。<br />虚线代表实际的速度。<br /><img src="https://cdn.dianhsu.com/img/2022-06-08-10-32-42.png" alt="速度示意图" /></p><p>那么速度区间就总共有三个，分别是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>1</mn><mo separator="true">,</mo><mn>3</mn><mo stretchy="false">)</mo><mo separator="true">,</mo><mo stretchy="false">(</mo><mn>4</mn><mo separator="true">,</mo><mn>5</mn><mo stretchy="false">)</mo><mo separator="true">,</mo><mo stretchy="false">(</mo><mn>6</mn><mo separator="true">,</mo><mn>7</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(1, 3), (4, 5), (6, 7)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">3</span><span class="mclose">)</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mopen">(</span><span class="mord">4</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">5</span><span class="mclose">)</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mopen">(</span><span class="mord">6</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">7</span><span class="mclose">)</span></span></span></span>，每个区间的速度等于区间头部的位置的速度。</p><p>考虑两种情况，分别用两个独立的case来举例。</p><p>一个case是<code>2 1</code>，即将 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>a</mi><mn>2</mn></msub><mo>=</mo><msub><mi>a</mi><mn>2</mn></msub><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">a_2 = a_2 - 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.73333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span>。</p><p><img src="https://cdn.dianhsu.com/img/2022-06-08-10-39-03.png" alt="case 1 操作之后的速度情况" /><br />速度区间仍然还是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>3</mn></mrow><annotation encoding="application/x-tex">3</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">3</span></span></span></span> 个，分别是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>1</mn><mo separator="true">,</mo><mn>3</mn><mo stretchy="false">)</mo><mo separator="true">,</mo><mo stretchy="false">(</mo><mn>4</mn><mo separator="true">,</mo><mn>5</mn><mo stretchy="false">)</mo><mo separator="true">,</mo><mo stretchy="false">(</mo><mn>6</mn><mo separator="true">,</mo><mn>7</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(1, 3), (4, 5), (6, 7)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">3</span><span class="mclose">)</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mopen">(</span><span class="mord">4</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">5</span><span class="mclose">)</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mopen">(</span><span class="mord">6</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">7</span><span class="mclose">)</span></span></span></span> 。<br />这个case意味着：<strong>如果将某个位置速度减小之后，此位置速度仍然不小于它所处的区间的速度的值，那么速度区间不会发生合并和拆分。</strong></p><p>另外一个case是 <code>3 3</code>，即 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>a</mi><mn>3</mn></msub><mo>=</mo><msub><mi>a</mi><mn>3</mn></msub><mo>−</mo><mn>3</mn></mrow><annotation encoding="application/x-tex">a_3 = a_3 - 3</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">3</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.73333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">3</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">3</span></span></span></span>。<br /><img src="https://cdn.dianhsu.com/img/2022-06-08-10-44-46.png" alt="case 2 操作之后的速度情况" /><br />速度区间变成了 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>3</mn></mrow><annotation encoding="application/x-tex">3</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">3</span></span></span></span> 个，分别是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>1</mn><mo separator="true">,</mo><mn>2</mn><mo stretchy="false">)</mo><mo separator="true">,</mo><mo stretchy="false">(</mo><mn>3</mn><mo separator="true">,</mo><mn>5</mn><mo stretchy="false">)</mo><mo separator="true">,</mo><mo stretchy="false">(</mo><mn>6</mn><mo separator="true">,</mo><mn>7</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(1, 2), (3, 5), (6, 7)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">2</span><span class="mclose">)</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mopen">(</span><span class="mord">3</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">5</span><span class="mclose">)</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mopen">(</span><span class="mord">6</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">7</span><span class="mclose">)</span></span></span></span> 。<br />因为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>a</mi><mn>3</mn></msub></mrow><annotation encoding="application/x-tex">a_3</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">3</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 的速度降低到区间速度以下之后，区间 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>1</mn><mo separator="true">,</mo><mn>3</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(1, 3)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">3</span><span class="mclose">)</span></span></span></span> 就拆分成 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>1</mn><mo separator="true">,</mo><mn>2</mn><mo stretchy="false">)</mo><mo separator="true">,</mo><mo stretchy="false">(</mo><mn>3</mn><mo separator="true">,</mo><mn>3</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(1, 2), (3, 3)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">2</span><span class="mclose">)</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mopen">(</span><span class="mord">3</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">3</span><span class="mclose">)</span></span></span></span> 了。<br />然后依次比较新的区间和后续区间的速度大小，直到后续无区间或者后续区间速度小于当前区间速度。<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>3</mn><mo separator="true">,</mo><mn>3</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(3, 3)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">3</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">3</span><span class="mclose">)</span></span></span></span> 区间的速度小于或等于 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>4</mn><mo separator="true">,</mo><mn>5</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(4, 5)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">4</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">5</span><span class="mclose">)</span></span></span></span> 区间的速度，故可以合并成区间 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>3</mn><mo separator="true">,</mo><mn>5</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(3, 5)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">3</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">5</span><span class="mclose">)</span></span></span></span>。 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>3</mn><mo separator="true">,</mo><mn>5</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(3, 5)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">3</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">5</span><span class="mclose">)</span></span></span></span> 区间速度大于 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>6</mn><mo separator="true">,</mo><mn>7</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(6, 7)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">6</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">7</span><span class="mclose">)</span></span></span></span> 区间速度，故不合并这两个区间。<br />这个case代表：<strong>如果某个速度减小之后，此位置速度小于它所处的区间的速度，那么速度区间就要进行拆分；如果新区间速度速度不大于后续区间的速度，那么要合并这两个相邻区间，直到后续无区间或者后续区间的速度小于此位置所处的区间的速度。</strong></p><p>区间数目即每次查询的结果。</p><p>PS: 学过一点<a href="http://oi-wiki.com/ds/odt/">珂学</a>，很容易就能想到。</p><h2 id="参考代码-7"><a class="markdownIt-Anchor" href="#参考代码-7"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;  fastIO();  int t;  cin &gt;&gt; t;  while(t--)&#123;    int n, m;    cin &gt;&gt; n &gt;&gt; m;    vector&lt;int&gt; arr(n + 1);    for(int i &#x3D; 1; i &lt;&#x3D; n; ++i) cin &gt;&gt; arr[i];    set&lt;PII&gt; st;    int pre &#x3D; 1;    for(int i &#x3D; 1; i &lt;&#x3D; n; ++i)&#123;      if(arr[i] &lt; arr[pre])&#123;        st.insert(&#123;pre, i - 1&#125;);        pre &#x3D; i;      &#125;    &#125;    st.insert(&#123;pre, n&#125;);    while(m--)&#123;      int k, d;      cin &gt;&gt; k &gt;&gt; d;      auto pos &#x3D; prev(st.lower_bound(&#123;k + 1, k + 1&#125;));      int fv &#x3D; arr[pos-&gt;first];      arr[k] -&#x3D; d;      if(arr[k] &lt; fv)&#123;        PII p &#x3D; *pos;        st.erase(pos);        if(k &gt; p.first)&#123;          st.insert(&#123;p.first, k - 1&#125;);        &#125;        int nv &#x3D; p.second;        auto nex &#x3D; st.lower_bound(&#123;k, k&#125;);        while(nex !&#x3D; st.end() and arr[nex-&gt;first] &gt;&#x3D; arr[k])&#123;          nv &#x3D; nex-&gt;second;          st.erase(nex);          nex &#x3D; st.lower_bound(&#123;k, k&#125;);        &#125;        st.insert(&#123;k, nv&#125;);      &#125;      cout &lt;&lt; st.size() &lt;&lt; &quot; &quot;;    &#125;    cout &lt;&lt; &quot;\n&quot;;  &#125;  return 0;&#125;</code></pre></div></figure>]]>
      </content:encoded>
    </item>
    <item>
      <title>介绍一个查看Codeforces GYM的代码的工具</title>
      <link>https://www.dianhsu.com/2022/06/04/cf-code/</link>
      <description>
        <![CDATA[<h1 id="简介"><a class="markdownIt-Anchor" href="#简介"></a> 简介</h1>
<p>因为Codeforces GYM要求黄名(rating &gt;= 2100) 或者 紫名(rating &gt;=]]>
      </description>
      <author>Dian Hsu</author>
      <category domain="https://www.dianhsu.com/categories/%E5%B7%A5%E5%85%B7/">工具</category>
      <category domain="https://www.dianhsu.com/tags/%E5%B7%A5%E5%85%B7/">工具</category>
      <category domain="https://www.dianhsu.com/tags/Codeforces/">Codeforces</category>
      <pubDate>Sat, 04 Jun 2022 15:25:17 GMT</pubDate>
      <content:encoded>
        <![CDATA[<h1 id="简介"><a class="markdownIt-Anchor" href="#简介"></a> 简介</h1><p>因为Codeforces GYM要求黄名(rating &gt;= 2100) 或者 紫名(rating &gt;= 1900)并且打过30场计分的比赛才可以查看公开的代码，为了方便群友查看GYM中的代码，故写了这个小工具。</p><h1 id="前置工具"><a class="markdownIt-Anchor" href="#前置工具"></a> 前置工具</h1><p>本工具需要安装浏览器用户脚本管理器，例如： <a href="https://chrome.google.com/webstore/detail/violent-monkey/jinjaccalgkegednnccohejagnlnfdag">暴力猴</a></p><p>上面链接是通过Google商店下载，如果进不去，可以通过GitHub下载 <a href="https://github.com/violentmonkey/violentmonkey/releases">暴力猴</a></p><h1 id="安装过程"><a class="markdownIt-Anchor" href="#安装过程"></a> 安装过程</h1><p>访问<a href="https://raw.githubusercontent.com/dianhsu/cf-code/main/script.user.js">脚本安装链接</a>，点击<code>确认安装</code>即可。</p><h1 id="如何获取代码"><a class="markdownIt-Anchor" href="#如何获取代码"></a> 如何获取代码</h1><p>打开一场GYM比赛的<code>status</code>页面，列表中第一列代码编号变成了可以点击的链接啦，如下图所示。<br /><img src="https://cdn.dianhsu.com/img/2022-06-06-12-52-37.png" alt="安装插件之后" /></p><p>对比一下安装插件之前的页面。</p><p><img src="https://cdn.dianhsu.com/img/2022-06-06-12-51-50.png" alt="安装插件之前" /></p><p>点击一下代码编号的链接，就跳转到了贴代码的网站。</p><p><img src="https://cdn.dianhsu.com/img/2022-06-04-23-44-21.png" alt="跳转到了贴代码的网站" /></p><p>PS：原本个人submission里面的无法查看的代码也可以查看啦</p><h1 id="其他的一些说明"><a class="markdownIt-Anchor" href="#其他的一些说明"></a> 其他的一些说明</h1><ol><li>目前还没做代码高亮，后续有想法。 PS：已实现</li><li>有些比赛需要通过邀请链接才能进去查看比赛。这个逻辑后台已经写了，前端没想好放在哪。</li><li>插件和后端源码 <a href="https://github.com/dianhsu/cf-code">cf-code</a></li></ol>]]>
      </content:encoded>
    </item>
    <item>
      <title>Educational Codeforces Round 129 (Rated for Div. 2)</title>
      <link>https://www.dianhsu.com/2022/05/24/cf1681/</link>
      <description>
        <![CDATA[<h1 id="a-game-with-cards"><a class="markdownIt-Anchor" href="#a-game-with-cards"></a> A. Game with Cards</h1>
<h2 id="题目解析"><a]]>
      </description>
      <author>Dian Hsu</author>
      <category domain="https://www.dianhsu.com/categories/Codeforces/">Codeforces</category>
      <category domain="https://www.dianhsu.com/tags/%E7%AE%97%E6%B3%95/">算法</category>
      <category domain="https://www.dianhsu.com/tags/Codeforces/">Codeforces</category>
      <pubDate>Tue, 24 May 2022 05:08:39 GMT</pubDate>
      <content:encoded>
        <![CDATA[<h1 id="a-game-with-cards"><a class="markdownIt-Anchor" href="#a-game-with-cards"></a> A. Game with Cards</h1><h2 id="题目解析"><a class="markdownIt-Anchor" href="#题目解析"></a> 题目解析</h2><p>直接判断Alice的最大卡片和Bob的最大的卡片的大小，如果相等，先手获胜，否则较大的获胜。</p><h2 id="参考代码"><a class="markdownIt-Anchor" href="#参考代码"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;    int t;    cin &gt;&gt; t;    while(t--)&#123;        int n, m;        cin &gt;&gt; n;        vector&lt;int&gt; arr(n);        for(auto&amp; it: arr) cin &gt;&gt; it;        cin &gt;&gt; m;        vector&lt;int&gt; brr(m);        for(auto&amp; it: brr) cin &gt;&gt; it;        sort(arr.begin(), arr.end());        sort(brr.begin(), brr.end());        int ra &#x3D; arr.back(), rb  &#x3D; brr.back();        if(ra &lt; rb)&#123;            cout &lt;&lt; &quot;Bob\nBob\n&quot;;        &#125;else if(ra &#x3D;&#x3D; rb)&#123;            cout &lt;&lt; &quot;Alice\nBob\n&quot;;        &#125;else&#123;            cout &lt;&lt; &quot;Alice\nAlice\n&quot;;        &#125;    &#125;    return 0;&#125;</code></pre></div></figure><h1 id="b-card-trick"><a class="markdownIt-Anchor" href="#b-card-trick"></a> B. Card Trick</h1><h2 id="题目解析-2"><a class="markdownIt-Anchor" href="#题目解析-2"></a> 题目解析</h2><p>移动前 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>b</mi><mi>j</mi></msub></mrow><annotation encoding="application/x-tex">b_j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.980548em;vertical-align:-0.286108em;"></span><span class="mord"><span class="mord mathnormal">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.311664em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.05724em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></span></span></span></span> 张牌到末尾，意味着将牌顶指针向下移动 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>b</mi><mi>j</mi></msub></mrow><annotation encoding="application/x-tex">b_j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.980548em;vertical-align:-0.286108em;"></span><span class="mord"><span class="mord mathnormal">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.311664em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.05724em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></span></span></span></span> 。如果牌顶指针移到牌底之下，就将牌顶指针移回牌顶。</p><h2 id="参考代码-2"><a class="markdownIt-Anchor" href="#参考代码-2"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;    int t;    cin &gt;&gt; t;    while(t--)&#123;        int n;        cin &gt;&gt; n;        vector&lt;int&gt; arr(n);        for(auto&amp; it: arr) cin &gt;&gt; it;        int top &#x3D; 0;        int m;        cin &gt;&gt; m;        for(int i &#x3D; 0; i &lt; m; ++i)&#123;            int nex;            cin &gt;&gt; nex;            top &#x3D; (top + nex) % n;        &#125;        cout &lt;&lt; arr[top] &lt;&lt; endl;    &#125;    return 0;&#125;</code></pre></div></figure><h1 id="c-double-sort"><a class="markdownIt-Anchor" href="#c-double-sort"></a> C. Double Sort</h1><h2 id="题目解析-3"><a class="markdownIt-Anchor" href="#题目解析-3"></a> 题目解析</h2><p>先将 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>a</mi><mi>i</mi></msub><mo separator="true">,</mo><msub><mi>b</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">a_i, b_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 合并起来排序，然后检查 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>b</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">b_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 是不是非递减的。<br />如果不是非递增的，那么就不存在结果；<br />如果是非递增的，那么就可以通过交换，使它满足均非递减的状态；</p><p>然后根据初始位置和当前位置，设定一下交换关系。</p><h2 id="参考代码-3"><a class="markdownIt-Anchor" href="#参考代码-3"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">struct Node&#123;    int a, b;    int idx;    bool operator &lt; (const Node&amp; arg) const&#123;        if(a &#x3D;&#x3D; arg.a)&#123;            return b &lt; arg.b;        &#125;        return a &lt; arg.a;    &#125;&#125;;int main() &#123;    fastIO();    int t;    cin &gt;&gt; t;    while(t--)&#123;        int n;        cin &gt;&gt; n;        vector&lt;Node&gt; arr(n);        for(int i &#x3D; 0; i &lt; n; ++i)&#123;            arr[i].idx &#x3D; i;            cin &gt;&gt; arr[i].a;        &#125;        for(int i &#x3D; 0; i &lt; n; ++i) cin &gt;&gt; arr[i].b;        sort(itr(arr));        bool ok &#x3D; true;        for(int i &#x3D; 1; i &lt; n; ++i)&#123;            if(arr[i].b &lt; arr[i - 1].b)&#123;                ok &#x3D; false;                break;            &#125;        &#125;        if(!ok)&#123;            cout &lt;&lt; &quot;-1\n&quot;;            continue;        &#125;        vector&lt;int&gt; brr(n); &#x2F;&#x2F;存放的是目标位置        vector&lt;int&gt; rbrr(n);  &#x2F;&#x2F;存放的是值对应的位置，brr的反向映射        for(int i &#x3D; 0; i &lt; n; ++i) rbrr[i] &#x3D; arr[i].idx;        for(int i &#x3D; 0; i &lt; n; ++i)&#123;            brr[rbrr[i]] &#x3D; i;        &#125;        vector&lt;PII&gt; ans;        for(int i &#x3D; 0; i &lt; n; ++i)&#123;            if(brr[i] !&#x3D; i)&#123;                int x &#x3D; i;                int y &#x3D; rbrr[i];                ans.push_back(&#123;x, y&#125;);                swap(brr[x], brr[y]);                rbrr[brr[x]] &#x3D; x;                rbrr[brr[y]] &#x3D; y;            &#125;        &#125;        cout &lt;&lt; ans.size() &lt;&lt; &quot;\n&quot;;        for(auto&amp; it: ans)&#123;            cout &lt;&lt; it.first + 1 &lt;&lt; &quot; &quot; &lt;&lt; it.second + 1 &lt;&lt; &quot;\n&quot;;        &#125;    &#125;    return 0;&#125;</code></pre></div></figure><h1 id="d-required-length"><a class="markdownIt-Anchor" href="#d-required-length"></a> D. Required Length</h1><h2 id="题目解析-4"><a class="markdownIt-Anchor" href="#题目解析-4"></a> 题目解析</h2><p>从 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi></mrow><annotation encoding="application/x-tex">x</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">x</span></span></span></span> 开始，遍历它的每一位，然后找到它可以转移到的，大于 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi></mrow><annotation encoding="application/x-tex">x</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">x</span></span></span></span> 的下个数字。通过BFS找到是否能转移到一个n位的数字。</p><p>开<code>unsigned long long</code>比较保险。</p><h2 id="参考代码-4"><a class="markdownIt-Anchor" href="#参考代码-4"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">typedef pair&lt;ull, int&gt; pui;int main() &#123;    ull n, x;    cin &gt;&gt; n &gt;&gt; x;    ull ml &#x3D; 1, mr &#x3D; 10;    while(--n)&#123;        ml *&#x3D; 10, mr *&#x3D; 10;    &#125;    pui st&#123;x, 0&#125;;    int ans &#x3D; -1;    queue&lt;pui&gt; q; &#x2F;&#x2F;当前数字，操作次数    q.push(st);    set&lt;ull&gt; vis;    vis.insert(st.first);    while(!q.empty())&#123;        auto it &#x3D; q.front();        q.pop();        if(it.first &gt;&#x3D; mr) continue;        if(it.first &gt;&#x3D; ml and it.first &lt; mr)&#123;            ans &#x3D; it.second;            break;        &#125;        ull flag &#x3D; 0; &#x2F;&#x2F;用来标记数字位是否已经访问过。        ull tmpv &#x3D; it.first;        while(tmpv)&#123;            int delta &#x3D; tmpv % 10;            tmpv &#x2F;&#x3D; 10;            if(delta &gt; 0 and !(flag &amp; (1 &lt;&lt; delta)))&#123;                flag |&#x3D; (1 &lt;&lt; delta);                ull nex &#x3D; it.first * delta;                if(!vis.count(nex))&#123;                    q.push(&#123;nex, it.second + 1&#125;);                    vis.insert(nex);                &#125;            &#125;        &#125;    &#125;    cout &lt;&lt; ans &lt;&lt; endl;    return 0;&#125;</code></pre></div></figure><h1 id="e-labyrinth-adventures"><a class="markdownIt-Anchor" href="#e-labyrinth-adventures"></a> E. Labyrinth Adventures</h1><h2 id="题目解析-5"><a class="markdownIt-Anchor" href="#题目解析-5"></a> 题目解析</h2><p>首先设定起始点 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><msub><mi>s</mi><mi>x</mi></msub><mo separator="true">,</mo><msub><mi>s</mi><mi>y</mi></msub><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(s_x, s_y)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.036108em;vertical-align:-0.286108em;"></span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">x</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.15139200000000003em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.03588em;">y</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span> 的层序 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>L</mi><mi>s</mi></msub></mrow><annotation encoding="application/x-tex">L_s</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.83333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">L</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">s</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 小于或者等于目标点 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><msub><mi>e</mi><mi>x</mi></msub><mo separator="true">,</mo><msub><mi>e</mi><mi>y</mi></msub><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(e_x, e_y)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.036108em;vertical-align:-0.286108em;"></span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal">e</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">x</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">e</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.15139200000000003em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.03588em;">y</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span> 的层序 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>L</mi><mi>e</mi></msub></mrow><annotation encoding="application/x-tex">L_e</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.83333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">L</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">e</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> ，如果不满足，就交换起始点和目标点。</p><p>如果起始点的层序和目标点的层序相同，起始点和目标点的曼哈顿距离就是结果，因为可以沿着当前层运动。</p><p>如果起始点层序小于目标点的层序。我们可以用线段树维护一下<strong>起始层的门旁位置</strong>到<strong>目标层的前一层门旁位置</strong>之间的最短距离（分别是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>d</mi><mrow><mi>u</mi><mi>u</mi></mrow></msub><mo separator="true">,</mo><msub><mi>d</mi><mrow><mi>u</mi><mi>r</mi></mrow></msub><mo separator="true">,</mo><msub><mi>d</mi><mrow><mi>r</mi><mi>u</mi></mrow></msub><mo separator="true">,</mo><msub><mi>d</mi><mrow><mi>r</mi><mi>r</mi></mrow></msub></mrow><annotation encoding="application/x-tex">d_{uu}, d_{ur}, d_{ru}, d_{rr}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">u</span><span class="mord mathnormal mtight">u</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">u</span><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span><span class="mord mathnormal mtight">u</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>）。门旁位置是代表当前位置的上方或者右方有一扇门。 然后计算<strong>起始点</strong>到<strong>起始层门旁位置</strong>的曼哈顿距离（分别是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>d</mi><mrow><mi>s</mi><mi>u</mi></mrow></msub><mo separator="true">,</mo><msub><mi>d</mi><mrow><mi>s</mi><mi>r</mi></mrow></msub></mrow><annotation encoding="application/x-tex">d_{su}, d_{sr}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">s</span><span class="mord mathnormal mtight">u</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">s</span><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> ）和<strong>目标层的前一层的门旁位置</strong>到<strong>目标点</strong>的曼哈顿距离（分别是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>d</mi><mrow><mi>u</mi><mi>e</mi></mrow></msub><mo separator="true">,</mo><msub><mi>d</mi><mrow><mi>r</mi><mi>e</mi></mrow></msub></mrow><annotation encoding="application/x-tex">d_{ue}, d_{re}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">u</span><span class="mord mathnormal mtight">e</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span><span class="mord mathnormal mtight">e</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> ）。</p><p>那么起始点到目标点的最近距离就是：</p><p class='katex-block'><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><msub><mi>d</mi><mrow><mi>s</mi><mi>e</mi></mrow></msub><mo>=</mo><mi>min</mi><mo>⁡</mo><mo stretchy="false">(</mo><msub><mi>d</mi><mrow><mi>s</mi><mi>u</mi></mrow></msub><mo>+</mo><msub><mi>d</mi><mrow><mi>u</mi><mi>u</mi></mrow></msub><mo>+</mo><msub><mi>d</mi><mrow><mi>u</mi><mi>e</mi></mrow></msub><mo separator="true">,</mo><msub><mi>d</mi><mrow><mi>s</mi><mi>u</mi></mrow></msub><mo>+</mo><msub><mi>d</mi><mrow><mi>u</mi><mi>r</mi></mrow></msub><mo>+</mo><msub><mi>d</mi><mrow><mi>r</mi><mi>e</mi></mrow></msub><mo separator="true">,</mo><msub><mi>d</mi><mrow><mi>s</mi><mi>r</mi></mrow></msub><mo>+</mo><msub><mi>d</mi><mrow><mi>r</mi><mi>u</mi></mrow></msub><mo>+</mo><msub><mi>d</mi><mrow><mi>u</mi><mi>e</mi></mrow></msub><mo separator="true">,</mo><msub><mi>d</mi><mrow><mi>s</mi><mi>r</mi></mrow></msub><mo>+</mo><msub><mi>d</mi><mrow><mi>r</mi><mi>r</mi></mrow></msub><mo>+</mo><msub><mi>d</mi><mrow><mi>r</mi><mi>e</mi></mrow></msub><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">  d_{se} = \min(d_{su} + d_{uu} + d_{ue}, d_{su} + d_{ur} + d_{re}, d_{sr} + d_{ru} + d_{ue}, d_{sr} + d_{rr} + d_{re})</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">s</span><span class="mord mathnormal mtight">e</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mop">min</span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">s</span><span class="mord mathnormal mtight">u</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">u</span><span class="mord mathnormal mtight">u</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">u</span><span class="mord mathnormal mtight">e</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">s</span><span class="mord mathnormal mtight">u</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">u</span><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span><span class="mord mathnormal mtight">e</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">s</span><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span><span class="mord mathnormal mtight">u</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">u</span><span class="mord mathnormal mtight">e</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">s</span><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span><span class="mord mathnormal mtight">e</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span></span></p><p>我们定义的线段树的节点如下所示：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">struct SegNode&#123;    int stu, str; &#x2F;&#x2F; stu: 起始层的上方门的y； str: 目标层的右方门的x    int edu, edr; &#x2F;&#x2F; stu: 目标层的上方门的y； str: 目标层的右方门的x    int s, e; &#x2F;&#x2F; s: 起始层序号； e: 目标层序号    &#x2F;&#x2F; uu: 起始层上方门旁位置到目标层上方门旁位置的最近距离；     &#x2F;&#x2F; ur: 起始层上方门旁位置到目标层右方门旁位置的最近距离；     &#x2F;&#x2F; ru: 起始层右方门旁位置到目标层上方门旁位置的最近距离；     &#x2F;&#x2F; rr: 起始层右方门旁位置到目标层右方门旁位置的最近距离；    ll uu, ur, ru, rr;      SegNode() &#x3D; default;    SegNode(int u, int r, int id): stu(u), str(r), edu(u), edr(r), uu(0), s(id), e(id), ur(abs(id - u) + abs(id - r)), ru(abs(id - u) + abs(id - r)), rr(0)&#123; &#125;    SegNode operator + (const SegNode&amp; arg) &#123;        SegNode ret;        ret.stu &#x3D; stu;        ret.str &#x3D; str;        ret.s &#x3D; s;        ret.e &#x3D; arg.e;        ret.edu &#x3D; arg.edu;        ret.edr &#x3D; arg.edr;        ll tuu &#x3D; abs(edu - arg.stu);        ll trr &#x3D; abs(edr - arg.str);        ll tur &#x3D; abs(edu - arg.s) + abs(arg.s - arg.str);        ll tru &#x3D; abs(edr - arg.s) + abs(arg.s - arg.stu);        ret.uu &#x3D; min(min(uu + arg.uu + tuu, ur + arg.ru + trr), min(uu + arg.ru + tur, ur + arg.uu + tru)) + 1;        ret.ur &#x3D; min(min(uu + arg.ur + tuu, ur + arg.rr + trr), min(uu + arg.rr + tur, ur + arg.ur + tru)) + 1;        ret.ru &#x3D; min(min(ru + arg.uu + tuu, rr + arg.ru + trr), min(ru + arg.ru + tur, rr + arg.uu + tru)) + 1;        ret.rr &#x3D; min(min(ru + arg.ur + tuu, rr + arg.rr + trr), min(ru + arg.rr + tur, rr + arg.ur + tru)) + 1;        return ret;    &#125;&#125;;</code></pre></div></figure><h2 id="参考代码-5"><a class="markdownIt-Anchor" href="#参考代码-5"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">struct Node&#123;    int x1, y1, x2, y2;&#125;;struct SegNode&#123;    int stu, str;    int edu, edr;    int s, e;    ll uu, ur, ru, rr;    SegNode() &#x3D; default;    SegNode(int u, int r, int id): stu(u), str(r), edu(u), edr(r), uu(0), s(id), e(id), ur(abs(id - u) + abs(id - r)), ru(abs(id - u) + abs(id - r)), rr(0)&#123; &#125;    SegNode operator + (const SegNode&amp; arg) &#123;        SegNode ret;        ret.stu &#x3D; stu;        ret.str &#x3D; str;        ret.s &#x3D; s;        ret.e &#x3D; arg.e;        ret.edu &#x3D; arg.edu;        ret.edr &#x3D; arg.edr;        ll tuu &#x3D; abs(edu - arg.stu);        ll trr &#x3D; abs(edr - arg.str);        ll tur &#x3D; abs(edu - arg.s) + abs(arg.s - arg.str);        ll tru &#x3D; abs(edr - arg.s) + abs(arg.s - arg.stu);        ret.uu &#x3D; min(min(uu + arg.uu + tuu, ur + arg.ru + trr), min(uu + arg.ru + tur, ur + arg.uu + tru)) + 1;        ret.ur &#x3D; min(min(uu + arg.ur + tuu, ur + arg.rr + trr), min(uu + arg.rr + tur, ur + arg.ur + tru)) + 1;        ret.ru &#x3D; min(min(ru + arg.uu + tuu, rr + arg.ru + trr), min(ru + arg.ru + tur, rr + arg.uu + tru)) + 1;        ret.rr &#x3D; min(min(ru + arg.ur + tuu, rr + arg.rr + trr), min(ru + arg.rr + tur, rr + arg.ur + tru)) + 1;        return ret;    &#125;&#125;;#define LEFT (cur &lt;&lt; 1)#define RIGHT (LEFT | 1)#define MID ((l + r) &gt;&gt; 1)int dis(int x1, int y1, int x2, int y2)&#123;    return abs(x1 - x2) + abs(y1 - y2);&#125;int main() &#123;    fastIO();    int n;    cin &gt;&gt; n;    vector&lt;Node&gt; arr(n);    for(int i &#x3D; 1; i &lt; n; ++i) &#123;        cin &gt;&gt; arr[i].x1 &gt;&gt; arr[i].y1 &gt;&gt; arr[i].x2 &gt;&gt; arr[i].y2;    &#125;    vector&lt;SegNode&gt; seg((n + 5) &lt;&lt; 2);    auto&amp;&amp; build &#x3D; [&amp;](auto&amp;&amp; self, int cur, int l, int r) -&gt; void&#123;        if(l &#x3D;&#x3D; r)&#123;            seg[cur] &#x3D; SegNode(arr[l].y1, arr[l].x2, l);            return;        &#125;        self(self, LEFT, l, MID);        self(self, RIGHT, MID + 1, r);        seg[cur] &#x3D; seg[LEFT] + seg[RIGHT];    &#125;;    build(build, 1, 1, n - 1);    auto&amp;&amp; query &#x3D; [&amp;](auto&amp;&amp; self, int cur, int l, int r, int st, int ed) -&gt; SegNode&#123;        if(ed &lt; l or r &lt; st) return SegNode(0, 0, -1);        if(st &lt;&#x3D; l and r &lt;&#x3D; ed) return seg[cur];        SegNode lv &#x3D; self(self, LEFT, l, MID, st, ed);        SegNode rv &#x3D; self(self, RIGHT, MID + 1, r, st, ed);        if(lv.s &gt;&#x3D; 0 and rv.s &gt;&#x3D; 0)&#123;            return lv + rv;        &#125;else if(lv.s &gt;&#x3D; 0)&#123;            return lv;        &#125;else if(rv.s &gt;&#x3D; 0)&#123;            return rv;        &#125;else&#123;            return SegNode(0, 0, -1);        &#125;    &#125;;    int m;    cin &gt;&gt; m;    while(m--)&#123;        int x1, y1, x2, y2;        cin &gt;&gt; x1 &gt;&gt; y1 &gt;&gt; x2 &gt;&gt; y2;        int m1 &#x3D; max(x1, y1), m2 &#x3D; max(x2, y2);        if(m1 &#x3D;&#x3D; m2)&#123;            cout &lt;&lt; abs(x1 - x2) + abs(y1 - y2) &lt;&lt; &quot;\n&quot;;            continue;        &#125;        if(m1 &gt; m2)&#123;            swap(m1, m2);            swap(x1, x2);            swap(y1, y2);        &#125;        SegNode delta &#x3D; query(query, 1, 1, n - 1, m1, m2 - 1);        ll ssu &#x3D; dis(x1, y1, delta.s, delta.stu);        ll ssr &#x3D; dis(x1, y1, delta.str, delta.s);        ll ttu &#x3D; dis(x2, y2, delta.e + 1, delta.edu);        ll ttr &#x3D; dis(x2, y2, delta.edr, delta.e + 1);        ll ans &#x3D; infl;        ans &#x3D; min(ssu + ttu + 1 + delta.uu, ans);        ans &#x3D; min(ssu + ttr + 1 + delta.ur, ans);        ans &#x3D; min(ssr + ttu + 1 + delta.ru, ans);        ans &#x3D; min(ssr + ttr + 1 + delta.rr, ans);        cout &lt;&lt; ans &lt;&lt; &quot;\n&quot;;    &#125;    return 0;&#125;</code></pre></div></figure><h1 id="f-unique-occurrences"><a class="markdownIt-Anchor" href="#f-unique-occurrences"></a> F. Unique Occurrences</h1><h2 id="题目解析-6"><a class="markdownIt-Anchor" href="#题目解析-6"></a> 题目解析</h2><p>首先将题意转化为求每条边对结果的贡献。对于边 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mi>u</mi><mo separator="true">,</mo><mi>v</mi><mo separator="true">,</mo><mi>c</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(u, v, c)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord mathnormal">u</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.03588em;">v</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal">c</span><span class="mclose">)</span></span></span></span> 来讲，他的贡献就是<strong>在 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>u</mi><mo>←</mo><mi>v</mi></mrow><annotation encoding="application/x-tex">u \leftarrow v</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">u</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">←</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal" style="margin-right:0.03588em;">v</span></span></span></span> 方向的 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>u</mi></mrow><annotation encoding="application/x-tex">u</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">u</span></span></span></span> 的子树中到 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>u</mi></mrow><annotation encoding="application/x-tex">u</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">u</span></span></span></span> 的路径不包含边权为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi></mrow><annotation encoding="application/x-tex">c</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">c</span></span></span></span> 的节点总数</strong> 与 <strong>在 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>u</mi><mo>→</mo><mi>v</mi></mrow><annotation encoding="application/x-tex">u \rightarrow v</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">u</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">→</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal" style="margin-right:0.03588em;">v</span></span></span></span> 方向的 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>v</mi></mrow><annotation encoding="application/x-tex">v</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal" style="margin-right:0.03588em;">v</span></span></span></span> 的子树中到 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>v</mi></mrow><annotation encoding="application/x-tex">v</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal" style="margin-right:0.03588em;">v</span></span></span></span> 的路径不包含边权为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi></mrow><annotation encoding="application/x-tex">c</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">c</span></span></span></span> 的节点总数</strong> 的乘积。</p><p>以 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> 为根，遍历整棵树，找到每个节点的子树的节点总数 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi><mi>n</mi><mi>t</mi></mrow><annotation encoding="application/x-tex">cnt</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.61508em;vertical-align:0em;"></span><span class="mord mathnormal">c</span><span class="mord mathnormal">n</span><span class="mord mathnormal">t</span></span></span></span>。同时构建倍增数组 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>f</mi><mi>a</mi></mrow><annotation encoding="application/x-tex">fa</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord mathnormal" style="margin-right:0.10764em;">f</span><span class="mord mathnormal">a</span></span></span></span> ，倍增数组用来寻找祖先节点。</p><p>第二次遍历以 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> 为根的整棵树的时候，当前节点是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi><mi>u</mi><msub><mi>r</mi><mi>p</mi></msub></mrow><annotation encoding="application/x-tex">cur_p</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.716668em;vertical-align:-0.286108em;"></span><span class="mord mathnormal">c</span><span class="mord mathnormal">u</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.15139200000000003em;"><span style="top:-2.5500000000000003em;margin-left:-0.02778em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></span></span></span></span>，子节点是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>p</mi></msub></mrow><annotation encoding="application/x-tex">nex_p</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.716668em;vertical-align:-0.286108em;"></span><span class="mord mathnormal">n</span><span class="mord mathnormal">e</span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.15139200000000003em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></span></span></span></span>，边权是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>c</mi><mrow><mo stretchy="false">(</mo><mi>c</mi><mi>u</mi><msub><mi>r</mi><mi>p</mi></msub><mo separator="true">,</mo><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>p</mi></msub><mo stretchy="false">)</mo></mrow></msub></mrow><annotation encoding="application/x-tex">c_{(cur_p, nex_p)}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8080799999999999em;vertical-align:-0.3775199999999999em;"></span><span class="mord"><span class="mord mathnormal">c</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.34479999999999994em;"><span style="top:-2.5198em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mopen mtight">(</span><span class="mord mathnormal mtight">c</span><span class="mord mathnormal mtight">u</span><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.16454285714285716em;"><span style="top:-2.357em;margin-left:-0.02778em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2818857142857143em;"><span></span></span></span></span></span></span><span class="mpunct mtight">,</span><span class="mord mathnormal mtight">n</span><span class="mord mathnormal mtight">e</span><span class="mord mtight"><span class="mord mathnormal mtight">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.16454285714285716em;"><span style="top:-2.357em;margin-left:0em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2818857142857143em;"><span></span></span></span></span></span></span><span class="mclose mtight">)</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.3775199999999999em;"><span></span></span></span></span></span></span></span></span></span>，判断可以判断之前遍历过的，具有相同边权 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>c</mi><mrow><mo stretchy="false">(</mo><mi>c</mi><mi>u</mi><msub><mi>r</mi><mi>p</mi></msub><mo separator="true">,</mo><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>p</mi></msub><mo stretchy="false">)</mo></mrow></msub></mrow><annotation encoding="application/x-tex">c_{(cur_p, nex_p)}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8080799999999999em;vertical-align:-0.3775199999999999em;"></span><span class="mord"><span class="mord mathnormal">c</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.34479999999999994em;"><span style="top:-2.5198em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mopen mtight">(</span><span class="mord mathnormal mtight">c</span><span class="mord mathnormal mtight">u</span><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.16454285714285716em;"><span style="top:-2.357em;margin-left:-0.02778em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2818857142857143em;"><span></span></span></span></span></span></span><span class="mpunct mtight">,</span><span class="mord mathnormal mtight">n</span><span class="mord mathnormal mtight">e</span><span class="mord mtight"><span class="mord mathnormal mtight">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.16454285714285716em;"><span style="top:-2.357em;margin-left:0em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2818857142857143em;"><span></span></span></span></span></span></span><span class="mclose mtight">)</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.3775199999999999em;"><span></span></span></span></span></span></span></span></span></span> 的边所相连的两个点 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mi>c</mi><mi>u</mi><msub><mi>r</mi><mi>i</mi></msub><mo separator="true">,</mo><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>i</mi></msub><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(cur_i, nex_i)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord mathnormal">c</span><span class="mord mathnormal">u</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.02778em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal">n</span><span class="mord mathnormal">e</span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span> 是否在当前子树之下， <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">nex_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord mathnormal">n</span><span class="mord mathnormal">e</span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi><mi>u</mi><msub><mi>r</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">cur_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord mathnormal">c</span><span class="mord mathnormal">u</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.02778em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 的相邻子节点。这里可以用倍增来判断是否是在相同子树上 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi mathvariant="normal">isSameTree</mi><mo>⁡</mo></mrow><annotation encoding="application/x-tex">\operatorname{isSameTree}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.68333em;vertical-align:0em;"></span><span class="mop"><span class="mord mathrm">i</span><span class="mord mathrm">s</span><span class="mord mathrm">S</span><span class="mord mathrm">a</span><span class="mord mathrm">m</span><span class="mord mathrm">e</span><span class="mord mathrm">T</span><span class="mord mathrm">r</span><span class="mord mathrm">e</span><span class="mord mathrm">e</span></span></span></span></span>。</p><p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msubsup><mi>S</mi><mrow><mi>d</mi><mi>o</mi><mi>w</mi><mi>n</mi></mrow><mi>i</mi></msubsup></mrow><annotation encoding="application/x-tex">S^i_{down}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.1077719999999998em;vertical-align:-0.2831079999999999em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.05764em;">S</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.824664em;"><span style="top:-2.4168920000000003em;margin-left:-0.05764em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">d</span><span class="mord mathnormal mtight">o</span><span class="mord mathnormal mtight" style="margin-right:0.02691em;">w</span><span class="mord mathnormal mtight">n</span></span></span></span><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2831079999999999em;"><span></span></span></span></span></span></span></span></span></span> 是从 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi><mi>u</mi><msub><mi>r</mi><mi>i</mi></msub><mo>→</mo><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">cur_i \rightarrow nex_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord mathnormal">c</span><span class="mord mathnormal">u</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.02778em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">→</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord mathnormal">n</span><span class="mord mathnormal">e</span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 方向的 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">nex_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord mathnormal">n</span><span class="mord mathnormal">e</span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 的子树中到 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">nex_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord mathnormal">n</span><span class="mord mathnormal">e</span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 的路径不包含边权为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>c</mi><mrow><mo stretchy="false">(</mo><mi>c</mi><mi>u</mi><msub><mi>r</mi><mi>i</mi></msub><mo separator="true">,</mo><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>i</mi></msub><mo stretchy="false">)</mo></mrow></msub></mrow><annotation encoding="application/x-tex">c_{(cur_i, nex_i)}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7857599999999999em;vertical-align:-0.3551999999999999em;"></span><span class="mord"><span class="mord mathnormal">c</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.34480000000000005em;"><span style="top:-2.5198em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mopen mtight">(</span><span class="mord mathnormal mtight">c</span><span class="mord mathnormal mtight">u</span><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3280857142857143em;"><span style="top:-2.357em;margin-left:-0.02778em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.143em;"><span></span></span></span></span></span></span><span class="mpunct mtight">,</span><span class="mord mathnormal mtight">n</span><span class="mord mathnormal mtight">e</span><span class="mord mtight"><span class="mord mathnormal mtight">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3280857142857143em;"><span style="top:-2.357em;margin-left:0em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.143em;"><span></span></span></span></span></span></span><span class="mclose mtight">)</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.3551999999999999em;"><span></span></span></span></span></span></span></span></span></span> 的节点总数。<br /><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msubsup><mi>S</mi><mrow><mi>u</mi><mi>p</mi></mrow><mi>i</mi></msubsup></mrow><annotation encoding="application/x-tex">S^i_{up}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.2077719999999998em;vertical-align:-0.383108em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.05764em;">S</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.824664em;"><span style="top:-2.4530000000000003em;margin-left:-0.05764em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">u</span><span class="mord mathnormal mtight">p</span></span></span></span><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.383108em;"><span></span></span></span></span></span></span></span></span></span> 是从 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi><mi>u</mi><msub><mi>r</mi><mi>i</mi></msub><mo>←</mo><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">cur_i \leftarrow nex_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord mathnormal">c</span><span class="mord mathnormal">u</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.02778em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">←</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord mathnormal">n</span><span class="mord mathnormal">e</span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 方向的 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi><mi>u</mi><msub><mi>r</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">cur_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord mathnormal">c</span><span class="mord mathnormal">u</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.02778em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 的子树中到 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi><mi>u</mi><msub><mi>r</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">cur_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord mathnormal">c</span><span class="mord mathnormal">u</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.02778em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 的路径不包含边权为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>c</mi><mrow><mo stretchy="false">(</mo><mi>c</mi><mi>u</mi><msub><mi>r</mi><mi>i</mi></msub><mo separator="true">,</mo><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>i</mi></msub><mo stretchy="false">)</mo></mrow></msub></mrow><annotation encoding="application/x-tex">c_{(cur_i, nex_i)}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7857599999999999em;vertical-align:-0.3551999999999999em;"></span><span class="mord"><span class="mord mathnormal">c</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.34480000000000005em;"><span style="top:-2.5198em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mopen mtight">(</span><span class="mord mathnormal mtight">c</span><span class="mord mathnormal mtight">u</span><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3280857142857143em;"><span style="top:-2.357em;margin-left:-0.02778em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.143em;"><span></span></span></span></span></span></span><span class="mpunct mtight">,</span><span class="mord mathnormal mtight">n</span><span class="mord mathnormal mtight">e</span><span class="mord mtight"><span class="mord mathnormal mtight">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3280857142857143em;"><span style="top:-2.357em;margin-left:0em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.143em;"><span></span></span></span></span></span></span><span class="mclose mtight">)</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.3551999999999999em;"><span></span></span></span></span></span></span></span></span></span> 的节点总数。</p><p>那么当前边 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mi>c</mi><mi>u</mi><msub><mi>r</mi><mi>p</mi></msub><mo separator="true">,</mo><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>p</mi></msub><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(cur_p, nex_p)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.036108em;vertical-align:-0.286108em;"></span><span class="mopen">(</span><span class="mord mathnormal">c</span><span class="mord mathnormal">u</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.15139200000000003em;"><span style="top:-2.5500000000000003em;margin-left:-0.02778em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal">n</span><span class="mord mathnormal">e</span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.15139200000000003em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span> 的 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi><mi>u</mi><msub><mi>r</mi><mi>p</mi></msub><mo>→</mo><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>p</mi></msub></mrow><annotation encoding="application/x-tex">cur_p \rightarrow nex_p</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.716668em;vertical-align:-0.286108em;"></span><span class="mord mathnormal">c</span><span class="mord mathnormal">u</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.15139200000000003em;"><span style="top:-2.5500000000000003em;margin-left:-0.02778em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">→</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.716668em;vertical-align:-0.286108em;"></span><span class="mord mathnormal">n</span><span class="mord mathnormal">e</span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.15139200000000003em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></span></span></span></span> 方向的 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>p</mi></msub></mrow><annotation encoding="application/x-tex">nex_p</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.716668em;vertical-align:-0.286108em;"></span><span class="mord mathnormal">n</span><span class="mord mathnormal">e</span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.15139200000000003em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></span></span></span></span> 的子树中到 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>p</mi></msub></mrow><annotation encoding="application/x-tex">nex_p</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.716668em;vertical-align:-0.286108em;"></span><span class="mord mathnormal">n</span><span class="mord mathnormal">e</span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.15139200000000003em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></span></span></span></span> 的路径不包含边权为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>c</mi><mrow><mo stretchy="false">(</mo><mi>c</mi><mi>u</mi><msub><mi>r</mi><mi>p</mi></msub><mo separator="true">,</mo><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>p</mi></msub><mo stretchy="false">)</mo></mrow></msub></mrow><annotation encoding="application/x-tex">c_{(cur_p, nex_p)}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8080799999999999em;vertical-align:-0.3775199999999999em;"></span><span class="mord"><span class="mord mathnormal">c</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.34479999999999994em;"><span style="top:-2.5198em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mopen mtight">(</span><span class="mord mathnormal mtight">c</span><span class="mord mathnormal mtight">u</span><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.16454285714285716em;"><span style="top:-2.357em;margin-left:-0.02778em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2818857142857143em;"><span></span></span></span></span></span></span><span class="mpunct mtight">,</span><span class="mord mathnormal mtight">n</span><span class="mord mathnormal mtight">e</span><span class="mord mtight"><span class="mord mathnormal mtight">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.16454285714285716em;"><span style="top:-2.357em;margin-left:0em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2818857142857143em;"><span></span></span></span></span></span></span><span class="mclose mtight">)</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.3775199999999999em;"><span></span></span></span></span></span></span></span></span></span> 的节点总数是</p><p class='katex-block'><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><msubsup><mi>S</mi><mrow><mi>d</mi><mi>o</mi><mi>w</mi><mi>n</mi></mrow><mi>p</mi></msubsup><mo>=</mo><mi>c</mi><mi>n</mi><msub><mi>t</mi><mrow><mi>n</mi><mi>e</mi><mi>x</mi></mrow></msub><mo>−</mo><munder><mo>∑</mo><mrow><mi>i</mi><mo>=</mo><mn>1</mn><mo>&amp;</mo><mi mathvariant="normal">isSameTree</mi><mo>⁡</mo><mo stretchy="false">(</mo><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>p</mi></msub><mo separator="true">,</mo><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>i</mi></msub><mo stretchy="false">)</mo></mrow></munder><mi>c</mi><mi>n</mi><msub><mi>t</mi><mrow><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>i</mi></msub></mrow></msub></mrow><annotation encoding="application/x-tex">  S^p_{down} = cnt_{nex} - \sum_{i = 1 \And \operatorname{isSameTree}(nex_p, nex_i)} cnt_{nex_i}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.083608em;vertical-align:-0.3013079999999999em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.05764em;">S</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.7822999999999999em;"><span style="top:-2.3986920000000005em;margin-left:-0.05764em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">d</span><span class="mord mathnormal mtight">o</span><span class="mord mathnormal mtight" style="margin-right:0.02691em;">w</span><span class="mord mathnormal mtight">n</span></span></span></span><span style="top:-3.180908em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.3013079999999999em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.76508em;vertical-align:-0.15em;"></span><span class="mord mathnormal">c</span><span class="mord mathnormal">n</span><span class="mord"><span class="mord mathnormal">t</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">n</span><span class="mord mathnormal mtight">e</span><span class="mord mathnormal mtight">x</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:2.58833em;vertical-align:-1.538325em;"></span><span class="mop op-limits"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.050005em;"><span style="top:-1.808995em;margin-left:0em;"><span class="pstrut" style="height:3.05em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">i</span><span class="mrel mtight">=</span><span class="mord mtight">1</span><span class="mbin mtight">&amp;</span><span class="mop mtight"><span class="mord mathrm mtight">i</span><span class="mord mathrm mtight">s</span><span class="mord mathrm mtight">S</span><span class="mord mathrm mtight">a</span><span class="mord mathrm mtight">m</span><span class="mord mathrm mtight">e</span><span class="mord mathrm mtight">T</span><span class="mord mathrm mtight">r</span><span class="mord mathrm mtight">e</span><span class="mord mathrm mtight">e</span></span><span class="mopen mtight">(</span><span class="mord mathnormal mtight">n</span><span class="mord mathnormal mtight">e</span><span class="mord mtight"><span class="mord mathnormal mtight">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.16454285714285716em;"><span style="top:-2.357em;margin-left:0em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2818857142857143em;"><span></span></span></span></span></span></span><span class="mpunct mtight">,</span><span class="mord mathnormal mtight">n</span><span class="mord mathnormal mtight">e</span><span class="mord mtight"><span class="mord mathnormal mtight">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3280857142857143em;"><span style="top:-2.357em;margin-left:0em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.143em;"><span></span></span></span></span></span></span><span class="mclose mtight">)</span></span></span></span><span style="top:-3.0500049999999996em;"><span class="pstrut" style="height:3.05em;"></span><span><span class="mop op-symbol large-op">∑</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.538325em;"><span></span></span></span></span></span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal">c</span><span class="mord mathnormal">n</span><span class="mord"><span class="mord mathnormal">t</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.15139199999999997em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">n</span><span class="mord mathnormal mtight">e</span><span class="mord mtight"><span class="mord mathnormal mtight">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3280857142857143em;"><span style="top:-2.357em;margin-left:0em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.143em;"><span></span></span></span></span></span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2501em;"><span></span></span></span></span></span></span></span></span></span></span></p><p>同时可以得到 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi><mi>u</mi><msub><mi>r</mi><mi>i</mi></msub><mo>←</mo><mi>r</mi><mi>i</mi><mi>g</mi><mi>h</mi><msub><mi>t</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">cur_i \leftarrow right_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord mathnormal">c</span><span class="mord mathnormal">u</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.02778em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">←</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="mord mathnormal">i</span><span class="mord mathnormal" style="margin-right:0.03588em;">g</span><span class="mord mathnormal">h</span><span class="mord"><span class="mord mathnormal">t</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 方向的 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi><mi>u</mi><msub><mi>r</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">cur_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord mathnormal">c</span><span class="mord mathnormal">u</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.02778em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 的子树中到 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi><mi>u</mi><msub><mi>r</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">cur_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord mathnormal">c</span><span class="mord mathnormal">u</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:-0.02778em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 的路径不包含边权为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>c</mi><mrow><mo stretchy="false">(</mo><mi>c</mi><mi>u</mi><msub><mi>r</mi><mi>p</mi></msub><mo separator="true">,</mo><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>p</mi></msub><mo stretchy="false">)</mo></mrow></msub></mrow><annotation encoding="application/x-tex">c_{(cur_p, nex_p)}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8080799999999999em;vertical-align:-0.3775199999999999em;"></span><span class="mord"><span class="mord mathnormal">c</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.34479999999999994em;"><span style="top:-2.5198em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mopen mtight">(</span><span class="mord mathnormal mtight">c</span><span class="mord mathnormal mtight">u</span><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.16454285714285716em;"><span style="top:-2.357em;margin-left:-0.02778em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2818857142857143em;"><span></span></span></span></span></span></span><span class="mpunct mtight">,</span><span class="mord mathnormal mtight">n</span><span class="mord mathnormal mtight">e</span><span class="mord mtight"><span class="mord mathnormal mtight">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.16454285714285716em;"><span style="top:-2.357em;margin-left:0em;margin-right:0.07142857142857144em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2818857142857143em;"><span></span></span></span></span></span></span><span class="mclose mtight">)</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.3775199999999999em;"><span></span></span></span></span></span></span></span></span></span> 的节点总数是</p><p class='katex-block'><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><msubsup><mi>S</mi><mrow><mi>u</mi><mi>p</mi></mrow><mi>i</mi></msubsup><mo>=</mo><msubsup><mi>S</mi><mrow><mi>d</mi><mi>o</mi><mi>w</mi><mi>n</mi></mrow><mi>p</mi></msubsup><mo stretchy="false">(</mo><mi mathvariant="normal">isSameTree</mi><mo>⁡</mo><mo stretchy="false">(</mo><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>p</mi></msub><mo separator="true">,</mo><mi>n</mi><mi>e</mi><msub><mi>x</mi><mi>i</mi></msub><mo stretchy="false">)</mo><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">  S^i_{up} = S^p_{down} (\operatorname{isSameTree}(nex_p, nex_i))</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.2577720000000001em;vertical-align:-0.383108em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.05764em;">S</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.874664em;"><span style="top:-2.4530000000000003em;margin-left:-0.05764em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">u</span><span class="mord mathnormal mtight">p</span></span></span></span><span style="top:-3.1130000000000004em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.383108em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1.083608em;vertical-align:-0.3013079999999999em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.05764em;">S</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.7822999999999999em;"><span style="top:-2.3986920000000005em;margin-left:-0.05764em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">d</span><span class="mord mathnormal mtight">o</span><span class="mord mathnormal mtight" style="margin-right:0.02691em;">w</span><span class="mord mathnormal mtight">n</span></span></span></span><span style="top:-3.180908em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.3013079999999999em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mop"><span class="mord mathrm">i</span><span class="mord mathrm">s</span><span class="mord mathrm">S</span><span class="mord mathrm">a</span><span class="mord mathrm">m</span><span class="mord mathrm">e</span><span class="mord mathrm">T</span><span class="mord mathrm">r</span><span class="mord mathrm">e</span><span class="mord mathrm">e</span></span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mord mathnormal">e</span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.15139200000000003em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal">n</span><span class="mord mathnormal">e</span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mclose">)</span><span class="mclose">)</span></span></span></span></span></p><h2 id="参考代码-6"><a class="markdownIt-Anchor" href="#参考代码-6"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">struct Node&#123;    int s, e, v;&#125;;int main() &#123;    int n;    cin &gt;&gt; n;    vector&lt;Node&gt; arr(n - 1);    vector&lt;vector&lt;PII&gt;&gt; g(n + 1); &#x2F;&#x2F;建图    for(int i &#x3D; 0; i &lt; n - 1; ++i)&#123;        cin &gt;&gt; arr[i].s &gt;&gt; arr[i].e &gt;&gt; arr[i].v;        g[arr[i].s].push_back(&#123;arr[i].e, i&#125;);        g[arr[i].e].push_back(&#123;arr[i].s, i&#125;);    &#125;    vector&lt;vector&lt;int&gt;&gt; fa(n + 1, vector&lt;int&gt;(20, 0));    vector&lt;int&gt; dep(n + 1, 0);    auto&amp;&amp; dfs &#x3D; [&amp;](auto&amp;&amp; self, int cur, int pre) -&gt; void&#123;        fa[cur][0] &#x3D; pre;        dep[cur] &#x3D; dep[pre] + 1;        for(int i &#x3D; 1; i &lt; 20; ++i)&#123;            fa[cur][i] &#x3D; fa[fa[cur][i - 1]][i - 1];        &#125;        for(auto&amp; nex: g[cur])&#123;            if(nex.first &#x3D;&#x3D; pre) continue;            self(self, nex.first, cur);        &#125;    &#125;;    dfs(dfs, 1, 0);    auto&amp;&amp; isSameTree &#x3D; [&amp;](int x, int y) -&gt; int&#123;        if(dep[x] &lt; dep[y]) swap(x, y);        int delta &#x3D; dep[x] - dep[y];        for(int i &#x3D; 0; i &lt; 20; ++i)&#123;            if(delta &amp; (1 &lt;&lt; i))&#123;                x &#x3D; fa[x][i];            &#125;        &#125;        return x &#x3D;&#x3D; y;    &#125;;    vector&lt;int&gt; cnt(n + 1, 0);    auto&amp;&amp; dfs1 &#x3D; [&amp;](auto&amp;&amp; self, int cur, int pre) -&gt; int&#123;        int ret &#x3D; 1;        for(auto&amp; [nex, idx]: g[cur])&#123;            if(nex &#x3D;&#x3D; pre) continue;            int res &#x3D; self(self, nex, cur);            ret +&#x3D; res;        &#125;        cnt[cur] &#x3D; ret;        return ret;    &#125;;    dfs1(dfs1, 1, 0);    map&lt;int, stack&lt;PII&gt;&gt; mp;    vector&lt;PLL&gt; ans(n - 1, &#123;0, 0&#125;);    auto&amp;&amp; dfs2 &#x3D; [&amp;](auto&amp;&amp; self, int cur, int pre) -&gt; void&#123;        for(auto&amp; [nex, idx]: g[cur])&#123;            if(nex &#x3D;&#x3D; pre) continue;            self(self, nex, cur);            int idv &#x3D; arr[idx].v;            int sum &#x3D; 0;            stack&lt;int&gt; st;            while(mp.count(idv) and !mp[idv].empty() and isSameTree(mp[idv].top().first, nex))&#123;                sum +&#x3D; cnt[mp[idv].top().first];                st.push(mp[idv].top().second);                mp[idv].pop();            &#125;            int sv &#x3D; cnt[nex] - sum;            ans[idx].first &#x3D; sv;            while(!st.empty())&#123;                ans[st.top()].second &#x3D; sv;                st.pop();            &#125;            if(!mp.count(idv)) mp[idv] &#x3D; stack&lt;PII&gt;();            mp[idv].push(&#123;nex, idx&#125;);        &#125;    &#125;;    dfs2(dfs2, 1, 0);    for(auto&amp; [idv, tst]: mp)&#123;        stack&lt;int&gt; st;        int sum &#x3D; 0;        while(tst.size() &gt; 0)&#123;            sum +&#x3D; cnt[tst.top().first];            st.push(tst.top().second);            tst.pop();        &#125;        int sv &#x3D; n - sum;        while(!st.empty())&#123;            ans[st.top()].second &#x3D; sv;            st.pop();        &#125;    &#125;    ll res &#x3D; 0;    for(int i &#x3D; 0; i &lt; n - 1; ++i)&#123;        res +&#x3D; ans[i].first * ans[i].second;    &#125;    cout &lt;&lt; res &lt;&lt; endl;    return 0;&#125;</code></pre></div></figure>]]>
      </content:encoded>
    </item>
    <item>
      <title>Codeforces Round 793 (Div. 2)</title>
      <link>https://www.dianhsu.com/2022/05/23/cf1682/</link>
      <description>
        <![CDATA[<blockquote>
<p><a href="https://codeforces.com/contest/1682">https://codeforces.com/contest/1682</a></p>
</blockquote>
<h1]]>
      </description>
      <author>Dian Hsu</author>
      <category domain="https://www.dianhsu.com/categories/Codeforces/">Codeforces</category>
      <category domain="https://www.dianhsu.com/tags/%E7%AE%97%E6%B3%95/">算法</category>
      <category domain="https://www.dianhsu.com/tags/Codeforces/">Codeforces</category>
      <category domain="https://www.dianhsu.com/tags/%E6%A0%91/">树</category>
      <pubDate>Mon, 23 May 2022 06:02:32 GMT</pubDate>
      <content:encoded>
        <![CDATA[<blockquote><p><a href="https://codeforces.com/contest/1682">https://codeforces.com/contest/1682</a></p></blockquote><h1 id="a-palindromic-indices"><a class="markdownIt-Anchor" href="#a-palindromic-indices"></a> A. Palindromic Indices</h1><h2 id="题目解析"><a class="markdownIt-Anchor" href="#题目解析"></a> 题目解析</h2><p>从字符串的中心寻找有多少个连续相同的字符。</p><h2 id="参考代码"><a class="markdownIt-Anchor" href="#参考代码"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;    int t;    cin &gt;&gt; t;    while(t--)&#123;        int n;        cin &gt;&gt; n;        string s;        cin &gt;&gt; s;        int l &#x3D; n &#x2F; 2, r &#x3D; n &#x2F; 2;        while(l - 1 &gt;&#x3D; 0 and s[l - 1] &#x3D;&#x3D; s[n &#x2F; 2]) l--;        while(r + 1 &lt; n and s[r + 1] &#x3D;&#x3D; s[n &#x2F; 2]) r++;        cout &lt;&lt; (r - l + 1) &lt;&lt; endl;    &#125;    return 0;&#125;</code></pre></div></figure><h1 id="b-and-sorting"><a class="markdownIt-Anchor" href="#b-and-sorting"></a> B. AND Sorting</h1><h2 id="题目解析-2"><a class="markdownIt-Anchor" href="#题目解析-2"></a> 题目解析</h2><p>略</p><h2 id="参考代码-2"><a class="markdownIt-Anchor" href="#参考代码-2"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;    int t;    cin &gt;&gt; t;    while(t--)&#123;        int n;        cin &gt;&gt; n;        vector&lt;int&gt; arr(n);        for(auto&amp; it: arr) cin &gt;&gt; it;        vector&lt;int&gt; brr(arr);        sort(itr(brr));        int ans &#x3D; INT_MAX;        for(int i &#x3D; 0; i &lt; n; ++i)&#123;            if(arr[i] !&#x3D; brr[i])&#123;                ans &amp;&#x3D; (arr[i] &amp; brr[i]);            &#125;        &#125;        cout &lt;&lt; ans &lt;&lt; endl;    &#125;    return 0;&#125;</code></pre></div></figure><h1 id="c-lis-or-reverse-lis"><a class="markdownIt-Anchor" href="#c-lis-or-reverse-lis"></a> C. LIS or Reverse LIS?</h1><h2 id="题目解析-3"><a class="markdownIt-Anchor" href="#题目解析-3"></a> 题目解析</h2><p>观察可以发现，LIS 和 RerverseLIS(RLIS) 可以共享一个数字，比如：<code>1 2 3 2 1</code>，共享的是 <code>3</code>； <code>3 2 1 2 3</code> 共享的是 <code>1</code>； <code>3 1 2 1 3</code>共享的是<code>2</code>。<br />当然 LIS 和 RLIS 无法共享多个数字。 因为 LIS 要求严格递增， RLIS 要求严格递减。</p><p>那么对于出现过超过 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> 次的数字，可以在 LIS 和 RLIS 中各选择一个。<br />对于只出现过 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> 次的数字，可以选择共享一个数字，其余的数字平均分配到 LIS 和 RLIS 中。</p><h2 id="参考代码-3"><a class="markdownIt-Anchor" href="#参考代码-3"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;    int t;    cin &gt;&gt; t;    while(t--)&#123;        int n;        cin &gt;&gt; n;        vector&lt;int&gt; arr(n);        for(auto&amp; it: arr) cin &gt;&gt; it;        sort(itr(arr));        vector brr(arr);        brr.erase(unique(itr(brr)), brr.end());        map&lt;int, int&gt; mp;        for(auto&amp; it: arr) mp[it]++;        int one &#x3D; 0, two &#x3D; 0;        for(auto&amp; c: brr) &#123;            if(mp[c] &#x3D;&#x3D; 1) one++;            else two++;        &#125;        cout &lt;&lt; two + (one + 1) &#x2F; 2 &lt;&lt; endl;    &#125;    return 0;&#125;</code></pre></div></figure><h1 id="d-circular-spanning-tree"><a class="markdownIt-Anchor" href="#d-circular-spanning-tree"></a> D. Circular Spanning Tree</h1><h2 id="题目解析-4"><a class="markdownIt-Anchor" href="#题目解析-4"></a> 题目解析</h2><p>节点总数是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">n</span></span></span></span> 。</p><p><strong>首先分析全为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0</mn></mrow><annotation encoding="application/x-tex">0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span> 和全为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> 的情况。</strong></p><p>如果全为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0</mn></mrow><annotation encoding="application/x-tex">0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span> ，每个节点都需要有偶数个节点和它相连，又因为叶子节点只有 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> 个相连的节点，所以没有叶子节点，所以不存在。</p><p>如果全为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> ，考虑节点的度的总和。如果节点总数是奇数，那么度的总和也是奇数，就无法构成一棵树。<br />如果节点总数是偶数，那我们可以画一个简单的方案，把所有节点都连接起来。</p><p><img src="https://cdn.dianhsu.com/img/2022-05-23-14-30-16.png" alt="红色节点是1" /></p><p>随便选择一个节点，然后把其他的节点都与它相连。因为节点总数是偶数，所以选择的那个节点相连的节点数是奇数（ <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">n - 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.66666em;vertical-align:-0.08333em;"></span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> ）。</p><p><strong>然后既包含 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0</mn></mrow><annotation encoding="application/x-tex">0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span> ，也包含 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> 的情况。</strong></p><p>当然，也需要 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> 的节点数目是偶数个。<br />然后我们可以环形地，把每个 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span>，和它顺时针的 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0</mn></mrow><annotation encoding="application/x-tex">0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span> 先连接起来，并且把每个连接起来的部分，视作一个整体。如下图所示。</p><p><img src="https://cdn.dianhsu.com/img/2022-05-23-14-47-03.png" alt="红色节点是1，蓝色节点是0" /></p><p>然后每个整体都是只有顺时针的最后一个位置不满足条件。这就等于上面分析的全1的情况。<br />我们任意选择一个整体，把它的顺时针最后一个节点，与其他的整体的顺时针最后一个节点相连。</p><p><img src="https://cdn.dianhsu.com/img/2022-05-23-14-46-12.png" alt="红色节点是1，蓝色节点是0" /></p><h2 id="参考代码-4"><a class="markdownIt-Anchor" href="#参考代码-4"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;    fastIO();    int t;    cin &gt;&gt; t;    while(t--)&#123;        int n;        cin &gt;&gt; n;        string s;        cin &gt;&gt; s;        int cnt &#x3D; 0;        for(int i &#x3D; 0; i &lt; n; ++i)&#123;            if(s[i] &#x3D;&#x3D; &#39;1&#39;) ++ cnt;        &#125;        if(cnt % 2 &#x3D;&#x3D; 1 or cnt &#x3D;&#x3D; 0)&#123;            cout &lt;&lt; &quot;NO\n&quot;;            continue;        &#125;        if(cnt &#x3D;&#x3D; n)&#123;            cout &lt;&lt; &quot;YES\n&quot;;            for(int i &#x3D; 2; i &lt;&#x3D; n; ++i)&#123;                cout &lt;&lt; 1 &lt;&lt; &quot; &quot; &lt;&lt; i &lt;&lt; &quot;\n&quot;;            &#125;            continue;        &#125;        cout &lt;&lt; &quot;YES\n&quot;;        vector&lt;PII&gt; ans;        vector&lt;int&gt; ones;        for(int i &#x3D; 0; i &lt; n; ++i)&#123;            if(s[i] &#x3D;&#x3D; &#39;1&#39;)&#123;                ones.push_back(i);            &#125;        &#125;        vector&lt;int&gt; backs;        for(auto&amp; it: ones)&#123;            int rb &#x3D; it;            while(s[(rb + 1) % n] &#x3D;&#x3D; &#39;0&#39;)&#123;                ans.push_back(&#123;rb, (rb + 1) % n&#125;);                rb &#x3D; (rb + 1) % n;            &#125;            backs.push_back(rb);        &#125;        for(auto&amp; it: backs)&#123;            if(it !&#x3D; backs.front())&#123;                ans.push_back(&#123;backs.front(), it&#125;);            &#125;        &#125;        for(auto&amp; it: ans)&#123;            cout &lt;&lt; it.first + 1 &lt;&lt; &quot; &quot; &lt;&lt; it.second + 1 &lt;&lt; &quot;\n&quot;;        &#125;    &#125;    return 0;&#125;</code></pre></div></figure>]]>
      </content:encoded>
    </item>
    <item>
      <title>Codeforces Round 792 (Div. 1 + Div. 2)</title>
      <link>https://www.dianhsu.com/2022/05/20/cf1684/</link>
      <description>
        <![CDATA[<h1 id="a-digit-minimization"><a class="markdownIt-Anchor" href="#a-digit-minimization"></a> A. Digit Minimization</h1>
<h2 id="题目大意"><a]]>
      </description>
      <author>Dian Hsu</author>
      <category domain="https://www.dianhsu.com/categories/Codeforces/">Codeforces</category>
      <category domain="https://www.dianhsu.com/tags/%E7%AE%97%E6%B3%95/">算法</category>
      <category domain="https://www.dianhsu.com/tags/Codeforces/">Codeforces</category>
      <pubDate>Fri, 20 May 2022 00:38:24 GMT</pubDate>
      <content:encoded>
        <![CDATA[<h1 id="a-digit-minimization"><a class="markdownIt-Anchor" href="#a-digit-minimization"></a> A. Digit Minimization</h1><h2 id="题目大意"><a class="markdownIt-Anchor" href="#题目大意"></a> 题目大意</h2><p>给你一个十进制表示中不包含<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0</mn></mrow><annotation encoding="application/x-tex">0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span>的数<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>s</mi></mrow><annotation encoding="application/x-tex">s</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">s</span></span></span></span>，Alice可以选择交换两个不同位置的数，Bob删除十进制末尾的数，直到剩下的数字只有一个。</p><p>问最后剩下的数字，最小是多少？</p><h2 id="题目解析"><a class="markdownIt-Anchor" href="#题目解析"></a> 题目解析</h2><p>这个题首先是分析数字的个数是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> 到 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>3</mn></mrow><annotation encoding="application/x-tex">3</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">3</span></span></span></span> 的情况，然后将更多数字的情况转化到之前已有的情况当中。</p><ul><li>当数字的个数是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> 的时候，结果就是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>s</mi><mn>0</mn></msub></mrow><annotation encoding="application/x-tex">s_0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 。</li><li>当数字的个数是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>2</mn></mrow><annotation encoding="application/x-tex">2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">2</span></span></span></span> 的时候，因为必须进行一次交换 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>s</mi><mn>0</mn></msub><mo>↔</mo><msub><mi>s</mi><mn>1</mn></msub></mrow><annotation encoding="application/x-tex">s_0 \leftrightarrow s_1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">↔</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> ，所以结果就是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>s</mi><mn>1</mn></msub></mrow><annotation encoding="application/x-tex">s_1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>。</li><li>当数字的个数是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>3</mn></mrow><annotation encoding="application/x-tex">3</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">3</span></span></span></span> 的时候，可以取到 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>s</mi><mn>0</mn></msub><mo separator="true">,</mo><msub><mi>s</mi><mn>1</mn></msub><mo separator="true">,</mo><msub><mi>s</mi><mn>2</mn></msub></mrow><annotation encoding="application/x-tex">s_0, s_1, s_2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 中的最小值。<ul><li>假如最小值是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>s</mi><mn>0</mn></msub></mrow><annotation encoding="application/x-tex">s_0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>，第一步可以交换 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>s</mi><mn>0</mn></msub><mo separator="true">,</mo><msub><mi>s</mi><mn>1</mn></msub></mrow><annotation encoding="application/x-tex">s_0, s_1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>，第二步再交换 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>s</mi><mn>0</mn></msub><mo separator="true">,</mo><msub><mi>s</mi><mn>1</mn></msub></mrow><annotation encoding="application/x-tex">s_0, s_1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>。</li><li>假如最小值是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>s</mi><mn>1</mn></msub></mrow><annotation encoding="application/x-tex">s_1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>，第一步可以交换 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>s</mi><mn>0</mn></msub><mo separator="true">,</mo><msub><mi>s</mi><mn>2</mn></msub></mrow><annotation encoding="application/x-tex">s_0, s_2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>，第二步再交换 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>s</mi><mn>0</mn></msub><mo separator="true">,</mo><msub><mi>s</mi><mn>1</mn></msub></mrow><annotation encoding="application/x-tex">s_0, s_1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>。</li><li>假如最小值是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>s</mi><mn>2</mn></msub></mrow><annotation encoding="application/x-tex">s_2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>，第一步可以交换 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>s</mi><mn>1</mn></msub><mo separator="true">,</mo><msub><mi>s</mi><mn>2</mn></msub></mrow><annotation encoding="application/x-tex">s_1, s_2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>，第二步再交换 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>s</mi><mn>0</mn></msub><mo separator="true">,</mo><msub><mi>s</mi><mn>1</mn></msub></mrow><annotation encoding="application/x-tex">s_0, s_1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>。</li></ul></li><li>当数字个数大于 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>3</mn></mrow><annotation encoding="application/x-tex">3</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">3</span></span></span></span> 的时候，如果最小的数字不在前 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>3</mn></mrow><annotation encoding="application/x-tex">3</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">3</span></span></span></span> 的位置，可以先将最小的数字转移到前 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>3</mn></mrow><annotation encoding="application/x-tex">3</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">3</span></span></span></span> 的位置，然后如果长度还是大于 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>3</mn></mrow><annotation encoding="application/x-tex">3</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">3</span></span></span></span> 的话，可以将 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>s</mi><mn>0</mn></msub><mo separator="true">,</mo><msub><mi>s</mi><mn>1</mn></msub></mrow><annotation encoding="application/x-tex">s_0, s_1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 进行交换，那么转移到长度为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>3</mn></mrow><annotation encoding="application/x-tex">3</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">3</span></span></span></span> 的时候，确保最小值在这 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>3</mn></mrow><annotation encoding="application/x-tex">3</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">3</span></span></span></span> 个位置当中，那么一定能够取得最小值。</li></ul><h2 id="参考代码"><a class="markdownIt-Anchor" href="#参考代码"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;    int t;    cin &gt;&gt; t;    while(t--)&#123;        string s;        cin &gt;&gt; s;        if(s.length() &#x3D;&#x3D; 1) cout &lt;&lt; s[0] &lt;&lt; endl;        else if(s.length() &#x3D;&#x3D; 2) cout &lt;&lt; s[1] &lt;&lt; endl;        else cout &lt;&lt; *min_element(itr(s)) &lt;&lt; endl;    &#125;    return 0;&#125;</code></pre></div></figure><h1 id="b-z-mod-x-c"><a class="markdownIt-Anchor" href="#b-z-mod-x-c"></a> B. Z mod X = C</h1><h2 id="题目大意-2"><a class="markdownIt-Anchor" href="#题目大意-2"></a> 题目大意</h2><p>已知 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>a</mi><mo separator="true">,</mo><mi>b</mi><mo separator="true">,</mo><mi>c</mi><mo stretchy="false">(</mo><mi>a</mi><mo>&lt;</mo><mi>b</mi><mo>&lt;</mo><mi>c</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">a, b, c (a &lt; b &lt; c)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">a</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal">b</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal">c</span><span class="mopen">(</span><span class="mord mathnormal">a</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">&lt;</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.73354em;vertical-align:-0.0391em;"></span><span class="mord mathnormal">b</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">&lt;</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">c</span><span class="mclose">)</span></span></span></span> ，且<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi><mo separator="true">,</mo><mi>y</mi><mo separator="true">,</mo><mi>z</mi></mrow><annotation encoding="application/x-tex">x, y, z</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">x</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.04398em;">z</span></span></span></span>满足以下条件：</p><p class='katex-block'><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mo fence="true">{</mo><mtable rowspacing="0.15999999999999992em" columnspacing="1em"><mtr><mtd><mstyle scriptlevel="0" displaystyle="false"><mrow><mi>x</mi><mtext> </mtext><mo lspace="0.22em" rspace="0.22em"><mrow><mi mathvariant="normal">m</mi><mi mathvariant="normal">o</mi><mi mathvariant="normal">d</mi></mrow></mo><mtext> </mtext><mi>y</mi><mo>=</mo><mi>a</mi></mrow></mstyle></mtd></mtr><mtr><mtd><mstyle scriptlevel="0" displaystyle="false"><mrow><mi>y</mi><mtext> </mtext><mo lspace="0.22em" rspace="0.22em"><mrow><mi mathvariant="normal">m</mi><mi mathvariant="normal">o</mi><mi mathvariant="normal">d</mi></mrow></mo><mtext> </mtext><mi>z</mi><mo>=</mo><mi>b</mi></mrow></mstyle></mtd></mtr><mtr><mtd><mstyle scriptlevel="0" displaystyle="false"><mrow><mi>z</mi><mtext> </mtext><mo lspace="0.22em" rspace="0.22em"><mrow><mi mathvariant="normal">m</mi><mi mathvariant="normal">o</mi><mi mathvariant="normal">d</mi></mrow></mo><mtext> </mtext><mi>x</mi><mo>=</mo><mi>c</mi></mrow></mstyle></mtd></mtr></mtable></mrow><annotation encoding="application/x-tex">\left\{\begin{matrix}x \bmod y = a\\ y \bmod z = b\\z \bmod x = c\end{matrix}\right.</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:3.60004em;vertical-align:-1.55002em;"></span><span class="minner"><span class="mopen"><span class="delimsizing mult"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:2.05002em;"><span style="top:-2.49999em;"><span class="pstrut" style="height:3.15em;"></span><span class="delimsizinginner delim-size4"><span>⎩</span></span></span><span style="top:-2.20499em;"><span class="pstrut" style="height:3.15em;"></span><span class="delimsizinginner delim-size4"><span>⎪</span></span></span><span style="top:-3.15001em;"><span class="pstrut" style="height:3.15em;"></span><span class="delimsizinginner delim-size4"><span>⎨</span></span></span><span style="top:-4.00501em;"><span class="pstrut" style="height:3.15em;"></span><span class="delimsizinginner delim-size4"><span>⎪</span></span></span><span style="top:-4.30002em;"><span class="pstrut" style="height:3.15em;"></span><span class="delimsizinginner delim-size4"><span>⎧</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.55002em;"><span></span></span></span></span></span></span><span class="mord"><span class="mtable"><span class="col-align-c"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:2.05em;"><span style="top:-4.21em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin"><span class="mord"><span class="mord mathrm">m</span><span class="mord mathrm">o</span><span class="mord mathrm">d</span></span></span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mord mathnormal">a</span></span></span><span style="top:-3.0099999999999993em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin"><span class="mord"><span class="mord mathrm">m</span><span class="mord mathrm">o</span><span class="mord mathrm">d</span></span></span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mord mathnormal" style="margin-right:0.04398em;">z</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mord mathnormal">b</span></span></span><span style="top:-1.8099999999999994em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.04398em;">z</span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin"><span class="mord"><span class="mord mathrm">m</span><span class="mord mathrm">o</span><span class="mord mathrm">d</span></span></span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mord mathnormal">x</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mord mathnormal">c</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.5500000000000007em;"><span></span></span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span></span></span></span></span></p><p>对于每组给定的 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>a</mi><mo separator="true">,</mo><mi>b</mi><mo separator="true">,</mo><mi>c</mi></mrow><annotation encoding="application/x-tex">a, b, c</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">a</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal">b</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal">c</span></span></span></span>， 构造一组 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi><mo separator="true">,</mo><mi>y</mi><mo separator="true">,</mo><mi>z</mi></mrow><annotation encoding="application/x-tex">x, y, z</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">x</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.04398em;">z</span></span></span></span> 满足上述条件。</p><h2 id="题目解析-2"><a class="markdownIt-Anchor" href="#题目解析-2"></a> 题目解析</h2><p>把三个式子用公式表示，如下所示：</p><p class='katex-block'><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mo fence="true">{</mo><mtable rowspacing="0.15999999999999992em" columnspacing="1em"><mtr><mtd><mstyle scriptlevel="0" displaystyle="false"><mrow><mi>x</mi><mo>=</mo><msub><mi>k</mi><mn>1</mn></msub><mo>∗</mo><mi>y</mi><mo>+</mo><mi>a</mi></mrow></mstyle></mtd></mtr><mtr><mtd><mstyle scriptlevel="0" displaystyle="false"><mrow><mi>y</mi><mo>=</mo><msub><mi>k</mi><mn>2</mn></msub><mo>∗</mo><mi>z</mi><mo>+</mo><mi>b</mi></mrow></mstyle></mtd></mtr><mtr><mtd><mstyle scriptlevel="0" displaystyle="false"><mrow><mi>z</mi><mo>=</mo><msub><mi>k</mi><mn>3</mn></msub><mo>∗</mo><mi>x</mi><mo>+</mo><mi>c</mi></mrow></mstyle></mtd></mtr></mtable></mrow><annotation encoding="application/x-tex">\left\{\begin{matrix}x = k_1 * y + a\\y = k_2 * z + b\\z = k_3 * x + c\end{matrix}\right.</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:3.60004em;vertical-align:-1.55002em;"></span><span class="minner"><span class="mopen"><span class="delimsizing mult"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:2.05002em;"><span style="top:-2.49999em;"><span class="pstrut" style="height:3.15em;"></span><span class="delimsizinginner delim-size4"><span>⎩</span></span></span><span style="top:-2.20499em;"><span class="pstrut" style="height:3.15em;"></span><span class="delimsizinginner delim-size4"><span>⎪</span></span></span><span style="top:-3.15001em;"><span class="pstrut" style="height:3.15em;"></span><span class="delimsizinginner delim-size4"><span>⎨</span></span></span><span style="top:-4.00501em;"><span class="pstrut" style="height:3.15em;"></span><span class="delimsizinginner delim-size4"><span>⎪</span></span></span><span style="top:-4.30002em;"><span class="pstrut" style="height:3.15em;"></span><span class="delimsizinginner delim-size4"><span>⎧</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.55002em;"><span></span></span></span></span></span></span><span class="mord"><span class="mtable"><span class="col-align-c"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:2.05em;"><span style="top:-4.21em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">∗</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mord mathnormal">a</span></span></span><span style="top:-3.0099999999999993em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">∗</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mord mathnormal" style="margin-right:0.04398em;">z</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mord mathnormal">b</span></span></span><span style="top:-1.8099999999999994em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.04398em;">z</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">3</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">∗</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mord mathnormal">x</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mord mathnormal">c</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.5500000000000007em;"><span></span></span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span></span></span></span></span></p><p>由上式可知，如果 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>k</mi><mn>1</mn></msub><mo separator="true">,</mo><msub><mi>k</mi><mn>2</mn></msub><mo separator="true">,</mo><msub><mi>k</mi><mn>3</mn></msub></mrow><annotation encoding="application/x-tex">k_1, k_2, k_3</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">3</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 均大于 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0</mn></mrow><annotation encoding="application/x-tex">0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span>，可得：</p><p class='katex-block'><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mo fence="true">{</mo><mtable rowspacing="0.15999999999999992em" columnspacing="1em"><mtr><mtd><mstyle scriptlevel="0" displaystyle="false"><mrow><mi>x</mi><mo>≥</mo><mi>y</mi></mrow></mstyle></mtd></mtr><mtr><mtd><mstyle scriptlevel="0" displaystyle="false"><mrow><mi>y</mi><mo>≥</mo><mi>z</mi></mrow></mstyle></mtd></mtr><mtr><mtd><mstyle scriptlevel="0" displaystyle="false"><mrow><mi>z</mi><mo>≥</mo><mi>x</mi></mrow></mstyle></mtd></mtr></mtable></mrow><annotation encoding="application/x-tex">\left\{\begin{matrix}x \geq y \\y \geq z \\z \geq x\end{matrix}\right.</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:3.60004em;vertical-align:-1.55002em;"></span><span class="minner"><span class="mopen"><span class="delimsizing mult"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:2.05002em;"><span style="top:-2.49999em;"><span class="pstrut" style="height:3.15em;"></span><span class="delimsizinginner delim-size4"><span>⎩</span></span></span><span style="top:-2.20499em;"><span class="pstrut" style="height:3.15em;"></span><span class="delimsizinginner delim-size4"><span>⎪</span></span></span><span style="top:-3.15001em;"><span class="pstrut" style="height:3.15em;"></span><span class="delimsizinginner delim-size4"><span>⎨</span></span></span><span style="top:-4.00501em;"><span class="pstrut" style="height:3.15em;"></span><span class="delimsizinginner delim-size4"><span>⎪</span></span></span><span style="top:-4.30002em;"><span class="pstrut" style="height:3.15em;"></span><span class="delimsizinginner delim-size4"><span>⎧</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.55002em;"><span></span></span></span></span></span></span><span class="mord"><span class="mtable"><span class="col-align-c"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:2.05em;"><span style="top:-4.21em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">≥</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mord mathnormal" style="margin-right:0.03588em;">y</span></span></span><span style="top:-3.0099999999999993em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">≥</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mord mathnormal" style="margin-right:0.04398em;">z</span></span></span><span style="top:-1.8099999999999994em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.04398em;">z</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">≥</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mord mathnormal">x</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.5500000000000007em;"><span></span></span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span></span></span></span></span></p><p>那么 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi><mo>=</mo><mi>y</mi><mo>=</mo><mi>z</mi></mrow><annotation encoding="application/x-tex">x = y = z</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">x</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.19444em;"></span><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal" style="margin-right:0.04398em;">z</span></span></span></span>，此时 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>a</mi><mo>=</mo><mi>b</mi><mo>=</mo><mi>c</mi><mo>=</mo><mn>0</mn></mrow><annotation encoding="application/x-tex">a = b = c = 0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">a</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal">b</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">c</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span>，不符合题意。<br />由此 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>k</mi><mn>1</mn></msub><mo separator="true">,</mo><msub><mi>k</mi><mn>2</mn></msub><mo separator="true">,</mo><msub><mi>k</mi><mn>3</mn></msub></mrow><annotation encoding="application/x-tex">k_1, k_2, k_3</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">3</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 当中至少有一个数是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0</mn></mrow><annotation encoding="application/x-tex">0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span>。<br />由此我们有 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>k</mi><mn>1</mn></msub><msub><mi>k</mi><mn>2</mn></msub><msub><mi>k</mi><mn>3</mn></msub><mo>=</mo><mn>0</mn></mrow><annotation encoding="application/x-tex">k_1k_2k_3 = 0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">3</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span>。</p><p>把第三个式子带入第二个，<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>y</mi><mo>=</mo><msub><mi>k</mi><mn>2</mn></msub><msub><mi>k</mi><mn>3</mn></msub><mi>x</mi><mo>+</mo><msub><mi>k</mi><mn>2</mn></msub><mi>c</mi><mo>+</mo><mi>b</mi></mrow><annotation encoding="application/x-tex">y = k_2k_3x + k_2c + b</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.19444em;"></span><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">3</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mord mathnormal">x</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mord mathnormal">c</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal">b</span></span></span></span><br />然后在把这个式子带入到第一个式子当中</p><p class='katex-block'><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>x</mi><mo>=</mo><msub><mi>k</mi><mn>1</mn></msub><msub><mi>k</mi><mn>2</mn></msub><msub><mi>k</mi><mn>3</mn></msub><mi>x</mi><mo>+</mo><msub><mi>k</mi><mn>1</mn></msub><msub><mi>k</mi><mn>2</mn></msub><mi>c</mi><mo>+</mo><msub><mi>k</mi><mn>1</mn></msub><mi>b</mi><mo>+</mo><mi>a</mi></mrow><annotation encoding="application/x-tex">x = k_1k_2k_3x + k_1k_2c + k_1b + a</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">x</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">3</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mord mathnormal">x</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mord mathnormal">c</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mord mathnormal">b</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">a</span></span></span></span></span></p><p>由此，<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi><mo>=</mo><msub><mi>k</mi><mn>1</mn></msub><msub><mi>k</mi><mn>2</mn></msub><mi>c</mi><mo>+</mo><msub><mi>k</mi><mn>1</mn></msub><mi>b</mi><mo>+</mo><mi>a</mi></mrow><annotation encoding="application/x-tex">x = k_1k_2c + k_1b + a</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">x</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mord mathnormal">c</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mord mathnormal">b</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">a</span></span></span></span></p><p>设 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>k</mi><mn>1</mn></msub><mo separator="true">,</mo><msub><mi>k</mi><mn>2</mn></msub></mrow><annotation encoding="application/x-tex">k_1, k_2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03148em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 均等于 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span>。（当然构造其他正整数也可以）</p><p class='katex-block'><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mo fence="true">{</mo><mtable rowspacing="0.15999999999999992em" columnspacing="1em"><mtr><mtd><mstyle scriptlevel="0" displaystyle="false"><mrow><mi>x</mi><mo>=</mo><mi>a</mi><mo>+</mo><mi>b</mi><mo>+</mo><mi>c</mi></mrow></mstyle></mtd></mtr><mtr><mtd><mstyle scriptlevel="0" displaystyle="false"><mrow><mi>y</mi><mo>=</mo><mi>b</mi><mo>+</mo><mi>c</mi></mrow></mstyle></mtd></mtr><mtr><mtd><mstyle scriptlevel="0" displaystyle="false"><mrow><mi>z</mi><mo>=</mo><mi>c</mi></mrow></mstyle></mtd></mtr></mtable></mrow><annotation encoding="application/x-tex">\left\{\begin{matrix}x = a + b + c \\y = b + c \\z = c\end{matrix}\right.</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:3.60004em;vertical-align:-1.55002em;"></span><span class="minner"><span class="mopen"><span class="delimsizing mult"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:2.05002em;"><span style="top:-2.49999em;"><span class="pstrut" style="height:3.15em;"></span><span class="delimsizinginner delim-size4"><span>⎩</span></span></span><span style="top:-2.20499em;"><span class="pstrut" style="height:3.15em;"></span><span class="delimsizinginner delim-size4"><span>⎪</span></span></span><span style="top:-3.15001em;"><span class="pstrut" style="height:3.15em;"></span><span class="delimsizinginner delim-size4"><span>⎨</span></span></span><span style="top:-4.00501em;"><span class="pstrut" style="height:3.15em;"></span><span class="delimsizinginner delim-size4"><span>⎪</span></span></span><span style="top:-4.30002em;"><span class="pstrut" style="height:3.15em;"></span><span class="delimsizinginner delim-size4"><span>⎧</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.55002em;"><span></span></span></span></span></span></span><span class="mord"><span class="mtable"><span class="col-align-c"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:2.05em;"><span style="top:-4.21em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mord mathnormal">a</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mord mathnormal">b</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mord mathnormal">c</span></span></span><span style="top:-3.0099999999999993em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mord mathnormal">b</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mord mathnormal">c</span></span></span><span style="top:-1.8099999999999994em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.04398em;">z</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mord mathnormal">c</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.5500000000000007em;"><span></span></span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span></span></span></span></span></p><h2 id="参考代码-2"><a class="markdownIt-Anchor" href="#参考代码-2"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;    int t;    cin &gt;&gt; t;    while(t--)&#123;        ll a, b, c;        cin &gt;&gt; a &gt;&gt; b &gt;&gt; c;        ll x &#x3D;  a + b + c, y &#x3D; b + c, z &#x3D; c;        cout &lt;&lt; x &lt;&lt; &quot; &quot;&lt;&lt; y &lt;&lt; &quot; &quot;  &lt;&lt; z &lt;&lt; endl;     &#125;    return 0;&#125;</code></pre></div></figure><h1 id="c-column-swapping"><a class="markdownIt-Anchor" href="#c-column-swapping"></a> C. Column Swapping</h1><h2 id="题目大意-3"><a class="markdownIt-Anchor" href="#题目大意-3"></a> 题目大意</h2><p>给你一个 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">n</span></span></span></span> 行 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>m</mi></mrow><annotation encoding="application/x-tex">m</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">m</span></span></span></span> 列的格子，你可以选择两列，交换这两列中每一行的两个数字，使其满足每行满足从左到右不递减。</p><h2 id="题目解析-3"><a class="markdownIt-Anchor" href="#题目解析-3"></a> 题目解析</h2><p>把原本的数据<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>a</mi><mi>r</mi><mi>r</mi></mrow><annotation encoding="application/x-tex">arr</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">a</span><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="mord mathnormal" style="margin-right:0.02778em;">r</span></span></span></span>拷贝一份<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>b</mi><mi>r</mi><mi>r</mi></mrow><annotation encoding="application/x-tex">brr</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal">b</span><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="mord mathnormal" style="margin-right:0.02778em;">r</span></span></span></span>，然后排序拷贝数据<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>b</mi><mi>r</mi><mi>r</mi></mrow><annotation encoding="application/x-tex">brr</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal">b</span><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="mord mathnormal" style="margin-right:0.02778em;">r</span></span></span></span>中的每一行。<br />比较第<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.65952em;vertical-align:0em;"></span><span class="mord mathnormal">i</span></span></span></span>行第<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>j</mi></mrow><annotation encoding="application/x-tex">j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.85396em;vertical-align:-0.19444em;"></span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span></span></span></span>列中<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>a</mi><mi>r</mi><msub><mi>r</mi><mrow><mi>i</mi><mi>j</mi></mrow></msub></mrow><annotation encoding="application/x-tex">arr_{ij}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.716668em;vertical-align:-0.286108em;"></span><span class="mord mathnormal">a</span><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.311664em;"><span style="top:-2.5500000000000003em;margin-left:-0.02778em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">i</span><span class="mord mathnormal mtight" style="margin-right:0.05724em;">j</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></span></span></span></span>和<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>b</mi><mi>r</mi><msub><mi>r</mi><mrow><mi>i</mi><mi>j</mi></mrow></msub></mrow><annotation encoding="application/x-tex">brr_{ij}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.980548em;vertical-align:-0.286108em;"></span><span class="mord mathnormal">b</span><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.311664em;"><span style="top:-2.5500000000000003em;margin-left:-0.02778em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">i</span><span class="mord mathnormal mtight" style="margin-right:0.05724em;">j</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.286108em;"><span></span></span></span></span></span></span></span></span></span>是否相同。如果不同，就代表第<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>j</mi></mrow><annotation encoding="application/x-tex">j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.85396em;vertical-align:-0.19444em;"></span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span></span></span></span>列经过了交换。</p><p>然后讨论一下经过交换的列的数目：</p><ul><li>经过交换的列的数目是<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0</mn></mrow><annotation encoding="application/x-tex">0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span>，那么直接输出两个相同的列就可以了。</li><li>经过交换的列的数目是<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span>，不存在这样的情况。</li><li>经过交换的列的数目是<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>2</mn></mrow><annotation encoding="application/x-tex">2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">2</span></span></span></span>，尝试在原本的<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>a</mi><mi>r</mi><mi>r</mi></mrow><annotation encoding="application/x-tex">arr</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">a</span><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="mord mathnormal" style="margin-right:0.02778em;">r</span></span></span></span>中交换这两列，然后比较是否是和<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>b</mi><mi>r</mi><mi>r</mi></mrow><annotation encoding="application/x-tex">brr</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal">b</span><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="mord mathnormal" style="margin-right:0.02778em;">r</span></span></span></span>一致。</li><li>经过交换的列的数目大于<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>2</mn></mrow><annotation encoding="application/x-tex">2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">2</span></span></span></span>，这样的情况不能再交换两列的情况下完成。</li></ul><h2 id="参考代码-3"><a class="markdownIt-Anchor" href="#参考代码-3"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;    int t;    cin &gt;&gt; t;    while(t--)&#123;        int n, m;        cin &gt;&gt; n &gt;&gt; m;        vector arr(n, vector&lt;int&gt;(m, 0));        for(auto&amp; row: arr) for(auto&amp; it: row) cin &gt;&gt; it;        vector brr(arr);        for(auto&amp; row: brr)&#123;            sort(itr(row));        &#125;        map&lt;int, int&gt; mp;        for(int i &#x3D; 0; i &lt; n; ++i)&#123;            for(int j &#x3D; 0; j &lt; m; ++j)&#123;                if(brr[i][j] !&#x3D; arr[i][j])&#123;                    mp[j]++;                &#125;            &#125;        &#125;        if(mp.size() &lt; 2)&#123;            cout &lt;&lt; 1 &lt;&lt; &quot; &quot; &lt;&lt; 1 &lt;&lt; endl;        &#125;else if(mp.size() &#x3D;&#x3D; 2)&#123;            int x &#x3D; mp.begin()-&gt;first, y &#x3D; mp.rbegin()-&gt;first;            for(auto&amp; row: arr) swap(row[x], row[y]);            bool ok &#x3D; true;            for(int i &#x3D; 0; i &lt; n and ok; ++i)&#123;                for(int j &#x3D; 0; j &lt; m and ok; ++j)&#123;                    if(arr[i][j] !&#x3D; brr[i][j])&#123;                        ok &#x3D; false;                    &#125;                &#125;            &#125;            if(ok) cout &lt;&lt; x + 1 &lt;&lt; &quot; &quot; &lt;&lt; y + 1 &lt;&lt; endl;            else cout &lt;&lt; -1 &lt;&lt; endl;        &#125;else&#123;            cout &lt;&lt; -1 &lt;&lt; endl;        &#125;    &#125;    return 0;&#125;</code></pre></div></figure>]]>
      </content:encoded>
    </item>
    <item>
      <title>Codeforces Round 791 (Div. 2)</title>
      <link>https://www.dianhsu.com/2022/05/14/cf1679/</link>
      <description>
        <![CDATA[<h1 id="a-avtobus"><a class="markdownIt-Anchor" href="#a-avtobus"></a> A. AvtoBus</h1>
<h2 id="题目大意"><a class="markdownIt-Anchor"]]>
      </description>
      <author>Dian Hsu</author>
      <category domain="https://www.dianhsu.com/categories/Codeforces/">Codeforces</category>
      <category domain="https://www.dianhsu.com/tags/%E7%AE%97%E6%B3%95/">算法</category>
      <category domain="https://www.dianhsu.com/tags/Codeforces/">Codeforces</category>
      <category domain="https://www.dianhsu.com/tags/%E4%BA%8C%E5%88%86/">二分</category>
      <category domain="https://www.dianhsu.com/tags/%E7%BA%BF%E6%AE%B5%E6%A0%91/">线段树</category>
      <category domain="https://www.dianhsu.com/tags/%E6%A0%91%E7%8A%B6%E6%95%B0%E7%BB%84/">树状数组</category>
      <category domain="https://www.dianhsu.com/tags/%E6%8B%93%E6%89%91%E6%8E%92%E5%BA%8F/">拓扑排序</category>
      <pubDate>Sat, 14 May 2022 11:58:36 GMT</pubDate>
      <content:encoded>
        <![CDATA[<h1 id="a-avtobus"><a class="markdownIt-Anchor" href="#a-avtobus"></a> A. AvtoBus</h1><h2 id="题目大意"><a class="markdownIt-Anchor" href="#题目大意"></a> 题目大意</h2><p>巴士车队的所有巴士总共拥有 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">n</span></span></span></span> 只轮胎，巴士车队有两种巴士，一种是4只轮胎的，一种是6只轮胎的。</p><p>问这个车队拥有的巴士数量的最小值和最大值。不满足输出<code>-1</code>。</p><h2 id="题目解析"><a class="markdownIt-Anchor" href="#题目解析"></a> 题目解析</h2><p>首先判断是否满足，可以观察发现轮子数量需要满足以下两个条件：</p><ul><li>轮子数量必须是偶数</li><li>轮子数量不小于<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn></mrow><annotation encoding="application/x-tex">4</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">4</span></span></span></span></li></ul><p><strong>首先来计算满足条件的最大值。</strong> 为了能让巴士车队的巴士数目最多，那么轮子数目为<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn></mrow><annotation encoding="application/x-tex">4</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">4</span></span></span></span>的巴士越多越好。</p><p class='katex-block'><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>C</mi><mi>n</mi><msub><mi>t</mi><mrow><mi>c</mi><mi>a</mi><mi>r</mi><mi>s</mi></mrow></msub><mo>=</mo><mfrac><mi>n</mi><mn>4</mn></mfrac></mrow><annotation encoding="application/x-tex">Cnt_{cars} = \frac{n}{4}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.83333em;vertical-align:-0.15em;"></span><span class="mord mathnormal" style="margin-right:0.07153em;">C</span><span class="mord mathnormal">n</span><span class="mord"><span class="mord mathnormal">t</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">c</span><span class="mord mathnormal mtight">a</span><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span><span class="mord mathnormal mtight">s</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1.7935600000000003em;vertical-align:-0.686em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.10756em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">4</span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal">n</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span></span></span></span></span></p><p>如果<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mtext> </mtext><mo lspace="0.22em" rspace="0.22em"><mrow><mi mathvariant="normal">m</mi><mi mathvariant="normal">o</mi><mi mathvariant="normal">d</mi></mrow></mo><mtext> </mtext><mn>4</mn><mo>=</mo><mn>0</mn></mrow><annotation encoding="application/x-tex">n \bmod 4 = 0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin"><span class="mord"><span class="mord mathrm">m</span><span class="mord mathrm">o</span><span class="mord mathrm">d</span></span></span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">4</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span>，就刚好能满足情况。<br />如果<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mtext> </mtext><mo lspace="0.22em" rspace="0.22em"><mrow><mi mathvariant="normal">m</mi><mi mathvariant="normal">o</mi><mi mathvariant="normal">d</mi></mrow></mo><mtext> </mtext><mn>4</mn><mo>=</mo><mn>2</mn></mrow><annotation encoding="application/x-tex">n \bmod 4 = 2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin"><span class="mord"><span class="mord mathrm">m</span><span class="mord mathrm">o</span><span class="mord mathrm">d</span></span></span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">4</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">2</span></span></span></span>，那么 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn></mrow><annotation encoding="application/x-tex">4</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">4</span></span></span></span> 只轮子的巴士数目是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mfrac><mi>n</mi><mn>4</mn></mfrac><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">\frac{n}{4} - 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.040392em;vertical-align:-0.345em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.695392em;"><span style="top:-2.6550000000000002em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">4</span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.394em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> ，<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>6</mn></mrow><annotation encoding="application/x-tex">6</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">6</span></span></span></span> 只轮子的巴士数目是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> ，巴士总数是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mfrac><mi>n</mi><mn>4</mn></mfrac></mrow><annotation encoding="application/x-tex">\frac{n}{4}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.040392em;vertical-align:-0.345em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.695392em;"><span style="top:-2.6550000000000002em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">4</span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.394em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span></span></span></span> 。</p><p><strong>然后来计算满足条件的最小值。</strong> 这里我们希望轮子数目为6的巴士数目越多越好。</p><p class='katex-block'><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>C</mi><mi>n</mi><msub><mi>t</mi><mrow><mi>c</mi><mi>a</mi><mi>r</mi><mi>s</mi></mrow></msub><mo>=</mo><mfrac><mi>n</mi><mn>6</mn></mfrac></mrow><annotation encoding="application/x-tex">  Cnt_{cars} = \frac{n}{6}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.83333em;vertical-align:-0.15em;"></span><span class="mord mathnormal" style="margin-right:0.07153em;">C</span><span class="mord mathnormal">n</span><span class="mord"><span class="mord mathnormal">t</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">c</span><span class="mord mathnormal mtight">a</span><span class="mord mathnormal mtight" style="margin-right:0.02778em;">r</span><span class="mord mathnormal mtight">s</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1.7935600000000003em;vertical-align:-0.686em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.10756em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">6</span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal">n</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span></span></span></span></span></p><p>如果<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mtext> </mtext><mo lspace="0.22em" rspace="0.22em"><mrow><mi mathvariant="normal">m</mi><mi mathvariant="normal">o</mi><mi mathvariant="normal">d</mi></mrow></mo><mtext> </mtext><mn>6</mn><mo>=</mo><mn>0</mn></mrow><annotation encoding="application/x-tex">n \bmod 6 = 0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin"><span class="mord"><span class="mord mathrm">m</span><span class="mord mathrm">o</span><span class="mord mathrm">d</span></span></span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">6</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span>，那么刚好能全部都是6个轮子的巴士。<br />如果<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mtext> </mtext><mo lspace="0.22em" rspace="0.22em"><mrow><mi mathvariant="normal">m</mi><mi mathvariant="normal">o</mi><mi mathvariant="normal">d</mi></mrow></mo><mtext> </mtext><mn>6</mn><mo>=</mo><mn>2</mn></mrow><annotation encoding="application/x-tex">n \bmod 6 = 2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin"><span class="mord"><span class="mord mathrm">m</span><span class="mord mathrm">o</span><span class="mord mathrm">d</span></span></span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">6</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">2</span></span></span></span>，那么 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>6</mn></mrow><annotation encoding="application/x-tex">6</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">6</span></span></span></span> 只轮子的巴士的数目是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mfrac><mi>n</mi><mn>6</mn></mfrac><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">\frac{n}{6} - 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.040392em;vertical-align:-0.345em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.695392em;"><span style="top:-2.6550000000000002em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">6</span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.394em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> ，<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn></mrow><annotation encoding="application/x-tex">4</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">4</span></span></span></span> 个轮子的巴士的数目是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>2</mn></mrow><annotation encoding="application/x-tex">2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">2</span></span></span></span> ，巴士总数是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mfrac><mi>n</mi><mn>6</mn></mfrac><mo>+</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">\frac{n}{6} + 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.040392em;vertical-align:-0.345em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.695392em;"><span style="top:-2.6550000000000002em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">6</span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.394em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> 。<br />如果<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mtext> </mtext><mo lspace="0.22em" rspace="0.22em"><mrow><mi mathvariant="normal">m</mi><mi mathvariant="normal">o</mi><mi mathvariant="normal">d</mi></mrow></mo><mtext> </mtext><mn>6</mn><mo>=</mo><mn>4</mn></mrow><annotation encoding="application/x-tex">n \bmod 6 = 4</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin"><span class="mord"><span class="mord mathrm">m</span><span class="mord mathrm">o</span><span class="mord mathrm">d</span></span></span><span class="mspace" style="margin-right:0.05555555555555555em;"></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">6</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">4</span></span></span></span>，那么 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>6</mn></mrow><annotation encoding="application/x-tex">6</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">6</span></span></span></span> 只轮子的巴士的数目是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mfrac><mi>n</mi><mn>6</mn></mfrac></mrow><annotation encoding="application/x-tex">\frac{n}{6}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.040392em;vertical-align:-0.345em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.695392em;"><span style="top:-2.6550000000000002em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">6</span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.394em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span></span></span></span>，<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn></mrow><annotation encoding="application/x-tex">4</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">4</span></span></span></span> 只轮子的巴士数目是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> ，巴士总数是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mfrac><mi>n</mi><mn>6</mn></mfrac><mo>+</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">\frac{n}{6} + 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.040392em;vertical-align:-0.345em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.695392em;"><span style="top:-2.6550000000000002em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">6</span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.394em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> 。</p><h2 id="参考代码"><a class="markdownIt-Anchor" href="#参考代码"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;    int t;    cin &gt;&gt; t;    while(t--)&#123;        ll n;        cin &gt;&gt; n;        if(n % 2 &#x3D;&#x3D; 1 or n &lt; 4) cout &lt;&lt; &quot;-1\n&quot;;        else&#123;            ll maxv &#x3D; n &#x2F; 4;            ll minv &#x3D; n &#x2F; 6;            if(n % 6) minv++;            cout &lt;&lt; minv &lt;&lt; &quot; &quot; &lt;&lt; maxv &lt;&lt; &#39;\n&#39;;        &#125;    &#125;    return 0;&#125;</code></pre></div></figure><h1 id="b-stone-age-problem"><a class="markdownIt-Anchor" href="#b-stone-age-problem"></a> B. Stone Age Problem</h1><h2 id="题目大意-2"><a class="markdownIt-Anchor" href="#题目大意-2"></a> 题目大意</h2><p>对于一个数组，有两种操作方式：</p><ul><li>将第 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.65952em;vertical-align:0em;"></span><span class="mord mathnormal">i</span></span></span></span> 个位置的元素，修改为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi></mrow><annotation encoding="application/x-tex">x</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">x</span></span></span></span>。</li><li>将数组中所有元素修改为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi></mrow><annotation encoding="application/x-tex">x</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">x</span></span></span></span>。</li></ul><p>对于每一次操作，计算数组中元素之和。</p><h2 id="题目解析-2"><a class="markdownIt-Anchor" href="#题目解析-2"></a> 题目解析</h2><p>对于数组中的每个位置，记录上次修改的时间和值。同时记录上次全局修改的时间和值。</p><p>对于操作1，比较 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.65952em;vertical-align:0em;"></span><span class="mord mathnormal">i</span></span></span></span> 位置修改的时间和全局修改的时间，然后选择最新的去获取元素差，从而更新数组中元素之和。</p><p>对于操作2，直接修改全局上次修改时间和值，并更新数组中元素之和。</p><h2 id="参考代码-2"><a class="markdownIt-Anchor" href="#参考代码-2"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;    int n, q;    cin &gt;&gt; n &gt;&gt; q;    PLL pre&#123;-1, 0&#125;; &#x2F;&#x2F; 上次全局修改时间和值    vector&lt;PLL&gt; arr(n + 1, &#123;0, 0&#125;); &#x2F;&#x2F;上次每个位置修改的时间和值    ll sum &#x3D; 0;    for(int i &#x3D; 1; i &lt;&#x3D; n; ++i)&#123;        cin &gt;&gt; arr[i].second;        sum +&#x3D; arr[i].second;    &#125;    ll opx &#x3D; 0;    while(q--)&#123;        ++opx;        int op;        cin &gt;&gt; op;        if(op &#x3D;&#x3D; 1)&#123;            int idx;            ll val;            cin &gt;&gt; idx &gt;&gt; val;            if(pre.first &gt; arr[idx].first)&#123;                sum +&#x3D; val - pre.second;            &#125;else&#123;                sum +&#x3D; val - arr[idx].second;            &#125;            arr[idx] &#x3D; &#123;opx, val&#125;;        &#125;else&#123;            ll val;            cin &gt;&gt; val;            sum &#x3D; val * n;            pre &#x3D; &#123;opx, val&#125;;        &#125;        cout &lt;&lt; sum &lt;&lt; endl;    &#125;    return 0;&#125;</code></pre></div></figure><h1 id="c-rooks-defenders"><a class="markdownIt-Anchor" href="#c-rooks-defenders"></a> C. Rooks Defenders</h1><h2 id="题目大意-3"><a class="markdownIt-Anchor" href="#题目大意-3"></a> 题目大意</h2><p>你有一个棋盘，棋盘大小是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mo>×</mo><mi>n</mi></mrow><annotation encoding="application/x-tex">n \times n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.66666em;vertical-align:-0.08333em;"></span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">×</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">n</span></span></span></span>。<br />然后有三种操作：</p><ul><li>向棋盘中 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mi>x</mi><mo separator="true">,</mo><mi>y</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(x, y)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord mathnormal">x</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="mclose">)</span></span></span></span> 坐标位置放置一枚<code>车</code>。</li><li>将棋盘中 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mi>x</mi><mo separator="true">,</mo><mi>y</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(x, y)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord mathnormal">x</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="mclose">)</span></span></span></span> 坐标位置的<code>车</code>移除，保证这个坐标位置有一枚<code>车</code>。</li><li>给你一个子矩形，矩形用左上角坐标 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><msub><mi>x</mi><mn>1</mn></msub><mo separator="true">,</mo><msub><mi>y</mi><mn>1</mn></msub><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(x_1, y_1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03588em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span> 和右下角坐标 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><msub><mi>x</mi><mn>2</mn></msub><mo separator="true">,</mo><msub><mi>y</mi><mn>2</mn></msub><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(x_2, y_2)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.03588em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span> 表示。问棋盘上面的<code>车</code>的移动范围能不能攻击到这个矩形内的所有位置。</li></ul><h2 id="题目解析-3"><a class="markdownIt-Anchor" href="#题目解析-3"></a> 题目解析</h2><p>分别用数组记录每一行和每一列一共有多少枚<code>车</code>。<br />当每一行（列）出现第一个<code>车</code>，或者最后一枚<code>车</code>消失的时候，将当前行（列）的<code>车</code>数目更新到树状数组或者线段树。<br />然后统计子矩阵所覆盖的行是不是全部能被<code>车</code>覆盖到 或者 每一列都能被 <code>车</code> 覆盖到。</p><h2 id="参考代码-3"><a class="markdownIt-Anchor" href="#参考代码-3"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">template&lt;typename T&gt;struct FenWick &#123;    int N;    vector&lt;T&gt; arr;    FenWick(int sz): N(sz), arr(sz + 1, 0) &#123;&#125;    void update(int pos, T val) &#123;        for (; pos &lt;&#x3D; N;pos |&#x3D; (pos + 1)) &#123;            arr[pos] +&#x3D; val;        &#125;    &#125;    &#x2F;&#x2F; 获取 [1, pos] 的和    T get(int pos) &#123;        T ret &#x3D; 0;        for (; pos &gt; 0; --pos) &#123;            ret +&#x3D; arr[pos];            pos &amp;&#x3D; (pos + 1);        &#125;        return ret;    &#125;    &#x2F;&#x2F; 获取 [l, r] 的和    T query(int l, int r) &#123;        return get(r) - get(l - 1);    &#125;&#125;;int main() &#123;    fastIO();    int n, q;    cin &gt;&gt; n &gt;&gt; q;    FenWick&lt;int&gt; fwr(n), fwc(n);    vector&lt;int&gt; r(n + 1, 0), c(n + 1, 0);    while(q--)&#123;        int op;        cin &gt;&gt; op;        if(op &#x3D;&#x3D; 1)&#123;            int x, y;            cin &gt;&gt; x &gt;&gt; y;            r[x]++;            c[y]++;            if(r[x] &#x3D;&#x3D; 1) fwr.update(x, 1);   &#x2F;&#x2F; 当 🚗 出现的时候            if(c[y] &#x3D;&#x3D; 1) fwc.update(y, 1);   &#x2F;&#x2F; 当 🚗 出现的时候        &#125;else if(op &#x3D;&#x3D; 2)&#123;            int x, y;            cin &gt;&gt; x &gt;&gt; y;            r[x]--;            c[y]--;            if(r[x] &#x3D;&#x3D; 0) fwr.update(x, -1);  &#x2F;&#x2F; 当 🚗 消失的时候            if(c[y] &#x3D;&#x3D; 0) fwc.update(y, -1);  &#x2F;&#x2F; 当 🚗 消失的时候        &#125;else&#123;            int x1, y1, x2, y2;            cin &gt;&gt; x1 &gt;&gt; y1 &gt;&gt; x2 &gt;&gt; y2;            if(fwr.query(x1, x2) &#x3D;&#x3D; x2 - x1 + 1 or fwc.query(y1, y2) &#x3D;&#x3D; y2 - y1 + 1)&#123;                cout &lt;&lt; &quot;Yes\n&quot;;            &#125;else&#123;                cout &lt;&lt; &quot;No\n&quot;;            &#125;        &#125;    &#125;    return 0;&#125;</code></pre></div></figure><h1 id="d-toss-a-coin-to-your-graph"><a class="markdownIt-Anchor" href="#d-toss-a-coin-to-your-graph"></a> D. Toss a Coin to Your Graph…</h1><h2 id="题目大意-4"><a class="markdownIt-Anchor" href="#题目大意-4"></a> 题目大意</h2><p>有一个不包含自环的有向图，图上的每一个节点都拥有一个权值 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>a</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">a_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>，问你从某个节点出发，经过 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">k - 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.77777em;vertical-align:-0.08333em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> 条单向边，经过的所有节点的最大值最小。</p><h2 id="题目解析-4"><a class="markdownIt-Anchor" href="#题目解析-4"></a> 题目解析</h2><p>二分一下最大值 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>a</mi><mrow><mi>m</mi><mi>a</mi><mi>x</mi></mrow></msub></mrow><annotation encoding="application/x-tex">a_{max}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">m</span><span class="mord mathnormal mtight">a</span><span class="mord mathnormal mtight">x</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>，然后判断在不经过权值超过最大值的节点情况下，能不能满足经过 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">k - 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.77777em;vertical-align:-0.08333em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> 条单向遍。</p><p>对于每次一次二分枚举 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>a</mi><mrow><mi>m</mi><mi>a</mi><mi>x</mi></mrow></msub></mrow><annotation encoding="application/x-tex">a_{max}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">m</span><span class="mord mathnormal mtight">a</span><span class="mord mathnormal mtight">x</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> ，将权值超过 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>a</mi><mrow><mi>m</mi><mi>a</mi><mi>x</mi></mrow></msub></mrow><annotation encoding="application/x-tex">a_{max}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.151392em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">m</span><span class="mord mathnormal mtight">a</span><span class="mord mathnormal mtight">x</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 的点和与它相连的边移除，判断剩余的图形是否存在节点数大于或者等于<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi></mrow><annotation encoding="application/x-tex">k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span></span></span></span>的链，或者存在环。这个可以用拓扑排序解决一下。</p><h2 id="参考代码-4"><a class="markdownIt-Anchor" href="#参考代码-4"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">struct Node&#123;    int a, b;    int val;    bool operator &lt; (const Node&amp; arg) const&#123;        return val &lt; arg.val;    &#125;&#125;;int main() &#123;    fastIO();    int n, m;    ll k;    cin &gt;&gt; n &gt;&gt; m &gt;&gt; k;    vector&lt;PLL&gt; arr(n);    for(int i &#x3D; 0; i &lt; n; ++i)&#123;        cin &gt;&gt; arr[i].first;        arr[i].second &#x3D; i;    &#125;    vector&lt;Node&gt; nodes(m);    for(auto&amp; it: nodes)&#123;        cin &gt;&gt; it.a &gt;&gt; it.b;        it.a--;        it.b--;        it.val &#x3D; max(arr[it.a].first, arr[it.b].first); &#x2F;&#x2F;边的权值设定为两个端点的最大值    &#125;    sort(itr(nodes));    sort(itr(arr));    &#x2F;&#x2F; 二分的检查函数，检查取最小的cnt个元素的情况下是否满足    auto&amp;&amp; check &#x3D; [&amp;](int cnt) -&gt; bool&#123;        vector&lt;int&gt; vis(n, 0);        vector&lt;vector&lt;int&gt;&gt; g(n); &#x2F;&#x2F;图        vector&lt;int&gt; ins(n, 0);  &#x2F;&#x2F;有向图入度        vector&lt;int&gt; dep(n, 1);  &#x2F;&#x2F;包含当前位置的链的节点数目        for(int i &#x3D; 0; i &lt; m; ++i)&#123;            if(nodes[i].val &lt;&#x3D; arr[cnt - 1].first)&#123;                g[nodes[i].a].push_back(nodes[i].b);                ins[nodes[i].b]++;            &#125;else&#123;                break;            &#125;        &#125;        queue&lt;int&gt; q;        for(int i &#x3D; 0; i &lt; n; ++i)&#123;            if(ins[i] &#x3D;&#x3D; 0)&#123;                q.push(i);                vis[i] &#x3D; 1;            &#125;        &#125;        while(!q.empty())&#123;            auto it &#x3D; q.front();            q.pop();            for(auto&amp; nex: g[it])&#123;                ins[nex]--;                dep[nex] &#x3D; max(dep[nex], dep[it] + 1);                if(ins[nex] &#x3D;&#x3D; 0)&#123;                    q.push(nex);                    vis[nex] &#x3D; 1;                &#125;            &#125;        &#125;         for(int i &#x3D; 0; i &lt; n; ++i) if(ins[i]) return true;  &#x2F;&#x2F; 存在环        for(int i &#x3D; 0; i &lt; n; ++i) if(dep[i] &gt;&#x3D; k) return true; &#x2F;&#x2F; 链的节点数目超过k        return false;    &#125;;    int ans &#x3D; n + 1;    for(int i &#x3D; (1 &lt;&lt; 20); i; i &gt;&gt;&#x3D; 1)&#123;        if(ans - i &gt; 0 and check(ans - i)) ans -&#x3D; i;    &#125;    if(ans &gt; n) cout &lt;&lt; -1 &lt;&lt; endl;    else cout &lt;&lt; arr[ans - 1].first &lt;&lt; endl;    return 0;&#125;</code></pre></div></figure>]]>
      </content:encoded>
    </item>
    <item>
      <title>Educational Codeforces Round 128 (Rated for Div. 2)</title>
      <link>https://www.dianhsu.com/2022/05/14/cf1680/</link>
      <description>
        <![CDATA[<h1 id="a-minimums-and-maximums"><a class="markdownIt-Anchor" href="#a-minimums-and-maximums"></a> A. Minimums and Maximums</h1>
<h2]]>
      </description>
      <author>Dian Hsu</author>
      <category domain="https://www.dianhsu.com/categories/Codeforces/">Codeforces</category>
      <category domain="https://www.dianhsu.com/tags/%E7%AE%97%E6%B3%95/">算法</category>
      <category domain="https://www.dianhsu.com/tags/Codeforces/">Codeforces</category>
      <category domain="https://www.dianhsu.com/tags/%E8%B4%AA%E5%BF%83/">贪心</category>
      <category domain="https://www.dianhsu.com/tags/%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92/">动态规划</category>
      <category domain="https://www.dianhsu.com/tags/%E6%A8%A1%E6%8B%9F/">模拟</category>
      <pubDate>Sat, 14 May 2022 02:07:05 GMT</pubDate>
      <content:encoded>
        <![CDATA[<h1 id="a-minimums-and-maximums"><a class="markdownIt-Anchor" href="#a-minimums-and-maximums"></a> A. Minimums and Maximums</h1><h2 id="题目大意"><a class="markdownIt-Anchor" href="#题目大意"></a> 题目大意</h2><p>一个<code>beautiful</code>数组需要同时具备一下两个条件：</p><ul><li>在这个数组中至少有<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>l</mi><mn>1</mn></msub></mrow><annotation encoding="application/x-tex">l_1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.01968em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>且至多有<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>r</mi><mn>1</mn></msub></mrow><annotation encoding="application/x-tex">r_1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.02778em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>个元素的值等于数组中的最小值。</li><li>在这个数组中至少有<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>l</mi><mn>2</mn></msub></mrow><annotation encoding="application/x-tex">l_2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.01968em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>且至多有<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>r</mi><mn>2</mn></msub></mrow><annotation encoding="application/x-tex">r_2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.02778em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>个元素的值等于数组中的最大值。</li></ul><p>给定<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>l</mi><mn>1</mn></msub><mo separator="true">,</mo><msub><mi>r</mi><mn>1</mn></msub><mo separator="true">,</mo><msub><mi>l</mi><mn>2</mn></msub><mo separator="true">,</mo><msub><mi>r</mi><mn>2</mn></msub></mrow><annotation encoding="application/x-tex">l_1, r_1, l_2, r_2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.01968em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.02778em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.01968em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.02778em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>，你的任务是计算数组中最少的的元素个数。</p><h2 id="题目解析"><a class="markdownIt-Anchor" href="#题目解析"></a> 题目解析</h2><p>如果$ [l_1, r_1] $ 和 $ [l_2, r_2] $ 的交集为空，那我们至少需要两种不同的元素来构造这个数组，那么最小的元素个数是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>l</mi><mn>1</mn></msub><mo>+</mo><msub><mi>l</mi><mn>2</mn></msub></mrow><annotation encoding="application/x-tex">l_1 + l_2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.01968em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.01968em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>。<br />如果$ [l_1, r_1] $ 和 $ [l_2, r_2] $ 的交集不为空，我们设定他们的交集是 $ [l, r] $ ，可以看出 $ l = \max(l_1, l_2), r = \min(r_1, r_2)$ 。这时可以用一种元素来构造这个数组，即最大值等于最小值，那么最小的元素个数就是<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>max</mi><mo>⁡</mo><mo stretchy="false">(</mo><msub><mi>l</mi><mn>1</mn></msub><mo separator="true">,</mo><msub><mi>l</mi><mn>2</mn></msub><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">\max(l_1, l_2)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mop">max</span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.01968em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:-0.01968em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span>。</p><h2 id="参考代码"><a class="markdownIt-Anchor" href="#参考代码"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;    int t;    cin &gt;&gt; t;    while(t--)&#123;        int l1, r1, l2, r2;        cin &gt;&gt; l1 &gt;&gt; r1 &gt;&gt; l2 &gt;&gt; r2;        int l &#x3D; l1, r &#x3D; r1;        l &#x3D; max(l, l2), r &#x3D; min(r, r2);        if(l &lt;&#x3D; r)&#123; &#x2F;&#x2F; 交集不为空            cout &lt;&lt; l &lt;&lt; endl;        &#125;else &#123;     &#x2F;&#x2F; 交集为空            cout &lt;&lt; l1 + l2 &lt;&lt; endl;        &#125;    &#125;    return 0;&#125;</code></pre></div></figure><h1 id="b-robots"><a class="markdownIt-Anchor" href="#b-robots"></a> B. Robots</h1><h2 id="题目大意-2"><a class="markdownIt-Anchor" href="#题目大意-2"></a> 题目大意</h2><p>现在有一个 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">n</span></span></span></span> 行 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>m</mi></mrow><annotation encoding="application/x-tex">m</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">m</span></span></span></span> 列区域，区域内有些格子是空闲的（用<code>E</code>来表示），有些格子是包含机器人（用<code>R</code>来表示）。</p><p>现在可以同时将所有的机器人进行上下左右移动，不能将机器人移出区域。</p><p>问能不能移动之后，使得一个机器人移动左上角。</p><h2 id="题目解析-2"><a class="markdownIt-Anchor" href="#题目解析-2"></a> 题目解析</h2><p>首先把机器人所在的最小矩形框出来，如下图黄色区域所示。</p><p><img src="https://cdn.dianhsu.com/img%2FQQ20220514-103442%402x.png" alt="一个样例" /></p><p>当黄色矩形在区域内移动时，边界不能移出区域。又因为所有的机器人都在区域内，所以判断能不能移动机器人到左上角等于黄色区域的左上角是不是机器人。</p><h2 id="参考代码-2"><a class="markdownIt-Anchor" href="#参考代码-2"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;    fastIO();    int t;    cin &gt;&gt; t;    while(t--)&#123;        int n, m;        cin &gt;&gt; n &gt;&gt; m;        &#x2F;&#x2F; [mx, my] 黄色区域的左上角的位置        int mx &#x3D; inf, my &#x3D; inf;         vector&lt;int&gt; arr(n, 0), brr(m, 0);        vector&lt;string&gt; vecs(n);        for(int i &#x3D; 0; i &lt; n; ++i)&#123;            cin &gt;&gt; vecs[i];            for(int j &#x3D; 0; j &lt; m; ++j)&#123;                if(vecs[i][j] &#x3D;&#x3D; &#39;R&#39;)&#123;                    mx &#x3D; min(mx, i);                    my &#x3D; min(my, j);                &#125;            &#125;        &#125;        if(vecs[mx][my] &#x3D;&#x3D; &#39;R&#39;) cout &lt;&lt; &quot;YES\n&quot;;        else cout &lt;&lt; &quot;NO\n&quot;;    &#125;    return 0;&#125;</code></pre></div></figure><h1 id="c-binary-string"><a class="markdownIt-Anchor" href="#c-binary-string"></a> C. Binary String</h1><h2 id="题目大意-3"><a class="markdownIt-Anchor" href="#题目大意-3"></a> 题目大意</h2><p>给你一个只包含<code>0</code>和<code>1</code>的字符串。<br />你可以从字符串的头部或者删除一些字符（删除字符之后，字符串可能为空）。这个操作的花费是以下两个指标的最大值：</p><ul><li>操作完成之后，字符串中<strong>剩余</strong>的<code>0</code>的数目。</li><li>操作完成之后，字符串中<strong>移除</strong>的<code>1</code>的数目。</li></ul><p>问最小的花费。</p><h2 id="题目解析-3"><a class="markdownIt-Anchor" href="#题目解析-3"></a> 题目解析</h2><p>二分枚举一下结果 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>a</mi><mi>n</mi><mi>s</mi></mrow><annotation encoding="application/x-tex">ans</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">a</span><span class="mord mathnormal">n</span><span class="mord mathnormal">s</span></span></span></span> 。<br />然后对于每个枚举值，使用双指针遍历一遍字符串，要求双指针的区间内的<code>0</code>的数目不超过 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>a</mi><mi>n</mi><mi>s</mi></mrow><annotation encoding="application/x-tex">ans</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">a</span><span class="mord mathnormal">n</span><span class="mord mathnormal">s</span></span></span></span> ，且区间长度越长越好 。然后判断双指针区间之外的部分的<code>1</code>的数目是否也满足不超过 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>a</mi><mi>n</mi><mi>s</mi></mrow><annotation encoding="application/x-tex">ans</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">a</span><span class="mord mathnormal">n</span><span class="mord mathnormal">s</span></span></span></span> 。</p><h2 id="参考代码-3"><a class="markdownIt-Anchor" href="#参考代码-3"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;    fastIO();    int t;    cin &gt;&gt; t;    while(t--)&#123;        string s;        cin &gt;&gt; s;        int n &#x3D; s.length();        &#x2F;&#x2F;前缀的1的数目        vector&lt;int&gt; sum1(n + 1, 0);         &#x2F;&#x2F;前缀的0的数目        vector&lt;int&gt; sum0(n + 1, 0);        for(int i &#x3D; 0; i &lt; n; ++i)&#123;            sum1[i + 1] &#x3D; sum1[i] + s[i] - &#39;0&#39;;            sum0[i + 1] &#x3D; sum0[i] + ((s[i] - &#39;0&#39;) ^ 1);        &#125;                &#x2F;&#x2F; 检查当前的 ans 是否满足条件        auto&amp;&amp; check &#x3D; [&amp;](int cur) -&gt; bool&#123;            for(int l &#x3D; 0, r &#x3D; 1; r &lt;&#x3D; n; ++r)&#123;                &#x2F;&#x2F; 调整左边的指针，使得区间内0的数目不超过cur                while(l &lt; r and sum0[r] - sum0[l] &gt; cur) l++;                &#x2F;&#x2F; 判断双指针外1的数目是否满足                if(sum1[n] - sum1[r] + sum1[l] - sum1[0] &lt;&#x3D; cur) return true;            &#125;            return false;        &#125;;        &#x2F;** 二分 ans **&#x2F;        int ans &#x3D; n;        for(int i &#x3D; (1 &lt;&lt; 20); i; i &gt;&gt;&#x3D; 1)&#123;            if(ans - i &gt;&#x3D; 0 and check(ans - i))&#123;                ans -&#x3D; i;            &#125;        &#125;        cout &lt;&lt; ans &lt;&lt; endl;    &#125;    return 0;&#125;</code></pre></div></figure><h1 id="d-dog-walking"><a class="markdownIt-Anchor" href="#d-dog-walking"></a> D. Dog Walking</h1><h2 id="题目大意-4"><a class="markdownIt-Anchor" href="#题目大意-4"></a> 题目大意</h2><p>你在左右方向长廊上遛🐶，刚开始你站在位置为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0</mn></mrow><annotation encoding="application/x-tex">0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span> 的地方。</p><p>你想给🐶一些自由，所以你会解开绳子，让狗自己活动一下。<br />狗能活动的时间是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">n</span></span></span></span> 分钟，对于第 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.65952em;vertical-align:0em;"></span><span class="mord mathnormal">i</span></span></span></span> 分钟，狗的行为由 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>a</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">a_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 来表示。</p><ul><li><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>a</mi><mi>i</mi></msub><mo>&lt;</mo><mn>0</mn></mrow><annotation encoding="application/x-tex">a_i &lt; 0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6891em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">&lt;</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span> 代表🐶往左走了 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi mathvariant="normal">∣</mi><msub><mi>a</mi><mi>i</mi></msub><mi mathvariant="normal">∣</mi></mrow><annotation encoding="application/x-tex">|a_i|</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">∣</span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mord">∣</span></span></span></span> 米。</li><li><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>a</mi><mi>i</mi></msub><mo>=</mo><mn>0</mn></mrow><annotation encoding="application/x-tex">a_i = 0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span> 不确定🐶怎么走。(<code>Unknown</code>)</li><li><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>a</mi><mi>i</mi></msub><mo>&gt;</mo><mn>0</mn></mrow><annotation encoding="application/x-tex">a_i &gt; 0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6891em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">&gt;</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span> 代表🐶往右走了 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi mathvariant="normal">∣</mi><msub><mi>a</mi><mi>i</mi></msub><mi mathvariant="normal">∣</mi></mrow><annotation encoding="application/x-tex">|a_i|</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">∣</span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mord">∣</span></span></span></span> 米。</li></ul><p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">n</span></span></span></span> 分钟之后，🐶会回到你身边，就是位置为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0</mn></mrow><annotation encoding="application/x-tex">0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span> 的地方。</p><p>对于 <code>Unknown</code> 的时刻，你可以设定了 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>a</mi><mi>i</mi></msub><mo>∈</mo><mo stretchy="false">[</mo><mo>−</mo><mi>k</mi><mo separator="true">,</mo><mi>k</mi><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">a_i \in [-k, k]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6891em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">∈</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">−</span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="mclose">]</span></span></span></span>（如果将 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>a</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">a_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> 设定为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0</mn></mrow><annotation encoding="application/x-tex">0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span>，那么它认为是原地不动）。</p><p>问通过设定<code>Unknown</code>的时刻的🐶的行为，🐶最大的活动范围是多大？最大的活动范围指的是狗能到达的最左边和最右边之内的所有点。</p><h2 id="题目解析-4"><a class="markdownIt-Anchor" href="#题目解析-4"></a> 题目解析</h2><p>枚举中两个不同时刻，假定在这两个时刻 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi><mo separator="true">,</mo><mi>j</mi></mrow><annotation encoding="application/x-tex">i, j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.85396em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">i</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span></span></span></span> 他们分别是🐶能到达最左边和最右边。</p><p>如果在 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi><mo separator="true">,</mo><mi>j</mi></mrow><annotation encoding="application/x-tex">i, j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.85396em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">i</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span></span></span></span> 时刻内，没有<code>Unknown</code>的时刻。那么狗能活动的最大范围就是 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.65952em;vertical-align:0em;"></span><span class="mord mathnormal">i</span></span></span></span> 时刻所处位置到 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>j</mi></mrow><annotation encoding="application/x-tex">j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.85396em;vertical-align:-0.19444em;"></span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span></span></span></span> 时刻所处位置的距离的绝对值，和 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi><mo separator="true">,</mo><mi>j</mi></mrow><annotation encoding="application/x-tex">i, j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.85396em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">i</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span></span></span></span> 时刻中间的所处位置无关。</p><p>如果在 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi><mo separator="true">,</mo><mi>j</mi></mrow><annotation encoding="application/x-tex">i, j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.85396em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">i</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span></span></span></span> 时刻内，有<code>Unknown</code>的时刻。那么可以通过调整 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi><mo separator="true">,</mo><mi>j</mi></mrow><annotation encoding="application/x-tex">i, j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.85396em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">i</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span></span></span></span> 时刻内的<code>Unknown</code>时刻的狗子的行为，来调整狗子 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.65952em;vertical-align:0em;"></span><span class="mord mathnormal">i</span></span></span></span> 时刻所处位置到 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>j</mi></mrow><annotation encoding="application/x-tex">j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.85396em;vertical-align:-0.19444em;"></span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span></span></span></span> 时刻所处位置的距离的绝对值的最大值。首先假定<code>Unknown</code>时刻狗子原地不动，如果 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.65952em;vertical-align:0em;"></span><span class="mord mathnormal">i</span></span></span></span> 时刻的狗子所在的位置在 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>j</mi></mrow><annotation encoding="application/x-tex">j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.85396em;vertical-align:-0.19444em;"></span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span></span></span></span> 时刻的位置的左边，那么<code>Unknown</code>设定为满足条件的最大值的时候，那么狗子的移动范围就最大了。反之亦然。</p><h2 id="参考代码-4"><a class="markdownIt-Anchor" href="#参考代码-4"></a> 参考代码</h2><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;    int n;    ll k;    cin &gt;&gt; n &gt;&gt; k;    vector&lt;ll&gt; arr(n + 1, 0);    for(int i &#x3D; 1; i &lt;&#x3D; n; ++i) cin &gt;&gt; arr[i];    ll sum &#x3D; accumulate(itr(arr), 0ll); &#x2F;&#x2F;统计Unknown都设定为0的情况下，狗子的最终位置。    vector&lt;int&gt; zeros(n + 1, 0); &#x2F;&#x2F; 统计前缀中0的数目    for(int i &#x3D; 1; i &lt;&#x3D; n; ++i)&#123;        if(!arr[i])&#123;            zeros[i] &#x3D; zeros[i - 1] + 1;        &#125;else&#123;            zeros[i] &#x3D; zeros[i - 1];        &#125;    &#125;    vector&lt;ll&gt; pref(n + 1, 0); &#x2F;&#x2F; 统计Unknown都设定为0的情况下，狗子的前缀移动位置。    for(int i &#x3D; 1; i &lt;&#x3D; n; ++i) pref[i] &#x3D; pref[i - 1] + arr[i];    if(zeros[n] * k &lt; abs(sum))&#123;  &#x2F;&#x2F; 设定了所有Unknown的时刻，狗子都不能返回初始点        cout &lt;&lt; -1 &lt;&lt; endl;        return 0;    &#125;    vector&lt;ll&gt; vals(zeros[n], 0); &#x2F;&#x2F; 设定狗子的Unknown时刻的情况集合，要求所有元素的绝对值之和尽量大，并且所有元素之和等于-sum    ll tmp &#x3D; abs(sum);    for(int i &#x3D; 0; i &lt; zeros[n]; ++i)&#123;        vals[i] &#x3D; min(tmp, k);        tmp -&#x3D; vals[i];    &#125;    for(int i &#x3D; (int)zeros[n]- 1; i &gt; 0 and !vals[i]; i -&#x3D; 2)&#123;        vals[i] +&#x3D; k;        vals[i - 1] -&#x3D; k;    &#125;    int m &#x3D; zeros[n];    if(sum &gt; 0)&#123;        for(auto&amp; it: vals) it &#x3D; -it;    &#125;    sort(itr(vals));    vector&lt;ll&gt; prefv(m + 1, 0);     for(int i &#x3D; 0; i &lt; m; ++i)&#123;        prefv[i + 1] &#x3D; prefv[i] + vals[i];    &#125;    ll ans &#x3D; 1;    for(int i &#x3D; 1; i &lt;&#x3D; n; ++i)&#123;        for(int j &#x3D; 0; j &lt; i; ++j)&#123;            int tmpz &#x3D; zeros[i] - zeros[j];            ll tv &#x3D; pref[i] - pref[j];            ll sv1 &#x3D; prefv[tmpz], sv2 &#x3D; prefv[m] - prefv[m - tmpz];            ans &#x3D; max(ans, max(abs(tv + sv1), abs(tv + sv2)) + 1);        &#125;    &#125;    cout &lt;&lt; ans &lt;&lt; endl;    return 0;&#125;</code></pre></div></figure><h1 id="e-moving-chips"><a class="markdownIt-Anchor" href="#e-moving-chips"></a> E. Moving Chips</h1><h2 id="题目大意-5"><a class="markdownIt-Anchor" href="#题目大意-5"></a> 题目大意</h2><p>给你一个 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>2</mn><mo>×</mo><mi>n</mi></mrow><annotation encoding="application/x-tex">2 \times n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.72777em;vertical-align:-0.08333em;"></span><span class="mord">2</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">×</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">n</span></span></span></span> 的棋盘，棋盘上面的棋子可以往相邻的格子上面移动。每次可以将一枚棋子移动到相邻的格子上，如果格子上面存在棋子，那么移动的这枚棋子将会消失。</p><p>问最少的操作次数，使得棋盘上面只存在 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> 枚棋子。</p><h2 id="题目解析-5"><a class="markdownIt-Anchor" href="#题目解析-5"></a> 题目解析</h2><p>对于第 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi><mo separator="true">,</mo><mi>j</mi></mrow><annotation encoding="application/x-tex">i, j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.85396em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">i</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span></span></span></span> 个位置，分别考虑将包含当前列的左边的所有棋子移动到当前位置所需要的最小操作次数<code>dpl[i][j]</code>。<br />对于第 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi><mo separator="true">,</mo><mi>j</mi></mrow><annotation encoding="application/x-tex">i, j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.85396em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">i</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span></span></span></span> 个位置，分别考虑将包含当前列的右边的所有棋子移动到当前位置所需要的最小操作次数<code>dpr[i][j]</code>。</p><p>对于<code>dpl[i][j]</code>，它的转移方式是两种：</p><ul><li>从<code>dpl[i][j - 1]</code> 将包含 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>j</mi><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">j - 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.85396em;vertical-align:-0.19444em;"></span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> 列的所有左边的棋子转移到当前位置。<br /><code>dpl[i][j] = dp[i][j - 1] + 1</code><br />如果 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi><mo>⊕</mo><mn>1</mn><mo separator="true">,</mo><mi>j</mi></mrow><annotation encoding="application/x-tex">i \oplus 1, j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.74285em;vertical-align:-0.08333em;"></span><span class="mord mathnormal">i</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">⊕</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.85396em;vertical-align:-0.19444em;"></span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span></span></span></span> 位置存在一枚棋子，那么也需要转移过来。<code>dpl[i][j]++</code></li><li>从<code>dpl[i^1][j - 1]</code> 将包含 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>j</mi><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">j - 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.85396em;vertical-align:-0.19444em;"></span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> 列的所有左边的棋子转移到当前位置。<br /><code>dpl[i][j] = dp[i^1][j - 1] + 2</code><br />如果 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>j</mi><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">j - 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.85396em;vertical-align:-0.19444em;"></span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span> 列及左边没有棋子，这种情况包含在上面一种情况当中了，就不再考虑。</li></ul><p>最后考虑左右合并位置是<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi><mo separator="true">,</mo><mi>j</mi></mrow><annotation encoding="application/x-tex">i, j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.85396em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">i</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span></span></span></span>，那么左右的花费就是<code>dpl[i][j - 1] + dpr[i][j]</code>，如果左边和右边都有棋子，那么还需要加上他们合并的花费 <code>1</code> 。</p><h2 id="参考代码-5"><a class="markdownIt-Anchor" href="#参考代码-5"></a> 参考代码</h2><p>PS: 代码中的 <code>dpl[i][j], dpr[i][j]</code>的两维和上述分析中不同。</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">int main() &#123;    int t;    cin &gt;&gt; t;    while(t--)&#123;        int n;        cin &gt;&gt; n;        vector&lt;string&gt; s(2);        for(auto&amp; it: s) cin &gt;&gt; it;        vector&lt;vector&lt;int&gt;&gt; dpl(n, vector&lt;int&gt;(2, 0)), dpr(n, vector&lt;int&gt;(2, 0));        for(int i &#x3D; 0; i &lt; n; ++i)&#123; &#x2F;&#x2F; 统计 dpl            if(i &#x3D;&#x3D; 0)&#123;                if(s[1][i] &#x3D;&#x3D; &#39;*&#39;) dpl[i][0] &#x3D; 1;                if(s[0][i] &#x3D;&#x3D; &#39;*&#39;) dpl[i][1] &#x3D; 1;            &#125;else&#123;                if(dpl[i - 1][0] &gt; 0 or s[0][i - 1] &#x3D;&#x3D; &#39;*&#39;) dpl[i][0] &#x3D; dpl[i - 1][0] + 1;                if(dpl[i - 1][1] &gt; 0 or s[1][i - 1] &#x3D;&#x3D; &#39;*&#39;) dpl[i][1] &#x3D; dpl[i - 1][1] + 1;                if(s[1][i] &#x3D;&#x3D; &#39;*&#39;) dpl[i][0]++;                if(s[0][i] &#x3D;&#x3D; &#39;*&#39;) dpl[i][1]++;                if(dpl[i - 1][1] or s[1][i - 1] &#x3D;&#x3D; &#39;*&#39;) dpl[i][0] &#x3D; min(dpl[i - 1][1] + 2, dpl[i][0]);                if(dpl[i - 1][0] or s[0][i - 1] &#x3D;&#x3D; &#39;*&#39;) dpl[i][1] &#x3D; min(dpl[i - 1][0] + 2, dpl[i][1]);            &#125;        &#125;        for(int i &#x3D; n - 1; i &gt;&#x3D; 0; --i)&#123;&#x2F;&#x2F; 统计 dpr            if(i &#x3D;&#x3D; n - 1)&#123;                if(s[1][i] &#x3D;&#x3D; &#39;*&#39;) dpr[i][0] &#x3D; 1;                if(s[0][i] &#x3D;&#x3D; &#39;*&#39;) dpr[i][1] &#x3D; 1;            &#125;else&#123;                if(dpr[i + 1][0] &gt; 0 or s[0][i + 1] &#x3D;&#x3D; &#39;*&#39;) dpr[i][0] &#x3D; dpr[i + 1][0] + 1;                if(dpr[i + 1][1] &gt; 0 or s[1][i + 1] &#x3D;&#x3D; &#39;*&#39;) dpr[i][1] &#x3D; dpr[i + 1][1] + 1;                if(s[1][i] &#x3D;&#x3D; &#39;*&#39;) dpr[i][0]++;                if(s[0][i] &#x3D;&#x3D; &#39;*&#39;) dpr[i][1]++;                if(dpr[i + 1][1] or s[1][i + 1] &#x3D;&#x3D; &#39;*&#39;) dpr[i][0] &#x3D; min(dpr[i + 1][1] + 2, dpr[i][0]);                if(dpr[i + 1][0] or s[0][i + 1] &#x3D;&#x3D; &#39;*&#39;) dpr[i][1] &#x3D; min(dpr[i + 1][0] + 2, dpr[i][1]);            &#125;        &#125;        int ans &#x3D; min(min(dpl[n - 1][0], dpl[n - 1][1]), min(dpr[0][0], dpr[0][1]));  &#x2F;&#x2F;处理两端的情况        for(int i &#x3D; 1; i &lt; n; ++i)&#123; &#x2F;&#x2F; 处理合并的情况            for(int j &#x3D; 0; j &lt; 2; ++j)&#123;                int tmp &#x3D; dpl[i - 1][j] + dpr[i][j];                if((dpl[i - 1][j] or s[j][i - 1] &#x3D;&#x3D; &#39;*&#39;) and (dpr[i][j] or s[j][i] &#x3D;&#x3D; &#39;*&#39;)) ++tmp;                ans &#x3D; min(ans, tmp);            &#125;        &#125;        cout &lt;&lt; ans &lt;&lt; endl;    &#125;    return 0;&#125;</code></pre></div></figure>]]>
      </content:encoded>
    </item>
    <item>
      <title>LCP 58. 积木拼接</title>
      <link>https://www.dianhsu.com/2022/05/13/LCP58/</link>
      <description>
        <![CDATA[<blockquote>
<p><a]]>
      </description>
      <author>Dian Hsu</author>
      <category domain="https://www.dianhsu.com/categories/LeetCode/">LeetCode</category>
      <category domain="https://www.dianhsu.com/tags/LeetCode/">LeetCode</category>
      <category domain="https://www.dianhsu.com/tags/LC%E6%98%A5%E5%AD%A3%E8%B5%9B/">LC春季赛</category>
      <category domain="https://www.dianhsu.com/tags/%E7%AB%8B%E4%BD%93%E5%87%A0%E4%BD%95/">立体几何</category>
      <pubDate>Fri, 13 May 2022 06:25:24 GMT</pubDate>
      <content:encoded>
        <![CDATA[<blockquote><p><a href="https://leetcode.cn/problems/De4qBB/">https://leetcode.cn/problems/De4qBB/</a></p></blockquote><p>这个题目比较困难的地方就是记录方阵的翻转、旋转状态</p><h1 id="方阵的翻转旋转和转置模板"><a class="markdownIt-Anchor" href="#方阵的翻转旋转和转置模板"></a> 方阵的翻转，旋转和转置模板</h1><p>为了能够高效的表示当前方阵的状态，我们用方阵的四个角点表示方阵当前的状态。</p><p>比如一个<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>3</mn><mo>×</mo><mn>3</mn></mrow><annotation encoding="application/x-tex">3 \times 3</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.72777em;vertical-align:-0.08333em;"></span><span class="mord">3</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">×</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">3</span></span></span></span>的方阵，我们用<code>array&lt;pair&lt;int, int&gt;, 4&gt;</code>来存放这个方阵的四个角，依次分别是：左上角<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>0</mn><mo separator="true">,</mo><mn>0</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(0, 0)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">0</span><span class="mclose">)</span></span></span></span>、右上角<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>0</mn><mo separator="true">,</mo><mi>y</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(0, y)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="mclose">)</span></span></span></span>、左下角<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mi>x</mi><mo separator="true">,</mo><mn>0</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(x, 0)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord mathnormal">x</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">0</span><span class="mclose">)</span></span></span></span>和右下角<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mi>x</mi><mo separator="true">,</mo><mi>y</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(x, y)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord mathnormal">x</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="mclose">)</span></span></span></span>。</p><h2 id="翻转操作"><a class="markdownIt-Anchor" href="#翻转操作"></a> 翻转操作</h2><figure><div class="code-wrapper"><pre class="line-numbers language-none" data-start="1"><code class="language-none">110    上下进行翻转    000010  -------------&gt;  010000                  110</code></pre></div></figure><p>那么他四个点的坐标就是</p><figure><div class="code-wrapper"><pre class="line-numbers language-none" data-start="1"><code class="language-none">(0,0)  (0,3)      上下进行翻转      (3,0)  (3,3)                 -------------&gt;(3,0)  (3,3)                      (0,0)  (0,3)</code></pre></div></figure><p>对应代码：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">void mirror(int dr &#x3D; 1)&#123;    if(dr &#x3D;&#x3D; 1)&#123;        &#x2F;&#x2F; 左右翻转        swap(vec[0], vec[1]);        swap(vec[2], vec[3]);    &#125;else&#123;        &#x2F;&#x2F; 上下翻转        swap(vec[0], vec[2]);        swap(vec[1], vec[3]);    &#125;&#125;</code></pre></div></figure><h2 id="转置操作"><a class="markdownIt-Anchor" href="#转置操作"></a> 转置操作</h2><figure><div class="code-wrapper"><pre class="line-numbers language-none" data-start="1"><code class="language-none">110      转置方阵     100010  -------------&gt;  110000                  000</code></pre></div></figure><p>那么他四个点的坐标就是</p><figure><div class="code-wrapper"><pre class="line-numbers language-none" data-start="1"><code class="language-none">(0,0)  (0,3)        转置方阵       (0,0)  (3,0)                 -------------&gt;(3,0)  (3,3)                      (0,3)  (3,3)</code></pre></div></figure><p>对应代码：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">void transpose(int dr &#x3D; 1)&#123;    if(dr &#x3D;&#x3D; 1)&#123;        &#x2F;&#x2F; 沿着y &#x3D; x 翻转        swap(vec[1], vec[2]);    &#125;else&#123;        &#x2F;&#x2F; 沿着x + y &#x3D; n 翻转        swap(vec[0], vec[3]);    &#125;&#125;</code></pre></div></figure><h2 id="旋转操作"><a class="markdownIt-Anchor" href="#旋转操作"></a> 旋转操作</h2><figure><div class="code-wrapper"><pre class="line-numbers language-none" data-start="1"><code class="language-none">110   顺时针旋转90度   001010  -------------&gt;  011000                  000</code></pre></div></figure><p>那么他四个点的坐标就是</p><figure><div class="code-wrapper"><pre class="line-numbers language-none" data-start="1"><code class="language-none">(0,0)  (0,3)     顺时针旋转90度     (3,0)  (0,0)                 -------------&gt;(3,0)  (3,3)                      (3,3)  (0,3)</code></pre></div></figure><p>对应代码（旋转可以用转置+翻转来实现）：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">void rotate(int dr &#x3D; 1)&#123;    transpose();    if(dr &#x3D;&#x3D; 1)&#123;        &#x2F;&#x2F; 顺时针        mirror(1);    &#125;else&#123;        &#x2F;&#x2F; 逆时针        mirror(0);    &#125;&#125;</code></pre></div></figure><p>可以从上面看出来，对图形的操作，就可以表示为对四个角的二维方阵的操作。</p><p>因为翻转之后，我们需要知道新的图形的x，y的坐标轴的变化，比如</p><figure><div class="code-wrapper"><pre class="line-numbers language-none" data-start="1"><code class="language-none">(0,0)  (0,3)     顺时针旋转90度     (3,0)  (0,0)                 -------------&gt;(3,0)  (3,3)                      (3,3)  (0,3)</code></pre></div></figure><p>这个图形旋转之前的坐标轴的单位变化分别是<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>d</mi><mi>x</mi><mo>=</mo><mo stretchy="false">(</mo><mn>1</mn><mo separator="true">,</mo><mn>0</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">dx = (1, 0)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal">d</span><span class="mord mathnormal">x</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">0</span><span class="mclose">)</span></span></span></span>和<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>d</mi><mi>y</mi><mo>=</mo><mo stretchy="false">(</mo><mn>0</mn><mo separator="true">,</mo><mn>1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">dy = (0, 1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">d</span><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">1</span><span class="mclose">)</span></span></span></span>，顺时针旋转90度之后的单位变化<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>d</mi><mi>x</mi><mo>=</mo><mo stretchy="false">(</mo><mn>0</mn><mo separator="true">,</mo><mn>1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">dx = (0, 1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal">d</span><span class="mord mathnormal">x</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">1</span><span class="mclose">)</span></span></span></span>，<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>d</mi><mi>y</mi><mo>=</mo><mo stretchy="false">(</mo><mo>−</mo><mn>1</mn><mo separator="true">,</mo><mn>0</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">dy = (-1, 0)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">d</span><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">−</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">0</span><span class="mclose">)</span></span></span></span>。<br />为了方便记录当前的单位变化<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>d</mi><mi>x</mi></mrow><annotation encoding="application/x-tex">dx</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal">d</span><span class="mord mathnormal">x</span></span></span></span>和<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>d</mi><mi>y</mi></mrow><annotation encoding="application/x-tex">dy</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">d</span><span class="mord mathnormal" style="margin-right:0.03588em;">y</span></span></span></span>，我们在每次翻转、旋转和转置的时候，重新计算一次<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>d</mi><mi>x</mi></mrow><annotation encoding="application/x-tex">dx</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal">d</span><span class="mord mathnormal">x</span></span></span></span>和<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>d</mi><mi>y</mi></mrow><annotation encoding="application/x-tex">dy</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">d</span><span class="mord mathnormal" style="margin-right:0.03588em;">y</span></span></span></span>。计算的代码如下：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">void update()&#123;    int xlim &#x3D; abs(vec[2].first - vec[0].first) + abs(vec[2].second - vec[0].second);    int ylim &#x3D; abs(vec[1].first - vec[0].first) + abs(vec[1].second - vec[0].second);    assert(xlim &gt; 0 and ylim &gt; 0);    dx &#x3D; Point&#123;(vec[2].first - vec[0].first) &#x2F; xlim, (vec[2].second - vec[0].second) &#x2F; xlim&#125;;    dy &#x3D; Point&#123;(vec[1].first - vec[0].first) &#x2F; ylim, (vec[1].second - vec[0].second) &#x2F; ylim&#125;;&#125;</code></pre></div></figure><p>那么最终，我们就可以通过左上角的坐标，和单位坐标的变化<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>d</mi><mi>x</mi></mrow><annotation encoding="application/x-tex">dx</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal">d</span><span class="mord mathnormal">x</span></span></span></span>和<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>d</mi><mi>y</mi></mrow><annotation encoding="application/x-tex">dy</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">d</span><span class="mord mathnormal" style="margin-right:0.03588em;">y</span></span></span></span>，来映射得到原始的坐标。<br />代码如下所示：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">Point mapping(Point p)&#123;    return &#123;vec[0].first + dx.first * p.first + dy.first * p.second, vec[0].second + dx.second * p.first + dy.second * p.second&#125;;&#125;</code></pre></div></figure><p>那么最终完整的矩阵模板：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">class Rectangle&#123;public:    typedef pair&lt;int, int&gt; Point;    Rectangle(int sx, int sy) : dx(&#123;1, 0&#125;), dy(&#123;0, 1&#125;), vec(&#123;Point&#123;0, 0&#125;, Point&#123;0, sy - 1&#125;, Point&#123;sx - 1, 0&#125;, Point&#123;sx - 1, sy - 1&#125;&#125;)&#123;&#125;    void mirror(int dr &#x3D; 1)&#123;        if(dr &#x3D;&#x3D; 1)&#123;            &#x2F;&#x2F; 左右翻转            swap(vec[0], vec[1]);            swap(vec[2], vec[3]);        &#125;else&#123;            &#x2F;&#x2F; 上下翻转            swap(vec[0], vec[2]);            swap(vec[1], vec[3]);        &#125;        update();    &#125;    void transpose(int dr &#x3D; 1)&#123;        if(dr &#x3D;&#x3D; 1)&#123;            &#x2F;&#x2F; 沿着y &#x3D; x 翻转            swap(vec[1], vec[2]);        &#125;else&#123;            &#x2F;&#x2F; 沿着x + y &#x3D; n 翻转            swap(vec[0], vec[3]);        &#125;        update();    &#125;    void rotate(int dr &#x3D; 1)&#123;        transpose();        if(dr &#x3D;&#x3D; 1)&#123;            &#x2F;&#x2F; 顺时针            mirror(1);        &#125;else&#123;            &#x2F;&#x2F; 逆时针            mirror(0);        &#125;        update();    &#125;    Point mapping(Point p)&#123;        return &#123;vec[0].first + dx.first * p.first + dy.first * p.second, vec[0].second + dx.second * p.first + dy.second * p.second&#125;;    &#125;    &#x2F;&#x2F; 当前状态下，x轴的方向和y轴的方向    Point dx, dy;    &#x2F;&#x2F; 当前状态下的方阵四个角点的坐标    array&lt;Point, 4&gt; vec;private:    void update()&#123;        int xlim &#x3D; abs(vec[2].first - vec[0].first) + abs(vec[2].second - vec[0].second);        int ylim &#x3D; abs(vec[1].first - vec[0].first) + abs(vec[1].second - vec[0].second);        assert(xlim &gt; 0 and ylim &gt; 0);        dx &#x3D; Point&#123;(vec[2].first - vec[0].first) &#x2F; xlim, (vec[2].second - vec[0].second) &#x2F; xlim&#125;;        dy &#x3D; Point&#123;(vec[1].first - vec[0].first) &#x2F; ylim, (vec[1].second - vec[0].second) &#x2F; ylim&#125;;    &#125;&#125;;</code></pre></div></figure><h1 id="本题的实现"><a class="markdownIt-Anchor" href="#本题的实现"></a> 本题的实现</h1><h2 id="前置内容"><a class="markdownIt-Anchor" href="#前置内容"></a> 前置内容</h2><p>我们首先设计了6个位置，就是立方体的展开图。如下所示：</p><figure><div class="code-wrapper"><pre class="line-numbers language-none" data-start="1"><code class="language-none">      00000                   00000                   00000                   00000                   00000             11111 22222 33333 44444 11111 22222 33333 44444 11111 22222 33333 44444 11111 22222 33333 44444 11111 22222 33333 44444 55555                   55555                   55555                   55555                   55555                   </code></pre></div></figure><p>我们把位置按照这个形状进行设计，是因为可以和方便的计算他的相邻边。具体可看后面相邻边的数字变化。</p><p>然后定义每个矩阵的边的顺序【0，1，2，3】，依次是【上，右，下，左】。<br />比如0号位置的下方和2号位置的上方相邻，就构成一个边的四元组「0号位置，2号位置，下方，上方」，[0, 2, 2, 0]。<br />比如0号位置的左边和1号位置的上方相邻，就构成一个边的四元组「0号位置，1号位置，左边，上方」，[0, 1, 3, 0]。</p><p>那么写出0号位置所相邻边的四元组：</p><figure><div class="code-wrapper"><pre class="line-numbers language-none" data-start="1"><code class="language-none">[0, 1, 3, 0][0, 2, 2, 0][0, 3, 1, 0][0, 4, 0, 0]</code></pre></div></figure><p>然后是5号位置相邻边的四元组：</p><figure><div class="code-wrapper"><pre class="line-numbers language-none" data-start="1"><code class="language-none">[5, 1, 0, 2][5, 2, 1, 2][5, 3, 2, 2][5, 4, 3, 2]</code></pre></div></figure><p>然后就是其他四条边：</p><figure><div class="code-wrapper"><pre class="line-numbers language-none" data-start="1"><code class="language-none">[1, 2, 1, 3][2, 3, 1, 3][3, 4, 1, 3][4, 1, 1, 3]</code></pre></div></figure><p>为了按照顺序获取方阵的四条边，我们先定义了个方阵，然后逆时针旋转四次，每次旋转，获取一次当前位置的第一条边。</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">Rectangle rec(sz, sz);vector&lt;Rectangle&gt; recd;for(int i &#x3D; 0; i &lt; 4; ++i)&#123;    recd.push_back(rec);    rec.rotate(0);&#125;</code></pre></div></figure><h2 id="题目思路"><a class="markdownIt-Anchor" href="#题目思路"></a> 题目思路</h2><p>我们本题使用搜索检查每个位置是否满足。首先固定第一个方阵，我们把它固定放在0位置。然后每个位置尝试将其他的方阵旋转或者翻转放入。<br />对于立体图形的边，我们要求不能相邻的边在同一个位置具有相同的元素。<br />对于立体图形的角，我们要求不能两个边同时出现<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span>，为了避免三个相邻面共享的同一个角都是0，我们一开始就先计算1个总个数，要求1个总个数刚刚好。<br />完整代码如下：</p><figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">class Rectangle&#123;public:    typedef pair&lt;int, int&gt; Point;    Rectangle(int sx, int sy) : dx(&#123;1, 0&#125;), dy(&#123;0, 1&#125;), vec(&#123;Point&#123;0, 0&#125;, Point&#123;0, sy - 1&#125;, Point&#123;sx - 1, 0&#125;, Point&#123;sx - 1, sy - 1&#125;&#125;)&#123;&#125;    void mirror(int dr &#x3D; 1)&#123;        if(dr &#x3D;&#x3D; 1)&#123;            &#x2F;&#x2F; 沿着x轴翻转            swap(vec[0], vec[1]);            swap(vec[2], vec[3]);        &#125;else&#123;            &#x2F;&#x2F; 沿着y轴翻转            swap(vec[0], vec[2]);            swap(vec[1], vec[3]);        &#125;        update();    &#125;    void transpose(int dr &#x3D; 1)&#123;        if(dr &#x3D;&#x3D; 1)&#123;            &#x2F;&#x2F; 沿着y &#x3D; x 翻转            swap(vec[1], vec[2]);        &#125;else&#123;            &#x2F;&#x2F; 沿着x + y &#x3D; n 翻转            swap(vec[0], vec[3]);        &#125;        update();    &#125;    void rotate(int dr &#x3D; 1)&#123;        transpose();        if(dr &#x3D;&#x3D; 1)&#123;            &#x2F;&#x2F; 顺时针            mirror(1);        &#125;else&#123;            &#x2F;&#x2F; 逆时针            mirror(0);        &#125;        update();    &#125;    Point mapping(Point p)&#123;        return &#123;vec[0].first + dx.first * p.first + dy.first * p.second, vec[0].second + dx.second * p.first + dy.second * p.second&#125;;    &#125;    Point dx, dy;    array&lt;Point, 4&gt; vec;private:    void update()&#123;        int xlim &#x3D; abs(vec[2].first - vec[0].first) + abs(vec[2].second - vec[0].second);        int ylim &#x3D; abs(vec[1].first - vec[0].first) + abs(vec[1].second - vec[0].second);        assert(xlim &gt; 0 and ylim &gt; 0);        dx &#x3D; Point&#123;(vec[2].first - vec[0].first) &#x2F; xlim, (vec[2].second - vec[0].second) &#x2F; xlim&#125;;        dy &#x3D; Point&#123;(vec[1].first - vec[0].first) &#x2F; ylim, (vec[1].second - vec[0].second) &#x2F; ylim&#125;;    &#125;&#125;;class Solution &#123;public:    bool composeCube(vector&lt;vector&lt;string&gt;&gt;&amp; shapes) &#123;        int sz &#x3D; shapes[0].size();        int cnt &#x3D; sz * sz * 2 + (sz - 1) * (sz - 2) * 4;        for(auto&amp; vec: shapes) &#123;            for(auto&amp; row: vec)&#123;                for(auto&amp; c: row)&#123;                    if(c &#x3D;&#x3D; &#39;1&#39;) --cnt;                &#125;            &#125;        &#125;        if(cnt !&#x3D; 0) return false;        typedef Rectangle::Point Point;        Rectangle rec(sz, sz);        vector&lt;Rectangle&gt; recd;        for(int i &#x3D; 0; i &lt; 4; ++i)&#123;            recd.push_back(rec);            &#x2F;&#x2F;recd.back().debug();            rec.rotate(0);        &#125;        vector&lt;Rectangle&gt; recs(6, Rectangle&#123;sz, sz&#125;);        auto&amp;&amp; isCon &#x3D; [&amp;](int x, int y, int sx, int sy)&#123;            for(int i &#x3D; 0; i &lt; sz; ++i)&#123;                auto px &#x3D; recd[sx].mapping(&#123;0, i&#125;);                auto py &#x3D; recd[sy].mapping(&#123;0, sz - 1 - i&#125;);                auto ppx &#x3D; recs[x].mapping(px);                auto ppy &#x3D; recs[y].mapping(py);                if(i &#x3D;&#x3D; 0 or i &#x3D;&#x3D; sz - 1)&#123;                    if(shapes[x][ppx.first][ppx.second] &#x3D;&#x3D; shapes[y][ppy.first][ppy.second] and shapes[y][ppy.first][ppy.second] &#x3D;&#x3D; &#39;1&#39;)&#123;                        return false;                    &#125;                &#125;else if(shapes[x][ppx.first][ppx.second] &#x3D;&#x3D; shapes[y][ppy.first][ppy.second])&#123;                    return false;                &#125;            &#125;            return true;        &#125;;        auto&amp;&amp; show &#x3D; [&amp;](int i, int x, int y)&#123;            return recs[i].mapping(&#123;x, y&#125;);        &#125;;        vector&lt;int&gt; idx(6);        vector&lt;vector&lt;int&gt;&gt; dr &#x3D; &#123;&#123;-1, 0, -1, -1&#125;, &#123;1, 2, 3, 4&#125;, &#123;5, -1, -1, -1&#125;&#125;;        auto&amp;&amp; print &#x3D; [&amp;](int q)&#123;            for(int i &#x3D; 0; i &lt; 3; ++i)&#123;                for(int j &#x3D; 0; j &lt; sz; ++j)&#123;                    for(int k &#x3D; 0; k &lt; 4; ++k)&#123;                        for(int l &#x3D; 0; l &lt; sz; ++l)&#123;                            if(dr[i][k] &lt; 0) cout &lt;&lt; &quot; &quot;;                            else if(dr[i][k]  &gt; q) cout &lt;&lt; &quot;?&quot;;                            else&#123;                                auto rt &#x3D; show(idx[dr[i][k]], j, l);                                cout &lt;&lt; shapes[idx[dr[i][k]]][rt.first][rt.second];                            &#125;                        &#125;                        cout &lt;&lt; &quot; &quot;;                    &#125;                    cout &lt;&lt; endl;                &#125;                cout &lt;&lt; endl;            &#125;        &#125;;        auto&amp;&amp; check &#x3D; [&amp;](int sz)&#123;            bool ok &#x3D; true;            for(int i &#x3D; 0; i &lt; 4 and i + 1 &lt;&#x3D; sz and ok; ++i)&#123;                if(!isCon(idx[0], idx[i + 1], 3 - i, 0))&#123;                    ok &#x3D; false;                &#125;            &#125;            for(int i &#x3D; 0; i &lt; 4 and i + 1 &lt;&#x3D; sz and (i + 1) % 4 + 1 &lt;&#x3D; sz and ok; ++i)&#123;                if(!isCon(idx[i + 1], idx[(i + 1) % 4 + 1], 1, 3)) ok &#x3D; false;            &#125;            if(sz &#x3D;&#x3D; 5)&#123;                for(int i &#x3D; 0; i &lt; 4 and ok; ++i)&#123;                    if(!isCon(idx[5], idx[i + 1], i, 2)) ok &#x3D; false;                &#125;            &#125;&#x2F;&#x2F;            if(ok)&#123;&#x2F;&#x2F;                print(sz);&#x2F;&#x2F;                cout &lt;&lt; &quot;ok&quot; &lt;&lt; endl;&#x2F;&#x2F;            &#125;            return ok;        &#125;;        idx[0] &#x3D; 0;        vector&lt;int&gt; vis(6, 0);        vis[0] &#x3D; 1;        auto&amp;&amp; dfs &#x3D; [&amp;](auto&amp;&amp; self, int cur) -&gt; bool&#123;            if(cur &gt;&#x3D; 6) &#123;                return true;            &#125;            for(int i &#x3D; 1; i &lt; 6; ++i)&#123;                if(vis[i] &#x3D;&#x3D; 0)&#123;                    idx[cur] &#x3D; i;                    vis[i] &#x3D; 1;                    for(int m &#x3D; 0; m &lt; 2; ++m)&#123;                        for(int r &#x3D; 0; r &lt; 4; ++r)&#123;                            if(check(cur)) &#123;                                if(self(self, cur + 1)) return true;                            &#125;                            recs[i].rotate();                        &#125;                        recs[i].mirror();                    &#125;                    vis[i] &#x3D; 0;                &#125;            &#125;            return false;        &#125;;        if(dfs(dfs, 1)) return true;        recs[0].mirror();        if(dfs(dfs, 1)) return true;        return false;    &#125;&#125;;</code></pre></div></figure><p>最后打印一下第一个样例的匹配情况：</p><figure><div class="code-wrapper"><pre class="line-numbers language-none" data-start="1"><code class="language-none">&#x2F;&#x2F; 样例1    000             110             000         001 011 011 011 011 010 110 111 010 000 011 011 001             011             001   </code></pre></div></figure>]]>
      </content:encoded>
    </item>
    <item>
      <title>2022春天的实习面试经历</title>
      <link>https://www.dianhsu.com/2022/05/10/intern-interviews/</link>
      <description>
        <![CDATA[<blockquote>
<p>目前已经接到微软的实习offer，所以将之前的面试内容都贴在这里了</p>
</blockquote>
<h2 id="20220228-微软实习正式批一面"><a class="markdownIt-Anchor"]]>
      </description>
      <author>Dian Hsu</author>
      <category domain="https://www.dianhsu.com/categories/%E9%9D%A2%E8%AF%95/">面试</category>
      <category domain="https://www.dianhsu.com/tags/%E9%9D%A2%E8%AF%95/">面试</category>
      <category domain="https://www.dianhsu.com/tags/Microsoft/">Microsoft</category>
      <category domain="https://www.dianhsu.com/tags/ByteDance/">ByteDance</category>
      <category domain="https://www.dianhsu.com/tags/Alibaba/">Alibaba</category>
      <category domain="https://www.dianhsu.com/tags/Hulu/">Hulu</category>
      <pubDate>Tue, 10 May 2022 17:12:11 GMT</pubDate>
      <content:encoded>
        <![CDATA[<blockquote><p>目前已经接到微软的实习offer，所以将之前的面试内容都贴在这里了</p></blockquote><h2 id="20220228-微软实习正式批一面"><a class="markdownIt-Anchor" href="#20220228-微软实习正式批一面"></a> 2022.02.28 微软实习正式批一面</h2><ul><li>面试时长：约45分钟</li><li>面试经过：<ol><li>面试官自我介绍</li><li>我的自我介绍</li><li>根据简历上面问了一下项目和本科毕业之后的经历</li><li>写了一道算法题：数组中的逆序对数目（归并排序，平衡树，树状数组或线段树）<br />参考：<a href="https://leetcode-cn.com/problems/shu-zu-zhong-de-ni-xu-dui-lcof/">数组中的逆序对</a> <figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">#include &lt;bits&#x2F;stdc++.h&gt;using namespace std;int handle(vector&lt;int&gt;&amp; vec)&#123;    int ret &#x3D; 0;    int sz &#x3D; vec.size();    if(sz &lt;&#x3D; 1) return 0;    int mid &#x3D; sz &#x2F; 2;    vector&lt;int&gt; vec1, vec2;    vec1.insert(vec1.end(), vec.begin(), vec.begin() + mid);    vec2.insert(vec2.end(), vec.begin() + mid, vec.end());    ret +&#x3D; handle(vec1);    ret +&#x3D; handle(vec2);    vec.clear();    int pos1 &#x3D; 0, pos2 &#x3D; 0;    while(pos1 &lt; vec1.size() or pos2 &lt; vec2.size())&#123;        if(pos1 &lt; vec1.size() and pos2 &lt; vec2.size())&#123;            if(vec1[pos1] &gt; vec2[pos2])&#123;                ret +&#x3D; vec1.size() - pos1;                vec.push_back(vec2[pos2++]);            &#125;else&#123;                vec.push_back(vec1[pos1++]);            &#125;        &#125;else if(pos1 &lt; vec1.size())&#123;            vec.push_back(vec1[pos1++]);        &#125;else if(pos2 &lt; vec2.size())&#123;            ret +&#x3D; vec1.size() - pos1;            vec.push_back(vec2[pos2++]);        &#125;    &#125;    return ret;&#125;    int main()&#123;    vector&lt;int&gt; arr&#123;7,6,8,3,5&#125;;    int ans &#x3D; handle(arr);    cout &lt;&lt; ans &lt;&lt; endl;    vector&lt;int&gt; brr&#123;9,8,7,6,5,4,3,2,1&#125;;    vector&lt;int&gt; crr&#123;1,2,3,4,5,6,7,8,9&#125;;    vector&lt;int&gt; drr&#123;1, 1&#125;;    cout &lt;&lt; handle(brr) &lt;&lt; endl;    cout &lt;&lt; handle(crr) &lt;&lt; endl;    cout &lt;&lt; handle(drr) &lt;&lt; endl;    return 0;&#125;</code></pre></div></figure></li><li>场景题：考虑在一个短链接生成系统中，如何设计短链接生成。</li><li>反问：简历有没有什么问题</li></ol></li></ul><h2 id="20220301-字节跳动飞书实习一面"><a class="markdownIt-Anchor" href="#20220301-字节跳动飞书实习一面"></a> 2022.03.01 字节跳动飞书实习一面</h2><ul><li><p>面试时长：约28分钟</p></li><li><p>面试经过：</p><ol><li>自我介绍</li><li>问了一下之前在百度实习的项目的内容</li><li>C++的面向对象的特点</li><li>多态的实现形式</li><li>讲一讲Python语言和C++语言的区别</li><li>三次握手的过程</li><li>保证TCP传输的可靠性的实现</li><li>浏览器输入网址之后的过程</li><li>C++虚函数，纯虚函数，虚析构函数</li><li>C++的vector的底层实现</li><li>智能指针（用过，但是不太熟。直接说没怎么用）</li><li>线程和进程</li><li>虚拟内存</li><li>进程调度的状态</li><li>写个代码：给定一个query字符串，和pattern字符串，问能不能在pattern字符串中插入若干个小写字母，使得query串和pattern串一致。</li></ol><table><thead><tr><th>query</th><th>pattern</th><th>结果</th></tr></thead><tbody><tr><td><code>FoolBar</code></td><td><code>FB</code></td><td><code>true</code></td></tr><tr><td><code>FoolBarTest</code></td><td><code>FB</code></td><td><code>false</code></td></tr><tr><td><code>FoolBar</code></td><td><code>FBa</code></td><td><code>true</code></td></tr><tr><td><code>FoolBar</code></td><td><code>FaB</code></td><td><code>false</code></td></tr></tbody></table>  <figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">#include &lt;bits&#x2F;stdc++.h&gt;using namespace std;bool match(string query, string pattern)&#123;    int n &#x3D; query.size(), m &#x3D; pattern.size();    int i &#x3D; 0, j &#x3D; 0;    while(i &lt; n or j &lt; m)&#123;        if(i &lt; n and j &lt; m)&#123;            if(query[i] &#x3D;&#x3D; pattern[j])&#123;                i++;                j++;            &#125;else if(islower(query[i]))&#123;                ++i;            &#125;else&#123;                return false;            &#125;        &#125;else if(j &lt; m)&#123;            return false;        &#125;else if(i &lt; n)&#123;            if(isupper(query[i]))                return false;            ++i;        &#125;    &#125;    return true;&#125;int main()&#123;    cout &lt;&lt; match(&quot;FoolBar&quot;, &quot;FB&quot;) &lt;&lt; endl;    cout &lt;&lt; match(&quot;FoolBarTest&quot;, &quot;FB&quot;) &lt;&lt; endl;    cout &lt;&lt; match(&quot;FoolBar&quot;, &quot;FBa&quot;) &lt;&lt; endl;    cout &lt;&lt; match(&quot;FoolBar&quot;, &quot;FaB&quot;) &lt;&lt; endl;    return 0;&#125;</code></pre></div></figure><ol start="16"><li>反问：没什么问题</li></ol></li></ul><h2 id="20220304-微软实习正式批三面"><a class="markdownIt-Anchor" href="#20220304-微软实习正式批三面"></a> 2022.03.04 微软实习正式批三面</h2><blockquote><p>备注：一面和二面是平行的，一面通过之后就没有二面了。</p></blockquote><ul><li>面试时长：约36分钟</li><li>面试经过：<ol><li>我的自我介绍</li><li>问了下在百度实习的情况</li><li>写一道算法题<br />类似的题目：<a href="https://leetcode-cn.com/problems/swap-for-longest-repeated-character-substring/">单字符重复子串的最大长度</a>   <figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">&#x2F;*Given an array with around 100K elements, each element is within [0,100K ], how to get maxsubsequencelength with same value if you have a opportunity to swap two elements?2 2 3 1 4 5 1 1 0 1 7 &#x3D;&gt; 4*&#x2F;#include &lt;bits&#x2F;stdc++.h&gt;using namespace std;typedef pair&lt;int, int&gt; PII;int solve(vector&lt;int&gt; arr)&#123;    if(arr.size() &#x3D;&#x3D; 0) return 0;    map&lt;int, vector&lt;PII&gt;&gt; mp;    int n &#x3D; arr.size();    int cur &#x3D; 0;    for(int i &#x3D; 0; i &lt; n; ++i)&#123;        if(arr[i] !&#x3D; arr[cur])&#123;            &#x2F;&#x2F; cur, i - 1            if(mp.count(arr[cur])) mp[arr[cur]].push_back(&#123;cur, i - 1&#125;);            else mp[arr[cur]] &#x3D; &#123;PII&#123;cur, i - 1&#125;&#125;;            cur &#x3D; i;        &#125;    &#125;    if(cur &lt; n)&#123;        mp[arr[cur]].push_back(&#123;cur, n - 1&#125;);    &#125;    int ans &#x3D; 1;    for(auto&amp; [_, vec]: mp)&#123;        if(vec.size() &#x3D;&#x3D; 1)&#123;            auto&amp; it &#x3D; vec.front();            ans &#x3D; max(ans, it.second - it.first + 1);        &#125;else if(vec.size() &#x3D;&#x3D; 2)&#123;            auto&amp; it1 &#x3D; vec[0];            auto&amp; it2 &#x3D; vec[1];            if(it1.second + 2 &#x3D;&#x3D; it2.first)&#123;                ans &#x3D; max(ans, it2.second - it2.first + 1 + it1.second - it1.first + 1);            &#125;else&#123;                ans &#x3D; max(ans, it1.second - it1.first + 2);                ans &#x3D; max(ans, it2.second - it2.first + 2);            &#125;        &#125;else&#123;            int m &#x3D; vec.size();            ans &#x3D; max(ans, vec[0].second - vec[0].first + 2);            for(int i &#x3D; 1; i &lt; m; ++i)&#123;                ans &#x3D; max(ans, vec[i].second - vec[i].first + 2);                if(vec[i - 1].second + 2 &#x3D;&#x3D; vec[i].first)&#123;                    ans &#x3D; max(ans, vec[i].second - vec[i].first + 1 + vec[i - 1].second - vec[i - 1].first + 1 + 1);                &#125;            &#125;        &#125;    &#125;    return ans;&#125;int main()&#123;    cout &lt;&lt; solve(&#123;2, 2, 3, 1, 4, 5, 1, 1, 0, 1, 7&#125;) &lt;&lt; endl;    cout &lt;&lt; solve(&#123;2, 2, 2, 1, 2, 2, 2&#125;) &lt;&lt; endl;    cout &lt;&lt; solve(&#123;2, 2, 1, 2, 2, 2&#125;) &lt;&lt; endl;    cout &lt;&lt; solve(&#123;2, 1, 2, 2, 1, 2, 2, 2&#125;) &lt;&lt; endl;    cout &lt;&lt; solve(&#123;2&#125;) &lt;&lt; endl;    cout &lt;&lt; solve(&#123;&#125;) &lt;&lt; endl;    return 0;&#125;</code></pre></div></figure></li><li>有三枚硬币，指定一种得到1/7概率的情况。</li><li>反问：部门情况</li></ol></li></ul><h2 id="20220308-字节跳动飞书实习二面"><a class="markdownIt-Anchor" href="#20220308-字节跳动飞书实习二面"></a> 2022.03.08 字节跳动飞书实习二面</h2><ul><li>面试时长：约60分钟</li><li>面试经过：<ol><li><p>自我介绍</p></li><li><p>介绍下在百度实习的项目</p></li><li><p>介绍下去年做的项目</p></li><li><p>讲讲几种设计模式</p></li><li><p>写个单例</p>   <figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">class Config&#123;private:    Config(): ptr(nullptr)&#123;&#125;    void update(string s)&#123;        delete ptr;        ptr &#x3D; new string(s);    &#125;    string query()&#123;        if(ptr &#x3D;&#x3D; nullptr) ptr &#x3D; new string(&quot;123&quot;);        return *ptr;    &#125;&#125;;static int val &#x3D; 0;int query()&#123;    return val;&#125;void update(int x)&#123;    val &#x3D; x;&#125;</code></pre></div></figure></li><li><p>说一下数据库的隔离模式</p></li><li><p>开放性问题：讲一下如何考虑操作系统拷贝一个文件</p></li><li><p>开放性问题：word文档如何单词纠错</p></li><li><p>算法题：<a href="https://leetcode-cn.com/problems/trapping-rain-water/">一维接雨水</a></p>   <figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">class Solution &#123;public:    int trap(vector&lt;int&gt;&amp; height) &#123;        vector&lt;int&gt; st1, st2;        vector&lt;int&gt; pref(height.size());        int n &#x3D; height.size();        pref[0] &#x3D; height[0];        for(int i &#x3D; 1; i &lt; n; ++i)&#123;            pref[i] &#x3D; pref[i - 1] + height[i];        &#125;        for(int i &#x3D; 0; i &lt; n; ++i)&#123;            while(!st2.empty() and height[i] &gt;&#x3D; height[st2.back()]) st2.pop_back();            st2.push_back(i);        &#125;        for(int i &#x3D; n - 1; i &gt;&#x3D; 0; --i)&#123;            while(!st1.empty() and height[i] &gt;&#x3D; height[st1.back()]) st1.pop_back();            st1.push_back(i);        &#125;        reverse(st1.begin(), st1.end());        reverse(st2.begin(), st2.end());        int ans &#x3D; 0;        for(int i &#x3D; 1; i &lt; st1.size(); ++i)&#123;            int curp &#x3D; st1[i], prep &#x3D; st1[i - 1];            int ts &#x3D; height[prep] * (curp - prep - 1) - (pref[curp - 1] - pref[prep]);            ans +&#x3D; ts;        &#125;        for(int i &#x3D; 1; i &lt; st2.size(); ++i)&#123;            int curp &#x3D; st2[i], prep &#x3D; st2[i - 1];            int ts &#x3D; height[prep] * (prep - curp - 1) - (pref[prep - 1] - pref[curp]);            ans +&#x3D; ts;        &#125;        int tl &#x3D; st1.back(), tr &#x3D; st2.back();        ans +&#x3D; (tr - tl) * height[tl] - (pref[tr] - pref[tl]);        return ans;    &#125;&#125;;</code></pre></div></figure></li><li><p>反问：部门情况和面试流程</p></li></ol></li></ul><h2 id="20220310-蚂蚁集团大安全技术部实习一面"><a class="markdownIt-Anchor" href="#20220310-蚂蚁集团大安全技术部实习一面"></a> 2022.03.10 蚂蚁集团大安全技术部实习一面</h2><blockquote><p>备注：电话面试，感觉闲聊为主</p></blockquote><ul><li>面试时长：约25分钟</li><li>面试过程：<ol><li>面试官自我介绍</li><li>我的自我介绍</li><li>询问百度实习经过</li><li>一顿闲聊</li><li>重载函数的规则和底层实现</li><li>const关键字</li><li>malloc、free和new、delete</li><li>delete和delete []</li><li>函数的调用约定（参数的入栈顺序）</li><li>vector扩容</li><li>什么情况下vector的迭代器会失效（扩容和删除元素）</li><li>动态库和静态库（没写过）</li><li>跨平台开发</li><li>本科和研究生之间的gap</li><li>有空去做下笔试（补充，3月14日完成笔试）</li><li>反问：没啥问题</li><li>面试官再介绍了一下蚂蚁和阿里</li></ol></li></ul><h2 id="20220314-字节跳动飞书实习三面"><a class="markdownIt-Anchor" href="#20220314-字节跳动飞书实习三面"></a> 2022.03.14 字节跳动飞书实习三面</h2><ul><li>面试时长：22分钟</li><li>面试经过：<br />hr面，主要了解下个人情况和职业规划等。<br />本来是视频面，因为通讯不好，改成电话面试。</li></ul><h2 id="20220316-美团实习一面"><a class="markdownIt-Anchor" href="#20220316-美团实习一面"></a> 2022.03.16 美团实习一面</h2><blockquote><p>备注：主动终止流程</p></blockquote><h2 id="20220329-hulu实习一面"><a class="markdownIt-Anchor" href="#20220329-hulu实习一面"></a> 2022.03.29 Hulu实习一面</h2><ul><li>面试时长：60分钟</li><li>面试经过：<ol><li>C++虚函数是怎么实现的</li><li>struct和class区别</li><li>C和C++区别</li><li>除了面向过程和面向对象，你还知道其他编程思想吗</li><li>说一下inline</li><li>选个项目讲一下</li><li>写个题吧<br />给定一个正整数<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">n</span></span></span></span>，计算出满足一下条件的整数<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">n</span></span></span></span>的个数：<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn><mo>&lt;</mo><mi>k</mi><mo>&lt;</mo><mi>n</mi></mrow><annotation encoding="application/x-tex">1 &lt; k &lt; n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.68354em;vertical-align:-0.0391em;"></span><span class="mord">1</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">&lt;</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.73354em;vertical-align:-0.0391em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">&lt;</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathnormal">n</span></span></span></span>，并且<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi></mrow><annotation encoding="application/x-tex">k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span></span></span></span>和<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi><mo>+</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">k + 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.77777em;vertical-align:-0.08333em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span>具有相同个数的的正因数。<br />比如<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>14</mn></mrow><annotation encoding="application/x-tex">14</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span><span class="mord">4</span></span></span></span>的正因数有<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>1</mn><mo separator="true">,</mo><mn>2</mn><mo separator="true">,</mo><mn>7</mn><mo separator="true">,</mo><mn>14</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(1, 2, 7, 14)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">2</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">7</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">1</span><span class="mord">4</span><span class="mclose">)</span></span></span></span>，<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>15</mn></mrow><annotation encoding="application/x-tex">15</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span><span class="mord">5</span></span></span></span>的正因数有<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>1</mn><mo separator="true">,</mo><mn>3</mn><mo separator="true">,</mo><mn>5</mn><mo separator="true">,</mo><mn>15</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(1, 3, 5, 15)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">3</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">5</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord">1</span><span class="mord">5</span><span class="mclose">)</span></span></span></span>， <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi><mo>=</mo><mn>14</mn></mrow><annotation encoding="application/x-tex">k=14</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span><span class="mord">4</span></span></span></span>满足条件。<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>3</mn><mo>≤</mo><mi>n</mi><mo>≤</mo><mn>1</mn><msup><mn>0</mn><mn>7</mn></msup><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(3 \leq n \leq 10^7)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">3</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">≤</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.7719400000000001em;vertical-align:-0.13597em;"></span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">≤</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1.064108em;vertical-align:-0.25em;"></span><span class="mord">1</span><span class="mord"><span class="mord">0</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141079999999999em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">7</span></span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span> <figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">&#x2F;&#x2F; 面试的时候只想到基于调和级数的O(n*log(n))的算法，这里补充一下O(n)的算法&#x2F;&#x2F; 基于线性筛，http:&#x2F;&#x2F;oi-wiki.com&#x2F;math&#x2F;number-theory&#x2F;sieve&#x2F;#_10#include &lt;vector&gt;#include &lt;iostream&gt;using namespace std;vector&lt;int&gt; SieveOfEuler(int n)&#123;    vector&lt;int&gt; ret(n + 1, 0); &#x2F;&#x2F;约数个数    vector&lt;int&gt; vis(n + 1, 0); &#x2F;&#x2F;是否访问标记    vector&lt;int&gt; prime; &#x2F;&#x2F; 质数表    vector&lt;int&gt; num(n + 1, 0); &#x2F;&#x2F; 最小质数因子出现次数    ret[1] &#x3D; 1;    for(int i &#x3D; 2; i &lt;&#x3D; n; ++i)&#123;        if(!vis[i])&#123;            vis[i] &#x3D; 1;            prime.push_back(i);            ret[i] &#x3D; 2;            num[i] &#x3D; 1;        &#125;        for(auto&amp; it: prime)&#123;            if(n &#x2F; it &lt; i) break;            vis[it * i] &#x3D; 1;            if(i % it &#x3D;&#x3D; 0)&#123;                num[i * it] &#x3D; num[i] + 1;                ret[i * it] &#x3D; ret[i] &#x2F; num[i * it] * (num[i * it] + 1);                break;            &#125;else&#123;                num[i * it] &#x3D; 1;                ret[i * it] &#x3D; ret[i] * 2;            &#125;        &#125;    &#125;    return ret;&#125;int main()&#123;    int n &#x3D; 1e7;    auto&amp;&amp; res &#x3D; SieveOfEuler(n);    int ans &#x3D; 0;    for(int i &#x3D; 1; i &lt;&#x3D; n; ++i)&#123;        if(res[i] &#x3D;&#x3D; res[i - 1])&#123;            ++ans;        &#125;    &#125;    cout &lt;&lt; ans &lt;&lt; endl;    return 0;&#125;</code></pre></div></figure></li><li>面试官介绍了一下部门情况</li></ol></li></ul><h2 id="20220411-hulu实习二面"><a class="markdownIt-Anchor" href="#20220411-hulu实习二面"></a> 2022.04.11 Hulu实习二面</h2><ul><li>面试时间：60分钟</li><li>面试经过：<ol><li>自我介绍一下</li><li>讲一下之前的百度实习项目</li><li>先写个题吧 <figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">&#x2F;&#x2F; 有两个没有刻度的水桶和一个蓄水量无限的水池，一个容量为x升，&#x2F;&#x2F; 另一个容量为y升，每次取水&#x2F;倒水视为一次操作，现需要量出z升水&#x2F;&#x2F; Q1：能否实现&#x2F;&#x2F; Q2：最少需要多少次操作#include &lt;iostream&gt;#include &lt;vector&gt;#include &lt;queue&gt;#include &lt;map&gt;#include &lt;algorithm&gt;#include &lt;numeric&gt;using namespace std;typedef tuple&lt;int, int, int&gt; TII;int solve(int x, int y, int z) &#123;    if (z % gcd(x, y) !&#x3D; 0) return -1; &#x2F;&#x2F; 不可实现    queue&lt;tuple&lt;int, int, int&gt;&gt; Q;    map&lt;tuple&lt;int, int, int&gt;, int&gt; mp;    tuple&lt;int, int, int&gt; ini&#123;0, 0, 0&#125;;    mp[ini] &#x3D; 0;    Q.push(ini);    while (!Q.empty()) &#123;        TII it &#x3D; Q.front();        Q.pop();        if (get&lt;2&gt;(it) &#x3D;&#x3D; z) &#123;            return mp[it];        &#125;        auto[tx, ty, tz] &#x3D; it;        TII nex1&#123;x, ty, tz&#125;;    &#x2F;&#x2F; 将水从池子中灌入到x容器中        TII nex2&#123;tx, y, tz&#125;;    &#x2F;&#x2F; 将水从池子中灌入到y容器中        TII nex3&#123;min(tx + ty, x), max(0, tx + ty - x), tz&#125;; &#x2F;&#x2F; 将水从y容器灌入到x容器中        TII nex4&#123;max(tx + ty - y, 0), min(tx + ty, y), tz&#125;; &#x2F;&#x2F; 将水从x容器灌入到y容器中        TII nex5&#123;tx, 0, tz&#125;;    &#x2F;&#x2F; 清空y容器        TII nex6&#123;0, ty, tz&#125;;    &#x2F;&#x2F; 清空x容器        TII nex7&#123;0, ty, tz + tx&#125;;   &#x2F;&#x2F; 将水从x容器中灌入到z        TII nex8&#123;tx, 0, tz + ty&#125;;   &#x2F;&#x2F; 将水从y容器中灌入到z        vector&lt;TII&gt; nexs&#123;nex1, nex2, nex3, nex4, nex5, nex6, nex7, nex8&#125;;        for (auto &amp;nx: nexs) &#123;            if (!mp.count(nx) and get&lt;2&gt;(nx) &lt;&#x3D; z) &#123;                mp[nx] &#x3D; mp[it] + 1;                Q.push(nx);            &#125;        &#125;    &#125;    return -1;&#125;int main() &#123;    cout &lt;&lt; solve(1, 2, 3) &lt;&lt; endl;    cout &lt;&lt; solve(2, 2, 1) &lt;&lt; endl;    cout &lt;&lt; solve(2, 2, 2) &lt;&lt; endl;    cout &lt;&lt; solve(2, 2, 0) &lt;&lt; endl;    cout &lt;&lt; solve(3, 1, 2) &lt;&lt; endl;    return 0;&#125;</code></pre></div></figure></li><li>那就再写个题吧 <figure><div class="code-wrapper"><pre class="line-numbers language-cpp" data-language="cpp" data-start="1"><code class="language-cpp">&#x2F;&#x2F; 在电影院中有一排座位，0代表空，1代表已经有人在座位上了，现在又来了2个人，因为疫情需要，把它安排某个没人的座位上，使任意两人直接距离最大，返回其中最短的距离。(座位足够的情况下)&#x2F;&#x2F; 以下是面试的时候和面试官讨论的情况：&#x2F;&#x2F; 所有区间两边都有人 - 要么做一个区间，要么两个不同区间&#x2F;&#x2F; 有1-2个一边没有人的区间&#x2F;&#x2F; 只有一个空区间#include &lt;string&gt;#include &lt;iostream&gt;using namespace std;&#x2F;&#x2F; 求左右端点都是1的最小的区间和最大三个区间的长度tuple&lt;int, int, int, int&gt; subSolve(const string&amp; str)&#123;    assert(str.front() &#x3D;&#x3D; &#39;1&#39; and str.back() &#x3D;&#x3D; &#39;1&#39;);    int cur &#x3D; 0;    int max1 &#x3D; 0, max2 &#x3D; 0, max3 &#x3D; 0;    int ans &#x3D; INT_MAX;    auto&amp;&amp; update &#x3D; [&amp;](int val)&#123;        if(val &gt; max1)&#123;            max3 &#x3D; max2;            max2 &#x3D; max1;            max1 &#x3D; val;        &#125;else if(val &gt; max2)&#123;            max3 &#x3D; max2;            max2 &#x3D; max1;        &#125;else if(val &gt; max3)&#123;            max3 &#x3D; val;        &#125;    &#125;;    for(int i &#x3D; 1; i &lt; (int)str.size(); ++i)&#123;        if(str[i] &#x3D;&#x3D; &#39;1&#39;)&#123;            if(i - cur &gt; 1)&#123;                update(i - cur);            &#125;            ans &#x3D; min(ans, i - cur);            cur &#x3D; i;        &#125;    &#125;    return &#123;ans, max1, max2, max3&#125;;&#125;int solve(string str)&#123;    if(str.front() &#x3D;&#x3D; &#39;1&#39; and str.back() &#x3D;&#x3D; &#39;1&#39;)&#123; &#x2F;&#x2F; 左右端点都是1的情况        auto [minv, mx1, mx2, mx3] &#x3D; subSolve(str);        return min(minv, max(mx1 &#x2F; 3, mx2 &#x2F; 2));    &#125;else if(str.front() &#x3D;&#x3D; &#39;1&#39;)&#123;   &#x2F;&#x2F; 左端点是1的情况        auto rPos &#x3D; str.find_last_of(&#39;1&#39;);        if(rPos &#x3D;&#x3D; 0)&#123;            return (int)(str.size() - 3 - rPos) &#x2F; 2 + 1;        &#125;else&#123;            auto [minv, mx1, mx2, mx3] &#x3D; subSolve(str.substr(0, rPos + 1));            int len &#x3D; str.size() - 1 - rPos;            int tmpv &#x3D; solve(str.substr(0, rPos + 1));            int ttv &#x3D; min(len - 1, min(minv, mx1 &#x2F; 2));            return min(minv, max((int)(str.size() - 3 - rPos) &#x2F; 2 + 1, max(tmpv, ttv)));        &#125;    &#125;else if(str.back() &#x3D;&#x3D; &#39;1&#39;)&#123;    &#x2F;&#x2F; 右端点是1的情况，翻转一下字符串，就得到了上面的一种情况        reverse(str.begin(), str.end());        return solve(str);    &#125;else&#123;  &#x2F;&#x2F; 左右端点都是0的情况        auto lPos &#x3D; str.find_first_of(&#39;1&#39;);        if(lPos &#x3D;&#x3D; string::npos)&#123;   &#x2F;&#x2F; 没有1的情况            return str.size() - 1;        &#125;else&#123;  &#x2F;&#x2F; 有1的情况            int rPos &#x3D; str.find_last_of(&#39;1&#39;);            int candinate &#x3D; min(str.size() - rPos - 1, lPos);            auto tmp &#x3D; max(solve(str.substr(0, rPos + 1)), solve(str.substr(lPos)));            if(lPos !&#x3D; rPos)&#123;                auto [minv, x1, x2, x3] &#x3D; subSolve(str.substr(lPos, rPos - lPos + 1));                candinate &#x3D; min(candinate, minv);            &#125;            return max(candinate, tmp);        &#125;    &#125;&#125;int main()&#123;    cout &lt;&lt; solve(&quot;1000100001&quot;) &lt;&lt; endl;    cout &lt;&lt; solve(&quot;10000000000000100101&quot;) &lt;&lt; endl;    cout &lt;&lt; solve(&quot;1000001001&quot;) &lt;&lt; endl;    cout &lt;&lt; solve(&quot;0000010001&quot;) &lt;&lt; endl;    cout &lt;&lt; solve(&quot;000000000010001&quot;) &lt;&lt; endl;    cout &lt;&lt; solve(&quot;000100000000000000000&quot;) &lt;&lt; endl;    return 0;&#125;</code></pre></div></figure></li></ol></li></ul><h2 id="20220506-hulu实习三面寄"><a class="markdownIt-Anchor" href="#20220506-hulu实习三面寄"></a> 2022.05.06 Hulu实习三面（寄）</h2><ul><li>面试时间: 90分钟</li><li>面试经过:<ol><li>自我介绍</li><li>聊一下百度实习的Contributions</li><li>问了一下简历上第二个项目的情况</li><li>了解Redis吗</li><li>问了一下消息队列的熟悉情况</li><li>最后还有很多时间，写个算法题：<a href="https://www.acwing.com/problem/content/181/">八数码</a><br />这个题通常有三种解法：1，朴素BFS；2.双向BFS；3.A*算法。其中可以用康托展开来保存访问状态。（再也不敢说康托展开是useless了）<br />然后面试的时候，凭着对康托展开微弱的印象，现场手搓，果然搓不出来（寄）。<br />然后A*又忘记怎么求八数码的估价。<br />然后一紧张，忘记能双向BFS优化一下。<br />最后面试官说时间不多了，10分钟写完bfs草草下机（寄）。</li></ol></li></ul><h2 id="20220518-hulu实习四面寄"><a class="markdownIt-Anchor" href="#20220518-hulu实习四面寄"></a> 2022.05.18 Hulu实习四面（寄）</h2><h2 id="20220518-hulu实习五面寄"><a class="markdownIt-Anchor" href="#20220518-hulu实习五面寄"></a> 2022.05.18 Hulu实习五面（寄）</h2><h2 id="最后补充一下笔试情况"><a class="markdownIt-Anchor" href="#最后补充一下笔试情况"></a> 最后补充一下笔试情况</h2><ul><li>微软：3道编程题，全部完成。代码细节可以优化，时间复杂度无法优化。</li><li>字节跳动：内推免笔试</li><li>美团：5道编程题，第二题只过了55%，其余都做出来了</li><li>阿里巴巴：3道编程题，全部做出来了</li><li>亚马逊：3道编程题，全部做出来了</li><li>Hulu：3道编程题，全部做出来了</li></ul>]]>
      </content:encoded>
    </item>
  </channel>
</rss>
