如形の博客

MDX 组件使用：User & Advanced

Sun, 11 Jan 2026 00:00:00 GMT

import { Aside, Tabs, TabItem, Spoiler } from '@/components/user' import { GithubCard, LinkPreview, QRCode, ImageGroup, WebVideo } from '@/components/advanced'

1. 必须使用 MDX

.md 文章无法 import 组件；请使用 .mdx（如 src/content/blogs/<slug>/index.mdx）。

2. User 组件示例

3. Advanced 组件示例

GitHub 卡片

链接预览

二维码

图片组（等高拼图）

内嵌视频

写作指南：Markdown / MDX

Sun, 11 Jan 2026 00:00:00 GMT

1. Markdown 支持范围

主题默认启用了常用扩展：

GFM：表格、删除线、任务列表等
数学公式：KaTeX（ $...$ / $$...$$）
代码高亮：Shiki（支持标题、差异标注等）

2. 数学公式（KaTeX）

行内：

欧拉公式：$e^{i\\pi}+1=0$

块级：

$$
\\int_0^1 x^2 dx = \\frac{1}{3}
$$

3. 代码块增强（差异/高亮）

你可以在代码中使用注释标记来展示变更（示例来自主题的高亮 transformer）：

const a = 1 // [!code --]
const a = 2 // [!code ++]

也可以做行高亮：

const token = 'secret' // [!code highlight]

4. 什么时候用 MDX

当你需要在文章里使用组件（例如 Aside、Tabs、GithubCard 等）时，请使用 .mdx，并在文件顶部 import 组件。

组件用法示例文档：见 “MDX 组件使用”。

博客迁移分流说明

Mon, 03 Aug 2026 10:59:41 GMT

在我的第 $2$ 个博客陪伴大家 $4$ 个月后，由于主题过于臃肿，加载太慢，迁移所有文章至此，原博客将归档，望周知。

谢谢你们的支持！

洛谷网校 CSP 初赛笔记

Wed, 22 Jul 2026 21:53:36 GMT

位运算

& 如果 $x,y$ 的对应位都为 $1$，则结果为 $1$，否则结果为 $0$。
| 如果 $x,y$ 的对应位都为 $0$，则结果为 $0$，否则结果为 $1$。
^ 如果 $x,y$ 的对应位不同，则结果为 $1$，否则结果为 $0$。
<< $x$ 左移 $y$ 位，高位删除，如：$(1010)_{2}\texttt{<<}2=1000$；
>> $x$ 右移 $y$ 位，低位删除，如：$(1010)_{2}\texttt{>>}2=0010$；

应用

n^=1<<x;//反转第x位
n|=1<<x;//将第x位设为1
n&=~(1u<<x)//将第x位设为0 (1u 是无符号数 unsigned 的写法)
int m=n&((1<<x)-1);//取出n的前x个位
int k=(n>>x)&1;//获得n的第x位

优先级表

~><<和>>>&>^>|，同级运算从左向右。

如图，是所有运算的优先级表：

ASCLL 码

$0 \sim 9$ : $48 \sim 57$
A $\sim$ Z: $65 \sim 90$
a $\sim$ a: $97 \sim 122$

:::info 以数字 $0 \sim 9$ 开头的都是数字，例如：$\texttt{0x3f3f3f}$ :::

在 Hexo 中复现洛谷插件

Sun, 07 Jun 2026 18:31:24 GMT

前言

OIer 都知道，洛谷中有个 Markdown 插件，非常好用，效果如下：

:::info[这是一个提示] 我是提示内容。 :::

:::::warning[我是父容器]

我是一些文字。

::::success[我是子容器 1]{open} 我是内容 1。 ::::

我是一些文字。

::::success[我是子容器 2]{open} :::error[我是子容器 3]{open} 我是内容 2。 ::: ::::

我是一些文字。

:::::

:::epigraph[——otto] 大家好啊，我是说的道理。 :::

:::align{left} 居左内容。 :::

:::align{center} 居中内容。 :::

:::align{right} 居右内容。 :::

源码：

:::info[这是一个提示]
我是提示内容。
:::

:::::warning[我是父容器]

我是一些文字。

::::success[我是子容器 1]{open}
我是内容 1。
::::

我是一些文字。

::::success[我是子容器 2]{open}
:::error[我是子容器 3]{open}
我是内容 2。
:::
::::

我是一些文字。

:::::

:::epigraph[——otto]
大家好啊，我是说的道理。
:::

:::align{left}
居左内容。
:::

:::align{center}
居中内容。
:::

:::align{right}
居右内容。
:::

还有更多……

尽管安知鱼主题自带很多标签外挂，但仍然无法满足~~复制洛谷文章到博客~~编写习惯性的需求，于是，我全网首发了在 Hexo 中使用洛谷 Md 插件教程。

:::info[闲话] 由于~~不良~~习惯，我的所有 Markdown 文章编写均遵循洛谷的专栏全站推荐规范、洛谷主题库题解规范和如何用 Markdown 和 LaTeX 写一篇排版整齐的题解？ :::

方法

:::align{center} 知其然，知其所以然 :::

用 Javasript 自定义 Hexo 的 markdown 解析，用正则匹配把标识等进行匹配，转换为 Html，最后由 Css 完成样式。

实现

:::warning{open} 本教程以 anzhiyu 主题为例，其他主题亦可，视情况更改 Css 文件目录和引用方式，~~参见你的博客主题的文档~~以后可能会更新下这篇文章，搞个多主题支持。 :::

首先，在博客中新建 Css （~/themes/···（主题名称）/source/css/custom_marked.css）粘贴以下代码并引入（Anzhiyu 主题可以在 config.yml 中的 Inject.head 配置项中引入）。

.align-left {
  text-align: left !important;
}

.align-center {
  text-align: center !important;
}

.align-right {
  text-align: right !important;
}

.epigraph {
  width: 40%;
  margin-left: 60%;
}

.epigraph > :last-child {
  margin-top: 0;
  border-top: 1px solid #888;
  text-align: right;
}

summary {
  list-style: none;
  -webkit-user-select: none;
  user-select: none;
  outline: 0;
  margin: 0;
  position: relative;
  padding-left: 24px;
  font-weight: 700;
  list-style: none;
  display: list-item;
  min-height: 1em;
}

.foldable {
  padding: 0.5em 1em;
  margin: 1em 0 1em 0.2em;
  border-left-width: 5px;
  border-left-style: solid;
  overflow: hidden;
}

.foldable.info {
  border-left-color: rgb(52, 152, 219);
}

.foldable.warning {
  border-left-color: rgb(255, 193, 22);
}

.foldable.success {
  border-left-color: rgb(82, 196, 26);
}

.foldable.error {
  border-left-color: rgb(231, 76, 60);
}

.foldable.bug {
  border-left-color: rgb(231, 76, 60);
}

.foldable.flask {
  border-left-color: rgb(155, 89, 182);
}

details.info > summary {
  color: rgb(52, 152, 219);
}

details.warning > summary {
  color: rgb(255, 193, 22);
}

details.success > summary {
  color: rgb(82, 196, 26);
}

details.error > summary {
  color: rgb(231, 76, 60);
}

details.bug > summary {
  color: rgb(231, 76, 60);
}

details.flask > summary {
  color: rgb(155, 89, 182);
}

details.info > summary::before {
  -webkit-mask-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg"%20viewBox="0 0 512 512"><path d="M256 512A256 256 0 1 0 256 0a256 256 0 1 0 0 512zM216 336h24V272H216c-13.3 0-24-10.7-24-24s10.7-24 24-24h48c13.3 0 24 10.7 24 24v88h8c13.3 0 24 10.7 24 24s-10.7 24-24 24H216c-13.3 0-24-10.7-24-24s10.7-24 24-24zm40-208a32 32 0 1 1 0 64 32 32 0 1 1 0-64z"/></svg>');
  mask-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg"%20viewBox="0 0 512 512"><path d="M256 512A256 256 0 1 0 256 0a256 256 0 1 0 0 512zM216 336h24V272H216c-13.3 0-24-10.7-24-24s10.7-24 24-24h48c13.3 0 24 10.7 24 24v88h8c13.3 0 24 10.7 24 24s-10.7 24-24 24H216c-13.3 0-24-10.7-24-24s10.7-24 24-24zm40-208a32 32 0 1 1 0 64 32 32 0 1 1 0-64z"/></svg>');
}

details.success > summary::before {
  -webkit-mask-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg"%20viewBox="0 0 512 512"><path d="M256 512A256 256 0 1 0 256 0a256 256 0 1 0 0 512zM369 209L241 337c-9.4 9.4-24.6 9.4-33.9 0l-64-64c-9.4-9.4-9.4-24.6 0-33.9s24.6-9.4 33.9 0l47 47L335 175c9.4-9.4 24.6-9.4 33.9 0s9.4 24.6 0 33.9z"/></svg>');
  mask-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg"%20viewBox="0 0 512 512"><path d="M256 512A256 256 0 1 0 256 0a256 256 0 1 0 0 512zM369 209L241 337c-9.4 9.4-24.6 9.4-33.9 0l-64-64c-9.4-9.4-9.4-24.6 0-33.9s24.6-9.4 33.9 0l47 47L335 175c9.4-9.4 24.6-9.4 33.9 0s9.4 24.6 0 33.9z"/></svg>');
}

details.warning > summary::before {
  -webkit-mask-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg"%20viewBox="0 0 512 512"><path d="M256 512A256 256 0 1 0 256 0a256 256 0 1 0 0 512zm0-384c13.3 0 24 10.7 24 24V264c0 13.3-10.7 24-24 24s-24-10.7-24-24V152c0-13.3 10.7-24 24-24zM224 352a32 32 0 1 1 64 0 32 32 0 1 1 -64 0z"/></svg>');
  mask-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg"%20viewBox="0 0 512 512"><path d="M256 512A256 256 0 1 0 256 0a256 256 0 1 0 0 512zm0-384c13.3 0 24 10.7 24 24V264c0 13.3-10.7 24-24 24s-24-10.7-24-24V152c0-13.3 10.7-24 24-24zM224 352a32 32 0 1 1 64 0 32 32 0 1 1 -64 0z"/></svg>');
}

details.error > summary::before {
  -webkit-mask-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg"%20viewBox="0 0 512 512"><path d="M256 512A256 256 0 1 0 256 0a256 256 0 1 0 0 512zM175 175c9.4-9.4 24.6-9.4 33.9 0l47 47 47-47c9.4-9.4 24.6-9.4 33.9 0s9.4 24.6 0 33.9l-47 47 47 47c9.4 9.4 9.4 24.6 0 33.9s-24.6 9.4-33.9 0l-47-47-47 47c-9.4 9.4-24.6 9.4-33.9 0s-9.4-24.6 0-33.9l47-47-47-47c-9.4-9.4-9.4-24.6 0-33.9z"/></svg>');
  mask-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg"%20viewBox="0 0 512 512"><path d="M256 512A256 256 0 1 0 256 0a256 256 0 1 0 0 512zM175 175c9.4-9.4 24.6-9.4 33.9 0l47 47 47-47c9.4-9.4 24.6-9.4 33.9 0s9.4 24.6 0 33.9l-47 47 47 47c9.4 9.4 9.4 24.6 0 33.9s-24.6 9.4-33.9 0l-47-47-47 47c-9.4 9.4-24.6 9.4-33.9 0s-9.4-24.6 0-33.9l47-47-47-47c-9.4-9.4-9.4-24.6 0-33.9z"/></svg>');
}

details.bug > summary::before {
  -webkit-mask-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!--! Font Awesome Free 6.7.2 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons:CC BY 4.0,Fonts:SIL OFL 1.1,Code:MIT License) Copyright 2024 Fonticons,Inc. --><path d="M256 0c53 0 96 43 96 96l0 3.6c0 15.7-12.7 28.4-28.4 28.4l-135.1 0c-15.7 0-28.4-12.7-28.4-28.4l0-3.6c0-53 43-96 96-96zM41.4 105.4c12.5-12.5 32.8-12.5 45.3 0l64 64c.7 .7 1.3 1.4 1.9 2.1c14.2-7.3 30.4-11.4 47.5-11.4l112 0c17.1 0 33.2 4.1 47.5 11.4c.6-.7 1.2-1.4 1.9-2.1l64-64c12.5-12.5 32.8-12.5 45.3 0s12.5 32.8 0 45.3l-64 64c-.7 .7-1.4 1.3-2.1 1.9c6.2 12 10.1 25.3 11.1 39.5l64.3 0c17.7 0 32 14.3 32 32s-14.3 32-32 32l-64 0c0 24.6-5.5 47.8-15.4 68.6c2.2 1.3 4.2 2.9 6 4.8l64 64c12.5 12.5 12.5 32.8 0 45.3s-32.8 12.5-45.3 0l-63.1-63.1c-24.5 21.8-55.8 36.2-90.3 39.6L272 240c0-8.8-7.2-16-16-16s-16 7.2-16 16l0 239.2c-34.5-3.4-65.8-17.8-90.3-39.6L86.6 502.6c-12.5 12.5-32.8 12.5-45.3 0s-12.5-32.8 0-45.3l64-64c1.9-1.9 3.9-3.4 6-4.8C101.5 367.8 96 344.6 96 320l-64 0c-17.7 0-32-14.3-32-32s14.3-32 32-32l64.3 0c1.1-14.1 5-27.5 11.1-39.5c-.7-.6-1.4-1.2-2.1-1.9l-64-64c-12.5-12.5-12.5-32.8 0-45.3z"/></svg>');
  mask-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!--! Font Awesome Free 6.7.2 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons:CC BY 4.0,Fonts:SIL OFL 1.1,Code:MIT License) Copyright 2024 Fonticons,Inc. --><path d="M256 0c53 0 96 43 96 96l0 3.6c0 15.7-12.7 28.4-28.4 28.4l-135.1 0c-15.7 0-28.4-12.7-28.4-28.4l0-3.6c0-53 43-96 96-96zM41.4 105.4c12.5-12.5 32.8-12.5 45.3 0l64 64c.7 .7 1.3 1.4 1.9 2.1c14.2-7.3 30.4-11.4 47.5-11.4l112 0c17.1 0 33.2 4.1 47.5 11.4c.6-.7 1.2-1.4 1.9-2.1l64-64c12.5-12.5 32.8-12.5 45.3 0s12.5 32.8 0 45.3l-64 64c-.7 .7-1.4 1.3-2.1 1.9c6.2 12 10.1 25.3 11.1 39.5l64.3 0c17.7 0 32 14.3 32 32s-14.3 32-32 32l-64 0c0 24.6-5.5 47.8-15.4 68.6c2.2 1.3 4.2 2.9 6 4.8l64 64c12.5 12.5 12.5 32.8 0 45.3s-32.8 12.5-45.3 0l-63.1-63.1c-24.5 21.8-55.8 36.2-90.3 39.6L272 240c0-8.8-7.2-16-16-16s-16 7.2-16 16l0 239.2c-34.5-3.4-65.8-17.8-90.3-39.6L86.6 502.6c-12.5 12.5-32.8 12.5-45.3 0s-12.5-32.8 0-45.3l64-64c1.9-1.9 3.9-3.4 6-4.8C101.5 367.8 96 344.6 96 320l-64 0c-17.7 0-32-14.3-32-32s14.3-32 32-32l64.3 0c1.1-14.1 5-27.5 11.1-39.5c-.7-.6-1.4-1.2-2.1-1.9l-64-64c-12.5-12.5-12.5-32.8 0-45.3z"/></svg>');
}

details.flask > summary::before {
  -webkit-mask-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512"><!--! Font Awesome Free 6.7.2 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons:CC BY 4.0,Fonts:SIL OFL 1.1,Code:MIT License) Copyright 2024 Fonticons,Inc. --><path d="M288 0L160 0 128 0C110.3 0 96 14.3 96 32s14.3 32 32 32l0 132.8c0 11.8-3.3 23.5-9.5 33.5L10.3 406.2C3.6 417.2 0 429.7 0 442.6C0 480.9 31.1 512 69.4 512l309.2 0c38.3 0 69.4-31.1 69.4-69.4c0-12.8-3.6-25.4-10.3-36.4L329.5 230.4c-6.2-10.1-9.5-21.7-9.5-33.5L320 64c17.7 0 32-14.3 32-32s-14.3-32-32-32L288 0zM192 196.8L192 64l64 0 0 132.8c0 23.7 6.6 46.9 19 67.1L309.5 320l-171 0L173 263.9c12.4-20.2 19-43.4 19-67.1z"/></svg>');
  mask-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512"><!--! Font Awesome Free 6.7.2 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons:CC BY 4.0,Fonts:SIL OFL 1.1,Code:MIT License) Copyright 2024 Fonticons,Inc. --><path d="M288 0L160 0 128 0C110.3 0 96 14.3 96 32s14.3 32 32 32l0 132.8c0 11.8-3.3 23.5-9.5 33.5L10.3 406.2C3.6 417.2 0 429.7 0 442.6C0 480.9 31.1 512 69.4 512l309.2 0c38.3 0 69.4-31.1 69.4-69.4c0-12.8-3.6-25.4-10.3-36.4L329.5 230.4c-6.2-10.1-9.5-21.7-9.5-33.5L320 64c17.7 0 32-14.3 32-32s-14.3-32-32-32L288 0zM192 196.8L192 64l64 0 0 132.8c0 23.7 6.6 46.9 19 67.1L309.5 320l-171 0L173 263.9c12.4-20.2 19-43.4 19-67.1z"/></svg>');
}

summary::before {
  content: "";
  background-color: currentcolor;
  -webkit-mask-size: contain;
  mask-size: contain;
  -webkit-mask-repeat: no-repeat;
  mask-repeat: no-repeat;
  -webkit-mask-position: center;
  mask-position: center;
  position: absolute;
  left: 0;
  top: 50%;
  transform: translateY(-50%);
  width: 16px;
  height: 16px;
  margin-right: 8px;
}

summary:after {
  content: "";
  background-color: currentcolor;
  -webkit-mask-size: contain;
  mask-size: contain;
  mask-image: url("data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%20256%20512%22%3E%3Cpath%20d%3D%22M246.6%20278.6c12.5-12.5%2012.5-32.8%200-45.3l-128-128c-9.2-9.2-22.9-11.9-34.9-6.9s-19.8%2016.6-19.8%2029.6l0%20256c0%2012.9%207.8%2024.6%2019.8%2029.6s25.7%202.2%2034.9-6.9l128-128z%22%2F%3E%3C%2Fsvg%3E");
  -webkit-mask-repeat: no-repeat;
  mask-repeat: no-repeat;
  -webkit-mask-position: center;
  mask-position: center;
  position: absolute;
  right: 0;
  top: 50%;
  transform: translateY(-50%);
  width: 16px;
  height: 16px;
  transition: transform 0.2s ease;
}

details[open] > summary::after {
  transform: translateY(-50%) rotate(90deg);
}

pre code.hljs {
  display: block;
  overflow-x: auto;
  padding: 1em;
}

code.hljs {
  padding: 3px 5px;
}

code[class*="language-"],
pre {
  background: #fefefe;
  color: #383a42;
  font-family:
    Fira Code,
    Fira Mono,
    Menlo,
    Consolas,
    DejaVu Sans Mono,
    monospace;
  direction: ltr;
  text-align: left;
  white-space: pre;
  word-spacing: normal;
  word-break: normal;
  line-height: 1.5;
  -moz-tab-size: 2;
  -o-tab-size: 2;
  tab-size: 2;
  -webkit-hyphens: none;
  -moz-hyphens: none;
  -ms-hyphens: none;
  hyphens: none;
}

code[class*="language-"]::-moz-selection,
code[class*="language-"] *::-moz-selection,
pre *::-moz-selection {
  background: #e5e5e6;
  color: inherit;
}

code[class*="language-"]::selection,
code[class*="language-"] *::selection,
pre *::selection {
  background: #e5e5e6;
  color: inherit;
}

pre {
  padding: 1em;
  margin: 0.5em 0;
  overflow: auto;
  border-radius: 0.3em;
}

:not(pre) > code[class*="language-"] {
  padding: 0.2em 0.3em;
  border-radius: 0.3em;
  white-space: normal;
}

.copy-button[data-v-a7061ca4] {
  position: absolute;
  top: 0.5em;
  right: 0.5em;
  padding: 0.6em;
  display: flex;
  align-items: center;
  justify-content: center;
  transition:
    0.2s ease-in-out opacity,
    0.2s ease-in-out color,
    0.2s ease-in-out background-color;
  opacity: 0;
  background-color: transparent;
  border: none;
  border-radius: 4px;
  cursor: pointer;
  color: #555;
}

.code-container {
  margin: 1rem 0;
  position: relative;
  border-radius: 0.3em;
}

.code-container:hover > .copy-button {
  opacity: 1;
}

.code-container:hover > .copy-button:hover {
  background-color: #ddd;
}

h1 {
  font-size: 2em;
  margin: 0.67em 0;
}

h1 {
  margin: 1.5rem 0 1rem;
  font-size: 2em;
  padding-bottom: 0.1em;
  border-bottom: solid 1px #d8d8d8;
}

h2 {
  margin: 1.2rem 0 1rem;
  font-size: 1.5em;
  padding-bottom: 0.1em;
  border-bottom: solid 1px #d8d8d8;
}

h3 {
  margin: 1.2rem 0 1rem;
  font-size: 1.2em;
}

h4 {
  margin: 1rem 0;
  font-size: 1.1em;
}

h5 {
  margin: 1rem 0;
  font-size: 1em;
}

h6 {
  margin: 1rem 0;
  font-size: 1em;
  color: #666;
}

img {
  max-width: 100%;
}

ul,
ol {
  padding-left: 2em;
}

li + li {
  margin-top: 0.2em;
}

li.task-list-item {
  position: relative;
  list-style-type: none;
}

li.task-list-item > input:first-child {
  position: absolute;
  left: -1.5em;
  top: 55%;
  transform: translateY(-50%);
  padding: 0;
  margin: 0;
}

hr {
  margin: 1em 0;
  height: 0;
  border: none;
  border-bottom: solid 1px #eee;
}

a {
  text-decoration: none;
  transition: filter 0.1s ease;
  color: rgb(var(--lcolor--link, 52, 152, 219));
  cursor: pointer;
}

table {
  border-collapse: collapse;
  border-spacing: 0;
  display: block;
  width: 100%;
  overflow: auto;
  word-break: keep-all;
  margin: 10px;
  font-variant-numeric: tabular-nums;
}

th,
td {
  border: 1px solid #ddd;
  padding: 6px 13px;
}

blockquote {
  padding: 10px 20px;
  margin: 0 0 20px;
  border-left: 5px solid #eee;
}

a {
  background-color: transparent;
}

然后直接在 ~/themes/···（主题名称）/scripts 中新建 custom_marked.js（也可以是别的名字），粘贴以下代码即可，不用引入。

const allowedFoldableTypes = new Set(['info', 'warning', 'success', 'error', 'bug', 'flask']);

function renderMarkdown(content) {
  return hexo.render.renderSync({ text: content.trim(), engine: 'markdown' });
}

function renderCustomBlock(blockType, title, opt, body) {
  const type = blockType.toLowerCase();
  const content = renderMarkdown(body.trim());

  if (type === 'align') {
    const dir = title ? title.trim() : 'left';
    return `\n<div class="align-${dir}">\n${content}\n</div>\n`;
  }

  if (type === 'epigraph') {
    const author = title ? `<p class="epigraph-author">${title}</p>` : '';
    return `\n<div class="epigraph">\n${content}${author}\n</div>\n`;
  }

  if (allowedFoldableTypes.has(type)) {
    const openAttr = opt && opt.includes('open') ? ' open' : '';
    const summary = title ? title.trim() : '详情';
    return `\n<details class="foldable ${type}"${openAttr}>\n  <summary>${summary}</summary>\n  <div>\n${content}\n  </div>\n</details>\n`;
  }

  return null;
}

function parseCustomBlocks(content) {
  const lines = content.split(/\r?\n/);
  const root = { type: 'root', children: [] };
  const stack = [root];
  let codeFence = null;
  const openRule = /^\s*(:{3,})([a-zA-Z]\w*)(?:\s*\[([^\]]*)\])?(?:\s*\{([^}]*)\})?\s*$/;
  const closeRule = /^\s*(:{3,})\s*$/;

  for (const line of lines) {
    const fenceMatch = line.match(/^\s*(`{3,}|~{3,})/);
    if (fenceMatch) {
      const fence = fenceMatch[1];
      if (!codeFence) {
        codeFence = fence;
      } else if (codeFence === fence) {
        codeFence = null;
      }
      stack[stack.length - 1].children.push({ type: 'text', value: line });
      continue;
    }

    if (codeFence) {
      stack[stack.length - 1].children.push({ type: 'text', value: line });
      continue;
    }

    const openMatch = line.match(openRule);
    if (openMatch) {
      const level = openMatch[1].length;
      const blockType = openMatch[2].toLowerCase();
      const title = openMatch[3] || '';
      const opt = openMatch[4] || '';
      const node = { type: 'block', level, blockType, title, opt, children: [] };
      stack[stack.length - 1].children.push(node);
      stack.push(node);
      continue;
    }

    const closeMatch = line.match(closeRule);
    if (closeMatch) {
      const level = closeMatch[1].length;
      if (stack.length > 1 && stack[stack.length - 1].level === level) {
        stack.pop();
        continue;
      }
    }

    stack[stack.length - 1].children.push({ type: 'text', value: line });
  }

  return renderNode(root);
}

function renderNode(node) {
  if (node.type === 'root') {
    return node.children.map(renderNode).join('\n');
  }
  if (node.type === 'text') {
    return node.value;
  }
  if (node.type === 'block') {
    const inner = node.children.map(renderNode).join('\n');
    const customHtml = renderCustomBlock(node.blockType, node.title, node.opt, inner);
    if (customHtml !== null) {
      return customHtml;
    }
    const start = `${':'.repeat(node.level)}${node.blockType}${node.title ? `[${node.title}]` : ''}${node.opt ? `{${node.opt}}` : ''}`;
    const end = ':'.repeat(node.level);
    return `${start}\n${inner}\n${end}`;
  }
  return '';
}

hexo.extend.filter.register('before_post_render', data => {
  if (typeof data.content !== 'string') return data;
  hexo.log.debug('custom_marked before_post_render', data.source || data.path || data.title || 'unknown');
  data.content = parseCustomBlocks(data.content);
  return data;
});

:::info[为什么不用引入？]{open} 与前面引入的 Css 不同的是，任意主题的目录 ~/themes/···（主题名称）/scripts 功能都都一样，Hexo 解析时都会运行改此目录下的所有 Javascript 文件。 :::

:::error[可能的错误] 一不小心放到了 ~/themes/anzhiyu/source/js/custom_marked.js 里。~~唐~~ :::

完结

hexo new "plugin-test"
hexo cl&&hexo g&&hexo s

赶紧在文章里尝试并体验一下吧！是不是很好用？如果有什么建议，可以在评论区告诉我哦！

笔记——树形动态规划

Sun, 07 Jun 2026 17:45:33 GMT

:::info{open} 设计状态：用 $dp_{u,0/1}$ 表示以 $u$ 为根的子树的最大快乐指数。

答案：$\max{dp_{root,1},dp_{root,0}}$。 :::

P1352 没有上司的舞会

若如图所示，当前 dfs 至点 $u$，则转移方程如下： $$dp_{u,0}\leftarrow dp_{u,0}+\max(dp_{v,0},dp_{v,1})$$ $$dp_{u,1}\leftarrow dp_{u,1}+dp_{v,0}$$

所以可以写出以下代码：

#include<bits/stdc++.h>
using namespace std;
int n,r[6005],in[6005],rt,dp[6005][2];
vector<int>g[6005];
void dfs(int u){
    for(int v:g[u]){
        dfs(v);
        dp[u][0]+=max(dp[v][0],dp[v][1]);
        dp[u][1]+=dp[v][0];
    }
    dp[u][1]+=r[u];
}
int main(){
    cin>>n;
    for(int i=1;i<=n;++i){
        cin>>r[i];
    }
    for(int i=1;i<n;++i){
        int u,v;
        cin>>u>>v;
        g[v].push_back(u);
        in[u]=1;
    }
    for(int i=1;i<=n;++i){
        if(!in[i]){
            rt=i;
            break;
        }
    }
    dfs(rt);
    cout<<max(dp[rt][0],dp[rt][1];
}

P2016 [SEERC 2000] 战略游戏

在开始是初始化一下 $dp_{u,0/1}$ 即可。 :::error[为什么不需要初始化 $dp$ 为无穷大]{open} 在 dfs 中会遍历每个子节点，所以初始化子节点即可，树形 DP 无需 memset $dp$ 数组。 :::

#include<bits/stdc++.h>
using namespace std;
int n,in[5005],dp[5005][2],rt;
vector<int>g[5005];
void dfs(int u){
    dp[u][0]=0;
    dp[u][1]=1;
    for(int v:g[u]){
        dfs(v);
        dp[u][0]+=dp[v][1];
        dp[u][1]+=min(dp[v][0],dp[v][1]);
    }
}
int main(){
    cin>>n;
    for(int i=1;i<=n;++i){
        int u,k,v;
        cin>>u>>k;
        u++;
        for(int j=1;j<=k;++j){
            cin>>v;
            v++;
            g[u].push_back(v);
            in[v]=1;
        }
    }
    for(int i=1;i<=n;++i){
        if(!in[i]){
            rt=i;
            break;
        }
    }
    dfs(rt);
    cout<<min(dp[rt][0],dp[rt][1]);
    return 0;
}

P1122 最大子树和

#include<bits/stdc++.h>
using namespace std;
int n,a[16005],dp[16005],ans=INT_MIN;
vector<int>g[16005];
void dfs(int u,int fa){
    dp[u]=a[u];
    for(int v:g[u]){
        if(v!=fa){
            dfs(v,u);
            dp[u]+=max(0,dp[v]);
        }
    }
}
int main(){
    cin>>n;
    for(int i=1;i<=n;++i)cin>>a[i];
    for(int i=1;i<n;++i){
        int u,v;
        cin>>u>>v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    dfs(1,0);
    for(int i=1;i<=n;++i){
        ans=max(dp[i],ans);
    }
    cout<<ans;
    return 0;
}

P2585 [ZJOI2006] 三色二叉树

题解：AT_pakencamp_2020_day1_d 立方体を壊せ！

Sat, 06 Jun 2026 19:35:33 GMT

问题分析

题目要求计算边长为 $N$ 的立方体被平面 $x+y+z=K$ 切割后，包含原点 $(0,0,0)$ 的部分体积的 6 倍是多少。
立方体的范围为 $0 \le x,y,z \le N$，平面 $x+y+z=K$ 将空间分为两部分，并且包含原点的部分满足 $x+y+z \le K$。

核心思路

根据 $K$ 与立方体的位置关系，平面切割立方体的效果不同，需分类讨论：

平面在立方体外部（$K \le 0$）：如图 1 ，此时 $x+y+z \le K$ 不包含立方体任何部分，$V_立=0$。
$\tiny\color{000000}图 1$
平面切割出小四面体（$0<K \le N$）：如图 2-1 , 平面与立方体相交形成以原点为顶点的四面体，如图 2-2 ，体积可直接用 $V_四$ 公式计算。

$$\tiny\color{000000}图 2-1$$ $$\tiny\color{000000}图 2-2$$
平面切割立方体中部（$N<K \le 2N$）：如图 3 ，平面与立方体的三个面相交，形成复杂区域，需通过几何分解推导体积公式。
$$\tiny\color{000000}图 3$$
平面靠近立方体对角顶点（$2N<K \le 3N$）：如图 4 ，平面切割后形成以原点为顶点的七面体，$V_七=V_立-V_四$。
$$\tiny\color{000000}图 4$$
平面完全在立方体外部（$K > 3N$）：如图 5 ，整个立方体都满足 $x+y+z \le K$，$V_立=$ 立方体体积公式。
$$\tiny\color{000000}图 5$$

公式推导

当 $K \le 0$
此时 $x+y+z \le K$ 无立方体部分，6 倍体积为：

$6 \times 0=0$
当 $0<K \le N$
平面切割出的区域是顶点为 $(0,0,0)、(K,0,0)、(0,K,0)、(0,0,K)$ 的四面体。四面体体积公式为 $V_四=\frac{1}{6}K^3$，因此 6 倍体积为：

$K^3$
当 $N < K \leq 2N$
平面与立方体的三个面相交，需通过积分或几何分解计算。推导得 6 倍体积公式：

$3K^2N - 3KN^2 + N^3 - 2(K - N)^3$
当 $2N < K \le 3N$
包含原点的部分是整个立方体减去一个小四面体（顶点为 $(N,N,N)$，边长为 $3N - K$）。
立方体 6 倍体积为 $6N^3$，小四面体 6 倍体积为 $(3N - K)^3$，因此结果为：

$6N^3 - (3N - K)^3$
当 $K > 3N$
整个立方体都满足 $x + y + z \le K$，6 倍体积为立方体体积的 6 倍：

$6N^3$

代码实现

根据上述推导，分情况计算结果：

#include<bits/stdc++.h>
using namespace std;
long long n,k,res;
int main(){
    cin>>n>>k;
    if(k==0){
        res=0;
    }else if(k<=n){
        res=k*k*k;
    }else if(k<=2*n){
        res=3*k*k*n-3*k*n*n+n*n*n-2*(k-n)*(k-n)*(k-n);
    }else if(k<=3*n){
        res=6*n*n*n-(3*n-k)*(3*n-k)*(3*n-k);
    }else{
        res=6*n*n*n;
    }
    cout<<res<<endl;
    return 0;
}

题解：P13361 [GCJ 2011 Qualification] Bot Trust

Sat, 06 Jun 2026 19:31:53 GMT

本题解被打回无法重新提交嘤嘤嘤

题意理解

形式化翻译

题目翻译有点难懂（~~其实是本蒟蒻懒得看~~），让本蒟蒻来形式化一下：

对于每组测试用例，有 $n$ 个执行任务的机器人和对应的按钮， $2$ 个机器人需依次按下自己对应的按钮，求计算 $2$ 个机器人按完按钮所需的最少时间。

注意事项

必须严格按照给定顺序操作，后一个按钮的操作必须在前一个完成后才能开始。
机器人可同时移动但不能同时执行按键操作。

解题思路

状态跟踪

需使用记录两个机器人的当前位置 $poso$ 和 $posb$ （ $poso$ 对应Orange， $posb$ 对应Blue）和各自上次操作完成的时间 $timeo$ 和 $timeb$ ，以及整个流程的总时间 $s$ 。
对于每组测试用例，千万不要忘记对 $poso$ 、 $posb$ 、 $timeo$ 和 $timeb$ 进行初始化！

操作逻辑

对每个命令，先确定执行的机器人（判断输入为O或B）。
计算从到达目标位置的时间 $|a_i-poso/posb| \times1$ 。
确定实际完成时间：取到达时间和当前总时间的最大值（保证顺序性），再加 $1$ 秒按键时间，用公式表达即为：

$$ntime \leftarrow \max{timeo+|a_i-poso/posb|,s}$$
更新机器人位置、对应完成时间和总时间。

代码实现

#include<bits/stdc++.h>
using namespace std;
// 存储每个命令的结构体：机器人类型和目标位置
struct Command{
    char robot; 
    int pos;
}a[100]; 
int t,n,poso,posb,timeo,timeb,s,p,ntime;
char c;

// 初始化函数：重置机器人初始状态
void init(){
    poso=1;  // 初始位置均为1
    posb=1;
    timeo=0;  // 初始时间为0
    timeb=0;
    s=0;  // 总时间初始为0
}

int main(){
    cin>>t;
    for (int k=1;k<=t;k++) {
        cin>>n;
        for (int i= 0;i<n;i++) {
            cin>>a[i].robot>>a[i].pos;
        }
        init();  // 初始化状态
        for(int i=0;i<n;++i){
            //核心：顺序按下每个按钮
            c=a[i].robot;  // 当前命令的机器人
            p=a[i].pos;    // 当前命令的目标位置
            if(c=='O'){  // Orange机器人操作
                // 计算完成时间：到达时间与总时间取最大后+1秒按键
                ntime=max(timeo+abs(p-poso),s)+1;
                poso=p;  // 更新位置
                timeo=s=ntime;  // 更新时间
            }else{  // Blue机器人操作
                ntime=max(timeb+abs(p-posb),s)+1;
                posb=p;  //同上
                timeb=s=ntime;
            }
        }
        // 格式化输出结果
        cout<<"Case #"<<k<<": "<<s<<endl;
    }
    return 0;
}

复杂度分析

时间复杂度： $O(n)$ ，其中 $n$ 为命令数量，只需遍历一次所有命令。
空间复杂度： $O(n)$ ，用于存储命令数组（可优化为 $O(1)$ ，边读边处理）。

闲话

~~真是一道水题！~~
提交后，那只有两个的测试点和 20pts 着实让我大跌眼镜。
本蒟蒻的第一篇题解，看了许多大佬的题解学习格式，花了一下午完成，望管理员大大通过。

题解：P8534 「Wdoi-2」比赤色更红的梦

Sat, 06 Jun 2026 19:26:35 GMT

题目传送门

题意分析

核心：对于每组数据，判断 $x$ 是否 $\ge 3$ 或 $\ge 5$ 并对应地将残机 $+1$，判断 $s$ 是否 $\ge 10000000$、$\ge 20000000$、$\ge 40000000$ 或 $\ge 60000000$ 并对应地将残机 $+1$。

思路引导

:::warning[提问] 如何处理多组数据？ :::

:::success[成功] 使用 while 循环语句，每次将 $t-1$，因为 $t=0$ 时布尔值为 $0$, 即 false，所以将会跳出循环，此时循环语句正好执行 $t$ 次。格式如下：

while(t--/*布尔表达式*/){
  //执行____
}

:::

:::warning[提问] 如何对 $x$ 和 $s$ 的值进行判断？ :::

:::success[成功] 使用 if 分支语句，格式如下：

//普通版：
if(/*布尔表达式*/){
	//执行____
}
//压行版：
if(/*布尔表达式*/)//执行____（限一句）

:::

:::error[警示]{open}

如果你将 $s$ 开 int ，那么你将喜提 $\color{E74C3C}{\text{WA}}$，$\color{E74C3C}{\text{25pts}}$。请注意观察数据范围！
~~别问我是怎么知道的~~
别忘了每次将 $ans$ 初始化为 $2$。 :::

核心代码

只提供 while 循环语句内的代码。

ans=2;
cin>>x>>s;
if(x>=3)ans++;
if(x>=5)ans++;
if(s>=10000000)ans++;
if(s>=20000000)ans++;
if(s>=40000000)ans++;
if(s>=60000000)ans++;
cout<<ans<<endl;
//code by _ruyingsuixing_(UID:1620655)

| 1 | 1 | |-|-| | 1 | < | | 1 | 1 |

AC 自动机笔记

Sat, 06 Jun 2026 19:22:35 GMT

模板代码（P3808 AC 自动机（简单版））

#include<bits/stdc++.h>
using namespace std;
int n,tot,cnt[1000005],ch[1000005][30],ne[1000005];
void insert(string s){
	int u=0;
	for(char c:s){
		int v=c-'a';
		if(!ch[u][v])ch[u][v]=++tot;
		u=ch[u][v];
	}
	cnt[u]++;
}
void build(){
	queue<int>q;
	for(int i=0;i<26;++i){
		if(ch[0][i])q.push(ch[0][i]);
	}
	while(!q.empty()){
		int u=q.front();
		q.pop();
		for(int i=0;i<26;++i){
			int v=ch[u][i];
			if(v)ne[v]=ch[ne[u]][i],q.push(v);
			else ch[u][i]=ch[ne[u]][i];
		}
	}
}
int query(string s){
	int ans=0;
	for(int k=0,i=0;s[k];k++){
		i=ch[i][s[k]-'a'];
		for(int j=i;j&&~cnt[j];j=ne[j]){
			ans+=cnt[j],cnt[j]=-1;
		}
	}
	return ans;
}
string t;
int main(){
	cin>>n;
	for(int i=1;i<=n;++i){
		string s;
		cin>>s;
		insert(s);
	}
	cin>>t;
	build();
	cout<<query(t);
	return 0;
}

网络流笔记

Sat, 06 Jun 2026 18:57:34 GMT

增广路

ek 模板：

#include<bits/stdc++.h>
using ll=long long;
using namespace std;
const int N=205,M=5005;
int n,m,s,t,cnt=1,head[N],pre[N],mf[N];
/*
mf：当前增广路可通过水流
*/
struct edge{
	int nxt,to,w;
}e[2*M];
void add(int u,int v,int w){
	e[++cnt].w=w;
	e[cnt].to=v;
	e[cnt].nxt=head[u];
	head[u]=cnt;
}
bool bfs(){
	memset(mf,0,sizeof mf);
	queue<int>q;
	q.push(s);
	mf[s]=1e9;
	while(!q.empty()){
		int u=q.front();
		q.pop();
		for(int i=head[u];i;i=e[i].nxt){
			int v=e[i].to;
			if(mf[v]==0&&e[i].w){
				mf[v]=min(mf[u],e[i].w);
				pre[v]=i;
				q.push(v);
				if(v==t)return 1;
			}
		}
	}
	return 0;
}
ll ek(){
	ll fl=0;
	while(bfs()){
		int v=t;
		while(v!=s){
			int i=pre[v];
			e[i].w-=mf[t];
			e[i^1].w+=mf[t];
			v=e[i^1].to;
		}
		fl+=mf[t];
	}
	return fl;
}
int main(){
	cin>>n>>m>>s>>t;
	for(int i=1;i<=m;++i){
		int u,v,w;
		cin>>u>>v>>w;
		add(u,v,w);
		add(v,u,0);
	}
	cout<<ek();
	return 0;
}

Dinic 模板：

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int M=5005;
int n,m,s,t,head[M],tot=1,d[M],cur[M];
struct edge{
	int v,nxt;
	ll flow;
}e[2*M];
void add(int u,int v,int w){
	e[++tot]={v,head[u],w},head[u]=tot;
}
bool bfs(){
	memset(d,0,sizeof d);
	memcpy(cur,head,sizeof head);
	queue<int>q;
	q.push(s);
	d[s]=1;
	while(!q.empty()){
		int u=q.front();
		q.pop();
		for(int i=head[u];~i;i=e[i].nxt){
			int v=e[i].v;
			if(!d[v]&&e[i].flow){
				d[v]=d[u]+1;
				if(v==t)return true;
				q.push(v);
			}
		}
	}
	return false;
}
ll dfs(int u,ll flow){
	if(u==t||!flow)return flow;
	ll rest=flow;
	for(int &i=cur[u];~i;i=e[i].nxt){
		int v=e[i].v;
		if(d[v]==d[u]+1&&e[i].flow){
			ll k=dfs(v,min(rest,e[i].flow));
			if(!k)d[v]=0;
			e[i].flow-=k,e[i^1].flow+=k;
			if(!(rest-=k))break;
		}
	}
	return flow-rest;
}
ll dinic(){
	ll maxflow=0;
	while(bfs())maxflow+=dfs(s,INT_MAX);
	return maxflow;
}
int main(){
	memset(head, -1, sizeof(head));
	cin>>n>>m>>s>>t;
	for(int i=1;i<=m;++i){
		int u,v,w;
		cin>>u>>v>>w;
		add(u,v,w),add(v,u,0);
	}
	cout<<dinic();
	return 0;
}

OI wiki
problems 1 & problems 2

:::warning[请注意]{open} 本文章使用了 AI 辅助编写，请谨慎鉴别。 :::

Part. 1 网络流的定义

1.1 流网络

一个流网络是一个四元组 $N=(G,c,s,t)$，其中：

$G=(V,E)$ 是一个无自环有向图。
$c:E\mapsto[0,+\infty)$ 是容量函数，$c(u,v)\geqslant0$。
$s\in V$ 是源点，$t\in V$ 是汇点，$s\ne t$。

1.2 流

一个流是函数 $f:E\to\mathbb{R}_{\geqslant0}$，满足：

(1) 容量约束：对每条边 $(u,v)\in E$， $$0\leqslant f(u,v)\leqslant c(u,v)$$

(2) 流量守恒：对每个节点 $u\in V\setminus{s,t}$， $$\sum_{v:(v,u)\in E} f(v,u) = \sum_{v:(u,v)\in E} f(u,v)$$ 即，流入量等于流出量。

1.4 净流量函数与流的值

对任意节点 $u\in V$，定义净流量： $$\text{net}f(u) = \sum{v:(u,v)\in E} f(u,v) - \sum_{v:(v,u)\in E} f(v,u)$$

于是：

对 $u\in V\setminus{s,t}$：$\text{net}_f(u)=0$（流量守恒）。
对源点：$\text{net}_f(s)=\left\lvert f\right\rvert$。
对汇点：$\text{net}_f(t)=-\left\lvert f\right\rvert$。

注：在标准建模中，通常没有边指向源点，此时第二项为 $0$。

Part. 2 割的定义

设 $S\sub V$ 满足 $s\in S$ 且 $t\notin S$。令 $T=V\setminus S$。

割是指集合对 $(S,T)$。

割的容量定义为： $$c(S,T) = \sum_{\substack{(u,v)\in E \ u\in S,,v\in T}} c(u,v)$$

即从 $S$ 指向 $T$ 的边的容量之和。

最小割是指容量最小的割。

Part.3 最大流最小割定理

定理：对任意流网络，最大流的值等于最小割的容量： $$\max\left\lvert f\right\rvert = \min_{S: s\in S,,t\notin S} c(S,T)$$

::::info[证明]

$1\degree$ 弱对偶性（流 $\leqslant$ 割）

引理 1：对任意可行流 $f$ 和任意 $s{-}t$ 割 $(S,T)$，有 $\left\lvert f\right\rvert \leqslant c(S,T)$。

:::info[证明]

首先，可将 $\left\lvert f\right\rvert$ 写成 $S$ 中所有节点的净流量之和： $$\left\lvert f\right\rvert = \sum_{u\in S} \text{net}_f(u)$$

将净流量展开： $$\begin{aligned} \left\lvert f\right\rvert &= \sum_{u\in S} \left( \sum_{v:(u,v)\in E} f(u,v) - \sum_{v:(v,u)\in E} f(v,u) \right) \ &= \sum_{u\in S}\sum_{v:(u,v)\in E} f(u,v) - \sum_{u\in S}\sum_{v:(v,u)\in E} f(v,u) \end{aligned}$$

交换求和顺序。第一项中，$(u,v)$ 的起点 $u$ 在 $S$ 中；第二项中，$(v,u)$ 的终点 $u$ 在 $S$ 中，等价于起点 $v$ 可以属于 $S$ 或 $T$。将第二项按起点分类：

$$ \left\lvert f\right\rvert = \sum_{u\in S,,v\in V} f(u,v) - \sum_{v\in V,,u\in S} f(v,u) $$

将 $V$ 拆成 $S$ 和 $T$：

$$\left\lvert f\right\rvert = \cancel{\sum_{u\in S,,v\in S} f(u,v)} + \sum_{u\in S,,v\in T} f(u,v) - \cancel{\sum_{v\in S,,u\in S} f(v,u)} - \sum_{v\in T,,u\in S} f(v,u) = \sum_{u\in S,,v\in T} f(u,v) - \sum_{v\in T,,u\in S} f(v,u)$$

第一项是从 $S$ 到 $T$ 的边的流量之和，第二项是从 $T$ 到 $S$ 的边的流量之和。由于流量非负，第二项 $\geqslant 0$，因此：

$$\left\lvert f\right\rvert \leqslant \sum_{u\in S,,v\in T} f(u,v)$$

再由容量约束 $f(u,v) \leqslant c(u,v)$，得：

$$\left\lvert f\right\rvert \leqslant \sum_{u\in S,,v\in T} c(u,v) = c(S,T)$$

证毕！ :::

故，推论：最大流 $\leqslant$ 最小割。

$2\degree$ 强对偶性（$\exist$ 流 $=$ 某个割）

引理2：设 $f$ 是最大流，定义 $S$ 为残量网络中从 $s$ 出发可达的节点集合。则 $(S,T)$ 是一个割，且 $\left\lvert f\right\rvert = c(S,T)$。

:::info[残量网络定义]{open} 对原图每条边 $(u,v)$，在残量网络中保留两条有向边：

正向残量边：容量为 $c(u,v)-f(u,v)$（还可增加流量）
反向残量边：容量为 $f(u,v)$（还可减少流量） :::

:::info[证明]

先证明 $t\notin S$。

反证法。假设 $t\in S$，则 $\exist$ 一条从 $s$ 到 $t$ 的残量路径。沿着这条路径，我们可以增加一个正数 $\delta$ 的流量（取路径上 $\min$ 残量），从而得到更大的流，与 $f$ 是最大流矛盾。因此 $t\notin S$，故 $(S,T)$ 是 $s{-}t$ 割。

再证明 $\forall,u\in S,\ v\in T$，原边 $(u,v)$ 必然饱和。

依旧反证法。若 $\exist,u\in S$，$v\in T$ 使得 $f(u,v) < c(u,v)$，则正向残量 $c(u,v)-f(u,v) > 0$，意味着残量网络中有一条从 $u$ 到 $v$ 的边。由于 $u\in S$（从 $s$ 可达），那么 $v$ 也可达，从而 $v\in S$，与 $v\in T$ 矛盾。因此 $f(u,v)=c(u,v)$。

接着证明 $\forall,u\in T$，$v\in S$，原边 $(u,v)$ 必然无流量。

还是反证法。若存在 $u\in T$，$v\in S$ 使得 $f(u,v) > 0$，则反向残量 $f(u,v) > 0$，意味着残量网络中有一条从 $v$ 到 $u$ 的边。由于 $v\in S$（从 $s$ 可达），那么 $u$ 也可达，从而 $u\in S$，与 $u\in T$ 矛盾。因此 $f(u,v)=0$。

最后计算 $\left\lvert f\right\rvert$。

由弱对偶性证明中的等式： $$\left\lvert f\right\rvert = \sum_{u\in S,,v\in T} f(u,v) - \sum_{v\in T,,u\in S} f(v,u)$$

由“再证明”的结论，第一项中 $f(u,v)=c(u,v)$；由“接着证明”的结论，第二项中 $f(v,u)=0$。因此： $$\left\lvert f\right\rvert = \sum_{u\in S,,v\in T} c(u,v) = c(S,T)$$

这就找到了一个割，其容量等于 $\left\lvert f\right\rvert$。证毕！ :::

综上，证毕！ ::::

Part. 4 增广路定理

定理：一个可行流 $f$ 是最大流当且仅当残量网络 $G_f$ 中不存在 $s$ 到 $t$ 的路径（称为增广路）。

:::info[证明] （$\Rightarrow$）若存在增广路 $P$，设 $\delta = \min{r(u,v): (u,v)\in P} > 0$。沿 $P$ 增加 $\delta$ 流量：

对正向残量边：$f(u,v) \leftarrow f(u,v) + \delta$
对反向残量边：$f(v,u) \leftarrow f(v,u) - \delta$

得到的新流仍满足容量约束，且 $|f'| = \left\lvert f\right\rvert + \delta > \left\lvert f\right\rvert$，故 $f$ 不是最大流。逆否命题成立。

（$\Leftarrow$）若无增广路，定义 $S$ 为 $s$ 在 $G_f$ 中可达的节点集，则 $t\notin S$。由 Part.3 “再证明”的证明过程，$\left\lvert f\right\rvert = c(S,T)$，再由弱对偶性知 $f$ 是最大流。证毕！ :::

Part.5 Dinic 算法的分层图引理

定义：在残量网络中，定义 $d(u)$ 为从 $s$ 到 $u$ 的最短边数（BFS 距离）。边 $(u,v)$ 称为允许边若 $d(v) = d(u) + 1$ 且残量 $>0$。所有允许边构成分层图 $L_f$。阻塞流是指在 $L_f$ 中无法再找到增广路的流。

引理：记 $d_k(t)$ 为第 $k$ 次阻塞流增广后 $t$ 的距离。则 $d_{k+1}(t) > d_k(t)$。

:::info[证明] 设 $f$ 是当前流，$f'$ 是增广一次阻塞流后得到的新流。考虑 $G_{f'}$ 中 $s$ 到 $t$ 的最短路径 $P$。若 $P$ 中存在一条边 $(u,v)$ 在 $G_f$ 中不存在（即由增广操作新产生的反向边），则 $f(v,u) > 0$，这意味着在 $G_f$ 中 $u$ 到 $v$ 有容量 $>0$ 的边。由 $P$ 的最短性可推出矛盾。因此 $P$ 中的所有边都在 $G_f$ 中存在，但阻塞流增广后，至少有一条 $G_f$ 中的最短路径上的边被饱和，故 $P$ 的长度必然大于 $d_k(t)$。证毕！ :::

推论：Dinic 算法中 BFS 的次数不超过 $\lvert V\rvert$，故总复杂度 $O(\lvert V\rvert^2\lvert E\rvert)$。

Part.6 Dinic 算法实践

当前弧优化

代码中的 cur[] 实现了当前弧优化。其原理是：在 DFS 过程中，若某条边已被尝试且无法推送更多流量，则同一轮 BFS 分层中无需再次尝试，直接从下一条边开始。

代码

struct Edge { int to, weight, nxt; } edges[MAXM << 1];
int head[MAXN], ecnt = 2, n, m;
void addedge(int u, int v, int weight) {
    edges[ecnt] = Edge{v, weight, head[u]};
    head[u] = ecnt++;
}

int dep[MAXN], cur[MAXN], s, t;
bool bfs() {
    clean(dep);
    queue < int > q;
    dep[s] = 1;
    q.psh(s);
    while (q.size()) {
        int u = q.front(); q.pop();
        for (int i = head[u]; i; i = edges[i].nxt) {
            int v = edges[i].to;
            if (!dep[v] && edges[i].weight) {
                dep[v] = dep[u] + 1; q.psh(v);
                if (v == t) return true;
            }
        }
    }
    return false;
}

int dfs(int u, int flow) {
    if (u == t) return flow;
    int used = 0;
    for (int &i = cur[u]; i; i = edges[i].nxt) {
        int v = edges[i].to;
        if (dep[v] == dep[u] + 1 && edges[i].weight) {
            int res = dfs(v, min(flow - used, edges[i].weight));
            if (res) {
                edges[i].weight -= res;
                edges[i ^ 1].weight += res;
                used += res;
            }
            if (used == flow) break;
        }
    }
    return used;
}

int dinic() {
    int mf = 0;
    while (bfs()) {
        memcpy(cur, head, sizeof cur);
        while (int res = dfs(s, inf)) mf += res;
    }
    return mf;
}

Part.7 HLPP（最高标号预流推进）算法

7.1 算法思想和基本概念

HLPP（Highest-Label Preflow Push）与 Dinic 等增广路算法不同，采用预流推进的思路：

不保持流量守恒：允许节点暂时存储超额流。
高度函数：给每个节点一个高度，流只能从高处向低处推送。
最高标号优先：每次选择高度最高的活跃节点处理。

定义超额流 $e(u)$： $$e(u) = \sum_{v} f(v,u) - \sum_{v} f(u,v)$$

当 $e(u) > 0$ 时，$u$ 称为活跃节点
源点 $s$ 和汇点 $t$ 除外

定义高度函数 $h(u)$：

流只能从高向低推：$h(u) = h(v) + 1$
初始高度：从 $t$ 反向 BFS 得到，$h(t)=0$，$h(s)=n$

7.2 核心操作

推流：当 $e(u) > 0$ 且存在边 $(u,v)$ 满足 $r(u,v) > 0$ 且 $h(u) = h(v) + 1$ 时，推送流量： $$\delta = \min(e(u), r(u,v))$$

重贴标签：当 $e(u) > 0$ 但无可推流的邻居时，更新高度： $$h(u) = \min{h(v) + 1 \mid r(u,v) > 0}$$

7.4 核心优化

最高标号优先：使用优先队列或桶维护活跃节点，每次取高度最大的处理。
GAP 优化：若某个高度 $k$ 的节点数为 0，则所有高度 $>k$ 的节点无法到达 $t$，直接将其高度设为 $n+1$。
当前弧优化：与 Dinic 相同，避免重复遍历已饱和的边。

7.5 算法流程

HLPP(s, t):
    1. 反向 BFS 初始化高度 h，h[s] = n
    2. 从 s 饱和推流，将活跃节点入桶
    3. while mxh >= 0:
         u = 桶中最高高度的节点
         for 当前弧遍历出边:
             if 边有残量 and h[u] == h[v] + 1:
                 push(u, v)
                 if e[u] == 0: break
         if e[u] > 0:
             relabel(u)
    4. return e[t]

7.6 代码实现

struct Edge { int to, nxt, cap; } edges[MAXM];
int head[MAXN], ecnt = 2, n, m;
void addedge(int u, int v, int cap) {
    edges[ecnt] = {v, head[u], cap}, head[u] = ecnt++;
    edges[ecnt] = {u, head[v], 0}, head[v] = ecnt++;
}

int h[MAXN], eflow[MAXN], cur[MAXN], gap[MAXN << 1], mxh, s, t;
vi bucket[MAXN << 1];
bool inq[MAXN];

void bfs() {
    memset(h, 0x3f, sizeof h);
    static int q[MAXN], qh, qt;
    h[t] = 0, q[qt = 0] = t, qh = 0, ++qt;
    while (qh < qt) {
        int u = q[qh++];
        for (int i = head[u]; i; i = edges[i].nxt) {
            int v = edges[i].to;
            if (edges[i ^ 1].cap && h[v] > h[u] + 1)
                h[v] = h[u] + 1,
                q[qt++] = v;
        }
    }
    h[s] = n;
}

void push(int u) {
    for (int &i = cur[u]; i; i = edges[i].nxt) {
        int v = edges[i].to;
        if (edges[i].cap && h[u] == h[v] + 1) {
            int delta = min(eflow[u], edges[i].cap);
            if (!delta) continue;
            edges[i].cap -= delta, edges[i ^ 1].cap += delta;
            eflow[u] -= delta, eflow[v] += delta;
            if (v != s && v != t && !inq[v] && eflow[v])
                inq[v] = true,
                bucket[h[v]].pb(v),
                mxh = max(mxh, h[v]);
            if (!eflow[u]) break;
        }
    }
}

void relabel(int u) {
    int mnh = inf;
    for (int i = head[u]; i; i = edges[i].nxt)
        if (edges[i].cap) mnh = min(mnh, h[edges[i].to]);
    int nwh = mnh + 1;
    if (!(--gap[h[u]]) && h[u] < n) {
        up(i, 1, n) if (i != s && i != t && h[i] > h[u] && h[i] <= n) h[i] = n + 1;
        up(i, h[u] + 1, n) {
            for (int v : bucket[i]) inq[v] = false;
            bucket[i].clear();
            gap[n] += gap[i], gap[i] = 0;
        }
    }
    h[u] = nwh;
    if (nwh <= n)
        ++gap[nwh],
        bucket[nwh].pb(u),
        inq[u] = true,
        mxh = max(mxh, nwh);
    cur[u] = head[u];
}

int hlpp() {
    if (s == t) return 0;
    bfs(); clean(gap), clean(eflow), clean(inq);
    up(i, 1, n) {
        if (h[i] < n) ++gap[h[i]];
        else ++gap[n];
    }
    for (int i = head[s]; i; i = edges[i].nxt) {
        int v = edges[i].to, cap = edges[i].cap;
        if (cap) {
            edges[i].cap -= cap, edges[i ^ 1].cap += cap;
            eflow[s] -= cap, eflow[v] += cap;
            if (v != t && eflow[v] && !inq[v] && h[v] < n)
                inq[v] = true,
                bucket[h[v]].pb(v),
                mxh = max(mxh, h[v]);
        }
    }
    while (mxh >= 0) {
        while (mxh >= 0 && bucket[mxh].empty()) --mxh;
        if (mxh < 0) break;
        int u = bucket[mxh].back(); bucket[mxh].ppb(); inq[u] = false;
        if (!eflow[u]) continue;
        if (!cur[u]) cur[u] = head[u];
        push(u);
        if (eflow[u]) relabel(u);
    }
    return eflow[t];
}

Part.8 题目选讲 A

P3376 【模板】网络最大流 & P4722 【模板】最大流加强版 / 预流推进

模板题，代码见上。

P2740 [USACO4.2] 草地排水 Drainage Ditches

$$s=1,\ t=n$$

P2936 [USACO09JAN] Total Flow S

换成字符。

P1343 地震逃生

$ans=0$ 特判。

P3386 【模板】二分图最大匹配

构造：

虚拟一个 $s$，与左部所有点建边。
左右部建边。
虚拟一个 $t$，与右部所有点建边。

如图：

JC 提高班期末测试题解

Sat, 06 Jun 2026 18:52:35 GMT

T1 雪花图

题目描述

雪花图是由两个整数 $x$ 和 $y$（均大于 $1$）生成的，生成方式如下：

以一个中心顶点开始。
将 $x$ 个新顶点与该中心顶点相连。
对每一个这 $x$ 个顶点，各自连接 $y$ 个新顶点。

例如，下图是 $x=5$，$y=3$ 的雪花图。上图中的雪花图有一个中心顶点 $15$，然后有 $x=5$ 个顶点与其相连（$3$、$6$、$7$、$8$ 和 $20$），每个顶点又分别连接 $y=3$ 个顶点。

给定一个雪花图，请你求出 $x$ 和 $y$ 的值。

输入格式

第一行包含一个整数 $t$（$1 \leq t \leq 1000$），表示测试用例的数量。

每个测试用例的第一行包含两个整数 $n$ 和 $m$（$2 \leq n \leq 200$；$1 \leq m \leq \min\left(1000, \frac{n(n-1)}{2}\right)$），分别表示图中的顶点数和边数。

接下来的 $m$ 行，每行包含两个整数 $u$ 和 $v$（$1 \leq u, v \leq n$，$u \neq v$），表示一条连接顶点 $u$ 和 $v$ 的边。图中没有重边和自环。

保证给定的图一定是某组大于 $1$ 的整数 $x$ 和 $y$ 所对应的雪花图。

输出格式

对于每个测试用例，输出一行，包含两个整数 $x$ 和 $y$，用空格分隔，顺序不能颠倒。

输入输出样例 #1

输入 #1

输出 #1

5 3
2 2
2 3

说明/提示

第一个测试用例如题面所示。注意输出 $3\ 5$ 是错误的，因为 $x$ 应该在 $y$ 之前输出。

#include<bits/stdc++.h>
using namespace std;
int t,n,m,cnt[205],mx,ends1[205],u[1005],v[1005];
int check(int x){
	for(int i=1;i<=m;++i){
		if((u[i]==x&&ends1[v[i]]==1)||(v[i]==x&&ends1[u[i]]==1)){
			return 0;
		}
	}
	return 1;
}
int main(){
	cin>>t;
	while(t--){
		int x=0,y=0;
		cin>>n>>m;
		memset(ends1,0,sizeof ends1),memset(cnt,0,sizeof cnt),mx=0;
		for(int i=1;i<=m;++i){
			cin>>u[i]>>v[i];
			cnt[u[i]]++,cnt[v[i]]++;
			mx=max({u[i],v[i],mx});
		}
		for(int i=1;i<=mx;++i){
			if(cnt[i]==1){
				ends1[i]=1;
				y++;
			}
		}
		for(int j=1;j<=n;++j){
			if(ends1[j]!=1&&check(j)){
				x=cnt[j];
			}else if(ends1[j]!=1&&check(j)){
				x=cnt[j];
			}
		}
		cout<<x<<" "<<y/x<<endl;
	}
	return 0;
}

T2 字母对拼接谜题

故事背景

字母王国里流传着一个古老的拼接谜题：传说有一组散落的字母伙伴，每一对伙伴都有着密不可分的羁绊，它们必须紧紧相邻才能发挥魔力。现在，你作为字母王国的解谜者，需要将这些字母伙伴重新组合成一条完整的字母链，让每一对羁绊深厚的字母都能在链中相邻出现。这条字母链的长度恰好比字母对的数量多1，并且如果存在多种组合方式，请给出字典序最小的那一条——这是字母王国传承已久的规则，字典序越小，魔力越纯净。若是无法完成拼接，就只能遗憾地告知王国：无解。

题目描述

给定 n 个各不相同的无序字母对（区分大小写，无序意味着字母对中的两个字母可以交换位置相邻，例如“aZ”与“Za”视为满足相邻要求）。请你构造一个包含 (n+1) 个字母的字符串，使得每个给定的字母对都能在这个字符串中相邻出现。

输入格式

第一行输入一个正整数 n，代表无序字母对的数量。

第二行到第 (n+1) 行，每行输入两个字母，代表一对需要相邻的字母。

输出格式

输出满足要求的字符串。

如果不存在满足要求的字符串，请输出 No Solution。

如果存在多种满足要求的方案，请输出字典序最小的方案（即字符串中前面的字母，其 ASCII 编码尽可能小）。

输入输出样例 #1

输入 #1

4
aZ
tZ
Xt
aX

输出 #1

XaZtX

说明/提示

n 的规模限制如下：

$25%$ 的测试数据中，$n = 2$；
$50%$ 的测试数据中，$n ≤ 10$；
$75%$ 的测试数据中，$n ≤ 100$；
$100%$ 的测试数据中，$n ≤ 600$。

T3 广义斐波那契图

题目描述

给定一个包含 $n$ 个顶点和 $m$ 条边的有向图。每个顶点 $v$ 上对应一个正整数 $a_v$。请你统计所有由至少两个顶点组成的不同简单路径，使得沿路径经过顶点的数字序列构成一个广义斐波那契数列。

在本题中，若数列 $x_0, x_1, \ldots, x_k$ 满足以下条件，则称其为广义斐波那契数列：

$x_0, x_1$ 为任意自然数。
对所有 $2 \le i \le k$，都有 $x_i = x_{i-2} + x_{i-1}$。

注意，广义斐波那契数列至少包含两个数字。

由于答案可能很大，输出其对 $998,244,353$ 取模的结果。

一个简单路径指在有向图中按顺序经过顶点 $v_1, v_2, \ldots, v_k$，且所有顶点至多出现一次，并且对于所有 $i < k$，存在从 $v_i$ 到 $v_{i+1}$ 的有向边。

输入格式

每个测试点包含若干组测试数据。第一行为测试数据组数 $t$（$1 \le t \le 10^4$）。每组测试数据包括：

第一行，两个整数 $n$ 和 $m$（$2 \le n \le 2 \cdot 10^5$，$1 \le m \le 2 \cdot 10^5$）——图中顶点数和边数。

第二行为 $n$ 个正整数 $a_1, a_2, \ldots, a_n$（$1 \le a_i \le 10^{18}$）——每个顶点上的数字。

接下来 $m$ 行，每行两个正整数 $v, u$（$1 \le v, u \le n$，$u \ne v$），表示一条从 $v$ 到 $u$ 的有向边。保证不存在重边。

保证所有测试数据中 $n$ 的总和与 $m$ 的总和不超过 $2 \times 10^5$。

输出格式

对于每组测试数据，输出广义斐波那契路径的数量，对 $998,244,353$ 取模。

输入输出样例 #1

输入 #1

4
4 4
3 4 3 6
1 2
1 3
2 4
3 4
4 6
1 1 1 2
1 2
2 3
3 1
1 4
2 4
3 4
8 11
2 4 2 6 8 10 18 26
1 2
2 3
3 1
4 3
2 4
3 5
5 6
4 6
6 7
7 5
5 8
2 2
10 10
1 2
2 1

输出 #1

说明/提示

第一个样例的解释（顶点编号在括号外，顶点上的数字在括号内）：

本例中共有 5 条广义斐波那契路径：(1, 2), (1, 3), (2, 4), (3, 4), (1, 3, 4)。例如，路径 (1, 3, 4) 沿途顶点上的数字序列为：[3, 3, 6]，可以看到第三个数字等于前两个数字之和。

第二个样例的解释：

本例中共有 9 条广义斐波那契路径：(1, 2), (1, 4), (2, 3), (2, 4), (3, 1), (3, 4), (1, 2, 4), (2, 3, 4), (3, 1, 4)。注意，路径 (1, 2, 3) 上的数字序列为：[1, 1, 1]，这不是广义斐波那契数列。

题解：P8506 标题计数

Sat, 06 Jun 2026 16:08:22 GMT

前言

本篇题解适合刚学字符串和模拟的同学阅读，语言浅显易懂。~~谁让作者是个蒟蒻呢。~~

题目分析

核心条件：

第一个非空格字符必须是井号 #。
井号后面必须紧跟着至少一个空格且不能有多个井号相连（如 ##）。
在井号后面的空格后必须有长度不为 $0$ 的句子。

思路引导

:::warning[提问] 如何输入一行含空格的字符串？ :::

:::success[成功] 使用 string 类型自带的 getline() 。 ::: :::success[提问] 如何判断字符串是否为一级标题？ :::

:::success[成功] 联系我们刚分析完的核心条件，可以进行模拟。具体如下：

首先，假设读入的字符串 $s$ 不是一级标题，$flag$ 为 false 。再将 $s$ 从头到尾扫一遍。
- 如果 $s_i$ 是空格，直接跳过。
- 否则如果 $flag$ 为 true ，说明已经满足核心条件中的 1、2 点，且现在 $s_i$ 不为空格，也满足第 3 点，计数器 $+1$。
- 否则如果 $s_i$ 是非 # 字符，$s$ 必定不是一级标题，跳出循环。
- 否则如果 $s_i$ 是 # 字符且满足核心条件中的 1、2 点，$flag$ 为 true 。
- 否则 $s$ 必定不是一级标题，跳出循环。 :::

完整代码

#include<bits/stdc++.h>
using namespace std;
int n,pos,cnt;  // cnt用于计数符合条件的标题
bool flag;      // 标记是否满足标题的前置条件
string s;
int main() {
	cin>>n;
	cin.ignore();  // 忽略n后面的换行符
	while(n--) {
		getline(cin,s);  // 读取一整行文本
		flag=false;      // 初始化标记
		for(int i=0; i<s.size(); ++i) {
			if(s[i]!=' ') {  // 遇到非空格字符
				if(flag){  // 如果已标记为满足前置条件
					cnt++;  // 计数加1
					break;  // 跳出循环，无需继续检查
				}
				if(s[i]!='#') {  // 非#字符，不是标题
					break;
				}
				// 检查是否为单个#且后面跟着空格
				if(s[i]=='#'&&(i==0||s[i-1]!='#')&&s[i+1]==' '&&i+1<s.size()) {
					pos=i+1;
					flag=true;  // 标记为满足前置条件
				}
				if(!flag){  // 如果不满足前置条件
					break;    // 跳出循环
				}
			}
		}
	}
	cout<<cnt;  // 输出结果
	return 0;
}

拯救谷歌和 Github！你的新“自行车”

Thu, 14 May 2026 19:02:20 GMT

还在为谷歌无法访问而发愁吗？这个宝藏项目一定要收藏好😍！顺便还能秒开 Github！

快速安装

打开 Release，找到最新版本，安装包选择方式：

Windows：DevSidecar-x.x.x-windows-universal.exe
Mac: DevSidecar-x.x.x-macos-universal.dmg
Linux:
- Debian 系等支持 Deb 的：DevSidecar-x.x.x-linux-<架构>.deb
- 其他：DevSidecar-x.x.x-linux-<架构>.AppImage

安装可能有点慢，建议以下 4 选 1 加速安装（我的是 2.0.2 Windows 版本，具体链接为 https://gh-proxy.org/+Github 原始链接）：

Vercel 仅部署指定分支的方法

Tue, 12 May 2026 20:55:55 GMT

如何指定特殊分支

从仪表板中选择的项目
在侧边栏中打开 Settings。
点击 Environments。
点击 Production 环境（/settings/environments/production）。

{% tip cogs %}这样配置之后，Vercel 仍然会在任一分支更改时自动构建，结果当然是 {% label Error red %} 了！怎么办呢？{% endtip %}

使用分支跟踪（推荐）

最直接的方法是在项目设置中配置分支跟踪。默认情况下，Vercel 会在所有分支上触发部署，但可以指定 {% label main red %} red %} 分支作为生产环境分支，这样只有 {% label main red %} 分支的变更才会触发生产部署。

开启分支跟踪非常简单，按照以下步骤操作：

从仪表板中选择的项目
在侧边栏中打开 Settings。
点击 Environments。
点击 Production 环境（/settings/environments/production）。
在 Branch Tracking 中，输入想要追踪的分支名称，例如 {% label main red %}。
点击 Save。

还可以在 Preview 环境（/settings/environments/preview）中关闭 Branch Tracking。这样就可以确保只有 {% label main red %} 分支的变更才会触发任何构建。

使用 git 配置

在项目根目录的 vercel.json 文件中添加 git.deploymentEnabled 配置，精确控制哪些分支可以触发部署：

{
  "git": {
    "deploymentEnabled": {
      "main": true
    }
  }
}

使用忽略构建步骤

如果需要更灵活的控制，可以在项目设置的“忽略构建步骤”部分使用自定义 Bash 脚本：

#!/bin/bash
if [[ "$VERCEL_GIT_COMMIT_REF" == "main" ]]; then
  exit 1  # 继续构建
else
  exit 0  # 跳过构建
fi

对单一仓库配置小号以远程管理小号仓库

Mon, 20 Apr 2026 21:16:59 GMT

命令行操作

给这个仓库单独设置小号（仅本地生效）

git config --local user.name "用户名"
git config --local user.email "邮箱"

把远程地址绑定到小号仓库

git remote set-url origin https://github.com/用户名/仓库名.git

推送（第一次会让你登录小号）
```
git push -f origin main
```

登录时怎么填？

弹出窗口时： 使用 SSH 登录

在输入框中填入在这里创建的 SSH 密钥（权限建议仅 Repo）。

最终效果（最舒服的状态）

全局 Git = 大号

其他所有仓库 = 大号

只有特定文件夹 = 小号

{% note blue 'anzhiyufont anzhiyu-icon-bullhorn' modern %}永远不用再切换账号{% endnote %}

在 VS code 上远程管理 Github 仓库并自动化部署项目

Sun, 19 Apr 2026 19:47:17 GMT

如果 GitHub 远程是没有提交的空仓库

git init
git add -A
git commit -m "🔄️ init:初始化 main 源码分支"
git checkout -b main

然后再绑定哦。

绑定本地仓库到你已有的 GitHub 远程仓库

先把本地和远程仓库建立连接，Ctrl+Shift+`调出 VS code 终端直接执行：

git remote add origin https://github.com/你的用户名/仓库名.git

验证绑定成功：

git remote -v

终端输出下面这样，就代表绑定成功：

origin  git@github.com:xxx/xxx.git (fetch)
origin  git@github.com:xxx/xxx.git (push)

{% note info flat %} 报错 fatal: remote origin already exists：说明之前绑过别的，先执行 git remote remove origin 解除绑定，再重新执行上面绑定命令即可。 {% endnote %}

拉取远程旧 main 分支内容，做安全备份（如果你的仓库原来有 main 分支，可选）

远程 {% label main red %} 全是旧的 {% label dist red %} 文件，我们先把它拉到本地，备份成一个旧分支，绝对不覆盖本地源码，全程安全兜底。

git fetch origin
git branch old-main origin/main

执行完，你本地就多了一个 {% emp old-main %} 备份分支，以前手动上传的所有文件全部永久保留，后续操作完全不会动它。

重置本地 main 分支为纯净源码分支

你的 .gitignore 已经写好了 dist，会自动忽略打包文件夹，不会把 dist 提交到 {% label main red %} 分支。

git checkout main
git add .
git commit -m "🔄️ init:初始化 main 源码分支"

推送全新源码 main 分支

如果 {% label main red %} 分支已经有冲突文件：

git push -f origin main

否则：

git push origin main

{% tip success %}GitHub 远程 {% label main red %} 分支：已经全部是你的项目源码，dist 文件夹被 .gitignore 自动忽略，完全不会上传到 {% label main red %}！{% endtip %}

新建 gh-pages 分支，只存放静态文件

这一步专门创建部署分支，全程独立，和 {% label main red %} 分支完全隔离，只存放打包后的 dist 静态文件。

pnpm build
cd dist && git init && git add . && git commit -m "init gh-pages" && git push -f git@github.com:你的用户名/仓库名.git HEAD:gh-pages && cd ..

{% tip success %}GitHub 远程 {% label gh-pages red %} 分支：里面只有 dist 静态网页文件，无任何源码，专门用于 GitHub Pages 网站部署。{% endtip %}

日常开发

你以后每次修改完代码，更新网页，只需要严格按这个顺序走，再也不用手动上传文件：

Vite 项目

1. 开发修改源码（全程在 main 分支）

你改完源码后，更新到 GitHub 源码仓库：

git add .
git commit -m "✨ UppubDatetime: 更新源码"
git push origin main

2. 打包生成最新的 dist 文件

在 main 分支终端执行打包命令（根据你的项目，你的是 vite 项目）

npm run build
# 或 pnpm build

执行完，本地 dist 文件夹就会更新为最新打包文件。

{% note primary flat %} 回到主项目根目录，执行这 2 条全局 git 配置，永久关闭这个烦人的换行符警告：

git config core.autocrlf true
git config core.safecrlf false

{% endnote %}

3. 一键更新 gh-pages 部署网页

npm run build
# 或 pnpm build
cd dist && git init && git add . && git commit -m "uppubDatetime site" && git push -f git@github.com:你的用户名/你的仓库名.git HEAD:gh-pages && cd ..

打包最新静态文件
一键纯净推送 gh-pages，无任何多余文件

NextJs 项目

每次写完代码 $\to$ 推源码（main）

Ctrl+Shift+` 打开终端，直接运行：

git add .
git commit -m "更新项目源码"
git push origin main

{% folding green, ✅ 作用 %} 把你的代码推送到小号 {% hideInline 看什么看,查******,#FF7242,#fff %} 的 {% label main red %} 分支（你已经配置好锁死小号，直接推就行）

{% endfolding %}

要发布网页 $\to$ 推静态文件（gh-pages）

还是在根目录，直接复制这一条完整命令运行：

npm run build && cd out && git add . && git commit -m "更新网页" && git push -f https://ru-sin@github.com/ru-sin/用户名.git HEAD:gh-pages && cd ..

{% note success flat %} 这条命令会自动

打包生成最新 out
提交网页文件
强制推送到小号 {% label gh-pages red %} 分支
退回根目录 {% endnote %}

高级做法（2 选 1）

推送 main 源码后自动推送 gh-pages 分支

访问 /settings/actions，下滑找到 Workflow permissions，勾选 Read and write permissions，点击 Save 就好了。

{% label main red %} 分支新建 .github/workflows/deploy.yml，直接复制代码如下：

name: 自动部署到 gh-pages

on:
  push:
    branches:
      - main  # 推送到 main 分支就自动触发

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: 拉取代码
        uses: actions/checkout@v4
        with:
          persist-credentials: false

      - name: 安装依赖
        run: npm install

      - name: 编译生成 out 文件夹
        run: npm run build

      - name: 部署到 gh-pages
        uses: peaceiris/actions-gh-pages@v4
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: ./out

这样就不需要推静态文件（{% label gh-pages red %}）分支了，直接推 {% label main red %} 即可。

build 后一行命令部署 dist

安装工具。

npm install gh-pages --save-dev

在 package.json 里添加部署脚本。

{
  "scripts": {
    "deploy": "gh-pages -d dist"
  }
}

部署命令，可以自动部署到 gh-pages 分支。

npm run build
npm run deploy

{% tip success %}成功！{% endtip %}

侧边栏添加个性定位欢迎信息

Mon, 06 Apr 2026 20:58:53 GMT

前景介绍

:::info[背景]{open} 基于{% btn 'https://blog.bsgun.cn/posts/ef58a648/',梦爱吃鱼的教程 %}进行修改，主要改进是更换 API 地址，因为原 API 已经失效。 :::

使用方法

创建 JS 文件

在博客主题目录的 js 文件夹（~\themes\anzhiyu\source\js）下创建 welcome.js 文件(也可以在source文件夹下另外新建文件夹)。

配置经纬度

{% btn 'https://uapis.cn/api/v1/network/myip?source=commercial',点击这里 %}，找到

"latitude": xxx,"longitude": xxx,

复制对应的经度(lng)和纬度(lat)值。

将以下内容复制到 welcome.js 中,并修改文件顶部配置信息

:::success[代码]

window.IP_CONFIG = {
    BLOG_LOCATION: {
        lng: 121.4, // 博主经度
        lat: 29.9,  // 博主纬度
    },
    CACHE_DURATION: 1000 * 60 * 60, // 缓存1小时
    HOME_PAGE_ONLY: true, // 是否只在首页显示
};

// 添加样式
const addStyles = () => {
    const style = document.createElement('style');
    style.textContent = `
        #welcome-info {
            user-select: none;
            display: flex;
            justify-content: center;
            align-items: center;
            height: 212px;
            padding: 10px;
            margin-top: 5px;
            border-radius: 12px;
            background-color: var(--anzhiyu-background);
            outline: 1px solid var(--anzhiyu-card-border);
        }
        .loading-spinner {
            width: 50px;
            height: 50px;
            border: 3px solid rgba(0, 0, 0, 0.1);
            border-radius: 50%;
            border-top: 3px solid var(--anzhiyu-main);
            animation: spin 1s linear infinite;
        }
        @keyframes spin {
            0% { transform: rotate(0deg); }
            100% { transform: rotate(360deg); }
        }
        .ip-address {
            filter: blur(5px);
            transition: filter 0.3s ease;
        }
        .ip-address:hover {
            filter: blur(0);
        }
        .error-message {
            color: #ff6565;
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
        }
        .error-message p,
        .permission-dialog p {
            margin: 0;
        }
        .error-icon {
            font-size: 3rem;
        }
        #retry-button {
            margin: 0 5px;
            color: var(--anzhiyu-main);
            transition: transform 0.3s ease;
            cursor: pointer;
        }
        #retry-button:hover {
            transform: rotate(180deg);
        }
    `;
    document.head.appendChild(style);
};

// 获取欢迎信息元素
const getWelcomeInfoElement = () => document.querySelector('#welcome-info');

// 显示加载动画
const showLoadingSpinner = () => {
    const welcomeInfoElement = getWelcomeInfoElement();
    if (!welcomeInfoElement) return;
    welcomeInfoElement.innerHTML = '<div class="loading-spinner"></div>';
};

// 显示错误信息
const showErrorMessage = (message = '抱歉，无法获取信息') => {
    const welcomeInfoElement = getWelcomeInfoElement();
    if (!welcomeInfoElement) return;
  
    welcomeInfoElement.innerHTML = `
        <div class="error-message">
            <div class="error-icon">😕</div>
            <p>${message}</p>
            <p>请<i id="retry-button" class="fa-solid fa-arrows-rotate"></i>重试或检查网络连接</p>
        </div>
    `;
    document.getElementById('retry-button').addEventListener('click', fetchIpInfo);
};

// 缓存相关
const IP_CACHE_KEY = 'ip_info_cache';
const getIpInfoFromCache = () => {
    const cached = localStorage.getItem(IP_CACHE_KEY);
    if (!cached) return null;
  
    const { data, timestamp } = JSON.parse(cached);
    if (publishDate.now() - timestamp > IP_CONFIG.CACHE_DURATION) {
        localStorage.removeItem(IP_CACHE_KEY);
        return null;
    }
    return data;
};

const setIpInfoCache = (data) => {
    localStorage.setItem(IP_CACHE_KEY, JSON.stringify({
        data,
        timestamp: publishDate.now()
    }));
};

// 计算距离
const calculateDistance = (lng, lat) => {
    const R = 6371; // 地球半径(km)
    const rad = Math.PI / 180;
    const dLat = (lat - IP_CONFIG.BLOG_LOCATION.lat) * rad;
    const dLon = (lng - IP_CONFIG.BLOG_LOCATION.lng) * rad;
    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
        Math.cos(IP_CONFIG.BLOG_LOCATION.lat * rad) * Math.cos(lat * rad) *
        Math.sin(dLon / 2) * Math.sin(dLon / 2);
    return Math.round(R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)));
};

// 格式化IP显示
const formatIpDisplay = (ip) => {
    if (!ip) return "未知IP";
    return ip.includes(":") ? "IPv6地址" : ip;
};

// 格式化位置
const formatLocation = (region) => {
    if (!region) return '神秘地区';
    return region.replace(/\s+/g, " ");
};

// 时段问候
const getTimeGreeting = () => {
    const hour = new publishDate().getHours();
    if (hour < 11) return "早上好🌤️，一日之计在于晨";
    if (hour < 13) return "中午好☀️，记得午休喔~";
    if (hour < 17) return "下午好🕞，饮茶先啦！";
    if (hour < 19) return "即将下班🚶‍♂️，记得按时吃饭~";
    return "晚上好🌙，夜生活嗨起来！";
};

// ====================== 终极修复：适配 浙江、江苏 这种简写 ======================
const getGreeting = (region) => {
    if (!region) return "带我去你的城市逛逛吧！";

    const parts = region.trim().split(/\s+/).filter(Boolean);
    const province = parts[1] || "";
    const city = parts[2] || "";

    if (city === "南京") return "六朝古都，风华依旧";
    if (city === "苏州") return "上有天堂，下有苏杭";
    if (city === "杭州") return "东风渐绿西湖柳，雁已还人未南归";
    if (city === "郑州") return "豫州之域，天地之中";
    if (city === "洛阳") return "洛阳城里见秋风，欲作家书意万重";
    if (city === "开封") return "包公那叫一个铁面无私，严惩贪官污吏";
    if (city === "宁波") return "海上丝路的起点，和我一个城市。";
    if (city === "西安") return "十三朝古都，长治久安！";

    // 省份匹配（简写版）
    if (province === "北京") return "北京欢迎你~~~";
    if (province === "天津") return "讲段相声吧";
    if (province === "河北") return "山势巍巍成壁垒，天下雄关";
    if (province === "山西") return "展开坐具长三尺，已占山河五百余";
    if (province === "内蒙古") return "天苍苍，野茫茫，风吹草低见牛羊";
    if (province === "辽宁") return "我想吃烤鸡架！";
    if (province === "吉林") return "状元阁就是东北烧烤之王";
    if (province === "黑龙江") return "很喜欢哈尔滨大剧院";
    if (province === "上海") return "众所周知，中国只有两个城市";
    if (province === "江苏") return "散装是必须要散装的";
    if (province === "浙江") return "望海楼明照曙霞，闲塘十里尽梅花";
    if (province === "河南") return "可否带我品尝河南烩面啦？";

    return "欢迎来到我的博客！";
};
// ==============================================================================

// 生成欢迎信息
const generateWelcomeMessage = (region, dist, ipDisplay) => {
    const location = formatLocation(region);
    const timeGreet = getTimeGreeting();
    const cityGreet = getGreeting(region);
  
    return `
        欢迎来自 <b>${location}</b> 的小友💖<br>
        你当前距博主约 <b>${dist}</b> 公里！<br>
        你的IP地址：<b class="ip-address">${ipDisplay}</b><br>
        ${timeGreet}<br>
        Tip：<b>${cityGreet}🍂</b>
    `;
};

const showWelcome = (data) => {
    if (!data || !data.ip) return showErrorMessage();
  
    const welcomeInfo = getWelcomeInfoElement();
    if (!welcomeInfo) return;
  
    const dist = calculateDistance(data.longitude, data.latitude);
    const ipDisplay = formatIpDisplay(data.ip);
  
    welcomeInfo.style.display = 'block';
    welcomeInfo.style.height = 'auto';
    welcomeInfo.innerHTML = generateWelcomeMessage(data.region, dist, ipDisplay);
};

// 从uapis.cn获取IP信息
const fetchIpData = async () => {
    const response = await fetch('https://uapis.cn/api/v1/network/myip?source=commercial');
    if (!response.ok) throw new Error('API请求失败');
    const result = await response.json();
    return result;
};

// 获取IP信息主函数
const fetchIpInfo = async () => {
    showLoadingSpinner();
  
    const cachedData = getIpInfoFromCache();
    if (cachedData) {
        showWelcome(cachedData);
        return;
    }
  
    try {
        const data = await fetchIpData();
        setIpInfoCache(data);
        showWelcome(data);
    } catch (error) {
        console.error('获取IP信息失败:', error);
        showErrorMessage('获取IP信息失败，请重试');
    }
};

const isHomePage = () => {
    return window.location.pathname === '/' || window.location.pathname === '/index.html';
};

// 插入组件
const insertAnnouncementComponent = () => {
    const announcementCards = document.querySelectorAll('.card-widget.card-announcement');
    if (!announcementCards.length) return;
  
    if (IP_CONFIG.HOME_PAGE_ONLY && !isHomePage()) {
        announcementCards.forEach(card => card.remove());
        return;
    }
  
    if (!document.querySelector('#welcome-info')) return;
    fetchIpInfo();
};

document.addEventListener('DOMContentLoaded', () => {
    addStyles();
    insertAnnouncementComponent();
    document.addEventListener('pjax:complete', insertAnnouncementComponent);
});

:::

插入 JS 文件

在 _config.anzhiyu.yml （或其他主题）主题配置文件下 inject 配置项中的 bottom 引入 welcome.js。

- <script src="/js/welcome.js"></script>

{% tip info %}图片内容仅供参考，具体根据实际情况修改。{% endtip %}

配置内容

确认 _config.anzhiyu.yml （或其他主题）主题配置文件下 aside 配置项中的 card_announcement 是否开启，配置参考：

card_announcement:
  enable: true # 必须开启
  content: ···（省略）
           <div id="welcome-info"></div> # 必须项

{% folding yellow, 注意事项 %}

确保API密钥正确填写,正确设置白名单
经纬度没必要填写详细,为了自身隐私安全
选择器可以根据你的主题实际情况修改

{% endfolding %}

常见问题

Q: 为什么显示"无法获取信息"? A: 可能是 API 炸了，检查配置并重试。实在不行联系我更新文章。

Q: 距离显示不准确? A: 正常现象，计算有无法避免的误差，大概就行了。

图论之欧拉回路、差分约束——算法笔记

Fri, 03 Apr 2026 21:17:47 GMT

图论之欧拉回路、差分约束——算法笔记

比赛

欧拉回路

无向代码1：

void dfs(int x){
	while(f[x]<to[x].size()){
		int y=to[x][f[x]].first,idx=to[x][f[x]].second;
		f[x]++;
		if(!vis[idx]){
			vis[idx]=vis[idx^1]=1;
			dfs(y);
			c[++l]=y;
		}
	}
}

无向代码2：

int x=0,y=0,z=0;
for(int i=1;i<=n;++i){
	if(d[i]&1)x=i,++y;
}
if(y&&y!=2){
	cout<<"Impossible"<<endl;
}

有向题目：

#include<bits/stdc++.h>
using namespace std;
int n,m,d[100005],c[100005],f[100005]/*表示遍历到第几个点*/;
vector<int>a[100005];
stack<int>st;
void dfs(int x){
	int l=0;
	while(f[x]<a[x].size()){
		int y=a[x][f[x]];
		f[x]++;
		dfs(y);
		c[++l]=y;
	}
	st.push(x);
}
int main(){
	cin>>n>>m;
	int ind[100005],outd[100005],u,v;
	for(int i=1;i<=m;++i){
		cin>>u>>v;
		a[u].push_back(v);
		ind[v]++,outd[u]++;
	}
	for(int i=1;i<=n;++i)sort(a[i].begin(),a[i].end());
	int x=1,y=0,z=0;
	for(int i=1;i<=n;++i){
		if(ind[i]+1==outd[i])x=i,++y;
		if(ind[i]!=outd[i])++z;
	}
	if(!((y==1&&z==2)||!z)){
		cout<<"No"<<endl;
		return 0;
	}
	dfs(x);
	while(!st.empty()){
		cout<<st.top()<<" ";
		st.pop();
	}
	return 0;
}

差分约束

Bellman_Ford：

void Bellman_Ford(int n){
	auto relax=[&](){
		bool f=0;
		for(int i=1;i<=n;++i){
			for(auto k:to[i]){
				if(ans[i]>ans[k.first]+k.second){
					ans[i]=min(ans[i],ans[k.first]+k.second),f=1;
				}
			}
		}
		return f;
	};
	for(int i=0;i<n-1;++i)relax();
	if(relax())cout<<"NO";
	else for(int i=1;i<=n;++i)cout<<ans[i]<<" ";
}

完整题目：

#include<bits/stdc++.h>
using namespace std;
int ans[5005];
vector<pair<int,int>>to[5005];
void Bellman_Ford(int n){
	auto relax=[&](){
		bool f=0;
		for(int i=1;i<=n;++i){
			for(auto k:to[i]){
				if(ans[i]>ans[k.first]+k.second){
					ans[i]=min(ans[i],ans[k.first]+k.second),f=1;
				}
			}
		}
		return f;
	};
	for(int i=0;i<n-1;++i)relax();
	if(relax())cout<<"NO";
	else for(int i=1;i<=n;++i)cout<<ans[i]<<" ";
}
int n,m,c1,c2,y;
int main() {
	cin>>n>>m;
	fill(ans,ans+n+1,0);
	for(int i=1;i<=m;++i){
		cin>>c1>>c2>>y;
		to[c1].push_back({c2,y});
	}
	Bellman_Ford(n);
    return 0;
}

第22届浙大宁波理工学院程序设计大赛题解

Fri, 03 Apr 2026 21:00:28 GMT

A. 字符串

按照题意模拟即可，如果想要省掉代码量可以开个 std::vector<std::pair<char, int>> ve(n) 前一个记录字符，后一个记录当前的下标，直接进行升序排序，然后直接从k+1个开始输出。提供排序的代码。

void clearlove13(void){
    int n, k;
    std::cin >> n >> k;
    std::string s;
    std::cin >> s;
    std::vector<std::pair<char, int>> ve(n);
    for (int i = 0; i < n; i++) {
        ve[i] = std::make_pair(s[i], i);
    }
    std::sort(ve.begin(), ve.end());
    std::vector<std::pair<char, int>> ans;
    ans.reserve(n);
    for (int i = k; i < n; i++) {
        ans.push_back({ve[i].first, ve[i].second});
    }
    std::sort(ans.begin(), ans.end(), [&](auto & a, auto & b) {
        return a.second < b.second;
    });
    for (auto &[x, y] : ans) {
        std::cout << x;
    }
}

B. 价格跨度

题意大概就是求该 $a_i$ 前面第一个大于该 $a_i$ 的位置，从题目数据可得知，此题我们需要使用 $\mathcal{O(n)}$ 复杂度来写这道题，思考一下可以使用单调栈来实现，只需要等效思想来写即可。

void clearlove13(void)
{
    int n;
    std::cin >> n;
    std::vector<int> a(n + 1);
    for (int i = 1; i <= n; i++) {
        std::cin >> a[i];
    }
    std::vector<int>st;
    std::vector<int> ans(n + 1);
    st.reserve(n + 1);
 
    for (int i = 1; i <= n; i++) {
        while (!st.empty() && a[st.back()] <= a[i]) {
            st.pop_back();
        }
        if (st.empty()) {
            ans[i] = i;
        } else {
            ans[i] = i - st.back();
        }
        st.push_back(i);
    }
 
    for (int i = 1; i <= n; i++) {
        std::cout << ans[i];
        if (i != n) std::cout << ' ';
    }
}

C. 斐波那契数

事实上题目已经告诉你了做法直接模拟即可。

i64 a[51];
void clearlove13(void)
{
    int n;
    std::cin >> n;
    std::cout << a[n] << '\n';
}
int main(void)
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    a[1] = 1;
    a[0] = 1;
    for (int i = 2; i <= 50; i++) {
        a[i] = a[i - 1] + a[i - 2];
    }
 
    int cas = 1;
    std::cin >> cas;
    while (cas--) clearlove13();
    return 0;
}

D. 回收礼物

设 $f(x\to y)$ 是以 $1$ 为根，求x到y的树上最小路径我们先了解题意，就可以明白是需要求形如 $f(1\to 2)+f(2\to 3)+f(3\to {\dots})+f({\dots}\to 2)$ 这么一个式子，那么我们应该怎么快速去求树上最短路径呢？引入lca求最近公共祖先，有一个小trick就是我们所以我们就先求出到两个点的深度之和再减去公共祖先的深度就可以写出这道题了。

struct LCA {
    int n, lg;
    std::vector<std::vector<int>> up;
    std::vector<int> depth, tin, tout;
    int timer = 0;
 
    LCA(std::vector<std::vector<int>>& ed, int root = 0) {
        n = int(ed.size());
        lg = std::__lg(n) + 1;
        up.assign(n, std::vector<int>(lg));
        depth.assign(n, 0);
        tin.resize(n), tout.resize(n);
        auto dfs = [&](auto self, int u, int p) -> void {
            tin[u] = timer++;
            up[u][0] = p;
            for (int i = 1; i < lg; ++i) up[u][i] = up[up[u][i - 1]][i - 1];
            for (int v : ed[u]) {
                if (v == p) continue;
                depth[v] = depth[u] + 1;
                self(self, v, u);
            }
            tout[u] = timer++;
        };
        dfs(dfs, root, root);
    }
 
    bool is_ancestor(int u, int v) {
        return tin[u] <= tin[v] && tout[v] <= tout[u];
    }
 
    int get_lca(int u, int v) {
        if (is_ancestor(u, v)) return u;
        if (is_ancestor(v, u)) return v;
        for (int i = lg - 1; i >= 0; --i)
            if (!is_ancestor(up[u][i], v)) u = up[u][i];
        return up[u][0];
    }
 
    std::vector<int> get_path(int u, int v) {
        int w = get_lca(u, v);
        std::vector<int> up_path, down_path;
        while (u != w) {
            up_path.push_back(u);
            u = up[u][0];
        }
        up_path.push_back(w);
        while (v != w) {
            down_path.push_back(v);
            v = up[v][0];
        }
        std::reverse(down_path.begin(), down_path.end());
        up_path.insert(up_path.end(), down_path.begin(), down_path.end());
        return up_path;
    }
};
 
void clearlove13() {
    constexpr int lg = 20;
    int n, q, rt;
    std::cin >> n >> q ;
    rt = 1;
    std::vector<std::vector<int>> g(n + 1);
    std::vector<int>ch(q);
    for (int i = 2; i <= n; i++) {
        int u;
        std::cin >> u;
        g[u].push_back(i);
        g[i].push_back(u);
    }
 
    std::vector<int> dep(n + 1);
    std::vector<std::array<int, lg>> up(n + 1);
    for (int i = 1; i <= n; i++) {
        std::fill(up[i].begin(), up[i].end(), -1);
    }
 
    auto dfs = [&](auto self, int u, int fa) -> void {
        up[u][0] = fa;
        for (int i = 1; i < lg; i++) {
            if (up[u][i - 1] != -1) {
                up[u][i] = up[up[u][i - 1]][i - 1];
            }
        }
        for (int v : g[u]) {
            if (v != fa) {
                dep[v] = dep[u] + 1;
                self(self, v, u);
            }
        }
    };
 
    dfs(dfs, rt, -1);
 
    auto lca = [&](i64 u, i64 v) -> int {
        if (dep[u] < dep[v]) std::swap(u, v);
        i64 d = dep[u] - dep[v];
        for (int i = 0; i < lg; i++) {
            if (d >> i & 1) u = up[u][i];
        }
        if (u == v) return u;
        for (int i = lg - 1; i >= 0; i--) {
            if (up[u][i] != up[v][i]) {
                u = up[u][i];
                v = up[v][i];
            }
        }
        return up[u][0];
    };
 
    auto dist = [&](i64 u, i64 v) -> int {
        i64 l = lca(u, v);
        return dep[u] + dep[v] - 2 * dep[l];
    };
 
    for (auto &i : ch) {
        std::cin >> i;
    }
    i64 ans = dist(1, ch[0]);
    for (int i = 1; i < q; i++) {
        ans += dist(ch[i - 1], ch[i]);
    }
    std::cout << ans << '\n';
}

E. 我们都是小怪兽 (Rescue Qfish)

推导公式发现边权每 $4$ 步循环。利用分层图思想，将每个点按时刻拆为 $4$ 层，层间连边，跑 Dijkstra 最短路即可。提供建图的代码。

for (ll i = 1; i <= m; i++) {
    cin >> u >> v >> w;
    
    ll w0 = w; //第一层是L
    ll w1 = (w - 1) * quickpow(w + 1, md - 2, md) % md; //第二层是(L-1)/(L+1)
    ll w2 = -quickpow(w, md - 2, md) % md;   //第三层是(-1)/L
    ll w3 = (w + 1) * quickpow((1 - w + md) % md, md - 2, md) % md;//第四层是(L+1)/(1-L) 每四次循环

    if (w1 < 0) w1 += md;
    if (w2 < 0) w2 += md;
    if (w3 < 0) w3 += md;

    g[u].push_back({w0, v + n});
    g[v].push_back({w0, u + n});

    g[u + n].push_back({w1, v + 2 * n});
    g[v + n].push_back({w1, u + 2 * n});

    g[u + 2 * n].push_back({w2, v + 3 * n});
    g[v + 2 * n].push_back({w2, u + 3 * n});

    g[u + 3 * n].push_back({w3, v});
    g[v + 3 * n].push_back({w3, u});
}

F. 爱的魔力转圈圈——终极幸存者挑战赛

这是一道约瑟夫环问题，但是数据开小了遍历也能过，递推公式： $\mathcal{f(n, k)=f(n-1, k)+k}$

#include <iostream>
using namespace std;

int main() {
    int n;
    long long k;  
    cin >> n >> k;
    
    long long res = 0;  // f(1)=0（1个人时位置为0）
    for (int i = 2; i <= n; ++i) {
        res = (res + k) % i;  // 递推计算f(i)
    }
    
    cout << res + 1 << endl;  // 转换为1-based编号
    return 0;
}

G. 探险者的补给路线

直接根据题目意思写就行，$x, y$ 分别是 $a, b$ 的倍数。

void clearlove13(void)
{
    i64 a, b, x, y;
    std::cin >> a >> b >> x >> y;
    if (x % a == 0 && y % b == 0 && x >= 0 && y >= 0) {
        std::cout << "YES\n";
    } else {
        std::cout << "NO\n";
    }
}

H. Qfish的法术

首先我们根据题意每次加2，可以知道区间和无论怎么操作奇偶性永远不会改变，由此延申我们进行分类讨论，如果区间长度是奇数的话，经过操作后的区间和直接贪心成偶数的目标去，因没有要求对操作后的值有具体要求，所以区间长度是奇数就一定可以，如果区间长度为偶数，但区间和为奇数，每次+2并不会改变奇偶性，所以无解。

值得注意的是，我们需要对长度为2的区间进行一个简单的特判，区间和直接用前缀和维护就行。

void clearlove13(void)
{
    int n, t;
    std::cin >> n >> t;
    std::vector<i64>a(n + 1);
    for (int i = 1; i <= n; i++) {
        std::cin >> a[i];
        a[i] += a[i - 1];
    }
    while (t--) {
        int l, r;
        std::cin >> l >> r;
        if (r - l + 1 == 2 && (a[r] != a[l - 1])) {
            std::cout << "NO\n";
            continue;
        }
        if (((r - l + 1LL) % 2 == 0) && ((a[r] - a[l - 1]) % 2 == 1)) {
            std::cout << "NO\n";
        } else {
            std::cout << "YES\n";
        }
    }
}

I. 字母混淆

直接根据题目来模拟就行。

void solve(){
    string s;
    int n;
    cin >> n >> s;
    s = " " + s;
    for (int i = 1; i <= n; ++i)
        cout << (char)((s[i] + 32 - 'a' - 2 + 26) % 26 + 'a');
}

J. 小s的杀戮尖塔

超级大模拟，首先我们可以观察到，观者的血量不会超过1000，并且大鄂虫每行动3轮攻击力就会永久增加，而观者每轮理想情况下只能有15点格挡。所以计算可知游戏轮数一定不会超过60轮。因此可以使用三维 $dp$ 求解。$dp_{i, j, q}$，$i$ 代表第 $i$ 轮，$j$ 代表大鄂虫剩余 $j$ 滴血，$q$ 代表观者处于的姿态。记录的是观者剩余的血量。每次抽取 $5$ 张牌，用 dfs 记录所有会到达的状态。后面就是漫长的调试代码时间，总复杂度是 $\mathcal{O(60\times b \times 3 \times 5)}$。而且题目的伤害与大鄂虫的格挡实际上都是3的倍数，因此可以把伤害与血量 $\div 3$ 进行计算。实际上由于状态数远不会到达最高复杂度，因此代码可以通过。std 的耗时约 $150ms$。一些容易导致 WA 的细节：

第一轮的行动 $1$ 与后面轮次的行动 $1$ 不同。后面轮次的行动 $1$ 是有 $9$ 点护甲的，第一轮没有。
最后 $1$ 轮观者战胜大鄂虫时，游戏立即结算，此时观者不会再受到伤害。
把费用用完并不是最优解，例如手里是 $5$ 张暴怒，此时可能会选择一张都不打。

由于出题人的 std 过于臃肿，因此在这里放上能够通过对拍的 AI 代码。

typedef long long ll;

ll dp[2][40400][3]; 
ll num[505050];

struct MoveResult {
    ll dmg;        // 造成的伤害
    ll self_blk;   // 获得的格挡
    ll end_stance; // 结束姿态
};
vector<MoveResult> moves_cache[3]; // [起始姿态] -> 结果列表

int main(){
    cin.tie(0); cout.tie(0); ios::sync_with_stdio(0);
    ll t, a, b, n;
    if(!(cin >> t)) return 0;
    
    while(t--){
        cin >> a >> b >> n;
        for(int i=1; i<=n; i++) cin >> num[i];
        
        // 压缩敌方血量
        ll max_b = (b - 1) / 3 + 1;
        
        for(int x=0; x<=max_b; x++) 
            for(int s=0; s<3; s++) dp[0][x][s] = -1;
            
        vector<pair<ll, ll>> q; // 队列: {敌方血量, 姿态}
        q.push_back({max_b, 0});
        dp[0][max_b][0] = a;
        
        ll ans = -1;
        ll turn = 0;
        ll gong = 0; // 力量
        
        while(!q.empty() && turn < 60) {
            ll cur = turn % 2;
            ll nxt = (turn + 1) % 2;
            turn++;
            
            // 重置下一轮DP状态
            for(int x=0; x<=max_b; x++)
                for(int s=0; s<3; s++) dp[nxt][x][s] = -1;
            
            // 1. 确定手牌
            vector<ll> hand;
            for(int i=0; i<5; i++) {
                ll idx = ((turn - 1) * 5 + i) % n + 1;
                hand.push_back(num[idx]);
            }
            sort(hand.begin(), hand.end());
            
            // 2. 预计算所有出牌结果
            for(int s=0; s<3; s++) moves_cache[s].clear();
            
            do {
                for(int start_s=0; start_s<3; start_s++) {
                    ll c = 3, cur_s = start_s;
                    ll raw_dmg = 0, self_blk = 0;
                    
                    // 记录"一张牌都不出"也是一种可能
                    moves_cache[start_s].push_back({0, 0, start_s});
                    
                    for(ll card : hand) {
                        ll cost = (card >= 4) ? 2 : 1;
                        if(c < cost) break;
                        c -= cost;
                        
                        // 伤害计算
                        ll d = 0;
                        if(card == 1) d = 6;
                        else if(card == 3 || card == 4) d = 9;
                        if(cur_s == 1) d *= 2; // 愤怒翻倍
                        raw_dmg += d;
                        
                        // 格挡计算
                        if(card == 2) self_blk += 5;
                        else if(card == 5) self_blk += 8;
                        
                        // 姿态变更
                        ll old_s = cur_s;
                        if(card == 3) cur_s = 0;
                        else if(card == 4) cur_s = 1;
                        else if(card == 5) cur_s = 2;
                        if(old_s == 2 && (card == 3 || card == 4)) c += 2;
                        
                        // 存入结果 (伤害/3, 格挡, 姿态)
                        moves_cache[start_s].push_back({raw_dmg / 3, self_blk, cur_s});
                    }
                }
            } while(next_permutation(hand.begin(), hand.end()));
            
            // 3. 大鄂虫属性计算
            ll chong = (turn - 1) % 3 + 1;
            if(turn > 1 && (turn - 1) % 3 == 0) gong += 5; // 每3回合加一次力量
            
            ll enemy_dmg = 0;
            if(chong == 1) enemy_dmg = 12 + gong;
            else if(chong == 2) enemy_dmg = 7 + gong;
            
            ll enemy_blk_reduce = 0;
            if(turn > 1) {
                ll prev_act = (turn - 2) % 3 + 1;
                if(prev_act == 2) enemy_blk_reduce = 2; // 6/3
                else if(prev_act == 3) enemy_blk_reduce = 3; // 9/3
            }
            
            vector<pair<ll, ll>> next_q;
            
            // 4. 状态转移
            for(auto &st : q) {
                ll e_hp = st.first;
                ll p_stance = st.second;
                ll p_hp = dp[cur][e_hp][p_stance];
                
                for(auto &res : moves_cache[p_stance]) {
                    // 计算实际对敌伤害
                    ll dmg_dealt = max(0LL, res.dmg - enemy_blk_reduce);
                    ll next_e_hp = e_hp - dmg_dealt;
                    
                    // 击杀判定
                    if(next_e_hp <= 0) {
                        ans = max(ans, p_hp);
                        continue; // 敌死，不入队
                    }
                    
                    // 玩家承伤计算
                    ll incoming = enemy_dmg;
                    if(res.end_stance == 1) incoming *= 2; // 愤怒易伤
                    ll take = max(0LL, incoming - res.self_blk);
                    ll next_p_hp = p_hp - take;
                    
                    if(next_p_hp > 0) {
                        if(dp[nxt][next_e_hp][res.end_stance] == -1) {
                            next_q.push_back({next_e_hp, res.end_stance});
                            dp[nxt][next_e_hp][res.end_stance] = next_p_hp;
                        } else {
                            dp[nxt][next_e_hp][res.end_stance] = max(dp[nxt][next_e_hp][res.end_stance], next_p_hp);
                        }
                    }
                }
            }
            q = next_q;
        }
        cout << ans << "\n";
    }
    return 0;
}

题解：P14702 [ICPC 2024 Tehran R] Boat

Fri, 03 Apr 2026 20:38:22 GMT

题目传送门

贪心，细节较多。

思路分析

先特判无解情况。

:::info[提示]{open}

如果某个重量大于最大载重量 $w$，输出 −1，结束。
如果最轻的两个人重量之和超过了 $w$，即无人可以当船夫，输出 −1，结束。

::: 否则一定有解，尽量让两人配对上船，为了用最少次数，先 sort 从小到大排序，再让最轻的人作为船夫，分为两种情况：

如果 $a_i+a_1 \leq w$，可以和最轻的人一起上船，可载两人。这样运送要 $2$ 次，$ans \leftarrow ans+2$。
否则，不可以和最轻的人一起上船，只载一人。这样运送要 $4$ 次，$ans \leftarrow ans+4$。

最后船夫不回来，所以输出 $ans-1$。

代码

按思路写即可，注意细节，这里不放了。

结语

感谢您的阅读！

题解：P14731 [ICPC 2022 Seoul R] Parentheses Tree

Fri, 03 Apr 2026 20:36:32 GMT

题目传送门

前置知识

STL 中的 stack 容器提供了一众成员函数以供调用，其中较为常用的有：

定义
- 头文件 $\color{green}\textbf{}$。
元素访问
- st.top() 返回栈顶。
修改
- st.push() 插入传入的参数到栈顶。
- st.pop() 弹出栈顶。
容量
- st.empty() 返回是否为空。
- st.size() 返回元素数量。

部分内容来自栈 - OI Wiki。

总体分析

核心：用栈匹配括号并在叶节点累加距离。

思路引导

:::warning[提问] 如何对左括号进行判断是否为叶节点？ :::

:::success[成功] 当 $s_i$ 为 ( 时，如果栈非空，将栈顶替换为 false，再将 true 入栈。 :::

:::warning[提问] 如何将答案进行累加？ :::

:::success[成功] 当 $s_i$ 为 ) 时，如果栈顶 ( 是叶子节点，先累加栈内元素数量，再弹出栈顶。 :::

:::error[警告] 不开 long long 见祖宗。 :::

核心代码

cin>>s;
for(char c:s){
	if(c=='('){
		if(st.size()){
			st.pop();
			st.push(false);
		}//替换操作
		st.push(true);
	}else{
		if(st.top()){
			ans+=st.size()-1;
		}//累加栈内元素数量
		st.pop();//弹出栈顶
	}
}
cout<<ans;
return 0;

我常常追忆过去

Fri, 03 Apr 2026 20:03:24 GMT

:::align{center} 居中内容。 :::

追忆

我常常追忆过去。

生命瞬间定格在脑海。我将背后的时间裁剪、折叠、蜷曲，揉捻成天上朵朵白云。

云朵之间亦有分别：积云厚重，而卷云飘渺。生命里震撼的场景掠过我的思绪便一生无法忘怀，而更为普通平常的记忆在时间的冲刷下只留下些许残骸。追忆宛如入梦，太过清楚则无法愉悦自己的幻想，过分模糊却又坠入虚无。只有薄雾间的山水，面纱下的女子，那恰到好处的朦胧，才能满足我对美的苛求。

追忆总在不经意间将我裹进泛黄的纸页里。分别又重聚的朋友，推倒又重建的街道，种种线索协助着我从一个具体的时刻出发沿时间的河逆流而上。曾经的日子无法重来，我只不过是一个过客。但我仍然渴望在每一次追忆之旅中留下闲暇时间，在一个场景前驻足，在岁月的朦胧里瞭望过去的自己，感受尽可能多的甜蜜。美好的时光曾流过我的身体，我便心满意足。

过去已经凝固，我带着回忆向前，只是时常疏于保管，回忆也在改变着各自的形态。这给我的追忆旅程带来些许挑战。

我该在哪里停留？我问我自己。

题解：P14730 [ICPC 2022 Seoul R] Palindrome Type

Mon, 30 Mar 2026 21:35:32 GMT

纯享阅读区
题目传送门

总体分析

核心：修改字符串 $s$ 使其成为回文串，记最小次数为 $k$，如果 $k\leq3$，输出 $k$，否则输出 -1 。

因此，可以从 $k=0\sim3$ 依次进行 DFS 搜索，只要有一次成功，输出 $k$，结束。

思路引导

{% note warning flat %} 提问如何 DFS 搜索修改过程算出 $k$？ {% endnote %}

{% note success flat %} DFS 函数 使用双指针。

当 $l<r$ 时：

如果左指针 $l$ 和右指针 $r$ 对应的 $s_l=s_r$，那么这部分已经是回文的，$l$ 向右移，$r$ 向左移。
否则：
- 如果剩余次数 $step=0$，无法继续修改，返回无法完成。
- 如果删除 $l+1$ 或 $r+1$ 可完成，返回可以完成。
- 否则返回无法完成。

返回无法完成。 {% endnote %}

{% note error flat %} 警告如果 $k\leq 3$ 都不可以，最后输出 -1 。 {% endnote %}

核心代码

bool dfs(int l, int r, int step){

    while(l<r){
        if(s[l]==s[r])l++,r--;
        else{
            if(!step)return 0;
            if(dfs(l+1,r,step-1)||dfs(l,r-1,step-1))return 1;
            return 0;
        }
    }
    return 1;

}

题解：AT_joi2024_yo1c_b 桁 (Digit)

Mon, 30 Mar 2026 19:21:06 GMT

安利一下自己的博客

题目传送门

题目大意

给出 $a,b$，求 $a+b$ 的位数。

思路引导

:::warning[提问] 如何统计 $a+b$ 的位数？ :::

:::success[成功] 我们将 $a+b$ 转化为字符串~~函数大法好~~，输出 $a+b$ 的长度即可。 :::

核心代码

#include<bits/stdc++.h>
using namespace std;
int a,b;
int main() {
	cin>>a>>b;
	cout<<to_string(a+b).size();//需使用洛谷IDE中C++14 (GCC 9)及以上版本，蓝C++会CE
	return 0;
}
//By _ruyingsuixing_(UID:1620655)

题解：CF2139B Cake Collection

Mon, 23 Mar 2026 21:33:21 GMT

CF2139B Cake Collection
安利一下博客🥳🎆🎉祝大家 2026 新年快乐！

纯享阅读区

题意分析

核心：用 $m$ 秒去拿 $n$ 个烤好的蛋糕，要拿的尽量多。用贪心算法。

思路引导

:::warning[提问] 如何保证能选到最好的方案？ :::

::::success[成功] 对数组 $a$ 从大到小进行排序，如果 $n \le m$，则可以把所有烤箱中的蛋糕都拿一遍，生产蛋糕越多的越晚拿，且后面会给出证明：早拿一次再晚拿一次和直接晚拿一次一样，不如直接晚拿一次简单。否则 $n>m$，就直接拿排序后最好（$a_i$ 较大）的烤箱中的蛋糕，同样，生产蛋糕越多的越晚拿。

综上，取个 $\min {n,m}$ 即可。 :::info[Tip]{open} 从大到小进行排序不用手写 cmp 了！使用 greater<int>() 可以直接大到小进行排序。示例代码：

sort(a+1,a+n+1,greater<int>());//对数组 a 从大到小进行排序

::: :::: :::warning[提问] 如何证明早拿一次再晚拿一次同一个烤箱，和直接晚拿一次一样？ ::: :::success[成功] 证明：
设早拿的时间为 $p_1$，晚拿的时间为 $p_2$，烤箱每秒生成 $a_i$ 个蛋糕，早拿一次再晚拿一次可以拿走 $p_1 \times a_i+(p_2-p_1) \times a_i=p_2 \times a_i$，晚拿一次可以拿走 $p_2 \times a_i$，两式相等，故结论成立。 ::: :::warning[提问] 每拿一次可以获得多少蛋糕？ ::: :::success[成功] 由于生产蛋糕越多的越晚拿，但我们已经从大到小排序了，循环的时间却是从小到大，应该用 $m-i+1$ 才能让下标 $i$ 越小，生产蛋糕 $a_i$ 越多，时间 $m-i+1$ 越大。

因此得出 $a_i$ 的价值为 $(m-i+1)\times a_i$。 ::: :::error[警告]{open} 不开 long long 见祖宗，不用 1LL 乘见祖宗。 :::

完整代码

#include<bits/stdc++.h>
using namespace std;
long long t,n,m,a[200005],s;
int main(){
	cin>>t;
	while(t--){
		s=0;
		cin>>n>>m;
		for(int i=1;i<=n;i++)cin>>a[i];
		sort(a+1,a+n+1,greater<int>());
		for(int i=1;i<=min(n,m);i++)s+=1LL*(m-i+1)*a[i];
		cout<<s<<endl;
	}
  return 0;
}
//code by _ruyingsuixing_(UID:1620655)

免费获取二级域名并部署 github 仓库

Mon, 23 Mar 2026 21:14:10 GMT

前提

拥有一个 Github 的账号和博客仓库。

领取域名

注册

Github

前往 {% btn 'https://github.com/signup',Github,anzhiyufont anzhiyu-icon-circle-arrow-right,purple larger %} 注册账号。

DigitalPlat Domains

前往 {% btn 'https://dash.domain.digitalplat.org/signup?ref=uGQR48cE9B',Digitalplat,anzhiyufont anzhiyu-icon-circle-arrow-right,purple larger %} 注册账号，完整人名、电话号码、完整地址等信息不用填写真实的，可以在美国身份生成器生成。注册完成后会发一封验证到邮箱。登录后需要 KYC 验证（使用 Github 账号即可）。验证成功后会显示这个页面。

获取

书接上回，点击左侧注册。

{% tip error %}~Digitalplat 于 2026/3/20（文章发布约一周后）左右更新 UI 和页面交互，文章中获取部分截图为旧版，可能无法对应位置，但操作基本相同。~{% endtip %} {% tip fa-atom, sync %}UppubDatetime: 本文章已更新至最新。{% endtip %}

{% link 旧版存档,点击查看旧版,https://life.rusin7.com/post/dpdns-org/ %}

{% link DigitalPlat Domains 仪表盘,下滑找到我的域名统计-最大允许域名数,https://dash.domain.digitalplat.org/dashboard %}

下滑找到我的域名统计-最大允许域名数，正常是 $2$ 个，如果你开始没按我的教程注册是 $1$ 个。

{% note info flat %} 每个账户理论上可以注册 $3$ 个免费的 dpdns.org 域名。

第 $2$ 个需要在注册时， Referral code 填 uGQR48cE9b 或 QFFXW3uiRm，如果按前面我的教程一步步注册，可以默认拥有 $2$ 个，再 star 一下获得第 $3$ 个。
第 $3$ 个需要给他们的 Github 项目 star，点击验证通过后就可以，验证不难。 {% endnote %}
登录 Github。
{% btn 'https://github.com/DigitalPlatDev/FreeDomain',访问仓库,anzhiyufont anzhiyu-icon-circle-arrow-right %}。
点击右上角 ⭐“Star”。
点击 {% btn 'https://dash.domain.digitalplat.org/auth/kyc/github',这里,anzhiyufont anzhiyu-icon-circle-arrow-right %}。 https://jsd.liiiu.cn/gh/ruying-suixing/blog/themes/hexo-theme-anzhiyu-1.7.1/sourcehttps://jsd.liiiu.cn/gh/ruying-suixing/blog/themes/hexo-theme-anzhiyu-1.7.1/source/img/2026/46209/12.png

如果被占用，可以换个域名试试，被占用图片：红框中的 *Name Server1，*Name Server2先填 1.com 和 2.com，等会儿可以修改。未被占用图片：

域名注册成功后会显示这个页面。

托管到 CF

添加

点击添加站点（Onboard a domain）。选择免费版继续。类型选择 CHAME，名称填写 @ ，目标填写 Github page 地址（username.github.io，将 username 替换为你的 Github 用户名），点击保存（Save）。保存后效果如下图。点击底部蓝色继续激活按钮。

修改 Name Server

回到注册域名的网站，点击刚刚的域名，下滑页面，找到原来是 1.com 和 2.com 的 Name server。在 Cloudflare 页面点击显示名称服务器指令（ Show nameserver instructions ）依次点击 Click to copy 按钮并依次复制到刚刚的域名的 Name server 1 和 Name server 2，修改后继续在注册域名的网站点击 更新名称服务器 （ UppubDatetime nameservers ），成功后效果如下图。

检查

回到 Cloudflare，点击 现在就检查名称服务器 （ Check nameservers now ）。域名注册商可能需要 $3$ 分钟 $\sim 24$ 小时来处理 Nameserver 的更新，当你的网站在 Cloudflare 上激活后，你会收到一封邮件通知。你也可以保留 Cloudflare 页面，当显示如下两图时，说明检查成功了。

结语

可以愉快地享用Cloudflare的服务了！祝大家打造出品牌化的个人博客，为平凡的生活添彩！

如形の博客

MDX 组件使用：User & Advanced

1. 必须使用 MDX

2. User 组件示例

3. Advanced 组件示例

GitHub 卡片

链接预览

二维码

图片组（等高拼图）

内嵌视频

写作指南：Markdown / MDX

1. Markdown 支持范围

2. 数学公式（KaTeX）

3. 代码块增强（差异/高亮）

4. 什么时候用 MDX

博客迁移分流说明

洛谷网校 CSP 初赛笔记

位运算

应用

优先级表

ASCLL 码

在 Hexo 中复现洛谷插件

前言

方法

实现

完结

笔记——树形动态规划

题解：AT_pakencamp_2020_day1_d 立方体を壊せ！

问题分析

核心思路

公式推导

代码实现

题解：P13361 [GCJ 2011 Qualification] Bot Trust

题意理解

形式化翻译

注意事项

解题思路

状态跟踪

操作逻辑

代码实现

复杂度分析

闲话

题解：P8534 「Wdoi-2」比赤色更红的梦

题意分析

思路引导

核心代码

AC 自动机笔记

网络流笔记

增广路

Part. 1 网络流的定义

1.1 流网络

1.2 流

1.4 净流量函数与流的值

Part. 2 割的定义

Part.3 最大流最小割定理

$1\degree$ 弱对偶性（流 $\leqslant$ 割）

$2\degree$ 强对偶性（$\exist$ 流 $=$ 某个割）

Part. 4 增广路定理

Part.5 Dinic 算法的分层图引理

Part.6 Dinic 算法实践

当前弧优化

代码

Part.7 HLPP（最高标号预流推进）算法

7.1 算法思想和基本概念

7.2 核心操作

7.4 核心优化

7.5 算法流程

7.6 代码实现

Part.8 题目选讲 A

P3376 【模板】网络最大流 & P4722 【模板】最大流 加强版 / 预流推进

JC 提高班期末测试题解

题目描述

输入格式

输出格式

输入输出样例 #1

输入 #1

输出 #1

说明/提示

故事背景

题目描述

P3376 【模板】网络最大流 & P4722 【模板】最大流加强版 / 预流推进