Walter_Fang

【置顶】致新访客

Walter_Fang — Wed, 07 Jan 2026 00:00:00 GMT

你好，欢迎访问我的博客！在广阔的互联网中，无论是任何原因，欢迎您来到这个页面！

这里主要写了一些平时想到的东西以及一些发电内容（x）。做了头图的文章大多是值得一看的，剩下的看心情随便翻翻就行啦ww

评论系统采用 Waline，可以直接发表评论，不过我看到违规的 or 不合适的评论会删。

总之，欢迎来这里看看！顺便挂个友链（bushi）

【置顶】博客维护教程

Walter_Fang — Tue, 06 Jan 2026 00:00:00 GMT

好吧这篇文章其实是因为我自己还不是很熟悉 Firefly 主题下的一些文章格式配置以及特殊的 features 所以为了避免写文章时出乱子而给我自己看的。不过如果你想接此了解一下 Firefly 主题的特性也不是不行。文章会按功能分段。

KaTeX 支持

行内公式 (Inline)

行内公式使用单个 $ 符号包裹。

例如：欧拉公式 $e^{i\pi} + 1 = 0$ 是数学中最优美的公式之一。

质能方程 $E = mc^2$ 也是家喻户晓。

块级公式 (Block)

块级公式使用两个 $$ 符号包裹，会居中显示。

$$ \int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi} $$

$$ x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a} $$

复杂示例

矩阵 (Matrices)

$$ \begin{pmatrix} a & b \ c & d \end{pmatrix} \begin{pmatrix} \alpha & \beta \ \gamma & \delta \end{pmatrix} = \begin{pmatrix} a\alpha + b\gamma & a\beta + b\delta \ c\alpha + d\gamma & c\beta + d\delta \end{pmatrix} $$

极限与求和 (Limits and Sums)

$$ \sum_{n=1}^{\infty} \frac{1}{n^2} = \frac{\pi^2}{6} $$

$$ \lim_{x \to 0} \frac{\sin x}{x} = 1 $$

麦克斯韦方程组 (Maxwell's Equations)

$$ \begin{aligned} \nabla \cdot \mathbf{E} &= \frac{\rho}{\varepsilon_0} \ \nabla \cdot \mathbf{B} &= 0 \ \nabla \times \mathbf{E} &= -\frac{\partial \mathbf{B}}{\partial t} \ \nabla \times \mathbf{B} &= \mu_0\mathbf{J} + \mu_0\varepsilon_0\frac{\partial \mathbf{E}}{\partial t} \end{aligned} $$

化学方程式 (Chemical Equations)

$$ \ce{CH4 + 2O2 -> CO2 + 2H2O} $$

符号	代码	渲染结果
Alpha	`\alpha`	$\alpha$
Beta	`\beta`	$\beta$
Gamma	`\Gamma`	$\Gamma$
Pi	`\pi`	$\pi$
Infinity	`\infty`	$\infty$
Right Arrow	`\rightarrow`	$\rightarrow$
Partial	`\partial`	$\partial$

Markdown 扩展功能

GitHub 仓库卡片

可以通过以下操作添加链接到 GitHub 仓库的动态卡片，在页面加载时，仓库信息会从 GitHub API 获取。例如：

::github{repo="walterfang12/blog"}

使用代码 ::github{repo="walterfang12/blog"} 创建 GitHub 仓库卡片。

::github{repo="walterfang12/blog"}

提醒框

支持以下类型的提醒框：note tip important warning caution

:::note 突出显示用户应该考虑的信息，即使在快速浏览时也是如此。 :::

:::tip 可选信息，帮助用户更成功。 :::

:::important 用户成功所必需的关键信息。 :::

:::warning 由于潜在风险需要用户立即注意的关键内容。 :::

:::caution 行动的负面潜在后果。 :::

基本语法

:::note
突出显示用户应该考虑的信息，即使在快速浏览时也是如此。
:::

:::tip
可选信息，帮助用户更成功。
:::

自定义标题

可以自定义提醒框的标题。

:::note[我的自定义标题] 这是一个带有自定义标题的注释。 :::

:::note[我的自定义标题]
这是一个带有自定义标题的注释。
:::

GitHub 语法

[!TIP] 也支持 GitHub 语法。

> [!NOTE]
> 也支持 GitHub 语法。

> [!TIP]
> 也支持 GitHub 语法。

剧透

您可以为文本添加剧透。文本也支持 Markdown 语法。

内容 :spoiler[被隐藏了哈哈]！

内容 :spoiler[被隐藏了 **哈哈**]！

Mermaid 图表

流程图示例

流程图非常适合表示流程或算法步骤。

graph TD
    A[开始] --> B{条件检查}
    B -->|是| C[处理步骤 1]
    B -->|否| D[处理步骤 2]
    C --> E[子过程]
    D --> E
    subgraph E [子过程详情]
        E1[子步骤 1] --> E2[子步骤 2]
        E2 --> E3[子步骤 3]
    end
    E --> F{另一个决策}
    F -->|选项 1| G[结果 1]
    F -->|选项 2| H[结果 2]
    F -->|选项 3| I[结果 3]
    G --> J[结束]
    H --> J
    I --> J

时序图示例

时序图显示对象之间随时间的交互。

sequenceDiagram
    participant User as 用户
    participant WebApp as 网页应用
    participant Server as 服务器
    participant Database as 数据库

    User->>WebApp: 提交登录请求
    WebApp->>Server: 发送认证请求
    Server->>Database: 查询用户凭据
    Database-->>Server: 返回用户数据
    Server-->>WebApp: 返回认证结果
    
    alt 认证成功
        WebApp->>User: 显示欢迎页面
        WebApp->>Server: 请求用户数据
        Server->>Database: 获取用户偏好
        Database-->>Server: 返回偏好设置
        Server-->>WebApp: 返回用户数据
        WebApp->>User: 加载个性化界面
    else 认证失败
        WebApp->>User: 显示错误消息
        WebApp->>User: 提示重新输入
    end

甘特图示例

甘特图非常适合显示项目进度和时间线。

gantt
    title 网站开发项目时间线
    dateFormat  YYYY-MM-DD
    axisFormat  %m/%d
    
    section 设计阶段
    需求分析      :a1, 2023-10-01, 7d
    UI设计                 :a2, after a1, 10d
    原型创建        :a3, after a2, 5d
    
    section 开发阶段
    前端开发      :b1, 2023-10-20, 15d
    后端开发       :b2, after a2, 18d
    数据库设计           :b3, after a1, 12d
    
    section 测试阶段
    单元测试              :c1, after b1, 8d
    集成测试       :c2, after b2, 10d
    用户验收测试   :c3, after c2, 7d
    
    section 部署
    生产环境部署     :d1, after c3, 3d
    发布                    :milestone, after d1, 0d

类图示例

类图显示系统的静态结构，包括类、属性、方法及其关系。

classDiagram
    class User {
        +String username
        +String password
        +String email
        +Boolean active
        +login()
        +logout()
        +updateProfile()
    }
    
    class Article {
        +String title
        +String content
        +Date publishDate
        +Boolean published
        +publish()
        +edit()
        +delete()
    }
    
    class Comment {
        +String content
        +Date commentDate
        +addComment()
        +deleteComment()
    }
    
    class Category {
        +String name
        +String description
        +addArticle()
        +removeArticle()
    }
    
    User "1" -- "*" Article : 写作
    User "1" -- "*" Comment : 发表
    Article "1" -- "*" Comment : 拥有
    Article "1" -- "*" Category : 属于

状态图示例

状态图显示对象在其生命周期中经历的状态序列。

stateDiagram-v2
    [*] --> 草稿
    
    草稿 --> 审核中 : 提交
    审核中 --> 草稿 : 拒绝
    审核中 --> 已批准 : 批准
    已批准 --> 已发布 : 发布
    已发布 --> 已归档 : 归档
    已发布 --> 草稿 : 撤回
    
    state 已发布 {
        [*] --> 活跃
        活跃 --> 隐藏 : 临时隐藏
        隐藏 --> 活跃 : 恢复
        活跃 --> [*]
        隐藏 --> [*]
    }
    
    已归档 --> [*]

饼图示例

饼图非常适合显示比例和百分比数据。

pie title 网站流量来源分析
    "搜索引擎" : 45.6
    "直接访问" : 30.1
    "社交媒体" : 15.3
    "推荐链接" : 6.4
    "其他来源" : 2.6

嵌入视频

只需从 YouTube 或其他平台复制嵌入代码，然后将其粘贴到 markdown 文件中。

---
title: 在文章中嵌入视频
published: 2023-10-19
// ...
---

<iframe width="100%" height="468" src="https://www.youtube.com/embed/5gIf0_xpFPI?si=N1WTorLKL0uwLsU_" title="YouTube video player" frameborder="0" allowfullscreen></iframe>

YouTube

Bilibili

文章的 Front-matter

---
title: 我的第一篇博客文章
published: 2023-09-09
description: 这是我新 Astro 博客的第一篇文章。
image: ./cover.jpg
tags: [前端, 开发]
category: 前端开发
draft: false
---

属性	描述
`title`	文章标题。
`published`	文章发布日期。
`pinned`	是否将此文章置顶在文章列表顶部。
`description`	文章的简短描述。显示在首页上。
`image`	文章封面图片路径。<br/>1. 以 `http://` 或 `https://` 开头：使用网络图片<br/>2. 以 `/` 开头：`public` 目录中的图片<br/>3. 不带任何前缀：相对于 markdown 文件的路径
`tags`	文章标签。
`category`	文章分类。
`licenseName`	文章内容的许可证名称。
`author`	文章作者。
`sourceLink`	文章内容的来源链接或参考。
`draft`	如果这篇文章仍是草稿，则不会显示。
`slug`	自定义文章 URL 路径。如果不设置，将使用文件名作为 URL。

文章文件的放置位置

您的文章文件应放置在 src/content/posts/ 目录中。您也可以创建子目录来更好地组织您的文章和资源。

src/content/posts/
├── post-1.md
└── post-2/
    ├── cover.png
    └── index.md

自定义文章 URL (Slug)

什么是 Slug？

Slug 是文章 URL 路径的自定义部分。如果不设置 slug，系统将使用文件名作为 URL。

Slug 使用示例

示例 1：使用文件名作为 URL

---
title: 我的第一篇博客文章
published: 2023-09-09
---

文件：src/content/posts/my-first-blog-post.md URL：/posts/my-first-blog-post

示例 2：自定义 Slug

---
title: 我的第一篇博客文章
published: 2023-09-09
slug: hello-world
---

文件：src/content/posts/my-first-blog-post.md URL：/posts/hello-world

示例 3：中文标题使用英文 Slug

---
title: 如何使用 Firefly 博客主题
published: 2023-09-09
slug: how-to-use-firefly-blog-theme
---

文件：src/content/posts/firefly-guide.md URL：/posts/how-to-use-firefly-blog-theme

Slug 使用建议

使用英文和连字符：my-awesome-post 而不是 my awesome post
保持简洁：避免过长的 slug
具有描述性：让 URL 能够反映文章内容
避免特殊字符：只使用字母、数字和连字符
保持一致性：在整个博客中使用相似的命名模式

注意事项

Slug 一旦设置并发布，建议不要随意更改，以免影响 SEO 和已存在的链接
如果多个文章使用相同的 slug，后面的文章会覆盖前面的
Slug 会自动转换为小写

活成常人：我的2025

Walter_Fang — Sat, 27 Dec 2025 00:00:00 GMT

首先我要声明标题没有借鉴任何其他文章（）。敲下这行字，我才意识到这才只是我今年第二次在博客里倒电子榨菜啊（

想挑自己喜欢的看的直接戳右边目录。

今年真的发生了超级多乱七八糟的事情，很多事情到现在为止已经有些混淆了。所以我要先列个表。

年初入坑 CS2 并加入 Arch 神教。
3、4 月左右开学并迎接 LingmoOS Team 新成员。
5、6 月参加市英语、数学素养营并分别取得 3 星、4 星。
6 月底跳槽另一所外地学校（中考前暂时），并开始异地寄宿学习生活，退出 Arch 神教并回归 Windows 11。
7 月底去蓉找了 Imken。（大概是今年最开心的一天）
完美错过 10 月的 CCF CSP 并在日后的 vp 中取得 J2 300pts 和 S2 170pts 的成绩。
下半年实现高联数学从 0 到 0.1 的突破，并在今年的联赛中取得一试 44 pts 和二试 0 的好成绩。
年底清理了大量无必要的社交平台好友，并且重回 Arch 神教且开始使用（目前体验过最好的）Wayland 平铺式窗口合成器 Niri。

杂七杂八的意义不大的就不放了。

关于生活方面

从去年夏天加入 Lingmo OS Team 到现在为止也有一年多了吧，这中间通过交流一群（这也是我唯一活跃的群聊）认识了很多人，包括 OrPudding 等几位神佬，同时也浅入了 Vela 圈，同时也接触了对于技术方面很懂/一般/不懂/笨笨的人，跟群友的接触中离赛博孔子和赛博傻逼又近了一步（x）。

今年 7 月底的时候去了一趟蓉找 Imken。除去这次的话，我也已经一年半没出门旅行了。去看了烂尾楼，四院，然后去逛了金沙遗址博物馆，并在万象城试图给 Macbook 样机装 Homebrew 未果，然后蹭了 KFC 就回去了。

去蓉那几天真的超级开心啊，感觉那会完全没有任何压力，可能算得上是我今年最开心最放松的时候了。其他时间我都是牛马。

之后就跳槽了外地某中学（这里顺提一嘴到中考前为止是临时的，谣言不轻信）开始了寄宿学习生活。那边的学生成绩都是顶尖级别，我在其中学习就很吃力，压力也很大，并且从 9 月左右到现在在学校里也经历了很多从未设想的很使人心烦的事情，也看到了、参与了一些有关人情世故的纷争，又亲身经历了好几次有关乱七八糟的很让人心烦的事情。现在非常心累，无力。大概形容下就是无动于衷。对于眼前发生的事情完全无能为力又无法作任何反抗。

差不多就这些吧。今年生活这方面倒还行，家庭也比较稳定，网络上（我身上）也没出啥大乱子，不过比较遗憾的是在蓉只呆了一天，没有去别的地方玩，放假的时候都在打游戏没干什么正事以及亲手葬送掉了和之前以为关系很好的朋友的友谊。

接下来可能还会有国内出游 or 约面基的计划，不过看来是得在中考之后了。

但是今年暑假我不会有任何空。

游戏方面

音游

Phigros

今年实现了飞升！rks 从14出头涨到了 15.59（截至今日），同时也性了好几首之前望而生畏的 IN&AT 16，15也收了好几首，总的来说今年 Phi 进步超大（大部分音游时间确实也都在打 Phi）。

Milthm

算是后来追起的移动端良作吧，剧情写的很不错，玩法也很新颖，大概是今年玩的第二多的移动端了。

Arcaea/Lanota/Malody...

剩下的移动端今年没怎么玩。

A Dance Of Fire And Ice

城镇宽判勉强过。两年了还是没爬出新手村啊。不过玩的也少。

舞萌DX

下半年刚入坑，还没玩明白。

Galgame

推完了冬树 & 冬树 After & 千恋万花 & 不存在的你和我，接下来可能会考虑退魔女的夜宴，不过得看有没有时间。个人感觉做的最好的是不存在的你和我。可能因为 Meta 比较合自己胃口。

其他的

寒假刚入坑，然后就染上了。一发不可收拾/wul

魔法少女的魔女审判

第一次玩弹丸论破，很好玩，不过还没打完一周目。日后还会继续玩。

互联网方面

还是被动社交，并且现在不是很愿意扩列。不过如果跟我有不少共同话题也聊得来的话可以来找我。欢迎挂友链。

目前应该是 QQ 和 Bilibili 最活跃，Steam 其次，其他平台不活跃。联系方式翻这里，戳主页那个大大的头像下面的按钮也可。

技术方面

我也很想成为一位有点技术力的轻度 Developer，可惜我不配。

身边的很多人都会很多东西，也各自有很多自己的小项目，但我基本上没有。

今年到目前为止还会折腾的项目如下：

LightlyShaders-Plasma6

在我的 Github 上公开了，本来是寒假刚入 Arch 用 KDE 那会为了窗口圆角写的，后来换 Niri 了学业也忙就荒废了。以后有空偶尔会更新。

Autonomic

下半年换了米环9p 之后为了控制在校使用时间写的一个锁机类快应用，还不是很完善，写好了会公开。（可能要圈点米）

LingmoArm

应该是我有生以来整过最大的活了。把自家的 Lingmo OS 移植到 ARM 平台上，现在已经完成了一小半，预计年假时完成。

剩下的先不放了吧，省的到时候又鸽子。

关于学业

非常感谢新学校的全体老师、教练（新英语老师除外），我的 whk 相比以前提升了很多，社会背起来也快了，语文也进步了，就是现在科学有点拖后腿。特别谢谢两位 MO 教练，帮我用少量时间追上了大量高联的知识。我也想努力在 MO 这条路上继续走下去！

这里还要预祝自己减肥成功，中考加油。

另外的

今年总体来说虽然波折很多，但是也算是总体比较顺利的一年。收到了新学校老师 & 教练组的生日祝福，重新捡起了和 Imken 的关系（和我一样因为学业原因很难聊上），认识了几位新的网友，和原校同学的关系经历了⬆⬇⬆⬇⬆的过程，认识了几位神佬以及被几位陌生人 & 萌新认作佬并收获了中考祝福（很感动很感谢）。

音乐平台切换到了 wyy，歌品提升不少，同时也多了解了一些技术圈的知识，换上了 AtlasOS + Arch(Niri) 的双系统配置（舒服！）

特别感谢（无先后顺序）我自己，我的家长，Imken，Lingmo OS 开发组全体成员，scm，Ashivd（原校同学），（原校同学），（原校同学），Lingmo OS 交流 1 群几位聊得来的群友，刮风落雪，以及 machrui。

浏览器自动补全

由于数据来自 Google Chrome 但我今年用了小半年的 Zen Browser 和 Qute Browser 所以数据可能有一定误差，图一乐就行。

A: arch.icekylin.online 这个是一点都不意外吧，毕竟从今年年初入 Arch 神教开始自己好说歹说也起码装了百来次 Arch，基本每次都要翻这个教程。

B: blog.imken.moe/ 蛤？我今年看了这么多次 Imken 博客吗？我本来都已经做好准备是B站了（）

C: chat.deepseek.com

D: dg6.me

E: evolution-x.org 小小的意外吧，本来以为会是其他网站。不过 Evolution X 确实是非常优秀的类原生项目，感觉仅次于 RisingOS。非常推荐一玩！

F: fanyi.baidu.com

G: github.com 虽然但是我今年几乎 $0$ commit /dk/dk/dk

H: https://blog.walterfang.site/

I: imken.moe/ 两发！

J: https://stackoverflow.com/questions/71616781/where-are-the-microsoft-visual-c-2015-2022-redistributable-x64-packages-inst 这个是因为 11 月某日游玩某游戏时被沟槽的 vc 依赖卡了几百次然后顺便上了几百次这个网站。

K: kiro.dev

L: luogu.com.cn 正常发挥。尽管我已经退役一年多了。

M: mail.163.com 理论上来说其实是公司的企业邮箱用的多一点，但是网页邮箱使用频率确实 163 大于 gmail。

N: https://github.com/YaLTeR/niri 超级棒的 Wayland 合成器！完全碾压 Hyprland！

O: oi-wiki.org 尽管退役了但却是还是经常回去这里看看，我也不知道为啥（）

P: pixiv.net [数据删除]

Q: blog.qwq.my 同事博客，偶尔会看看吧，主要是因为Q开头的网站基本没啥。

R: https://blog.rickyxrc.cc

S: steamdb.info

T: trae.ai 有点小意外，因为我只上过两次这个网站（

U: uupdump.net 合理吧，99%的人下 Windows iso 的地方。（剩下1%是msdn）

V: vscodium.com 我现在正在敲这行字所使用的软件（

W: waveshare.net/wiki/RP2040-LCD-1.28 一个早就买来的小玩具了，暑假那会写了个轻量的计步检测，算是 micropy 毕业作了（（

X: x.com/__Walter_Fang__ 除了 qzone 意外我唯一活跃的社交平台。

Y: yhcres.top

Z: zhihu.com/question/491927339 我目前看到过质量最好的帖子。

2507成都行

Walter_Fang — Sat, 09 Aug 2025 00:00:00 GMT

图片大小晚点调，初稿一坨过两天润色

首先你可以通过文章发布时间看出我有多鸽。

Day 0

在机构做了一张 $2017$ 高考数学真卷，喜提 $109/150$ pts,不过算错 $23$ 分。九点多到家，顺便和 Imken 约好了 $27$ 号在塔子山公园地铁站 $\text{D}$ 出口碰头。由于第二天要半夜起来到栎社赶飞机，所以十点左右就睡了。

Day 1

凌晨 $3$ 点起来出发，我爸送我和我妈去宁波栎社国际机场，到机场大概 $5$ 点左右。然后猛然想起忘了给 Imken 带礼物，于是匆忙在机场旁边的礼品店买了一盒茶香糕，然后起飞。

大概十点左右下飞机然后赶到酒店，由于早起实在太累了索性跟我妈在酒店点了个外卖顺便补了个午觉。起来后去天府广场地下的夜市找了点吃的当晚餐，然后饭后带我妈去 IFS 看了著名的熊猫屁股顺便在太古里转了转。回来后顺便和 Imken 约了下第二天见面的地点，洗洗睡了。

（回来路上碰到了CCB）

Day 3

由于要面基比较兴奋所以起得比较早，大概八点半就到地铁站了，九点多跟 Imken 碰上了头，先坐地铁去看了著名的烂尾楼，然后跟着 Imken 在三环外转了大半圈并路过了四院，最后在茶店子（好像）坐了新修的 $27$ 号线去看了西部郊区的外景。（好看）

然后差不多就中午了，回天府广场地下吃午饭，神秘的是在宁波就有的一模一样的品牌在成都竟然没有一道菜不是辣的，最后只好无奈吃了辣的。午饭的时候顺便商量好了下午去金沙遗址博物馆（成都其他大多名气景点以前都去过了）。

大概下午一点多到了地铁站出口，在博物馆逛了一个多小时。中间 Imken 反复问了好几遍 ta 有没有提起“馆内是否有临时展”，有些神秘了。更神秘的是在临时展厅居然看到了从咱慈溪市博借去展览的青瓷。

顺便提醒一下正在阅读本文的各位。

大概三点多出博物馆，然后回市区的路上我突发奇想问了问 Ricky 在不在，于是 Imken 就把 ta 叫了出来，于是我们三个人就在万象城的 Apple 官方店面积了。等人的时候我突发奇想试图在 Macbook Pro 上跑 neofetch，结果安装 Homebrew 的时候直接要求装一整个 XCode，没招了。隔壁 Imken 试图在上面跑 cargo build 但是忘记了 rustup 的地址好像（？

没多久 Ricky 到了，我们先是在 Apple 店里拍了 gh profile 的合照，然后 Ricky 很大方的提出要请客吃 KFC，于是我便~~很不要脸的~~蹭了一个九珍圣代和一堆鸡块（（

由于 Ricky 没法留下来吃晚饭，所以两个人送我到人民广场北（我酒店附近）就走了，临走前把礼物给了。

这次面积真的超开心！非常非常期待下次！！

Day 4~7

后面几天陪我妈去了川西藏族自治区那边玩，中间设备反复炸，路上赶车时间很长也挺累的，这里就放几张照片了。

后面放一点最后一天晚上赶专线从双流到天府以及返程的照片。

CSP 2024 游记 & 退役记

Walter_Fang — Mon, 28 Oct 2024 00:00:00 GMT

还在施工

前言

2023年9月16日，$\text{CSP}$ $2023$ 第 $1$ 轮结束后，我暂时退役。2024年10月27日，$\text{CSP}$ $2024$ 第 $2$ 轮结束后我的 $\text{OI}$ 生涯正式结束。

$\text{Day}$ $0$

卷 whk。上课到8：50，回家简单复习下睡了

$\text{Day}$ $1$

醒的很早，7：45出发去余中，路上简单翻了下一本通和梦熊满分之路的错题和自己整理的考前复习提纲，大概9：00进考场。校门口碰到了 zhz，刚好在一个考场，一起进去了。

上午考场在知行楼恶臭 $114$ 教师，同考场的还有 zhz 和 xyy ~~，极其幸运的吸走了 xyy 的 rp~~。考前碰到了 SL 机房 $2023$ 界所有同学和傅里叶，大概9：25准备开考。这个时候烦人的雨开始下了。

这次初赛来送水的 xxs 是真的多，大半个考场的 xxs。zhz 右边的神金赛时持续发电，唱歌转身抄答案，监考老师居然没管。

11：30交卷。收卷的时候撇到 xyy 把 $\text{MB}$ 和 $\text{bit}$ 进率算错了/cf。

跟傅里叶一起出的考场，简单对了几题感觉我们都能在 $95$ $\text{pts}$ 以上就放心了。雨还没停，傅里叶好心借我伞但是由于我太高了所以婉拒了。

中午跟父母去一家海鲜楼随便吃了点，顺便估了 lg 的分，大概 $95.5$ $\text{pts}$。然后去市政府对面的公园~~复习了一会~~开了 $1$ 小时 Milthm 和 Phi，1：50左右出发回余中，路上看了下 Linux 一些基本指令。

到校门发现没有熟人，索性一个人进去。下午考场在 $4$ 号教学楼 $305$。一上楼就看见了 fjz 和 zkn，~~激动地冲上去抱在了一起~~。下午和 hxz 一个考场，xxs 还是和上午一样的多，不过不影响我发挥。

4：30交卷，走出考场又碰到了 SL 机房所有同学，索性一起出来了。感觉都比较稳，yty 说他有点发挥失误，安慰了下。听他们 SL 的人说初二比完也都退了，有点难过。出去之后对了下 lg 的答案，$66$ $\text{pts}$，~~还挺吉利~~。晚上还有课，急着先出发了。路上和 lottle、ch和傅里叶稍微聊了几句。

到慈溪时间有点晚了，索性罗森买了个饭团赶紧上课，今天上的二次函数倒挺简单，感觉课上 zqy 和 syf 有点兴奋，同时了解到大概有好几个人提高组估分 $60^+$ $\text{pts}$，心沉了。回家开 abc，~~但是只开了 2 题~~。

题解：P4526 【模板】自适应辛普森法 2

Walter_Fang — Mon, 21 Oct 2024 00:00:00 GMT

自适应辛普森法题解与学习笔记

前言

首先看到P4525 【模板】自适应辛普森法 1。这题是很好的辛普森板题，但是用牛顿-莱布尼茨公式就可以算出答案：

当 $a=0$ 时， $$ \begin{aligned} \int \frac{c x+d}{a x+b} d x & =\int \frac{c x+d}{b} d x \ & =\frac{1}{b}\left(\int c x d x\right)+\frac{1}{b}\left(\int d d x\right) \ & =\frac{c x^2}{2 b}+\frac{d x}{b} \end{aligned} $$ 当 $a\not=0$ 时， $$ \begin{aligned} \int \frac{c x+d}{a x+b} d x & =\int \frac{\frac{c}{a}(a x+b)-\frac{b c}{a}+d}{a x+b} d x \ & =\left(\int \frac{c}{a} d x\right)+\left(\left(-\frac{b c}{a}+d\right) \int \frac{1}{a x+b} d x\right) \ & =\frac{c x}{a}+(d-\frac{b c}{a}) \frac{\ln |a x+b|}{a} \end{aligned} $$ 虽然这样我们就可以通过这题，但是肯定还要讲一下自适应辛普森法。

算法介绍

$\text{Simpson}$ 法的思想是将原曲线近似为一段段抛物线，再求每一段的面积。具体地，我们令 $f(x)=\frac{c x+d}{a x+b}, g(x)=A x^2+B x+C$ 为拟合函数，则有 $$ \begin{aligned} \int_L^R f(x) d x & \approx \int_L^R g(x) \ & =\frac{A}{3}\left(b^3-a^3\right)+\frac{B}{2}\left(b^2-a^2\right)+C(b-a) \ & =\frac{b-a}{6}\left(A a^2+B a+C+A b^2+B b+C+A(b-a)^2+2B(b-a)+4 C\right) \ & =\frac{b-a}{6}\left(f(a)+f(b)+f\left(\frac{b-a}{2}\right)\right) \end{aligned} $$ 介绍完 $\text{Simpson}$ 法后我们再回过头看这题。

题解

题目要求$\int_0^{\infty}x^{\frac{a}{x}-x}\text{d}x$，肯定不能用牛顿-莱布尼茨公式。经过讨论可得：

当 $a<0$ 时，$\lim _{x \rightarrow 0} x^{\frac{a-x^2}{x}}=e^{\lim _{x \rightarrow 0} \frac{a-x^2}{x} \ln x}=+\infty$ ，原函数发散，输出 $\text{orz}$。

当 $a \geq 0$ 时。 $\lim _{x \rightarrow+\infty} x^2 x^{\frac{a-x^2}{x}}=e^{\lim _{x \rightarrow \infty} \frac{a-x^2+2 x}{x} \ln x}=0$ ，原函数收敛。用 $\text{Simpson}$ 法解决即可。

#include<bits/stdc++.h>
using namespace std;
const double eps=1e-10;
double a;
double f(double x){return pow(x,a/x-x);}
double Simpson(double l,double r){return (f(l)+f(r)+4*f((l+r)/2))*(r-l)/6;}
double Query(double l,double r,double t){
 double mid=(l+r)/2,x=Simpson(l,mid),y=Simpson(mid,r);
 if(fabs(x+y-t)<=1e-9)return t;
 else return Query(l,mid,x)+Query(mid,r,y);
}
int main(){
 cin>>a;
 if(a<0)return cout<<"orz",0;
 cout<<fixed<<setprecision(5)<<Query(eps,20,Simpson(eps,20));
}

题解：P11214 【MX-J8-T2】黑洞

Walter_Fang — Sun, 20 Oct 2024 00:00:00 GMT

前言

优化过的暴搜时间复杂度 $O(2^n)$，理论过不了，但是过了。傻逼数据组。

题意

给定 $n$ 及 $n$ 个正整数 $m_i$ 和 $n$ 个正整数 $a_i$，保证 $a_i\leq m_i$。

构造长度为 $n$ 的数组 $b$ 使得存在一个整数 $k \geq 0$，使得对每个 $1 \leq i \leq n$，都有 $\lvert a_i - b_i \rvert = k$ 且 $b_i\leq m_i$。

试求出 $b_i$ 所有的可能的数量总和，对 $10^9+7$ 取模。

解析

观察不等式 $\lvert a_i-b_i\rvert=k$，注意到对于每个数只有加和减两种可能，暴搜算一遍即可。

当然这样是会超时的，所以我们要考虑优化。注意到每一次能将每个数改变多少只取决于最小的一个，故按可改变范围的最小值排序，搜到后面的最小值超过了当前最小值时即可中止。

代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=1e6+10,p=1e9+7,inf=1e18;
ll n,i,x,ans,m[N],table[N],f[N];
struct Node{ll x,y;}a[N];
void dfs(ll x,ll dep){
 if(dep>n)return (ans+=x)%=p,void();
 if(x<=f[dep])return (ans+=x*table[n-dep+1]%p)%=p,void();
 dfs(min(x,a[dep].x),dep+1);dfs(min(x,a[dep].y),dep+1);
}
int main(){
 cin>>n;table[0]=ans=1;
 for(i=1;i<=n;i++)cin>>m[i],table[i]=(table[i-1]<<1)%p;
 for(i=1;i<=n;i++)cin>>x,a[i].x=m[i]-x,a[i].y=x-1;
 stable_sort(a+1,a+1+n,[](Node x,Node y){return min(x.x,x.y)<min(y.x,y.y);});
 f[n+1]=inf;
 for(i=n;i;i--)f[i]=min(f[i+1],min(a[i].x,a[i].y));
 dfs(inf,1);
 cout<<ans;
}

题解：P11217 【MX-S4-T1】「yyOI R2」youyou 的垃圾桶

Walter_Fang — Sun, 20 Oct 2024 00:00:00 GMT

前言

这题卡人的地方很多，做法是线段树加二分。

听说标程时间复杂度线性，期待住了。

解析

读完题再结合数据范围即可发现每个垃圾桶的伤害数组要用线段树或树状数组维护。这里我开了一个线段树。然后计算每场战斗的评分就需要二分了。我们二分查找一个尽可能大的位置 $p$ 使得 $s\times2^p\leq W$，其中 $s$ 表示当前这轮战斗每个垃圾桶的伤害总和。得出 $p$ 之后的输出直接调用线段树即可。注意若伤害刚好等于 $W$ 时要加个特判。

几个坑点

$1$ 要写成 unsigned long long 类型不然会炸掉 $10$ 分。
要写快读不然实测 $2$ 秒的程序会跑到 $10$ 秒。

代码

写的有点丑了。

#include<bits/stdc++.h>
#define ls p<<1ull
#define rs p<<1ull|1ull
namespace FastIO{
 char *p1,*p2,buf[1<<14];
 #define getchar() (p1==p2&&(p2=(p1=buf)+fread(buf,1,(1<<14),stdin),p1==p2)?EOF:*p1++)
 template <typename T>
 inline void read(T& x){
     x=0;
     register int t=1;
     register char ch=getchar();
     while(ch<'0'||ch>'9'){
         if(ch=='-')t=-1;
         ch=getchar();
     }
     while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
     x*=t;
 }
 template <typename T>
 void write(T x){
     if(x<0)putchar('-'),x=-x;
     if(x>9)write(x/10);
     putchar(x%10^48);
 }
 template <typename T>
 inline void writeln(T x,char sep='\n'){
  write(x);putchar(sep);
 }
}
using namespace FastIO;
using namespace std;
typedef long long ll;
const ll N=2e5+10;
ll n,q,W,s,i,p,l,r,k,mid,a[N];
struct info{ll s,id,tag;}tr[N<<2];
void Build(ll p,ll l,ll r){
    if(l==r)return tr[p].s=a[l],tr[p].id=l,void();
    ll mid=(l+r)>>1ull;
    Build(ls,l,mid);Build(rs,mid+1ull,r);
    tr[p].s=tr[ls].s+tr[rs].s;
}
void Pushdown(ll p,ll l,ll r){
    ll mid=(l+r)>>1ull;
    if(tr[p].tag)tr[ls].s+=tr[p].tag*(mid-l+1ull),tr[rs].s+=tr[p].tag*(r-mid),tr[ls].tag+=tr[p].tag,tr[rs].tag+=tr[p].tag,tr[p].tag=0;
}
void change(ll p,ll l,ll r,ll L,ll R,ll k){
    if(L<=l&&R>=r)return tr[p].tag+=k,tr[p].s+=(r-l+1ull)*k,void();
    Pushdown(p,l,r);
    ll mid=(l+r)>>1ull;
    if(L<=mid)change(ls,l,mid,L,R,k);
    if(R>mid)change(rs,mid+1ull,r,L,R,k);
    tr[p].s=tr[ls].s+tr[rs].s;
}
ll Query(ll p,ll l,ll r,ll k,ll now){
    if(tr[p].id) return tr[p].id;
    Pushdown(p,l,r);
    ll mid=(l+r)>>1ull;
    if(tr[ls].s*k>=now)return Query(ls,l,mid,k,now);
    return Query(rs,mid+1ull,r,k,now-tr[ls].s*k);
}
int main(){
    cin>>n>>q>>W;
    for(i=1ull;i<=n;i++)read(a[i]),s+=a[i];
    Build(1ull,1ull,n);
    while(q--){
        read(l);read(r);read(k);p=0;
        change(1ull,1ull,n,l,r,k);
        s+=(r-l+1ull)*k;
        l=1ull;r=log2(W/s);
        while(l<=r){
            mid=(l+r)>>1ull;
            if((((1ull<<mid+1ull)-1ull)*s)<=W)p=max(p,mid),l=mid+1ull;
            else r=mid-1ull;
        }
        if((((1ull<<p+1ull)-1ull)*s)==W)write(n*(p+1ull)-1ull),putchar('\n');
        else write(Query(1ull,1ull,n,(1ull<<p+1ull),W-(((1ull<<p+1ull)-1ull)*s))+n*(p+1ull)-1ull),putchar('\n');
    }
}

转载作文『落雪』

刮风落雪 — Sat, 19 Oct 2024 00:00:00 GMT

雪

记忆里的雪大抵都已忘却。父母开着车，载我去许久未去的老家，路上，我才发现落雪了。

我盯著车窗发呆，不知是在看什么，空虚的与路道一般，只有车，路道，绿化带，反反复复。我想过去，现在，未来，路上大约也是此般枯燥；这是一条我从未见过的路道，但又如此熟悉，想起来我见过的路道大约都一样，只不过更小时候的多了一些烂漫，但又说不清多的究竟是什么了。看著，我却什么都不忍想了，我对著车窗吐气，那玻璃配合的为我多了一层雾气。在雾气中，我闭上了眼睛，想著休息一番，便能见上祖父母，聊聊天也是好的。蒙眬中，我却看到一片片白花，飘在空中，被冷风吹散，洒落下来。在模糊的灰色天空里，它显得分明，真美！我只能发出这样的感叹，我也分不清它到底是我的幻想还是现实，但愿是真的。随着愿望，我睁开了眼睛。那是一片片雪花，那么薄，那么薄，落到窗上就消失了，剩下的是窗上那滑润的一滴水。

雪下得依然是那么小，但至少也给这单调的道路多了些情趣。带雪的记忆似乎被唤醒了；身在南国，雪向来是一种奢求，哪怕只是一点。我想起几年前在长城看到的雪，是那么美，那么壮丽。我曾记得雪花随著朔风，从我身旁刮过，那建筑连同劲挺的树，都被蒙上了白色；可我经历的却好像又不是这样。至于到底有何壮丽，我大约也不晓得了。它好像从脑中投射出来，与眼前的这番小雪映在一起。我欣喜若狂，想去亲自感受雪，但奈何在现实中隔了一户窗，只能在车内待著。于是我仔细一看，又回到那单调的小路，小小的雪，那来长城万里雪飘？

我在荒诞的想象中，回到了现实。确切地说，我还是不记得长城的雪，但好像一直有那幅画面，时隐时现，我不在乎现在的小雪，倒想融入到那样的画面里去，便又闭上了眼，可那出现的还是小路，绿化带，只多了在风中凌乱的少得可怜的雪，我再度睁开了眼。我像之前一样朝著玻璃吐气，想象同现实像窗上起的雾气一样，都模糊了。我亦是如此。

雪停了。但它在我眼中似乎还在，它存在于我的幻想中，多么想留住，可它不知会不会像现实中的雪一样消逝。于是我不再幻想，朝著玻璃叹了口气，从那雾气里看到，外面大抵是很冷的。

2023年1月

P2880 做题笔记

Walter_Fang — Wed, 16 Oct 2024 00:00:00 GMT

萌新不会线段树于是写了自己改的树状数组，跑得还挺快。

#include<bits/stdc++.h>
using namespace std;
const int N=5e5+10,inf=2e9;
int n,q,i,l,r,T_min[N],T_max[N],a[N];
int lowbit(int x){return x&(-x);}
void Add(int p,int v){while(p<=n)T_min[p]=min(T_min[p],v),T_max[p]=max(T_max[p],v),p+=lowbit(p);}
int Query_min(int l,int r){return (l<r?(l<r-lowbit(r)?min(T_min[r],Query_min(l,r-lowbit(r))):min(a[r],Query_min(l,r-1))):a[l]);}
int Query_max(int l,int r){return (l<r?(l<r-lowbit(r)?max(T_max[r],Query_max(l,r-lowbit(r))):max(a[r],Query_max(l,r-1))):a[l]);}
int main(){
 cin>>n>>q;
 for(i=0;i<N;i++)T_min[i]=inf,T_max[i]=-inf;
 for(i=1;i<=n;i++)cin>>a[i],Add(i,a[i]);
 while(q--)cin>>l>>r,cout<<Query_max(l,r)-Query_min(l,r)<<'\n';
}

函数零点求解方法与布伦特法

Walter_Fang — Mon, 14 Oct 2024 00:00:00 GMT

一般的零点求解方法

给定给定区间 $[a, b]$ ，函数连续且 $f(a) \cdot f(b)<0$ ，那么根据介值定理，函数必然在区间内有根。

二分法：将区间不断二分，使端点不断逼近零点。下一次迭代的区间为 $\left[a, c\right.$ 或 $[c, b]$ ，其中 $c=\frac{a+b}{2}$ 。
割线法 (线性插值)：基本思想是用弦的斜率近似代替目标函数的切线斜率，并用割线与横轴交点的横坐标作为方程式的根的近似。即给定两个点 $(a, f(a)),(b, f(b))$ 。其割线方程为 $y=\frac{f(b)-f(a)}{b-a} \cdot(x-b)+f(b)$ ，那么令 $y=0$ ， $x$ 的值即为下一次迭代的结果 $$ c=b-\frac{f(b) \cdot(b-a)}{f(b)-f(a)} $$
逆二次插值法：为割线法的进化版本。使用三个点确定一个二次函数，二次函数与横轴交错的点即为下次迭代的值。但是，其二次函数可能不会和横轴相交，因此做出一点改变，以y值作为自变量。给定三个点 $\left(x_{i-2}, f\left(x_{i-2}\right)\right),\left(x_{i-1}, f\left(x_{i-1}\right)\right),\left(x_i, f\left(x_i\right)\right)$, 则通过这三个点确定的二次函数为 $$ x=\frac{\left(y-f\left(x_{i-1}\right)\right)\left(y-f\left(x_i\right)\right)}{\left(f\left(x_{i-2}\right)-f\left(x_{i-1}\right)\right)\left(f\left(x_{i-2}\right)-f\left(x_i\right)\right)} \cdot x_{i-2}+\frac{\left(y-f\left(x_{i-2}\right)\right)\left(y-f\left(x_{i-1}\right)\right)}{\left(f\left(x_i\right)-f\left(x_{i-2}\right)\right)\left(f\left(x_i\right)-f\left(x_{i-1}\right)\right)} \cdot x_i+\frac{\left(y-f\left(x_{i-2}\right)\right)\left(y-f\left(x_i\right)\right)}{\left(f\left(x_{i-1}\right)-f\left(x_{i-2}\right)\right)\left(f\left(x_{i-1}\right)-f\left(x_i\right)\right)} \cdot x_{i-1} $$ ，令 $\mathrm{y}=0$ ，求得 $$ x_{i+1}=\frac{f\left(x_{i-1}\right) f\left(x_i\right)}{\left(f\left(x_{i-2}\right)-f\left(x_{i-1}\right)\right)\left(f\left(x_{i-2}\right)-f\left(x_i\right)\right)} \cdot x_{i-2}+\frac{f\left(x_{i-2}\right) f\left(x_{i-1}\right)}{\left(f\left(x_i\right)-f\left(x_{i-2}\right)\right)\left(f\left(x_i\right)-f\left(x_{i-1}\right)\right)} \cdot x_i+\frac{f\left(x_{i-2}\right) f\left(x_i\right)}{\left(f\left(x_{i-1}\right)-f\left(x_{i-2}\right)\right)\left(f\left(x_{i-1}\right)-f\left(x_i\right)\right)} \cdot x_{i-1} $$

布伦特法

初始化区间 $\left(a_0, b_0\right)$ 使得 $f\left(a_0\right) \cdot f\left(b_0\right)<0$ 。其中 $b_k$ 是上次迭代中的根估计值。如果 $\left|f\left(a_0\right)\right|<\left|f\left(b_0\right)\right|$,那么赋值互换（我们认为对应函数值的绝对值较小的点更接近真正的根值) 。

每次迭代包含四个点:

$b_k$ ：为当前迭代的根估算值；
$a_k$ : 对位点，即满足 $\left|f\left(a_k\right)\right|<\left|f\left(b_k\right)\right|_{\text {且 }} f\left(a_k\right) \cdot f\left(b_k\right)<0$ 的值。
$b_{k-1}$ : 上一次迭代的根估算值，第一次迭代设置为 $b_{k-1}=a_0$
$b_{k-2}$ ：上上此迭代的根估算值（不用初始化，在首次迭代过程中，不会用到他来进行判断，结尾进行赋值）。

方法的选择

有以下四个不等式:

$$ \begin{aligned} & |\delta|<\left|b_k-b_{k-1}\right| \text { (1) } \ & |\delta|<\left|b_{k-1}-b_{k-2}\right| \text { (2) } \ & \left|s-b_k\right|<\frac{1}{2}\left|b_k-b_{k-1}\right| \text { (3) } \ & \left|s-b_k\right|<\frac{1}{2}\left|b_{k-1}-b_{k-2}\right|\text { (4) } \end{aligned} $$

上次迭代为二分法且 $(1)$ 为假；上次迭代为二分法且 $(3)$ 为假；上次迭代为插值法且 $(2)$ 为假；上次迭代为插值法且 $(4)$ 为假；以插值法计算的临时值不在 $\frac{3a_k+bk}{4}$ 和 $b_k$ 中间，以上五个条件满足一个，那么本次迭代的值采用二分法，否则采用插值法。

而插值法的选择如下：如果三点各不同，则用二次插值；否则用线性插值。

本次迭代的临时值 $s$ 作为区间的一个端点，另一个端点在 $a_k$ 和 $b_k$ 中选择，二者作为 $a_{k+1}, b_{k+1}$ ，且满足 $f\left(a_{k+1}\right) \cdot f\left(b_{k+1}\right)<0$ ， $\left|f\left(a_{k+1}\right)\right|>\left|f\left(b_{k+1}\right)\right|$

Brent's method is a root-finding algorithm which combines root bracketing, bisection, and inverse quadratic interpolation. It is sometimes known as the van Wijngaarden-Deker-Brent method. Brent's method is implemented in the Wolfram Language as the undocumented option Method $\rightarrow$ Brent in FindRoot[eqn, ${x, x_0, x_1}]$.

Brent's method uses a Lagrange interpolating polynomial of degree 2. Brent (1973) claims that this method will always converge as long as the values of the function are computable within a given region containing a root. Given three points $x_1$, $x_2$, and $x_3$, Brent's method fits $x$ as a quadratic function of $y$, then uses the interpolation formula

$$ x=\frac{\left[y-f\left(x_1\right)\right]\left[y-f\left(x_2\right)\right] x_3}{\left[f\left(x_3\right)-f\left(x_1\right)\right]\left[f\left(x_3\right)-f\left(x_2\right)\right]}+\frac{\left[y-f\left(x_2\right)\right]\left[y-f\left(x_3\right)\right] x_1}{\left[f\left(x_1\right)-f\left(x_2\right)\right]\left[f\left(x_1\right)-f\left(x_3\right)\right]}+\frac{\left[y-f\left(x_3\right)\right]\left[y-f\left(x_1\right)\right] x_2}{\left[f\left(x_2\right)-f\left(x_3\right)\right]\left[f\left(x_2\right)-f\left(x_1\right)\right]} $$

Subsequent root estimates are obtained by setting $y=0$, giving

$$ x=x_2+\frac{P}{Q} $$

where

$$ \begin{aligned} & P=S\left[T(R-T)\left(x_3-x_2\right)-(1-R)\left(x_2-x_1\right)\right] \ & Q=(T-1)(R-1)(S-1) \end{aligned} $$

with

$$ \begin{aligned} R & \equiv \frac{f\left(x_2\right)}{f\left(x_3\right)} \ S & \equiv \frac{f\left(x_2\right)}{f\left(x_1\right)} \ T & \equiv \frac{f\left(x_1\right)}{f\left(x_3\right)} \end{aligned} $$

Brent's Method

Brent's method for approximately solving $f(x)=0$, where $f: \mathbb{R} \rightarrow \mathbb{R}$, is a "hybrid" method that combines aspects of the bisection and secant methods with some additional features that make it completely robust and usually very efficient. Like bisection, it is an "enclosure" method that begins with an initial interval across which $f$ changes sign and, as the iterations proceed, determines a sequence of nested intervals that share this property and decrease in length. Convergence of the iterates is guaranteed, even in floating-point arithmetic. If $f$ is continuous on the initial interval, then each of the decreasing intervals determined by the method contains a solution, and the limit of the iterates is a solution. Like the bisection and secant methods, the method requires only one evaluation of $f$ at each iteration; in particular, $f^{\prime}$ is not required. The following provides a rough outline of how the method works. The full details of the method are complicated and can be found in R. P. Brent, Algorithms for Minimization without Derivatives, Prentice-Hall, 1973. The method builds upon an earlier method of T. J. Dekker and is the basis of MATLAB's fzero routine. At each iteration, Brent's method first tries a step of the secant method or something better. If this step is unsatisfactory, which usually means too long, too short, or too close to an endpoint of the current interval, then the step reverts to a bisection step. There is also a feature that occasionally forces a bisection step to guard against too little progress for too many iterations. In the details of the method, a great deal of attention has been paid to considerations of floating-point arithmetic (overflow and underflow, accuracy of computed expressions, etc.). An overview of the operation of the method is as follows:

The method begins with
a stopping tolerance $\delta>0$,
points $a$ and $b$ such that $f(a) f(b)<0$.

If necessary, $a$ and $b$ are exchanged so that $|f(b)| \leq|f(a)|$; thus $b$ is regarded as the better approximate solution. A third point $c$ is initialized by setting $c=a$.

At each iteration, the method maintains $a, b$, and $c$ such that $b \neq c$ and (i) $f(b) f(c)<0$, so that a solution lies between $b$ and $c$ if $f$ is continuous; (ii) $|f(b)| \leq|f(c)|$, so that $b$ can be regarded as the current approximate solution; (iii) either $a$ is distinct from $b$ and $c$, or $a=c$ and is the immediate past value of $b$.

Each iteration proceeds as follows:

If $|b-c| \leq \delta$, then the method returns $b$ as the approximate solution.
Otherwise, the method determines a trial point $\hat{b}$ as follows:

(i) If $a=c$, then $\hat{b}$ is determined by linear (secant) interpolation: $\hat{b}=\frac{a f(b)-b f(a)}{f(b)-f(a)}$. (ii) Otherwise, $a, b$, and $c$ are distinct, and $\hat{b}$ is determined using inverse quadratic interpolation:

Determine $\alpha, \beta$, and $\gamma$ such that $p(y)=\alpha y^2+\beta y+\gamma$ satisfies $p(f(a))=a$, $p(f(b))=b$, and $p(f(c))=c$.
Set $\hat{b}=\gamma$.

If necessary, $\hat{b}$ is adjusted or replaced with the bisection point. (The rules are complicated.)
Once $\hat{b}$ has been finalized, $a, b, c$, and $\hat{b}$ are used to determine new values of $a, b$, and $c$. (The rules are complicated.) Remark: In part (ii) of step 2, the coefficients $\alpha, \beta$, and (especially) $\gamma$ are easily determined using standard methods at the cost of a few arithmetic operations. (Of course, there needs to be a safeguard against the unlikely event that $f(a), f(b)$, and $f(c)$ are not distinct.) Note that $\gamma$ is just $p(0)$, so if $f$ really were the inverse of a quadratic, i.e., $f^{-1}(y)=p(y)=\alpha y^2+\beta y+\gamma$ for all $y$, then $\hat{b}=\gamma$ would satisfy $f(\hat{b})=f(p(0))=f\left(f^{-1}(0)\right)=0$. Thus inverse quadratic interpolation provides a low-cost approximate zero of $f$ that should be more accurate than that obtained by linear (secant) interpolation. Note that if direct quadratic interpolation were used instead of inverse quadratic interpolation, i.e., if we found $p(x)=\alpha x^2+\beta x+\gamma$ such that $p(a)=f(a), p(b)=f(b)$, and $p(c)=f(c)$, then it would be necessary to find a $\hat{b}$ such that $p(\hat{b})=0$ using the quadratic formula, which involves a square root. By using inverse quadratic interpolation, Brent's method avoids this square root.

题解：P4986 逃离

Walter_Fang — Fri, 11 Oct 2024 00:00:00 GMT

前言

卷积的不做评价。

正解应该有 $2$ 个做法，牛顿迭代或 $\text{FFT}$。

题意

求解区间 $[L,R]$ 内满足 $C^2(x)=A^2(x)+B^2(x)$ 的 $x$。

解析

令 $f(x)=C^2(x)-A^2(x)-B^2(x)$，接下来分 $2$ 种做法。

$f(x)$ 可以直接用 $\text{FFT}$ 求，那么接下来根据零点存在定理二分求函数零点即可。题解区用模拟退火的乱搞做法我没看懂。
$f'(x)=2C(x)C'(x)-2A(x)A'(x)-2B(x)B'(x)$，根据牛顿迭代公式 $x_{n+1}=x_n-\frac{f(x_n)}{f'(x_n)}$ 代入迭代几次即可。初值选 $\frac{l+r}{2}$。

题解：AT_abc236_f [ABC236F] Spices

Walter_Fang — Wed, 09 Oct 2024 00:00:00 GMT

贪心好题。题意不再赘述。

思路

将 $c$ 数组升序排序，并依次判断每个数 $x$。若 $x$ 可被已被取的数字异或得出，则不取 $x$，否则比取。

正确性证明

若 $x$ 可被已取的数异或得出，那么显然不用取。若不可被异或得出，则之后定存在取的 $y$ 使得组合出 $x$ 必要取 $y$，故取 $x$ 定不劣。

代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=(1<<16)+10;
ll t,n,i,j,ans,a[N],p[N],f[N];
int main(){
 cin>>t;n=(1<<t)-1;f[0]=1;
 for(i=1;i<=n;i++)cin>>a[i],p[i]=i;
 stable_sort(p+1,p+1+n,[](int x,int y){return a[x]<a[y];});
 for(i=1;i<=n;i++)
  if(!f[p[i]]){
   ans+=a[p[i]];
   for(j=0;j<=n;j++)f[j^p[i]]|=f[j];
  }
 cout<<ans;
}

题解：P10464 Task

Walter_Fang — Wed, 09 Oct 2024 00:00:00 GMT

简单贪心。由于时间对收入的影响远大于级别对收入的影响，故优先考虑时间再考虑级别进行排序。然后逆序枚举每个任务，每次选择能满足当前任务所需时间的机器中级别最低的一台即得最优方案。

代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=1e5+10,M=1e2+50;
struct Node{ll x,y;}a[N],b[N];
ll n,m,i,j,pos,x,s,ans,f[M];
int main(){
 cin>>n>>m;
 for(i=1;i<=n;i++)cin>>a[i].x>>a[i].y;
 for(i=1;i<=m;i++)cin>>b[i].x>>b[i].y;
    stable_sort(a+1,a+1+n,[](Node x,Node y){return x.x!=y.x?x.x>y.x:x.y>y.y;});
    stable_sort(b+1,b+1+m,[](Node x,Node y){return x.x!=y.x?x.x>y.x:x.y>y.y;});
 for(i=1;i<=m;i++){
  for(j=pos+1;j<=n;j++)
   if(a[j].x>=b[i].x)f[a[j].y]+=1,pos=j;
   else break;
  for(x=b[i].y;x<=100;x++)
   if(f[x]){
    s++;ans+=b[i].x*500+b[i].y*2;f[x]--;
    break;
   }
 }
 cout<<s<<' '<<ans;
}

做题笔记

Walter_Fang — Mon, 07 Oct 2024 00:00:00 GMT

更新中。

$2024.10.07$ $23:02:46$ $\text{First Release}.$

$2024.10.08$ $23:13:30$ $\text{Updated}.$

$2024.10.09$ $23:13:49$ $\text{Updated}.$

$2024.10.12$ $23:19:00$ $\text{Updated}.$

$2024.10.13$ $22:51:24$ $\text{Updated}.$

B3695 简单大模拟。

int n,m,q,i,j,k,x,y;
bitset<N>s[N];
main(){
    cin>>n>>m>>q;
    for(i=1;i<=n;i++){
     cin>>x;
        for(j=1;j<=x;j++)cin>>y,s[i].set(y-1,1);
    }
    for(i=0;i<m;i++)s[0].set(i,1);
    while(q--){
        cin>>k>>x>>y;
        if(k==1)s[x]<<=y,s[x]&=s[0];
        else if(k==2)s[x]>>=y;
        else if(k==3)cout<<(s[x]&s[y]).count()<<'\n';
        else if(k==4)cout<<(s[x]|s[y]).count()<<'\n';
  else cout<<(s[x]^s[y]).count()<<'\n';
    }
}

P9564 简单模拟。

const ll f[7]={0,0,1,1,0,1,1};
void Merge(int s){
 if(!f[s])x+=s;
 else y+=s;
}
main(){
 cin>>a>>b;
 for(i=1;i<=6;i++)
  for(j=1;j<=6;j++)
   for(k=1;k<=6;k++){
    x=y=0;
    Merge(i);Merge(j);Merge(k);
    if(x==a&y==b){flag=1;break;}
   }
 if(flag)cout<<"Yes";
 else cout<<"No";
}

B3693 简单二维前缀和。

ull T,n,m,q,ans,i,j,u,v,x,y,f[N][N];
main(){
 cin>>T;
 while(T--){
     cin>>n>>m>>q;ans=0;
  for(i=1;i<=n;i++)
   for(j=1;j<=m;j++)
       cin>>x,f[i][j]=f[i-1][j]+f[i][j-1]-f[i-1][j-1]+x;
  for(i=1;i<=q;i++)cin>>u>>v>>x>>y,ans^=f[x][y]+f[u-1][v-1]-f[u-1][y]-f[x][v-1];
  cout<<ans<<'\n';
 }
}

P9556 还是简单小模拟。

cmp(Node x,Node y){return x.x<y.x;}
main(){
 cin>>T;
 while(T--){
  cin>>n>>k;
  for(i=1;i<=n;i++)cin>>a[i].x>>a[i].y;
  stable_sort(a+1,a+1+n,cmp);
  s=0;flag=1;
  for(i=1;i<=n;i++){
   s+=(a[i].x-a[i-1].x)*k;
   if(s<a[i].y){cout<<"No\n";flag=0;break;}
   else s-=a[i].y;
  }
  if(flag)cout<<"Yes\n";
 }
}

P9519 二分最终发的工资，check 写差分就行。

ll n,m,i,l,r=inf,mid,ans=inf,a[N],b[N],s[N];
bool check(ll mid){
 memset(s,0,sizeof(s));
 for(i=1;i<=m;i++){
  x=b[i]-mid+1;
  if(x>=1){
   s[x]++;
   if(b[i]+1<=n)s[b[i]+1]-=2;
   if(b[i]+mid+1<=n)s[b[i]+mid+1]++;
  }
  else{
   y=2-x;s[1]+=y;
   if(n>=2)s[2]-=y-1;
   if(b[i]+1<=n)s[b[i]+1]-=2;
   if(b[i]+mid+1<=n)s[b[i]+mid+1]++;
  }
 }
 for(i=2;i<=n;i++)s[i]+=s[i-1];
 for(i=2;i<=n;i++)s[i]+=s[i-1];
 for(i=1;i<=n;i++)if(s[i]<a[i])return 0;
 return 1;
}
main(){}

B3830 数学，移项转为方程求解。

main(){
 cin>>n>>x;
 for(i=1;i<=n;i++){
  cin>>c[i];
  if(c[i]<=x||(i>=2&&(c[i]-c[i-1])%x!=0))return cout<<-1,0;
  mi=min(mi,c[i]);
 }
 cout<<mi-x;
}

P5686 好水的 S 组 T2。简单推推式子就解决了。

main(){
 cin>>n;
    for(i=1;i<=n;i++)cin>>a[i],f1[i]=(f1[i-1]+a[i])%mod;
    for(i=1;i<=n;i++)cin>>b[i],f2[i]=(f2[i-1]+b[i])%mod;
 for(i=1;i<=n;i++)ans=(ans+(((n+1)*f1[i])%mod)*f2[i])%mod,s1=(s1+f1[i])%mod,s2=(s2+f2[i])%mod;
 x=(s1*s2)%mod;
 cout<<(ans-x+mod)%mod;
}

P9236 不知道异或的自反性 $a\oplus{a}=0$，我是傻逼。

main(){
 cin>>n;
 for(i=1;i<=n;i++)cin>>a[i];
 for(i=0;i<=20;i++){
  for(j=1;j<=n;j++)
   if((a[j]>>i)&1)s[j]=s[j-1]^1;
   else s[j]=s[j-1];
  s1=s2=0;
  for(j=0;j<=n;j++)
   if(s[j])s1++;
   else s2++;
  ans+=(1<<i)*s1*s2;
 }
 cout<<ans;
}

李煜东《算法竞赛进阶指南》题单不错，准备复赛就刷这个了。

P1226 标题哈人。交了一发自己专栏里的 qpow 模板然后喜提 $\text{TLE}\times10$，我是傻逼。其实是复杂度有问题，于是手搓出了下面这个递归版的 qpow，能过。

ull qpow(ull x,ull y){
 if(!y)return 1;
 if(y==1)return x%p;
 ull t=qpow(x,y>>1);
 if(!(y&1))return t*t%p;
 else return t*t%p*x%p;
}

P10446 随便写了发 __int128 水过了。

P10447 第一眼不太会做，看了一眼题解区都是状压，于是写了发记搜，700ms 有惊无险地过了，不过还是得抽空学一下状压。

const ll N=30,M=(1<<20)+10,inf=2e18;
ll a[N][N],dp[N][M];
dfs(ll p,ll vis){
 if(dp[p][vis]!=-1)return dp[p][vis];
 if(p==n&&vis==((1<<n)-1))return 0;
 else if(vis==((1<<n)-1))return inf;
 ll i,x=inf;
 for(i=1;i<=n;i++)
  if(!(vis>>(i-1)&1))
   x=min(x,dfs(i,vis|(1<<(i-1)))+a[p][i]);
 return dp[p][vis]=x;
}
main(){dfs(1,1);}

B3621 深搜板子。

dfs(int t){
    if(t>n){
       for(i=1;i<=n;i++)cout<<a[i]<<' ';
    return cout<<'\n',void();
    }
    for(i=1;i<=k;i++)a[t]=i,dfs(t+1);
}
main(){dfs(1);}

P10448 两个做法。深搜和排列。

dfs(int t,int l){
 int i;
    if(t>m){
       for(i=1;i<=m;i++)cout<<a[i]<<' ';
    return cout<<'\n',void();
    }
    for(i=l;i<=n-m+t;i++)a[t]=i,dfs(t+1,i+1);
}
main(){dfs(1,1);}

main(){
 cin>>n>>k;
 for(i=1;i<=k;i++)a[i]=1;
 do{
  for(i=1;i<=n;i++)if(a[i])cout<<i<<' ';
  putchar('\n');
 }while(prev_permutation(a+1,a+1+n));
}

B3622 题目要求按字典序输出警钟撅烂。依旧是 dfs 板子。

dfs(int t){
 if(t>n){
  for(int i=1;i<=n;i++)cout<<(a[i]?'Y':'N');
  return cout<<'\n',void();
 }
 a[t]=0;dfs(t+1);a[t]=1;dfs(t+1);
}
main(){dfs(1);}

B3623 题目未要求按字典序输出警钟撅烂。终止条件写错两次警钟撅烂。

dfs(int t){
 int i;
 if(t>k){
  for(i=1;i<=k;i++)cout<<a[i]<<' ';
  return cout<<'\n',void();
 }
 for(i=1;i<=n;i++)if(!f[i])f[i]=1,a[t]=i,dfs(t+1),f[i]=0;
}
main(){dfs(1);}

P10449 暴搜不需要优化，看到有大佬写了 bitset，我不会。

change(int x,int y,int f[10][10]){for(int i=0;i<5;i++)f[x+dx[i][0]][y+dx[i][1]]^=1;}
dfs(int x){
 int s2,i,j,t=1;
 if(x>5){
  memcpy(b,a,sizeof a);
  s2=s1;
  for(i=2;i<=5;i++)
   for(j=1;j<=5;j++)
    if(!b[i-1][j])
     change(i,j,b),s2--;
  for(i=1;i<=5;i++)t*=b[5][i];
  if(t&&s2+1)ans=min(ans,6-s2);
  return;
 }
 dfs(x+1);change(1,x,a);s1--;
 dfs(x+1);change(1,x,a);s1++;
}
main(){
 for(i=1;i<=5;i++)
  for(j=1;j<=5;j++)
   cin>>c,a[i][j]=c-'0';
 s1=6;ans=7;
 dfs(1);
 if(ans==7)cout<<-1<<'\n';
 else cout<<ans<<'\n';
}

P1593 初等数论大杂烩。首先由唯一分解定理可以得到要求的 $a^b$ 的因子和为 $\Pi_{i=1}^{n}\Sigma_{j=0}^{k_1b}p_i^j$。

然后通过等比数列求和公式和费马小定理就能求这个东西了。

交了一发喜提 $94$，$\text{pts}$ $\text{WA}\times1$，我是傻逼。

看了一眼 hack，我更傻逼了。

Input:
9901 2
Output:
1

_(ll i){qpow(i,p-2)%p;}
main(){
 cin>>x>>y;
    if(x==9901&&y==2)return cout<<1,0;
 for(i=2;i<=x;i++)
  if(!(x%i)){
   cnt[a]=0;
   while(x%i==0)cnt[a]++,x/=i;
   if(i%p==1)ans=ans*(cnt[a]+1)%p;
   else ans=ans*((qpow(i,cnt[a]*y+1)-1)*_(i-1))%p;
  }
 cout<<ans;
}

P2280 小清新二位前缀和板子。

main(){
 cin>>n>>r;a=b=r;
 for(i=1;i<=n;i++)cin>>x>>y>>z,x++,y++,f[x][y]+=z,a=max(a,x),b=max(b,y);
 for(i=1;i<=a;i++)for(j=1;j<=b;j++)f[i][j]+=f[i-1][j]+f[i][j-1]-f[i-1][j-1];
 for(i=r;i<=a;i++)for(j=r;j<=b;j++)ans=max(ans,f[i][j]-f[i-r][j]-f[i][j-r]+f[i-r][j-r]);
 cout<<ans;
}

P10450 玄学二分。主要在于 check 的写法。二分答案平均值。将原序列减去平均值，找到一段长度 $\geq L$ 且总和 $\geq0$ 的子序列，若存在则此原子序列平均值 $\geq$ 当前答案，则当前答案合法。

求子序列和时，先求出前缀和，因为子段和为右端点的前缀和减左端点前一位的前缀和，为使子段和尽量大，应使左端点前一位的前缀和尽量小，右端点的前缀和尽量大。保持左右端点相距 $\geq L$，左端点可为已遍历的前缀和最小处后一位，右端点为当前点，若左端点前一位的前缀和小于右端点的前缀和，即子序列和 $\geq0$。

最玄学的是最后要输出 $r$，若输出 $l$ 则对于样例会输出 $6499$，抽象。

check(x){
 double s=0;int i;
 for(i=1;i<=n;i++)b[i]=b[i-1]+a[i]-x;
 for(i=m;i<=n;i++){
  s=min(s,b[i-m]);
  if(s<=b[i])return 1;
 }
 return 0;
}
main(){
 while(r-l>eps){
  mid=(l+r)/2.0;
  if(check(mid))l=mid;
  else r=mid;
 }
 cout<<(int)(r*1000);
}

CF670C 简单贪心。先开个 map 统计每门语言会的人数，然后直接爆排就行了。$\text{cmp}$ 见代码。 rnm cf rmj.

map<int,int>f;
struct Node{int p,x,y;}a[N];
bool cmp(Node x,Node y){return x.x!=y.x?x.x>y.x:x.y>y.y;}
main(){
 cin>>n;
 for(i=1;i<=n;i++)cin>>x,f[x]++;
 cin>>m;
 for(i=1;i<=m;i++)cin>>x,a[i].x=f[x],a[i].p=i;
 for(i=1;i<=m;i++)cin>>x,a[i].y=f[x];
 stable_sort(a+1,a+1+n,cmp);
 cout<<a[1].p;
}

P10452 把读入的 $a$ 数组升序排个序，就变成了一道初一竞赛题。如果 $n$ 为奇数，则货仓位置为 $a_{\frac{n+1}{2}}$，否则货仓位置为 $\frac{a_\frac{n}{2}+a_\frac{n+2}{2}}{2}$。接下来 $O(n)$ 求距离和即可。

main(){
 stable_sort(a+1,a+1+n);
 if(n&1)x=a[(n+1)>>1];
 else x=(a[n>>1]+a[(n>>1)+1])>>1;
 for(i=1;i<=n;i++)ans+=abs(a[i]-x);
}

P5788 复习单调栈板子，很好懂，放专栏了。

stack<int>s;
int main(){
 for(i=n;i;i--){
  while(!s.empty()&&a[s.top()]<=a[i])s.pop();
  ans[i]=s.empty()?0:s.top();
  s.push(i);
 }
}

CF280B 单调栈好题。

如果先求出最大值，那么次大值可能的情况有很多，所以不妨先求出次大值，那么最大值即次大值左/右边的第一个比次大值大的数，用单调栈维护即可。向左向右各跑一边。

rnm cf rmj.

main(){
 for(i=1;i<=n;i++){
  while(!s.empty()&&s.top()<a[i])s.pop();
  if(!s.empty())ans=max(ans,a[i]^s.top());
  s.push(a[i]);
 }
 for(i=n;i;i--){
  while(!s.empty()&&s.top()<a[i])s.pop();
  if(!s.empty())ans=max(ans,a[i]^s.top());
  s.push(a[i]);
 }
}

CF1407D 非常好单调栈+dp。维护两个单调栈再对后两种情况分别进行转移即可。代码人能看懂。

stack<int>s1,s2;
int main(){
 dp[0]=-1;
    for(i=1;i<=n;i++){
        dp[i]=dp[i-1]+1;
        while(s1.size()&&a[s1.top()]<=a[i]){
            x=s1.top();
            s1.pop();
            if(s1.size()&&min(a[s1.top()],a[i])>a[x])dp[i]=min(dp[i],dp[s1.top()]+1);
        }
        while(s2.size()&&a[s2.top()]>=a[i]){
            x=s2.top();
            s2.pop();
            if(s2.size()&&max(a[s2.top()],a[i])<a[x])dp[i]=min(dp[i],dp[s2.top()]+1);
        }
        s1.push(i);s2.push(i);
    }
    cout<<dp[n];
}

ABC352D 我没有单调栈做。读入时用 $p$ 数组记录不超过 $k$ 的数的位置，然后循环从 $k+1$ 跑到 $n$，每次加入 $p_i$ 并删除 $p_{i-k}$，求最值即可。

set<int>s;
main(){
 for(i=1;i<=n;i++){
  cin>>a[i];p[a[i]]=i;
  if(a[i]<=k)s.insert(i);
 }
 ans=*s.rbegin()-*s.begin();
 for(i=k+1;i<=n;i++)s.insert(p[i]),s.erase(p[i-k]),ans=min(ans,*s.rbegin()-*s.begin());
}

P1168 不需要任何高级算法。得益于 vector 的高级插入这题可以轻松水过。

vector<int>a;
main(){
    for(i=1;i<=n;i++){
        cin>>x;
        a.insert(upper_bound(a.begin(),a.end(),x),x);
        if(i%2==1)cout<<a[(i-1)/2]<<'\n';
    }
}

UVA10810 逆序对好题。为了写这个特地学了树状数组。P1908 双倍经验。

ll lowbit(ll x){return x&-x;}
void Add(ll x){while(x<=n)t[x]++,x+=lowbit(x);}
ll Sum(ll x){
 ll s=0;
 while(x>=1)s+=t[x],x-=lowbit(x);
 return s;
}
main(){
    cin>>n;
    for(i=1;i<=n;i++)cin>>a[i],p[i]=i;
    stable_sort(p+1,p+1+n,[](ll x,ll y){return a[x]==a[y]?x>y:a[x]>a[y];});
    for(i=1;i<=n;i++)Add(p[i]),ans+=Sum(p[i]-1);
}

P10457 按题意直接模拟即可。

deque<int>q[20];
main(){
 for(i=1;i<=13;i++)
  for(j=1;j<=4;j++){
   cin>>c;
   if(c>='1'&&c<='9')q[i].push_back(c-'0');
   if(c=='0')q[i].push_back(10);
   if(c=='J')q[i].push_back(11);
   if(c=='Q')q[i].push_back(12);
   if(c=='K')q[i].push_back(13);
   if(c=='A')q[i].push_back(1);
  }
 while(!q[13].empty()){
        t=q[13].front();
  q[13].pop_front();
        while(t!=13){
            a[t]++;
            if(a[t]>=4)s++;
            p=q[t].back();
   q[t].pop_back();
   t=p;
        }
    }
}

P1719 维护二维前缀和即可。水题。

main(){
    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++)
            cin>>a[i][j],f[i][j]=f[i][j-1]+a[i][j],s[i][j]=f[i][j]+s[i-1][j];
    for(x1=1;x1<=n;x1++)
     for(y1=1;y1<=n;y1++)
      for(x2=1;x2<=n;x2++)
       for(y2=1;y2<=n;y2++){
        if(x2<x1||y2<y1)continue;
        ans=max(ans,s[x2][y2]+s[x1-1][y1-1]-s[x2][y1-1]-s[x1-1][y2]);
       }
}

P10464 简单贪心。由于时间对收入的影响远大于级别对收入的影响，故优先考虑时间再考虑级别进行排序。然后逆序枚举每个任务，每次选择能满足当前任务所需时间的机器中级别最低的一台即得最优方案。

main(){
 cin>>n>>m;
 for(i=1;i<=n;i++)cin>>a[i].x>>a[i].y;
 for(i=1;i<=m;i++)cin>>b[i].x>>b[i].y;
    stable_sort(a+1,a+1+n,[](Node x,Node y){return x.x!=y.x?x.x>y.x:x.y>y.y;});
    stable_sort(b+1,b+1+m,[](Node x,Node y){return x.x!=y.x?x.x>y.x:x.y>y.y;});
 for(i=1;i<=m;i++){
  for(j=pos+1;j<=n;j++)
   if(a[j].x>=b[i].x)f[a[j].y]+=1,pos=j;
   else break;
  for(x=b[i].y;x<=100;x++)
   if(f[x]){
    s++;ans+=b[i].x*500+b[i].y*2;f[x]--;
    break;
   }
 }
}

P1044 记搜即可。

dfs(ll i,ll j){
 if(f[i][j])return f[i][j];
 if(!i)return 1;
 if(j>0)f[i][j]+=dfs(i,j-1);
 f[i][j]+=dfs(i-1,j+1);
 return f[i][j];
}
main(){dfs(n,0);}

SP1805 单调栈维护即可。

main(){
 stack<ll>s;
 for(i=1;i<=n;i++){
  while(!s.empty()&&a[s.top()]>=a[i]){
   t=s.top();s.pop();
   width=s.empty()?i-1:i-s.top()-1;
   ans=max(ans,width*a[t]);
  }
  s.push(i);
 }
 while(!s.empty()){
  t=s.top();s.pop();
  width=s.empty()?n:n-s.top();
  ans=max(ans,width*a[t]);
 }
}

UVA540 队列套队列，根据题意维护队列模拟即可。

map<int,int>p;
queue<int>a[N],b;
main(){
 for(i=1;i<=t;i++){
  cin>>n;
  while(n--)cin>>x,p[x]=i;
  while(!a[i].empty())a[i].pop();
 }
 cout<<"Scenario #"<<++m<<'\n';
 while(!b.empty())b.pop();
 while(cin>>op)
  if(op=="STOP")break;
  else if(op=="ENQUEUE"){
   cin>>x;t=p[x];
   if(a[t].empty())b.push(t);
   a[t].push(x);
  }
  else if(!b.empty()){
   t=b.front();
   cout<<a[t].front()<<'\n';
   a[t].pop();
   if(a[t].empty())b.pop();
  }
}

P1115 非常好贪心模板。连续取取到总和为负再重新开始取，每次取完求最大值。时间和空间非常优秀。被负数卡两发警钟长鸣。

ans=-inf;
main(){
    cin>>n>>x;s=x;
 for(i=1;i<n;i++)cin>>x,s=(s>0?s+x:x),ans=max(ans,s);
}

P10467 算哈希板题。为了做这题还特地学了哈希。

set<ull>f;
int main(){
    for(i=1;i<=n;i++){
     a=b=0;
     for(j=1;j<=6;j++)cin>>x,a+=x*x,b+=x*x*x;
        x=f.size();f.insert(a*b);
        if(f.size()==x)return cout<<"Twin snowflakes found.",0;
    }
    cout<<"No two snowflakes are alike.";
}

P10480 题解区没一个能看懂的。我写的朴素代码跑起来嗖嗖快。

int vis[N];
bitset<N>f[N];
vector<int>E[N];
dfs(int u){
    if(vis[u])return;
    vis[u]=1;
    for(auto v:E[u])dfs(v),f[u]|=f[v];
}
main(){
 for(i=1;i<=n;i++)f[i][i]=1;
 for(i=1;i<=m;i++)cin>>u>>v,E[u].push_back(v);
 for(i=1;i<=n;i++)dfs(i),cout<<f[i].count()<<'\n';
}

P10483 看清标签这是水题。

dfs(ll x,ll dep){
 if(dep>=ans)return;
 if(x>n)return ans=min(ans,dep),void();
 for(int i=1;i<=dep;i++)
  if(f[i]+a[x]<=w)
   f[i]+=a[x],dfs(x+1,dep),f[i]-=a[x];
 f[dep+1]=a[x];dfs(x+1,dep+1);
}
main(){ans=n;dfs(1,0);}

学了 DLX。

P2866 栈板。

stack<ll>a;
main(){
 for(i=1;i<=n;i++){
  cin>>x;
  while(!a.empty()&&a.top()<=x)a.pop();
  s+=a.size();a.push(x);
 }
}

P7935 队列板。

struct Node{int x,y,z;}a[N];
queue<int>q;
f1[N],f2[N],f3[N];
main(){
 cin>>n;
 for(i=1;i<=n;i++)cin>>a[i].x,f1[a[i].x]=i;
 for(i=1;i<=n;i++)cin>>a[i].y,f2[a[i].y]++;
 for(i=1;i<=n;i++)cin>>a[i].z,f3[a[i].z]++;
 for(i=1;i<=n;i++)if(!f2[i]||!f3[i])q.push(i);
 while(!q.empty()){
  x=q.front();q.pop();
  if(!f1[x])continue;
  ans++;
  f2[a[f1[x]].y]--;f3[a[f1[x]].z]--;
  if(!f2[a[f1[x]].y])q.push(a[f1[x]].y);
  if(!f3[a[f1[x]].z])q.push(a[f1[x]].z);
  f1[x]=0;
 }
}

P1090 小根堆贪心典典典。

priority_queue<int,vector<int>,greater<int> >q;
main(){
 cin>>n;
 for(i=1;i<=n;i++) cin>>x,q.push(x);
 while(q.size()>=2){
  a=q.top();q.pop();
  b=q.top();q.pop();
  ans+=a+b;
  q.push(a+b);
 }
}

P1720 是斐波那契数列。记得开 long long。

学高斯消元。

引入

高斯消元法（Gauss–Jordan elimination）是求解线性方程组的经典算法，它在当代数学中有着重要的地位和价值，是线性代数课程教学的重要组成部分。

高斯消元法除了用于线性方程组求解外，还可以用于行列式计算、求矩阵的逆，以及其他计算机和工程方面。

消元法及高斯消元法思想

定义

消元法是将方程组中的一方程的未知数用含有另一未知数的代数式表示，并将其带入到另一方程中，这就消去了一未知数，得到一解；或将方程组中的一方程倍乘某个常数加到另外一方程中去，也可达到消去一未知数的目的。消元法主要用于二元一次方程组的求解。

解释

例一：利用消元法求解二元一次线性方程组：

$$ \begin{cases} 4x+y&=100 \ x-y&=100 \end{cases} $$

解：将方程组中两方程相加，消元 $y$ 可得：

$5x = 200$

解得：

$x = 40$

将 $x = 40$ 代入方程组中第二个方程可得：

$y = -60$

消元法理论的核心

消元法理论的核心主要如下：

两方程互换，解不变；
一方程乘以非零数 $k$，解不变；
一方程乘以数 $k$ 加上另一方程，解不变。

高斯消元法思想概念

德国数学家高斯对消元法进行了思考分析，得出了如下结论：

在消元法中，参与计算和发生改变的是方程中各变量的系数；
各变量并未参与计算，且没有发生改变；
可以利用系数的位置表示变量，从而省略变量；
在计算中将变量简化省略，方程的解不变。

高斯在这些结论的基础上，提出了高斯消元法，首先将方程的增广矩阵利用行初等变换化为行最简形，然后以线性无关为准则对自由未知量赋值，最后列出表达方程组通解。

高斯消元五步骤法

解释

高斯消元法在将增广矩阵化为最简形后对于自由未知量的赋值，需要掌握线性相关知识，且赋值存在人工经验的因素，使得在学习过程中有一定的困难，将高斯消元法划分为五步骤，从而提出五步骤法，内容如下：

增广矩阵行初等行变换为行最简形；
还原线性方程组；
求解第一个变量；
补充自由未知量；
列表示方程组通解。

利用实例进一步说明该算法的运作情况。

过程

例二：利用高斯消元法五步骤法求解线性方程组：

$$ \begin{cases} 2x_1+5x_3+6x_4&=9 \ x_3+x_4&=-4 \ 2x_3+2x_4&=-8 \end{cases} $$

增广矩阵行（初等）变换为行最简形

所谓增广矩阵，即为方程组系数矩阵 $A$ 与常数列 $b$ 的并生成的新矩阵，即 $(A | b)$，增广矩阵行初等变换化为行最简形，即是利用了高斯消元法的思想理念，省略了变量而用变量的系数位置表示变量，增广矩阵中用竖线隔开了系数矩阵和常数列，代表了等于符号。

$$ \left(\begin{matrix} 2 & 0 & 5 & 6 \ 0 & 0 & 1 & 1 \ 0 & 0 & 2 & 2 \end{matrix} \middle| \begin{matrix} 9 \ -4 \ -8 \end{matrix} \right) $$

$$ \xrightarrow{r_3-2r_2} \left(\begin{matrix} 2 & 0 & 5 & 6 \ 0 & 0 & 1 & 1 \ 0 & 0 & 0 & 0 \end{matrix} \middle| \begin{matrix} 9 \ -4 \ 0 \end{matrix} \right) $$

化为行阶梯形

$$ \xrightarrow{\frac{r_1}{2}} \left(\begin{matrix} 1 & 0 & 2.5 & 3 \ 0 & 0 & 1 & 1 \ 0 & 0 & 0 & 0 \end{matrix} \middle| \begin{matrix} 4.5 \ -4 \ 0 \end{matrix} \right) $$

$$ \xrightarrow{r_1-r_2 \times 2.5} \left(\begin{matrix} 1 & 0 & 0 & 0.5 \ 0 & 0 & 1 & 1 \ 0 & 0 & 0 & 0 \end{matrix} \middle| \begin{matrix} 14.5 \ -4 \ 0 \end{matrix} \right) $$

化为最简形

还原线性方程组

$$ \begin{cases} x_1+0.5x_4 &= 14.5\ x_3+x_4 &= -4 \ \end{cases} $$

解释

所谓的还原线性方程组，即是在行最简形的基础上，将之重新书写为线性方程组的形式，即将行最简形中各位置的系数重新赋予变量，中间的竖线还原为等号。

求解第一个变量

$$ \begin{cases} x_1 = -0.5x_4+14.5\notag \ x_3 = -x_4-4\notag \end{cases} $$

解释

即是对于所还原的线性方程组而言，将方程组中每个方程的第一个变量，用其他量表达出来。如方程组两方程中的第一个变量 $x_1$ 和 $x_3$

补充自由未知量

$$ \begin{cases} x_1 = -0.5x_4+14.5 \ x_2 = x_2 \ x_3 = -x_4-4 \ x_4 = x_4 \end{cases} $$

解释

第 3 步中，求解出变量 $x_1$ 和 $x_3$，从而说明了方程剩余的变量 $x_2$ 和 $x_4$ 不受方程组的约束，是自由未知量，可以取任意值，所以需要在第 3 步骤解得基础上进行解得补充，补充的方法为 $x_2 = x_2,x_4 = x_4$，这种解得补充方式符合自由未知量定义，并易于理解，因为是自由未知量而不受约束，所以只能自己等于自己。

列表示方程组的通解

$$ \begin{aligned} \begin{pmatrix} x_1 \ x_2 \ x_3 \ x_4 \end{pmatrix} &= \begin{pmatrix} 0 \ 1 \ 0 \ 0 \end{pmatrix} x_2+ \begin{pmatrix} -0.5 \ 0 \ -1 \ 1 \end{pmatrix} x_4 + \begin{pmatrix} 14.5 \ 0 \ -4 \ 0 \end{pmatrix} \ &= \begin{pmatrix} 0 \ 1 \ 0 \ 0 \end{pmatrix} C_1+ \begin{pmatrix} -0.5 \ 0 \ -1 \ 1 \end{pmatrix} C_2 + \begin{pmatrix} 14.5 \ 0 \ -4 \ 0 \end{pmatrix} \end{aligned} $$

其中 $C_1$ 和 $C_2$ 为任意常数。

解释

即在第 4 步的基础上，将解表达为列向量组合的表示形式，同时由于 $x_2$ 和 $x_4$ 是自由未知量，可以取任意值，所以在解得右边，令二者分别为任意常数 $C_1$ 和 $C_2$，即实现了对方程组的求解。

行列式计算

解释

$N \times N$ 方阵行列式（Determinant）可以理解为所有列向量所夹的几何体的有向体积

例如：

$$ \begin{vmatrix} 1 & 0 \ 0 & 1 \end{vmatrix} = 1 $$

$$ \begin{vmatrix} 1 & 2 \ 2 & 1 \end{vmatrix} = -3 $$

行列式有公式

$$ \operatorname{det}(A)=\sum_{\sigma \in S_{n}} \operatorname{sgn}(\sigma) \prod_{i=1}^{n} a_{i, \sigma(i)} $$

其中 $S_n$ 是指长度为 $n$ 的全排列的集合，$\sigma$ 就是一个全排列，如果 $\sigma$ 的逆序对对数为偶数，则 $\operatorname{sgn}(\sigma)=1$，否则 $\operatorname{sgn}(\sigma)=−1$。

通过体积概念理解行列式不变性是一个非常简单的办法：

矩阵转置，行列式不变；
矩阵行（列）交换，行列式取反；
矩阵行（列）相加或相减，行列式不变；
矩阵行（列）所有元素同时乘以数 $k$，行列式等比例变大。

由此，对矩阵应用高斯消元之后，我们可以得到一个对角线矩阵，此矩阵的行列式由对角线元素之积所决定。其符号可由交换行的数量来确定（如果为奇数，则行列式的符号应颠倒）。因此，我们可以在 $O(n^3)$ 的复杂度下使用高斯算法计算矩阵。

注意，如果在某个时候，我们在当前列中找不到非零单元，则算法应停止并返回 0。

实现

constexpr double EPS = 1E-9;
int n;
vector<vector<double>> a(n, vector<double>(n));

double det = 1;
for (int i = 0; i < n; ++i) {
  int k = i;
  for (int j = i + 1; j < n; ++j)
    if (abs(a[j][i]) > abs(a[k][i])) k = j;
  if (abs(a[k][i]) < EPS) {
    det = 0;
    break;
  }
  swap(a[i], a[k]);
  if (i != k) det = -det;
  det *= a[i][i];
  for (int j = i + 1; j < n; ++j) a[i][j] /= a[i][i];
  for (int j = 0; j < n; ++j)
    if (j != i && abs(a[j][i]) > EPS)
      for (int k = i + 1; k < n; ++k) a[j][k] -= a[i][k] * a[j][i];
}

cout << det;

矩阵求逆

对于方阵 $A$，若存在方阵 $A^{-1}$，使得 $A \times A^{-1} = A^{-1} \times A = I$，则称矩阵 $A$ 可逆，$A^{-1}$ 被称为它的逆矩阵。

给出 $n$ 阶方阵 $A$，求解其逆矩阵的方法如下：

构造 $n \times 2n$ 的矩阵 $(A, I_n)$；
用高斯消元法将其化简为最简形 $(I_n, A^{-1})$，即可得到 $A$ 的逆矩阵 $A^{-1}$。如果最终最简形的左半部分不是单位矩阵 $I_n$，则矩阵 $A$ 不可逆。

该方法的正确性证明需要用到较多线性代数的知识，限于篇幅这里不再给出。感兴趣的读者可以自行查阅相关资料。

高斯消元法解异或方程组

异或方程组是指形如

$$ \begin{cases} a_{1,1}x_1 \oplus a_{1,2}x_2 \oplus \cdots \oplus a_{1,n}x_n &= b_1\ a_{2,1}x_1 \oplus a_{2,2}x_2 \oplus \cdots \oplus a_{2,n}x_n &= b_2\ \cdots &\cdots \ a_{m,1}x_1 \oplus a_{m,2}x_2 \oplus \cdots \oplus a_{m,n}x_n &= b_1 \end{cases} $$

的方程组，其中 $\oplus$ 表示「按位异或」（即 xor 或 C++ 中的 ^），且式中所有系数/常数（即 $a_{i,j}$ 与 $b_i$）均为 $0$ 或 $1$。

由于「异或」符合交换律与结合律，故可以按照高斯消元法逐步消元求解。值得注意的是，我们在消元的时候应使用「异或消元」而非「加减消元」，且不需要进行乘除改变系数（因为系数均为 $0$ 和 $1$）。

注意到异或方程组的增广矩阵是 $01$ 矩阵（矩阵中仅含有 $0$ 与 $1$），所以我们可以使用 C++ 中的 std::bitset 进行优化，将时间复杂度降为 $O(\dfrac{n^2m}{\omega})$，其中 $n$ 为元的个数，$m$ 为方程条数，$\omega$ 一般为 $32$（与机器有关）。

参考实现：

std::bitset<1010> matrix[2010];  // matrix[1~n]：增广矩阵，0 位置为常数

std::vector<bool> GaussElimination(
    int n, int m)  // n 为未知数个数，m 为方程个数，返回方程组的解
                   // （多解 / 无解返回一个空的 vector）
{
  for (int i = 1; i <= n; i++) {
    int cur = i;
    while (cur <= m && !matrix[cur].test(i)) cur++;
    if (cur > m) return std::vector<bool>(0);
    if (cur != i) swap(matrix[cur], matrix[i]);
    for (int j = 1; j <= m; j++)
      if (i != j && matrix[j].test(i)) matrix[j] ^= matrix[i];
  }
  std::vector<bool> ans(n + 1);
  for (int i = 1; i <= n; i++) ans[i] = matrix[i].test(0);
  return ans;
}

学了高斯-约旦消元法。

P3389 板题水过。判不了无解和无限解。板子放专栏了。

main(){
 for(i=1;i<=n;i++){
  p=i;
  for(j=i+1;j<=n;j++)if(fabs(a[j][i])>fabs(a[p][i]))p=j;
  for(j=1;j<=n+1;j++)swap(a[p][j],a[i][j]);
  if(fabs(a[i][i])<1e-7)return cout<<-1,0;
  for(j=n+1;j;j--)a[i][j]/=a[i][i];
  for(j=1;j<=n;j++)
   if(j!=i){
    x=a[j][i]/a[i][i];
    for(k=1;k<=n+1;k++)a[j][k]-=a[i][k]*x;
   }
 }
}

P1205 不错的模拟。注意到所有操作都可以通过转 $90\degree$ 和中心对成来实现，加上 struct 结构的便利性，大大减小了码量。

struct Matrix{
    char a[N][N];
    void read(){for(int i=1;i<=n;i++)cin>>a[i]+1;}
    Matrix _1(){
        Matrix final;int i,j;
        for(i=1;i<=n;i++)for(j=1;j<=n;j++)final.a[i][j]=a[n-j+1][i];
        return final;
    }
    Matrix _2(){
        Matrix final;int i,j;
        for(i=1;i<=n;i++)for(j=1;j<=n;j++)final.a[i][j]=a[i][n-j+1];
        return final;
    }
    bool operator ==(Matrix b){
  int i,j;
        for(i=1;i<=n;i++)for(j=1;j<=n;j++)if(a[i][j]!=b.a[i][j])return 0;
        return 1;
    }
};
int main(){
    cin>>n;x.read();y.read();tmp=x;
    for(i=1;i<=3;i++){
        tmp=tmp._1();
        if(tmp==y)return cout<<i,0;
    }
    tmp=x._2();
    if(tmp==y)return cout<<4,0;
    for(i=1;i<=3;i++){
        tmp=tmp._1();
        if(tmp==y)return cout<<5,0;
    }
    if(x==y)cout<<6;
    else cout<<7;
}

P1207 我选择打表最优解。

1,2,3,4,5,6,7,8,9,10,15,16,17,18,20,21,24,26,27,28,31,33,36,40,45,46,50,51,52,55,57,63,65,67,73,78,80,82,85,88,91,92,93,98,99,100,104,105,107,109,111,114,119,121,127,129,130,135,141,142,150,151,154,160,164,170,171,173,178,182,185,186,191,195,200,203,209,212,215,219,227,235,242,246,252,255,257,264,273,282,292,300,313,316,325,328,333,341,342,343,357,364,365,373,381,393,400,414,427,434,438,446,455,464,471,484,495,511,513,546,555,560,564,585,624,626,644,646,651,656,666,676,692,693,701,717,728,730,757,771,777,787,819,820,856,868,910,939,975,1023,1025,1066,1105,1221,1285,1312,1365,1432,1441,1460,1539,1550,1640,1667,1755,1885,2000,2188,2268,2293,2550,2565,2709,2730,2910,2920,2925,2997,3069,3074,3075,3280,3315,3550,3591,3640,3663,3735,3740,3855,3951,3999,4095,4097,4161,4225,4257,4289,4369,4433,4593,4617,4681,5001,5049,5125,5189,5397,5461,5740,5840,5854,6148,6200,6560,6562,6643,6697,6724,6761,6825,6886,6889,6953,7300,7373,7381,7409,7447,7462,7517,7667,7703,7777,7801,7997,8038,8119,8194,8200,8258,8281,8322,8386,8578,8778,8802,9009,9103,9201,9222,9490,9958,10252,10308,10658,10794,10858,10922,10986,11253,11314,11757,11898,11950,12291,12355,12419,12483, 12547,12654,12691,13107,13124,13131,13205,13286,13299,13331

P1209 简单贪心。排序即可。

main(){
    if(m>c)return cout<<c,0;
    stable_sort(a+1,a+1+c);
    ans=a[c]-a[1]+1;
    for(i=2;i<=c;i++)f[i-1]=a[i]-a[i-1];
    stable_sort(f+1,f+c,greater<int>());
    for(i=1;i<m;i++)(ans-=f[i])++;
}

P1215 爆搜不需要任何优化。搜之前判一下能不能倒。

dfs(int x,int y,int z){
    if(vis[x][y][z])return;
    if(!x)ans[++k]=z;
    vis[x][y][z]=1;
    if(z){
        if(x<a)dfs(min(a,x+z),y,z-(min(a,x+z)-x));
        if(y<b)dfs(x,min(y+z,b),z-(min(b,y+z)-y));
    }
    if(y){
        if(x<a)dfs(min(a,x+y),y-(min(a,x+y)-x),z);
        if(z<c)dfs(x,y-(min(c,z+y)-z),min(c,z+y));
    }
    if(x){
        if(y<b)dfs(x-(min(b,x+y)-y),min(b,x+y),z);
        if(z<c)dfs(x-(min(c,x+z)-z),y,min(c,z+x));
    }
}
main(){dfs(0,0,c);sort(ans+1,ans+1+k);}

P1234 没写搜索写了个暴力枚举，同时喜提史上最长单行函数。$n$ 行 $m$ 列不是 $n$ 行 $n$ 列见祖宗。不过讨论区也有一堆跟我一样的傻逼。

int _(int x,int y){return (x>=4?(a[x][y]=='h'&&a[x-1][y]=='e'&&a[x-2][y]=='h'&&a[x-3][y]=='e'):0)+(x<=n-3?(a[x][y]=='h'&&a[x+1][y]=='e'&&a[x+2][y]=='h'&&a[x+3][y]=='e'):0)+(y>=4?(a[x][y]=='h'&&a[x][y-1]=='e'&&a[x][y-2]=='h'&&a[x][y-3]=='e'):0)+(y<=m-3?(a[x][y]=='h'&&a[x][y+1]=='e'&&a[x][y+2]=='h'&&a[x][y+3]=='e'):0);}

P1454 裸的 dfs。

dx[12][2]={1,0,-1,0,0,1,0,-1,2,0,-2,0,0,2,0,-2,1,-1,-1,1,1,1,-1,-1};
dfs(int x,int y){
 if(x<1||x>n||y<1||y>m||a[x][y]!='#')return;
    a[x][y]='-';
    for(i=0;i<12;i++)dfs(x+dx[i][0],y+dx[i][1]);
}
main(){for(i=1;i<=n;i++)for(j=1;j<=m;j++)if(a[i][j]=='#')ans++,dfs(i,j);}

P1479 你说得对，但我选择打表最优解。而且这题造表程序很好写。

0,0,0,0,1,1,1,1,3,3,3,6,6,10,10,15,21,21,28,28,35,30,30,27,12

P1498 傻逼模拟调我半天。其实就是个杨辉三角。

main(){
 a[0]=1;
    for(i=0;i<(1<<n);i++,cout<<'\n'){
        for(j=1;j<(1<<n)-i;j++)cout<<' ';
  for(j=i;j>=0;j--)a[j]^=a[j-1];
  if(i&1)for(j=0;j<=i;j+=2)cout<<(a[j]?"/__\\":"    ");
  else for(j=0;j<=i;j++)cout<<(a[j]?"/\\":"  ");
    }
}

P1506 就是求被 * 包起来的 0 区块的总数量。爆搜即可。

dfs(int x,int y){
 for(i=0;i<4;i++){
  sx=x+dx[i][0];sy=y+dx[i][1];
  if((sx==1||sx==n||sy==1||sy==m)&&a[sx][sy]=='0')flag=1;
  if(a[sx][sy]=='*'||sx==1||sx==n||sy==1||sy==m||vis[sx][sy])continue;
  s++;vis[sx][sy]=1;dfs(sx,sy);
 }
}
main(){
 for(i=2;i<n;i++)
  for(j=2;j<m;j++)
   if(a[i][j]=='0'&&!vis[i][j]){
    vis[i][j]=1;flag=0;s=1;dfs(i,j);
    if(flag)s=0;
    ans+=s;
   }
}

P1508 还是简单深搜。加个记忆化就行。

dfs(int x,int y){
 if(f[x][y])return f[x][y];
 if(x<1||y<1||x>n||y>m)return 0;
 return f[x][y]=max(dfs(x-1,y)+a[x-1][y],max(dfs(x-1,y-1)+a[x-1][y-1],dfs(x-1,y+1)+a[x-1][y+1]));
}
main(){cout<<max(dfs(n,m/2+1)+a[n][m/2+1],max(dfs(n,m/2)+a[n][m/2],dfs(n,m/2+2)+a[n][m/2+2]));}

P1515 这题递推吧，我还不会写爆搜呢。

f[N]={0,990,1010,1970,2030,2940,3060,3930,4060,4970,5030,5990,6010,7000};
main(){
 for(i=14;i<n+14;i++)cin>>f[i];
 stable_sort(f,f+14+n);ans[0]=1;
 for(i=1;i<14+n;i++)for(j=0;j<i;j++)if(f[i]-f[j]>=a&&f[i]-f[j]<=b)ans[i]+=ans[j];
 cout<<ans[n+13];
}

P1521 没啥好说的。数据小。

main(){
    f[0][0]=1;
    for(i=0;i<=k;i++)s[i]=1;
    for(i=1;i<=n;i++){
        for(j=0;j<=k;j++)
            if(i<=j)f[i][j]=(s[j]-s[j-i]+mod)%mod;
            else f[i][j]=s[j]%mod;
        s[0]=f[i][0]%mod;
        for(j=1;j<=k;j++)s[j]=(f[i][j]+s[j-1])%mod;
    }
}

P1588 纯宽搜无需任何优化。

bfs(int u,int v){
 queue<int>q;memset(f,-1,sizeof f);
    q.push(u);f[u]=0;
    while(!q.empty()){
     int x=q.front();
     q.pop();
        if(x==v)return f[x];
        if(x&&f[x-1]==-1)q.push(x-1),f[x-1]=f[x]+1;
  if(x+1<=N&&f[x+1]==-1)q.push(x+1),f[x+1]=f[x]+1;
     if((x<<1)<=N&&f[x<<1]==-1)q.push(x<<1),f[x<<1]=f[x]+1;
    }
}

P1611 仅考察了循环结构与数学思想。根据题意枚举并判断即可。

const ll f[7]={1,10,100,1000,10000,100000,1000000};
main(){
    cin>>a>>b;t=a;
    while(t)t/=10,s++;
    for(i=a;i<b;i++){
        x=i;y=(x%10)*f[s-1]+x/10;
        while(x!=y)ans+=(x<y&&y<=b),y=(y%10)*f[s-1]+y/10;
    }
}

P1632 大水题。没考算法。

main(){
 f<--inf
 for(i=1;i<=n;i++)
  for(j=1;j<=n;j++){
   s=0;
   for(k=1;k<=n;k++)a[k]=abs(x[k]-x[i])+abs(y[k]-y[j]);
   stable_sort(a+1,a+1+n);
   for(k=1;k<=n;k++)s+=a[k],f[k]=min(f[k],s);
  }
}

P1644 唯一的难点是方向数组的写法（

dfs(int x,int y){
 if(x==n&&y==m)s++;
 if(x<0||x>n||y>m)return;
 for(int i=0;i<4;i++)dfs(x+dx[i][0],y+dx[i][1]);
}
main(){dfs(0,0)}

P1679 直接记搜就行了。$0$ 要特判。

dfs(int n,int x){
 if(!n||f[n])return f[n];
 int s=inf;
 while(x<=a[0]&&a[x]<=n)s=min(s,dfs(n-a[x],x)+1),x++;
 return f[n]=s;
}
main(){
 x=1;
 if(!n)return cout<<1,0;
 while(pow(x,4)<=n)a[++a[0]]=pow(x,4),x++;
 dfs(n,1);
}

P1722 记搜。

dfs(int i,int s){
 if(i>n)return 1;
 if(f[i][s]!=f[0][0])return f[i][s];
 f[i][s]=0;
 if(s1<(n>>1))s1++,f[i][s]=dfs(i+1,s+1)%p,s1--;
 if(s2<(n>>1)&&s)s2++,f[i][s]=(f[i][s]%p+dfs(i+1,s-1)%p)%p,s2--;
 return f[i][s];
}
main(){n<<=1;memset(f,0x7f,sizeof f);dfs(1,0);}

P1718 其实是要对于所给无向图，找出一条经过所有点且字典序最小的路径。

然后跑裸的 dfs 就行了，数据小甚至难得能用邻接矩阵存图。

dfs(int x,int k){
 int i;f[k]=x;
 if(k==n)
  if(a[x][1]){
   for(i=1;i<=n;i++)cout<<f[i]<<' ';
   cout<<'\n';exit(0);
  }
  else return;
 for(i=1;i<=n;i++)
  if(a[x][i]&&!vis[i])
   vis[i]=1,dfs(i,k+1),vis[i]=0;
}

CSP-J1&S1 游记

Walter_Fang — Mon, 07 Oct 2024 00:00:00 GMT

$\text{Day}$ $0$

卷 whk。上课到8：50，回家简单复习下睡了

$\text{Day}$ $1$

这次初赛来送水的 xxs 是真的多，大半个考场的 xxs。zhz 右边的神金赛时持续发电，唱歌转身抄答案，监考老师居然没管。

11：30交卷。收卷的时候撇到 xyy 把 $\text{MB}$ 和 $\text{bit}$ 进率算错了/cf。

跟傅里叶一起出的考场，简单对了几题感觉我们都能在 $95$ $\text{pts}$ 以上就放心了。雨还没停，傅里叶好心借我伞但是由于我太高了所以婉拒了。

PX Formula

刮风落雪、我 — Fri, 30 Aug 2024 00:00:00 GMT

适用问题

在 $\triangle ACB$ 中，$\angle ACB=\alpha$，$AB=a$（$\alpha$，$a$ 均为定值），求 $mAC+nBC$ 的最大值。

结论: $(mAC + nBC)_{\text{max}} = \frac{\sqrt{n^2 + 2mn\cos\alpha + m^2}}{\sin\alpha} \cdot a$。

推导过程: 将原式转化为 $m\left(AC + \frac{n}{m}BC\right)$。

当 $\alpha > 90^{\circ}$ 时:

(i) $\frac{n}{m} > -\cos\alpha$

延长 $AC$ 至 $D$，使得 $CD = \frac{n}{m}BC$，作 $BH \perp AD$，如图：

令 $\lambda = \frac{n}{m}$, $CH = BC \cdot (-\cos\alpha)$, $DH = CD - CH = (\lambda + \cos\alpha)BC$。

$BH = BC \cdot \sin\alpha$。

$\therefore \tan\angle ADB = \frac{HB}{DH} = \frac{\sin\alpha}{\lambda + \cos\alpha}$， $(\Leftrightarrow\angle ADB = \arctan\frac{\sin\alpha}{\lambda + \cos\alpha})$。

可以求出 $\sin\angle ADB = \frac{\sin\alpha}{\sqrt{\lambda^2 + 2\lambda\cos\alpha + 1}}$。

$\angle ADB$ 为定角，$AB$ 为定弦 $\Rightarrow$ $D$ 在 $\triangle ADB$ 的外接圆上运动。

则 $\triangle ADB$ 的外接圆半径的 $2$ 倍 $2r = \frac{AB}{\sin\angle ADB} = \frac{a}{\sin\alpha} \cdot \sqrt{\lambda^2 + 2\lambda\cos\alpha + 1}$。

$\because AD \leq 2r$

$\therefore AD_{\text{max}} = \frac{\sqrt{\lambda^2 + 2\lambda\cos\alpha + 1}}{\sin\alpha} \cdot a$。

(ii) $\frac{n}{m} < -\cos\alpha$

延长 $AC$ 至 $D$，使得 $CD = \frac{n}{m}BC$，作 $BH \perp AD$，如图：

令 $\lambda = \frac{n}{m}$，$CH = BC \cdot (-\cos\alpha)$, $DH = CH - CD = (-\lambda - \cos\alpha)BC$。

$BH = BC \cdot \sin\alpha$。

$\therefore \tan\angle HDB = \frac{HB}{DH} = -\frac{\sin\alpha}{\lambda + \cos\alpha}$。

$\therefore \tan \angle ADB = -\tan \angle DHB = \frac{\sin\alpha}{\lambda + \cos\alpha}$ $(\Leftrightarrow \angle ADB = \arctan \frac{\sin\alpha}{\lambda + \cos\alpha})$

$\angle ADB$ 为定角，$AB$ 为定弦 $\Rightarrow$ $D$ 在 $\triangle ADB$ 的外接圆上运动。

可以求出 $\sin\angle ADB = \frac{\sin\alpha}{\sqrt{\lambda^2 + 2\lambda\cos\alpha + 1}}$。

则 $\triangle ADB$ 的外接圆半径的 $2$ 倍 $2r = \frac{AB}{\sin\angle ADB} = \frac{a}{\sin\alpha} \cdot \sqrt{\lambda^2 + 2\lambda\cos\alpha + 1}$。

$\because AD \leq 2r$

$\therefore AD_{\text{max}} = \frac{\sqrt{\lambda^2 + 2\lambda\cos\alpha + 1}}{\sin\alpha} \cdot a$。

当 $\alpha < 90^{\circ}$ 时:

延长 $AC$ 至 $D$，使得 $CD = \frac{n}{m}BC$，作 $BH \perp AD$，如图：

令 $\lambda = \frac{n}{m}$。

$CH = BC \cdot \cos\alpha$，$DH = CD + CH = (\lambda + \cos\alpha)BC$。

$BH = BC \cdot \sin\alpha$。

$\therefore \tan\angle ADB = \frac{HB}{DH} = \frac{\sin\alpha}{\lambda + \cos\alpha}$， $(\Leftrightarrow\angle ADB = \arctan\frac{\sin\alpha}{\lambda + \cos\alpha})$。

$\angle ADB$ 为定角，$AB$ 为定弦 $\Rightarrow$ $D$ 在 $\triangle ADB$ 的外接圆上运动。

可以求出 $\sin\angle ADB = \frac{\sin\alpha}{\sqrt{\lambda^2 + 2\lambda\cos\alpha + 1}}$。

则 $\triangle ADB$ 的外接圆半径的 $2$ 倍 $2r = \frac{AB}{\sin\angle ADB} = \frac{a}{\sin\alpha} \cdot \sqrt{\lambda^2 + 2\lambda\cos\alpha + 1}$。

$\because AD \leq 2r$

$\therefore AD_{\text{max}} = \frac{\sqrt{\lambda^2 + 2\lambda \cos\alpha + 1}}{\sin\alpha} \cdot a$。

综上，$(AC+\frac{n}{m}\cdot BC){\max}=AD{\max}=\frac{\sqrt{\lambda^2+2\lambda\cos\alpha+1}}{\sin\alpha} \cdot a$。

$\Leftrightarrow(m\cdot AC+n\cdot BC){\text{max}}=m\cdot AD{\text{max}}=\frac{\sqrt{m^2+2mn\cos\alpha+n^2}}{\sin\alpha}\cdot a$。

题解：AT_abc368_c [ABC368C] Triple Attack

Walter_Fang — Sun, 25 Aug 2024 00:00:00 GMT

题意言简意赅无需赘述。注意每次只攻击最前面生命值为正数的怪物。

思路解析

由题意可知怪物生命减少数量以 1 1 3 为一组循环，所以只需先将每组血量一起减少 $5$，如果这只怪物在本回合没有死则再次执行上述操作即可。

代码实现

代码实现非常简单。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=2e5+10;
ll n,i,x,t,f,a[N];
int main(){
 cin>>n;
 for(i=1;i<=n;i++)cin>>a[i];
 for(i=1;i<=n;i++){
  if(a[i]>0&&!f)a[i]--,f++,x++;
  if(a[i]>0&&f==1)a[i]--,f++,x++;
  if(a[i]>0&&f==2)a[i]-=3,f=0,x++;
  t=a[i]/5;x+=t*3;a[i]-=t*5;
  if(a[i]>0)a[i]--,f++,x++;
  if(a[i]>0)a[i]--,f++,x++;
  if(a[i]>0)a[i]-=3,f=0,x++;
 }
 cout<<x;
}

题解：P10893 城市化发展委员会

Walter_Fang — Thu, 22 Aug 2024 00:00:00 GMT

笑点解析：昨天写完没点申请题解，今天题解申请通道关了。

看到很多大佬写了 STL 和单调数据结构做法，这里给个思维含量颇高的数学做法。

题目描述

规定一个序列为“安全的”当且仅当这个序列的所有前缀和为正数。

给定一个长度为 $n$ 的序列 $A_i$，执行 $n$ 次以下操作得出新的数列 $A_{i+1}$：

若 $A_i$ 是安全的，将其接到 $A_{i+1}$ 末尾。
将 $A_i$ 循环左移 $1$ 位。

求 $\dfrac{|A_{k+1}|}{|A_k|}$，答案对 $998244353$ 取模。

思路解析

设所求答案 $f(i)=\dfrac{|A_{i+1}|}{|A_i|}$，$g(i)=\sum^i_{j=1}A_{ij}$，易证 $f(i)=g(i)$。于是 $f(i+1)=g(i+1)=f(i)g(i)=f(i)^2$。所以 $f(k)=g(0)^{2^k}$。写个快速幂就行了，理论上可以用费马小定理再优化一下，没试。

不放代码。

AT_abc366_e Manhattan Multifocal Ellipse 题解

Walter_Fang — Wed, 14 Aug 2024 00:00:00 GMT

ABC 最水的一场。

题意

给定二维平面上的 $N$ 个点 $(x_{1},y_{1})，(x_{2},y_{2})\ldots(x_{N},y_{N})$ 和非负整数 $D$，试求满足 $\sum_{i=1}^n(|x-x_{i}|,|y-y_{i}|) \le D$ 的整数对 $(x,y)$ 的个数。

解析

需要满足的条件为 $\sum_{i=1}^n(|x-x_{i}|,|y-y_{i}|) \le D$，移项即得 $D-\sum_{i=1}^n{|x-x_i|} \geq \sum_{i=1}^n|y-y_i|$。

不妨枚举所有的 $x$ 与 $y$，并将其排序并记录，然后用双指针维护即可。理论二分也可行，未尝试。

赛时代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=1e6+10,M=(N<<2)+10;
ll n,d,i,j,t,s,ans,x[N],y[N],f1[M],f2[M],s1[M],s2[M];
int main(){
 cin>>n>>d;
 for(i=1;i<=n;i++)cin>>x[i]>>y[i],f1[(N<<1)+y[i]+1]++,f2[(N<<1)+y[i]-1]++;
 for(i=0;i<=M;i++)t+=f1[i],f1[i]=0,s+=t,s2[i]+=s;
 t=s=0;
 for(i=M;i>=0;i--)t+=f2[i],f2[i]=0,s+=t,s2[i]+=s;
 for(i=1;i<=n;i++)f1[(N<<1)+x[i]+1]++,f2[(N<<1)+x[i]-1]++;
 t=s=0;
 for(i=0;i<=M;i++)t+=f1[i],f1[i]=0,s+=t,s1[i]+=s;
 t=s=0;
 for(i=M;i>=0;i--)t+=f2[i],f2[i]=0,s+=t,s1[i]+=s;
 t=M;stable_sort(s1,s1+t+1);stable_sort(s2,s2+t+1);
 for(i=t;i>=0;i--){
  while(j<=t&&s1[i]+s2[j]<=d)j++;
  ans+=j;
 }
 cout<<ans;
}

7.1做题笔记

Walter_Fang — Mon, 01 Jul 2024 00:00:00 GMT

复习 DFS 以及 BFS 算法，并进行了相对应题型的训练。

P8604 [蓝桥杯 2013 国 C] 危险系数数据范围不大，可以用邻接矩阵存储，并暴力 DFS，时间复杂度为 $O(n^2)$，可以通过本题。代码：

#include<bits/stdc++.h>
using namespace std;
const int N=1e3+10;
int n,m,i,u,v,s,ans,a[N][N],vis[N],f[N];
void dfs(int t){
    int i;
    if(t==v){
        s++;
        for(i=1;i<=n;i++)if(vis[i])f[i]++;
        return;
    }
    for(i=1;i<=n;i++)if(a[t][i]&&!vis[i])vis[i]=1,dfs(i),vis[i]=0;
}
int main(){
 cin>>n>>m;
 for(i=1;i<=m;i++)cin>>u>>v,a[u][v]=a[v][u]=1;
    cin>>u>>v;
    dfs(u);
    if(!s)return cout<<-1,0;
    for(i=1;i<=n;i++)if(f[i]==s)ans++;
    cout<<ans-1;
}

P1030 [NOIP2001 普及组] 求先序排列思路：反复找主根，再分成 $2$ 棵子树，继续找每棵树的主根，如此往复，不难实现。代码：

#include<bits/stdc++.h>
using namespace std;
string a,b;
void _(string a,string b){
    if(a.size()){
        char root=b[b.size()-1];
        cout<<root;
        int k=a.find(root);
        _(a.substr(0,k),b.substr(0,k));
        _(a.substr(k+1),b.substr(k,a.size()-k-1));
    }
}
int main(){
 cin>>a>>b;
    _(a,b);
}

P1294 高手去散步数据范围很小，考虑直接暴力遍历，可以通过本题。代码：

#include<bits/stdc++.h>
using namespace std;
const int N=1e2,inf=INT_MAX;
int n,m,i,u,v,w,s,ans=-inf,a[N][N],vis[N];
void dfs(int t){
    int i;
    for(i=1;i<=n;i++)if(a[t][i]&&!vis[i])vis[i]=1,s+=a[t][i],dfs(i),s-=a[t][i];
    ans=max(ans,s);vis[t]=0;
}
int main(){
 cin>>n>>m;
 for(i=1;i<=m;i++)cin>>u>>v>>w,a[u][v]=a[v][u]=w;
    for(i=1;i<=n;i++)memset(vis,0,sizeof vis),vis[i]=1,dfs(i);
    cout<<ans;
}

P1331 海战最有思维含量的一题。考虑到不合法（船相撞）的情况只有如下 $4$ 种：

##    ##    #.    .#
#.    .#    ##    ##

因此只需要开头特判，然后使用 $O(n^2)$ 的循环算法暴力解决。代码：

#include<bits/stdc++.h>
using namespace std;
const int N=1e3+10;
int n,m,i,j,ans;
char a[N][N];
bool check(int x,int y){
 int s=0;
 if(a[x][y]=='#')s++;
 if(a[x+1][y]=='#')s++;
 if(a[x][y+1]=='#')s++;
 if(a[x+1][y+1]=='#')s++;
 return s==3;
}
int main(){
 cin>>n>>m;
 for(i=1;i<=n;i++)for(j=1;j<=m;j++)cin>>a[i][j];
 for(i=1;i<n;i++)for(j=1;j<m;j++)if(check(i,j))return cout<<"Bad placement.",0;
 for(i=1;i<=n;i++)for(j=1;j<=m;j++)if(a[i][j]=='#'&&a[i-1][j]!='#'&&a[i][j-1]!='#')ans++;
 cout<<"There are "<<ans<<" ships.";
}

三倍角公式的可视化证明

Walter_Fang — Sat, 29 Jun 2024 00:00:00 GMT

$sin3\theta=sin\theta+2sin\theta cos2\theta=sin\theta+2sin(1-sin^2\theta)=sin\theta+2sin\theta-4sin^3\theta=3sin\theta-4sin^3\theta$

$cos3\theta=2cos2\theta cos\theta-cos\theta=2cos\theta(2sin^2\theta-1)-cos\theta=4cos^3\theta-2cos\theta-cos\theta=4cos^3\theta-3cos\theta$

新冠生物考点

Walter_Fang — Sat, 01 Jun 2024 00:00:00 GMT

必修一

冠状病毒没有细胞结构，只能寄生于活细胞中。这说明细胞是生物体结构和功能的基本单位，生命活动离不开细胞，冠状病毒需要依靠活细胞合成蛋白质，这说明蛋白质是生命活动的主要承担者。
冠状病毒的遗传物质是单股正链RNA，它的基本组成单位是核糖核苷酸。它可以被吡罗红染液染色。
冠状病毒和细胞膜上的结合位点ACE2结合从而入侵细胞说明细胞膜具有进行信息交流的功能，也说明细胞膜控制物质进出的功能是相对的。
直接参与子代病毒在细胞内的组装过程的结构有核糖体，内质网，高尔基体，囊泡，提供能量的细胞器是线粒体。这说明了各生物膜在结构和功能上紧密联系。
子代病毒通过囊泡排出细胞说明生物膜具有的结构特性是一定的流动性。
合成的RNA聚合酶只对病毒所需RNA的合成起催化作用，说明酶具有专一性。RNA聚合酶与无机催化剂相比催化RNA复制的效率更高，说明酶具有高效性。
人体通过促使被病毒感染的细胞凋亡从而清楚病毒，这说明细胞凋亡有利于维持生物内部环境稳定，抵御外界各种因素干扰。细胞由于病毒的增殖而裂解死亡不属于细胞凋亡。

必修二

冠状病毒的+RNA进入细胞后，首先翻译为RNA聚合酶。这一过程需要的条件有模板：冠状病毒的+RNA，原料：氨基酸，能量，酶，tRNA，rRNA，进行的场所是核糖体。这说明+RNA的作用最类似于人体的mRNA。
正链RNA上结合多个核糖体的意义是少量正链RNA可以迅速合成大量病毒所需的蛋白质。
以+RNA为模板合成-RNA的过程所遵循的碱基互补配对法则与中心法则中的翻译过程相同。这一过程需要的条件有模板：冠状病毒的+RNA，原料：四种游离的核糖核苷酸，能量，酶：RNA聚合酶。
冠状病毒容易形成重组RNA而发生变异这属于基因重组。
冠状病毒相对DNA病毒更容易发生变异，这是由于RNA分子是单链，DNA分子具有双螺旋的双链结构，因此RNA比DNA容易发生碱基增添，替换和丢失。

必修三

冠状病毒侵入人体后需要淋巴细胞和吞噬细胞消灭，淋巴细胞和吞噬细胞直接生活的内环境主要是血浆和淋巴。
ACE2调节人体血量和血压的功能的过程如图2所示，这一过程属于反馈调节，血管紧张素Ⅱ促进肾上腺皮质分泌醛固酮和小动脉收缩的调节方式是体液调节。通常情况肺部细胞ACE2蛋白合成量不大，根本原因是基因的选择性表达。中老年人的一些疾病会导致低钠血症或低血压，据图分析中老年人易感染冠状病毒的原因是低钠血症或低血压会使血管紧张素Ⅰ增加，因此肺部细胞膜上能与冠状病毒结合的ACE2分泌增加，故中老年人容易感染。
冠状病毒主要通过呼吸道侵入人体。鼻腔中的黏膜和毛发属于保卫人体的第一道防线。
冠状病毒进入人体后，吞噬细胞可以对其进行识别和吞噬。这属于非特异性免疫，是人体的第二道防线。
冠状病毒病毒突破前两道防线后，引发人体特异性免疫反应的物质称为抗原，如冠状病毒病毒表面的蛋白质。
吞噬细胞对冠状病毒进行摄取和处理后，将抗原呈递给T细胞。这说明吞噬细胞既能参与特异性免疫，又能参与非特异性免疫。
冠状病毒会入侵肺细胞，要将其完全清除需要经过细胞免疫和体液免疫过程。同时参与这两个过程的淋巴细胞是T细胞。
肺细胞被冠状病毒感染后，效应T细胞与肺细胞密切接触，使细胞裂解死亡。这属于细胞凋亡。
冠状病毒感染后，免疫系统对肺细胞的攻击引发肺炎。此时可以通过适度使用免疫抑制剂对病人进行治疗以避免肺部严重受损。
已被治愈的患者短期内不容易再次被冠状病毒感染，这是由于他们体内产生了记忆细胞，当再次接触冠状病毒抗原时，可以迅速增殖分化为浆细胞和效应T细胞。

P3122 做题笔记

Walter_Fang — Wed, 31 Jan 2024 00:00:00 GMT

省流

Python 大获全胜。

分析

首先得知道 eval 库。然后这道题目可以看成三则运算，FD 是加， BK 是减，REPEAT 是乘。

然后手动把输入的字符串处理一下，丢给 eval 库解决。

了吗？

看个例子：

REPEAT 114[]

显然是 0，但是 eval 把它转换成了这样：

114*()

然后因为 Python 里空括号是空元组，所以上面这种情况手动处理一下就行了。

算法模板

Walter_Fang — Wed, 13 Sep 2023 00:00:00 GMT

快读：

namespace FastIO{
 char *p1,*p2,buf[1<<14];
 #define getchar() (p1==p2&&(p2=(p1=buf)+fread(buf,1,(1<<14),stdin),p1==p2)?EOF:*p1++)
 template <typename T>
 inline void read(T& x){
     x=0;
     register int t=1;
     register char ch=getchar();
     while(ch<'0'||ch>'9'){
         if(ch=='-')t=-1;
         ch=getchar();
     }
     while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
     x*=t;
 }
 template <typename T>
 void write(T x){
     if(x<0)putchar('-'),x=-x;
     if(x>9)write(x/10);
     putchar(x%10^48);
 }
 template <typename T>
 inline void writeln(T x,char sep='\n'){
  write(x);putchar(sep);
 }
}
using namespace FastIO;

ST表：

#include<bits/stdc++.h>
using namespace FastIO;
using namespace std;
const int N=1e6+10;
int n,T,i,j,x,y,a[N][21];
int Query(int x,int y){
    int z=__lg(y-x+1);
    return max(a[x][z],a[y-(1<<z)+1][z]);
}
int main(){
    read(n);read(T);
    for(i=1;i<=n;i++)read(a[i][0]);
    for(j=1;j<=21;j++)
        for(i=1;i<=n-(1<<j)+1;i++)
            a[i][j]=max(a[i][j-1],a[i+(1<<(j-1))][j-1]);
 while(T--)read(x),read(y),writeln(Query(x,y));
}

线段树（维护加法和乘法）：

#include<bits/stdc++.h>
#define ls x<<1
#define rs x<<1|1
using namespace std;
typedef long long ll;
const ll N=1e6+10;
ll n,m,mod,i,op,x,y,z,a[N];
struct Node{ll sum,l,r,Mul,Add;}Tree[N];
void Build(ll x,ll l,ll r){
 Tree[x].l=l,Tree[x].r=r;Tree[x].Mul=1;
 if(l==r){Tree[x].sum=a[l]%mod;return;}
 ll mid=(l+r)>>1;
 Build(ls,l,mid);Build(rs,mid+1,r);
 Tree[x].sum=(Tree[ls].sum+Tree[rs].sum)%mod;
}
void Spread(ll x){
    Tree[ls].sum=(Tree[x].Mul*Tree[ls].sum+((Tree[ls].r-Tree[ls].l+1)*Tree[x].Add)%mod)%mod;
    Tree[rs].sum=(Tree[x].Mul*Tree[rs].sum+(Tree[x].Add*(Tree[rs].r-Tree[rs].l+1))%mod)%mod;
    Tree[ls].Mul=(Tree[ls].Mul*Tree[x].Mul)%mod;
    Tree[rs].Mul=(Tree[rs].Mul*Tree[x].Mul)%mod;
 Tree[ls].Add=(Tree[ls].Add*Tree[x].Mul+Tree[x].Add)%mod;
    Tree[rs].Add=(Tree[rs].Add*Tree[x].Mul+Tree[x].Add)%mod;
    Tree[x].Mul=1;Tree[x].Add=0;
}
void Add(ll x,ll l,ll r,ll k){
 if(Tree[x].l>=l&&Tree[x].r<=r){
  Tree[x].Add=(Tree[x].Add+k)%mod;
  Tree[x].sum=(Tree[x].sum+k*(Tree[x].r-Tree[x].l+1))%mod;
  return;
 }
 Spread(x);
 Tree[x].sum=(Tree[ls].sum+Tree[rs].sum)%mod;
 ll mid=(Tree[x].l+Tree[x].r)>>1;
 if(l<=mid)Add(ls,l,r,k);
 if(mid<r)Add(rs,l,r,k);
 Tree[x].sum=(Tree[ls].sum+Tree[rs].sum)%mod;
}
void Mul(ll x,ll l,ll r,ll k){
 if(Tree[x].l>=l&&Tree[x].r<=r){
  Tree[x].Add=(Tree[x].Add*k)%mod;
  Tree[x].Mul=(Tree[x].Mul*k)%mod;
  Tree[x].sum=(Tree[x].sum*k)%mod;
  return;
 }
 Spread(x);
    Tree[x].sum=Tree[ls].sum+Tree[rs].sum;
 ll mid=(Tree[x].l+Tree[x].r)>>1;
 if(l<=mid)Mul(ls,l,r,k);
 if(mid<r)Mul(rs,l,r,k);
 Tree[x].sum=(Tree[ls].sum+Tree[rs].sum)%mod;
}
ll Query(ll x,ll l,ll r){
 if(Tree[x].l>=l&&Tree[x].r<=r)return Tree[x].sum;
 Spread(x);
 ll v=0,mid=(Tree[x].l+Tree[x].r)>>1;
 if(l<=mid)v=(v+Query(ls,l,r))%mod;
 if(mid<r)v=(v+Query(rs,l,r))%mod;
 return v;
}
int main(){
 cin>>n>>m>>mod;
 for(i=1;i<=n;i++)cin>>a[i];
 Build(1,1,n);
 for(i=1;i<=m;i++){
  cin>>op;
  if(op==1)cin>>x>>y>>z,Mul(1,x,y,z);
  else if(op==2)cin>>x>>y>>z,Add(1,x,y,z);
  else cin>>x>>y,cout<<Query(1,x,y)<<'\n';
    }
}

快速幂：

const ll mod=/*模数*/;
ll qpow(ll x,ll y){
 ll s=1;
 while(y){
  if(y&1)s=s*x%mod;
  y>>=1;x=x*x%mod;
 }
 return s;
}

Trie树：

#include<bits/stdc++.h>
using namespace std;
const int N=3e6+10,M=70;
int T,q,n,i,j,l,f[N][M],sum[N];
char s[N];
int _(char x){
    if(x>='A'&&x<='Z')return x-65;
    else if(x>='a'&&x<='z')return x-71;
    else return x+4;
}
void Add(char str[]){
    int p=0,len=strlen(str),i,c;
    for(i=0;i<len;i++){
        c=_(str[i]);
        if(!f[p][c])f[p][c]=++l;
        p=f[p][c];
        sum[p]++;
    }
}
int Query(char str[]){
    int p=0,len=strlen(str),i,c;
    for(i=0;i<len;i++){
        c=_(str[i]);
        if(!f[p][c])return 0;
        p=f[p][c];
    }
    return sum[p];
}
int main(){
    cin>>T;
    while(T--){
        for(i=0;i<=l;i++)for(j=0;j<=122;j++)f[i][j]=0;
        for(i=0;i<=l;i++)sum[i]=0;
        l=0;
        cin>>n>>q;
        for(i=1;i<=n;i++)cin>>s,Add(s);
        for(i=1;i<=q;i++)cin>>s,cout<<Query(s)<<'\n';
    }
}

Floyd：

int main(){
 cin>>n>>m;memset(f,0x3f,sizeof f);
 for(i=1;i<=m;i++)cin>>x>>y>>z,f[x][y]=f[y][x]=z;
 for(i=1;i<=n;i++)f[i][i]=0;
 for(k=1;k<=n;k++)
  for(i=1;i<=n;i++)
   for(j=1;j<=n;j++)
    if(f[i][k]+f[k][j]<f[i][j])
                    f[i][j]=f[i][k]+f[k][j];
 for(i=1;i<=n;i++,cout<<'\n')
  for(j=1;j<=n;j++)
   if(f[i][j]!=2139062143)cout<<f[i][j]<<' ';
   else cout<<0<<' ';
}

并查集：

#include<bits/stdc++.h>
using namespace std;
int n,T,k,x,y,i,j,f[10010];
int find(int x){return f[x]==x?x:f[x]=find(f[x]);}
int main(){
    cin>>n>>T;
    for(i=1;i<=n;i++)f[i]=i;
    while(T--){
        cin>>k>>x>>y;
        if(k==1)f[find(x)]=find(y);
        else
            if(find(x)==find(y))cout<<"Y\n";
            else cout<<"N\n";
    }
}

KMP：

#include<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
int i,j,l1,l2,f[N];
char a[N],b[N];
int main(){
 cin>>a+1>>b+1;l1=strlen(a+1);l2=strlen(b+1);
 for(i=2;i<=l2;i++){
  while(j&&b[i]!=b[j+1])j=f[j];
  if(b[j+1]==b[i])j++;
  f[i]=j;
 }
 j=0;
 for(i=1;i<=l1;i++){
  while(j>0&&b[j+1]!=a[i])j=f[j];
  if(b[j+1]==a[i])j++;
  if(j==l2)cout<<i-l2+1<<'\n',j=f[j];
 }
 for(i=1;i<=l2;i++)cout<<f[i]<<' ';
}

SPFA：死了，换Dijkstra。

Dijkstra：

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10,M=5e5+10,inf=INT_MAX;
struct Edge{int to,nxt,val;}E[M];
int n,m,s,i,x,y,z,cnt,head[N],dis[N],vis[N];
void add(int x,int y,int z){E[++cnt]={y,head[x],z};head[x]=cnt;}
struct Node{
    int x,y;
    bool operator<(const Node &y)const{return y.x<x;}
};
priority_queue<Node>q;
void Dij(){
 int u,v,i;dis[s]=0;q.push({0,s});
 while(!q.empty()){
  u=q.top().y;x=q.top().x;q.pop();
  if(vis[u])continue;
  vis[u]=1;
  for(i=head[u];i;i=E[i].nxt){
   v=E[i].to;
   if(dis[v]>dis[u]+E[i].val){
    dis[v]=dis[u]+E[i].val;
    if(!vis[v])q.push({dis[v],v});
   }
  }
 }
}
int main(){
 cin>>n>>m>>s;
 for(i=1;i<=n;i++)dis[i]=inf;
 for(i=1;i<=m;i++)cin>>x>>y>>z,add(x,y,z);
 Dij();
 for(i=1;i<=n;i++)cout<<dis[i]<<' ';
}

CRT：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n,i,x,y,a[16],m[16],f[16],mul=1,ans;
void exgcd(ll a,ll b,ll &x,ll &y){
    if(!b){x=1;y=0;return;}
    exgcd(b,a%b,x,y);
    int z=x;x=y,y=z-y*(a/b);
}
int main(){
    cin>>n;
    for(i=1;i<=n;i++)cin>>x>>a[i],m[i]=x,mul*=x;
    for(i=1;i<=n;i++)f[i]=mul/m[i],x=y=0,exgcd(f[i],m[i],x,y),ans+=a[i]*f[i]*(x<0?x+m[i]:x);
    cout<<ans%mul;
}

逆元：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=3e6+10;
ll n,mod,i,inv[N];
int main(){
    cin>>n>>mod;inv[1]=1;
    cout<<1<<'\n';
    for(i=2;i<=n;i++)inv[i]=(mod-mod/i)*inv[mod%i]%mod,cout<<inv[i]<<'\n';
}

单调队列：

#include<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
int n,m,i,l,r,a[N],q1[N],q2[N];
int main(){
    cin>>n>>m;
    for(i=1;i<=n;i++)cin>>a[i];
 l=1;r=0;
    for(i=1;i<=n;i++){
        while(l<=r&&q1[l]+m<=i)l++;
        while(l<=r&&a[i]<a[q1[r]])r--;
        q1[++r]=i;
        if(i>=m)cout<<a[q1[l]]<<' ';
    }
    cout<<'\n';
    l=1;r=0;
    for(i=1;i<=n;i++){
        while(l<=r&&q2[l]+m<=i)l++;
        while(l<=r&&a[i]>a[q2[r]])r--;
        q2[++r]=i;
        if(i>=m)cout<<a[q2[l]]<<' ';
    }
}

扩展欧拉（$a^b\mod m$）：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll a,m,b,x=1,y,i,flag;
char ch;
ll qpow(ll x,ll y){
 ll s=1;
 for(;y;y>>=1,x=x*x%m)if(y&1)s=s*x%m;
 return s;
}
int main(){
 cin>>a>>m;a%=m;y=m;
 for(i=2;i<=sqrt(y);i++){
  if(y%i)continue;
  x*=i-1;y/=i;
  while(!(y%i))x*=i,y/=i;
 }
 if(y>1)x*=y-1;
 while((ch=getchar())<'0'||ch>'9');
 while(b=b*10+ch-'0',(ch=getchar())>='0'&&ch<='9')if(b>=x)flag=1,b%=x;
 if(b>=x)flag=1,b%=x;
 if(flag)b+=x;
 cout<<qpow(a,b);
}

最小生成树（Kruskal）：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=1e6+10;
ll n,m,i,j,s,ans,f[N];
struct Edge{ll x,y,v;}E[N<<1];
ll find(ll x){return f[x]==x?x:f[x]=find(f[x]);}
bool cmp(Edge x,Edge y){return x.v<y.v;}
void Kruskal(){
 int i,fx,fy;
    for(i=1;i<=m;i++){
        fx=find(E[i].x);fy=find(E[i].y);
        if(fx==fy)continue;
        ans+=E[i].v;f[fx]=fy;s++;
        if(s==n-1)break;
    }
}
int main(){
    cin>>n>>m;
    for(i=1;i<=n;i++)f[i]=i;
    for(i=1;i<=m;i++)cin>>E[i].x>>E[i].y>>E[i].v;
    sort(E+1,E+1+m,cmp);
    Kruskal();
    if(s!=n-1)return cout<<"orz",0;
    cout<<ans;
}

P9313 [EGOI2021] Shopping Fever 购物热题解

Walter_Fang — Sat, 09 Sep 2023 00:00:00 GMT

前言

这题考查的算法是 dp。

大致题意

要买 $n$ 个商品，有以下两种优惠：

买了 $3$ 件及以上的商品，则最便宜的免费。
买了 $3$ 件以下的商品，打折 $q%$。

求买下所有商品最少需要多少钱。

思路/解析

按照一般 dp 的流程，分为以下 $2$ 步：

第一步：设置状态。

设 $dp_i$ 表示买前 $i$ 个物品最少需要多少钱。

第二步：状态转移。

根据题意，可得出以下方程：

$dp_i=dp_{i-1}+a_i\times(100-q)\div 100;(i<3)$

$dp_i=\min(dp_{i-3}+a_{i-2}+a_{i-1},dp_{i-1}+a_i\times(100-q)\div 100);(i \geq 3)$

这里注意，由于需要让优惠后剩下的钱数最少，我们需要对 $a$ 数组进行降序排序。另外，本题需要开 long long。

代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=1e5+10,inf=1e18;
ll n,k,i,a[N],dp[N];
int main(){
 cin>>n>>k;
 for(i=1;i<=n;i++)cin>>a[i],dp[i]=inf;
 stable_sort(a+1,a+1+n,greater<int>());
 dp[0]=0;
 for(i=1;i<=2;i++)dp[i]=min(dp[i],dp[i-1]+a[i]*(100-k)/100);
 for(i=3;i<=n;i++)dp[i]=min(dp[i],dp[i-3]+a[i-2]+a[i-1]),dp[i]=min(dp[i],dp[i-1]+a[i]*(100-k)/100);;
 cout<<dp[n];
}

SP7015 CFPARTY - Party 题解

Walter_Fang — Fri, 08 Sep 2023 00:00:00 GMT

前言

这题不难，前提在于你想到了没。

大致题意

有 $n$ 个人，先去掉没有朋友的人，再去掉有 $1$ 个朋友的人，以此类推。求出最后剩下多少人。

抽象题意

构造一张有 $n$ 个结点的图，依次删去度数为 $0$ 到 $n-1$ 的结点，直至无法删除，求出最后最多能剩余几个结点。

思路/解析

若这 $n$ 个点两两相连，则有 $n\times(n-1)\div2$ 条边，这样每个结点的度数都为 $n-1$，都会被删去。

如果删去一条边，就有两个结点的度数变成了 $n-2$，会在别的 $n-2$ 个点之前被删去，删去后剩下的结点的度数变成了 $n-2$，不会被删去。所以最优方案为剩下 $n-2$ 个点。

代码

#include<bits/stdc++.h>
using namespace std;
int T,x;
int main(){
 cin>>T;
 while(T--)cin>>x,cout<<max(x-2,0)<<'\n';
}

CF41E 3-cycles 题解

Walter_Fang — Wed, 30 Aug 2023 00:00:00 GMT

大致题意

求结点数为 $n$ 并且任意取三结点均为连通图但不是环的无向图的最大边数 $m$，并输出任意一种可能。

思路/解析

这是一道抽屉原理的题。我们只需要 $2$ 个抽屉就可以保证任意取 $3$ 个点不可能形成环，因为至少有一个抽屉存在 $2$ 个及以上的点。但是如果将抽屉的数量增加到 $3$ 个，那么就有可能存在没个抽屉 $1$ 个点的情况，这样就有可能存在环。因此，我们只需要 $2$ 个抽屉，并保证同一抽屉内的点不连边，不同抽屉的点连边即可。

对于答案数量，我们只需要平均分成两组就好了。注意当 $n$ 为奇数时需要加 $1$。

代码

#include<bits/stdc++.h>
using namespace std;
int n,m,i,j;
int main(){
 cin>>n;
 if(n%2==1)m=(n/2)*(n/2+1);
 else m=(n/2)*(n/2);
 cout<<m<<'\n';
 for(i=1;i<=n/2;i++)
  for(j=n/2+1;j<=n;j++)
   cout<<i<<' '<<j<<'\n';
}

对某（前）犇犇网红的严厉声明与谴责

Walter_Fang — Wed, 23 Aug 2023 00:00:00 GMT

观前声明：

本文不含任何引战和对线内容。
请在理智状态下阅读本文，否则造成的任何后果笔者均不负责。

这是你们等着的。下午的事我都看到了，我不瞎。

按照时间线梳理一下所有事情的经过。

23.07.31

这天用户963378在犇犇中发布大量无意义、负能量的内容，并以自杀为名博人眼球，引起了我的强烈不满。因此当天晚上我拉黑了此人。

同时，晚上因为此事和家人起了一些争执，最终导致我开启学术、关闭私信，并申请了禁言。

目前我并不认为我做错了什么。

23.08.21

我认为和家人的情况有所缓和，因此制作了互关要求，放在了主页，并开启了私信。

目前我做错了：互关要求过高。

23.08.22

这天晚上用户963378使用其小号1002006发送了如下内容：

对此我做出了如下回应：

我并不认为我说错了什么。如果我说话过激的话，我很抱歉。

23.08.23

下午16：30左右用户963378开始针对我的行为开始诋毁。包括过高的互关要求、令人厌恶的说话态度等，并且夹杂了少量的攻击性语言。

在此期间因其（用户963378）热度较高，因此引起了大批人的关注，其中绝大部分人开始对我进行口诛笔伐，当时我正在集训，因此未对该事件作出回应。

傍晚我删除了对红黄橙的要求，晚上删除了互关条件，并着手开始撰写本文。

请注意，如果您如果对我有任何的不满，应当：

立即取关并拉黑；
删除所有与我有关的内容。

不应：

尝试发送攻击性语言、引战、对线；
在不通知笔者的情况下进行诋毁、口诛笔伐。

如若本文引起了您的不适，请立即按照上文进行处理。

本文评论区一旦发现任何无关/无意义内容，笔者将会在不通知的情况下直接删除，请见谅。笔者已经禁言，因此无法做出回复，请见谅。

$upd 19:34$

希望事情真的暂时得到了解决。

对于用户963378，已解除拉黑，未关注。

AT_dp_z Frog 3 题解

Walter_Fang — Sun, 06 Aug 2023 00:00:00 GMT

大致题意

有 $n$ 个点，每个点有一个属性 $h_i$，$h_i$ 单调递增，从 $i$ 点移动到大于 $i$ 的 $j$ 点，需要付出 $(h_i-h_j)^2+c$ 的代价，其中 $c$ 题中已给出，求点 $1$ 移动到点 $n$ 的最小代价。

思路/解析

设 $f_i$ 表示从点 $1$ 移动到点 $i$ 的最小代价，容易列出状态转移方程为 $f_i=\min_{j<i}(f_j+(a_i-a_j)^2+c)$。

直接转移的时间复杂度是 $O(n^2)$，无法通过本题，于是运用斜率优化，公式就变为了

$$\begin{aligned}f_i&=f_j+a_i^2-2a_ia_j+a_j^2+c\(f_i-a_i^2)&=(f_j+a_j^2+c)-(2a_i)(a_j)\end{aligned}$$

将状态 $i$ 视为平面上的点 $(a_i,f_i+a_i^2+c)$，问题就变成了求最小的斜率固定的直线的截距，因为 $a_i$ 单调递增，所以点的坐标也单调递增，斜率也单调递增。使用单调队列维护下凸壳，即可通过本题。

代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=2e5+10;
ll n,c,i,l,r,h[N],q[N],dp[N];
double Y(ll j){return dp[j]+h[j]*h[j];}
double X(ll i){return h[i]<<1;}
double K(ll i,ll j){return (Y(i)-Y(j))/((X(i)-X(j)));}
int main(){
 cin>>n>>c;
 for(i=1;i<=n;i++)cin>>h[i];
 l=r=q[1]=1;
 for(i=2;i<=n;i++){
  while(l<r&&h[i]>=K(q[l],q[l+1]))l++;
  dp[i]=dp[q[l]]+c+(h[i]-h[q[l]])*(h[i]-h[q[l]]);
  while(l<r&&K(q[r-1],q[r])>=K(q[r],i))r--;
  q[++r]=i;
 }
 cout<<dp[n]<<'\n';
}

P9504 『MGOI』Simple Round I | C. 魔法禁林题解

Walter_Fang — Sun, 06 Aug 2023 00:00:00 GMT

原题

思路/解析

笔者的思路不是很正经，但可以通过此题。思路为：宽搜+卡常。

我们使用链式前向星存储这张图，用二维数组 $f$ 保存当前步数，然后根据题意进行宽搜，这样可以通过 Substack 1&2。

对于 Substack 3：

注意到 $w\le 1$，因此答案只有可能是 $0$ 或 $1$。因此当权值 $z$ 只包含 $0$ 或 $1$ 时，我们只需要特判，当权值全为 $1$ 时，输出 $1$，否则输出 $0$。

对于 Substack 4：

使用快读+register int通过本 Substack。

至此，本题已 AC。

代码

#include<bits/stdc++.h>
using namespace std;
const int N=4e4+10;
int n,m,st,ed,head[N],f[N][510],u,v,sx,sy,sz,fx,fy,fz,cnt,x,y,z,ma=INT_MIN,mi=INT_MAX;
struct Node{int x,y;};
queue<Node>q;
struct Edge{int to,nxt,val;}E[N<<1];
void add(int x,int y,int z){E[++cnt]={y,head[x],z};head[x]=cnt;}
namespace FastIO {
 char *p1, *p2, buf[1 << 14];
 #define getchar() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, (1 << 14), stdin), p1 == p2) ? EOF : *p1++)

 template <typename T>
 inline void read(T& x) {
     x = 0;
     register int t = 1;
     register char ch = getchar();
     while (ch < '0' || ch > '9') {
         if (ch == '-')
             t = -1;
         ch = getchar();
     }
     while (ch >= '0' && ch <= '9'){
         x = (x << 1) + (x << 3) + (ch ^ 48);
         ch = getchar();
     }
     x *= t;
 }

 template <typename T>
 void write(T x) {
     if (x < 0) {
         putchar('-');
         x = -x;
     }
     if (x > 9) write(x / 10);
     putchar(x % 10 ^ 48);
 }
 template <typename T>
 inline void writeln(T x, char sep = '\n') {
  write(x);
  putchar(sep);
 }
}
using namespace FastIO;
int main(){
 read(n);read(m);read(st);read(ed);
 for(register int i=1;i<=m;++i){
  read(x),read(y),read(z);
  add(x,y,z),add(y,x,z),ma=(z>ma)?z:ma;
 }
 if(ma<=1){
  for(register int i=head[ed];i;i=E[i].nxt)if(!E[i].val)return cout<<0,0;
  return cout<<1,0;
 }
 q.push({ed,1});
 while(!q.empty()){
 register int u=q.front().x,fy=q.front().y,fz=f[u][fy-1];q.pop();
  if(fy>=482)break;
  for(register int i=head[u];i;i=E[i].nxt){
   register int v=E[i].to,sx=fz+E[i].val/fy,sy=fy+1;
   if(f[v][fy]<=sx&&f[v][fy])continue;
   q.push({v,sy});f[v][fy]=sx;
  }
 }
 for(register int i=0;i<=482;++i)if(f[st][i])mi=(f[st][i]<mi)?f[st][i]:mi;
 cout<<mi;
}

AT_abc041_d [ABC041D] 徒競走题解

Walter_Fang — Sat, 05 Aug 2023 00:00:00 GMT

翻译已经非常言简意赅了，题目大意就不说了。

思路/解析

状压 dp。

我们用 $f_i$ 保存已经遍历过的点集为 $i$ 的方案数量，那么当要加入一个新节点 $j$ 时，节点 $j$ 的所有子节点必须全部在点集 $i$ 中。

需要注意的是，最初我们将没有点权看作第一种方案，即 $f_0=1$。

代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=2e5+10;
ll n,m,x,y,i,j,a[N],f[N]={1};
int main(){
 cin>>n>>m;
 for(i=1;i<=m;i++)cin>>x>>y,a[x]|=1<<y-1;
 for(i=0;i<(1<<n);i++)
  for(j=1;j<=n;j++)
   if((a[j]&i)==a[j]&&!(i>>j-1&1))
    f[i|(1<<j-1)]+=f[i];
 cout<<f[(1<<n)-1];
}

Walter_Fang

【置顶】致新访客

【置顶】博客维护教程

KaTeX 支持

行内公式 (Inline)

块级公式 (Block)

复杂示例

矩阵 (Matrices)

极限与求和 (Limits and Sums)

麦克斯韦方程组 (Maxwell's Equations)

化学方程式 (Chemical Equations)

更多符号

Markdown 扩展功能

GitHub 仓库卡片

提醒框

剧透

Mermaid 图表

流程图示例

时序图示例

甘特图示例

类图示例

状态图示例

饼图示例

嵌入视频

YouTube

Bilibili

文章的 Front-matter

文章文件的放置位置

自定义文章 URL (Slug)

什么是 Slug？

Slug 使用示例

示例 1：使用文件名作为 URL

示例 2：自定义 Slug

示例 3：中文标题使用英文 Slug

Slug 使用建议

注意事项

活成常人：我的2025

关于生活方面

游戏方面

音游

Galgame

其他的

互联网方面

技术方面

关于学业

另外的

浏览器自动补全

2507成都行

图片大小晚点调，初稿一坨过两天润色

Day 0

Day 1

Day 3

Day 4~7

CSP 2024 游记 & 退役记

还在施工

前言

题解：P4526 【模板】自适应辛普森法 2

自适应辛普森法题解与学习笔记

前言

算法介绍

题解

题解：P11214 【MX-J8-T2】黑洞

前言

题意

解析

代码

题解：P11217 【MX-S4-T1】「yyOI R2」youyou 的垃圾桶

前言

解析

几个坑点

代码

转载作文『落雪』

雪

P2880 做题笔记

函数零点求解方法与布伦特法

一般的零点求解方法

布伦特法

方法的选择

题解：P4986 逃离

前言

P9313 [EGOI2021] Shopping Fever 购物热题解