Posts on GoodCoder's Blog

katac4: 基于 AlphaZero 的强化学习探索

Sat, 28 Jun 2025 23:49:50 +0800

前言

如题，这是我的一个探索型项目。其目的并不是为了达成什么效果，而是在尝试的过程中学习知识。本文包含简要的技术报告，亦有过程中的一些心得体会。评论系统还没弄好，若有任何想法或疑问欢迎直接在项目的 Issue / Discussion 中发出来。

最近在研究强化学习（RL），其中特别喜欢 AlphaZero 算法。它是 2016 年击败世界围棋冠军李世石的 AlphaGo 演化而来的通用强化学习算法。一些主流的强化学习介绍书籍一般止步于 PPO、SAC 或 DDPG 等方法（而没有 AlphaZero、MuZero 系列），私以为是一个很大的错误。

从根源上来看，AlphaZero 属于 Model-Based RL 的范畴，这与以 Q-learning、Actor-Critic 为代表的 Model-Free RL 有本质区别。其在于使用了环境模型（游戏模拟器）进行树搜索推演最优策略，而不是通过大量试错来逐步提升预期收益。良好的环境模型对于这类算法的结果至关重要；在棋类游戏中，明确的规则直接给出了一个完美的环境模型。而真实物理世界中的环境十分复杂，难以用简单的规则去描述，这成为了阻碍强化学习技术落地应用的关键瓶颈。Meta 近期开源的 V-JEPA 2 就是构建世界模型的重要一步，非常建议大家去进一步了解。

受计算资源的限制，我选择了 Saiblo 四子棋作为游戏环境 ¹，状态空间相对较小，但也有一定的复杂性，没有已知必胜策略。另外平台上也有非常优秀的传统方法用于比较，可以获得一个相对客观的算法棋力评测。在此非常感谢清华大学提供的平台，在满足校内同学实验需求的同时能给校外的爱好者带来很大便利。

由于我的 AI 使用了 KataGo 中的一些算法改进，故命名为 katac4，代码在 GitHub 上完全开源。

截至文章写作时间（2025.06.27），katac4 在游戏天梯上以遥遥领先的分数稳居榜一：

AlphaZero 速览

网上通俗易懂地介绍 AlphaZero 的文章不在少数，因此这里仅作较为抽象的简要概述（思路参考 KataGo 论文）。

算法通过神经网络引导的蒙特卡洛树搜索（MCTS）进行自我对弈以生成训练数据。搜索过程即反复扩展游戏树：每次从根节点出发沿一条链走到叶子节点，在节点 $n$ 处选择使以下式子最大的子节点 $c$ 进行访问：

$$ \mathrm{PUCT}(c)=V(c)+c_\mathrm{PUCT}P(c) \frac{\sqrt{\sum_{c'}N(c')}}{1+N(c)} $$

其中 $V(c)$ 是 $c$ 子树中所有节点的平均预测效用值，$P(c)$ 是神经网络给出的 $c$ 对应动作先验概率，$N(c)$ 为之前通过节点 $c$ 进行模拟的次数，常数 $c_\mathrm{PUCT}=1.1$；$c'$ 表示 $n$ 的所有子节点。

不同于 $\epsilon$-greedy 算法，AlphaZero 通过对根节点处的先验概率施加 Dirichlet 噪声以增强探索：

$$ P(c)=0.75P_{\text{raw}}(c)+0.25\eta $$

其中 $\eta$ 采样自参数 $\alpha=0.8$ 的 Dirichlet 分布，$P_{\text{raw}}$ 表示神经网络给出的原始策略分布。

设搜索树的根有 $k$ 个子节点 $u_1,\dots,u_k$，它们对应的动作分别为 $a_1,\dots,a_k$。则 MCTS 的 visit distribution 正比于 $N(u_i)$：

$$ \pi(a_k|s_t)=\frac{N(u_k)}{\sum_{i=1}^k N(u_i)} $$

这是神经网络的训练目标，同时用于选择自对弈时的下一个动作（以动态变化的温度 $T$ 采样）。自对弈的起点为初始局面。在推理（实战）阶段，一般直接选择该分布中概率最大的动作，也就是访问次数最多的。

神经网络接受当前的局面状态 $s_t$ 作为输入，预测下一个动作的概率分布 $\pi$ 和局面胜率 $z$。其损失函数为：

$$ L=-c_g \sum_r z(r) \log(\hat z(r))-\sum_m \pi(m) \log(\hat \pi(m))+c_{L2} ||\boldsymbol\theta||^2 $$

其中 $r \in \{\text{win}, \text{loss}, \text{draw}\}$ 表示当前玩家视角下的游戏结果，常数 $c_g=1.5,c_{L2}=3\times 10^{-5}$。整个损失函数即为以下三部分的加权和：

胜率预测与实际结果的 Cross Entropy ²；
策略分布预测与 MCTS visit distribution 的 Soft Cross Entropy；
对神经网络参数 $\boldsymbol\theta$ 的 L2 正则化。

策略更新采用 Off-policy 的方式，维护经验回放池（replay buffer），每轮自对弈完成后将新的经验数据加入回放池，再从中采样一个大小为 $B$ 的小批量进行梯度下降更新。使用 SGD with Momentum 优化器，学习率随训练阶段调整。

整体上，AlphaZero 与策略迭代算法的核心思想是一致的，只是用 MCTS 同时完成了策略评估和策略提升的任务。

训练，退火

退火的思想对于成功训练一个 AlphaZero Agent 至关重要。这里涉及到非常多的细节，建议大家参考代码，我在此列出几个关键要点：

从 visit distribution 中采样动作的温度 $T=0.8^{1+step/boardsize}$。AlphaZero_Gomoku 中使用常数 $T=1$，实践证明这是完全错误的。在一盘棋后期很容易”一招不慎，满盘皆输“，若直接根据 visit distribution 采样动作会产生大量错误 game outcome 样本，导致整个训练崩溃。
神经网络给出的策略，在根节点应用温度 $T=\max(1.03,1.35\times0.66^{step/boardsize})$。这可以确保一定的探索性，增强训练稳定性。
学习率退火。训练的前期（$5\%$ 迭代次数）使用 $1/3$ 的正常学习率（防止前期训练大幅波动），$72\%$ 以后使用 $1/10$ 的正常学习率（最大化提升棋力）。

很多超参数不一定最优，都是随手设置的，但是它们的组合确实有效，希望能给大家提供一些参考价值。

算法优化

Recomputing the AlphaGo Zero weights will take about 1700 years on commodity hardware.

这句话来自 Leela Zero 项目的 README 文档。AlphaZero 本身的探索过程十分低效，但是利用精心设计的算法优化可以显著缩短其训练周期。KataGo 论文中的方法共同作用，可将训练效率提升 ~50x。下面介绍我使用的一些算法优化，其中部分来自 KataGo。

梯度累加

我们的游戏环境——Saiblo 四子棋的棋盘大小不固定，长宽均在 $[9,12]$ 区间内取值。因此共有 $16$ 种不同大小的棋盘。

为了适应不同的棋盘大小，做以下两点改进：

神经网络采用全卷积（FCN）架构³，策略头输出与输入状态大小保持一致。
从 replay buffer 中采样时，由直接采样 $256$ 个样本改为每种棋盘大小各采样 $16$ 个样本。对不同棋盘大小的样本各进行一次 forward pass，计算梯度并累加。然后正常 backward + step 即可。

KataGo 中采用的是 board masking 的方式适应不同输入，而这涉及到繁琐的细节实现。直接采用最简单的梯度累加来完成这一点，虽效率稍低但方便了许多。

动作空间剪枝

这个方法的动机非常简单：人工筛选掉可以被证明严格错误的着法，将其视为不合法动作，排除出 MCTS 计算。

实现只需非常小的代码更改，总结为两条规律：

我走一步棋直接赢，则必走；
对手走一步棋直接赢，则我必堵。

这种优化非常简单，却能显著加快训练前期探索，让模型迅速理解游戏规则。同时，这也能避免一些很糟糕的盲点，尤其是对手在棋盘边缘成三有可能会被 CNN 忽视。

First Play Urgency (FPU)

这项优化源自 Leela Zero。

细心的读者肯定会问：PUCT 计算时，若子节点没有访问即 $N(c)=0$，$V(c)$ 怎么定义？

AlphaGo Zero 给出了标准答案：$V(c)=0$。但 Leela Zero 社区讨论发现，这并不是最优选择。他们选择：

$$ V(c)=V(n)-c_\text{FPU}\sqrt{P_\text{explored}} $$

其中 $n$ 为父亲节点，常数 $c_\text{FPU}=0.2$，$P_\text{explored}$ 为访问过至少一次的子节点的策略先验概率总和：

$$ P_\text{explored}=\sum_{c'|N(c')>0} P(c') $$

读者可以自行思考这种做法的合理性。Lc0 的一个讨论指出，对于实力较强的神经网络，此法足以带来 ~200 Elo 的提升。

模拟上限随机化

对应 KataGo 论文中的 Playout Cap Randomization。

AlphaZero 中的两个输出头训练所需 playouts 并不相同。一些非正式研究表明，训练 policy head 最高效的模拟次数设置与 AlphaZero 的 $N=800$ 十分接近，但在 AlphaGo 的第一个版本中只用 $N=1$ 也能训练出较好的 value head。为了缓解二者的紧张关系，我们取一个较小的模拟次数 $n < N$，并以概率 $p$ 执行 fast search（$n$ 次模拟），其余情况正常 full search（$N$ 次模拟）。fast search 产生的样本不用于策略训练⁴。

我的超参数选择是 $(N,n)=(800,160)$，以及 $p=0.25$。个人感觉对于四子棋这种游戏，模拟次数再小一点应该也没事。

强制探索 & 策略剪枝

对应 KataGo 论文中的 Forced Playouts and Policy Target Pruning。

前面提到，为了增强探索，AlphaZero 在根节点处引入 Dirichlet noise。然而这种方式并不能保证好的着法一定能被发现。

设想下面这个场景：

游戏状态 $s_t$。当前的神经网络十分青睐着法 $a$，而实际最优着法为 $a^*$。在输出的策略分布中，$a$ 获得了高于 $80\%$ 的概率，$a^*$ 不到 $5\%$。
引入 Dirichlet noise。$a$ 的概率仍然很大，$a^*$ 被“选中”来到 $10\%$。假设此时 $P(a)$ 正好为 $80\%$。
MCTS 依次访问 $a$ 和 $a^*$。此时，价值网络仍不看好 $a^*$ 走到的状态 $s^*$，还是倾向于 $a$ 走到的状态 $s$，给出 $V(s^*)=-0.8$ 和 $V(s)=-0.1$。
现在的总模拟次数 $N=2$。根据 PUCT 公式可知 $\text{PUCT}(a)=0.34,\text{PUCT}(a^*)=-0.745$。这时二者 PUCT 值已经差距巨大，若 MCTS 不断选择 $a$ 进行访问并保持 $V(s)$ 不变，要到将近 $200$ 次模拟的时候才会使 $\text{PUCT}(a^*)\ge\text{PUCT}(a)$，此时 $1/4$ 的模拟次数已经被浪费了；并且如果 $a^*$ 再一次被给予差评，又要等上很长一段时间才能获得下一次访问。

由此可见，即使 Dirichlet noise 运气很好落在了正确的着法上，策略和价值网络共同的盲点仍然可能未被正确处理。故引入强制探索（Forced Playouts）机制，确保根节点的每个孩子都获得至少 $\lceil n_\text{forced} \rceil$ 次访问：

$$ n_\text{forced}(c)=\left(kP(c)\sum_{c'}N(c')\right)^{1/2} $$

沿用 KataGo 的设置，常数 $k=2$。

与此同时，为了消去 Dirichlet noise 和 Forced Playouts 共同带来的大量噪声，我们在 MCTS 完成后对 visit distribution 进行策略剪枝：

找到访问次数 $N(c)$ 最多的孩子 $c^*$。
对于其他子节点 $c$，减去尽可能多的访问次数，确保 $\text{PUCT}(a^*) > \text{PUCT}(a)$ 且减掉的次数不超过 $n_\text{forced}(c)$。

我这里选择直接使用不等式解出剪枝后的访问次数：

$$ N'(c)=\mathrm{clip}\left(\left\lceil\frac{P\sqrt N}{V+\text{PUCT}(c^*)}-1\right\rceil,N-n_\text{forced},N\right) $$

为了方便阅读，以上公式中直接用 $N$ 指代 $N(c)$，$P$ 指代 $P(c)$，etc.

以下使用/不使用策略剪枝的效果对比来自 KataGo 论文。黑：$p \approx 2\times 10^{-4}$；绿： $p \approx 1$。


使用策略剪枝	不使用策略剪枝

动态经验回放池

来自 KataGo 论文中 Appendix C: Training Details。

Off-policy 的强化学习算法中，经验回放池的大小（容纳样本数）大多是固定的，常设置在 $[2^{14},2^{20}]$ 区间内。而我们采取一种亚线性的增长策略：

$$ N_{\text{window}} = c \left( 1 + \beta \frac{ ( N_{\text{total}} / c ) ^ \alpha - 1} { \alpha } \right) $$

其中 $N_{\text{total}} $ 为当前训练过程生成的样本总数，$c=250000,\alpha=0.75,\beta=0.4$。这实际上就是对 $f(n)=n^\alpha$ 应用线性变换，使得 $f(c)=c$ 且 $f'(c)=\beta$。这样就能快速舍弃前期产生的低质量着法，并在后期增加训练样本多样性，有效抑制过拟合。

蒙特卡洛图搜索（MCGS）

见 KataGo/docs/GraphSearch.md。非常感谢 David Wu 提供的通俗易懂的讲解；我在做这个项目过程中还发现了其中一处 typo 并 PR 修复了 😆

整体思路：

对局面实现 Zobrist hash，扩展叶子时优先从哈希表中查找相同状态节点，搜索树变为 DAG；
依据 action edge（而不是 node）的访问次数来计算 PUCT；
反向传播过程采用增量更新：
$$ V(n) \larr \frac{1}{N(n)} \left(U(n)+\sum_c N(c)V(c)\right) $$
注意 $U(n)$ 表示价值网络给出的 utility estimate，是必不可少的。

实际操作中，MCGS 在内存回收方面会比较麻烦，好在 AlphaZero 产生的搜索树不是很大，所以我直接做一遍 DFS 清理。目前训练阶段还是使用 MCTS，推理使用 MCGS。

工程优化

由于项目代码是 100% Python，要达到资源的完全利用几乎不可能。不过还是有一些技巧可以提升训练效率的。

并行自对弈

这个 idea 很好理解，也可以应用到大部分主流强化学习算法上。使用多个进程并行在不同的 GPU 上收集训练数据，并将结果发送给主进程进行模型更新。

目前，我总共使用 $20$ 个不同的进程自对弈，均匀分配到 $4$ 张卡上运行。注意要使用 torch.multiprocessing 代替 Python 内置的 multiprocessing 模块。

CUDA Graphs

这也是一个比较通用的优化技巧，在很多机器学习应用中都可以使用。其原理是将整个计算图发送到 GPU 上执行，显著减少前/后端交互和 kernel 启动开销 ⁵。对于较小的网络和 batch_size，CUDA Graph 可以带来意料之外的速度提升。

项目根目录下提供了（简陋的）benchmark 脚本，在单张 RTX 4090 上测试结果如下（batch_size=1 模拟 self-play 环境）：

类别	推理方法	计算速度（FPS）
Base	`torch.no_grad`	$249.1$
Base	`torch.inference_mode`	$265.9$
TorchScript	`torch.jit.script`	$271.5$
TorchScript	`torch.jit.trace`	$501.4$
CUDA Graphs	`torch.cuda.graph`	$3184.5$

另外 torch.compile(mode='reduce-overhead') 也可以实现基于 CUDA Graph 的推理。不过这个 API 不支持 Windows，且编译耗时，没有 torch.cuda.graph 用的舒服。

测试结果

训练持续约 $14$ 天，共 $30000 \times 16$ 次迭代。首先是训练过程的 Loss、Entropy（策略熵）和 episode_len（自对弈棋局长度）曲线：

loss 和 entropy 前期快速下降，后期趋于稳定（不会向 $0$ 收敛是由于数据分布在不断改变）；episode_len 前期提升，后期略有下降（可能是因为找到了更快的杀棋走法）。总体来说符合直觉，没有出现什么不同于预期的表现。

下面是 ELO⁶ 评分曲线，体现真实棋力：

整体来看训练过程十分稳定（近似亚线性增长），最终训练基本饱和。

解决相同任务的最优传统方法在相同算力下对 katac4 的最佳检查点只有约 $26\%$ 的胜率，对应 -182 ELO 分差。画在图上可以看出，我们只用 $1/4$ 的迭代次数（$3$ 天训练）就达到了与之相当的水平。

实际上这个估计并不准确——Epoch 6500 的检查点也能对其取得超过 $50\%$ 的胜率。上图仅供参考。

我非常感激这位前辈能在最近开源出他的方法；在项目开发前期，我一直很好奇他为什么能在榜上遥遥领先。前两天看了他的项目报告，真没想到传统方法用 PUCT 也比 UCT 效果更好。说实话，不让我用神经网络，估计连总榜第一页都进不去。

附上对战 Saiblo 平台样例 AI 的测试结果：

这个结果有时跑不出来，会 TLE。最强的 checkpoint 除了 TLE 之外从来就没输过（测了 $6\times100$ 场）。平台上只有 CPU，因此推理方案用的是 TorchScript。然而 import torch 和 torch.jit.load 都需要时间开销，评测机负载比较大的时候可能还没加载完模型就 TLE 了，这个我真的无能为力。（叹气）

给平台几个建议：

支持 LibTorch，这样我可以用 C++ 写推理，排除掉 import 时间；
提供一些轻量化的推理框架（比如 ONNX Runtime），也可以缓解加载缓慢问题。
再退一步，可以适当放宽第一步的时间限制……

另外我还搞了一个娱乐性的版本 fastc4，直接选择神经网络输出概率最大的着法。这个版本其实也不赖：

对样例 AI 胜率 $97\%$；
对 jiegec/FourChess 胜率 $65\%$；
对 frvdec（前榜二）胜率 $48\%$；
对 Lionjump0723/connect4（前榜一）胜率 $45\%$。

手动观察了一些对局，感觉神经网络更在乎长期收益——它们会为未来很多步规划，而不在乎局部得失。传统方法则天然侧重于短期算杀，而在无明显杀棋时就显得弱势很大。我的 AI 输给其他 AI 经常是在前 $25$ 步因为杀棋盲点被秒掉，但到 $50$ 步以后，局面几乎完全落入它的的控制中，传统算法由于前期规划失误后期根本无能为力。这有点类似于国际象棋引擎中 Stockfish 和 Leela Chess Zero 的区别——前者精打细算，后者更依赖直觉。

希望这些 insight 能为后续传统方法 AI 的开发提供一些帮助，也欢迎大家在平台上与 katac4 对局、测试：

katac4（Epoch 29000）：96c96ac2389547958141d932d9279efc
katac4（Epoch 30000）：2c9bd80e1e0e480a8f32214448880a62
katac4（Epoch 6500）：d4e85acaf1ab4025b3c6a7ebec4fd0f0
fastc4（Epoch 29000）：941dafdce03640bfb7ceb3aa32613252

后续改进方向

现在主要问题有二：

硬件利用效率低；
模型前期盲点多。

后续会考虑将不同自对弈对局中的叶子状态合并到一个大 batch 中，应该能基本解决问题一；

对于问题二，除了扩大模型规模（预计下一个模型为 b5c128nbt）之外，还有一些有待实现的算法优化：

添加辅助策略头（对手下一步策略分布、棋局最后落子点、soft policy）帮助训练；
优化棋盘状态表示（前面更多手的落子位置、棋子成二成三的位置等）；
Playout Cap Randomization 的 fast game policy sample 要弃掉；
正比于 $D_\mathrm{KL}(\hat{\boldsymbol\pi}||\boldsymbol\pi)$ 进行 importance sampling，重点训练预测错误的位置；
Batch Norm 替换成 Batch Renorm，防止模型训练和推理的行为不一致。

这个暑假如果有空会来实现一些。各位若有兴趣也可以 PR 实现改进。随时欢迎！

拓展阅读

游戏规则见文档。 ↩︎
原版 AlphaZero 中直接预测局面价值 $V(s_t) \in [-1,1]$ 并使用 MSE Loss，这里沿用了 KataGo 和 Leela Zero 的改进做法。 ↩︎
神经网络设计也参考了 KataGo，使用了全局池化（Global Pooling）和 Nested Bottleneck Residual Nets。现在的版本命名为 b3c128nbt，表示 $3$ 个 $128$ 通道的 nested bottleneck 残差块。出于篇幅考虑，这里不具体介绍模型方面的设计优化，感兴趣的读者可自行翻阅代码。 ↩︎
我的代码实现没有做到这一点，看起来影响并不大。不过把它们去掉应该是更好的选择，后续计划测试。 ↩︎
Accelerating PyTorch with CUDA Graphs – PyTorch ↩︎
Elo rating system - Wikipedia ↩︎

Mathematica 入门

Fri, 26 Jan 2024 17:12:00 +0800

前言

Wolfram Mathematica（简称 MMA），是由 Wolfram Research 开发的科学计算软件。本文我们将介绍 Mathematica 的界面、语法和基本应用。类似的软件还有 MATLAB 和 Maple 等。

MMA 官网：https://www.wolfram.com/mathematica/

MMA 的安装及激活：Mathematica安装激活极简教程 - 科研小飞 (知乎)

本文适合有一定编程基础的读者。当然，如果你不了解编程也没关系，直接跳过相关部分即可。屏幕截图全部来自 Windows 11，Mathematica 13.3。（最新版本 14.0 已经在 2023 年 12 月发布，语法向下兼容）

界面

安装并正确激活 MMA 后，新建笔记本，应该能看到如下的界面：

一张图带你快速熟悉 MMA 的界面：

几个需要注意的点：

Enter 默认换行，执行代码需要用 Shift+Enter。
指令面板左侧的红三角形也可执行代码，灰色的正方形用于终止正在进行的运算。
MMA 带有 Notebook（笔记本）功能，由于其主要用于计算而不是笔记，本文不详细介绍，若需要使用可自行查阅相关资料。

对于任意输入或输出，按下Ctrl+Shift+I即可显示输入（代码）形式，按下Ctrl+Shift+N即可显示数学形式。后面会对两种显示形式进行详细讲解。

语法

Mathematica 实质是一个 Wolfram Language 的解释器，所以使用它之前必须学习 WL 的语法。
这里介绍基本语法和常用的指令。

帮助文档

首先来了解帮助文档的使用。输入 ? Solve 来获取 Solve 函数的说明：

? 后面可以跟任何函数名，MMA 会直接在笔记本中输出简化版的帮助文档。可以选择输出右上角的 i 来获取更详细的文档（优先打开离线文档，不存在则默认打开在线文档）。菜单栏中的 “帮助 -> Wolfram 参考资料” 可以打开完整版文档。

注释

1

(* 注释 *)

如上，MMA 的注释使用 (* 和 *) 来标注，用法类似于 C/C++ 中的 /* 和 */。注释可以添加在代码的任何位置，它们会被自动忽略。例如：

1
2


1 + 1 (*Hello*)
1 + (*World*)1 

这两行代码在实际执行中与 1 + 1 无区别：

括号

在学习 MMA 的函数之前，一定要先学会括号的使用！！
官方参考文档：正确使用括号和大括号

MMA 中共有四种括号，分别为 ()、[]、{} 和 [[]]，具体作用如下：

圆括号 `()`

用作对表达式编组和确定运算的优先次序：

方括号 `[]`

表示函数的调用和传参：

大括号 `{}`

表示列表：

列表的具体使用后续会介绍。

双方括号 `[[]]`

表示对列表元素的访问，实质是函数 Part 的简写形式：

同样会在后面具体介绍。

运算与表达式

MMA 支持基本的数学运算，见下表：

名称	符号形式	函数形式	数学形式
加法	`a + b`	`Plus[a, b]`	$a+b$
减法	`a - b`	`Subtract[a, b]`	$a-b$
乘法	`a * b`¹	`Times[a, b]`	$a\times b$
除法	`a / b`	`Divide[a, b]`	$\frac ab$
幂	`a ^ b`	`Power[a, b]`	$a^b$
模余	-	`Mod[a, b]`	$a\bmod b$

数字和符号都可以参与运算：

表达式是一个或多个运算/函数调用的组合，使用()指定优先级。上图中 4*5、a+a、3 x y/y 都是合法的表达式。

需要注意的是，MMA 只会对输入的表达式进行约分、合并同类项，而不会自动执行需要展开的化简。必要时可以使用 Simplify 或 FullSimplify 函数：

关于函数的使用，后面会详解。

布尔表达式

表达式也可以是等式或不等式：

注意等式用两个等号 == 连接，单个等号表示变量赋值。
不等式可以用 !=（不等于）、>（大于）、>=（大于等于）、<（小于）、<=（小于等于）连接。!=、>= 和 <= 在输入时会自动转换为相应的数学符号。

这类返回值为 True（真）或 False（假）的表达式，我们统称为布尔表达式。可以用 && 和 || 运算符来连接两个布尔表达式，分别表示“与”“或”，所得结果仍为布尔表达式。

绝大部分布尔表达式都不能自动化简，但可以通过 Simplify、FullSimplify 或 Solve、Reduce 来化简或求解：

变量与常数

MMA 中，使用 变量名 = 值 的形式来声明或赋值变量：

由上方 10a + 3 的计算结果可知，表达式中所有已声明的变量都会被替换成变量值。变量的声明也可以包含其他变量和符号，此时仍符合变量替换法则：

用于解方程的 Solve 函数没有返回 $a$ 的解，而是返回 $x$ 的解，说明表达式在解析时 $a$ 被自动替换为了 $x$。

除此之外，还可以用类似于 Python 的语法，同时赋值多个变量：
1
{a, b, c} = {1, 2, 3}
这行代码可以把变量 $a,b,c$ 分别赋值为 $1,2,3$。

若要取消声明一个变量，可以使用 Clear[变量名]：

在使用 MMA 的过程中，我们会发现某些特定符号不能声明为变量，且有一个固定不变的值。这些是内置常量：

常量	名称	近似值	数学形式
`Pi`	圆周率	$3.141592654$	$\pi$
`E`	自然常数	$2.718281828$	$\mathrm e$
`I`	虚数单位	-	$i$
`Infinity`	无穷大	-	$\infty$
`Degree`	度	-	$\degree$

函数

在前面的讲解中，我们多次提到函数。现在，让我们详细解读函数的使用。

调用

要调用一个函数，只需输入 函数名[参数1, 参数2, ...] 即可：

对于只有一个参数的函数，可以用 参数 // 函数名 的形式调用。这种形式常用于 Simplify（化简）、FullSimplify（完全简化）和 N（数值运算）的调用：

这种写法的最大优点在于可以链式调用：

定义

说完了函数的调用，再来说说新函数的定义。

MMA 中，定义新函数的语法为 函数名[参数1_, 参数2_, ...] := 返回值。注意每个参数名后面都要加一个下划线（_）。

定义新函数推荐用 :=，但使用 = 也可行。

拓展 - 定义递归函数
参考下面定义斐波那契数列的格式：

内置函数

MMA 中有将近 $6000$ 个内置函数²，它们都以大写字母开头。下面介绍几种常用的内置函数：

数值运算 N

数值运算函数 N：

N[expr] 给出 $\mathrm{expr}$ 的数值值
N[expr, n] 尝试给出具有 $n$ 位精度的结果

使用示例：

三角函数

MMA 内置了各类三角函数，它们全部使用习惯名称且首字母大写（Sin、Sinh、ArcSin），这里不一一阐释。
只说一个注意点，MMA 中三角函数的参数默认是弧度，若要使用角度必须加上 Degree 单位：

解方程和不等式 Solve/Reduce

解方程 Solve：

解不等式用 Reduce：

Reduce 还有更高级的使用，可以约化各种表达式：

这句话说的是：求解 $a,b$ 的范围，使得存在 $x$ 满足等式 $ax=b$。实际上就是在求解使一元一次方程有解的参数值。注意 Solve 和 Reduce 不一定总返回最简形式的表达式，很多情况下需要手动调用 Simplify 或 FullSimplify 进行化简。感兴趣的读者可以自行测试上面的例子中不使用 Simplify 的返回结果。

解方程的其他方法 NSolve/FindInstance

NSolve 用法同 Solve，但会返回数值解而不是精确解。相当于 Solve[...] // N。
FindInstance 用法同 Solve，但添加了一个参数表示至多返回解的个数（默认为 $1$）：

极点值 Maximize/Minimize

Minimize 返回函数（在限制条件下）的最小值以及取到最小值的（一种）变量值：

如上图中的示例，Minimize 支持多个变量，可以指定条件，也可指定求解域。
Maximize 用法完全相同，返回最大值，此处略过。

偏导 D

偏导 D 的两种最常用用法：

D[f, x] 给出 $f$ 关于 $x$ 的偏导。
D[f, {x, n}] 给出 $f$ 关于 $x$ 的 $n$ 阶偏导。

示例略。注意 f'[x] 可以直接求出 f[x] 的导数：

积分 Integrate

积分 Integrate：

Integrate[f, x] 给出不定积分 $\int f~\mathrm{d}x$。
Integrate[f, {x, x_min, x_max}] 给出定积分 $\int_{x_{min}}^{x_{max}} f~\mathrm{d}x$。
Integrate[f, {x, x_min, x_max}, {y, y_min, y_max}, ...] 给出多重积分 $\int_{x_{min}}^{x_{max}} \mathrm{d}x \int_{y_{min}}^{y_{max}} \mathrm{d}y\dots f$。

一个简单的定积分示例：

展开 Expand/ExpandAll

Expand 很好理解，Expand[expr] 会展开表达式 $\mathrm{expr}$ 中的乘积和正整数幂。限于篇幅，这里不提供使用范例，可参考官方文档。
ExpandAll 在 Expand 的基础上，会展开表达式中任意位置的乘积和整数幂。如表达式 Sin[(1 + x)^3]，Expand 不会展开其中的 (1+x)^3，而 ExpandAll 会。

因式分解 Factor

Factor[poly]：在整数上对一个多项式分解因式。使用示例参考官方文档。

绘图 Plot/Plot3D

Plot 和 Plot3D 的用法较为复杂，这里只介绍最基本的函数绘图：

两个语句分别绘制：

$\sin(x)$ 的图像，其中 $-2\pi\le x\le 2\pi$；
$\sin(x+y^2)$ 的图像，其中 $-3\le x\le 3$，$-2\le y\le 2$。

总结

我自己当初学习 MMA 时，被网上杂乱的教程搞得混乱不堪。因此就想写一篇教程，涵盖所有常用语法知识点，并让初学者避开我自己踩的一些坑。
初衷是写个简明的教程，结果一写就是八千多字…… 也感谢认真读到这里的读者们！
后续可能还会更一些用 Mathematica 解决数学和实际问题的文章，敬请期待！

乘法也可简写为 a b（中间必须有空格）。MMA 中，大部分空格可省略，但是乘法的空格不能省略（若写作没有空格的 ab 会被认为是一个变量）。 ↩︎
https://www.wolfram.com/language/fast-introduction-for-programmers/en/built-in-functions/ ↩︎

UNIQUE VISION Programming Contest 2023 Christmas (AtCoder Beginner Contest 334) A~G 题解

Sun, 24 Dec 2023 12:05:00 +0800

A - Christmas Present

题目大意

给定两个正整数 $B,G$（$1\le B,G\le 1000$ 且 $B\ne G$），判断哪个更大。

分析

模拟即可。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 int b, g;
 scanf("%d%d", &b, &g);
 puts(b > g? "Bat": "Glove");
 return 0;
}

B - Christmas Trees

题目大意

给定 $A,M,L,R$。
对于任意整数 $k$，Snuke 都会在数轴上的 $A+kM$ 处放置一棵圣诞树。
试问区间 $[L,R]$ 中共有多少棵圣诞树？

$-10^{18}\le A\le 10^{18}$
$1\le M\le 10^9$
$-10^{18}\le L\le R\le 10^{18}$

分析

不难发现，对于任意整数 $x$，数轴上 $x$ 处有圣诞树当且仅当 $x \equiv A \ (\bmod \ M)$。变形可得 $x-A \equiv 0 \ (\bmod \ M)$，即 $(x-A) \mid M$。故只需考虑相对于 $A$ 的坐标，所以统计 $[L-A,R-A]$ 中 $M$ 的倍数数量即可。

代码

使用 C++ 语言时，注意正确处理负数的情况。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <cstdio>
using namespace std;

using LL = long long;

int main()
{
 LL a, l, r;
 int m;
 scanf("%lld%d%lld%lld", &a, &m, &l, &r);
 l -= a, r -= a;
 if(l < 0) l = -((-l) / m * m);
 else l = (l + m - 1) / m * m;
 if(r < 0) r = -((-r + m - 1) / m * m);
 else r = r / m * m;
 printf("%lld\n", (r - l) / m + 1);
 return 0;
}

C - Socks 2

题目大意

有长为 $2N$ 的序列 $S=(1,1,2,2,\dots,N,N)$。
给定 $A=(A_1,\dots,A_K)$，将 $S$ 中数字 $A_1,\dots,A_K$ 各拿掉一个，剩余 $2N-K$ 个。
对这 $2N-K$ 个数进行两两组合（可能剩余 $1$ 个），使得每对数之差的绝对值之和最小。输出这个最小和。

$1\le K\le N\le 2\times 10^5$
$1\le A_1 < A_2 < \dots < A_K\le N$

分析

首先，可以证明我们一定会将 $N-K$ 个成双的数字进行自我组合。

简要证明
采用 反证法。假设有两个 $a$，我们将它们分别与 $b,c$ 组合。显然：
$$|a-b|+|a-c| \ge |a-a|+|b-c|$$
于是，将 $a,a$ 组合、$b,c$ 组合的方案一定不比原方案差。因此直接组合 $a,a$，一定能得到最优解。

由于 $|a-a|=0$，所以这部分可以直接忽略，将单个的数字，即 $A_1,\dots,A_K$ 进行组合即可。

分两种情况讨论。

$K$ 为偶数：此时组合没有剩余。不难发现，相邻两两组合即为最优解，所以答案为：
$$\mathrm{ans}=\sum_{i=1}^{k/2} A_{2i}-A_{2i-1}$$
直接计算即可。注意 $A$ 已排序，故无需取绝对值。
$K$ 为奇数：此时组合剩余一个。枚举此剩余的数，从 $A$ 中删去就转换成了偶数的情况。但是暴力计算的时间复杂度为 $\mathcal O(K^2)$，维护前缀后缀和即可优化到 $\mathcal O(K)$。

综上，我们在 $\mathcal O(K)$ 的时间内解决了此问题。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


#include <cstdio>
#define maxn 200005
using namespace std;

inline void setmin(int& x, int y)
{
 if(y < x) x = y;
}

int a[maxn], pre[maxn], suf[maxn];

int main()
{
 int n, k;
 scanf("%d%d", &n, &k);
 for(int i=1; i<=k; i++)
 scanf("%d", a + i);
 if(!(k & 1))
 {
 int ans = 0;
 for(int i=1; i<=k; i+=2)
 ans += a[i + 1] - a[i];
 printf("%d\n", ans);
 return 0;
 }
 for(int i=1; i<k; i+=2)
 pre[i] = pre[i + 1] = pre[i - 1] + a[i + 1] - a[i];
 for(int i=k-1; i>0; i-=2)
 suf[i] = suf[i + 1] = suf[i + 2] + a[i + 1] - a[i];
 int ans = 1e9;
 for(int i=1; i<=k; i++)
 {
 int cur = i & 1? pre[i - 1] + suf[i + 1]
 : a[i + 1] - a[i - 1] + pre[i - 2] + suf[i + 2];
 setmin(ans, cur);
 }
 printf("%d\n", ans);
 return 0;
}

D - Reindeer and Sleigh

题目大意

有 $N$ 个雪橇，编号为 $1,2,\dots,N$。拉动第 $i$ 个雪橇需要 $R_i$ 只驯鹿。

给定 $Q$ 次询问，每次给定正整数 $X$：

$X$ 只驯鹿最多能拉动多少个雪橇？

注意：雪橇可以任选，每只驯鹿最多只能拉一个雪橇。

$1\le N,Q\le 2\times 10^5$
$1\le R_i\le 10^9$
$1\le X\le 2\times 10^{14}$

分析

首先，为了拉到最多的雪橇，我们考虑贪心的策略：从 $R_i$ 最小的雪橇开始拉，从小到大直到驯鹿不够用为止。

因此我们先对 $R_i$ 进行排序，很明显这不影响结果。此时令前缀和 $S_i=\sum_{j=1}^i R_j$，则当 $S_i \le X$ 时，可以拉动前 $i$ 个雪橇。故只需找到最大的 $i$ 使得 $S_i\le X$ 即为所求。此时注意到前缀和已经有序，所以直接在 $S$ 上使用二分查找即可。

总时间复杂度为 $\mathcal O(N\log N)$。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


#include <cstdio>
#include <algorithm>
#define maxn 200005
using namespace std;

using LL = long long;
LL s[maxn];

int main()
{
 int n, q;
 scanf("%d%d", &n, &q);
 for(int i=0; i<n; i++)
 scanf("%lld", s + i);
 sort(s, s + n);
 for(int i=1; i<n; i++)
 s[i] += s[i - 1];
 while(q--)
 {
 LL x;
 scanf("%lld", &x);
 printf("%d\n", int(upper_bound(s, s + n, x) - s));
 }
 return 0;
}

E - Christmas Color Grid 1

题目大意

有一个 $H\times W$ 的网格，其中.代表红色，#代表绿色。

随机选一个红色方块，将其涂成绿色。将网格抽象成一张简单无向图，边连接相邻（上下左右）的绿色节点。
图中连通分量个数的期望值是多少？对 $998244353$ 取模。

$1\le H,W\le 1000$

分析

暴力算法的时间复杂度是 $\mathcal O(H^2W^2)$，显然不满足要求。

考虑将一个红色方块涂成绿色对绿色连通分量数的贡献。令它周围属于不同连通分量的绿色方块个数为 $n$，则此次操作会将答案减去 $n-1$。这样，我们先预处理出连通分量，就可以 $\mathcal O(1)$ 的计算答案。

此问题可以用 DFS、BFS 或并查集解决。示例代码使用并查集，时间复杂度约为 $\mathcal O(HW)$（忽略小函数）。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53


#include <cstdio>
#include <unordered_map>
#include <set>
#include <atcoder/modint>
#define maxn 1005
using namespace std;

using modint = atcoder::modint998244353;

int n, m, fa[maxn * maxn];
char s[maxn][maxn];

int find(int x) { return fa[x] == x? fa[x]: fa[x] = find(fa[x]); }
inline int calc(int x, int y) { return x * m + y; }
inline int fc(int x, int y) { return find(calc(x, y)); }
inline void merge(int x, int y) { fa[find(x)] = find(y); }

int main()
{
 scanf("%d%d", &n, &m);
 for(int i=0; i<n; i++)
 scanf("%s", s[i]);
 int k = n * m;
 for(int i=0; i<k; i++)
 fa[i] = i;
 for(int i=0; i<n; i++)
 for(int j=0; j<m; j++)
 {
 if(s[i][j] != '#') continue;
 if(i && s[i - 1][j] == '#') merge(calc(i, j), calc(i - 1, j));
 if(j && s[i][j - 1] == '#') merge(calc(i, j), calc(i, j - 1));
 }
 int cnt = 0, tot = 0;
 for(int i=0; i<n; i++)
 for(int j=0; j<m; j++)
 if(s[i][j] == '#' && fc(i, j) == calc(i, j))
 cnt ++;
 modint ans = 0;
 for(int i=0; i<n; i++)
 for(int j=0; j<m; j++)
 if(s[i][j] == '.')
 {
 set<int> S;
 if(i && s[i - 1][j] == '#') S.insert(fc(i - 1, j));
 if(s[i + 1][j] == '#') S.insert(fc(i + 1, j));
 if(j && s[i][j - 1] == '#') S.insert(fc(i, j - 1));
 if(s[i][j + 1] == '#') S.insert(fc(i, j + 1));
 int cur = cnt - (int)S.size() + 1;
 ans += cur, tot ++;
 }
 printf("%d\n", (ans / tot).val());
 return 0;
}

F - Christmas Present 2

题目大意

圣诞老人 Santa 要在平面直角坐标系中给孩子们送礼物啦！

他的家在 $(S_X,S_Y)$ 处。他要按照数字顺序给 $N$ 个孩子送出礼物。第 $i$ 个孩子的家在 $(X_i,Y_i)$ 处。

Santa 手上最多只能一次性拿 $K$ 个礼物。他想用最短的路程送完所有礼物，再回到自己家，求最短的总路程是多少？

$1\le K\le N\le 2\times 10^5$
$-10^9\le S_X,S_Y,X_i,Y_i \le 10^9$
$(S_X,S_Y)\ne (X_i,Y_i)$
$(X_i,Y_i)\ne (X_j,Y_j)\ (i\ne j)$

分析

这里介绍我自己的独具特（chōu）色（xiàng）的解法，常规解法请参考官方题解。

考虑 dp，令 $f_{i,j}$ 表示走到第 $i$ 个房子并送完前 $i$ 个礼物时，手上剩余 $j$ 个礼品的最短路程。很显然，我们每次回家都一定拿满 $K$ 个礼品，则 $j=k-1$ 一定是拿了礼品之后送出一个。故：

$$ f_{i,j}=\begin{cases} d(i-1,i)+f_{i-1,j+1} & (j < k-1)\\ \min f_{i-1}+d(i-1,0)+d(0,i) & (j=k-1) \end{cases} $$

其中 $d(a,b)$ 表示房子 $a$ 到 $b$ 的路程。特别规定 $0$ 号房子为 $(S_X,S_Y)$，即圣诞老人的住处。这样，答案即为 $\min f_n+d(n,0)$。

直接计算的复杂度为 $\mathcal O(NK)$，时间和空间上都不能接受。

然而，仔细观察递推式可以发现，$f_i$ 这一行实际上就是由前一行 $f_{i-1}$ 删去第一个元素，再整体加 $d(i-1,i)$，并在最后添上 $f_{i,k-1}$ 得到的。

因此，我们可以用一个deque（双端队列）动态维护状态。对于整体加的操作，用一个变量维护整体的变化值即可。这样空间的问题就得到了解决。再进一步考虑，用一个multiset（可重集合，基于红黑树）或者二叉堆维护队列内元素，求 $\min$ 的操作时间就减小到了 $\mathcal O(\log K)$，可以接受。

于是，我们就成功地在 $\mathcal O(N\log K)$ 的时间和 $\mathcal O(N+K)$ 的空间内解决了此问题。另外，我们还可以把deque同时充当单调队列，这样时间也优化到了 $\mathcal O(N+K)$。两种实现的示例代码都会给出。

代码

实现 1：deque + multiset

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


#include <cstdio>
#include <deque>
#include <set>
#define maxn 200005
using namespace std;

using ld = long double;
const ld INF = 2e18l;

int x[maxn], y[maxn];

inline ld dis(int i, int j)
{
 return __builtin_hypotl(x[i] - x[j], y[i] - y[j]);
}

int main()
{
 int n, k;
 scanf("%d%d", &n, &k);
 for(int i=0; i<=n; i++)
 scanf("%d%d", x + i, y + i);
 deque<ld> f;
 multiset<ld> s;
 k --;
 for(int i=0; i<k; i++)
 f.push_back(INF), s.insert(INF);
 f.push_back(dis(0, 1)), s.insert(dis(0, 1));
 ld dt = 0;
 for(int i=2; i<=n; i++)
 {
 ld lt = *s.begin() + dis(i - 1, 0) + dis(0, i) + dt;
 s.erase(s.find(f.front())), f.pop_front();
 dt += dis(i - 1, i), lt -= dt;
 f.push_back(lt), s.insert(lt);
 }
 printf("%.15Lf\n", dt + *s.begin() + dis(n, 0));
 return 0;
}

实现 2：单调队列

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#include <cstdio>
#include <deque>
#define maxn 200005
using namespace std;

int x[maxn], y[maxn];

inline double dis(int i, int j)
{
 return __builtin_hypotl(x[i] - x[j], y[i] - y[j]);
}

int main()
{
 int n, k;
 scanf("%d%d", &n, &k);
 for(int i=0; i<=n; i++)
 scanf("%d%d", x + i, y + i);
 deque<pair<double, int>> f;
 f.emplace_back(dis(0, 1), 1);
 double dt = 0;
 for(int i=2; i<=n; i++)
 {
 double lt = f.front().first + dis(i - 1, 0) + dis(0, i) + dt;
 if(f.front().second == i - k) f.pop_front();
 dt += dis(i - 1, i), lt -= dt;
 while(!f.empty() && f.back().first >= lt) f.pop_back();
 f.emplace_back(lt, i);
 }
 printf("%.15lf\n", dt + f.front().first + dis(n, 0));
 return 0;
}

G - Christmas Color Grid 2

题目大意

有一个 $H\times W$ 的网格，其中.代表红色，#代表绿色。

随机选一个绿色方块，将其涂成红色。将网格抽象成一张简单无向图，边连接相邻（上下左右）的绿色节点。
图中连通分量个数的期望值是多少？对 $998244353$ 取模。

$1\le H,W\le 1000$

E 与 G 的区别

E：将红色涂成绿色。求绿色连通块个数。

G：将绿色涂成红色。求绿色连通块个数。

分析

注意到本题中红色方块没有任何实质意义，于是先将绿色方块建成一张图。此时题目变为：

从简单无向图中随机选取一个结点，将此结点和与其相连的边全部删除。求连通分量个数的期望值，对 $998244353$ 取模。

根据“删去无向图中一个点导致连通分量个数改变”，很容易联想到割点。对求割点的 Tarjan 算法稍加改编，就可以计算删去一个点能把图分割成的连通块个数。详见代码。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66


#include <cstdio>
#include <vector>
#include <atcoder/modint>
#define maxn 1000005
using namespace std;

using modint = atcoder::modint998244353;

inline void setmin(int& x, int y)
{
 if(y < x) x = y;
}

vector<int> G[maxn];

inline void add(int x, int y)
{
 G[x].push_back(y);
 G[y].push_back(x);
}

int root, low[maxn], cnt, dfn[maxn], ncut[maxn];

void tarjan(int v)
{
 low[v] = dfn[v] = ++cnt;
 ncut[v] = v != root;
 for(int u: G[v])
 if(!dfn[u])
 {
 tarjan(u);
 if(low[u] >= dfn[v])
 ncut[v] ++;
 setmin(low[v], low[u]);
 }
 else setmin(low[v], dfn[u]);
}

char s[1005][1005];
int id[1005][1005];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 for(int i=1; i<=n; i++)
 scanf("%s", s[i] + 1);
 int num = 0;
 for(int i=1; i<=n; i++)
 for(int j=1; j<=m; j++)
 if(s[i][j] == '#')
 {
 id[i][j] = ++num;
 if(s[i - 1][j] == '#') add(num, id[i - 1][j]);
 if(s[i][j - 1] == '#') add(num, id[i][j - 1]);
 }
 int cc = -1;
 for(int i=1; i<=num; i++)
 if(!dfn[i])
 tarjan(root = i), cc ++;
 modint ans = 0;
 for(int i=1; i<=num; i++)
 ans += cc + ncut[i];
 printf("%d\n", (ans / num).val());
 return 0;
}

后记

首先预祝大家圣诞节快乐 🎉！这场比赛从标题到题目设定，无不与圣诞节有关，AtCoder 官方算是精心准备了这场圣诞庆祝赛 💝。

遗憾的是我在比赛中先做了 A~E 和 G，F 题比赛结束后 51s 提交，AC。挺可惜的，难得 G 能做出来一次，差点 AK，结果差的就是不到一分钟 😂。希望下次能比得更好，也希望大家能再接再厉。加油！😚

洛谷 P9754 [CSP-S 2023] 结构体题解

Sat, 02 Dec 2023 22:21:00 +0800

题目传送门
 洛谷博客博客园

基本思路

本题主要考查编码能力，所以直接给出基本思路：

由于可以递归式的创建元素，最多可以同时存在 $100^{100}$ 个不同的基础类型的元素。即使算上最大地址的限制，元素的数量也能达到 $10^{18}$。显然，依次构造每个元素，在空间和时间上都是无法接受的。
然而，由于询问数量有限，真正能在查询时用到的元素数量相对很少。因此，我们只需维护一个顶层元素（不隶属于任何其他元素的元素）列表，再根据查询的地址或名称逐层向下找到需要的元素即可。以下是四种操作的具体做法：
- 对于 $op=1$：储存当前类型信息，计算大小和对齐要求并输出。
- 对于 $op=2$：用一个变量记录当前第一个可分配内存的地址，操作时先对齐后计算、输出。
- 对于 $op=3$：从顶层开始，逐层向下寻找，计算地址并输出。
- 对于 $op=4$：从顶层开始，维护当前考查的元素地址，并与给定地址比对，最终输出底层元素名称。

由以上思路，很容易想到下面三种类型的存储方式：

用类型名称作为类型的唯一的标识符。这是最直观的做法，但是效率低下且使用起来较为繁琐，pass。
用 map 将类型名称映射到序号，来代表一种数据类型。相比第一种做法，效率高了很多，但是写起来仍然很麻烦，pass。
用结构体存储类型信息，并使用指针来处理类型之间的关联。这种做法不仅高效，而且编码时也很直观，所以我们将采用这种存储方式。

分步详解

准备

用 LL 表示 long long，setmax(x, y) 等同于 x = max(x, y)：

1
2
3
4
5
6


inline void setmax(int& x, int y)
{
 if(x < y) x = y;
}

using LL = long long;

数据类型的存储

定义 struct DataType，表示一种数据类型：

1
2
3
4
5
6
7


struct DataType
{
 const string name; // 类型名
 LL size, actual_size; // 对齐后的大小和实际大小（有数据的部分的长度）
 int indent; // 对齐要求
 vector<pair<DataType*, string>> members; // 类型成员，<成员类型指针，成员名称> 方式存储
};

对齐操作，依照如下公式：

$$ {对齐后的地址} = \lceil \frac {对齐前的地址} {对齐要求} \rceil \times {对齐要求} $$

1
2
3
4


inline LL shift(LL addr)
{
 return addr % indent? (addr / indent + 1) * indent: addr;
}

维护操作，用于操作 $1$ 后计算大小：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


inline void maintain()
{
 size = indent = 0;
 for(const auto& m: members)
 {
 setmax(indent, m.first->indent);
 size = m.first->shift(size) + m.first->size;
 }
 actual_size = size;
 size = shift(size);
}

注意 shift 和 maintain 都是 DataType 的成员函数。

主函数中，用一个 unordered_map 记录类型名到数据类型的映射关系：

1

unordered_map<string, DataType*> types;

添加基本类型：

1
2
3
4
5
6
7
8
9


auto add_base_type = [&](string name, int size) -> void {
 DataType* t = new DataType(name);
 t->size = t->indent = t->actual_size = size;
 types[name] = t;
};
add_base_type("byte", 1);
add_base_type("short", 2);
add_base_type("int", 4);
add_base_type("long", 8);

操作 1：定义类型

由于 DataType 中已经实现维护操作，简单处理一下输入即可：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


string s;
int k;
cin >> s >> k;
DataType* type = new DataType(s);
types[s] = type;
type->members.resize(k);
for(auto& m: type->members)
{
 string t;
 cin >> t >> m.second;
 m.first = types[t];
}
type->maintain();
cout << type->size << ' ' << type->indent << '\n';

操作 2：定义元素

根据「基本思路」中给出的做法，维护当前第一个可分配的地址和顶层元素列表：

1
2


LL cur_addr = 0LL;
vector<Object> toplevel_objects;

Object 的定义：

1
2
3
4
5
6


struct Object
{
 DataType* type; // 类型
 string name; // 名称
 LL addr; // 地址
};

计算地址并保存元素：

1
2
3
4
5
6
7


Object obj;
string t;
cin >> t >> obj.name; // 输入
obj.type = types[t]; // 找到类型指针
obj.addr = obj.type->shift(cur_addr); // 对齐
cur_addr = obj.addr + obj.type->size; // 更新可分配的地址
toplevel_objects.push_back(obj); // 保存元素

输出元素地址：

1

cout << obj.addr << '\n';

操作 3：访问元素

定义一个辅助函数，类似于 Python 中的 split()，将一个字符串根据指定分隔符分成若干段：

1
2
3
4
5
6
7
8
9


inline void split(const string& s, char sep, vector<string>& res)
{
 string t;
 for(char c: s)
 if(c == sep)
 res.push_back(t), t.clear();
 else t += c;
 res.push_back(t);
}

先处理字符串并找到顶层元素：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


// 读入
string s;
cin >> s;
// 分割
vector<string> ord;
split(s, '.', ord);
// 根据名称匹配顶层元素
LL addr;
DataType* type;
for(auto& obj: toplevel_objects)
 if(obj.name == ord[0])
 {
 addr = obj.addr;
 type = obj.type;
 break;
 }

逐层向下，计算地址：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


// ord[0] 对应顶层元素名称，删掉
ord.erase(ord.begin());
// 逐层向下遍历
for(string& s: ord)
 for(auto& m: type->members)
 {
 addr = m.first->shift(addr); // 地址对齐
 if(m.second == s) // 名称匹配
 {
 type = m.first; // 找到下一层，向下遍历
 break;
 }
 addr += m.first->size; // 地址移到下一个元素
 }

输出最终地址：

1

cout << addr << '\n';

操作 4：访问地址

同操作 3，先找到顶层元素：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


LL addr;
cin >> addr;
if(addr >= cur_addr) // 大于最高有效地址，直接挂掉
{
 cout << "ERR\n";
 continue;
}
DataType* type = nullptr;
LL f_addr = 0LL; // 当前考察的地址
string res; // 结果字符串
for(auto& obj: toplevel_objects)
{
 if(addr < obj.addr) goto bad; // 特判由于对齐导致的地址无效
 if(addr < obj.addr + obj.type->size) // 地址在当前范围内，记录结果
 {
 type = obj.type;
 res = obj.name;
 f_addr = obj.addr;
 break;
 }
}

向下寻找并输出：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// 循环条件：(1) 地址有效 (2) 不是基本类型（类型有成员）
while(addr < f_addr + type->actual_size && !type->members.empty())
 for(auto& m: type->members)
 {
 f_addr = m.first->shift(f_addr); // 对齐
 if(addr < f_addr) goto bad; // 特判，同上
 if(addr < f_addr + m.first->size)
 {
 type = m.first;
 res.push_back('.');
 res += m.second;
 break;
 }
 f_addr += m.first->size;
 }
if(addr < f_addr + type->actual_size) cout << res << '\n'; // 地址有效则输出结果
else cout << "ERR\n"; // 地址无效
continue;
bad: cout << "ERR\n"; // 前面使用的 bad 标签

完整代码

下面是赛时代码，也是前面讲解中使用的：

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180


#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>
#include <algorithm>
using namespace std;

inline void setmax(int& x, int y)
{
 if(x < y) x = y;
}

using LL = long long;

struct DataType
{
 const string name;
 LL size, actual_size;
 int indent;
 vector<pair<DataType*, string>> members;
 inline DataType(const string& n): name(n) {}
 inline LL shift(LL addr)
 {
 return addr % indent? (addr / indent + 1) * indent: addr;
 }
 inline void maintain()
 {
 size = indent = 0;
 for(const auto& m: members)
 {
 setmax(indent, m.first->indent);
 size = m.first->shift(size) + m.first->size;
 }
 actual_size = size;
 size = shift(size);
 }
};

struct Object
{
 DataType* type;
 string name;
 LL addr;
};

inline void split(const string& s, char sep, vector<string>& res)
{
 string t;
 for(char c: s)
 if(c == sep)
 res.push_back(t), t.clear();
 else t += c;
 res.push_back(t);
}

int main()
{
 ios::sync_with_stdio(false); cin.tie(nullptr);
 unordered_map<string, DataType*> types;
 auto add_base_type = [&](string name, int size) -> void {
 DataType* t = new DataType(name);
 t->size = t->indent = t->actual_size = size;
 types[name] = t;
 };
 add_base_type("byte", 1);
 add_base_type("short", 2);
 add_base_type("int", 4);
 add_base_type("long", 8);
 int q;
 cin >> q;
 vector<Object> toplevel_objects;
 LL cur_addr = 0LL;
 while(q--)
 {
 int op;
 cin >> op;
 if(op == 1)
 {
 string s;
 int k;
 cin >> s >> k;
 DataType* type = new DataType(s);
 types[s] = type;
 type->members.resize(k);
 for(auto& m: type->members)
 {
 string t;
 cin >> t >> m.second;
 m.first = types[t];
 }
 type->maintain();
 cout << type->size << ' ' << type->indent << '\n';
 }
 else if(op == 2)
 {
 Object obj;
 string t;
 cin >> t >> obj.name;
 obj.type = types[t];
 obj.addr = obj.type->shift(cur_addr);
 cur_addr = obj.addr + obj.type->size;
 toplevel_objects.push_back(obj);
 cout << obj.addr << '\n';
 }
 else if(op == 3)
 {
 string s;
 cin >> s;
 vector<string> ord;
 split(s, '.', ord);
 LL addr;
 DataType* type;
 for(auto& obj: toplevel_objects)
 if(obj.name == ord[0])
 {
 addr = obj.addr;
 type = obj.type;
 break;
 }
 ord.erase(ord.begin());
 for(string& s: ord)
 for(auto& m: type->members)
 {
 addr = m.first->shift(addr);
 if(m.second == s)
 {
 type = m.first;
 break;
 }
 addr += m.first->size;
 }
 cout << addr << '\n';
 }
 else // op == 4
 {
 LL addr;
 cin >> addr;
 if(addr >= cur_addr)
 {
 cout << "ERR\n";
 continue;
 }
 DataType* type = nullptr;
 LL f_addr = 0LL;
 string res;
 for(auto& obj: toplevel_objects)
 {
 if(addr < obj.addr) goto bad;
 if(addr < obj.addr + obj.type->size)
 {
 type = obj.type;
 res = obj.name;
 f_addr = obj.addr;
 break;
 }
 }
 while(addr < f_addr + type->actual_size && !type->members.empty())
 for(auto& m: type->members)
 {
 f_addr = m.first->shift(f_addr);
 if(addr < f_addr) goto bad;
 if(addr < f_addr + m.first->size)
 {
 type = m.first;
 res.push_back('.');
 res += m.second;
 break;
 }
 f_addr += m.first->size;
 }
 if(addr < f_addr + type->actual_size) cout << res << '\n';
 else cout << "ERR\n";
 continue;
 bad: cout << "ERR\n";
 }
 }
 for(auto it=types.begin(); it!=types.end(); it++)
 delete it->second;
 return 0;
}

程序共计 $180$ 行，长度 $4.64\mathrm{KB}$，运行用时 $73\mathrm{ms}$。

实际上 Object 的定义没有必要，也不需要存储每个顶层元素的地址，同时还可以稍加压行：

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146


#include <bits/stdc++.h>
using namespace std;

using LL = long long;

struct DataType {
 const string name;
 LL size, actual_size;
 int indent;
 vector<pair<DataType*, string>> members;
 inline DataType(const string& n): name(n) {}
 inline LL shift(LL addr) {
 return addr % indent? (addr / indent + 1) * indent: addr;
 }
 inline void maintain() {
 size = indent = 0;
 for(const auto& m: members)
 {
 indent = max(indent, m.first->indent);
 size = m.first->shift(size) + m.first->size;
 }
 actual_size = size;
 size = shift(size);
 }
};

inline void split(const string& s, char sep, vector<string>& res) {
 string t;
 for(char c: s)
 if(c == sep) res.push_back(t), t.clear();
 else t += c;
 res.push_back(t);
}

int main() {
 ios::sync_with_stdio(false); cin.tie(nullptr);
 unordered_map<string, DataType*> types;
 auto add_base_type = [&](string name, int size) -> void {
 DataType* t = new DataType(name);
 t->size = t->indent = t->actual_size = size;
 types[name] = t;
 };
 add_base_type("byte", 1);
 add_base_type("short", 2);
 add_base_type("int", 4);
 add_base_type("long", 8);
 int q;
 cin >> q;
 vector<pair<DataType*, string>> toplevel_objects;
 LL cur_addr = 0LL;
 while(q--) {
 int op;
 cin >> op;
 if(op == 1) {
 string s;
 int k;
 cin >> s >> k;
 DataType* type = new DataType(s);
 types[s] = type;
 type->members.resize(k);
 for(auto& m: type->members) {
 string t;
 cin >> t >> m.second;
 m.first = types[t];
 }
 type->maintain();
 cout << type->size << ' ' << type->indent << '\n';
 }
 else if(op == 2) {
 string t, name;
 cin >> t >> name;
 DataType* type = types[t];
 cur_addr = type->shift(cur_addr);
 cout << cur_addr << '\n';
 cur_addr += type->size;
 toplevel_objects.emplace_back(type, name);
 }
 else if(op == 3) {
 string s;
 cin >> s;
 vector<string> ord;
 split(s, '.', ord);
 LL addr = 0LL;
 DataType* type;
 for(auto& obj: toplevel_objects) {
 addr = obj.first->shift(addr);
 if(obj.second == ord[0]) {
 type = obj.first;
 break;
 }
 addr += obj.first->size;
 }
 ord.erase(ord.begin());
 for(string& s: ord)
 for(auto& m: type->members) {
 addr = m.first->shift(addr);
 if(m.second == s) {
 type = m.first;
 break;
 }
 addr += m.first->size;
 }
 cout << addr << '\n';
 }
 else {
 LL addr;
 cin >> addr;
 if(addr >= cur_addr) {
 cout << "ERR\n";
 continue;
 }
 DataType* type = nullptr;
 LL f_addr = 0LL;
 string res;
 for(auto& obj: toplevel_objects) {
 f_addr = obj.first->shift(f_addr);
 if(addr < f_addr) goto bad;
 if(addr < f_addr + obj.first->size) {
 type = obj.first;
 res = obj.second;
 break;
 }
 f_addr += obj.first->size;
 }
 while(addr < f_addr + type->actual_size && !type->members.empty())
 for(auto& m: type->members) {
 f_addr = m.first->shift(f_addr);
 if(addr < f_addr) goto bad;
 if(addr < f_addr + m.first->size) {
 type = m.first;
 res.push_back('.');
 res += m.second;
 break;
 }
 f_addr += m.first->size;
 }
 if(addr < f_addr + type->actual_size) cout << res << '\n';
 else cout << "ERR\n";
 continue;
 bad: cout << "ERR\n";
 }
 }
 for(auto it=types.begin(); it!=types.end(); it++)
 delete it->second;
 return 0;
}

这样只有 $146$ 行，$4.51\mathrm{KB}$。

不过个人觉得写个 Object 更清楚，所以讲解的时候就没改啦~

后记

算法固然重要，但是编码能力也很重要！强烈建议各位 OIer 重视大模拟，不在这种题上挂分~

写大模拟需要注意的几个点：

变量名写清楚，全写 a、b、c、d 到后面自己都不知道是啥，没法调试
该用指针就用指针，不要害怕，用多了会发现真的很好用
适当使用类和结构体，尽量不要全部使用 int 数组
时间复杂度允许的情况下，可读性比性能重要！！（比如本题没有使用二分查找）

祝大家在 NOIP 2023 取得好成绩！~~求赞qwq~~

AtCoder Beginner Contest 318 G - Typical Path Problem 题解

Sun, 03 Sep 2023 13:28:00 +0800

G - Typical Path Problem

题目大意

给定一张 $N$ 个点、$M$ 条边的简单无向图 $G$ 和三个整数 $A,B,C$。

是否存在一条从顶点 $A$ 到 $C$，且经过 $B$ 的简单路径？

数据范围：

$3\le N\le 2\times 10^5$
$N-1\le M\le \min(\frac{N(N-1)}2,2\times 10^5)$
$1\le A,B,C\le N$（$A,B,C$ 互不相同）

什么是 简单路径 ？
简单路径 是不重复经过同一个点的路径。例如，$1\to 2\to 3$ 是简单路径，但 $1\to 2\to 1$ 不是简单路径。

解法1：最大流

不难发现，存在一条 $A\to B\to C$ 的简单路径，当且仅当存在一条 $B\to A$ 和一条 $B\to C$ 的路径，使得这两条路径不经过同一个点（$B$ 除外）。因此，我们可以构建网络流模型来解决此问题。

考虑由 $(2N+2)$ 个点组成的有向图 $G'$：

源点：$s$
汇点：$t$
$G$ 中每个点对应的入点：$x_1,\dots,x_N$
$G$ 中每个点对应的出点：$y_1,\dots,y_N$

然后进行连边：

对于每个 $1\le i\le N$，从入点 $x_i$ 向出点 $y_i$ 连接一条流量为 $1$ 的边；
从源点 $s$ 到中转点的入点 $x_B$ 连接一条流量为 $2$ 的边；
从 $A$ 和 $C$ 的出点 $y_A,y_C$ 向汇点 $t$ 分别连接一条流量为 $1$ 的边；
最后，$\forall (u,v)\in E_G$，连接 $y_u \to x_v$ 和 $y_v \to x_u$，流量为 $1$。

计算 $s$ 到 $t$ 的最大流，如果最大流为 $2$ 则必定有存在不经过同一个顶点的 $B\to A,B\to C$ 的路径。

证明
显然，如果最大流为 $2$，必然通过了 $y_A$ 和 $y_C$ 向汇点连接的边，则一定分别有 $B\to A$ 和 $B\to C$ 的路径。
假设选择的这两条路径经过了同一顶点 $v$，则两流都必须经过 $x_v\to y_v$ 这一条流量为 $1$ 的边，此时最大流不可能超过 $1$。而最大流为 $2$，说明假设不成立，故没有经过同一顶点。

若使用 $\text{Dinic}$ 算法，由于最大流不超过 $2$，网络流的时间复杂度为 $\mathcal O(N+M)$。

代码实现

在以下的两种实现中，我们规定

源点：$s=0$
汇点：$t=2n+1$
$i$ 的入点：$x_i=i$
$i$ 的出点：$y_i=n+i$

AC Library 实现

AtCoder Library 内置最大流的 $\text{Dinic}$ 实现。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


#include <cstdio>
#include <atcoder/maxflow>
using namespace std;

int main()
{
 int n, m, a, b, c;
 scanf("%d%d%d%d%d", &n, &m, &a, &b, &c);
 int s = 0, t = (n << 1) + 1;
 atcoder::mf_graph<int> G(t + 1);
 G.add_edge(s, b + n, 2);
 G.add_edge(a + n, t, 1);
 G.add_edge(c + n, t, 1);
 for(int i=1; i<=n; i++)
 G.add_edge(i, i + n, 1);
 while(m--)
 {
 int x, y;
 scanf("%d%d", &x, &y);
 G.add_edge(x + n, y, 1);
 G.add_edge(y + n, x, 1);
 }
 puts(G.flow(s, t, 2) == 2? "Yes": "No");
 return 0;
}

Dinic 手写实现

$\text{Dinic}$ 算法对于此图的时间复杂度为 $\mathcal O(N+M)$。如果不清楚算法原理可以参考 OI Wiki。

关于空间分配问题
由于新图 $G'$ 包含 $(N+2M+3)$ 条边，若使用静态链式前向星存图，数组大小需要开到 $2(N+2M+3)$，其理论最大值为 $1.2\times 10^6+6$。此处建议使用 $1.25\times 10^6$ 大小的数组。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92


#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
#define maxn 400005
#define maxm 1250005
using namespace std;

int n, s, t, head[maxn], cur[maxn], dis[maxn],
 cnt, w[maxm], to[maxm], nxt[maxm];

inline void add(int u, int v, int flow)
{
 nxt[cnt] = head[u];
 head[u] = cnt;
 to[cnt] = v;
 w[cnt++] = flow;
}

inline void add_flow(int u, int v, int f)
{
 add(u, v, f);
 add(v, u, 0);
}

inline bool bfs()
{
 memset(dis, -1, sizeof(int) * n);
 dis[s] = 0, cur[s] = head[s];
 queue<int> q;
 q.push(s);
 while(!q.empty())
 {
 int v = q.front(); q.pop();
 for(int i=head[v]; ~i; i=nxt[i])
 if(w[i])
 {
 int u = to[i];
 if(dis[u] == -1)
 {
 dis[u] = dis[v] + 1, cur[u] = head[u];
 if(u == t) return true;
 q.push(u);
 }
 }
 }
 return false;
}

int dfs(int v, int flow)
{
 if(v == t) return flow;
 int res = 0;
 for(int i=cur[v]; ~i && flow; i=nxt[i])
 {
 cur[v] = i;
 int u = to[i];
 if(w[i] && dis[u] == dis[v] + 1)
 {
 int k = dfs(u, min(flow, w[i]));
 w[i] -= k;
 w[i ^ 1] += k;
 flow -= k;
 res += k;
 }
 }
 return res;
}

int main()
{
 int n, m, a, b, c;
 scanf("%d%d%d%d%d", &n, &m, &a, &b, &c);
 s = 0, t = (n << 1) + 1, ::n = t + 1;
 memset(head, -1, sizeof(int) * ::n);
 add_flow(s, b + n, 2);
 add_flow(a + n, t, 1);
 add_flow(c + n, t, 1);
 for(int i=1; i<=n; i++)
 add_flow(i, i + n, 1);
 while(m--)
 {
 int x, y;
 scanf("%d%d", &x, &y);
 add_flow(x + n, y, 1);
 add_flow(y + n, x, 1);
 }
 int mf = 0;
 while(bfs()) mf += dfs(s, 2);
 puts(mf == 2? "Yes": "No");
 return 0;
}

解法2：圆方树

注意到以下算法的正确性：

找到 $A\to C$ 的任意简单路径。对于经过的每一个点双连通分量，如果 $B$ 在此点双内，则必然存在 $A\to B\to C$ 的简单路径；如果 $B$ 不属于任一经过的点双，则不可能存在 $A\to B\to C$ 的简单路径。

因此，可以使用 $\text{Tarjan}$ 算法构造原图的圆方树 $T$ 来解决此问题。将上述算法转换到圆方树上如下：

在 $T$ 上找到 $A\to C$ 的唯一简单路径。对于经过的每一个方点，如果 $B$ 是与其相邻的圆点，则必然存在 $A\to B\to C$ 的简单路径；如果 $B$ 不与任一经过的方点相邻，则不可能存在 $A\to B\to C$ 的简单路径。

总时间复杂度为 $\mathcal O(N+M)$，实际运行时间优于网络流解法。

代码实现

小贴士：圆方树相关的数组要开到两倍大小，不然会 RE 哦~

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73


#include <cstdio>
#include <cstdlib>
#include <vector>
#define maxn 200005
using namespace std;

inline void setmin(int& x, int y)
{
 if(y < x) x = y;
}

vector<int> G[maxn], T[maxn << 1];

inline void add_edge(vector<int>* G, int x, int y)
{
 G[x].push_back(y);
 G[y].push_back(x);
}

int dfc, dfn[maxn], low[maxn], top, st[maxn], cnt;

void tarjan(int v)
{
 low[v] = dfn[v] = ++dfc;
 st[++top] = v;
 for(int u: G[v])
 if(!dfn[u])
 {
 tarjan(u);
 setmin(low[v], low[u]);
 if(low[u] == dfn[v])
 {
 add_edge(T, v, ++cnt);
 do add_edge(T, st[top], cnt);
 while(st[top--] != u);
 }
 }
 else setmin(low[v], dfn[u]);
}

int n, m, a, b, c, ct[maxn << 1];
void dfs(int v, int par)
{
 if(v > n)
 for(int u: T[v])
 ct[u] ++;
 if(v == c)
 {
 puts(ct[b]? "Yes": "No");
 exit(0);
 }
 for(int u: T[v])
 if(u != par)
 dfs(u, v);
 if(v > n)
 for(int u: T[v])
 ct[u] --;
}

int main()
{
 scanf("%d%d%d%d%d", &n, &m, &a, &b, &c);
 while(m--)
 {
 int x, y;
 scanf("%d%d", &x, &y);
 add_edge(G, x, y);
 }
 cnt = n;
 tarjan(1);
 dfs(a, -1);
 return 0;
}

总结

三种解法的对比参见下表：

解法	代码长度	运行时间	内存占用
最大流（AC Library）¹	$523~\mathrm{B}$	$337~\mathrm{ms}$	$106480~\mathrm{KB}$
最大流（Dinic）²	$1650~\mathrm{B}$	$334~\mathrm{ms}$	$46980~\mathrm{KB}$
圆方树³	$1142~\mathrm{B}$	$162~\mathrm{ms}$	$57824~\mathrm{KB}$

可见，圆方树算法的运行速度最快，最大流（AC Library）的代码最短，最大流（Dinic）的内存占用最小。

个人评价
这道题出得很好，题意简单而内涵丰富。
~~我赛时甚至没想到还可以网络流~~

TOYOTA MOTOR CORPORATION Programming Contest 2023#1 (AtCoder Beginner Contest 298) A~G 题解

Wed, 19 Apr 2023 18:34:00 +0800

好久没写题解了，这就来水一篇。

A - Job Interview

题目大意

给定一个长为 $N$ 的字符串 $S$，由 o、-、x 组成。

判断 $S$ 是否符合下列条件：

$S$ 中至少有一个 o。
$S$ 中没有 x。

$1\le N\le 100$

分析

签到题。直接按题意模拟即可。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <cstdio>
using namespace std;

int main()
{
 while(getchar() != '\n');
 char c;
 bool ok = false;
 while((c = getchar()) != '\n')
 {
 if(c == 'x')
 {
 puts("No");
 return 0;
 }
 if(c == 'o')
 ok = true;
 }
 puts(ok? "Yes": "No");
 return 0;
}

Python ~~水题大法~~ 速通大法
1
2
3
input()
s = input()
print('Yes' if 'o' in s and 'x' not in s else 'No')
成功省掉$208$个字符（逃

B - Coloring Matrix

题目大意

给定两个 $N\times N$ 的矩阵 $A$ 和 $B$，都由 $0$ 和 $1$ 组成。

你可以将 $A$ 顺时针旋转 $0\degree,90\degree,180\degree$ 或 $270\degree$（任选其一）。

判断旋转后的 $A$ 能否满足：

对于每个 $A_{i,j}=1$ 的 $(i,j)$，$B_{i,j}=1$。

$1\le N\le 100$

分析

原题中还贴心的给出了如何将一个矩阵旋转$90\degree$，照题意模拟，旋转$4$次并逐个判断即可。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <cstdio>
#define maxn 105
using namespace std;

int a[maxn][maxn], b[maxn][maxn], c[maxn][maxn];

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=0; i<n; i++)
 for(int j=0; j<n; j++)
 scanf("%d", a[i] + j);
 for(int i=0; i<n; i++)
 for(int j=0; j<n; j++)
 scanf("%d", b[i] + j);
 for(int x=0; x<4; x++)
 {
 for(int i=0; i<n; i++)
 for(int j=0; j<n; j++)
 c[i][j] = a[i][j];
 for(int i=0; i<n; i++)
 for(int j=0; j<n; j++)
 a[i][j] = c[n - 1 - j][i];
 for(int i=0; i<n; i++)
 for(int j=0; j<n; j++)
 if(a[i][j] && !b[i][j])
 goto bad; // goto 不是好习惯（改不掉了），千万不要学
 puts("Yes");
 return 0;
 bad:;
 }
 puts("No");
 return 0;
}

C - Cards Query Problem

题目大意

有 $N$ 个盒子，编号 $1\sim N$，初始均为空。依次处理 $Q$ 次询问：

1 i j：将数字 $i$ 写在一张空卡牌上，放入盒子 $j$。
2 i：按升序输出盒子 $i$ 中的所有卡牌（允许重复）。
3 i：按升序输出包含卡牌 $i$ 的所有盒子的编号。若一个盒子里有多张卡牌 $i$，则这个盒子的编号仅输出一次。

$1\le N,Q\le 2\times 10^5$

对于查询中所有卡牌上的数字 $x$，均有 $1\le x\le 2\times 10^5$。
对于查询中所有的盒子编号 $y$，均有 $1\le y\le N$。

题目保证输出不超过 $2\times 10^5$ 个整数。

分析

我们分别考虑两种输出操作的做法。

2 i：很容易想到，既然要按升序输出，并且允许重复，我们可以使用 $N$ 个 multiset 来依次存储每个盒子中的卡牌，处理操作 $1$ 时更新。
3 i：首先不能从 $N$ 个盒子中依次查找，这样明显会 TLE。正确的做法是，使用 $2\times 10^5$ 个 set（注意不能重复，所以不用 multiset）分别存储每张卡牌所在的箱子编号，处理操作 $1$ 时更新。

此外，本题也可以使用 priority_queue、map，甚至直接输出时排序并去重，不过使用 set 的方式是最简单、代码量最少的。几种方法的总时间复杂度都是 $\mathcal O(Q\log N)$。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


#include <cstdio>
#include <set>
#define maxn 200005
using namespace std;

multiset<int> box[maxn];
set<int> has[maxn];

int main()
{
 int n, q;
 scanf("%d%d", &n, &q);
 while(q--)
 {
 int op, i;
 scanf("%d%d", &op, &i);
 if(op == 1)
 {
 int j;
 scanf("%d", &j);
 box[j].insert(i);
 has[i].insert(j);
 }
 else if(op == 2)
 {
 for(int x: box[i])
 printf("%d ", x);
 putchar('\n');
 }
 else if(op == 3)
 {
 for(int x: has[i])
 printf("%d ", x);
 putchar('\n');
 }
 }
 return 0;
}

D - Writing a Numeral

题目大意

我们有一个字符串 $S$。初始时，$S=$ 1。

处理如下 $Q$ 次询问：

1 x：将数字 $x$ 追加至 $S$ 的最后面。保证 $x \in \{1,2,3,4,5,6,7,8,9\}$。
2：删除 $S$ 的第一个字符。保证此时 $|S| > 1$。
3：输出 $S$ 在十进制中对应的数字，对 $998244353$ 取模。

$1\le Q\le 6\times 10^5$

分析

首先，我们必须使用一个 queue 或 deque 来存储字符串 $S$。然后，为了在 $\mathcal O(1)$ 的时间内处理第三种操作，我们必须维护 $S \bmod (P=998244353)$ 的值，记为 $A$。下面考虑前两种操作对 $A$ 的影响：

1 x：只需在十进制中腾出一位 $0$ 再加上 $x$ 即可，可表示为 $A \leftarrow (10A+x)\bmod P$。
2：先从队列中取出 $S$ 的第一位，记为 $x$。我们需要从 $A$ 中减掉最高位乘上其在十进制中的权值，即 $A \leftarrow (A-10^{|S|}x)\bmod P$（此时 $|S|$ 表示队列取出前一位后的长度，等同于取出前的 $|S|-1$）

对于 $10^n$ 的计算，我们可以用一个变量实时维护 $10^{|S|}\bmod P$ 的值，也可以预处理出所有 $10^n \bmod P$，或者直接使用快速幂。

总时间复杂度为 $\mathcal O(Q\log Q)$（快速幂）或 $\mathcal O(Q)$（预处理）。

代码

实现 $1$：使用 AtCoder Library + 快速幂，队列使用 deque

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


#include <cstdio>
#include <deque>
#include <atcoder/modint>
using namespace std;

using modint = atcoder::modint998244353;

int main()
{
 deque<int> s;
 s.push_back(1);
 int q;
 scanf("%d", &q);
 modint ans = 1;
 while(q--)
 {
 int op;
 scanf("%d", &op);
 if(op == 1)
 {
 int x;
 scanf("%d", &x);
 s.push_back(x);
 ans = ans * 10 + x;
 }
 else if(op == 2)
 {
 int x = s.front(); s.pop_front();
 ans -= x * modint(10).pow((int)s.size());
 }
 else printf("%d\n", ans.val());
 }
 return 0;
}

实现 $2$：用变量维护 $10^{|S|} \bmod P$ 的值，队列使用 queue

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


#include <cstdio>
#include <queue>
#define MOD 998244353
using namespace std;

int main()
{
 int Q;
 scanf("%d", &Q);
 queue<int> q;
 q.push(1);
 int ans = 1, p = 1;
 while(Q--)
 {
 int op;
 scanf("%d", &op);
 if(op == 1)
 {
 int x;
 scanf("%d", &x);
 q.push(x);
 ans = (ans * 10LL + x) % MOD;
 p = p * 10LL % MOD;
 }
 else if(op == 2)
 {
 ans -= (long long) q.front() * p % MOD; q.pop();
 p = p * 299473306LL % MOD; // 299473306 是 10 对于 MOD 的逆元，这句话相当于把 p 除以 10 
 if(ans < 0) ans += MOD;
 }
 else printf("%d\n", ans);
 }
 return 0;
}

E - Unfair Sugoroku

题目大意

Takahashi 和 Aoki 将玩一个游戏。游戏规则如下：

游戏棋盘有 $N$ 个点（编号 $1\sim N$），两玩家轮流投骰子并前进。
Takahashi 初始在点 $A$，Aoki 初始在点 $B$。
Takahashi 的骰子等概率出现 $1,2,\dots,P$，Aoki 的骰子等概率出现 $1,2,\dots,Q$。
当一个玩家当前在点 $x$ 且骰子出现 $i$ 时，他移动到点 $\min(x+i,N)$。
先到达点 $N$ 的玩家胜利。

假定 Takahashi 先行，求他赢的概率，对 $998244353$ 取模。

$2\le N\le 100$
$1\le A,B\le N$
$1\le P,Q\le 10$

分析

自己的赛时解法太复杂了，这里介绍官方题解的做法。

考虑概率 DP（下面用 Ta 表示 Takahashi，Ao 表示 Aoki）：

令 $f_{i,j}$ 表示 Ta 在点 $i$，Ao 在点 $j$，下一轮 Ta 移动时 Ta 获胜的概率。
令 $g_{i,j}$ 表示 Ta 在点 $i$，Ao 在点 $j$，下一轮 Ao 移动时 Ta 获胜的概率。

首先考虑初始状态。根据游戏规则，对于任意 $1\le i < n$，$f_{n,i}=g_{n,i}=1,f_{i,n}=g_{i,n}=0$。

转移也很显然：

对于 Ta 当前走的每种可能的步数 $k=1,2,\dots,P$，有 $f_{i,j}:=f_{i,j}+\frac1Pg_{\min(i+k,N),j}$。
对于 Ao 当前走的每种可能的步数 $k=1,2,\dots,Q$，有 $g_{i,j}:=g_{i,j}+\frac1Qf_{i,\min(j+k,N)}$。

整理上面的式子，得到：

$$ f_{i,j}=\begin{cases} 0 & (j=N)\\ 1 & (i=N)\\ \frac1P\sum\limits_{k=1}^Pg_{\min(i+k,N),j} & (i,j\ne N) \end{cases}\\ ~\\ g_{i,j}=\begin{cases} 0 & (j=N)\\ 1 & (i=N)\\ \frac1Q\sum\limits_{k=1}^Qf_{i,\min(j+k,N)} & (i,j\ne N) \end{cases}\\ $$

这里注意，由于 $i=j=N$ 的情况无意义（不可能达到），所以无需特殊考虑。

最终输出结果即为 $f_{p,q}$。总时间复杂度为 $\mathcal O(N^2(P+Q))$。使用前缀和可以优化到 $\mathcal O(N^2)$，有兴趣的可以自己尝试，这里不详细解释了。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


#include <cstdio>
#include <algorithm>
#define MOD 998244353
#define maxn 105
using namespace std;

using LL = long long;
inline LL inv(LL x) // x ^ (MOD - 2) % MOD
{
 int y = MOD - 2;
 LL res = 1LL;
 while(y)
 {
 if(y & 1) (res *= x) %= MOD;
 (x *= x) %= MOD, y >>= 1;
 }
 return res;
}

inline void add(int& x, int y)
{
 if((x += y) >= MOD)
 x -= MOD;
}

int f[maxn][maxn], g[maxn][maxn];

int main()
{
 int n, a, b, p, q;
 scanf("%d%d%d%d%d", &n, &a, &b, &p, &q);
 for(int i=0; i<n; i++)
 f[n][i] = g[n][i] = 1, f[i][n] = g[i][n] = 0;
 LL prob_p = inv(p), prob_q = inv(q);
 for(int i=n-1; i>=a; i--)
 for(int j=n-1; j>=b; j--)
 {
 for(int k=1; k<=p; k++)
 add(f[i][j], g[min(i + k, n)][j]);
 f[i][j] = f[i][j] * prob_p % MOD;
 for(int k=1; k<=q; k++)
 add(g[i][j], f[i][min(j + k, n)]);
 g[i][j] = g[i][j] * prob_q % MOD;
 }
 printf("%d\n", f[a][b]);
 return 0;
}

F - Rook Score

题目大意

有一个 $10^9\times 10^9$ 的网格。令 $(i,j)$ 表示第 $i$ 行 $j$ 列的格子（$1\le i,j\le 10^9$）。

对于 $i=1,2,\dots,N$，整数 $x_i$ 被写在 $(r_i,c_i)$ 上。在剩余的 $10^{18}-N$ 个格子里只有数字 $0$。

你可以选择一个格子 $(R,C)$ 并计算与其同行或同列的 $2\times 10^9-1$ 个整数之和 $S$。

求最大可能的 $S$。

$1\le N\le 2\times 10^5$
$1\le r_i,c_i,x_i\le 10^9$
$(r_i,c_i)\ne (r_j,c_j)~~~~~~(i\ne j)$

分析

我们令 $f(R,C)$ 表示对于 $(R,C)$ 的 $S$，令 $\mathrm{rs}_R$ 表示第 $R$ 行的整数之和，$\mathrm{cs}_C$表示第 $C$ 列的整数之和，$A_{R,C}$ 表示 $(R,C)$ 上的整数。

容易发现，$f(R,C)=\mathrm{rs}_R+\mathrm{cs}_C-A_{R,C}$。

然后证明当 $f(R,C)$ 最大时，$\mathrm{rs}_R,\mathrm{cs}_C\ne0$：

若 $\mathrm{rs}_R=\mathrm{cs}_C=0$，则 $f(r_0,c_0)=x_0 > 0=f(R,C)$，所以 $(R,C)$ 不是最优解；
若 $\mathrm{rs}_R\ne0,\mathrm{cs}_C=0$，则 $f(R,c_0)=\mathrm{rs}_R+\mathrm{cs}_{c_0}-A_{R,c_0}\ge f(R,C)=\mathrm{rs}_R$，所以 $(R,C)$ 不是最优解（或有多个最优解，但其中至少有一个解 $(x,y)$ 使得 $\mathrm{rs}_x,\mathrm{cs}_y\ne0$）
$\mathrm{rs}_R=0,\mathrm{cs}_C\ne0$ 同理。

所以，我们可以依次考虑每一行 $R$（$\mathrm{rs}_R\ne 0$），相当于固定了 $\mathrm{rs}_R$。这时，我们只需找到一列 $C$（$\mathrm{cs}_C\ne 0$），使得 $\mathrm{cs}_C-A_{R,C}$ 最大，就可以解决此问题。

但如果依次考虑所有包含点的列，则最坏情况下时间复杂度为 $\mathcal O(N^2)$，无法通过此题。这时，我们可以使用一个 multiset 或 map 来维护当前每列对答案的贡献（$\mathrm{cs}_C-A_{R,C}$）。对于每一行 $R$，仅需更新这一行上有非 $0$ 数字的点 $(R,C)$ 的贡献（减去 $A_{R,C}$）即可。

这样，由于每个点会被更新正好一次，所以总时间复杂度为 $\mathcal O(N\log N)$。

代码

注意更新完成，求得当前答案后需要复原 map 或 multiset。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


#include <cstdio>
#include <vector>
#include <set>
#include <unordered_map>
using namespace std;

using LL = long long;
using pii = pair<int, int>;

unordered_map<int, vector<pii>> rows;
unordered_map<int, LL> col_sum;

template <typename T>
class MaxSet {
private:
 multiset<T> s;
public:
 inline void insert(const T& x) { s.insert(x); }
 inline void update(const T& old, const T& New) {
 s.erase(s.find(old));
 s.insert(New);
 }
 inline T max() { return *s.rbegin(); }
};

int main()
{
 int n;
 scanf("%d", &n);
 while(n--)
 {
 int x, y, v;
 scanf("%d%d%d", &x, &y, &v);
 rows[x].emplace_back(y, v);
 col_sum[y] += v;
 }
 MaxSet<LL> s;
 for(auto [_, sum]: col_sum)
 s.insert(sum);
 LL ans = 0LL;
 for(auto& [x, v]: rows)
 {
 for(auto [y, val]: v)
 s.update(col_sum[y], col_sum[y] - val);
 LL cur = s.max();
 for(auto [y, val]: v)
 s.update(col_sum[y] - val, col_sum[y]), cur += val;
 if(cur > ans) ans = cur;
 }
 printf("%lld\n", ans);
 return 0;
}

G - Strawberry War

题目大意

==注意本题时间限制为 $6\mathrm s$。==

我们有一块长方形的蛋糕。它可被看作一个 $H\times W$ 的网格，第 $i$ 行 $j$ 列上有 $s_{i,j}$ 个草莓。

我们对蛋糕进行 $T$ 次切分，切成 $T+1$ 块。每次切蛋糕可以选择当前的一块，并将其从中间横切或竖切成两块：

你想把蛋糕切的尽可能均匀。意思是，令 $M$ 表示切分完成后每一块上的草莓数量的最大值，$m$ 表示最小值，求出 $M-m$ 的最小值。

$1\le H,W\le 6$
$1\le T\le HW-1$
$0\le s_{i,j}\le 10^{16}$

分析

本题解参考官方题解。

操作完成后得到的蛋糕一定是蛋糕的子矩形，所以最多只有 $\binom {H+1}2\times\binom {W+1}2=\frac{H(H+1)W(W+1)}4\le 441$ 种数字在剩下的块中。令这些可能的数分别为 $a_1,a_2,\dots,a_X$。可知 $X\le \frac{H(H+1)W(W+1)}4\le 441$。

根据上面的 $a$，我们只需先确定 $m\in \{a_1,a_2,\dots,a_X\}$，再找到与其对应的最小 $M$，算出 $M-m$ 的最小值即可。

定义 $f_{i,j,k,l,m}$ 表示将 $x\in[i,j),y\in[k,l)$ 的子矩形切成 $m$ 片时最小可能的每片上草莓数的最大值。

详见代码。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000000000000000;
int main(){
 int H, W, T;
 cin >> H >> W >> T;
 vector<vector<long long>> s(H, vector<long long>(W));
 for (int i = 0; i < H; i++){
 for (int j = 0; j < W; j++){
 cin >> s[i][j];
 }
 }
 vector<vector<vector<vector<long long>>>> sum(H, vector<vector<vector<long long>>>(H + 1, vector<vector<long long>>(W, vector<long long>(W + 1, 0))));
 vector<long long> x;
 for (int i = 0; i < H; i++){
 for (int j = i + 1; j <= H; j++){
 for (int k = 0; k < W; k++){
 for (int l = k + 1; l <= W; l++){
 for (int m = i; m < j; m++){
 for (int n = k; n < l; n++){
 sum[i][j][k][l] += s[m][n];
 }
 }
 x.push_back(sum[i][j][k][l]);
 }
 }
 }
 }
 int cnt = x.size();
 long long ans = INF;
 for (int i = 0; i < cnt; i++){
 vector<vector<vector<vector<vector<long long>>>>> dp(T + 1, vector<vector<vector<vector<long long>>>>(H, vector<vector<vector<long long>>>(H + 1, vector<vector<long long>>(W, vector<long long>(W + 1, INF)))));
 for (int j = H - 1; j >= 0; j--){
 for (int k = j + 1; k <= H; k++){
 for (int l = W - 1; l >= 0; l--){
 for (int m = l + 1; m <= W; m++){
 if (sum[j][k][l][m] >= x[i]){
 dp[0][j][k][l][m] = sum[j][k][l][m];
 }
 for (int n = j + 1; n < k; n++){
 for (int o = 0; o < (n - j) * (m - l); o++){
 for (int p = 0; p < (k - n) * (m - l) && o + p < T; p++){
 dp[o + p + 1][j][k][l][m] = min(dp[o + p + 1][j][k][l][m], max(dp[o][j][n][l][m], dp[p][n][k][l][m]));
 }
 }
 }
 for (int n = l + 1; n < m; n++){
 for (int o = 0; o < (k - j) * (n - l); o++){
 for (int p = 0; p < (k - j) * (m - n) && o + p < T; p++){
 dp[o + p + 1][j][k][l][m] = min(dp[o + p + 1][j][k][l][m], max(dp[o][j][k][l][n], dp[p][j][k][n][m]));
 }
 }
 }
 }
 }
 }
 }
 ans = min(ans, dp[T][0][H][0][W] - x[i]);
 }
 cout << ans << endl;
}

【算法笔记】最近公共祖先（LCA）问题求解——倍增算法

Fri, 06 Jan 2023 23:03:00 +0800

前言

最近公共祖先简称 LCA（Lowest Common Ancestor）。两个节点的最近公共祖先，就是这两个点的公共祖先里面，离根最远的那个。

这种算法应用很广泛，可以很容易解决树上最短路等问题。

为了方便，我们记某点集 $S=\{v_1,v_2,\ldots,v_n\}$ 的最近公共祖先为 $\text{LCA}(v_1,v_2,\ldots,v_n)$ 或 $\text{LCA}(S)$。

部分内容参考 OI Wiki，文章中所有算法均使用C++实现。

例题：洛谷 P3379 【模板】最近公共祖先（LCA）

性质

$\text{LCA}(\{u\})=u$；
$u$ 是 $v$ 的祖先，当且仅当 $\text{LCA}(u,v)=u$；
如果 $u$ 不为 $v$ 的祖先并且 $v$ 不为 $u$ 的祖先，那么 $u,v$ 分别处于 $\text{LCA}(u,v)$ 的两棵不同子树中；
前序遍历中，$\text{LCA}(S)$ 出现在所有 $S$ 中元素之前，后序遍历中 $\text{LCA}(S)$ 则出现在所有 $S$ 中元素之后；
两点集并的最近公共祖先为两点集分别的最近公共祖先的最近公共祖先，即 $\text{LCA}(A\cup B)=\text{LCA}(\text{LCA}(A), \text{LCA}(B))$；
两点的最近公共祖先必定处在树上两点间的最短路上；
$d(u,v)=h(u)+h(v)-2h(\text{LCA}(u,v))$，其中 $d$ 是树上两点间的距离，$h$ 代表某点到树根的距离。

求解算法

前置知识1：树的邻接表存储

简单来说，树的邻接表存储就是对于每个结点，存储其能通过一条有向或无向边，直接到达的所有结点。
传统的存储方式是使用链表（或模拟链表），这样实现比较麻烦，也容易写错。
此处为了更好的可读性我们使用STL中的可变长度顺序表vector。

1
2
3
4


#include <vector> // 需要使用STL中的vector
#define maxn 100005 // 最大结点个数

std::vector<int> G[maxn];

此时，若要添加一条无向边$u\leftrightarrow v$，可使用：

1
2


G[u].push_back(v);
G[v].push_back(u);

若要添加$u\to v$的有向边：

1

G[u].push_back(v);

遍历$v$能直接到达的所有结点：

1
2


for(int u: G[v])
 cout << u << endl;

前置知识2：DFS 遍历 & 结点的深度计算

对于两种算法，都需要预处理出每个结点的深度。
一个结点的深度定义为这个结点到树根的距离。

要预处理出所有结点的深度，很简单：
运用树形dp的方法，令 $h_u$ 表示结点 $u$ 的深度，逐层向下推进：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <cstdio>
#include <vector>
#define maxn 100005
using namespace std;

vector<int> G[maxn]; // 邻接表存储
int depth[maxn]; // 每个结点的深度

void dfs(int v, int par) // dfs(当前结点，父亲结点)
{
 int d = depth[v] + 1; // 子结点的深度=当前结点的深度+1
 for(int u: G[v])
 if(u != par) // 不加这条判断会无限递归
 {
 depth[u] = d; // dp更新子结点深度
 dfs(u, v); // 往下dfs
 }
}

int main()
{
 // 构建一张图
 // ...
 // 假定图已存入邻接表G:
 int root = 0; // 默认树根为0号结点，根据实际情况设置
 dfs(root, -1); // 对于根结点，父亲结点为-1即为无父亲结点
 return 0;
}

朴素算法

令 $u,v$ 表示两个待求 LCA 的结点。需提前预处理出每个结点的父亲（记结点 $v$ 的父亲为 $f_v$）。

算法步骤：

使 $u,v$ 的深度相同：可以让深度大的结点往上走，直到与深度小的结点深度相同。
当 $u\ne v$时：$u\gets f_u,v\gets f_v$。
循环直到 $u=v$，此条件成立后 $u$ 和 $v$ 的值即为我们要求的 LCA。

时间复杂度分析：

预处理：DFS 遍历整棵树，$\mathcal O(N)$
单次查询：最坏 $\mathcal O(N)$，平均 $\mathcal O(\log N)$（随机树的高为 $\lceil\log N\rceil$）

参考代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


#include <cstdio>
#include <vector>
#include <algorithm>
#define maxn 500005
using namespace std;

vector<int> G[maxn];
int depth[maxn], par[maxn];

void dfs(int v)
{
 int d = depth[v] + 1;
 for(int u: G[v])
 if(u != par[v])
 {
 par[u] = v, depth[u] = d;
 dfs(u);
 }
}

int lca(int u, int v)
{
 if(depth[u] < depth[v])
 swap(u, v);
 while(depth[u] > depth[v])
 u = par[u];
 while(u != v)
 u = par[u], v = par[v];
 return u;
}

int main()
{
 int n, q, root;
 scanf("%d%d%d", &n, &q, &root);
 for(int i=1; i<n; i++)
 {
 int u, v;
 scanf("%d%d", &u, &v);
 G[u].push_back(v);
 G[v].push_back(u);
 }
 par[root] = -1, depth[root] = 0;
 dfs(root);
 while(q--)
 {
 int u, v;
 scanf("%d%d", &u, &v);
 printf("%d\n", lca(u, v));
 }
 return 0;
}

可以发现，程序在最后四个测试点上TLE了：

这是因为，这四个点是专门针对朴素算法设计的（正好是一个 Subtask），使算法的时间复杂度达到了最坏情况 $\mathcal O(NQ)$，而 $N,Q\le 5\times 10^5$，所以无法通过测试点。当然，朴素算法在随机树上回答 $Q$ 次询问的时间复杂度还是 $\mathcal O(N+Q\log N)$~~，被极端数据卡掉也没办法~~。

倍增

倍增算法是朴素算法的改进算法，也是最经典的 LCA 求法。

预处理：

令 $\text{fa}_{x,i}$ 表示点 $x$ 的第 $2^i$ 个祖先。
dfs 预处理深度信息时，也可以预处理出 $\text{fa}_{x,i}$：
- 首先考虑$i$的范围：$2^i\le d_x$（前面说的，$d_x$ 表示结点 $x$ 的深度），所以有$0\le i\le \lfloor\log_2 d_x\rfloor$。
- 对于 $i=0$，$2^i=2^0=1$，所以直接令 $\text{fa}_{x,0}=(x\text{的父亲})$ 即可。
- 对于 $1\le i\le \lfloor\log_2 d_x\rfloor$，$x$ 的第 $2^i$ 个祖先可看作 $x$ 的第 $2^{i-1}$ 个祖先的第 $2^{i-1}$ 个祖先（$2^{i-1}+2^{i-1}=2^i$），即：
  $$ \text{fa}_{x,i}=\text{fa}_{\text{fa}_{x,i-1},i-1} $$

求解步骤：

使 $u,v$ 的深度相同：计算出 $u,v$ 两点的深度之差，设其为 $y$。通过将 $y$ 进行二进制拆分，我们将 $y$ 次游标跳转优化为「$y$ 的二进制表示所含 1 的个数」次游标跳转（详见代码）。
特判：如果此时$u=v$，直接返回 $u$ 或 $v$ 作为 LCA 结果。
同时上移$u$和$v$：从 $i=\lfloor\log_2 d_u\rfloor$ 开始循环尝试，一直尝试到 $0$（包括 $0$），如果 $\text{fa}_{u,i}\not=\text{fa}_{v,i}$，则 $u\gets\text{fa}_{u,i},v\gets\text{fa}_{v,i}$，那么最后的 LCA 为 $\text{fa}_{u,0}$。

时间复杂度分析：

预处理：$\mathcal O(N)$ DFS $\times~\mathcal O(\log N)$ 预处理 $=\mathcal O(N\log N)$
单次查询：平均 $O(\log N)$，最坏 $O(\log N)$
预处理 + $Q$ 次查询：$\mathcal O(N+Q\log N)$

另外倍增算法可以通过交换 fa 数组的两维使较小维放在前面。这样可以减少 cache miss 次数，提高程序效率。

参考代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


#include <cstdio>
#include <vector>
#include <cmath>
#define maxn 500005
using namespace std;

vector<int> G[maxn];
int fa[maxn][19]; // 2^19=524288
int depth[maxn];

void dfs(int v, int par)
{
 fa[v][0] = par;
 int d = depth[v] + 1;
 for(int i=1; (1<<i)<d; i++)
 fa[v][i] = fa[fa[v][i - 1]][i - 1];
 for(int u: G[v])
 if(u != par)
 depth[u] = d, dfs(u, v);
}

inline int lca(int u, int v)
{
 if(depth[u] < depth[v])
 u ^= v ^= u ^= v;
 int m = depth[u] - depth[v];
 for(int i=0; m; i++, m>>=1)
 if(m & 1)
 u = fa[u][i];
 if(u == v) return u; // 这句不能丢
 for(int i=log2(depth[u]); i>=0; i--)
 if(fa[u][i] != fa[v][i])
 u = fa[u][i], v = fa[v][i];
 return fa[u][0];
}

int main()
{
 int n, q, root;
 scanf("%d%d%d", &n, &q, &root);
 for(int i=1; i<n; i++)
 {
 int x, y;
 scanf("%d%d", &x, &y);
 G[--x].push_back(--y);
 G[y].push_back(x);
 }
 depth[--root] = 0;
 dfs(root, -1);
 while(q--)
 {
 int u, v;
 scanf("%d%d", &u, &v);
 printf("%d\n", lca(--u, --v) + 1);
 }
 return 0;
}

习题

题目链接：洛谷 P8805 [蓝桥杯 2022 国 B] 机房
题解：https://best-blogs.blog.luogu.org/solution-p8805

总结

本文详细讲解了 LCA 问题以及求解 LCA 的两种算法。对比如下：

算法	预处理时间复杂度	单次查询时间复杂度¹	空间复杂度	能否通过例题²？
朴素算法	$\mathcal O(N)$	$\mathcal O(N)$	$\mathcal O(N)$	❌
倍增算法	$\mathcal O(N\log N)$	$\mathcal O(\log N)$	$\mathcal O(N\log N)$	✔️

创作不易，希望大家能给个三连，感谢支持！

此时间复杂度按照最坏情况计算。 ↩︎
例题：洛谷 P3379 【模板】最近公共祖先（LCA） ↩︎

【算法笔记】【专题】RMQ 问题：ST表/树状数组/线段树

Thu, 05 Jan 2023 22:48:00 +0800

前言

好久没更算法笔记专栏了，正好学了新算法来更新……
这也是本专栏的第一个专题问题，涉及到三种数据结构，如果写得有问题请各位大佬多多指教，谢谢！

关于 RMQ 问题

RMQ 的全称是 Range Minimum/Maximum Query，即区间最大/最小值问题。

本文中，我们的算法以求最大值为例（最小值基本一致）。题面如下：

给定一个长为$N$的序列$A=(A_1,A_2,\dots,A_N)$。
有$Q$个询问，第$i$个询问如下：
$\to~$给定$1\le l_i\le r_i\le N$，求区间$[l_i,r_i]$的最大值，即$\displaystyle\max_{j=l_i}^{r_i} A_j$。

下面，我们将从暴力算法开始，逐步讲解 RMQ 问题的常用解法。

通用的 RMQ 问题（除暴力外所有算法都能通过）：

洛谷 P1816 忠诚（标准的RMQ，没有任何变动，全篇通用例题）
洛谷 P2880 [USACO07JAN] Balanced Lineup G
洛谷 P2251 质量检测
洛谷 P8818 [CSP-S 2022] 策略游戏（有一定思维难度）

解法

暴力法

我们先读取序列$A$，再逐个读取询问，对于每个询问直接遍历$A_l\dots A_r$，最终输出结果。
总时间复杂度为$\mathcal O(\sum r_i-l_i)=\mathcal O(NQ)$。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


#include <cstdio>
#define maxn 100005
using namespace std;

int a[maxn];

int main()
{
 int n, q;
 scanf("%d%d", &n, &q);
 for(int i=0; i<n; i++)
 scanf("%d", a + i);
 while(q--)
 {
 int l, r;
 scanf("%d%d", &l, &r);
 l --, r --;
 int res = a[l];
 for(int i=l+1; i<=r; i++)
 if(a[i] < res)
 res = a[i];
 printf("%d ", res);
 }
 return 0;
}

然而，当你提交到洛谷 P1816时……

肯定还是时间复杂度的锅，算法需要进一步优化。

Sparse Table

Sparse Table（以下称ST表）是用于静态求解 RMQ 问题的数据结构。

静态求解是指在原始序列不改变的情况下求解问题。或者说，ST表不能直接进行修改操作。

ST表的初始化时间复杂度为$\mathcal O(N\log N)$，单次查询时间复杂度为$\mathcal O(1)$。

存储结构

ST表的本质是一个$N\times\lceil\log N\rceil$的二维数组，其定义如下（令$A$表示原数组，求最小值同理）：

$$ st[i][j]=\max\{A_i,A_{i+1},\dots,A_{i+2^j-1}\} $$

也就是说，$st[i][j]$表示从$A_i$开始，$2^j$个元素中的最大值。这运用了倍增的思想。

下面考虑如何快速初始化整个数组。

初始化

根据倍增的常用算法，使用类似于DP的方式填满整个表：

$$ st[i][j]=\max\{st[i][j-1],st[i+2^{j-1}][j-1]\} $$

填表时，先枚举$j$，再枚举$i$。由于整个表共有大约$N\log N$个状态，而计算一个状态值的时间复杂度为$\mathcal O(1)$，所以初始化的总时间复杂度为$\mathcal O(N\log N)$。

伪代码如下：

1
2
3
4
5
6
7


function init() {
 for i = 1 to N
 st[i][0] = A[i]
 for j = 1 to log2(N)
 for i = 1 to (N + 1 - 2^j)
 st[i][j] = max(st[i][j - 1], st[i + 2^(j-1)][j - 1])
}

C++ 实现：

1
2
3
4
5
6
7
8


void init()
{
 for(int i=0; i<n; i++)
 st[i][0] = A[i];
 for(int j=1; j<=log2(n); j++)
 for(int i=0; i+(1<<j)<=n; i++) // 注意必须是<=n，1<<j即为2^j
 st[i][j] = max(st[i][j - 1], st[i + (1 << j - 1)][j - 1]);
}

查询

对于$[l,r)$区间的 RMQ 查询，根据ST表的原理，我们要找到两个区间$[l,a)$和$[b,r)$，使得它们的并集正好为$[l,r)$。即：$l\le b\le a\le r$。

为什么是并集?
$\to~$因为$\max(a,a)=a$，所以重复的不影响结果。
$\to~$如果出现遗漏，且遗漏的正好为最大/最小值，那会影响最终结果，所以不能遗漏。
$\to~$如果检查到了多余的元素，且多余的正好大于原区间的最大值，会使查询结果变大，所以不能有多余。
综上，必须满足$[l,a)$和$[b,r)$的并集正好为$[l,r)$才能查询。

要满足上述条件，我们可以让$a$尽可能靠近$r$，让$b$尽可能靠近$l$，来达到这样的效果。
此时，我们还需要满足并集的条件$l\le a,b\le r$，因此我们需要找到最大的$k$，使得$a=l+2^k$，$b=r-2^k$。

则有

$$ \left\{ \begin{array}{c} l+2^k\le r \\ r-2^k\ge l \end{array} \right.~~\to~~ 2^k\le r-l\\ ~\\ \to~k\le \log_2(r-l) $$

又因为$k$必须是整数，所以取$k=\lfloor\log_2(r-l)\rfloor$即可。

1
2
3
4
5
6


// query(l, r) = max(A[l], ..., A[r - 1])
inline int query(int l, int r)
{
 int k = log2(r - l);
 return max(st[l][k], st[r - (1 << k)][k]);
}

完整实现

下面给出用Sparse Table解决例题的完整代码。总时间复杂度为$\mathcal O(Q+N\log N)$。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


#include <cstdio>
#include <cmath>
#include <algorithm>
#define maxn 100005
using namespace std;

int st[maxn][17]; // 2^17=131072

void init(int n)
{
 for(int j=1, t=log2(n); j<=t; j++)
 for(int i=0; i+(1<<j)<=n; i++)
 st[i][j] = min(st[i][j - 1], st[i + (1 << j - 1)][j - 1]);
}

inline int query(int l, int r)
{
 int k = log2(r - l);
 return min(st[l][k], st[r - (1 << k)][k]); // 注意此题为min，不是求max
}

int main()
{
 int n, q;
 scanf("%d%d", &n, &q);
 for(int i=0; i<n; i++)
 scanf("%d", st[i]); // 直接读入到ST表中，节约时间和空间
 init(n);
 while(q--)
 {
 int l, r;
 scanf("%d%d", &l, &r);
 // 此处注意因为是左闭右开区间[l,r)，所以只有l需要-1
 printf("%d ", query(--l, r));
 }
 return 0;
}

运行时间：$128\mathrm{ms}$
使用内存：$6.90\mathrm{MB}$

树状数组

关于树状数组的原理我已经在这篇文章中讲过，这里不再多说了。下面我们考虑如何应用树状数组解决 RMQ 问题。

原算法

树状数组可以用lowbit操作实现prefixSum（前缀和）以及update（更新）操作，时间复杂度均为$\mathcal O(N\log N)$。不仅是加法，对于任意满足结合律的运算这两种操作都有效。

我们来简单实现一下支持prefixMax和update操作的树状数组：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#define INF 2147483647
#define lowbit(x) ((x) & -(x))
inline void setmax(int& x, int y) { if(y > x) x = y; }

int n, A[N], bit[N];

// max(A[1], ..., A[i])
inline int prefixMax(int i)
{
 int res = -INF;
 for(; i>0; i-=lowbit(i))
 setmax(res, bit[i]);
 return res;
}

// A[i] = max(A[i], val)
inline void update(int i, int val)
{
 for(; i<=n; i+=lowbit(i))
 setmax(bit[i], val);
}

若要初始化树状数组，可以利用update操作进行$\mathcal O(N\log N)$的初始化：

1
2
3
4
5
6
7


inline void init()
{
 for(int i=1; i<=n; i++)
 bit[i] = -INF; // 这一段不要忘！
 for(int i=1; i<=n; i++)
 update(i, A[i]);
}

另外，我们也可以用子节点直接更新父节点，达到$\mathcal O(N)$建树的效果：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


inline void init()
{
 for(int i=1; i<=n; i++)
 bit[i] = A[i];
 for(int i=1; i<=n; i++)
 {
 int j = i + lowbit(i);
 if(j <= n) setmax(bit[j], bit[i]);
 }
}

考虑加法时我们计算rangeSum（区间和）的算法：

1
2
3
4


inline int rangeSum(int l, int r)
{
 return prefixSum(r) - prefixSum(l - 1);
}

也就是用$(A_1+A_2+\dots+A_r)-(A_1+A_2+\dots+A_{l-1})=A_l+\dots+A_r$。

现在回过来考虑 RMQ 的查询，Min/Max运算不可逆，所以很明显不能用这种计算方式。
下面我们来介绍针对 RMQ 的树状数组设计。

RMQ 树状数组

我们令$f(l,r)$表示rangeMax(l, r)，即$[l,r]$的区间最大值。
令$t=r-\mathrm{lowbit}(r)$，$A$表示原序列，$B$表示树状数组，考虑如下递推式：

$$ f(l,r)=\begin{cases} \max\{B_r,f(l,t)\} & (t\ge l)\\ \max\{A_r,f(l,r-1)\} & (t

等式$1$ 证明
根据树状数组的定义，$B_i=\max\{A_{i-\mathrm{lowbit}(i)+1},\dots,A_i\}=f(i-\mathrm{lowbit}(i)+1,i)$。
又有$f(l,r)=\max\{f(l,t),f(t+1,r)\}$，由于$f(t+1,r)=f(r-\mathrm{lowbit}(r)+1,r)=B_r$，所以当$t\ge l$时，$f(l,r)=\max\{B_r,f(l,t)\}$。

等式$2$ 证明
根据$\max$操作的结合律可得：$f(l,r)=\max\{f(l,r-1),f(r,r)\}=\max\{f(l,r-1),A_r\}$。
这个等式对于任意$r$都成立，但出于时间考虑，我们尽可能使用等式$1$（如果全用等式$2$就退化成了$\mathcal O(N)$的暴力）。

代码实现：

1
2
3
4
5
6
7
8


int rangeMax(int l, int r)
{
 if(l == r) return A[l];
 int t = r - lowbit(r);
 return t < l?
 max(A[r], rangeMax(l, r - 1)):
 max(bit[r], rangeMax(l, t));
}

这种查询方式的时间复杂度不好估算，可粗略地记为$\mathcal O(\log N)$。实际情况下，运行时间可能稍大于这个值。
另外，此算法对任意满足结合律的运算（如gcd，lcm）都有效。

完整实现

下面给出用树状数组解决例题的完整代码。总时间复杂度为$\mathcal O(N+Q\log N)$¹。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


#include <cstdio>
#include <algorithm>
#define maxn 100005
using namespace std;

#define lowbit(x) ((x) & -(x))

int a[maxn], bit[maxn];

int rangeMin(int l, int r)
{
 if(l == r) return a[l];
 int t = r - lowbit(r);
 return t < l?
 min(a[r], rangeMin(l, r - 1)):
 min(bit[r], rangeMin(l, t));
}

inline void init(int n)
{
 for(int i=1; i<=n; i++)
 bit[i] = a[i];
 for(int i=1; i<=n; i++)
 {
 int j = i + lowbit(i);
 if(j <= n)
 bit[j] = min(bit[j], bit[i]);
 }
}

int main()
{
 int n, q;
 scanf("%d%d", &n, &q);
 for(int i=1; i<=n; i++)
 scanf("%d", a + i);
 init(n);
 while(q--)
 {
 int l, r;
 scanf("%d%d", &l, &r);
 printf("%d ", rangeMin(l, r));
 }
 return 0;
}

运行时间：$207\mathrm{ms}$
使用内存：$1.10\mathrm{MB}$

另外，我们还可以把rangeMin写成非递归的形式，以进一步节省运行时间：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


#include <cstdio>
#define maxn 100005
using namespace std;

#define INF 2147483647
#define lowbit(x) ((x) & -(x))
inline void setmin(int& x, int y) { if(y < x) x = y; }

int a[maxn], bit[maxn];

int rangeMin(int l, int r)
{
 int res = INF;
 while(l <= r)
 {
 int t = r - lowbit(r);
 if(t < l) setmin(res, a[r--]);
 else setmin(res, bit[r]), r = t;
 }
 return res;
}

inline void init(int n)
{
 for(int i=1; i<=n; i++)
 bit[i] = a[i];
 for(int i=1; i<=n; i++)
 {
 int j = i + lowbit(i);
 if(j <= n) setmin(bit[j], bit[i]);
 }
}

int main()
{
 int n, q;
 scanf("%d%d", &n, &q);
 for(int i=1; i<=n; i++)
 scanf("%d", a + i);
 init(n);
 while(q--)
 {
 int l, r;
 scanf("%d%d", &l, &r);
 printf("%d ", rangeMin(l, r));
 }
 return 0;
}

运行时间：$135\mathrm{ms}$
使用内存：$1.14\mathrm{MB}$

线段树

线段树和树状数组一样，都是解决区间问题的树状结构。不过线段树的应用范围更加广泛，时间复杂度与树状数组基本一致，但每种操作都有一个$3\thicksim4$之间的常数。线段树建树（初始化）的时间复杂度为$\mathcal O(N)$，单次区间查询的时间复杂度为$\mathcal O(\log N)$。

RMQ 问题不涉及修改操作，因此我们暂时不考虑这种操作。

如图即为$N=10$的一棵线段树。可以发现，线段树本质上是一棵二叉树，每个结点代表一个区间，其存储的值为这个区间的区间和（在 RMQ 问题中为区间最大/最小值）。一个结点的左儿子结点和右儿子结点对应区间的并集正好为这个结点对应的区间（叶子结点除外），且左右两区间的长度的差值不超过$1$。

从树的角度考虑，$n_1=0$，即没有子结点数量为$1$的结点。

一般的，若一个结点对应的区间为$[l,r]$：

$l = r$：此结点为叶子结点。
$l < r$，令$m=\lfloor\frac{l+r}2\rfloor$：
- 左子结点对应的区间为$[l,m]$。
- 右子结点对应的区间为$[m+1,r]$。

顺便纠正一下线段树的几个误区：
~~线段树是一棵完全二叉树。~~
请仔细看看图。
~~线段树是一棵二叉搜索树。~~
反正我是没找到哪里这样定义的。百度百科 OI Wiki
~~线段树上同一深度的结点所对应的区间长度一定相等。~~
看看图，$[1,3]$和$[4,5]$两个区间，长度明显不相等。
特例：当$N$是$2$的整数次幂时，这句话一定成立。

存储结构

线段树采用堆式储存法，根结点为$1$，结点$u$的父亲为$\lfloor\frac u2\rfloor$，左子结点为$2u$，右子结点为$2u+1$。

可以用位运算优化：

$u$的父亲：$\lfloor\frac u2\rfloor=~$u >> 1
$u$的左儿子：$2u=~$u << 1
$u$的右儿子：$2u+1=~$u << 1 | 1（或u << 1 ^ 1）

1
2
3
4
5
6
7
8


// 数组定义
int a[N], c[4 * N];

// 宏定义
#define INF 2147483647
#define ls(x) (x << 1) // 左儿子结点
#define rs(x) (x << 1 | 1) // 右儿子结点
#define par(x) (x >> 1) // 父亲结点

下文中，我们令$N$表示元素个数，$A$表示原数组，$C$表示线段树（数组形式存储）。
可以证明，线段树的结点个数不会超过$4N-5$，所以我们可以把$C$的长度设为$4N$。

建树（初始化）

对于一个结点数据的计算，我们可以先递归地初始化其左子树，再到右子树，最后两儿子的数据取$\max$即可。

代码实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// 结点p, 区间[l, r]建树
void build(int l, int r, int p)
{
 if(l == r)
 {
 c[p] = a[l];
 return;
 }
 int m = l + r >> 1;
 build(l, m, ls(p));
 build(m + 1, r, rs(p));
 c[p] = max(c[ls(p)], c[rs(p)]);
}

区间查询

同样采用递归的方式，设$p$为当前结点，$[l,r]$为当前结点区间，$[a,b]$为当前查询区间，函数返回$[l,r]$和$[a,b]$的交集的区间和：

如果$[l,r]$是$[a,b]$的子集（$a\le l\le r\le b$），直接返回当前结点对应的区间和。
否则，递归查询左右子树，如果没有交集则不查询。返回查询的子树的最大值。

如果上面不是很好理解，可以直接看代码实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 结点p, 查询区间[a, b], 当前区间[l, r]
int query(int l, int r, int a, int b, int p)
{
 if(a <= l && r <= b) return c[p];
 int m = l + r >> 1, res = -INF;
 if(m >= a) res = max(res, query(l, m, a, b, ls(p)));
 // m + 1 <= b 即为 m < b
 if(m < b) res = max(res, query(m + 1, r, a, b, rs(p)));
 return res;
}

完整实现

下面给出用线段树解决例题的完整代码。总时间复杂度为$\mathcal O(N+Q\log N)$。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


#include <cstdio>
#include <algorithm>
#define maxn 100005
using namespace std;

#define INF 2147483647
#define ls(x) (x << 1)
#define rs(x) (x << 1 | 1)
#define par(x) (x >> 1)

int a[maxn], c[maxn << 2];

void build(int l, int r, int p)
{
 if(l == r)
 {
 c[p] = a[l];
 return;
 }
 int m = l + r >> 1;
 build(l, m, ls(p));
 build(m + 1, r, rs(p));
 c[p] = min(c[ls(p)], c[rs(p)]);
}

int query(int l, int r, int a, int b, int p)
{
 if(a <= l && r <= b) return c[p];
 int m = l + r >> 1, res = INF;
 if(m >= a) res = min(res, query(l, m, a, b, ls(p)));
 if(m < b) res = min(res, query(m + 1, r, a, b, rs(p)));
 return res;
}

int main()
{
 int n, q;
 scanf("%d%d", &n, &q);
 for(int i=0; i<n; i++)
 scanf("%d", a + i);
 build(0, n - 1, 1);
 while(q--)
 {
 int l, r;
 scanf("%d%d", &l, &r);
 printf("%d ", query(0, n - 1, --l, --r, 1));
 }
 return 0;
}

运行时间：$163\mathrm{ms}$
使用内存：$1.78\mathrm{MB}$

总结

我们来对比一下四种算法，从理论的角度：

算法	预处理时间复杂度	单次查询时间复杂度	空间复杂度	符合题目要求？²
暴力	$\mathcal O(1)$	$\mathcal O(N)$	$\mathcal O(N)$	❌
ST表	$\mathcal O(N\log N)$	$\mathcal O(1)$	$\mathcal O(N\log N)$	✔️
树状数组	$\mathcal O(N)$或$\mathcal O(N\log N)$	$\mathcal O(\log N)$	$\mathcal O(N)$	✔️
线段树	$\mathcal O(N)$	$\mathcal O(\log N)$	$\mathcal O(N)$	✔️

从洛谷 P1816上实际运行情况的角度（暴力TLE，不考虑）：

算法	运行时间	内存占用	代码长度
ST表	$128\mathrm{ms}$	$6.90\mathrm{MB}$	$625\mathrm B$
树状数组（递归）³	$207\mathrm{ms}$	$1.10\mathrm{MB}$	$720\mathrm B$
树状数组（非递归）³	$135\mathrm{ms}$	$1.14\mathrm{MB}$	$786\mathrm B$
线段树	$163\mathrm{ms}$	$1.78\mathrm{MB}$	$905\mathrm B$

可以看出，ST表写起来简单省事，运行时间也是最快，不过内存占用稍高，毕竟空间复杂度是$\mathcal O(N\log N)$；
树状数组可以说是均衡了时间与空间，尽量使用非递归查询，比递归速度快$53\%$，当然如果想省事也可以使用递归式查询；
线段树可以说是完全输给了树状数组（非递归），不过线段树功能比较多，用来做 RMQ 可以说是大材小用。所以线段树在 RMQ 问题中没什么优势，有一些缺点还是可以理解的。

本文到此结束，希望大家给个三连！
这也是我在$2023$年写的第一篇文章（也是我的第一篇万字长文），祝大家新年快乐！

直接调用update建树的方法总时间复杂度为$\mathcal O((N+Q)\log N)$，这里采用的是前面说的$\mathcal O(N)$快速建树。在此问题中，由于不需要修改，使用$\mathcal O(N)$建树可省去update方法。 ↩︎
以洛谷 P1816为准，$N\le 10^5$，所以单次查询时间复杂度不能超过$\mathcal O(\sqrt N)$。 ↩︎
此处指递归/非递归的单次查询实现，两者其他操作完全一致。 ↩︎ ↩︎

AtCoder Beginner Contest 274 A~E 题解

Mon, 24 Oct 2022 08:30:00 +0800

吐槽：这比赛名字为啥没有英文版。。。

A - Batting Average

题目大意

给定整数$A,B$，输出$\frac BA$，保留三位小数。

$1\le A\le 10$
$0\le B\le A$

分析

签到题，使用printf或cout格式化输出即可。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 int a, b;
 scanf("%d%d", &a, &b);
 printf("%.3Lf\n", (long double)b / a);
 return 0;
}

B - Line Sensor

题目大意

给定一个$H\times W$的网格，每个方格内都是.或#。
求每一列的#的个数，分别输出。

$1\le H,W\le 1000$

分析

开一个数组ans[W]，存储每一列的#的个数。输入时统计一下即可。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <cstdio>
#define maxn 1005
using namespace std;

char s[maxn];
int ans[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(n--)
 {
 scanf("%s", s);
 for(int i=0; i<m; i++)
 if(s[i] == '#')
 ans[i] ++;
 }
 for(int i=0; i<m; i++)
 printf("%d ", ans[i]);
 return 0;
}

C - Ameba

题目大意

有一棵由$2N+1$个结点组成的树，根结点是$1$。

整棵树用一个序列$A=(A_1,A_2,\dots,A_N)$表示：

结点$A_i$是$2i$和$2i+1$的父亲。

求每个结点的深度。

$1\le N\le 2\times 10^5$
$1\le A_i\le 2i-1$

解法1

根据题意构造树的邻接表，从根结点$1$开始向下搜索，从而推出每个结点的深度。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <cstdio>
#include <vector>
#define maxn 200005
using namespace std;

vector<int> G[maxn << 1];
int dep[maxn << 1];

void dfs(int v, int par)
{
 for(int u: G[v])
 if(u != par)
 {
 dep[u] = dep[v] + 1;
 dfs(u, v);
 }
}

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=1; i<=n; i++)
 {
 int x;
 scanf("%d", &x);
 G[x].push_back(i << 1);
 G[x].push_back(i << 1 | 1);
 }
 dep[1] = 0;
 dfs(1, -1);
 for(int i=1; i<=(n<<1)+1; i++)
 printf("%d\n", dep[i]);
 return 0;
}

解法2（最优解）

我们从解法$1$进一步考虑：由于$1\le A_i\le 2i-1$，所以$A_i$一定在$2i$和$2i+1$前被处理，那么直接在输入时计算depth[2*i] = depth[2*i+1] = depth[A[i]] + 1即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <cstdio>
#include <vector>
#define maxn 200005
using namespace std;

int dep[maxn << 1];

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=1; i<=n; i++)
 {
 int x;
 scanf("%d", &x);
 dep[i << 1] = dep[i << 1 | 1] = dep[x] + 1;
 }
 for(int i=1; i<=(n<<1)+1; i++)
 printf("%d\n", dep[i]);
 return 0;
}

D - Robot Arms 2

题目大意

给定整数$N$和序列$A=(A_1,A_2,\dots,A_N)$，能否在平面直角坐标系中通过$N$步从$(0,0)$走到$(x,y)$？每一步如下：

第$1$步：从$(0,0)$走到$(A_1,0)$（向右前进$A_1$格）。
第$i$步（$i > 1$）先左转或右转$90\degree$，再前进$A_i$格。

$2\le N\le 10^3$
$1\le A_i\le 10$
$-10^4\le x,y\le 10^4$

分析

先考虑另一个问题：

在一维坐标系中，从$s$开始进行$N$次位移，第$i$次的操作如下：
$\to~$选择左移或者右移$A_i$个长度单位，即坐标加上$A_i$或者减去$A_i$。
$N$次操作后是否能到达终点$t$？注意：必须为最终到达，中途经过不算数！

很容易想到使用一个简单的$\text{DP}$，令$f(i,j)$表示前$i$次操作后是否能达到$j$（$0$或$1$），转移显而易见：$f(i,j)=f(i-1,j-A_i)\vee f(i-1,j+A_i)$。
但是这样的时间复杂度很高，高达$\mathcal O(Nk)$，其中$k$为坐标系大小。

稍加思考会发现，只有小部分坐标能真正达到，其余都没有必要参与转移，所以使用set进行存储，$S_i$表示前$i$次操作后能到达的坐标集合，利用$S_i=(S_{i-1}+A_i)\cup(S_{i-1}-A_i)$进行转移即可。

代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


inline bool check(vector<int>& v, int start, int target)
{
 set<int> s;
 s.insert(start);
 for(int d: v)
 {
 set<int> ls = s;
 s.clear();
 for(int x: ls)
 s.insert(x + d), s.insert(x - d);
 }
 return s.count(target);
}

然后回到原来的问题，发现由于$x$和$y$两个坐标互不影响，所以把两个坐标轴分别独立出来是没有问题的，可以转换为刚才的子问题：

对于$x$坐标，起始位置为$A_1$，终点为$x$，移动序列为$A_3,A_5,\dots$。
对于$y$坐标，起始位置为$0$，终点为$y$，移动序列为$A_2,A_4,\dots$。

只要两个子问题的条件都满足，那么一定存在一种可行的操作序列来满足原题的要求。
至此，问题得到解决。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <cstdio>
#include <vector>
#include <set>
using namespace std;

inline bool check(vector<int>& v, int start, int target)
{
 set<int> s;
 s.insert(start);
 for(int d: v)
 {
 set<int> ls = s;
 s.clear();
 for(int x: ls)
 s.insert(x + d), s.insert(x - d);
 }
 return s.count(target);
}

int main()
{
 int n, x, y;
 scanf("%d%d%d", &n, &x, &y);
 vector<int> a(n);
 for(int& t: a) scanf("%d", &t);
 vector<int> dx;
 for(int i=2; i<n; i+=2)
 dx.push_back(a[i]);
 if(!check(dx, a[0], x)) { puts("No"); return 0; }
 vector<int> dy;
 for(int i=1; i<n; i+=2)
 dy.push_back(a[i]);
 puts(check(dy, 0, y)? "Yes": "No");
 return 0;
}

E - Booster

题目大意

在平面直角坐标系中，有$N$个城市和$M$个箱子。城市$i$位于坐标$(X_i,Y_i)$，箱子$i$则在坐标$(P_i,Q_i)$。

Takahashi现在要从原点$(0,0)$开始访问$N$个城市，中途箱子可去可不去。他初始的速度为$1$，每碰到一个箱子都可以将速度提升至原先的两倍（每个箱子只能加速一次）。

至少要用多少时间，才能将$N$个城市都访问至少一次？

分析

参考AtCoder 官方题解的做法，这里不详细解释。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


#include <cstdio>
#include <cmath>
#define maxn 17
using namespace std;

inline double ppow(int x) { return 1.0 / (1 << __builtin_popcount(x)); }
inline void setmin(double& x, double y)
{
 if(y < x) x = y;
}

double x[maxn], y[maxn], dp[maxn][1 << maxn];

int main()
{
 // Input
 int n, m;
 scanf("%d%d", &n, &m);
 m += n;
 for(int i=0; i<m; i++)
 scanf("%lf%lf", x + i, y + i);
 int mx = 1 << m;
 for(int i=0; i<m; i++)
 for(int s=0; s<mx; s++)
 dp[i][s] = 1e18;

 // DP: Initial state
 for(int i=0; i<m; i++)
 dp[i][1 << i] = hypot(x[i], y[i]);

 // DP: Transfer
 for(int s=1; s<mx; s++)
 {
 double coef = ppow(s >> n);
 for(int i=0; i<m; i++)
 {
 if(!(s >> i & 1)) continue;
 for(int j=0; j<m; j++)
 {
 if(s >> j & 1) continue;
 setmin(dp[j][s | (1 << j)],
 dp[i][s] + hypot(x[i] - x[j], y[i] - y[j])*coef);
 }
 }
 }

 // Output
 double ans = 1e18;
 for(int i=0, t=1<<n; i<m; i++)
 for(int s=t-1; s<mx; s+=t)
 setmin(ans, dp[i][s] + dp[i][1 << i] * ppow(s >> n));
 printf("%.10f\n", ans);
 return 0;
}

【算法笔记】位运算详解

Tue, 18 Oct 2022 08:30:00 +0800

前言

突然想到位运算是个好东西，就来水一波文章了……

注意：我把能想到的有关位运算的所有内容都放进来了，所以篇幅较长，请谅解！若有写的不清楚或者不够详细的地方欢迎在评论区补充，谢谢支持！

本文中参考代码均使用C++编写。

废话不多说，下面步入正题。

基本运算

有一定基础的可以跳过该部分。

位运算的简要法则：

符号	描述	规则
`&`	按位与	两位都为1才为1，不同为0
`\|`	按位或	两位都为0才为0，不同为1
`^`	异或	相同为0，不同为1
`~`	取反	0变1，1变0
`<<`	左移	二进制位向左移动，高位去掉，低位补0
`>>`	右移	二进制位向右移动，低位去掉，高位补0

详细解释：

取反

取反（~x）是最简单的位运算操作，只有一个参数$x$。将参数上的每一位对应取反即可。例如：
~0011 = 1100
~1011 = 0100
性质：~(~x) = x

按位与

按位与（x & y）有两个参数$x$和$y$。对于$x$和$y$中的每个对应位，参照下表输出到结果的对应位：

$x$	$y$	`x & y`
$0$	$0$	$0$
$0$	$1$	$0$
$1$	$0$	$0$
$1$	$1$	$1$

例子：
0011 & 1100 = 0000
1010 & 1011 = 1010

性质：

交换律：a & b = b & a
结合律：a & b & c = a & (b & c)
自与：a & a = a
与$0$：0 & a1 & a2 & a3 & ... = 0
与$\infty$（全$1$）：a & inf = a

按位或

按位与（x | y）有两个参数$x$和$y$。对于$x$和$y$中的每个对应位，参照下表输出到结果的对应位：

$x$	$y$	`x \| y`
$0$	$0$	$0$
$0$	$1$	$1$
$1$	$0$	$1$
$1$	$1$	$1$

例子：
1100 | 0011 = 1111
1010 | 0001 = 1011

性质：

交换律：a | b = b | a
结合律：a | b | c = a | (b | c)
自或：a | a = a
或$0$：a | 0 = a
或$\infty$（全$1$）：a | inf = inf

异或

异或（$x\oplus y$或x ^ y）有两个参数$x$和$y$。对于$x$和$y$中的每个对应位，参照下表输出到结果的对应位：

$x$	$y$	$x\oplus y$
$0$	$0$	$0$
$0$	$1$	$1$
$1$	$0$	$1$
$1$	$1$	$0$

举例：
1000 ^ 1011 = 0011
0101 ^ 1010 = 1111

性质：

交换律：$a\oplus b=b\oplus a$
结合律：$a\oplus b\oplus c=a\oplus(b\oplus c)$
自异或：$a\oplus a=0$
异或$0$：$a\oplus 0=a$
多重异或：$a\oplus b\oplus b=a\oplus (b\oplus b)=a\oplus 0=a$
异或$\infty$（全$1$）：$a\oplus \infty=~$~a
若$a\oplus b=c$，则$a\oplus c=b$。

位移

位移分为左移（<<）和右移（>>）。

a << b：将$a$末尾添上$b$个$0$的结果。
a >> b：从$a$末尾删掉$b$位的结果。

性质：

(a << b) >> b = a
a << b$~=a\times 2^b$
a >> b$~=\lfloor\frac a {2^b}\rfloor$

练习题

判断$2$的整数次幂

题意：给定整数$N$，判断其是否为$2$的整数次幂。

洛谷 P1100 高低位交换

题意：给定一个$32$位整数$x$，在二进制下交换其前$16$位与后$16$位，输出最终的数。

答案为ans = (x >> 16) | (x << 16)，这样解释：

数值	前$16$位	后$16$位
$x$	$A$	$B$
`x >> 16`	$16$个$0$	$A$
`x << 16`	$B$	$16$个$0$
`ans`	$B$	$A$

注意此处使用$32$位无符号整数进行计算，这样x << 16会自然溢出，导致前$16$位被丢弃，恰好满足要求。

参考程序：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 unsigned int x;
 scanf("%u", &x);
 printf("%u\n", (x >> 16) | (x << 16));
 return 0;
}

找出不同的数

给定一个序列$A=(A_1,A_2,\dots,A_{2N+1})$，其中有$N$个数各出现$2$次，还有一个数正好出现$1$次。找到这个数。请尽可能优化程序的时间和空间复杂度。

- 时间$\mathcal O(N)$或$\mathcal O(N\log N)$，空间$\mathcal O(N)$解法
简单统计每个数的出现次数，最后找到正好出现$1$次的数。

- 时间$\mathcal O(N)$，空间$\mathcal O(1)$解法
考虑所有数的异或和$S=A_1\oplus A_2\oplus\dots\oplus A_{2N+1}$，则$A$中所有出现两次的数抵消为$0$，剩下的即为唯一出现一次的数，所以直接输出$S$即可。

参考程序：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <cstdio>
using namespace std;

int main()
{
 int n;
 scanf("%d", &n);
 n = (n << 1) + 1;
 int ans = 0;
 while(n--)
 {
 int x;
 scanf("%d", &x);
 ans ^= x;
 }
 printf("%d\n", ans);
 return 0;
}

AtCoder Beginner Contest 261 E - Many Operations

解法：对于$i=1,2,\dots,N$，记录操作$1,2,\dots,i$后每一位上的$0$和$1$分别变成什么，可以在$\mathcal O(N)$的时间内用类似于前缀和的方法完成；最后用位运算快速模拟$N$次连续操作即可，总时间复杂度为$\mathcal O(N)$。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// https://atcoder.jp/contests/abc261/submissions/33495431
#include <cstdio>
using namespace std;

int main()
{
 unsigned n, c, zero = 0, one = 0xffffffff;
 scanf("%d%d", &n, &c);
 while(n--)
 {
 int t, a;
 scanf("%d%d", &t, &a);
 if(t == 1) one &= a, zero &= a;
 else if(t == 2) one |= a, zero |= a;
 else one ^= a, zero ^= a;
 printf("%d\n", c = (c & one) | (~c & zero));
 }
 return 0;
}

扩展概念&运算

lowbit

lowbit(x)即为二进制下$x$的最低位，如lowbit(10010) = 10、lowbit(1) = 1。严格来说$0$没有lowbit，部分情况下可视为lowbit(0) = 1。利用lowbit函数可实现树状数组等数据结构。

lowbit 计算方式

暴力计算
简单粗暴的按位直接计算，如下：
1 2 3 4 5 6 7

int lowbit(int x) { int res = 1; while(x && !(x & 1)) x >>= 1, res <<= 1; return res; }
时间复杂度$\mathcal O(\log X)$。缺点：速度慢，代码长，没有体现位运算的优势
x & -x
巧妙利用lowbit(x) = x & -x。感兴趣的读者可自行尝试证明。
时间复杂度$\mathcal O(1)$。相比(1)来说，代码更短，速度更快。
x & (x - 1)
注意：x & (x - 1)不是lowbit(x)，而是x - lowbit(x)。
这种方法常用于树状数组中，可提升x - lowbit(x)的计算速度。

popcount

popcount(x)定义为$x$在二进制下$1$的个数，如popcount(10101) = 3，popcount(0) = 0。

popcount 计算方式

暴力计算检查
还是最粗暴的算法，通过枚举每一位并检查是否为$1$达到目的，时间复杂度为$\mathcal O(\log X)$。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


int popcount(int x)
{
 int res = 0;
 while(x)
 {
 res += x & 1;
 x >>= 1;
 }
 return res;
}

lowbit 优化
时间复杂度还是$\mathcal O(\log X)$，不过平均用时会比(1)快2~3倍左右。

1
2
3
4
5
6


int popcount(int x)
{
 int res = 0;
 for(; x; x&=x-1) res ++;
 return res;
}

builtin 函数（最快）
详见3.1 __builtin_popcount/__builtin_popcountll。

builtin 位运算函数

注意：后面带ll的传入long long类型，不带ll接受int类型。本部分内容按常用程度递减排序。
参考：https://blog.csdn.net/zeekliu/article/details/124848210

__builtin_popcount/__builtin_popcountll

返回参数在二进制下$1$的个数。

__builtin_ctz / __buitlin_ctzll

返回参数在二进制下末尾$0$的个数。

__buitlin_clz / __buitlin_clzll

返回参数在二进制下前导$0$的个数。

__builtin_ffs / __buitlin_ffsll

返回参数在二进制下最后一个1在第几位（从后往前）。
注意：一般来说，builtin_ffs(x) = __builtin_ctz(x) + 1。当$x=0$时，builtin_ffs(x) = 0。

__builtin_parity / __builtin_parityll

返回参数在二进制下$1$的个数的奇偶性（偶：0，奇：1），即__builtin_parity(x) = __builtin_popcount(x) % 2。
P.S. 这函数，不知是哪位神仙想出来的……

位运算的应用

子集表示法

对于集合$\{0,1,\dots,N-1\}$，我们使用一个$N$位的二进制整数$S$来表示它的一个子集。从右往左第$i$位表示子集是否包含了$i$。容易发现，对于任意子集$S$，$S\in [0,2^N-1]$，且对于任意$S\in [0,2^N-1]$，$S$都是$\{0,1,\dots,N-1\}$的一个有效子集。下面我们来讲这种子集表示的具体操作。

子集操作

子集的操作如下（规定$N$为集合元素个数）：

空集：$0$
满集：$2^N-1$（$N$个$1$）
集合$S$的元素个数：__builtin_popcount(S)或__builtin_popcountll(S)
集合$S$是否包含$i$：S >> i & 1
将$i$加入$S$（操作前$S$是否包含$i$不影响操作结果）：S |= 1 << i
将$i$从$S$中删除（操作前$S$必须包含$i$）：S ^= 1 << i
将$i$从$S$中删除（操作前$S$是否包含$i$不影响操作结果）：S &= ~(1 << i)
$S$和$T$的交集（$S$和$T$都包含的集合）：S & T
$S$和$T$的并集（$S$和$T$中有任意一个包含的集合）：S | T
$S$和$T$的差集（$S$和$T$中恰好有一个包含的集合）：S ^ T

子集枚举

讲了这么多，也该到子集的实际应用了吧。下面我们来看子集最初步的应用——子集枚举。

- 必会：枚举$N$个元素的所有子集
这个很简单，直接枚举$S\in [0,2^N-1]$即可。代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <cstdio>
using namespace std;

const int N = 3;

int main()
{
 printf("N = %d\n", N);
 for(int s=0, full=(1<<N)-1; s<=full; s++)
 {
 printf("Subset %d:", s + 1);
 for(int i=0; i<N; i++)
 if(s >> i & 1)
 printf(" %d", i);
 putchar('\n');
 }
 return 0;
}

- 必会：枚举子集的子集
如果我们想枚举$\{0,1,\dots,N-1\}$的子集的子集，怎么办？这是一个经典套路，常用于状压DP，写法如下：

1
2
3
4
5
6


for(int S=0; S<(1<<N); S++) // 枚举子集S
 for(int T=S; T; T=(T-1)&S) // 枚举子集的子集T
 {
 // Do something...
 printf("%d\n", t);
 }

请注意：这个算法的时间复杂度为$\mathcal O(3^N)$，不是$\mathcal O(4^N)$，使用此算法时请准确估算时间复杂度。

- 扩展：枚举$N$个元素中大小为$K$的子集
首先很容易想到先枚举所有$\{0,1,\dots,N-1\}$的所有子集，再依次检查大小是否为$K$。代码如下：

1
2
3
4
5
6


for(int s=0; s<(1<<n); s++)
{
 int cnt = __builtin_popcount(s);
 if(cnt != K) continue;
 // Do something...
}

这种做法虽然正确，也很易懂，但可惜效率太低，$2^N$次popcount操作浪费了很多时间。我们考虑优化。《挑战程序设计竞赛》上给出了一种算法，如下：

1
2
3
4
5
6
7
8
9


int S = (1 << k) - 1;
while(S < 1 << n)
{
 // Do something...
 printf("%d\n", S);
 // 移到下一个合法子集
 int x = S & -S, y = S + x;
 S = ((S & ~y) / x >> 1) | y;
}

这样可保证每次枚举到的都是大小为$K$的子集，可以大大提高算法效率。

扩展：std::bitset

bitset，顾名思义，即为用位运算操作的集合。
对于元素个数$N\in [1,64]$，集合$\{0,1,\dots,N-1\}$的任意子集都可以用一个$32$或$64$位整数表示出来，操作时间复杂度为$\mathcal O(1)$。那么对于$N > 64$，怎么办？我们可以用多个$32$或$64$位无符号整数拼凑为一个$N$位的bitset，容易发现其操作的时间复杂度为$\mathcal O(\frac Nw)$（$N$位的二进制数可用$\lceil\frac Nw\rceil$个$w$位无符号整数拼凑而成），其中$w$一般为$32$或$64$。

C++的Standard Template Library（STL）为我们提供了<bitset>头文件，用于bitset的定义。

用法如下：

函数/操作	作用
`b.any()`	`b`中是否存在至少1位的二进制位？
`b.none()`	`b`中不存在至少1位的二进制位吗？
`b.count()`	`b`中值为1的二进制位的个数
`b.size()`	`b`中二进制位的个数
`b[pos]`	访问`b`中`pos`处的二进制位
`b.test(pos)`	检测`b`中`pos`处的二进制位是否为1
`b.set(pos)`	把`b`中`pos`处的二进制位设置为1
`b.set()`	把`b`中的所有二进制位设置为1
`b.reset(pos)`	把`b`中`pos`处的二进制位设置为0
`b.reset()`	把`b`中的所有二进制位设置为0
`b.flip()`	把`b`中的所有二进制位按位取反
`b.flip(pos)`	把`b`中`pos`处的二进制位按位取反
`b.to_ulong()`	用`b`中所有的二进制位返回`unsigned long`值
`os << b`	把`b`的值输出到流`os`中

用法示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <cstdio>
#include <bitset> // 头文件
using namespace std;

int main()
{
 const int N = 500;
 bitset<N> S; // 定义大小为N的bitset S，初始为全0
 S.set(1); // 将S的第1位设为1
 S[0] = 1; // 将S的第0位设为1，注意bitset可使用下标访问和赋值
 S.reset(1); // 将S的第1位设为0
 printf("S[1]: %d\n", (int)S[1]); // 输出S第2位上的值
 printf("Count: %d\n", (int)S.count()); // S的popcount（二进制下1的个数）
 printf("Size: %d\n", (int)S.size()); // S的二进制位数（N）
 printf("None? %d\n", (int)S.none()); // S是否为空？
 printf("Any? %d\n", (int)S.any()); // S是否有1？
 bitset<N> T; // 定义一个新的bitset -- T
 T.set(); // T置为全1
 S.set(2), T.reset(2);
 printf("Intersection: %d\n", (int)(S & T).count()); // 交集
 printf("Union: %d\n", (int)(S | T).count()); // 并集
 printf("Difference: %d\n", (int)(S ^ T).count()); // 差集
 return 0;
}

习题：AtCoder Beginner Contest 258 G - Triangle

题意和解法见我的题解。

深度优先搜索（DFS）的位运算优化

本算法其实还是二进制表示子集的一种优化，不过内容较多，所以单独放了出来。

考虑经典的八皇后问题：

有一个$8\times 8$的国际象棋棋盘，要在其中摆$8$个皇后，求有多少种不同的摆法，使得任意两个皇后之间都没有互相攻击。
注：皇后的攻击范围是一个“米”字，如下图所示：

八皇后问题很容易求解，用一个简单的回溯就可以了。
考虑$N$皇后问题，即：

有一个$N\times N$的国际象棋棋盘，要在其中摆$N$个皇后，求有多少种不同的摆法，使得任意两个皇后之间都没有互相攻击。

此时，还是先用标准的「回溯」算法解决问题：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


#include <cstdio>
#define maxn 20
using namespace std;

bool row[maxn], diag_left[maxn << 1], diag_right[maxn << 1];
int ans, n;

void dfs(int i)
{
 if(i == n)
 {
 ans ++;
 return;
 }
 for(int j=0; j<n; j++)
 if(!row[j] && !diag_left[i + j] && !diag_right[i - j + n])
 {
 row[j] = diag_left[i + j] = diag_right[i - j + n] = true;
 dfs(i + 1);
 row[j] = diag_left[i + j] = diag_right[i - j + n] = false;
 }
}

int main()
{
 scanf("%d", &n);
 ans = 0;
 dfs(0);
 printf("%d\n", ans);
 return 0;
}

代码很移动，也不是重点，这里就不详细解释了。对于$N=13$，搜索时间约为$243\mathrm{ms}$；$N=14$，$1.31\mathrm s$；$N=15$，$8.14\mathrm s$；$N=16$…… $53.4\mathrm s$。

明显，这样的算法效率太低，我们来考虑使用位运算优化。
首先，我们把上面程序里的row、diag_left和diag_right换成一个int整数，赋值、取值全部改用位运算。但这样对整体的时间优化还是不大，我们要充分发挥位运算的优势——“百发百中”，即利用lowbit算法，确保每次枚举到的都是目前一步可放置的位置，减少不必要的判断。此时，我们改变diag_left和diag_right的含义，使diag_left表示左下-右上的$45\degree$对角线上当前一步可放置的皇后位置集合，diag_right同理。见代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


#include <cstdio>
using namespace std;

int ans, mx;

void dfs(int row, int diag_left, int diag_right)
{
 if(row == mx)
 {
 ans ++;
 return;
 }
 int a = mx & ~(row | diag_left | diag_right);
 while(a)
 {
 int p = a & -a; a ^= p;
 dfs(row | p, (diag_left | p) >> 1, (diag_right | p) << 1);
 }
}

int main()
{
 int n;
 scanf("%d", &n);
 ans = 0;
 mx = (1 << n) - 1;
 dfs(0, 0, 0);
 printf("%d\n", ans);
 return 0;
}

此时，计算$16$皇后只需$6.23\mathrm s$！
习题：洛谷 P1092 [NOIP2004 提高组] 虫食算

附：N皇后问题的两种解法耗时对比

本测试中，两种算法耗时均为在Intel i7-12700H CPU上$5$次程序运行的最快速度。

$N$	无优化	位运算优化	速度提升
$13$	$253\mathrm{ms}$	$66\mathrm{ms}$	$2.83\text x$
$14$	$1.31\mathrm s$	$179\mathrm{ms}$	$6.32\text x$
$15$	$8.14\mathrm s$	$955\mathrm{ms}$	$7.52\text x$
$16$	$53.4\mathrm s$	$6.23\mathrm s$	$7.57\text x$

其他应用

两数交换

1
2
3
4


void swap(int& a, int& b)
{
 a ^= b ^= a ^= b;
}

位运算交换法扩展：超快GCD

1
2
3
4
5


inline int gcd(int a, int b)
{
 if(b) while(b ^= a ^= b ^= a %= b);
 return a;
}

两数平均数（防溢出）

1
2
3
4
5
6
7
8
9


inline int average1(int x, int y)
{
 return (x >> 1) + (y >> 1) + (x & y & 1);
}

inline int average2(int x, int y)
{
 return (x & y) + ((x ^ y) >> 1);
}

判断一个数是否为$2$的整数次幂

1
2
3
4


inline bool ispowof2(int x)
{
 return x > 0 && !(x & x - 1);
}

总结

本文详细讲解了位运算的使用和扩展。

创作不易，各位如果觉得好的话就请给个三连，感谢大家的支持！

【算法笔记】树状数组/Binary Indexed Tree/Fenwick Tree

Sat, 20 Aug 2022 20:08:00 +0800

前言

树状数组，即树形存储的数组，又称Binary Indexed Tree或Fenwick Tree。
抛开它树形的存储结构，这种神奇的数据结构的应用看起来与「树」没什么关系：

有一个序列$A=(A_1,A_2,\dots,A_N)$，在不超过$\mathcal O(\log N)$的时间复杂度内完成下列操作：
$\to~$求$[L,R]$区间内所有数之和。
$\to~$指定一个元素$A_x$，将其加上$k$。

如果想要使求和操作尽可能快，很容易想到前缀和，这样求和操作只要$\mathcal O(1)$的时间，但更新操作的时间复杂度就升至$\mathcal O(N)$，无法满足题目要求；反之，若直接暴力维护$A$中所有元素的值，则虽然更新操作只需要$\mathcal O(1)$，但求和操作的时间又变成了$\mathcal O(N)$，还是满足不了要求。那有没有一种算法，综合了两种方式的优势，达到题目时间要求呢？

肯定有，那就是今天说的——树状数组。

基本算法

洛谷 P3374【模板】树状数组 1
同“前言”中的部分，$1\le n,m\le 10^5$，其中$m$为操作总次数。

由于$n,m\le 10^5$，所以$\mathcal O(nm)$的暴力解法肯定行不通，需要使用$\mathcal O(M\log N)$的树状数组。其存储结构大致上是这样的：

是不是已经有些明白了？这里我们我们把$B$当作树状数组的内部存储，则据图可知：

$B_1=A_1$
$B_2=A_1+A_2$
$B_3=A_3$
$B_4=A_1+A_2+A_3+A_4$
$B_5=A_5$
$B_6=A_5+A_6$
$B_7=A_7$
$B_8=A_1+A_2+A_3+A_4+A_5+A_6+A_7+A_8$
..

可以看出，$B_i=A_{i-2^k+1}+A_{i-2^k+2}+\dots+A_i$，其中$k$为$i$在二进制下末尾$0$的的个数。换句话说，$2^k$就是$i$在二进制中的的lowbit。

关于lowbit函数
$\to~$lowbit的定义：

$\mathrm{lowbit}(0)$ 无意义。

对于任意$x > 0$，$\mathrm{lowbit}(x)=2^k$，其中$k$为$x$在二进制下末尾$0$的的个数。

$\to~$举例：$\mathrm{lowbit}(10010)=10$；$\mathrm{lowbit}(10000)=10000$
$\to~$C/C++实现：
1
2
3
inline int lowbit(int x) {
 return x & -x;
}
或宏定义形式：
1
#define lowbit(x) (x) & -(x)

根据lowbit函数，上述公式可以写作：

$$ l:=i-\mathrm{lowbit}(i)+1\\ r:=i\\ B_i=\sum_{j=l}^{r} A_j $$

按照这样，就可以在$\mathcal O(\log n)$的时间复杂度内求$[0,x]$中整数之和（prefixSum(x)）或将$A_x$加上$k$（update(x, k)）。
对于$[L,R]$的区间之和，可以按照segmentSum(l, r) = prefixSum(r) - prefixSum(l - 1)的方式进行计算。详见代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


#include <cstdio>
using namespace std;

template <typename value_type>
class fenwick_tree {
private:
 const int n;
 value_type* a;
 inline int lowbit(int x) { return x & -x; }
public:
 inline fenwick_tree(int m): n(m) {
 a = new value_type[n + 1];
 for(int i=0; i<=n; i++)
 a[i] = 0;
 }
 inline ~fenwick_tree() { delete[] a; }
 inline value_type prefixSum(int i) {
 value_type res = 0;
 for(; i; i-=lowbit(i)) res += a[i];
 return res;
 }
 inline value_type segmentSum(int l, int r) {
 return prefixSum(r) - prefixSum(l - 1);
 }
 inline void update(int i, const value_type& d) {
 for(; i<=n; i+=lowbit(i))
 a[i] += d;
 }
};

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 fenwick_tree<int> bit(n);
 for(int i=1; i<=n; i++)
 {
 int a;
 scanf("%d", &a);
 bit.update(i, a);
 }
 while(m--)
 {
 int op, x, y;
 scanf("%d%d%d", &op, &x, &y);
 if(op == 1) bit.update(x, y);
 else printf("%d\n", bit.segmentSum(x, y));
 }
 return 0;
}

在洛谷 P3374上提交耗时仅$572\mathrm{ms}$，同题用同样为$\mathcal O(\log N)$的线段树耗时约$2.5\mathrm{s}$，可见相比于线段树算法，使用树状数组不仅代码量小、容易实现，还有运行速度快等等优势。

基础算法到此为止，下面来看一些经典的扩展应用。

扩展应用

知识补充：离散化
对于序列$A=(A_1,A_2,\dots,A_N)$，我们将$A$中的每个数都按原先的映射到一个$[1,N]$的范围内，这个过程被称为离散化。一般来说，离散化时同样的元素映射到同样的值，不同的元素映射到不同的值，且满足原先的大小关系。换句话说，令原先的序列为$(A_1,\dots,A_N)$，离散化后的序列为$(B_1,\dots,B_N)$，则满足如下条件：

$1\le B_i\le N$（$1\le i\le N$）
若$i \ne j$，且$A_i < A_j$，则$B_i < B_j$。
若$i \ne j$，且$A_i = A_j$，则$B_i = B_j$。
若$i \ne j$，且$A_i > A_j$，则$B_i > B_j$。

求逆序对

逆序对问题是经典的序列问题。众所周知，这类问题可以用归并排序在$\mathcal O(N\log N)$的时间内解决。不过，既然今天讲的是树状数组，~~那就不能用归并排序~~，就主要来说一说树状数组的解法。

洛谷 P1908 逆序对
给定一个整数序列$A=(A_1,A_2,\dots,A_N)$，求其中逆序对的个数。
一个整数对$(i,j)$被称为“逆序对”，当且仅当如下条件满足：
$\to 1\le i < j\le N$
$\to A_i > A_j$
数据范围：$N\le 10^5,A_i\le 10^9$。

由于$N\le 10^5$，所以暴力的$\mathcal O(N^2)$做法肯定不行。
我们考虑使用树状数组，先将数组离散化成$[1,N]$之间的数，记离散化后的序列为$B=(B_1,\dots,B_N)$。我们按$($总数对数量$)-($非逆序对数量$)=($逆序对数量$)$的公式计算，其中总数对的数量为$1+2+\dots+N-1=\frac {N(N-1)}2$。用树状数组维护每个数字的出现次数，则非逆序对的数量可以在遍历$B$中的每个元素时动态计算。详见代码。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58


#include <cstdio>
#include <algorithm>
#define maxn 500005
using namespace std;

inline int read() {
 static char c;
 while((c = getchar()) < '0' && c > '9');
 int res = c ^ 48;
 while((c = getchar()) >= '0' && c <= '9')
 res = (res << 3) + (res << 1) + (c ^ 48);
 return res;
}

template <typename value_type>
class fenwick_tree {
private:
 const int n;
 value_type* a;
 inline int lowbit(int x) { return x & -x; }
public:
 inline fenwick_tree(int m): n(m) {
 a = new value_type[n + 1];
 for(int i=0; i<=n; i++)
 a[i] = 0;
 }
 inline ~fenwick_tree() { delete[] a; }
 inline value_type prefixSum(int i) {
 value_type res = 0;
 for(++i; i; i-=lowbit(i)) res += a[i];
 return res;
 }
 inline void update(int i, const value_type& d) {
 for(++i; i<=n; i+=lowbit(i))
 a[i] += d;
 }
};

int a[maxn], rk[maxn];

int main()
{
 int n = read();
 for(int i=0; i<n; i++)
 a[rk[i] = i] = read();
 stable_sort(rk, rk + n, [&](int x, int y) -> bool {
 return a[x] < a[y];
 }); // 因为可能会有重复的数字，所以必须使用稳定的stable_sort排序，用sort只有40分
 fenwick_tree<int> bit(n); // 初始化树状数组，离散化之后大小为n就行
 long long ans = n * (n - 1LL) >> 1LL; // 总数对个数
 for(int i=0; i<n; i++)
 {
 ans -= bit.prefixSum(rk[i]); // 减去非逆序数对，即prefixSum(b[i])
 bit.update(rk[i], 1); // 动态更新当前元素出现次数
 }
 printf("%lld\n", ans);
 return 0;
}

习题：CF1676H2 Maximum Crossings (Hard Version)

区间更新

用过线段树的都知道，树状数组最大的缺点就是无法直接实现区间更新。不过，在一些特殊情况¹下，我们可以通过差分+离散化来间接实现区间的更新。先来看洛谷上的模板：

P3368【模板】树状数组 2
已知一个长为$N$的数列，你需要进行下面两种操作：

1 x y k：将$[x,y]$区间内的每个数都加上$k$。

2 x：求第$x$个数的值。

运用差分的思想，用树状数组维护$A$的差分数组$B$（$B_i=A_i-A_{i-1}$）。
此时，我们可以把“区间$[x,y]$中所有元素都加上$k$”看作：

$B_x:=B_x+k$
$B_{y+1}:=B_{y+1}-k$

此时，$A_x=B_1+\dots+B_x$，正好是树状数组的前缀和操作。
于是，我们在$\mathcal O(N\log N)$的时间复杂度内解决了这个问题。

C++实现如下（此实现方式与前面讲的略有不同）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


#include <cstdio>
#define maxn 500005
using namespace std;

template <typename value_type>
class fenwick_tree {
private:
 const int n;
 value_type* a;
 inline int lowbit(int x) { return x & -x; }
public:
 inline fenwick_tree(int m): n(m) {
 a = new value_type[n + 1];
 for(int i=0; i<=n; i++)
 a[i] = 0;
 }
 inline ~fenwick_tree() { delete[] a; }
 inline value_type prefixSum(int i) {
 value_type res = 0;
 for(; i; i-=lowbit(i)) res += a[i];
 return res;
 }
 inline void update(int i, const value_type& d) {
 for(; i<=n; i+=lowbit(i))
 a[i] += d;
 }
};

int a[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 for(int i=1; i<=n; i++)
 scanf("%d", a + i);
 fenwick_tree<int> bit(n);
 while(m--)
 {
 int op;
 scanf("%d", &op);
 if(op == 1)
 {
 int l, r, k;
 scanf("%d%d%d", &l, &r, &k);
 bit.update(l, k);
 if(r < n) bit.update(r + 1, -k);
 }
 else
 {
 int x;
 scanf("%d", &x);
 printf("%d\n", a[x] + bit.prefixSum(x));
 }
 }
 return 0;
}

习题

洛谷 P1168 中位数（求第$k$大问题）
洛谷 P1637 三元上升子序列
洛谷 P6477 [NOI Online #2 提高组] 子序列问题
洛谷 P8253 [NOI Online 2022 提高组] 如何正确地排序
AtCoder Beginner Contest 256 F - Cumulative Cumulative Cumulative Sum
P3372【模板】线段树 1（没错，就是线段树模板，不妨考虑一下「超级树状数组」？）

总结

树状数组支持更新、求和两种操作。欢迎大家前来提问或补充~
~~求三连qwq~~

实际上所有情况都可以，不过其他的非特殊情况实现起来非常繁琐，有时还不如直接用线段树来得方便，因此这里忽略这种情况。 ↩︎

【算法笔记】三种背包问题——背包 DP

Thu, 18 Aug 2022 19:05:00 +0800

前言

背包（Knapsack）问题是经典的动态规划问题，也很有实际价值。
##背包

洛谷 P2871 [USACO07DEC] Charm Bracelet S
AtCoder Educational DP Contest D - Knapsack 1
有$n$个物品和一个总容量为$W$的背包。第$i$件物品的重量是$w_i$，价值是$v_i$。求解将哪些物品装入背包可使这些物品的重量总和不超过背包容量，且价值总和最大。

这是最原始的01背包问题（即每个物品只能选$0$或$1$次）。下面我们来看如何求解。
令$f_{i,j}$表示只考虑前$i$个物品的情况下，容量为$j$的背包所能装的最大总价值。则最终答案为$f_{n,W}$，状态转移方程为：

$$ f_{i,j}=\begin{cases} 0 & (i=0/j=0) \\ \max(f_{i-1,j},f_{i-1,j-w_i}+v_i) & (i>0,j\ge w_i) \end{cases} $$

依次递增$i$，逐步增加问题规模即可求解。时间、空间复杂度均为$\mathcal O(nW)$。
在本题中，$\mathcal O(nW)$的空间复杂度容易MLE，因此考虑使用数组重复利用或者滚动表的优化。

压缩掉$f$的第一维，变成：

$$ f_j=\max(f_j,f_{j-w_i}+v_i) $$

此时空间复杂度为$\mathcal O(W)$。
一定要牢记这个公式，注意使用时需倒序枚举$j$，防止串连转移。参考代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <cstdio>
#define setmax(x, y) if(x < y) x = y
using namespace std;

int f[12881];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(n--)
 {
 int w, v;
 scanf("%d%d", &w, &v);
 for(int i=m; i>=w; i--)
 setmax(f[i], f[i - w] + v);
 }
 printf("%d\n", f[m]);
 return 0;
}

01背包还有一种简单变形，即求最小剩余空间，此时用$($总空间$-$最大可装空间$)$即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <cstdio>
#define setmax(x, y) if(x < y) x = y
using namespace std;

int f[20005];

int main()
{
 int n, v;
 scanf("%d%d", &v, &n);
 while(n--)
 {
 int w;
 scanf("%d", &w);
 for(int i=v; i>=w; i--)
 setmax(f[i], f[i - w] + w);
 }
 printf("%d\n", v - f[v]);
 return 0;
}

扩展：对付更大的$W$

AtCoder Educational DP Contest E - Knapsack 2
本题和普通的01背包完全相同，只是数据范围改为$n\le 100,W\le 10^9,v_i\le 10^3$。

注意数据范围，$W\le 10^9$意味着只要开这么大的数组都会MLE，因此我们考虑修改dp状态。前看原来的dp状态，本质上就是“确定重量，求最大价值”，现在我们反过来，即“确定价值，求最小重量”。令$f_{i,j}$表示只用前$i$个物品，达到总价值为$j$所需的最小空间。由于$n\le 100,v_i\le 10^3$，所以$\sum v_i\le 10^5$，极限情况下dp数组只需要开$n\times\sum v_i\approx10^7$即可，相对而言会好很多。下面考虑dp状态转移方程：

$$ f_{i,j}=\begin{cases} +\infin & (i=0,j\ne0) \\ 0 & (i\ge 0,j=0) \\ \min(f_{i-1,j},f_{i-1,j-v_i}+w_i) & (i>0,j>0) \end{cases} $$

其中，$i=0,j\ne 0$这种情况不存在，所以初始值为$+\infin$。最终答案，即为最大的$j$，使得$f_{n,j}\le W$，更新状态时可同时记录这个答案。

这种算法的时间和空间都可以优化：

时间：对于每个$i$，循环迭代$j$时只需到$v_1+v_2+\dots+v_i$即可，因为当前的总价值不可能超过这个值；
空间：用与前面完全相同的方法，压缩掉第一维空间，变成$f_j=\min(f_j,f_{j-v_i}+w_i)$（注意要倒序枚举$j$）

运用了两种优化的代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


#include <cstdio>
#include <cstring>
using namespace std;

long long f[100005], t, tot, ans;

int main()
{
 int n, sz;
 scanf("%d%d", &n, &sz);
 memset(f, 0x3f, sizeof f);
 f[0] = 0;
 while(n--)
 {
 int w, v;
 scanf("%d%d", &w, &v);
 tot += v;
 for(int i=tot; i>=v; i--)
 if((t = f[i - v] + w) < f[i] && t <= sz)
 {
 f[i] = t;
 if(i > ans) ans = i;
 }
 }
 printf("%lld\n", ans);
 return 0;
}

完全背包

洛谷 P1616 疯狂的采药
有$n$个物品和一个总容量为$W$的背包。第$i$件物品的重量是$w_i$，价值是$v_i$。每个物品可以使用无限次。求解将哪些物品装入背包可使这些物品的重量总和不超过背包容量，且价值总和最大。

这种背包与01背包唯一的不同之处在于，每个物品使用次数不限，所以参考01背包的dp状态：
令$f_{i,j}$表示只考虑前$i$个物品的情况下，容量为$j$的背包所能装的最大总价值，则有：

$$ \begin{aligned} f_{i,j}=\max_{k=0}^{+\infin}\{f_{i-1,j-k\times w_i}\}+v_i\times k\\ =\max_{k=0}^{\lfloor\frac j{w_i}\rfloor}\{f_{i-1,j-k\times w_i}\}+v_i\times k \end{aligned} $$

可以发现，实际上只需要用$f_{i,j}=\max(f_{i-1,j},f_{i,j-w_i}+v_i)$即可，因为此时的$f_{i,j-w_i}$会被$f_{i,j-2w_i}$更新，$f_{i,j-2w_i}$又会被$f_{i,j-3w_i}$更新，以此类推，这样算与前面的公式等效。

对比一下01背包和完全背包的状态转移方程：

$$ \begin{aligned} f_{i,j}=\max(f_{i-1,j},f_{i-1,j-w_i}+v_i) \\ f_{i,j}=\max(f_{i-1,j},f_{i,j-w_i}+v_i) \end{aligned} $$

实际上，区别就在于一个是$f_{i-1,j-w_i}$，一个是$f_{i,j-w_i}$。所以仍可以使用数组压缩，只需要改变一下循环顺序，~~是不是很神奇？~~
long long别忘了~

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <cstdio>
#define setmax(x, y) if(x < y) x = y
using namespace std;

long long f[10000005];

int main()
{
 int sz, n;
 scanf("%d%d", &sz, &n);
 while(n--)
 {
 int w, v;
 scanf("%d%d", &w, &v);
 for(int i=w; i<=sz; i++)
 setmax(f[i], f[i - w] + v);
 }
 printf("%lld\n", f[sz]);
 return 0;
}

多重背包

洛谷 P1776 宝物筛选
有$n$个物品和一个总容量为$W$的背包。第$i$件物品的重量是$w_i$，价值是$v_i$，最多能选择$m_i$次。我们要选择一些物品，使这些物品的重量总和不超过背包容量，且价值总和最大。$n\le100,\sum m_i\le10^5,W\le 4\times10^4$。

很容易想到，可以转换成每件物品都被拆分成$m_i$个只能选一次的物品，即$N=\sum m_i$的01背包。很明显，这样做的时间复杂度是$\mathcal O(W\sum m_i)$，会TLE。因此，我们可以优化拆分的方法，将$m$转化为$x+\sum\limits_{j=0}^i 2^j$的形式，举几个栗子：

$5=(1+2)+2$，其中$i=1,x=2$；
$16=(1+2+4+8)+1$，其中$i=3,x=1$；
$31=(1+2+4+8+16)$，其中$i=4,x=0$。

这种方法的正确性这里就不详细说明了，主要依赖于二进制的拼凑。容易发现，数字$m$按这种拆分的方法会被拆分为$\lceil\log_2m\rceil$个数字的和，因此总时间复杂度为$\mathcal O(W\sum\limits_{i=1}^n\log m_i)$，可以通过此题。

还有一种单调队列/单调栈优化，同样针对多重背包问题，时间复杂度为$\mathcal O(nW)$，有时不一定优于二进制优化，这里就不多说了。下面给出二进制优化的参考程序。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


#include <cstdio>
#define maxw 40004
#define setmax(x, y) if(x < y) x = y
using namespace std;

int n, w, f[maxw];

inline void add(int a, int b) // a: value, b: weight
{
 for(int i=w; i>=b; i--)
 setmax(f[i], f[i - b] + a);
}

int main()
{
 scanf("%d%d", &n, &w);
 while(n--)
 {
 int a, b, c;
 scanf("%d%d%d", &a, &b, &c);
 for(int i=0; (1<<i)<=c; i++)
 add(a << i, b << i), c -= 1 << i;
 if(c) add(a * c, b * c);
 }
 printf("%d\n", f[w]);
 return 0;
}

混合背包

没错，就是前三种放在一起的背包。不用的物品有不同的种类。比如洛谷 P1833 樱花，就是混合背包。不过，也不要慌，直接用个分支判断，比如：

1
2
3
4
5
6
7
8


for (循环物品种类) {
 if (是 0 - 1 背包)
 套用 0 - 1 背包代码;
 else if (是完全背包)
 套用完全背包代码;
 else if (是多重背包)
 套用多重背包代码;
}

实际上也不一定要这样，可以全部统一成混合背包：

对于01背包，可选数目$k_i=1$。
对于完全背包，可选数目$k_i=\lceil\frac W{w_i}\rceil$。

这里就不给出详细代码，有兴趣的读者可以自己尝试一下。

总结

让我们来总结一下三种基本背包DP的异同：

项目	01背包	完全背包	多重背包
适用场景	每件物品只能选择一次	每件物品可以无限选择	每件物品可以选择的次数有限
状态转移方程¹	$\max(f_j,f_{j-w_i}+v_i)$	$\max(f_j,f_{j-w_i}+v_i)$	基本同01背包
时间复杂度²	$\mathcal O(nW)$	$\mathcal O(nW)$	$\mathcal O(W\sum\log k_i)$
空间复杂度³	$\mathcal O(W)$	$\mathcal O(W)$	$\mathcal O(W)$
编码难度	低	低	中

创作不易，如果觉得好就请给个三连，谢谢支持！

压缩掉第一维的$f_j$，01背包为倒序枚举$j$，完全背包为正序 ↩︎
完全背包为优化后的复杂度，多重背包为二进制优化的复杂度。 ↩︎
指压缩第一维后的dp数组大小。 ↩︎

【算法笔记】Kruskal/Prim算法——求解最小生成树问题

Mon, 15 Aug 2022 11:43:00 +0800

前言

生活中经常遇到类似这种的问题：

公路修建
有一些城市，城市之间要修建高速公路，每两个城市之间都可以修双向的路。其中每两个城市之间修路都需要花费对应的金额。请问如何修路，使得总花费的金额最少，且任意两个城市之间都可以直接或间接通过修建的路来通行？

实际上，我们可以把这种问题抽象化，把城市看作图的顶点，公路看作带权的无向边，这样整个国家就被抽象成了一张带权无向图。又因为要求总花费最小，所以修的路一定组成一棵生成树，于是转换成下面的问题：

给定一张带权无向图$G$，求它的一棵生成树，使其中所有边权之和最小。

实际上，这就是大名鼎鼎的「最小生成树问题」。
比如看下面这张图：

其中，标绿的部分即为其最小生成树。

对于这种问题，很多数学家都有所研究。但毕竟是数学家，不懂计算机，就只管算法的正确性，不管实现起来的简单性、可行性和效率，所以很多算法都被人们所抛弃。不过，还是有两种算法脱颖而出，它们就是标题中的——Kruskal 和 Prim。

模板：洛谷 P3366【模板】最小生成树
数据范围：$N\le5000,M\le2\times10^5,w\le 10^4$。

Kruskal

Kruskal算法是由Joseph Kruskal于1956年提出的最小生成树算法，时间复杂度为$\mathcal O(m\log m)$。下面来看这种算法的流程。

Kruskal 算法流程

将所有边按权值从小到大排序，依次遍历每一条边；
对于每一条边，如果在当前子图中连上之后不会形成环，则选择这条边作为最小生成树的一部分，加入子图；
选择$N-1$条边后即可结束算法。

并查集 - 加快算法速度

在正式实现Kruskal算法之前，我们还需要先了解一下并查集。如果判定是否会出现环的部分使用$\text{DFS}$，则时间复杂度为$\mathcal O(nm+m\log m)$，费时费力。若使用并查集来实现，则代码非常简单，且时间复杂度仅为$\mathcal O(m\log m)$（排序的耗时）。并查集模板：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


class dsu
{
private:
 const int n;
 int* fa;
public:
 inline dsu(int count): n(count) // 初始化大小为n的并查集
 {
 fa = new int[n]; // 申请新的内存
 for(int i=0; i<n; i++)
 fa[i] = i; // 初始化fa[i]=i
 }
 inline ~dsu() { delete[] fa; } // 销毁存储空间，防止内存泄露
 inline int size() { return n; } // 返回并查集大小
 int find(int x) { return fa[x] == x? x: fa[x] = find(fa[x]); } // 查找父亲+路径压缩
 inline bool same(int x, int y) { return find(x) == find(y); } // x,y是否在同一个连通分量里？
 inline void merge(int x, int y) { fa[find(x)] = find(y); } // 合并x、y，即连接x<->y这条双向边
 inline bool connected() // 判断整个图是否连通
 {
 int p = find(0);
 for(int i=0; i<n; i++)
 if(find(i) != p)
 return false;
 return true;
 }
};

使用并查集后，算法时间复杂度降到$\mathcal O(m\log m)$，即排序的时间复杂度。下面来看代码。

参考代码

如果对并查集不熟悉的读者可以先复制模板写代码，~~后面再仔细研究TA~~
单次Kruskal算法的排序建议用priority_queue（比sort效率更高），如果要多次Kruskal则需要提前排好序。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74


#include <cstdio>
#include <queue>
using namespace std;

// 代表一条边，方便排序
struct Edge
{
 int from, to, weight;
 inline bool operator <(const Edge& e2) const
 {
 return weight > e2.weight; // 注意：使用优先队列时要把大小倒过来过来
 }
 inline void read()
 {
 scanf("%d%d%d", &from, &to, &weight);
 from --, to --;
 }
};

// 并查集模板
class dsu
{
private:
 const int n;
 int* fa;
public:
 inline dsu(int count): n(count)
 {
 fa = new int[n];
 for(int i=0; i<n; i++)
 fa[i] = i;
 }
 inline ~dsu() { delete[] fa; }
 inline int size() { return n; }
 int find(int x) { return fa[x] == x? x: fa[x] = find(fa[x]); }
 inline bool same(int x, int y) { return find(x) == find(y); }
 inline void merge(int x, int y) { fa[find(x)] = find(y); }
 inline bool connected()
 {
 int p = find(0);
 for(int i=0; i<n; i++)
 if(find(i) != p)
 return false;
 return true;
 }
};

int main()
{
 int n, m;
 scanf("%d%d", &n, &m); // 读入顶点数和边数
 priority_queue<Edge> q; // 初始化优先队列，用于排序
 while(m--)
 {
 Edge e;
 e.read(); // 读入一条边
 q.push(e); // 放入队列进行排序
 }
 int ans = 0, // 记录总权值
 cnt = 0; // 当前选择边的个数
 dsu d(n); // 初始化并查集
 while(!q.empty() && cnt < n - 1) // 遍历所有边，选择了n-1条边即可退出
 {
 auto [u, v, w] = q.top(); q.pop(); // 弹出边权最小的边
 if(!d.same(u, v)) // 如果连通后不会形成环
 {
 d.merge(u, v); // 连上这条边
 ans += w, cnt ++; // 更新答案和计数
 }
 }
 if(cnt == n - 1) printf("%d\n", ans); // 如果最终选择了n-1条边，输出答案
 else puts("orz"); // 否则...
 return 0;
}

最后一段也可以写成这样（不用cnt计数，输出答案时判定连通，速度稍慢）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


int ans = 0;
dsu d(n);
while(!q.empty())
{
 auto [u, v, w] = q.top(); q.pop();
 if(!d.same(u, v))
 {
 d.merge(u, v);
 ans += w;
 }
}
if(d.connected()) printf("%d\n", ans);
else puts("orz");

Prim

Prim算法于1930年由捷克数学家Vojtěch Jarník发现，在1957年又由美国计算机科学家Robert C. Prim独立发现。1959年，Edsger Wybe Dijkstra（没错，就是Dijkstra算法的发明者）再次发现了该算法。因此，在某些场合，Prim算法又被称为DJP算法、Jarník算法或Prim－Jarník算法。

Prim 算法流程

Prim与Dijkstra很相似，将顶点分为$S$和$T$两个集合，具体流程如下：

初始时，所有顶点全部在$S$中，$T$为空集。
从$S$中选择任意顶点，移动到集合$T$；
重复以下步骤，直到所有顶点都在$T$中：
- 选择一条边$(u,v,w)$，使得$u$在点集$S$中，$v$在点集$T$中，且权值$w$最小；
- 将这条边加入最小生成树，并将$u$移入点集$T$。

Prim算法的原始写法就不多说了，这里和Dijkstra一样，介绍priority_queue和set优化。

优先队列优化

运行时间：$328\mathrm{ms}$
时间复杂度：$\mathcal O(n\log m)$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


#include <cstdio>
#include <queue>
#define maxn 5005
#define INF 2147483647
using namespace std;

using pii = pair<int, int>;
vector<pii> G[maxn];
int dis[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int u, v, w;
 scanf("%d%d%d", &u, &v, &w);
 G[--u].emplace_back(--v, w);
 G[v].emplace_back(u, w);
 }
 for(int i=1; i<n; i++)
 dis[i] = INF;
 priority_queue<pii, vector<pii>, greater<pii>> q;
 q.emplace(0, 0);
 int ans = 0, left = n;
 while(!q.empty() && left > 0)
 {
 auto [d, v] = q.top(); q.pop();
 if(d != dis[v]) continue;
 dis[v] = -INF, left --, ans += d;
 for(auto [u, w]: G[v])
 if(w < dis[u])
 q.emplace(dis[u] = w, u);
 }
 if(left) puts("orz");
 else printf("%d\n", ans);
 return 0;
}

set优化

运行时间：$351\mathrm{ms}$
时间复杂度：$\mathcal O(n\log n)$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


#include <cstdio>
#include <vector>
#include <set>
#define maxn 5005
#define INF 2147483647
using namespace std;

using pii = pair<int, int>;
vector<pii> G[maxn];
int dis[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int u, v, w;
 scanf("%d%d%d", &u, &v, &w);
 G[--u].emplace_back(--v, w);
 G[v].emplace_back(u, w);
 }
 for(int i=1; i<n; i++)
 dis[i] = INF;
 set<pii> s;
 s.emplace(0, 0);
 int ans = 0, left = n;
 while(!s.empty() && left > 0)
 {
 auto it = s.begin();
 auto [d, v] = *it; s.erase(it);
 dis[v] = -INF, left --, ans += d;
 for(auto [u, w]: G[v])
 if(w < dis[u])
 {
 if(dis[u] != INF)
 s.erase(pii(dis[u], u));
 s.emplace(dis[u] = w, u);
 }
 }
 if(left) puts("orz");
 else printf("%d\n", ans);
 return 0;
}

习题

总结

我们来看一下Kruskal、Prim两种算法的对比：

指标	Kruskal	Prim
时间复杂度	$\mathcal O(m\log m)$	$\mathcal O(n\log m)$¹
运行时间²	$255\mathrm{ms}$	$328\mathrm{ms}$
编码难度	低	中
适用域	稀疏图	稠密图

由此可见，大部分题目首选Kruskal，有特殊需要时才使用Prim。
本篇文章到此结束，如果觉得好的话就请给个三连，感谢大家的支持！

此处为优先队列优化的复杂度，set优化为$\mathcal O(n\log n)$ ↩︎
在洛谷 P3366上的提交结果，Kruskal算法使用并查集+优先队列，Prim使用优先队列优化 ↩︎

【算法笔记】单源最短路问题——Dijkstra算法（无优化/优先队列/set优化）

Sat, 13 Aug 2022 12:37:00 +0800

前言

Dijkstra算法可在$\mathcal O(m\log m)$或$\mathcal O(m\log n)$的时间内求解无负权单源最短路问题。本文中，我们将详细介绍算法的原理、实现，以及常用的两种优化。

另外，Dijkstra算法也不要乱用，比如说多源的最短路，用Dijkstra求解的复杂度只有$\mathcal O(nm\log m)$，但太麻烦，如果数据范围允许，直接用Floyd就能在$\mathcal O(n^3)$的时间内完成任务。

废话不多说，下面来看Dijkstra算法的流程。

流程

将结点分成两个集合：已确定最短路长度的点集（记为$S$集合）的和未确定最短路长度的点集（记为$T$集合）。一开始所有的点都属于$T$集合。

用$d_v$表示顶点$v$到起始点的距离、$s$表示起始点。
初始化$d_s=0$，其他点的$d$均为$+\infin$。

然后重复这些操作：

从$T$集合中，选取一个最短路长度最小的结点$v$，移到$S$集合中。
对于与$v$相邻的每个点$u$，执行松弛操作：dis[u] = min(dis[u], dis[v] + G[v][u])。

直到$T$集合为空，算法结束。下面来看最简单的实现。

实现

本算法的代码可以在CF20C/洛谷链接提交。后面提供的参考代码的输入输出格式都是基于这道题的。数据范围：$n,m\le 10^5,w_i\le 10^6$。

在编写代码之前，我们还要考虑一个问题：如何输出最短路径？
定义一个数组$\mathrm{par}$，$\mathrm{par}[i]$表示最短路径上在点$i$前面的点。初始时，$\mathrm{par}[s]=-1$，表示前面没有点。

在$v\to u$这条边上更新dis[u] = dis[v] + G[v][u]时，同时更新par[u] = v，最后输出时顺着par[v]的路径往下逆序输出到达的点即可。

朴素实现（无优化）

这种实现完全按照算法流程，时间复杂度为$\mathcal O(n^2)$，无法通过例题。下面给出代码。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59


#include <cstdio>
#include <cstring>
#include <vector>
#define maxn 100005
using namespace std;

vector<pair<int, int>> G[maxn];

long long dis[maxn];
int par[maxn];
bool vis[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int u, v, c;
 scanf("%d%d%d", &u, &v, &c);
 G[--u].emplace_back(--v, c);
 G[v].emplace_back(u, c);
 }
 // Dijkstra 算法流程
 // 初始化
 memset(dis, 0x3f, sizeof dis);
 memset(vis, 0, sizeof vis);
 dis[0] = 0LL, par[0] = -1; // 起点的距离为0
 while(true)
 {
 int v = n; // 不存在的虚拟结点，距离为+INF，方便判断
 for(int i=0; i<n; i++)
 if(!vis[i] && dis[i] < dis[v])
 v = i;
 if(v >= n - 1) break; // 找不到或到达终点，退出
 vis[v] = true; // 标记访问过
 for(auto [u, d]: G[v])
 if(dis[v] + d < dis[u]) // 是否有更优路径？
 {
 dis[u] = dis[v] + d; // 更新距离
 par[u] = v; // 更新路径
 }
 }
 if(dis[n - 1] == dis[n]) // 没有找到解（图不连通）
 {
 puts("-1");
 return 0;
 }
 vector<int> path; // 存储路径，注意要倒序输出
 int v = n - 1; // 从终点向前获取最优路径
 while(v != -1)
 {
 path.push_back(v); // 加入路径
 v = par[v]; // 向前回溯
 }
 for(int i=path.size()-1; i>=0; i--)
 printf("%d ", path[i] + 1); // 输出
 return 0;
}

评测结果：

优先队列优化

优先队列，又称二叉堆，是常用的一种数据结构。可以执行下列操作（$n$为优先队列队列中的元素个数）：

弹出最小/最大的元素，时间$\mathcal O(\log n)$
添加新元素，时间$\mathcal O(\log n)$

利用这些特点，我们可以在$\mathcal O(m\log m)$的时间内完成一轮Dijkstra。其细节为：

初始时，仅将起始点和距离$(s,0)$放入队列；
当队列不为空时，执行：
- 弹出距离最小的顶点和距离$(v,d)$，如果距离$d\ne dis[v]$，则说明已经找到了其他更短路径，舍弃这条路；
- 否则，依次更新每条邻边$v\to u$，如果距离比原来的更短，则不仅要更新$\mathrm{dis}$和$\mathrm{par}$，还要把$(u,\mathrm{dis}[u])$放入队列。

实现代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


#include <cstdio>
#include <queue>
#define maxn 100005
#define INF 9223372036854775807LL
using namespace std;

using LL = long long;
using pli = pair<LL, int>;

vector<pair<int, int>> G[maxn];
LL dis[maxn];
int par[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int u, v, c;
 scanf("%d%d%d", &u, &v, &c);
 G[--u].emplace_back(--v, c);
 G[v].emplace_back(u, c);
 }
 for(int i=1; i<n; i++) dis[i] = INF;
 par[0] = -1;
 priority_queue<pli, vector<pli>, greater<pli>> q;
 q.emplace(0LL, 0);
 while(!q.empty())
 {
 auto [d, v] = q.top(); q.pop();
 if(dis[v] == d)
 for(auto [u, w]: G[v])
 if(d + w < dis[u])
 par[u] = v,
 q.emplace(dis[u] = d + w, u);
 }
 if(dis[n - 1] == INF) { puts("-1"); return 0; }
 vector<int> path;
 int v = n - 1;
 while(v != -1)
 {
 path.push_back(v);
 v = par[v];
 }
 for(int i=path.size()-1; i>=0; i--)
 printf("%d ", ++path[i]);
 return 0;
}

时间复杂度为$\mathcal O(m\log m)$，可以通过此题。运行时间：$93\text{ms}$

`set`优化

set又称集合，与优先队列相似，支持添加、删除，另外还可以删除任意元素，时间$\mathcal O(\log n)$。要发挥出set的优势，就要在维护时删掉多余的顶点-距离对，防止不必要的dis[v] == d这种判断。

此时，集合中的元素个数永远不会超过$N$，因此总时间复杂度为$\mathcal O(m\log n)$。
在$m\ge n$，即边数大于顶点数时，这种方法优于priority_queue。不过，一般使用Dijkstra算法的题目中都是$m\le n$，所以set的优化不常用，但下面还是给出代码。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


#include <cstdio>
#include <vector>
#include <set>
#define maxn 100005
#define INF 9223372036854775807LL
using namespace std;

using LL = long long;
using pli = pair<LL, int>;

vector<pair<int, int>> G[maxn];
LL dis[maxn];
int par[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int u, v, c;
 scanf("%d%d%d", &u, &v, &c);
 G[--u].emplace_back(--v, c);
 G[v].emplace_back(u, c);
 }
 for(int i=1; i<n; i++) dis[i] = INF;
 par[0] = -1;
 set<pli> s;
 s.emplace(0LL, 0);
 while(!s.empty())
 {
 auto it = s.begin(); s.erase(it);
 auto [d, v] = *it;
 for(auto [u, w]: G[v])
 if(d + w < dis[u])
 {
 par[u] = v;
 if(dis[u] != INF)
 s.erase(pli(dis[u], u));
 s.emplace(dis[u] = d + w, u);
 }
 }
 if(dis[n - 1] == INF) { puts("-1"); return 0; }
 vector<int> path;
 int v = n - 1;
 while(v != -1)
 {
 path.push_back(v);
 v = par[v];
 }
 for(int i=path.size()-1; i>=0; i--)
 printf("%d ", ++path[i]);
 return 0;
}

AC，运行时间：$78\text{ms}$

后记

总结一下Dijkstra算法的实现方式：

暴力（$\mathcal O(n^2)$，TLE ;(）
优先队列（$\mathcal O(m\log m)$，$93\text{ms}$ :|）
集合/set（$\mathcal O(m\log n)$，$78\text{ms}$ :)）

【算法笔记】多源最短路问题——Floyd算法

Fri, 12 Aug 2022 21:07:00 +0800

前言

在图中，如果要求任意两点间的距离，则可以使用Floyd（$\mathcal O(N^3)$;)）和Dijkstra（$\mathcal O(NM\log M)$:)）。对于比较小的数据范围（一般为顶点数$N\le 150$），可以使用Floyd算法。本文将讲述Floyd算法的原理、实现和扩展应用。

如果有哪里写得不好请各位dalao多多指教，谢谢！

原理

不同于Dijkstra，Floyd算法同样适用于带负边权的最短路问题。其原理为：
令$f(x,y)$为从顶点$x$到$y$的最短路径。初始时，有：

$$ f(x,y)= \begin{cases} 0 & (x=y) \\ G[x][y] & (G[x][y]\ne0)\\ +\infin & (x\ne y,G[x][y]=0) \end{cases} $$

其中$G$为图的邻接矩阵，$G[x][y]$表示顶点$x$到$y$的边权，$0$表示$x$到$y$没有连边。
接下来，考虑枚举中间点$k$，按$x\to k\to y$的路线计算最短路，则伪代码为：

1
2
3
4


for k = 1, 2, ..., n
 for x = 1, 2, ..., n
 for y = 1, 2, ..., n
 f[x][y] = min(f[x][y], f[x][k] + f[k][y])

此时，算法结束，最终$f(x,y)$即为从$x$到$y$的最短路。

注意：当给定图为无向图时，对于任意$(x,y)$，$G[x][y]=G[y][x]$，则$f(x,y)=f(y,x)$，可改变计算过程（如变成f[k][x]+f[k][y]）；但若是有向图，请务必按照伪代码中的顺序编写程序！

代码

Floyd算法的代码可在洛谷 B3647提交。下面给出这题对应的AC代码（注意是按边输入）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


#include <cstdio>
#include <cstring>
#define maxn 100
using namespace std;

int dis[maxn][maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 // 初始化，注意初始值不能超过INT_MAX/2（防止两个INF相加溢出）
 memset(dis, 0x3f, sizeof dis); 
 // 每个点到自己的距离为0
 for(int i=0; i<n; i++)
 dis[i][i] = 0;
 // 读入边
 while(m--)
 {
 int u, v, d;
 scanf("%d%d%d", &u, &v, &d);
 u --, v --; // 0-index
 dis[u][v] = dis[v][u] = d; // 注意两个值都要设
 }
 // Floyd 算法流程
 for(int k=0; k<n; k++) // 中间点
 for(int i=0; i<n; i++) // 起始点
 for(int j=0; j<n; j++) // 终点
 {
 int d = dis[i][k] + dis[k][j]; // i->k->j
 if(d < dis[i][j]) dis[i][j] = d; // 取最短长度
 }
 for(int i=0; i<n; i++, putchar('\n'))
 for(int j=0; j<n; j++)
 printf("%d ", dis[i][j]);
 return 0;
}

扩展

下面问题来了：如何输出结果路径？其实方法很简单。与Dijkstra类似但略有不同，设$\text{path}(x, y)=x\to y$的最短路径上的某一点，则状态转移时若$f(x,k)+f(k,y) < f(x,y)$，则不仅要更新$f(x,y)$，还要更新$\text{path}(x,y):=k$。最后，递归输出结果即可。

题面

给定一张有$N$个点，$M$条边的简单无向图，对于每一对$(i,j)$（$1\le i < j\le N$），求$i\to j$的最短路径上的每一点。

样例

输入：

输出：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


1->2: 1 2
1->3: 1 4 3
1->4: 1 4
1->5: 1 4 5
2->3: 2 1 4 3
2->4: 2 1 4
2->5: 2 1 4 5
3->4: 3 4
3->5: 3 4 5
4->5: 4 5

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


#include <cstdio>
#include <cstring>
#define maxn 100
using namespace std;

int dis[maxn][maxn], path[maxn][maxn];
void print(int x, int y) // 递归输出x->y的路径，不包含y
{
 int k = path[x][y]; // x->k->y
 if(k == x || k == y) // 两点相邻，直接输出
 printf(" %d", x);
 else
 {
 // 分成两部分递归
 print(x, k); // x->k
 print(k, y); // k->y
 }
}

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 // 初始化
 memset(dis, 0x3f, sizeof dis); 
 for(int i=0; i<n; i++)
 dis[i][i] = 0;
 // 读入边
 while(m--)
 {
 int u, v, d;
 scanf("%d%d%d", &u, &v, &d);
 dis[u][v] = dis[v][u] = d; // 注意两个值都要设
 path[u][v] = path[v][u] = u; // 初始化path
 }
 // Floyd 算法流程，为了方便输出，采用1-index
 for(int k=1; k<=n; k++) // 中间点
 for(int i=1; i<=n; i++) // 起始点
 for(int j=1; j<=n; j++) // 终点
 {
 int d = dis[i][k] + dis[k][j]; // i->k->j
 if(d < dis[i][j]) // 更新最短路径
 dis[i][j] = d, path[i][j] = k;
 }
 // 依次枚举(i,j) 输出路径
 for(int i=1; i<n; i++)
 for(int j=i+1; j<=n; j++)
 {
 printf("%d->%d:", i, j);
 print(i, j);
 printf(" %d\n", j);
 }
 return 0;
}

注：由于每条路径的长度不会超过$N$，所以总时间复杂度仍为$\mathcal O(N^3)$。

后记

总结：Floyd算法时间复杂度为$\mathcal O(N^3)$，写起来很方便。如果觉得好就请给个三连，谢谢支持！

【算法笔记】树形DP算法总结&详解

Fri, 12 Aug 2022 10:15:00 +0800

定义

树形DP，又称树状DP，即在树上进行的DP，是DP（动态规划）算法中较为复杂的一种。

基础

令$f[u]=~$与树上顶点$u$有关的某些数据，并按照拓扑序（从叶子节点向上到根节点的顺序）进行$\text{DP}$，确保在更新一个顶点时其子节点的dp值已经被更新好，以更新当前节点的$\text{DP}$值。为方便计算，一般写成dfs的形式，如下：

1
2
3
4
5
6
7


void dfs(int v) { // 遍历节点v
 dp[v] = ...; // 初始化
 for(int u: G[v]) { // 遍历v的所有子节点
 dfs(u);
 update(u, v); // 用子节点的dp值对当前节点的dp值进行更新
 }
}

下面来看一道简单的例题：

【例1.1】子树大小

给定一棵有$N$个结点的树，根结点为结点$1$。对于$i=1,2,\dots,N$，求以结点$i$为根的子树大小（即子树上结点的个数，包括根结点）。

本题明显可以使用树形DP的方法，令$f[v]=~$以$v$为根的子树大小，则易得

$$ f[v]=1+\sum_{i=1}^{\text{deg}_v} G[v][i] $$

即：一个结点的子树大小$~=1$（根节点）$+~$每个子树的大小。

沿用刚才的模板，可得：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


#include <cstdio>
#include <vector>
#define maxn 100
using namespace std;

vector<int> G[maxn]; // 邻接表
int sz[maxn]; // dp数组，sz[v] = 子树v的大小

void dfs(int v)
{
 sz[v] = 1; // 初始化，最初大小为1，后面累加
 for(int u: G[v]) // 遍历子结点
 {
 dfs(u); // 先对子结点进行dfs
 sz[v] += sz[u]; // 更新当前子树的大小
 }
}

int main()
{
 int n;
 scanf("%d", &n); // 结点个数
 for(int i=1; i<n; i++) // N-1条边
 {
 int u, v;
 scanf("%d%d", &u, &v); // 读入一条边
 G[u].push_back(v); // 存入邻接表
 }
 dfs(1);
 for(int i=1; i<=n; i++)
 printf("%d\n", sz[i]);
 return 0;
}

下面来看一道稍微复杂一点的题：

【例1.2】洛谷P1352 没有上司的舞会

本题即树的最大独立集问题。

有$N$名职员，编号为$1\dots N$，他们的关系就像一棵以老板为根的树，父节点就是子节点的直接上司。每个职员有一个快乐指数$r_i$，现在要召开一场舞会，使得没有职员和直接上司一起参会。主办方希望邀请一部分职员参会，使得所有参会职员的快乐指数总和最大，求这个最大值。

令$f(v)$表示以$v$为根的子树中，选择$v$的最优解，$g(v)$表示以$v$为根的子树中，不选$v$的最优解。

则对于每个状态，都存在两种决策（其中$u$代表$v$的儿子）：

不选$v$时，可选也可不选$u$，此时有$g(v)=\sum\max\{f(u),g(u)\}$；
选择$v$时，一定不能选$u$，此时有$f(v)=r_i+\sum g(u)$。

时间复杂度为$\mathcal O(N)$。
注意本题需要寻找根节点，没有上司的结点即为根节点，读入时用数组标记即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


#include <cstdio>
#include <vector>
#define maxn 6005
using namespace std;

inline int max(int x, int y) { return x > y? x: y; }

vector<int> G[maxn]; // 邻接表
bool bad[maxn]; // 根结点标记
int f[maxn], g[maxn]; // 数据存储

void dfs(int v) // 遍历结点v
{
 // 读入时已初始化，这里可省略
 for(int u: G[v]) // 遍历子结点
 {
 dfs(u); // 先对子结点进行dfs
 // 更新当前dp状态
 f[v] += g[u]; // 选择v，不能选u
 g[v] += max(f[u], g[u]); // 不选v，u可选可不选
 }
}

int main()
{
 int n;
 scanf("%d", &n); // 结点个数
 for(int i=0; i<n; i++)
 scanf("%d", f + i); // 相当于提前初始化好f[i]=r[i]
 for(int i=1; i<n; i++) // N-1条边
 {
 int u, v;
 scanf("%d%d", &u, &v); // 读入一条边
 G[--v].push_back(--u); // 0-index，存入邻接表
 bad[u] = true; // 标记不可能是根结点
 }
 int root = -1; // 根结点变量
 for(int i=0; i<n; i++)
 if(!bad[i]) // 找到根结点
 {
 root = i; // 记录根结点
 break;
 }
 dfs(root); // 开始进行树形DP
 printf("%d\n", max(f[root], g[root])); // 根结点也有两种选择
 return 0;
}

习题

树上背包

在基本算法之上，树形dp还可以用于树上背包问题。来看一道例题：

【例2.1】洛谷P2014 / AcWing 286 选课

有$N$门课，第$i$门课的学分是$s_i$。每门课有不超过一门先修课，需要上了先修课才能上这门课。现要选$M$门课，使得学分总和最大。

每门课最多只有一门先修课，这符合树结构的特点，与有根树中一个点最多只有一个父亲结点的特点类似。因此，我们根据数据构造一棵树，课程的先修课为这门课的父结点。又由于给定的输入是一个森林（多棵树组成的不一定连通的图），不是一棵完整的树，因此我们添加虚拟根结点$0$（$s_0=0$），将没有先修课的结点全部连到它下面，并从这里开始dfs。注意此时必须选中$0$号结点（它是所有课程的直接或间接先修课），所以操作前先将$M$加上$1$。

格式问题解决，下面考虑如何$\text{DP}$。
令$f[i][j]$表示当前在结点$i$、且已经选了$j$门课时的最大学分数量，则答案为$f[0][M+1]$。状态转移方程等详见代码。时间复杂度为$\mathcal O(NM)$，有兴趣的可以自己尝试证明。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


#include <cstdio>
#include <vector>
#include <algorithm>
#define maxn 305
using namespace std;

// dp算法中常用的模板，等效于x=max(x,y)
inline void setmax(int& x, int y)
{
 if(x < y) x = y;
}

vector<int> G[maxn]; // 邻接表
int n, m, f[maxn][maxn];

int dfs(int u) // 遍历结点u，返回值为其子树大小
{
 int tot = 1; // 记录子树大小，初始为1
 for(int v: G[u]) // 遍历u的所有子结点
 {
 int sz = dfs(v); // 对当前子结点进行搜索
 // 状态转移，注意i倒序，防止串连转移现象
 for(int i=min(tot, m); i>0; i--) // 子树大小优化可降低算法复杂度
 for(int j=1, lim=min(sz, m-i); j<=lim; j++)
 setmax(f[u][i + j], f[u][i] + f[v][j]); // 更新状态
 tot += sz; // 加到当前子树下
 }
 return tot; // 返回子树大小
}

int main()
{
 scanf("%d%d", &n, &m);
 for(int i=1; i<=n; i++)
 {
 int a;
 scanf("%d%d", &a, f[i] + 1); // 初始化f[i][1]=s[i]
 G[a].push_back(i);
 }
 m ++; // 别忘了这一句
 dfs(0);
 printf("%d\n", f[0][m]);
 return 0;
}

习题

换根 DP

换根DP，即为不知道根结点时使用的一种树形DP，时间复杂度一般为$\mathcal O(N)$。

【例3.1】洛谷 P3478 [POI2008] STA-Station

给定一个$n$个点的树，请求出一个结点，使得以这个结点为根时，所有结点的深度之和最大。

先考虑最简单粗暴的方法，即为枚举所有结点，代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


#include <cstdio>
#include <vector>
#define maxn 1000005
using namespace std;

vector<int> G[maxn];

int dfs(int v, int d, int par)
{
 int s = d;
 for(int u: G[v])
 if(u != par)
 s += dfs(u, d + 1, v);
 return s;
}

int main()
{
 int n;
 scanf("%d", &n);
 for(int t=n; --t; )
 {
 int u, v;
 scanf("%d%d", &u, &v);
 G[--u].push_back(--v);
 G[v].push_back(u);
 }
 int ans = 0, maxDepth = dfs(0, 0, -1);
 for(int root=1; root<n; root++)
 {
 int d = dfs(root, 0, -1);
 if(d > maxDepth) ans = root, maxDepth = d;
 }
 printf("%d\n", ++ans);
 return 0;
}

很明显，这种做法时间复杂度为$\mathcal O(n^2)$，又因为$n\le 10^6$，所以无法得全分，评测结果如下：

~~好家伙，居然还有50分，本以为最多30..~~

下面来考虑换根DP的方法。不妨令$u$为当前结点，$v$为其子结点。先预处理出每个结点的子树大小$s[u]=1+\sum s[v]$和以$1$为根结点时所有结点的深度（$\text{depth}_i$），此时第一遍DFS即为预处理。

令$f_u$表示以$u$为根时，所有结点的总深度和，则$f_1=\sum\text{depth}_i$。
考虑$f_u\to f_v$的转移，即“根结点从$u$变成$v$时所有结点深度和的变化”，则有：

所有在$v$的子树上的结点深度全部$-1$，则总深度和减少$s_v$；
所有不在$v$的子树上的结点深度都$+1$，则总深度和增加$n-s_v$；

此时，可得$f_v=f_u-s_v+n-s_v=f_u+n-2s_v$。注意数据类型，使用long long。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


#include <cstdio>
#include <vector>
#define maxn 1000005
using namespace std;

using LL = long long;

vector<int> G[maxn];
LL sz[maxn], f[maxn];
int n, ans;

LL dfs1(int v, int d, int par)
{
 sz[v] = 1;
 LL s = d;
 for(int u: G[v])
 if(u != par)
 s += dfs1(u, d + 1, v), sz[v] += sz[u];
 return s;
}

void dfs2(int v, int par)
{
 if(f[v] > f[ans]) ans = v;
 for(int u: G[v])
 if(u != par)
 {
 f[u] = f[v] + n - (sz[u] << 1LL);
 dfs2(u, v);
 }
}

int main()
{
 scanf("%d", &n);
 for(int t=n; --t; )
 {
 int u, v;
 scanf("%d%d", &u, &v);
 G[--u].push_back(--v);
 G[v].push_back(u);
 }
 f[0] = dfs1(0, 0, -1);
 dfs2(0, -1);
 printf("%d\n", ++ans);
 return 0;
}

习题

后记

~~好像这玩意也并不是开头所说的那么难…… 记得给个三连哦！~~

参考文献：

LINE Verda Programming Contest (AtCoder Beginner Contest 263) A~E 题解

Sun, 07 Aug 2022 19:45:00 +0800

A - Full House

题目大意

~~来自一个掼蛋爱好者的翻译qwq~~

给定一副扑克牌中五张牌的编号$A,B,C,D,E$，判断这五张是否为一组“三带二”。~~（不懂的自行百度~~

数据范围：$1\le A,B,C,D,E\le 13$，且$A,B,C,D,E$不会全部相同。

输入格式

$A~B~C~D~E$

输出格式

如果是“三带二”，输出Yes；否则，输出No。

样例

$A$	$B$	$C$	$D$	$E$	输出
$1$	$2$	$1$	$2$	$1$	`Yes`
$12$	$12$	$11$	$1$	$2$	`No`

分析

嘿嘿，被自己的翻译给~~笑喷了~~吓住了，从来没见过这么好垃圾的翻译！
话不多说，这A题就是水（虽然studentWheat这位大佬还WA了3次，具体怎么WA的请大家~~好好学学~~引以为戒），解法很多，但是个人感觉还是直接统计一下来得简单明了，见代码。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <cstdio>
using namespace std;

int cnt[13];

int main()
{
 for(int i=0; i<5; i++)
 {
 int x;
 scanf("%d", &x);
 cnt[--x] ++;
 }
 bool has2 = false, has3 = false;
 for(int i=0; i<13; i++)
 if(cnt[i] == 2) has2 = true;
 else if(cnt[i] == 3) has3 = true;
 puts(has2 && has3? "Yes": "No");
 return 0;
}

B - Ancestor

题目大意

有$N$个人，第$i$个人的父/母是$P_i$，题目保证$P_i < i$。
问：第$N$个人是第$1$个人的第几代？

$2\le N\le 50$
$1\le P_i < i$

输入格式

$N$
$P_2~P_3~\dots~P_N$

输出格式

输出答案。

分析

本题可以使用$\text{DFS}$，但没有必要。题目限制条件特别给出了$P_i < i$，因此如果按输入顺序依次处理每个人的世代，一个人的父亲肯定在这个人之前被考察到。

下面来看详细过程。
我们设$\text{depth}_i=~$第$i$个节点的深度，因此答案为$\text{depth}_N$。
初始时，$\text{depth}_0=0$。对于$i=1\dots N$，依次设置$\text{depth}_i:=\text{depth}_{P_i}+1$。
最终，输出结果即可。总时间复杂度为$\mathcal O(N)$。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <cstdio>
#define maxn 55
using namespace std;

int dep[maxn];

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=1; i<n; i++)
 {
 int f;
 scanf("%d", &f);
 dep[i] = dep[--f] + 1;
 }
 printf("%d\n", dep[n - 1]);
 return 0;
}

C - Monotonically Increasing

题目大意

输出所有的长度为$N$的严格上升的序列，其中每个元素都在$[1,M]$之间，按字典升序输出，$1\le N\le M\le 10$。

输入格式

$N~M$

输出格式

按字典升序输出所有符合条件的序列，一行一个，序列中的每个元素用空格分隔。

分析

基础的回溯算法题，见代码。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <cstdio>
#define maxn 15
using namespace std;

int n, m, ans[maxn];

void dfs(int pos, int last)
{
 if(pos == n)
 {
 for(int i=0; i<n; i++)
 printf("%d ", ans[i]);
 putchar('\n');
 return;
 }
 while(++last <= m)
 {
 ans[pos] = last;
 dfs(pos + 1, last);
 }
}

int main()
{
 scanf("%d%d", &n, &m);
 dfs(0, 0);
 return 0;
}

D - Left Right Operation

题目大意

给定长为$N$的整数序列$A=(A_1,A_2,\dots,A_N)$。
你可以进行下列两个操作，每个最多一次：

选择整数$x$，将$A$的前$x$项全部改成$L$。
选择整数$y$，将$A$的后$y$项全部改成$R$。

求操作后，最小的$A$中所有元素之和。

$1\le N\le 2\times 10^5$
$-10^9\le L,R,A_i\le 10^9$

输入格式

$N~L~R$
$A_1~A_2~\dots~A_N$

输出格式

输出答案。

分析

令$f_i=($使用操作$1$选择$x\le i$时的前$i$个序列元素的最小和$)$，
$~~~~g_i=($使用操作$2$选择$y\le i$时的后$i$个序列元素的最小和$)$，
则可得递推式$f_i=\min\{f_{i-1}+A_i,L\times i\}$，$g_i$同理。
此时，枚举两种操作的分界点$i$，则答案为$\min\limits_{i=1}^N(f_i+g_{N-i})$。实现时，可将$g$数组倒过来计算，这样答案为$\min\limits_{i=1}^N(f_i+g_{i+1})$。

递推式的正确性证明
前面已经提到了，$f_i=\min\{f_{i-1}+A_i,L\times i\}$。为什么？
先看$\min$后面的部分，应该好理解，就是前$i$个全部替换成$L$的总和。前面的$f_{i-1}+A_i$才是关键。考虑$f_{i-1}$的计算来源，要么是从$f_{i-2}+A_{i-1}$递推过来的，要么也是直接用$L\times(i-1)$得到的。再考虑$f_{i-2},f_{i-3},\dots,f_1$会发现，递推式的结果一定是(一段$L$)+(一段$A_i$)得到的。因此，这个递推式正确。$g$的正确性也可以用同样的方法证明，感兴趣的读者可以自行尝试。

总时间复杂度为$\mathcal O(N)$。

代码

注意使用long long。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


#include <cstdio>
#define maxn 200005
using namespace std;

using LL = long long;
inline LL min(const LL& x, const LL& y)
{
 return x < y? x: y;
}

int a[maxn];
LL f[maxn], g[maxn];

int main()
{
 int n, l, r;
 scanf("%d%d%d", &n, &l, &r);
 for(int i=0; i<n; i++)
 scanf("%d", a + i);
 f[0] = min(l, a[0]);
 for(int i=1; i<n; i++)
 f[i] = min(f[i - 1] + a[i], (i + 1LL) * l);
 for(int i=n-1; i>=0; i--)
 g[i] = min(g[i + 1] + a[i], LL(n - i) * r);
 LL ans = g[0];
 for(int i=0; i<n; i++)
 ans = min(ans, f[i] + g[i + 1]);
 printf("%lld\n", ans);
 return 0;
}

E - Sugoroku 3

题目大意

有$N$个方格，分别是方格$1$，方格$2$，..，方格$N$。
在方格$1,2,\dots,N-1$上，各有一枚骰子。方格$i$上的骰子会按照相同的概率随机输出$0,1,\dots,A_i$中的一个。

直到到达方格$N$之前，你每次会前进骰子输出的步数。换句话说，如果你在方格$x$上（$1\le x < N$），骰子输出了数字$y$（$0\le y\le A_i$），你下一步会到达方格$x+y$。

求到达方格$N$步数的期望值，对$998244353$取模。

$2\le N\le 2\times 10^5$
$1\le A_i\le N-i$（$1\le i < N$）

有理数取模【洛谷模板：P2613】
任意一个有理数都可被表示为$\frac PQ$的形式。令$R$为取模的结果，则$R\times Q\equiv P~(\bmod~998244353)$。
友情提示：对于除法计算，如$\frac AB$计算时，改为$A\times B^{P-2}\bmod P$，其他逐步取模即可。本题中，$P=998244353$。

输入格式

$N$
$A_1~A_2~\dots~A_{N-1}$

输出格式

输出答案，对$998244353$取模。

分析

令$\text{dp}_i=~$从$i$到$N$的期望步数，则初始状态为$\text{dp}_N=0$，答案为$\text{dp}_1$。
由于在方格上不能倒退，因此考虑倒序计算$\text{dp}$。对于第$i$个点，易得

$$ \text{dp}_i=\frac{\sum\limits_{j=i}^{i+A_i}\text{dp}_j}{A_i+1}+1 $$

其中，求和即遍历后面每一个下一步可能到达的位置，乘上出现概率$\frac1{A_i+1}$，最后再加上$1$表示使用一步。
由于左右都有$\text{dp}_i$，无法直接计算，我们将其单独提出并解方程，得：

$$ \text{dp}_i=\frac{(\sum\limits_{j=i}^{i+A_i}\text{dp}_j)+A_i+1}{A_i} $$

此时，时间复杂度为$\mathcal O(N^2\log P)$（快速幂inv操作需要$\log P$的时间，其中$P=998244353$），使用后缀和优化后可达$\mathcal O(N\log P)$，可以通过本题。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


#include <cstdio>
#define maxn 200005
#define MOD 998244353
using namespace std;

using LL = long long;
int a[maxn], suf[maxn];

inline int inv(LL x)
{
 LL res = 1LL;
 int p = MOD - 2;
 while(p)
 {
 if(p & 1) (res *= x) %= MOD;
 (x *= x) %= MOD, p >>= 1;
 }
 return res;
}

int main()
{
 int n, cur;
 scanf("%d", &n);
 for(int i=0; i<n-1; i++)
 scanf("%d", a + i);
 for(int i=n-2; i>=0; i--)
 {
 int t = suf[i + 1] - suf[i + 1 + a[i]];
 if(t < 0) t += MOD;
 cur = (a[i] + t + 1LL) % MOD * inv(a[i]) % MOD;
 if((suf[i] = suf[i + 1] + cur) >= MOD)
 suf[i] -= MOD;
 }
 printf("%d\n", cur);
 return 0;
}

PyQt6/PySide6：账本项目前端制作【附完整项目地址】

Sat, 23 Jul 2022 08:00:00 +0800

前言

最近在家里闲着没事，正好又看到朋友@studentWheat发了篇用Tkinter做的账本，于是决定跟他一起改进这个程序。

屏幕截图：

后端

后端主要是朋友做的，在这里就不多说了，放个代码：
src/api.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75


from collections import defaultdict

class ApiError(RuntimeError):
 pass

def openFile(filename):
 '''
 Open file.
 File format: 4 lines per record for date, event type, money delta, and note.
 Such as:
 (file.example, encoding=utf-8)
 (Record 1)
 (ln 1) date1
 (ln 2) event_type1
 (ln 3) money_delta1
 (ln 4) note1
 (Record 2)
 (ln 5) date2
 (ln 6) event_type2
 (ln 7) money_delta2
 (ln 8) note2
 @param filename: File name.
 Returns: data in the format [[date1, event_type1, money_delta1, note1], ...]
 '''
 with open(filename, 'r', encoding='utf-8') as f:
 res = []
 while date := f.readline():
 if (etype := f.readline()) and (mdelta := f.readline()) and (note := f.readline()):
 res.append([date.rstrip('\n'), etype.rstrip('\n'), mdelta.rstrip('\n'), note.rstrip('\n')])
 else:
 raise ApiError('Unexpected EOF at ' + filename)
 return res

def saveFile(filename, data): # Save
 '''
 Save with the same format mentioned in openFile().
 @param filename: File name.
 @param data: Data with the same format returned in openFile().
 '''
 with open(filename, 'w', encoding='utf-8') as f:
 for line in data:
 print(*line, sep='\n', file=f)

def query(data, key):
 return [record for record in data if any(key in x for x in record)] if key else data

def total(data):
 in_total = out_total = 0
 for _, _, mdelta, _ in data:
 mdelta = int(mdelta)
 if mdelta < 0:
 out_total -= mdelta
 else:
 in_total += mdelta
 return in_total, out_total

def totalByEvent(data):
 cnt = defaultdict(lambda: [0, 0])
 for _, event, mdelta, _ in data:
 mdelta = int(mdelta)
 if mdelta < 0:
 cnt[event][1] -= mdelta
 else:
 cnt[event][0] += mdelta
 return cnt

def totalByDate(data):
 cnt = defaultdict(lambda: [0, 0])
 for date, _, mdelta, _ in data:
 mdelta = int(mdelta)
 if mdelta < 0:
 cnt[date][1] -= mdelta
 else:
 cnt[date][0] += mdelta
 return cnt

详见https://blog.csdn.net/qq_67190987/article/details/125918530。

前端

正如标题中所说，框架采用Qt6+Python，一般有两种选择（PyQt6和PySide6），我这里使用的是PySide6。

准备资源

在src/icons下存好所有图片资源：

Designer 窗口绘制

用Qt Designer绘制好各个窗口，如图:

安装依赖项

准备一份requirements.txt，内容如下：

1

PySide6>=6.3.1

然后，cmd中输入：

1

pip install -r requirements.txt

搞定安装。

编译资源和UI

这个就不用多说了，直接用pyside6-uic和pyside6-rcc命令编译文件，编译出的文件列表如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


AccountBook
└─src
 │ dlgAdd.ui
 │ dlgCharts.ui
 │ MainWindow.ui
 │ res.qrc
 │ res_rc.py
 │ ui_dlgAdd.py
 │ ui_dlgCharts.py
 │ ui_dlgHelp.py
 │ ui_MainWindow.py

代码编写

src/dlgAdd.py
“添加账目”窗口，一个简单的QDialog实例。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


from PySide6.QtWidgets import *
from PySide6.QtCore import QDate, QRegularExpression
from PySide6.QtGui import QRegularExpressionValidator
from ui_dlgAdd import Ui_Dialog

class dlgAdd(QDialog):
 def __init__(self, parent=None):
 super().__init__(parent)
 self.ui = Ui_Dialog()
 self.ui.setupUi(self)
 self.ui.dateEdit.setDate(QDate.currentDate())
 self.ui.moneyEdit.setValidator(QRegularExpressionValidator(QRegularExpression(r'(\+|\-)[1-9]+[0-9]*')))
 self.ui.buttonBox.button(QDialogButtonBox.Ok).setText('确定')
 self.ui.buttonBox.button(QDialogButtonBox.Cancel).setText('取消')
 
 def getRow(self):
 date = self.ui.dateEdit.text()
 event = self.ui.eventEdit.text()
 money = self.ui.moneyEdit.text()
 note = self.ui.noteEdit.text()
 return [date, event, money, note]

 def accept(self):
 if not self.ui.eventEdit.text():
 QMessageBox.critical(self, "错误", "事件不能为空，请重新填写。")
 return
 if self.ui.moneyEdit.text() in ('', '+', '-'):
 QMessageBox.critical(self, "错误", "金额不能为空，请重新填写。")
 return
 return super().accept()

src/dlgCharts.py
图表展示窗口，使用QtCharts（用法跟PyQt5/PySide2略有区别）绘制柱状图。后续会考虑增加更多图表。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97


from bisect import bisect_left, bisect_right

from PySide6.QtCore import QDate, Qt
from PySide6.QtWidgets import *
from PySide6.QtCharts import QBarCategoryAxis, QBarSeries, QBarSet, QChart, QChartView, QValueAxis

from api import total, totalByDate, totalByEvent
from ui_dlgCharts import Ui_Dialog

class dlgCharts(QDialog):
 def __init__(self, data, parent=None):
 super().__init__(parent)
 self.ui = Ui_Dialog()
 self.ui.setupUi(self)
 self.showMaximized()

 self.data = data
 minDate = QDate.fromString(data[0][0], 'yyyy/MM/dd')
 maxDate = QDate.fromString(data[-1][0], 'yyyy/MM/dd')
 self.ui.startDateEdit.setDateRange(minDate, maxDate)
 self.ui.endDateEdit.setDateRange(minDate, maxDate)
 self.ui.startDateEdit.setDate(minDate)
 self.ui.endDateEdit.setDate(maxDate)

 self.__update_totalChart(*total(data))
 self.__update_eventChart(totalByEvent(data))
 self.__update_dateChart(totalByDate(data))

 self.ui.startDateEdit.editingFinished.connect(self.__updateCharts)
 self.ui.endDateEdit.editingFinished.connect(self.__updateCharts)

 @staticmethod
 def createChart(chartView: QChartView, title, xAxis, yAxisList):
 chart = QChart()
 chart.setTitle(title)
 chart.setAnimationOptions(QChart.SeriesAnimations)

 series = QBarSeries()
 for axisName, data in yAxisList:
 barSet = QBarSet(axisName)
 barSet.append(data)
 series.append(barSet)
 chart.addSeries(series)

 axisX = QBarCategoryAxis()
 axisX.append(xAxis)
 chart.addAxis(axisX, Qt.AlignBottom)
 series.attachAxis(axisX)

 axisY = QValueAxis()
 axisY.setLabelFormat('%d')
 chart.addAxis(axisY, Qt.AlignLeft)
 series.attachAxis(axisY)

 chartView.setChart(chart)

 def __update_totalChart(self, total_in, total_out):
 self.createChart(
 chartView = self.ui.totalView,
 title = '总收支',
 xAxis = ['收入', '支出'], 
 yAxisList = [
 ('金额', [total_in, total_out])
 ]
 )

 def __update_eventChart(self, events):
 self.createChart(
 chartView = self.ui.eventView,
 title = '收支分类',
 xAxis = list(events.keys()),
 yAxisList = [
 ('收入', list(map(lambda x: x[0], events.values()))),
 ('支出', list(map(lambda x: x[1], events.values())))
 ]
 )

 def __update_dateChart(self, dates):
 self.createChart(
 chartView = self.ui.dateView,
 title = '每日收支',
 xAxis = list(dates.keys()),
 yAxisList = [
 ('收入', list(map(lambda x: x[0], dates.values()))),
 ('支出', list(map(lambda x: x[1], dates.values())))
 ]
 )

 def __updateCharts(self):
 startDate = self.ui.startDateEdit.text()
 endDate = self.ui.endDateEdit.text()
 left = bisect_left(self.data, startDate, key=lambda x: x[0])
 right = bisect_right(self.data, endDate, key=lambda x: x[0])
 data = self.data[left:right]
 self.__update_totalChart(*total(data))
 self.__update_eventChart(totalByEvent(data))
 self.__update_dateChart(totalByDate(data))

src/main.py
主程序，同时管理主窗口。最麻烦的地方是QTableView，要同时处理搜索和排序问题。

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209


import sys
from bisect import insort_right
from functools import partial
from os.path import basename
from webbrowser import open_new_tab

from PySide6.QtWidgets import *
from PySide6.QtCore import Slot, QDate
from PySide6.QtGui import QStandardItem, QStandardItemModel

from api import ApiError, openFile, query, saveFile
from dlgAdd import dlgAdd
from dlgCharts import dlgCharts
from ui_dlgHelp import Ui_Dialog as Ui_dlgHelp
from ui_MainWindow import Ui_MainWindow

# Version info
VERSION = '1.0.1'
CHANNEL = 'stable'
BUILD_DATE = '2022-07-01'
FULL_VERSION = f'{VERSION}-{CHANNEL} ({BUILD_DATE}) on {sys.platform}'

app = QApplication(sys.argv)

class AccountBookMainWindow(QMainWindow):
 version_str = '账本 ' + VERSION
 unsaved_tip = '*'
 SUPPORTED_FILTERS = '账本文件(*.abf);;文本文件(*.txt);;所有文件(*.*)'

 def __init__(self, parent=None):
 # Initialize window
 super().__init__(parent)
 self.ui = Ui_MainWindow()
 self.ui.setupUi(self)
 self.setWindowTitle('账本 ' + VERSION)
 self.labStatus = QLabel(self)
 self.ui.statusBar.addWidget(self.labStatus)

 # Initialize table
 self.model = QStandardItemModel(0, 4, self)
 self.model.setHorizontalHeaderLabels(['日期', '事项', '金额', '备注'])
 self.ui.table.setModel(self.model)
 self.ui.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)

 self.__data = []
 self.on_actFile_New_triggered()
 self.ui.actEdit_Remove.setEnabled(False)

 # Connect slots
 self.ui.table.selectionModel().selectionChanged.connect(self.__selectionChanged)
 self.model.itemChanged.connect(self.__itemChanged)

 def __updateTable(self, data):
 self.model.itemChanged.disconnect(self.__itemChanged)
 self.model.setRowCount(len(data))
 for row in range(len(data)):
 for col in range(len(data[row])):
 self.model.setItem(row, col, QStandardItem(data[row][col]))
 self.model.itemChanged.connect(self.__itemChanged)

 def __openFile(self, filename):
 try:
 self.__data = openFile(filename)
 except IOError:
 QMessageBox.critical(self, '错误', '文件打开失败。请稍后再试。')
 except ApiError:
 QMessageBox.critical(self, '错误', '文件格式错误。请检查文件完整性。')
 except Exception as e:
 QMessageBox.critical(self, '错误', '未知错误：' + str(e.with_traceback()))
 else:
 self.ui.searchEdit.clear()
 self.__key = ''
 self.__updateTable(self.__data)
 self.labStatus.setText(filename)
 self.setWindowTitle(self.version_str)
 self.__filename = filename

 def __saveFile(self, filename):
 try:
 saveFile(filename, self.__data)
 except IOError:
 QMessageBox.critical(self, '错误', '文件保存错误。请稍后再试。')
 except Exception as e:
 QMessageBox.critical(self, '错误', '未知错误：' + str(e.with_traceback()))
 else:
 self.labStatus.setText('保存成功：' + filename)
 self.setWindowTitle(self.version_str)
 self.__filename = filename

 @Slot()
 def on_actFile_New_triggered(self):
 self.__filename = self.__key = ''
 self.setWindowTitle(self.unsaved_tip + self.version_str)
 self.labStatus.setText('新文件')
 self.model.setRowCount(0)
 self.__data.clear()

 @Slot()
 def on_actFile_Open_triggered(self):
 filename, _ = QFileDialog.getOpenFileName(self, '打开', filter=self.SUPPORTED_FILTERS)
 if filename:
 self.__openFile(filename)

 @Slot()
 def on_actFile_Save_triggered(self):
 if self.__filename:
 self.__saveFile(self.__filename)
 else:
 filename, _ = QFileDialog.getSaveFileName(self, '保存', filter=self.SUPPORTED_FILTERS)
 if filename:
 self.__saveFile(filename)

 @Slot()
 def on_actFile_SaveAs_triggered(self):
 filename, _ = QFileDialog.getSaveFileName(self, '另存为', filter=self.SUPPORTED_FILTERS)
 if filename:
 self.__saveFile(filename)

 @Slot()
 def on_actHelp_About_triggered(self):
 dialog = QDialog(self)
 ui = Ui_dlgHelp()
 ui.setupUi(dialog)
 for link in (ui.githubLink, ui.giteeLink, ui.licenseLink, ui.readmeLink):
 link.clicked.connect(partial(open_new_tab, link.description()))
 ui.labVersion.setText('版本号：' + FULL_VERSION)
 ui.btnUpdate.clicked.connect(partial(open_new_tab, 'https://github.com/GoodCoder666/AccountBook/releases'))
 dialog.exec()

 @Slot()
 def on_actHelp_AboutQt_triggered(self):
 QMessageBox.aboutQt(self, '关于Qt')

 @Slot()
 def on_actEdit_Add_triggered(self):
 dialog = dlgAdd(self)
 if dialog.exec() == QDialog.Accepted:
 row = dialog.getRow()
 insort_right(self.__data, row)
 self.__updateTable(query(self.__data, self.__key))
 self.setWindowTitle(self.unsaved_tip + self.version_str)

 @Slot()
 def on_actEdit_Remove_triggered(self):
 rows = list(set(map(lambda idx: idx.row(), self.ui.table.selectedIndexes())))
 for row in rows:
 self.__data.remove([self.model.item(row, col).text() for col in range(self.model.columnCount())])
 self.model.itemChanged.disconnect(self.__itemChanged)
 self.model.removeRows(rows[0], len(rows))
 self.model.itemChanged.connect(self.__itemChanged)
 self.setWindowTitle(self.unsaved_tip + self.version_str)

 def __selectionChanged(self):
 self.ui.actEdit_Remove.setEnabled(self.ui.table.selectionModel().hasSelection())

 def __itemChanged(self, item: QStandardItem):
 i, j, new = item.row(), item.column(), item.text()
 if (old := self.__data[i][j]) == new: return
 if j == 0 and not QDate.fromString(new, 'yyyy/MM/dd').isValid():
 QMessageBox.critical(self, '错误', '日期格式错误。')
 self.model.itemChanged.disconnect(self.__itemChanged)
 item.setText(old)
 self.model.itemChanged.connect(self.__itemChanged)
 return
 row = self.__data.pop(i)
 row[j] = new
 insort_right(self.__data, row)
 self.__updateTable(query(self.__data, self.__key))
 self.setWindowTitle(self.unsaved_tip + self.version_str)

 @Slot()
 def on_searchEdit_textChanged(self):
 self.__key = self.ui.searchEdit.text()
 self.__updateTable(query(self.__data, self.__key))

 @Slot()
 def on_actStat_Show_triggered(self):
 if self.__data:
 dlgCharts(self.__data, self).exec()
 else:
 QMessageBox.information(self, '提示', '请添加数据以使用统计功能。')

 def closeEvent(self, event):
 if not self.windowTitle().startswith(self.unsaved_tip): return
 filename = basename(self.__filename) if self.__filename else '新文件'
 messageBox = QMessageBox(
 parent=self, icon=QMessageBox.Warning, windowTitle='提示',
 text=f'是否要保存对 {filename} 的更改？', informativeText='如果不保存，你的更改将丢失。',
 standardButtons=QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel
 )
 messageBox.setButtonText(QMessageBox.Save, '保存')
 messageBox.setButtonText(QMessageBox.Discard, '不保存')
 messageBox.setButtonText(QMessageBox.Cancel, '取消')
 reply = messageBox.exec()
 if reply == QMessageBox.Save:
 self.on_actFile_Save_triggered()
 event.accept()
 elif reply == QMessageBox.Discard:
 event.accept()
 else:
 event.ignore()

 def dropEvent(self, event):
 self.__openFile(event.mimeData().text()[8:]) # [8:] is to get rid of 'file:///'

mainform = AccountBookMainWindow()
mainform.show()

sys.exit(app.exec())

总结

本项目到此结束。

【附：项目地址】

GitHub 地址：https://github.com/GoodCoder666/AccountBook
Gitee 镜像地址：https://gitee.com/GoodCoder666/AccountBook

记得点个Star哦~

创作不易，若您喜欢这篇文章就请点个三连吧！万分感激！！！

AtCoder Beginner Contest 260 A~F 题解

Tue, 19 Jul 2022 20:31:00 +0800

A - A Unique Letter

题目大意

给定一个长度为$3$的字符串$S$。
输出$S$中出现正好一次的字母（任意，如abc中，三个字母都可为答案）。

如果没有，输出-1。

数据保证$S$的长为$3$，且由小写英文字母组成。

输入格式

$S$

输出格式

输出任意符合条件的答案。

样例

$S$	输出
`pop`	`o`
`abc`	`a`/`b`/`c`
`xxx`	`-1`

分析

我们设输入的3个字母分别为a、b、c。
首先，如果$a=b=c$，那么输出$-1$。
其次，我们依次尝试找到两个相同的字母：

xxy形式（$a=b$）：输出$c$
xyx形式（$a=c$）：输出$b$
yxx形式（$b=c$）：输出$a$
xyz形式（$a\ne b\ne c$）：输出任意一个

代码

这里，我把最后两种情况合并了（一个else搞定，都输出$a$）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


#include <cstdio>
using namespace std;

int main()
{
 char a = getchar(), b = getchar(), c = getchar();
 if(a == b && b == c) puts("-1");
 else if(a == c) putchar(b);
 else if(a == b) putchar(c);
 else putchar(a);
 return 0;
}

B - Better Students Are Needed!

题目大意

$N$个员工参加了一场选聘考试。
第$i$个员工数学考了$A_i$分，英语$B_i$分。

公司按如下的方式选聘员工：

数学分数在前$X$的被直接录取；
剩下的人中，英语分数在前$Y$的被录取；
最后，总分在前$Z$的被录取，剩下的人被淘汰。

注意：分数相同的员工按编号排序。

输出被录取的所有员工的编号，按升序排列。

$1\le N\le 1000$
$0\le X,Y,Z\le N$
$1\le X+Y+Z\le N$
$0\le A_i,B_i\le 100$

输入格式

$N~X~Y~Z$
$A_1~A_2~\dots~A_N$
$B_1~B_2~\dots~B_N$

输出格式

输出被录取的所有员工的编号，按升序排列，每行一个。

样例

略，请自行前往AtCoder查看

分析

本题主要有两种思路：

用pair<int, int>代表一个员工，再使用vector+sort或priority_queue执行三次分别排序数学、英语、总分；
用struct { int math, english, id; }表示员工，存储一次，排序三次（使用不同的排序依据）

详见代码1、代码2。

代码

代码1

vector+sort实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


#include <cstdio>
#include <vector>
#include <algorithm>
#define maxn 1005
using namespace std;

int a[maxn], b[maxn];
bool used[maxn];

int main()
{
 int n, x, y, z;
 scanf("%d%d%d%d", &n, &x, &y, &z);
 for(int i=0; i<n; i++)
 scanf("%d", a + i);
 for(int i=0; i<n; i++)
 scanf("%d", b + i);

 // Math
 vector<pair<int, int>> sel_a;
 for(int i=0; i<n; i++)
 sel_a.emplace_back(-a[i], i);
 sort(sel_a.begin(), sel_a.end());
 for(int i=0; i<x; i++)
 used[sel_a[i].second] = true;

 // English
 vector<pair<int, int>> sel_b;
 for(int i=0; i<n; i++)
 if(!used[i])
 sel_b.emplace_back(-b[i], i);
 sort(sel_b.begin(), sel_b.end());
 for(int i=0; i<y; i++)
 used[sel_b[i].second] = true;

 // Total
 vector<pair<int, int>> sel_t;
 for(int i=0; i<n; i++)
 if(!used[i])
 sel_t.emplace_back(-(a[i] + b[i]), i);
 sort(sel_t.begin(), sel_t.end());
 for(int i=0; i<z; i++)
 used[sel_t[i].second] = true;

 for(int i=0; i<n; i++)
 if(used[i])
 printf("%d\n", i + 1);
 return 0;
}

priority_queue实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


#include <cstdio>
#include <queue>
#define maxn 1005
using namespace std;

int a[maxn], b[maxn], c[maxn];
bool used[maxn];

inline void selectOnce(int* scores, int n, int snum)
{
 priority_queue<pair<int, int>> sel;
 for(int i=0; i<n; i++)
 if(!used[i])
 {
 sel.emplace(-scores[i], i);
 if(sel.size() > snum) sel.pop();
 }
 while(!sel.empty())
 used[sel.top().second] = true, sel.pop();
}

int main()
{
 int n, x, y, z;
 scanf("%d%d%d%d", &n, &x, &y, &z);
 for(int i=0; i<n; i++)
 scanf("%d", a + i);
 for(int i=0; i<n; i++)
 scanf("%d", b + i);
 for(int i=0; i<n; i++)
 c[i] = a[i] + b[i];
 selectOnce(a, n, x);
 selectOnce(b, n, y);
 selectOnce(c, n, z);
 for(int i=0; i<n; i++)
 if(used[i])
 printf("%d\n", i + 1);
 return 0;
}

代码2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


#include <cstdio>
#include <vector>
#include <algorithm>
#define maxn 1005
using namespace std;

struct Emp { // Employee
 int math, eng, id;
} emps[maxn];

inline bool cmp1(const Emp& e1, const Emp& e2) {
 return e1.math == e2.math?
 e1.id < e2.id:
 e1.math > e2.math;
}

inline bool cmp2(const Emp& e1, const Emp& e2) {
 return e1.eng == e2.eng?
 e1.id < e2.id:
 e1.eng > e2.eng;
}

inline bool cmp3(const Emp& e1, const Emp& e2) {
 int tot1 = e1.math + e1.eng, tot2 = e2.eng + e2.math;
 return tot1 == tot2?
 e1.id < e2.id:
 tot1 > tot2;
}

inline bool cmp4(const Emp& e1, const Emp& e2) {
 return e1.id < e2.id;
}

int main()
{
 // Input
 int n, x, y, z;
 scanf("%d%d%d%d", &n, &x, &y, &z);
 
 for(int i=0; i<n; i++)
 scanf("%d", &emps[i].math),
 emps[i].id = i;
 for(int i=0; i<n; i++)
 scanf("%d", &emps[i].eng);
 
 // Sort
 auto last = emps + n;
 sort(emps, last, cmp1);
 sort(emps + x, last, cmp2);
 sort(emps + x + y, last, cmp3);
 sort(emps, emps + x + y + z, cmp4); // 按编号升序排序
 
 // Output
 for(int i=0; i<x+y+z; i++)
 printf("%d\n", emps[i].id + 1);
 return 0;
}

C - Changing Jewels

题目大意

Takahashi有一个$N$级的红色宝石。
他可以重复下列操作任意次数：

将一个$N$级的红色宝石转换为“一个$(N-1)$级的红色宝石和$X$个$N$级的蓝色宝石”。
将一个$N$级的蓝色宝石转换为“一个$(N-1)$级的红色宝石和$Y$个$N-1$级的蓝色宝石”。

Takahashi最后最多能得到几个$1$级的蓝色宝石？

$1\le N\le 10$
$1\le X,Y\le 5$

输入格式

$N~X~Y$

输出格式

输出一个整数，即最终蓝色宝石的数量。

样例

$N$	$X$	$Y$	输出
$2$	$3$	$4$	$12$
$10$	$5$	$5$	$3942349900$

注意小心$32$位整数（int/int32）溢出。

分析

要获得$(N-1)$级的蓝宝石，必须先尽可能多的获得$N$级的蓝宝石。
而要达到这个目的，就需要有尽可能多的$N$级红宝石。

以此类推，我们可以按顺序进行操作$1$，操作$2$……直到所有宝石全部为$1$级（也就是循环$(N-1)$次）。维护两个变量$\text{red}$（初始为$1$）和$\text{blue}$（初始为$0$），分别表示当前的红、蓝宝石的数目。
每次循环，先将$\text{blue}$加上$\text{red}\times X$（操作$1$），再将$\text{red}$加上$\text{blue}$、$\text{blue}$乘上$Y$（操作$2$）。

时间复杂度$\mathcal O(n)$，如有读不懂的地方，可参考代码。

代码

注意使用long long。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <cstdio>
using namespace std;

int main()
{
 int n, x, y;
 scanf("%d%d%d", &n, &x, &y);
 long long red = 1LL, blue = 0LL;
 while(--n)
 {
 blue += red * x;
 red += blue, blue *= y;
 }
 printf("%lld\n", blue);
 return 0;
}

D - Draw Your Cards

题目大意

有$N$张牌，上面分别写着数字$P_1,P_2,\dots,P_N$。
按照这个顺序，我们进行$N$个操作，第$i$个操作的具体步骤如下：

取出第$i$张牌，令$X=P_i$；
找到存堆中顶牌$~\ge X$的最小一张，将这张牌置于其上；
如果没有符合条件的牌，将$X$放入一新堆；
当某堆牌数达到$K$时，把这堆的牌全部吃掉。

求每张牌被吃掉的时间（若没有被吃掉，输出-1，详见输出格式）。

$1\le K\le N \le 2\times 10^5$
$P$是$(1,2,\dots,N)$的一种排列。

输入格式

$N~K$
$P_1~P_2~\dots~P_N$

输出格式

输出$N$行，第$i$行表示卡片$i$被吃掉的时间（如果没被吃掉，输出-1）。

样例

略，~~就是懒~~

分析

首先肯定不能用vector<stack<int>>这种数据结构，效率太低，容易写错，还不好用。可以用一个类似于并查集的数据结构，每次叠放操作都可看作“把下面的牌的父亲设置为上面的牌”。我们还需要记录并查集中每个连通分量的大小，方便模拟“吃掉”操作。

最终对于每个节点，输出其祖宗被吃掉的时间（~~咋听起来有点怪~~）。

目前的时间复杂度是$\mathcal O(N^2)$，因为每次操作都需要用$\mathcal O(n)$的时间，找到最小的符合条件的牌堆。
很容易想到，可以使用set优化。

set是自动排序的集合，常用的的操作有插入（insert）、删除（erase）、二分查找（lower_bound/upper_bound），一次操作的时间复杂度均为$\mathcal O(\log n)$。

这时，使用一个set<int>维护每个堆顶的卡牌编号，就可以把时间复杂度降到$\mathcal O(n\log n)$以内。

至此，此题完。注意对$K=1$的特判。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


#include <cstdio>
#include <set>
#define maxn 200005
using namespace std;

int fa[maxn], eat[maxn], sz[maxn];

int find(int x) {
 return fa[x] == x? x: fa[x] = find(fa[x]);
}

int main()
{
 int n, k;
 scanf("%d%d", &n, &k);
 set<int> cards;
 for(int i=0; i<n; i++)
 {
 int x;
 scanf("%d", &x);
 x --;
 eat[x] = -1, fa[x] = x;
 if(k == 1)
 {
 eat[x] = i + 1;
 continue;
 }
 auto it = cards.upper_bound(x);
 if(it == cards.end())
 cards.insert(x), sz[x] = 1;
 else
 {
 fa[*it] = x;
 cards.erase(it);
 if((sz[x] = sz[*it] + 1) == k)
 eat[x] = i + 1;
 else cards.insert(x);
 }
 }
 for(int i=0; i<n; i++)
 printf("%d\n", eat[find(i)]);
 return 0;
}

E - At Least One

题目大意

给定整数$M$和$N$对整数：$(A_1,B_1),(A_2,B_2),\dots,(A_N,B_N)$。
题目保证对于任意$i$，$1\le A_i < B_i\le M$。

符合如下条件的整数序列$S$被称作好的序列：

$S$是$(1,2,\dots,M)$的连续子序列；
对于每个$i$，$S$中包含$A_i$或$B_i$（或同时包含）。

令$f(k)=($长为$k$的好序列的个数$)$。求$f(1),f(2),\dots,f(M)$。

$1\le N\le 2\times 10^5$
$2\le M\le 2\times 10^5$
$1\le A_i < B_i\le M$

输入格式

$N~M$
$A_1~B_1$
$A_2~B_2$
$\vdots$
$A_N~B_N$

输出格式

输出一行，即$f(1),f(2),\dots,f(M)$，用空格分隔。

样例

略，请自行前往AtCoder查看

分析

首先，根据题意，$S$可被表示为一个区间$[l,r]$，其中$1\le l\le r\le M$。
当对于每个$i$，$l\le A_i\le r$或$l\le B_i\le r$时，区间$[l,r]$符合条件。
若按这样直接暴力枚举，时间复杂度为$\mathcal O(N^2M)$，明显超时，不可取。

仔细想想会发现，对于两个区间$[l,r]$和$[a,b]$，若$a\le l\le r\le b$，且$[l,r]$符合条件，则$[a,b]$也肯定符合条件。

此时，可以考虑使用滑动窗口优化，则时间复杂度降至$\mathcal O(MN)$。

继续优化。在窗口滑动的过程中，每次移动左/右端点时考虑一次移动对当前符合条件的$i$的数量的贡献，需要两个数组$\mathrm{cnt}[N]$（记录每个$A_i$和$B_i$符合条件的个数）和$\mathrm{inv}[M+1][\dots]$（预处理每个数值对应的所有元素下标）。

总时间复杂度为$\mathcal O(N+M)$，详见代码。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


#include <cstdio>
#include <vector>
#define maxn 200005
using namespace std;

vector<int> inv[maxn];
int cnt[maxn], ans[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 for(int i=0; i<n; i++)
 {
 int a, b;
 scanf("%d%d", &a, &b);
 inv[a].push_back(i);
 inv[b].push_back(i);
 }
 int left = n;
 for(int i=1, j=1; i<=m; i++)
 {
 for(; j <= m && left > 0; j++)
 for(int x: inv[j])
 if(++cnt[x] == 1)
 left --;
 if(left > 0) break;
 ans[j - i] ++, ans[m - i + 2] --;
 for(int x: inv[i])
 if(--cnt[x] == 0)
 left ++;
 }
 for(int i=1; i<=m; i++)
 printf("%d ", ans[i] += ans[i - 1]);
 return 0;
}

F - Find 4-cycle

给定一个二分图$G$，形如下：

图片来源：二分图_百度百科

其中顶点集$U$中的顶点数为$S$，$V$的顶点数为$T$，总边数为$M$（第$i$条边连接$u_i$和$v_i$）。
请找出此图中任意长为$4$的环。如果没有，输出-1。

$2\le S\le 3\times 10^5$
==$2\le T\le 3000$==
$4\le M\le \min(S\times T,3\times 10^5)$
$1\le u_i\le S < v_i\le S+T$

输入格式

$S~T~M$
$u_1~V_1$
$u_2~V_2$
$\vdots$
$u_M~V_M$

输出格式

如果有长为$4$的环，输出其中四个顶点的编号（顺序随意，用空格分隔）。
如果没有，输出-1。

样例

略，请自行前往AtCoder查看

分析

注意到样例中$T$只有$3000$，$\mathcal O(T^2)=9\times 10^6$可以接受。
然后因为是二分图，所以长为$4$的环肯定是在两个顶点集中各有两个点。

令$f(x,y)$为目前发现的与点$x,y$都相连的点，初始化为$-1$（表示未发现）。
输入使用邻接表存储，$G[v]$存储连到$v$的所有点，注意只需存顶点集$U$的$G[v]$即可。
再对于每个$v$，依次枚举$G[v]$中的两个点$(x,y)$，如果$f(x,y)=-1$，则执行$f(x,y):=v$，如果不是$-1$，则输出{x} {y} {v} {f(x,y)}，结束程序。

时间复杂度约为$\mathcal O(T^2)$。

本题中的时间复杂度怎么算？
$\to f(x,y)$中不同$(x,y)$的组合只有$T(T-1)=T^2-T\approx T^2$种。
$\to~$ 根据鸽笼原理（又称抽屉原理），在最坏情况下，$T^2$种组合都记录过$f$之后，下一种组合无论是什么肯定都已经记录过$f$，因此最坏时间复杂度为$\mathcal O(T^2)$，对于随机数据的平均时间复杂度远远小于这个值。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


#include <cstdio>
#include <cstring>
#include <vector>
#define maxs 300005
#define maxt 3005
using namespace std;

vector<int> G[maxs];
int f[maxt][maxt];

int main()
{
 int s, t, m;
 scanf("%d%d%d", &s, &t, &m);
 while(m--)
 {
 int u, v;
 scanf("%d%d", &u, &v);
 G[--u].push_back(--v - s);
 }
 memset(f, -1, sizeof(f));
 for(int i=0; i<s; i++)
 for(int j=0; j+1<G[i].size(); j++)
 for(int k=j+1; k<G[i].size(); k++)
 {
 int u = G[i][j], v = G[i][k];
 if(u > v) u ^= v ^= u ^= v;
 if(f[u][v] != -1)
 {
 printf("%d %d %d %d\n", f[u][v] + 1, i + 1, u + s + 1, v + s + 1);
 return 0;
 }
 f[u][v] = i;
 }
 puts("-1");
 return 0;
}

AtCoder Beginner Contest 258 A~Ex 题解

Mon, 04 Jul 2022 22:15:00 +0800

D - Trophy

题目大意

有一个游戏，由$N$个关卡组成。第$i$个关卡由一个数对$(A_i,B_i)$组成。

要通过一个关卡，你必须先花$A_i$的时间看一次介绍。然后，用$B_i$的时间打通这个关卡。若想多次通过同一个关卡，则第一次需要看介绍，后面无需再看（即如果想打通第$i$关$N$次，则所需时间为$A_i+N\times B_i$）。

开始时，只有第一关被解锁。当你每打通一关，其下一关会自动解锁（最后一关除外）。求总共打通$X$关的最少时间（重复通关也算）。

$1\le N\le 2\times 10^5$
$1\le A_i,B_i\le 10^9$
$1\le X\le N$

输入格式

$N~X$
$A_1~B_1$
$\vdots$
$A_N~B_N$

输出格式

输出答案。

样例

略，请自行前往AtCoder查看。

分析

仔细想想会发现，通过的方式都是先不重复通过某一关前所有关卡，再通过这一关一定次数，最终达到正好$X$次。因此，我们利用前缀和，依次枚举每个关卡，最终时间复杂度可达$\mathcal O(n)$。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <cstdio>
#define INF 0x7FFFFFFFFFFFFFFFLL
using namespace std;

int main()
{
 int n, x;
 scanf("%d%d", &n, &x);
 if(x < n) n = x;
 long long s = 0LL, ans = INF, cur;
 for(int i=1; i<=n; i++)
 {
 int a, b;
 scanf("%d%d", &a, &b);
 if((cur = (s += a + b) + (long long)(x - i) * b) < ans)
 ans = cur;
 }
 printf("%lld\n", ans);
 return 0;
}

E - Packing Potatoes

题目大意

$10^{100}$个土豆排成一列。它们的重量分别是$W_0,W_1,\dots,W_{N-1},W_0,\dots$，即第$i$个土豆的重量是$W_{i\bmod N}$（$i=0,1,2,\dots$）。

Takahashi会往一个盒子里依次放入每个土豆，当放入的土豆总重量$~\ge X$的时候他会换一个新盒子。

给定$Q$个询问。第$i$个询问：给定整数$K_i$，求第$K_i$个盒子中土豆的个数。

$1\le N,Q\le 2\times 10^5$
$1\le X,W_i\le 10^9$
$1\le K_i\le 10^{12}$

输入格式

$N~Q~X$
$W_0~\dots~W_{N-1}$
$K_1$
$\vdots$
$K_Q$

输出格式

输出$Q$行，第$i$行是第$i$个询问的答案。

样例

略，请自行前往AtCoder查看。

分析

周期问题。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74


#include <cstdio>
#include <vector>
#define maxn 200005
using namespace std;

using LL = long long;
int cnt[maxn], ord[maxn], w[maxn << 1];

template <typename T>
inline T read()
{
 char c;
 while((c = getchar()) < '0' || c > '9');
 T res = c ^ 48;
 while((c = getchar()) >= '0' && c <= '9')
 res = (res << T(3)) + (res << T(1)) + (c ^ 48);
 return res;
}

inline void print(int x)
{
 if(x > 9) print(x / 10);
 putchar(x % 10 ^ 48);
}

inline void println(int x)
{
 print(x);
 putchar('\n');
}

int main()
{
 int n = read<int>(), q = read<int>(), x = read<int>();
 LL sum = 0LL;
 for(int i=0; i<n; i++)
 sum += w[i + n] = w[i] = read<int>();
 int fill = x / sum * n;
 for(int i=0; i<n; i++)
 cnt[i] = fill, ord[i] = -1;
 x %= sum;
 for(int i=0, j=0, s=0; i<n; i++)
 {
 if(j < i) j = i, s = 0;
 while(s < x)
 {
 s += w[j];
 j += 1;
 }
 cnt[i] += j - i;
 s -= w[i];
 }
 vector<int> path;
 int loop = -1;
 for(int u=0, k=0; ; k++)
 {
 if(ord[u] != -1)
 {
 loop = k - ord[u];
 break;
 }
 ord[u] = k;
 path.push_back(u);
 (u += cnt[u]) %= n;
 }
 int non_loop = path.size() - loop;
 while(q--)
 {
 LL k = read<LL>();
 println(cnt[path[--k < non_loop? k:
 non_loop + (k - non_loop) % loop]]);
 }
 return 0;
}

F - Main Street

WJ...

G - Triangle

题目大意

给定一张由$N$个点组成的简单无向图$G$和它的邻接矩阵$A$。

什么是邻接矩阵 ？

邻接矩阵，顾名思义，即表示图中每两点之间关系的矩阵。

如本题中$A_{i,j}$表示$i,j$两点之间是否有边。$A_{i,j}=0$表示无边，$1$表示有边。

一般来说，对于任意简单无向图，$A_{i,i}=0$，$A_{i,j}=A_{j,i}$ ($i\ne j$)。

求数对$(i,j,k)$的个数，使得：

$1\le i < j < k\le N$
$(i,j,k)$三个点在图中组成一个三角形，即$i,j,k$中任意两点之间有一条连边。

$3\le N\le 3000$

输入格式

$N$
$A_{1,1}A_{1,2}\dots A_{1,N}$
$A_{2,1}A_{2,2}\dots A_{2,N}$
$\vdots$
$A_{N,1}A_{N,2}\dots A_{N,N}$（注意没有空格，如10110）

输出格式

输出一个整数，即符合条件的数对$(i,j,k)$的个数。

样例

略，请自行前往AtCoder查看。

分析

前言

个人感觉这题其实是这场比赛中最有意思的题。题目不难，但很具有研究意义。
这里我将从各个角度分析题目，也期待大家在评论区中分享其他方法。

废话不多说，题解开始！

题目说得太啰嗦，其实不用管什么图论，可以看成是给定$N\times N$的$01$矩阵$A$，求$A_{i,j}=A_{i,k}=A_{j,k}=1$的$(i,j,k)$的个数。

再来看数据范围。$N\le 3000$，则$\mathcal O(N^3)$的朴素算法时间可达到$T(2.7\times 10^{10})$，显然无法通过。

然而，事实并非如此。
在仔细研究后发现，时间限制为$3\mathrm{s}$的题目可以使用复杂度稍高的算法。
但是一般来说，极端情况下超过$T(10^{10})$的算法无法通过。
因此，也许是数据不够强吧，使用如下的优化可以恰好通过（#32949139 $37764\mathrm{KB},2755 \mathrm{ms}$）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


#pragma GCC optimize("Ofast") // -Ofast 预编译优化
#include <cstdio>
#define maxn 3000 // 数组大小设置正好，减少内存占用
using namespace std;

// 题目中正常的邻接矩阵
bool a[maxn][maxn];

// 特殊邻接表存储，减少尝试次数
// 这里不使用vector，会拖慢速度
int G[maxn][maxn], sz[maxn];

inline void print(const long long& x) // 快写-输出优化
{
 if(x > 9LL) print(x / 10);
 putchar(x % 10 ^ 48);
}

int main()
{
 // getchar快读输入优化
 int n = 0; char c;
 while((c = getchar()) != '\n')
 n = (n << 3) + (n << 1) + (c ^ 48);
 for(int i=0; i<n; i++, getchar())
 for(int j=0; j<n; j++)
 if(getchar() == '1' && j > i) // j > i：只存一半，去掉重复
 a[i][j] = 1, G[i][sz[i]++] = j;

 // 注意答案数据类型使用long long
 long long ans = 0LL;
 for(int v=0; v<n; ++v)
 for(int i=0; i<sz[v]; ++i) // 直接调取邻接表，省去不必要判断
 {
 int u = G[v][i];
 for(int j=0; j<sz[u]; ++j)
 if(a[v][G[u][j]])
 ans ++;
 }
 print(ans);
 return 0;
}

当然，这种方法并非每道题都能用，因此还是建议大家继续看正解。

正解还是基于上面的朴素算法，可看作：

依次遍历$A_{i,j}=1$的$(i,j)$（$i < j$）
=> 将答案加上$A[i]$和$A[j]$对应位置上都是$1$的位置个数
输出答案，除以3（去掉每个重复算的三次）

那么别的地方都没办法，只有第二步可以使用bitset的并集(&)操作进行优化。此时时间复杂度为$\mathcal O(\frac{n^3}w)$，其中$w=64$。详见代码。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <cstdio>
#include <bitset>
#define maxn 3000
using namespace std;

bitset<maxn> a[maxn];

int main()
{
 int n = 0; char c;
 while((c = getchar()) != '\n')
 n = (n << 3) + (n << 1) + (c ^ 48);
 for(int i=0; i<n; i++, getchar())
 for(int j=0; j<n; j++)
 if(getchar() == '1')
 a[i].set(j); // a[i][j] = 1
 long long ans = 0LL;
 for(int i=0; i+1<n; i++)
 for(int j=i+1; j<n; j++)
 if(a[i][j])
 ans += (a[i] & a[j]).count(); // 取交集，数1的个数
 printf("%lld\n", ans / 3LL);
 return 0;
}

AtCoder Beginner Contest 254 A~E 题解

Sat, 04 Jun 2022 22:41:00 +0800

A - Last Two Digits

题目大意

给定正整数$N$，求$N$的后两位。
$100\le N\le 999$

输入格式

$N$

输出格式

输出$N$的后两位，注意输出可能有前导0。

样例

$N$	输出
$254$	`54`
$101$	`01`

分析

题目已经规定$N$是三位数，因此无需使用整数输入，直接将输入看成字符串，输出后两位即可。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 getchar();
 putchar(getchar());
 putchar(getchar());
 return 0;
}

B - Practical Computing

题目大意

输出$N$个整数序列$A_0,\dots,A_{N-1}$。它们按如下定义：

$A_i$的长为$i+1$。
$A_i$的第$j+1$个元素记为$a_{i,j}$（$0\le j\le i < N$），即：
- 当$j=0$或$j=i$时，$a_{i,j}=1$；
- 否则，$a_{i,j}=a_{i-1,j-1}+a_{i-1,j}$。

$1\le N\le 30$

输入格式

$N$

输出格式

输出$N$行。第$i$行上有$A_{i-1}$中的$i$个数，用空格分隔。

样例

样例输入1

1

3

样例输出1

样例输入2

1

10

样例输出2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1

分析

其实不用读题，看一眼样例，是不是很眼熟？没错，就是著名的杨辉三角。
不知道也没关系（~~不过应该也没人不知道~~），直接按题目要求（$i,j$正序）依次计算即可。时间复杂度$\mathcal O(n^2)$，空间复杂度$\mathcal O(n)$或$\mathcal O(n^2)$。详见代码$1,2$。

继续考虑，杨辉三角中$a_{i,j}=C_j^i$，所以可以用$\mathcal O(1)$的空间计算，时间不变，代码待会补。

代码

代码$1$（普通方法+无优化+cin/cout，$7\text{ms}~3604\text{KB}$）
时间：$\mathcal O(n^2)$
空间：$\mathcal O(n^2)$
难度：低

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


#include <iostream>
using namespace std;

int arr[35][35];

int main()
{
 int n;
 cin >> n;
 for (int i = 0; i < n; i++)
 {
 arr[i][0] = 1;
 arr[i][i] = 1;
 }
 for (int i = 2; i < n; i++)
 {
 for (int j = 1; j < i; j++)
 {
 arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
 }
 }
 for (int i = 0; i < n; i++)
 {
 for (int j = 0; j <= i; j++)
 {
 cout << arr[i][j] << " ";
 }
 cout << endl;
 }
 return 0;
}

代码$2$（普通方法+滚动表+scanf/printf，$6\text{ms}~1656\text{KB}$）
时间：$\mathcal O(n^2)$
空间：$\mathcal O(n)$
难度：中低

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <cstdio>
using namespace std;

int a[35];

int main()
{
 int n;
 scanf("%d", &n);
 a[0] = 1, puts("1");
 for(int i=1; i<n; i++)
 {
 putchar('1');
 for(int j=i-1; j>0; j--)
 a[j] += a[j - 1];
 for(int j=1; j<i; j++)
 printf(" %d", a[j]);
 a[i] = 1, puts(" 1");
 }
 return 0;
}

C - K Swap

题目大意

给定长度为$N$的序列$A=(a_1,a_2,\dots,a_N)$和整数$K$，你可以重复下列操作任意次：

选择整数$1\le i\le N-K$，交换$a_i$和$a_{i+K}$。

问：是否能通过上述操作将$A$按升序排列？

$2\le N\le 2\times 10^5$
$1\le K\le N-1$
$1\le a_i\le 10^9$

输入格式

$N~K$
$a_1~\dots~a_N$

输出格式

如果可以达到目标，输出Yes；否则，输出No。

样例

样例输入1

样例输出1

1

Yes

该样例中，$A=(3,4,1,3,4),K=2$。一种完成任务的操作如下：

交换$a_1$和$a_3$，此时$A=(1,4,3,3,4)$；
交换$a_2$和$a_4$，此时$A=(1,3,3,4,4)$，排序完成。

样例输入2

样例输出2

1

No

$K=3$，无法将$A$排序。

样例输入3

1
2


7 5
1 2 3 4 5 5 10

样例输出3

1

Yes

可以不进行操作。

分析

题目可以看成：在$a_i,a_{K+i},a_{2K+i},\dots$（$1\le i < K$）中的元素是可以两两相邻交换的。那么，根据冒泡排序的原理，这些元素是可以直接排序并放入原位置上的。此时，只需依次对于$i=1,2,\dots,K-1$的上述序列并排序、放回原位，最终检查是否已被排成升序即可。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <cstdio>
#include <set>
#include <algorithm>
#define maxn 200005
using namespace std;

int a[maxn], b[maxn];

int main()
{
 int n, k;
 scanf("%d%d", &n, &k);
 for(int i=0; i<n; i++)
 {
 scanf("%d", a + i);
 b[i] = a[i];
 }
 sort(b, b + n);
 for(int i=0; i<k; i++)
 {
 multiset<int> s1, s2;
 for(int j=i; j<n; j+=k)
 {
 s1.insert(a[j]);
 s2.insert(b[j]);
 }
 if(s1 != s2)
 {
 puts("No");
 return 0;
 }
 }
 puts("Yes");
 return 0;
}

特别: 本题涉及到很多数组操作，使用Python代码量非常小（使用数组切片和sorted()），所以也是一道很好的Python数组练习题。因此，这里破例提供Python示例代码：

1
2
3
4
5


n, k = map(int, input().split())
a = list(map(int, input().split()))
for i in range(k):
 a[i::k] = sorted(a[i::k])
print('Yes' if a == sorted(a) else 'No')

D - Together Square

题目大意

给定整数$N$。求正整数对$(i,j)$的个数，满足：

$1\le i,j\le N$
$i\times j$是一个完全平方数（即$1^2,2^2,3^2,\dots$）

$1\le N\le 2\times 10^5$

输入格式

$N$

输出格式

输出答案。

样例

$N$	输出
$4$	$6$
$254$	$896$

分析

注意$N$较大，所以最容易想到的$\mathcal O(n^2)$暴力枚举肯定是不行的，然后仔细思考后发现可以枚举整数对$(x,y)$（$1\le x,y\le\lfloor\sqrt N\rfloor$），当$x,y$互质时将答案加上$\frac N {\max\{x^2,y^2\}}$，这样答案正确，建议读者自行思考原因。

时间复杂度计算：

循环（次数$\sqrt N$，枚举$x$）
- 循环（次数$\sqrt N$，枚举$y$）
  - gcd最大公约数算法（辗转相除法$\log\max\{x,y\}\approx\log\sqrt N$，判断互质）

综上，总时间复杂度为$\mathcal O(\sqrt N\times\sqrt N\times\log\sqrt N)=\mathcal O(N\log\sqrt N)$。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


#include <cstdio>
using namespace std;

inline int gcd(int a, int b)
{
 while(b ^= a ^= b ^= a %= b);
 return a;
}

int main()
{
 int n = 0; char c;
 while((c = getchar()) != '\n')
 n = (n << 3) + (n << 1) + (c ^ 48);
 int t = __builtin_sqrt(n);
 long long ans = 0LL, x;
 for(int i=1; i<=t; i++)
 for(int j=i; j<=t; j++)
 if(gcd(i, j) == 1)
 {
 ans += (x = n / (i > j? i * i: j * j));
 if(i != j) ans += x;
 }
 printf("%lld\n", ans);
 return 0;
}

E - Small d and k

题目大意

给定一个由$N$个点和$M$条边组成的简单无向图。
对于每个$i=1,2,\dots,M$，第$i$条边连接顶点$a_i$和$b_i$。

已知 ==每个顶点的度数不超过3==，回答下列$Q$个查询，第$i$个查询为：

求与顶点$x_i$距离不超过$k_i$的点的下标之和。

$1\le N,Q\le 1.5\times 10^5$
$0\le M\le \min\{\frac{N(N-1)}2,\frac32N\}$
$1\le a_i < b_i\le N$，$(a_i,b_i)$互不相同。
$1\le x_i\le N$，==$0\le k_i\le 3$==

输入格式

$N~M$
$a_1~b_1$
$\vdots$
$a_M~b_M$
$Q$
$x_1~k_1$
$\vdots$
$x_Q~k_Q$

输出格式

输出$Q$行。第$i$行应包含第$i$个查询的答案。

样例

样例输入

样例输出

样例解释：AtCoder 254E - Small d and k #sample

分析

注意这题数据范围，这是解体的关键：

减少算法耗时：
- $0\le k\le 3$
- 顶点度数$~\le3$
- 根据乘法原理，一次查询最大符合条件的顶点数为$3^3+1=28$个
防止常数问题：
- $1\le N\le \textbf{1.5}\times 10^5$
- 时间限制$3.5\text{s}$

因此，使用简单的暴力$\text{BFS}$正好符合题目数据范围。详见代码。

代码

注意dis数组的清零操作，无需全部清零，只需把刚刚改过的清零即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


#include <cstdio>
#include <queue>
#define maxn 150005
using namespace std;

vector<int> G[maxn];
int dis[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int a, b;
 scanf("%d%d", &a, &b);
 G[a].push_back(b);
 G[b].push_back(a);
 }
 int Q; scanf("%d", &Q);
 for(int i=1; i<=n; i++) dis[i] = -1;
 while(Q--)
 {
 int x, k;
 scanf("%d%d", &x, &k);
 vector<int> ans;
 queue<int> q;
 q.push(x);
 dis[x] = 0;
 while(!q.empty())
 {
 int v = q.front(); q.pop();
 int d = dis[v];
 if(d <= k) ans.push_back(v);
 if(++d > k) continue;
 for(int u: G[v])
 if(dis[u] == -1)
 {
 dis[u] = d;
 q.push(u);
 }
 }
 int res = 0;
 for(int v: ans)
 res += v, dis[v] = -1;
 printf("%d\n", res);
 }
 return 0;
}

AtCoder Beginner Contest 253 A~E 题解

Sun, 29 May 2022 16:07:00 +0800

A - Median?

题目大意

给定正整数$a,b,c$，判断$b$是否为三个数中的中位数（即从小到大排序后是第二个，不是平均数）。
$1\le a,b,c\le 100$

输入格式

$a~b~c$

输出格式

如果$b$是三个数中的中位数，输出Yes；否则，输出No。

样例

$a$	$b$	$c$	输出
$5$	$3$	$2$	`Yes`
$2$	$5$	$3$	`No`
$100$	$100$	$100$	`No`

分析

本来就是A题，其实没什么难的，~~比赛的时候就是看成平均数WA了..~~（上面应该讲的够清楚了）

当然可以直接将三个数排序（简单粗暴），也可以判断$a\le b\le c$和$c\le b\le a$中是否有至少一个成立。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 int a, b, c;
 scanf("%d%d%d", &a, &b, &c);
 puts((a <= b && b <= c) || (c <= b && b <= a)? "Yes": "No");
 return 0;
}

B - Distance Between Tokens

题目大意

在$H\times W$的网格上，有恰好两个位置上各有一颗棋子，别的都是空位。
你可以从任意一个棋子开始，通过上下左右移动，前往另一个棋子的位置。
求至少要移动多少次？

输入格式

先是一行$H,W$，用空格隔开，然后有$H$行，每行是一个长度为$W$的字符串，-表示这个位置是空位，o表示这里有一颗棋子（详见样例）。

输出格式

输出一行，即至少要移动的次数。

样例

样例输入1

1
2
3


2 3
--o
o--

样例输出1

1

3

样例输入2

1
2
3
4
5
6


5 4
-o--
----
----
----
-o--

样例输出2

1

4

分析

本题不需要$\text{BFS}$，由于没有障碍物，直接找到两颗棋子，并输出$x_\text{diff}+y_\text{diff}$（即$x,y$的坐标差之和）即可。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <cstdio>
#include <vector>
using namespace std;

int main()
{
 int h = 0, w = 0, x1 = -1, y1 = -1, x2 = -1, y2 = -1;
 char c;
 while((c = getchar()) != ' ')
 h = (h << 3) + (h << 1) + (c ^ 48);
 while((c = getchar()) != '\n')
 w = (w << 3) + (w << 1) + (c ^ 48);
 for(; h--; getchar())
 for(int i=w; i--; )
 if(getchar() == 'o')
 if(x1 == -1) x1 = h, y1 = i;
 else { x2 = h, y2 = i; break; }
 printf("%d\n", x1 - x2 + (y1 > y2? y1 - y2: y2 - y1));
 return 0;
}

C - Max - Min Query

题目大意

我们有一个序列$S$，初始为空。
请处理如下$Q$个操作：

1 x：将$x$插入至$S$的末尾。
2 x c：从$S$中删除$c$个$x$，如果不够删就直接删完。
3：求$S$中最大值与最小值的差。

$1\le Q\le 2\times 10^5$
$0\le x\le 10^9$
$1\le c\le Q$

输入格式

$Q$
$\text{query}_1$
$\text{query}_2$
$\vdots$
$\text{query}_Q$

输出格式

对于每个操作$3$，输出$S$中最大值与最小值的差。

分析

~~典型STL练习题~~

本题可以用multiset或map解决，这里介绍使用map的方法（仅限C++使用）。
C++中，我们需要用到std::map<int, int>的如下方法：

mp[x]或int& operator[](int&& key)
返回key对应的value的引用，如果之前没有用到过则创建并返回$0$。
时间复杂度：$\mathcal O(\log n)$，其中$n$为map中元素总数。
iterator begin()
返回最小的元素对应的指针，mp.begin()->first可以获得mp的最小元素
时间复杂度：$\mathcal O(1)$
iterator rbegin()
返回最大的元素对应的指针，mp.rbegin()->first可以获得mp的最大元素
时间复杂度：$\mathcal O(1)$
size_type erase(const int& key)
将key以及对应的value从map中删除，返回删除的元素个数（$0$或$1$），返回值一般可以忽略。
时间复杂度：$\mathcal O(\log n)$，其中$n$为map中元素总数。

这时，每个查询都可转换为上述操作，详见代码。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


#include <cstdio>
#include <map>
using namespace std;

int main()
{
 int q;
 scanf("%d", &q);
 map<int, int> cnt;
 while(q--)
 {
 int op;
 scanf("%d", &op);
 if(op == 3) printf("%d\n", cnt.rbegin()->first - cnt.begin()->first);
 else if(op == 1)
 {
 int x;
 scanf("%d", &x);
 cnt[x] ++;
 }
 else if(op == 2)
 {
 int x, m;
 scanf("%d%d", &x, &m);
 if(cnt[x] > m) cnt[x] -= m;
 else cnt.erase(x);
 }
 }
 return 0;
}

D - FizzBuzz Sum Hard

题目大意

输出$1$到$N$之间不是$A$或$B$的倍数的数之和。

$1\le N,A,B\le 10^9$

输入格式

$N~A~B$

输出格式

输出答案。

分析

根据容斥原理，$1$到$N$之间是$A$或$B$的倍数的数之和为：
$(A$的倍数之和$)+(B$的倍数之和$)-($同时为$A,B$的倍数之和$)$。
又因为同时为$A,B$的倍数的数是$[A,B]$（最小公倍数）的倍数，所以可转化为$(A$的倍数之和$)-(B$的倍数之和$)+([A,B]$的倍数之和$)$。

再设$f(N)=1+2+\dots+N,g(x,N)=xf(\lfloor\frac N X\rfloor)=(N$以内所有$x$的倍数之和$)$，
则答案为

$$\text{Ans}=f(N)-g(A)-g(B)+g([A,B])$$

总时间复杂度为求解$[A,B]$的复杂度，即$\mathcal O(\log \max\{A,B\})$。

代码

这里使用了另一种$g(x,N)$的求法，思路类似。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <cstdio>
using namespace std;

using LL = long long;
inline LL sum(const LL& x, const LL& n)
{
 LL cnt = n / x;
 return x * cnt * (cnt + 1LL) >> 1LL;
}

int main()
{
 int n, a, b;
 scanf("%d%d%d", &n, &a, &b);
 LL x = b, y = a;
 while(b ^= a ^= b ^= a %= b);
 LL t = x / a * y; // t = lcm(a, b)
 printf("%lld\n", sum(1, n) - sum(x, n) - sum(y, n) + sum(t, n));
 return 0;
}

E - Distance Sequence

题目大意

求符合如下条件的$A=(A_1,\dots,A_N)$的个数，对$998244353$取模：

$1\le A_i\le M$（$1\le i\le N$）
$|A_i-A_{i+1}|\ge K$（$1\le i < N$）

$2\le N\le 1000$
$1\le M\le 5000$
$0\le K < M$

输入格式

$N~M~K$

输出格式

输出符合条件的序列的个数，对$998244353$取模。

分析

很明显是$\text{DP}$（动态规划）的思路，仿照01背包的方式，我们设计如下状态：

$$\text{dp}(i,j)=(A_i=j\text{的可能数})$$

状态转移方程也很简单，即：

$$\text{dp}(i,j)=\sum_{p=1}^{j-k}\text{dp}(i-1,p)+\sum_{p=j+k}^m\text{dp}(i-1,p)$$

那么，如果直接暴力循环计算，整个算法的时间复杂度是$\mathcal O(NM^2)$，显然不能通过。

但是注意到这里有个求和的操作，显然可以用前缀/后缀和优化，用$\mathcal O(1)$的时间复杂度求出两个和，因此时间复杂度降到$\mathcal O(NM)$，可以通过。

最后一个坑，需要注意特判$K=0$的情况，答案为$M^N\bmod 998244353$。
本题到此结束。

代码

特判使用快速幂，$\text{DP}$建议使用滚动表（又称数组重复利用）技巧，优化后实测：

时间：$49\mathrm{ms}\to39\mathrm{ms}$
空间：$21220\mathrm{kb}\to1664\mathrm{kb}$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


#include <cstdio>
#define maxn 1002
#define maxm 5005
#define MOD 998244353
using namespace std;

using LL = long long;
int qpow(LL a, LL b)
{
 LL ans = 1LL;
 while(b > 0)
 {
 if(b & 1LL) ans = ans * a % MOD;
 a = a * a % MOD, b >>= 1LL;
 }
 return ans;
}

inline void mod(int& x) { if(x >= MOD) x -= MOD; }
int dp[2][maxm];

int main()
{
 int n, m, k;
 scanf("%d%d%d", &n, &m, &k);
 if(k == 0)
 {
 printf("%d\n", qpow(m, n));
 return 0;
 }
 for(int i=1; i<=m; i++)
 dp[0][i] = 1;
 for(int i=1; i<n; i++)
 {
 int c = i & 1, p = c ^ 1, s = 0;
 for(int j=k+1; j<=m; j++)
 mod(s += dp[p][j]);
 for(int j=1; j<=m; j++)
 {
 if(j > k) mod(s += dp[p][j - k]);
 mod(dp[c][j] = s);
 if(j + k <= m)
 {
 mod(s -= dp[p][j + k]);
 if(s < 0) s += MOD;
 }
 }
 }
 int ans = 0, t = n & 1 ^ 1;
 for(int i=1; i<=m; i++)
 mod(ans += dp[t][i]);
 printf("%d\n", ans);
 return 0;
}

AtCoder Beginner Contest 252 A~G 题解

Sun, 22 May 2022 11:31:00 +0800

前言

这是我第一次写7题（A~G）的ABC题解，若有写得不好或者不到位的地方请多多指教，我将万分感激，感谢大家的支持！

A - ASCII code

题目大意

给定正整数$N$，输出ASCII码是$N$的字母。
$97\le N\le 122$

输入格式

$N$

输出格式

输出ASCII码是$N$的字母。

分析

注意a对应$97$，b对应$98$，……，z对应$122$。
安上小白专属转换教程：

C
1 2

int n = 97; putchar(n); /* 输出：a */
putchar函数自动转换为字符，也可以使用printf("%c", n)效果相同

C++

1
2


int n = 97;
cout << char(n) << endl; // 输出：a

直接cout << n会输出97，需要用char转换为字符

Python
1 2

n = 97 print(chr(n)) # 输出：a
同样也不能直接输出，需要用chr转换

Java

1
2
3


int n = 97;
char c = (char) n;
System.out.print(c);

与C++、Python类似，需要转换

JavaScript

1
2
3


var n = 97;
var c = String.fromCharCode(n);
console.log(c); // 输出：a

同样使用接口转化，需调用String.fromCharCode

再不懂你试试……

代码

太水，直接走一发py（现场25秒AC）

1

print(chr(int(input())))

B - Takahashi’s Failure

题目大意

Takahashi的房子里有$N$个食物。第$i$个食物的美味度是$A_i$。
其中，他不喜欢$K$个食物：$B_1,B_2,\dots,B_K$。
已知Takahashi会从$N$个食物中随机选取一个美味度最大的食物，并把它吃掉。
Takahashi是否有可能迟到不喜欢的食物？

$1\le K\le N\le 100$
$1\le A_i\le 100$
$1\le B_i\le N$

输入格式

$N~K$
$A_1~\dots~A_N$
$B_1~\dots~B_K$

输出格式

如果有可能，输出Yes；否则，输出No。

分析

只要有不喜欢的食物美味度最高就有可能，否则不可能。详见代码。

代码

还是水，注意如果是$\text{0-indexed}$的话$B_i$要减$1$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


#include <cstdio>
using namespace std;

int a[105];

int main()
{
 int n, k, mx = 0;
 scanf("%d%d", &n, &k);
 for(int i=0; i<n; i++)
 {
 scanf("%d", a + i);
 if(a[i] > mx) mx = a[i];
 }
 while(k--)
 {
 scanf("%d", &n);
 if(a[--n] == mx)
 {
 puts("Yes");
 return 0;
 }
 }
 puts("No");
 return 0;
}

C - Slot Strategy

题目大意

略，请自行前往AtCoder查看。

$2\le N\le 100$

输入格式

$N$
$S_1$
$\vdots$
$S_N$

输出格式

输出答案。

分析

令$\text{cnt}[i][j]=(S_k[j]=i$的个数$)$，对最终变成$0$-$9$分别计算代价即可。详见代码。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


#include <cstdio>
using namespace std;

int cnt[10][10]; // cnt[i][j] = number of (s[j]=i)

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=0; i<n; i++)
 {
 char s[15];
 scanf("%s", s);
 for(int j=0; j<10; j++)
 cnt[s[j] ^ 48][j] ++;
 }
 int ans = 1000;
 for(int i=0; i<10; i++)
 {
 int cur = 0;
 for(int j=0; j<10; j++)
 {
 int c = j + (cnt[i][j] - 1) * 10;
 if(c > cur) cur = c;
 }
 if(cur < ans) ans = cur;
 }
 printf("%d\n", ans);
 return 0;
}

D - Distinct Trio

题目大意

给定长为$N$的整数序列$A=(A_1,\dots,A_N)$。
求符合以下条件的整数对$(i,j,k)$的个数：

$1\le i < j < k\le N$
$A_i\ne A_j\ne A_k$

$3\le N\le 2\times 10^5$
$1\le A_i\le 2\times 10^5$

输入格式

$N$
$A_1~\dots~A_N$

输出格式

输出一行，即符合条件的整数对$(i,j,k)$的个数。

分析

本题主要有两种思路：

逆向思维，用总数-不符合条件的；
将题目转化为求$A_i < A_j < A_k$的$(i,j,k)$的个数。

这里介绍第一种方法（第二种方法较为简单，不详细说明）。

首先易得，总共的$1\le i < j < k\le N$有$C_n^3$种取法。
然后考虑$A_i,A_j,A_k$中有重复的个数：

对于$A$中每个数$x$，我们记录$\text{cnt}_x=A$中$x$出现的次数；
然后，如果$\text{cnt}_x\ge 2$，则将答案减去$C_{\text{cnt}_x}^2\times(N-\text{cnt}_x)$，即$x,x,y$格式出现的次数；
又如果$\text{cnt}_x\ge 3$，将答案减去$C_{\text{cnt}_x}^3$，即$x,x,x$的次数。

总时间复杂度为$\mathcal O(N+\max_A-\min_A)$，空间复杂度为$\mathcal O(\max_A-\min_A)$。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


#include <cstdio>
#define maxn 200005
using namespace std;

using LL = long long;
int cnt[maxn];

inline LL C2(int n) { return n * (n - 1LL) >> 1LL; }
inline LL C3(int n) { return C2(n) * (n - 2LL) / 3LL; }

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=0; i<n; i++)
 {
 int a;
 scanf("%d", &a);
 cnt[a] ++;
 }
 LL ans = C3(n);
 for(int i=1; i<maxn; i++)
 if(cnt[i] > 1)
 {
 ans -= C2(cnt[i]) * (n - cnt[i]);
 if(cnt[i] > 2) ans -= C3(cnt[i]);
 }
 printf("%lld\n", ans);
 return 0;
}

E - Road Reduction

题目大意

给定一张由$N$个点和$M$条边组成的简单无向图。
第$i$条边长度为$C_i$，同时连接点$A_i$和$B_i$。
求任意一颗生成树，使得从点$1$到其他所有点的距离之和最小。

$2\le N\le 2\times 10^5$
$N-1\le M\le 2\times 10^5$
$1\le A_i < B_i\le N$
$(A_i,B_i)\ne(A_j,B_j)$（$i\ne j$）
$1\le C_i\le 10^9$

输入格式

$N~M$
$A_1~B_1~C_1$
$\vdots$
$A_M~B_M~C_M$

输出格式

按任意顺序输出留下来的$N-1$条边的下标，用空格隔开。

分析

显然，在生成树中，点$1$到任意点的距离肯定不少于在原图中到这个点的距离。
因此，如果两个距离相等，显然就是最优解。
此时可以证明，肯定有这样的解。使用Dijkstra算法求最短路径的同时，记录到每个点之前的最后一条路即可。

代码

Dijkstra的两种经典实现方式，$\mathcal O(N\log N+M\log N)$

priority_queue优先队列（$182\text{ms}$）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


#include <cstdio>
#include <queue>
#define maxn 200005
#define INF 9223372036854775807LL
using namespace std;

using LL = long long;
using pli = pair<LL, int>;

struct Edge
{
 int v, id; LL d;
 inline Edge(int u, int l, int i): v(u), d(l), id(i) {}
};

vector<Edge> G[maxn];
LL dis[maxn];
int ans[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 for(int i=1; i<=m; i++)
 {
 int a, b, c;
 scanf("%d%d%d", &a, &b, &c);
 G[--a].emplace_back(--b, c, i);
 G[b].emplace_back(a, c, i);
 }
 priority_queue<pli, vector<pli>, greater<pli>> q;
 for(int i=1; i<n; i++) dis[i] = INF;
 q.emplace(0LL, 0);
 while(!q.empty())
 {
 auto [d, v] = q.top(); q.pop();
 if(dis[v] == d)
 for(const Edge& e: G[v])
 {
 LL nd = d + e.d;
 if(nd < dis[e.v])
 q.emplace(dis[e.v] = nd, e.v),
 ans[e.v] = e.id;
 }
 }
 for(int i=1; i<n; i++) printf("%d ", ans[i]);
 return 0;
}

set集合（$202\text{ms}$）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


#include <cstdio>
#include <vector>
#include <set>
#define maxn 200005
#define INF 9223372036854775807LL
using namespace std;

using LL = long long;
using pli = pair<LL, int>;

struct Edge
{
 int v, id; LL d;
 inline Edge(int u, int l, int i): v(u), d(l), id(i) {}
};

vector<Edge> G[maxn];
LL dis[maxn];
int ans[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 for(int i=1; i<=m; i++)
 {
 int a, b, c;
 scanf("%d%d%d", &a, &b, &c);
 G[--a].emplace_back(--b, c, i);
 G[b].emplace_back(a, c, i);
 }
 set<pli> s; // <distance, vertex>
 for(int i=1; i<n; i++) dis[i] = INF;
 s.emplace(0LL, 0);
 while(!s.empty())
 {
 auto [d, v] = *s.begin(); s.erase(s.begin());
 for(const Edge& e: G[v])
 {
 LL nd = d + e.d;
 if(nd < dis[e.v])
 {
 if(dis[e.v] < INF)
 s.erase(pli(dis[e.v], e.v));
 s.emplace(dis[e.v] = nd, e.v);
 ans[e.v] = e.id;
 }
 }
 }
 for(int i=1; i<n; i++) printf("%d ", ans[i]);
 return 0;
}

注意使用long long。

F - Bread

题目大意

本题翻译已经过简化，部分表示与原题不同，仅供参考，请以原题为准。

有一个的整数序列$S$，初始只有一个元素$L$，我们可以执行如下操作无限次：

从$S$中删去任意元素$k$（$k > 1$），同时选取整数$x$（$1\le x\le k-1$），将$x$和$k-x$放入$S$。此操作的代价为$k$。

求最小的代价，使得$A$在$S$中，即$A$中每个元素的出现次数$~\le S$中对应元素的出现次数。

$2\le N\le 2\times 10^5$
$1\le N\le 10^9$
$A_1+A_2+\dots+A_N\le L\le 10^{15}$

输入格式

$N~L$
$A_1~\dots~A_N$

输出格式

输出最小的代价。

分析

本题考虑逆向思维，仔细思考后发现题目可以如下转化：

令$S=(A_1,\dots,A_N,L-\sum A)$（$L=\sum A$时不千万不要加上最后一个元素）
每次操作将$A$中任意两个元素合并，它们的和即为合并后新的元素，也是本次操作的代价
最后发现全部合并完后$S$中正好剩下一个$L$，此时操作结束，所有代价和即为方案的最终代价。

此时，显然每次合并最小的两个数即为最优方案，因此可以使用优先队列实现，总时间复杂度为$\mathcal O(N\log N)$。

代码

注意使用long long。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


#include <cstdio>
#include <queue>
using namespace std;

using LL = long long;

int main()
{
 int n;
 LL l;
 scanf("%d%lld", &n, &l);
 priority_queue<LL, vector<LL>, greater<LL>> q;
 for(int i=0; i<n; i++)
 {
 int x;
 scanf("%d", &x);
 q.push(x);
 l -= x;
 }
 if(l > 0) q.push(l);
 LL ans = 0LL;
 while(q.size() > 1)
 {
 LL x = q.top(); q.pop();
 x += q.top(); q.pop();
 ans += x;
 q.push(x);
 }
 printf("%lld\n", ans);
 return 0;
}

G - Pre-Order

题目大意

有一颗由$N$个节点$1,2,\dots,N$组成的树，它的根节点为$1$。
它的先序遍历序列是$(P_1,P_2,\dots,P_N)$。
每次搜索时，我们都会优先前往编号小的节点。
有多少种不同的树，使其符合上述条件？对$998244353$取模。

$2\le N\le 500$
$1\le P_i\le N$
$P_1=1$
$P_1\ne P_2\ne\dots\ne P_N$

输入格式

$N$
$P_1~\dots~P_N$

输出格式

输出答案，对$998244353$取模。

分析

我们先将$P$变为$\text{0-indexed}$，即原来的$(P_1,P_2,\dots,P_N)$分别对应$(A_0,A_1,\dots,A_{N-1})$。
此时，不妨考虑区间$\text{dp}$的思想，设$\mathrm{dp}(l,r)=~($一棵树已经去掉根节点的先序遍历为$A_l,A_{l+1},\dots,A_{r-1}$的可能数$)$，则$\mathrm{dp}(1,N)$即为所求。

下面考虑$\mathrm{dp}(l,r)$的动态转移方程。

先考虑$A_l$为$A_{l+1},\dots,A_{r-1}$的祖宗的情况，如图：

易得，此时$\mathrm{dp}(l,r)$初始化为$\mathrm{dp}(l+1,r)$。

再考虑区分左右子树，对于每个$k$（$l < k < r$），将$A_l,\dots,A_{k-1}$当作左子树（可能数为$\mathrm{dp}(l+1,k)$），再将$A_k,\dots,A_{r-1}$当作右子树（可能数为$\mathrm{dp}(k,r)$），此时如果$A_l < A_k$则符合题意，将$\mathrm{dp}(l,r)$加上$\mathrm{dp}(l+1,k)\times \mathrm{dp}(k,r)$即可。

至此，本题已结束，时间复杂度为$\mathcal O(N^3)$。

代码

注意事项：

乘法操作需要转为long long再取模。
答案为$\mathrm{dp}(1,N)$，不是$\mathrm{dp}(0,N)$。
注意区间$\text{dp}$计算顺序，参考代码提供两种写法（先枚举$l$和先枚举长度）。

写法一（先枚举$l$，$59\text{ms}$）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <cstdio>
#define MOD 998244353
#define maxn 505
using namespace std;

using LL = long long;
int p[maxn], dp[maxn][maxn];

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=0; i<n; i++)
 scanf("%d", p + i);
 for(int l=n; l>0; l--)
 {
 dp[l][l] = 1;
 for(int r=l+1; r<=n; r++)
 {
 dp[l][r] = dp[l + 1][r];
 for(int k=l+1; k<r; k++)
 if(p[l] < p[k] && (dp[l][r] += LL(dp[l + 1][k]) * dp[k][r] % MOD) >= MOD)
 dp[l][r] -= MOD;
 }
 }
 printf("%d\n", dp[1][n]);
 return 0;
}

写法二（先枚举长度，$66\text{ms}$）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


#include <cstdio>
#define MOD 998244353
#define maxn 505
using namespace std;

using LL = long long;
int p[maxn], dp[maxn][maxn];

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=0; i<n; i++)
 scanf("%d", p + i);
 for(int i=1; i<=n; i++)
 dp[i][i] = 1;
 for(int d=1; d<=n; d++)
 for(int l=1, r=d+1; r<=n; l++, r++)
 {
 dp[l][r] = dp[l + 1][r];
 for(int k=l+1; k<r; k++)
 if(p[l] < p[k] && (dp[l][r] += LL(dp[l + 1][k]) * dp[k][r] % MOD) >= MOD)
 dp[l][r] -= MOD;
 }
 printf("%d\n", dp[1][n]);
 return 0;
}

AtCoder Beginner Contest 250 C~E 题解

Wed, 11 May 2022 07:45:00 +0800

C - Adjacent Swaps

题目大意

$N$个球从左到右排成一列。开始时，从左往右的第$i$个球上写着数字$i$。
请执行$Q$个操作，第$i$个操作如下：

令$j=~N$个球中写着数字$x_i$的球的位置
如果$j=N$，将其与第$j-1$个球交换；否则，与第$j+1$个球交换。

求所有操作后的球上分别写的数字。详见输出格式。

$2\le N\le 2\times 10^5$
$1\le Q\le 2\times 10^5$
$1\le x_i\le N$

输入格式

$N~Q$
$x_1$
$\vdots$
$x_Q$

输出格式

令$a_i=N$个球中从左往右的第$i$个在所有操作结束后写的数，则按如下格式输出：
$a_1~a_2~\dots~a_n$
即将$a_1,\dots,a_n$按顺序输出到一行，用空格隔开。

样例

略，请自行前往AtCoder查看。

分析

根据数据范围可得，本题只能使用时间复杂度不超过$\mathcal O(N+Q\log n)$的算法。
因此，暴力模拟，即查找每个球对应的位置$j$（$\mathcal O(NQ)$）肯定是行不通的。

但是很容易想到可以设置索引数组$p$，使当$a_i=x$时，$p_x=i$。
这样，对于每一个操作，只需$\mathcal O(1)$的时间复杂度就能找到$x_i$出现的位置。
交换时注意同时交换一下$a$和$p$中的元素即可。总时间复杂度$\mathcal O(N+Q)$。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


#include <cstdio>
#define maxn 200005
using namespace std;

inline void swap(int& x, int& y) { x ^= y ^= x ^= y; }

int pos[maxn], ans[maxn];

int main()
{
 int n, q;
 scanf("%d%d", &n, &q);
 for(int i=1; i<=n; i++)
 ans[i] = pos[i] = i;
 while(q--)
 {
 int x;
 scanf("%d", &x);
 int p1 = pos[x];
 int p2 = p1 == n? p1 - 1: p1 + 1;
 swap(pos[x], pos[ans[p2]]);
 swap(ans[p1], ans[p2]);
 }
 for(int i=1; i<=n; i++)
 printf("%d ", ans[i]);
 return 0;
}

D - 250-like Number

题目大意

当一个正整数$k$满足以下条件时，我们称其为“与$250$相似的”：

$k=p\times q^3$，其中$p,q$均为质数，且$p < q$。

求不超过$N$的“与$250$相似的”$k$的个数。

$1\le N\le 10^{18}$

输入格式

$N$

输出格式

将答案输出为一个整数。

样例

$N$	输出
$250$	$2$
$1$	$0$
$123456789012345$	$226863$

分析

看到数据范围后我们发现$N$太大，不能盲目下手。
由$k=p\times q^3,k\le N$可知，$p\times q^3\le N\le 10^{18}$。
又因为$p,q$是质数，且$p < q$可得，$2\le p < q$。
因此，当$p$最小时$q$最大，所以$q\le \sqrt[3]{\frac {N=10^{18}} {p=2}}\approx794000$。

这时，可以想到筛出质数表，并对于每个质数$p$计算最大的$q$，此时质数$p < x\le q$都能作为$q$，因此将答案加上$p < x\le q$的质数数量即可。当$p\ge q$时，退出循环，输出结果即可。

计算$q$时可以使用二分查找或者双指针算法快速处理。
总时间复杂度大约在$\mathcal O(n^{\frac 7 {22}})$。

代码

本代码使用双指针实现。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <cstdio>
#include <cmath>
#include <vector>
#define maxp 794000
using namespace std;

using LL = long long;

bool bad[maxp];
vector<int> primes;

inline LL pow3(LL x) { return x * x * x; }

int main()
{
 bad[0] = bad[1] = true;
 for(int i=2; i<maxp; i++)
 if(!bad[i])
 {
 primes.push_back(i);
 for(int j=i<<1; j<maxp; j+=i)
 bad[j] = true;
 }
 LL n;
 scanf("%lld", &n);
 LL ans = 0LL;
 for(int i=0, j=primes.size()-1; i<j; i++)
 {
 while(j >= 0 && primes[i] * pow3(primes[j]) > n) j --;
 if(i >= j) break;
 ans += j - i;
 }
 printf("%lld\n", ans);
 return 0;
}

E - Prefix Equality

题目大意

给定长度为$N$的正整数序列$A=(A_1,\dots,A_N)$和$B=(B_1,\dots,B_N)$。
对于每个$1\le i\le Q$，给定两个正整数$x_i,y_i$，回答如下格式的查询：

判断集合$\{A_1,\dots,A_{x_i}\}$和$\{B_1,\dots,B_{y_i}\}$是否相等。

集合可以说成是序列排序并去重的结果，如序列$(9,3,5,3,4)$对应的集合是$\{3,4,5,9\}$。

$1\le N,Q\le 2\times 10^5$
$1\le A_i\le B_i\le 10^9$
$1\le x_i,y_i\le N$

输入格式

$N$
$A_1~\dots~A_N$
$B_1~\dots~B_N$
$Q$
$x_1~y_1$
$\vdots$
$x_Q~y_Q$

样例

样例输入

样例输出

1
2
3
4
5
6
7


Yes
Yes
Yes
No
No
Yes
No

分析

本题做法很多。这里我们介绍使用哈希(Hash)的算法。
现在我们有一个很简单但明显错误的思路：
将$A$和$B$做一个前缀和，只计算不重复的元素，即

$$ P_A(i)=\sum\{A_1,\dots,A_i\}\\ P_B(i)=\sum\{B_1,\dots,B_i\} $$

此时，只需判断$P_A(x_i)$和$P_B(y_i)$是否相等即可。时间复杂度为$\mathcal O(N+Q)$或$\mathcal O(Q+N\log N)$。
构造hack数据也很简单，只需部分前缀和相等即可，如：

这样，因为$1+3+5=3+2+4=9$，所以这样的程序会认为这是相等的序列，从而输出Yes，但显然$\{1,3,5\}\ne\{3,2,4\}$，因此答案为No，程序错误。

现在考虑改进这个思路，使其不容易被hack，可以使用一个哈希函数：

$$ H(x)=x(x+A)(x+B)\bmod P $$

其中$A,B,P$一般取质数，$H(x)$即为$x$对应的哈希值。（对$P$取模是为了防止哈希值太大导致溢出）
显然，这样有一个很小的概率会产生哈希冲突（即不同的数得到相同的哈希值），但因为$A,B,P$的取值太多，评测机没法针对性的hack，所以正常情况下都能通过（CF的Hack机制除外）。如果真担心有问题，可以采取双哈希，即对于一个$x$，用两个不同的哈希函数计算哈希值，这样就几乎不可能出现哈希冲突了。

现在，前缀和变为：

$$ P_A(i)=\sum\{H(A_1),\dots,H(A_i)\}\bmod P\\ P_B(i)=\sum\{H(B_1),\dots,H(B_i)\}\bmod P $$

还是按原来的思路，判断前缀和是否相等即可。
总时间复杂度为$\mathcal O(n)$（unordered_set/HashSet）或$\mathcal O(n\log n)$（set/TreeSet）。

代码

这里还是要提一点，就是使用哈希时有一个小技巧，即直接取$P=2^{32}-1$（unsigned int）或者$P=2^{64}-1$（unsigned long long），使整数自然溢出，省去了麻烦又耗时间的取模步骤。CodeForces上还是建议取较大的质数（常用的有$10^9+7,998244353$）作为$P$，以免被hack导致丢分。

这里我用的哈希函数为$H(x)=x(x+93)(x+117)\bmod(2^{32}-1)$，即$A=93,B=117,P=2^{32}-1$。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


#include <cstdio>
#include <unordered_set>
#define maxn 200005
using namespace std;

inline int read()
{
 char c;
 while((c = getchar()) < '0' || c > '9');
 int res = c ^ 48;
 while((c = getchar()) >= '0' && c <= '9')
 res = (res << 3) + (res << 1) + (c ^ 48);
 return res;
}

unsigned suma[maxn], sumb[maxn];
inline void hread(unsigned* psum, int n)
{
 unordered_set<int> s;
 for(int i=1, x; i<=n; i++)
 {
 psum[i] = psum[i - 1];
 if(s.insert(x = read()).second)
 psum[i] += x * unsigned(x + 93) * unsigned(x + 117);
 }
}

int main()
{
 int n = read();
 hread(suma, n);
 hread(sumb, n);
 for(int q=read(); q--;)
 puts(suma[read()] == sumb[read()]? "Yes": "No");
 return 0;
}

UNIQUE VISION Programming Contest 2022（AtCoder Beginner Contest 248）C~D 题解

Sun, 17 Apr 2022 15:45:00 +0800

C - Dice Sum

题目大意

有多少个整数序列$A=(A_1,\dots,A_N)$符合如下条件：

$1\le A_i\le M$
$\sum\limits_{i=1}^NA_i\le K$

输出答案，对$998244353$取模。

$1\le N,M\le 50$
$N\le K\le NM$

输入格式

$N~M~K$

输出格式

输出答案，对$998244353$取模。

分析

~~艹C题又要dp~~
考虑$\text{DP}$思想，令$\text{dp}(i,j):=A$的前$i$个元素中和为$j$的总可能数（$1\le A_x\le M$），则可得伪代码：

1
2
3
4
5
6


dp[0][0] = 1
for i = 0 to N-1 // 逐个位置考虑
 for j = 0 to K-1 // 考虑所有和的情况，无需考虑K
 for k = 1 to M // 1-M的每个选择
 if j + k <= K: // 限制条件
 dp[i + 1][j + k] += dp[i][j] // 更新dp[i+1]

时间复杂度为$\mathcal O(NMK)$，可以通过。

其实还可以利用前缀和优化。
不难发现$\mathrm{dp}(i,j)=\displaystyle\sum_{k=L}^R\text{dp}(i-1,k)$，
其中$L\le R$，具体的值请自行推导。
因此，我们可以记录$\mathrm{dp}[i-1]$的前缀和$\mathrm{pre}$：

$\mathrm{pre}_j=\displaystyle\sum_{k=1}^j\mathrm{dp}(i-1,k)$

则$\mathrm{dp}(i,j)=\mathrm{pre}_R-\mathrm{pre}_{L-1}$。
因此，时间复杂度为$\mathcal O(NK)$。
强烈建议读者独立推导并实现该方法。 前缀和优化$\text{DP}$的算法在E、F题中很常见。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <cstdio>
#define MOD 998244353
#define maxn 200005
using namespace std;

inline void mod(int& x) { if(x >= MOD) x -= MOD; }
int dp[2][maxn];

int main()
{
 int n, m, k;
 scanf("%d%d%d", &n, &m, &k);
 dp[0][0] = 1;
 for(int i=0; i<n; i++)
 {
 int c = i & 1, p = c ^ 1;
 for(int j=0; j<=k; j++)
 dp[p][j] = 0;
 for(int j=0; j<k; j++)
 for(int d=1; d<=m && d<=k-j; d++)
 mod(dp[p][j + d] += dp[c][j]);
 }
 int ans = 0;
 for(int i=1; i<=k; i++)
 mod(ans += dp[n & 1][i]);
 printf("%d\n", ans);
 return 0;
}

D - Range Count Query

题目大意

给定整数序列$A=(A_1,\dots,A_N)$。
有$Q$个查询。每个查询的格式如下：

给定三个整数$L,R,X$，求$A_L,\dots,A_R$中$X$的出现次数。

$1\le A_i,X\le N\le 2\times10^5$
$1\le L\le R\le N$

输入格式

$N$
$A_1~\dots~A_N$
$Q$
$L_1~R_1~X_1$
$\vdots$
$L_Q~R_Q~X_Q$

输出格式

输出$Q$行，第$i$行是第$i$个查询的答案。

分析

题目换句话说就是：求$X$出现的位置中，在$[L,R]$区间内的有多少个？
因此，我们很容易想到先预处理$1,\dots,N$中每个数出现的位置，存入vector，查询时二分即可。

代码

注意二分边界。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


#include <cstdio>
#include <vector>
#include <algorithm>
#define maxn 200005
using namespace std;

vector<int> pos[maxn];

int main()
{
 int n, q;
 scanf("%d", &n);
 for(int i=0; i<n; i++)
 {
 int a; scanf("%d", &a);
 pos[a].push_back(i);
 }
 scanf("%d", &q);
 while(q--)
 {
 int l, r, x;
 scanf("%d%d%d", &l, &r, &x);
 printf("%d\n", int(
 lower_bound(pos[x].begin(), pos[x].end(), r) -
 lower_bound(pos[x].begin(), pos[x].end(), --l)
 ));
 }
 return 0;
}

AtCoder题解集锦

Fri, 15 Apr 2022 22:27:00 +0800

注：本文原发表于 CSDN，现已停止更新。原文如下：

AtCoder题解集锦

自己从全网整理的一些优质 AtCoder 题解，目前只有 ABC（AtCoder Beginner Contest）的 C~F。不定期更新。

如您有更多需求，欢迎私信我或在评论区留言！
$\rarr$ 题解列表传送门

用法

表格查找
1. 找到对应比赛的行
2. 找到对应题目的列
3. 该位置即为对应的题解
题号查找
1. 在浏览器中按下搜索快捷键Ctrl+F，调出搜索窗口。
2. 输入对应的题号，如 244F
3. 找到对应题解
标题查找
1. 在浏览器中按下搜索快捷键Ctrl+F，调出搜索窗口。
2. 输入题目标题，如 Shortest Good Path
3. 找到对应题解

题解筛选规则：

优先选择中文题解
若没有较好的中文题解，选择AtCoder官方题解
若赛后几天暂时没有题解，选取优质的提交记录作为链接

题目列表

按比赛时间升序排列，从ABC195开始。

比赛	C	D	E	F
ABC195	195C - Comma	195D - Shipping Center	195E - Lucky 7 Battle	195F - Coprime Present
ABC196	196C - Doubled	196D - Hanjo	196E - Filters	196F - Substring 2
ABC197	197C - ORXOR	197D - Opposite	197E - Traveler	197F - Construct a Palindrome
ABC198	198C - Compass Walking	198D - Send More Money	198E - Unique Color	198F - Cube
ABC199	199C - IPFL	199D - RGB Coloring 2	199E - Permutation	199F - Graph Smoothing
ABC200	200C - Ringo’s Favorite Numbers 2	200D - Happy Birthday! 2	200E - Patisserie ABC 2	200F - Minflip Summation
ABC201	201C - Secret Number	201D - Game in Momotetsu World	201E - Xor Distances	201F - Insertion Sort
ABC202	202C - Made Up	202D - aab aba baa	202E - Count Descendants	202F - Integer Convex Hull
ABC203	203C - Friends and Travel costs	203D - Pond	203E - White Pawn	203F - Weed
ABC204	204C - Tour	204D - Cooking	204E - Rush Hour 2	204F - Hanjo 2
ABC205	205C - POW	205D - Kth Excluded	205E - White and Black Balls	205F - Grid and Tokens
ABC206	206C - Swappable	206D - KAIBUNsyo	206E - Divide Both	206F - Interval Game 2
ABC207	207C - Many Segments	207D - Congruence Points	207E - Mod i	207F - Tree Patrolling
ABC208	208C - Fair Candy Distribution	208D - Shortest Path Queries 2	208E - Digit Products	208F - Cumulative Sum
ABC209	209C - Not Equal	209D - Collision	209E - Shiritori	209F - Deforestation
ABC210	210C - Colorful Candies	210D - National Railway	210E - Ring MST	210F - Coprime Solitaire
ABC211	211C - chokudai	211D - Number of Shortest paths	211E - Red Polyomino	211F - Rectilinear Polygons
ABC212	212C - Min Difference	212D - Querying Multiset	212E - Safety Journey	212F - Greedy Takahashi
ABC213	213C - Reorder Cards	213D - Takahashi Tour	213E - Stronger Takahashi	213F - Common Prefixes
ABC214	214C - Distribution	214D - Sum of Maximum Weights	214E - Packing Under Range Regulations	214F - Substrings
ABC215	215C - One More aab aba baa	215D - Coprime 2	215E - Chain Contestant	215F - Dist Max 2
ABC216	216C - Many Balls	216D - Pair of Balls	216E - Amusement Park	216F - Max Sum Counting
ABC217	217C - Inverse of Permutation	217D - Cutting Woods	217E - Sorting Queries	217F - Make Pair
ABC218	218C - Shapes	218D - Rectangles	218E - Destruction	218F - Blocked Roads
ABC219	219C - Neo-lexicographic Ordering	219D - Strange Lunchbox	219E - Moat	219F - Cleaning Robot
ABC220	220C - Long Sequence	220D - FG operation	220E - Distance on Large Perfect Binary Tree	220F - Distance Sums 2
ABC221	221C - Select Mul	221D - Online games	221E - LEQ	221F - Diameter set
ABC222	222C - Swiss-System Tournament	222D - Between Two Arrays	222E - Red and Blue Tree	222F - Expensive Expense
ABC223	223C - Doukasen	223D - Restricted Permutation	223E - Placing Rectangles	223F - Parenthesis Checking
ABC224	224C - Triangle?	224D - 8 Puzzle on Graph	224E - Integers on Grid	224F - Problem where +s Separate Digits
ABC225	225C - Calendar Validator	225D - Play Train	225E - フ/7	225F - String Cards
ABC226	226C - Martial artist	226D - Teleportation	226E - Just one	226F - Score of Permutations
ABC227	227C - ABC conjecture	227D - Project Planning	227E - Swap	227F - Treasure Hunting
ABC228	228C - Final Day	228D - Linear Probing	228E - Integer Sequence Fair	228F - Stamp Game
ABC229	229C - Cheese	229D - Longest X	229E - Graph Destruction	229F - Make Bipartite
ABC230	230C - X drawing	230D - Destroyer Takahashi	230E - Fraction Floor Sum	230F - Predilection
ABC231	231C - Counting 2	231D - Neighbors	231E - Minimal payments	231F - Jealous Two
ABC232	232C - Graph Isomorphism	232D - Weak Takahashi	232E - Rook Path	232F - Simple Operations on Sequence
ABC233	233C - Product	233D - Count Interval	233E - Σ[k=0..10^100]floor(X／10^k)	233F - Swap and Sort
ABC234	234C - Happy New Year!	234D - Prefix K-th Max	234E - Arithmetic Number	234F - Reordering
ABC235	235C - The Kth Time Query	235D - Multiply and Rotate	235E - MST + 1	235F - Variety of Digits
ABC236	236C - Route Map	236D - Dance	236E - Average and Median	236F - Spices
ABC237	237C - kasaka	237D - LR insertion	237E - Skiing	237F - \|LIS\| = 3
ABC238	238C - digitnum	238D - AND and SUM	238E - Range Sums	238F - Two Exams
ABC239	239C - Knight Fork	239D - Prime Sum Game	239E - Subtree K-th Max	239F - Construct Highway
ABC240	240C - Jumping Takahashi	240D - Strange Balls	240E - Ranges on Tree	240F - Sum Sum Max
ABC241	241C - Connect 6	241D - Sequence Query	241E - Putting Candies	241F - Skate
ABC242	242C - 1111gal password	242D - ABC Transform	242E - (∀x∀)	242F - Black and White Rooks
ABC243	243C - Collision 2	243D - Moves on Binary Tree	243E - Edge Deletion	243F - Lottery
ABC244	244C - Yamanote Line Game	244D - Swap Hats	244E - King Bombee	244F - Shortest Good Path
ABC245	245C - Choose Elements	245D - Polynomial division	245E - Wrapping Chocolate	245F - Endless Walk
ABC246	246C - Coupon	246D - 2-variable Function	246E - Bishop 2	246F - typewriter
ABC247	247C - 1 2 1 3 1 2 1	247D - Cylinder	247E - Max Min	247F - Cards
ABC248	248C - Dice Sum	248D - Range Count Query	248E - K-colinear Line	248F - Keep Connect
ABC249	249C - Just K	249D - Index Trio	249E - RLE	249F - Ignore Operations
ABC250	250C - Adjacent Swaps	250D - 250-like Number	250E - Prefix Equality	250F - One Fourth
ABC251	251C - Poem Online Judge	251D - At Most 3 (Contestant ver.)	251E - Takahashi and Animals	251F - Two Spanning Trees
ABC252	252C - Slot Strategy	252D - Distinct Trio	252E - Road Reduction	252F - Bread
ABC253	253C - Max - Min Query	253D - FizzBuzz Sum Hard	253E - Distance Sequence	253F - Operations on a Matrix
ABC254	254C - K Swap	254D - Together Square	254E - Small d and k	254F - Rectangle GCD
ABC255	255C - ±1 Operation 1	255D - ±1 Operation 2	255E - Lucky Numbers	255F - Pre-order and In-order
ABC256	256C - Filling 3x3 array	256D - Union of Interval	256E - Takahashi’s Anguish	256F - Cumulative Cumulative Cumulative Sum
ABC257	257C - Robot Takahashi	257D - Jumping Takahashi 2	257E - Addition and Multiplication 2	257F - Teleporter Setting
ABC258	258C - Rotation	258D - Trophy	258E - Packing Potatoes	258F - Main Street
ABC259	259C - XX to XXX	259D - Circumferences	259E - LCM on Whiteboard	259F - Select Edges
ABC260	260C - Changing Jewels	260D - Draw Your Cards	260E - At Least One	260F - Find 4-cycle
ABC261	261C - NewFolder(1)	261D - Flipping and Bonus	261E - Many Operations	261F - Sorting Color Balls
ABC262	262C - Min Max Pair	262D - I Hate Non-integer Number	262E - Red and Blue Graph	262F - Erase and Rotate
ABC263	263C - Monotonically Increasing	263D - Left Right Operation	263E - Sugoroku 3	263F - Tournament
ABC264	264C - Matrix Reducing	264D - "redocta".swap(i,i+1)	264E - Blackout 2	264F - Monochromatic Path
ABC265	265C - Belt Conveyor	265D - Iroha and Haiku (New ABC Edition)	265E - Warp	265F - Manhattan Cafe
ABC266	266C - Convex Quadrilateral	266D - Snuke Panic (1D)	266E - Throwing the Die	266F - Well-defined Path Queries on a Namori
ABC267	267C - Index × A(Continuous ver.)	267D - Index × A(Not Continuous ver.)	267E - Erasing Vertices 2	267F - Exactly K Steps
ABC268	268C - Chinese Restaurant	268D - Unique Username	268E - Chinese Restaurant (Three-Star Version)	268F - Best Concatenation
ABC269	269C - Submask	269D - Do use hexagon grid	269E - Last Rook	269F - Numbered Checker
ABC270	270C - Simple path	270D - Stones	270E - Apple Baskets on Circle	270F - Transportation
ABC271	271C - Manga	271D - Flip and Adjust	271E - Subsequence Path	271F - XOR on Grid Path
ABC272	272C - Max Even	272D - Root M Leaper	272E - Add and Mex	272F - Two Strings
ABC273	273C - (K+1)-th Largest Number	273D - LRUD Instructions	273E - Notebook	273F - Hammer 2
ABC274	274C - Ameba	274D - Robot Arms 2	274E - Booster	274F - Fishing
ABC275	275C - Counting Squares	275D - Yet Another Recursive Function	275E - Sugoroku 4	275F - Erase Subarrays
ABC276	276C - Previous Permutation	276D - Divide by 2 or 3	276E - Round Trip	276F - Double Chance
ABC277	277C - Ladder Takahashi	277D - Takahashi's Solitaire	277E - Crystal Switches	277F - Sorting a Matrix
ABC278	278C - FF	278D - All Assign Point Add	278E - Grid Filling	278F - Shiritori
ABC279	279C - RANDOM	279D - Freefall	279E - Cheating Amidakuji	279F - BOX
ABC280	280C - Extra Character	280D - Factorial and Multiple	280E - Critical Hit	280F - Pay or Receive
ABC281	281C - Circular Playlist	281D - Max Multiple	281E - Least Elements	281F - Xor Minimization
ABC282	282C - String Delimiter	282D - Make Bipartite 2	282E - Choose Two and Eat One	282F - Union of Two Sets
ABC283	283C - Cash Register	283D - Scope	283E - Don't Isolate Elements	283F - Permutation Distance
ABC284	284C - Count Connected Components	284D - Happy New Year 2023	284E - Count Simple Paths	284F - ABCBAC
ABC285	285C - abc285_brutmhyhiizp	285D - Change Usernames	285E - Work or Rest	285F - Substring of Sorted String
ABC286	286C - Rotate and Palindrome	286D - Money in Hand	286E - Souvenir	286F - Guess The Number 2
ABC287	287C - Path Graph?	287D - Match or Not	287E - Karuta	287F - Components
ABC288	288C - Don’t be cycle	288D - Range Add Query	288E - Wish List	288F - Integer Division
ABC289	289C - Coverage	289D - Step Up Robot	289E - Swap Places	289F - Teleporter Takahashi
ABC290	290C - Max MEX	290D - Marking	290E - Make it Palindrome	290F - Maximum Diameter
ABC291	291C - LRUD Instructions 2	291D - Flip Cards	291E - Find Permutation	291F - Teleporter and Closed off
ABC292	292C - Four Variables	292D - Unicyclic Components	292E - Transitivity	292F - Regular Triangle Inside a Rectangle
ABC293	293C - Make Takahashi Happy	293D - Tying Rope	293E - Geometric Progression	293F - Zero or One
ABC294	294C - Merge Sequences	294D - Bank	294E - 2xN Grid	294F - Sugar Water 2
ABC295	295C - Socks	295D - Three Days Ago	295E - Kth Number	295F - substr = S
ABC296	296C - Gap Existence	296D - M<=ab	296E - Transition Game	296F - Simultaneous Swap
ABC297	297C - PC on the Table	297D - Count Subtractions	297E - Kth Takoyaki Set	297F - Minimum Bounding Box 2
ABC298	298C - Cards Query Problem	298D - Writing a Numeral	298E - Unfair Sugoroku	298F - Rook Score
ABC299	299C - Dango	299D - Find by Query	299E - Nearest Black Vertex	299F - Square Subsequence
ABC300	300C - Cross	300D - AABCC	300E - Dice Product 3	300F - More Holidays
ABC301	301C - AtCoder Cards	301D - Bitmask	301E - Pac-Takahashi	301F - Anti-DDoS
ABC302	302C - Almost Equal	302D - Impartial Gift	302E - Isolation	302F - Merge Set
ABC303	303C - Dash	303D - Shift vs. CapsLock	303E - A Gift From the Stars	303F - Damage over Time
ABC304	304C - Virus	304D - A Piece of Cake	304E - Good Graph	304F - Shift Table
ABC305	305C - Snuke the Cookie Picker	305D - Sleep Log	305E - Art Gallery on Graph	305F - Dungeon Explore
ABC306	306C - Centers	306D - Poisonous Full-Course	306E - Best Performances	306F - Merge Sets
ABC307	307C - Ideal Sheet	307D - Mismatched Parentheses	307E - Distinct Adjacent	307F - Virus 2
ABC308	308C - Standings	308D - Snuke Maze	308E - MEX	308F - Vouchers
ABC309	309C - Medicine	309D - Add One Edge	309E - Family and Insurance	309F - Box in Box
ABC310	310C - Reversible	310D - Peaceful Teams	310E - NAND repeatedly	310F - Make 10 Again
ABC311	311C - Find it!	311D - Grid Ice Floor	311E - Defect-free Squares	311F - Yet Another Grid Task
ABC312	312C - Invisible Hand	312D - Count Bracket Sequences	312E - Tangency of Cuboids	312F - Cans and Openers
ABC313	313C - Approximate Equalization 2	313D - Odd or Even	313E - Duplicate	313F - Flip Machines
ABC314	314C - Rotate Colored Subsequence	314D - LOWER	314E - Roulettes	314F - A Certain Game
ABC315	315C - Flavors	315D - Magical Cookies	315E - Prerequisites	315F - Shortcuts
ABC317	317C - Remembering the Days	317D - President	317E - Avoid Eye Contact	317F - Nim
ABC318	318C - Blue Spring	318D - General Weighted Max Matching	318E - Sandwiches	318F - Octopus
ABC319	319C - False Hope	319D - Minimum Width	319E - Bus Stops	319F - Fighter Takahashi
ABC320	320C - Slot Strategy 2 (Easy)	320D - Relative Position	320E - Somen Nagashi	320F - Fuel Round Trip
ABC321	321C - 321-like Searcher	321D - Set Menu	321E - Complete Binary Tree	321F - #(subset sum = K) with Add and Erase
ABC322	322C - Festival	322D - Polyomino	322E - Product Development	322F - Vacation Query
ABC323	323C - World Tour Finals	323D - Merge Slimes	323E - Playlist	323F - Push and Carry
ABC324	324C - Error Correction	324D - Square Permutation	324E - Joint Two Strings	324F - Beautiful Path
ABC325	325C - Sensors	325D - Printing Machine	325E - Our clients, please wait a moment	325F - Sensor Optimization Dilemma
ABC326	326C - Peak	326D - ABC Puzzle	326E - Revenge of "The Salary of AtCoder Inc."	326F - Robot Rotation
ABC327	327C - Number Place	327D - Good Tuple Problem	327E - Maximize Rating	327F - Apples
ABC328	328C - Consecutive	328D - Take ABC	328E - Modulo MST	328F - Good Set Query
ABC329	329C - Count xxx	329D - Election Quick Report	329E - Stamp	329F - Colored Ball
ABC330	330C - Minimize Abs 2	330D - Counting Ls	330E - Mex and Update	330F - Minimize Bounding Square
ABC331	331C - Sum of Numbers Greater Than Me	331D - Tile Pattern	331E - Set Meal	331F - Palindrome Query

更新日志

日期	更新内容
2022/06/16	增加更新日志；更新 ABC254-255 题解
..	..
2022/09/16	更新 ABC266-268 题解
2022/10/11	更新 ABC269-272 题解
2022/11/6	更新 ABC273-276 题解
2022/12/31	更新 ABC277-283 题解
2023/01/24	更新 ABC283-286 题解
2023/04/19	更新 ABC287-298 题解
2023/11/01	更新 ABC299-326 题解；优化格式
2023/12/02	更新 ABC327-331 题解

注：本人老是在比赛后忘（lan）记（de）更新，欢迎大家私信提醒我，谢谢！

ARC138 B - 01 Generation 题解

Thu, 14 Apr 2022 22:37:00 +0800

ARC138 B - 01 Generation

思路

考虑逆向思维，很容易想到可以优先从后面删掉0（操作B的逆向操作），然后如果前面是0则删掉它并将序列翻转（操作A的逆向操作），一直重复这两个步骤直到字符串为空。如果中途无法操作，输出No，否则输出Yes。

下面我们来证明这个方法的正确性：

首先，假设有一个序列$A$按照上述方法输出No，但正确答案为Yes；
则一定在某一步（可能是第一步）只能先倒推操作A，而不是操作B，设这一步执行前的序列为$S$；
此时，令$N=|S|$，则$S_1=S_N=0$；
如果先倒推操作A，得到$(S_2,S_3,\dots,S_{N-1},1)$
如果先倒推操作B，得到$(S_1,S_2,\dots,S_{N-1})$
对比两个序列，发现先倒推操作B不会影响后续倒推A的结果，因此，序列$S$不存在。
结论：做法正确。

代码

代码实现时，没有必要真正翻转序列，只需记录当前翻转的状态（$0$或$1$），记为$\text{flipped}$，则实际的$A_i=A_i'\oplus\text{flipped}$（其中$A_i'$为输入的$A$，$\oplus$表示异或/XOR操作）。

删除时可以使用deque或者数组$l,r$端点记录。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <cstdio>
#define maxn 200005
using namespace std;

bool a[maxn];

int main()
{
 int n = 0;
 char c;
 while((c = getchar()) != '\n')
 n = (n << 3) + (n << 1) + (c ^ 48);
 for(int i=0; i<n; i++, getchar())
 a[i] = getchar() ^ 48;
 bool flipped = false;
 for(int l=0, r=n-1; a[l]==flipped; flipped^=1, l++)
 while(!a[r] ^ flipped)
 if(l > --r)
 return puts("Yes"), 0;
 puts("No");
 return 0;
}

AtCoder Beginner Contest 245 A~E 题解

Mon, 28 Mar 2022 21:00:00 +0800

A - Good morning

题目大意

在同一天里，Takahashi在$A$时$B$分起床，Aoki在$C$时$D$分$1$秒起床，请问谁起床更早？

$0\le A,C < 24$
$0\le B,D < 60$

输入格式

$A~B~C~D$

输出格式

输出起得更早的人的名字（Takahashi或Aoki）。

样例

$A$	$B$	$C$	$D$	输出
$7$	$0$	$6$	$30$	`Aoki`
$7$	$30$	$7$	$30$	`Takahashi`
$0$	$0$	$23$	$59$	`Takahashi`

分析

思路很明显，直接判断$(A,B)\le(C,D)$是否成立即可。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 int a, b, c, d;
 scanf("%d%d%d%d", &a, &b, &c, &d);
 puts((a == c? b <= d: a < c)? "Takahashi": "Aoki");
 return 0;
}

B - Mex

题目大意

给定整数序列$A=(A_1,\dots,A_N)$。求最小的不在$A$中的自然数。

$1\le N\le 2000$
$0\le A_i\le 2000$

输入格式

$N$
$A_1~\dots~A_N$

输出格式

输出一行，即最小的不在$A$中的自然数。

样例

略，请自行前往AtCoder查看

分析

由于题面中有限制$0\le A_i\le 2000$，所以我们直接开一个数组记录$[0,2001]$中每个数是否出现过即可。
本题方法很多，这里介绍的是最快的算法，时间复杂度$\mathcal O(N)$。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <cstdio>
using namespace std;

bool used[2005];

int main()
{
 int n;
 scanf("%d", &n);
 while(n--)
 {
 int a;
 scanf("%d", &a);
 used[a] = true;
 }
 int i = -1;
 while(used[++i]);
 printf("%d\n", i);
 return 0;
}

C - Choose Elements

题目大意

给定两个长度为$N$的整数序列$A=(A_1,\dots,A_N)$和$B=(B_1,\dots,B_N)$。
问是否存在序列$X=(X_1,\dots,X_N)$，满足如下条件：

$X_i=A_i$或$X_i=B_i$
$|X_i-X_{i+1}|\le K$，其中$1\le i < N$

$1\le N\le 2\times 10^5$
$1\le K\le 10^9$
$1\le A_i,B_i\le 10^9$

输入格式

$N~K$
$A_1~\dots~A_N$
$B_1~\dots~B_N$

输出格式

如果存在符合全部条件的$X$，输出Yes；否则，输出No。

样例

略，请自行前往AtCoder查看

分析

~~好家伙，C题都要用dp……~~
本题普通的方法貌似不太好做，因此我们考虑$\text{DP}$。
令$f(i)=X_i$选择能否等于$A_i$，$g(i)=X_i$能否等于$B_i$。
然后状态转移方程就简单了，详见代码。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


#include <cstdio>
#define maxn 200005
using namespace std;

int a[maxn], b[maxn];
bool f[maxn], g[maxn];

int main()
{
 int n, k;
 scanf("%d%d", &n, &k);
 for(int i=0; i<n; i++)
 scanf("%d", a + i);
 for(int i=0; i<n; i++)
 scanf("%d", b + i);
 f[0] = g[0] = true;
#define set(x, y, z) x |= y - z <= k && z - y <= k
 for(int i=1; i<n; i++)
 {
 if(f[i - 1])
 set(f[i], a[i - 1], a[i]),
 set(g[i], a[i - 1], b[i]);
 if(g[i - 1])
 set(f[i], b[i - 1], a[i]),
 set(g[i], b[i - 1], b[i]);
 }
 puts(f[n - 1] || g[n - 1]? "Yes": "No");
 return 0;
}

==注：本题还有一种很奇怪的解法，就是直接判断相邻的四种连接方式是否有至少一种能连通，比如#30453703，如果有大佬能证明这种方法的正确性，欢迎在评论区留言告诉我，谢谢！==

D - Polynomial division

题目大意

我们有三个多项式

$$ A(x)=\sum_{i=0}^N A_iX^i\\ B(x)=\sum_{i=0}^M B_iX^i\\ C(x)=\sum_{i=0}^{N+M} B_iX^i $$

已知$A_0,\dots,A_N$和$C_0,\dots,C_N$且$A(x)\times B(x)=C(x)$（$x\in R$），求$B_0,\dots,B_M$。
换句话说，给定多项式$A$和$C$每一项的系数，求多项式$B=\frac C A$。

$1\le N,M < 100$
$|A_i|\le 100$
$|C_i|\le 10^6$
$A_N\ne0,C_{N+M}\ne0$
题目保证存在合法的$(B_0,\dots,B_M)$。

输入格式

$N~M$
$A_0~\dots~A_N$
$C_0~\dots~C_{N+M}$

输出格式

输出$B_0,\dots,B_M$，用空格分隔。

样例

略，请自行前往AtCoder查看

分析

本题可以直接模拟多项式的大除法运算，运算时只需记录系数即可。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <cstdio>
#define maxn 105
using namespace std;

int a[maxn], b[maxn], c[maxn << 1];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 for(int i=0; i<=n; i++) scanf("%d", a + i);
 for(int i=0; i<=n+m; i++) scanf("%d", c + i);
 for(int i=m; i>=0; i--) // NOTE: 必须倒推！
 {
 b[i] = c[n + i] / a[n];
 for(int j=0; j<=n; j++)
 c[i + j] -= a[j] * b[i];
 }
 for(int i=0; i<=m; i++)
 printf("%d ", b[i]);
 return 0;
}

E - Wrapping Chocolate

题目大意

我们有$N$块巧克力和$M$个盒子。第$i$块巧克力长$A_i$厘米，宽$B_i$厘米；第$i$个盒子长$C_i$厘米，宽$D_i$厘米。
问是否能把巧克力分别装在盒子里，使其满足如下条件：

每个盒子里只能有一块巧克力。
当我们将第$i$块巧克力放入第$j$个盒子里时，$A_i\le C_j$和$B_i\le D_j$必须都成立。

$1\le N\le M\le 2\times10^5$
$1\le A_i,B_i,C_i,D_i\le 10^9$

输入格式

$N~M$
$A_1~\dots~A_N$
$B_1~\dots~B_N$
$C_1~\dots~C_N$
$D_1~\dots~D_N$

输出格式

如果有合法的方法，输出Yes；否则，输出No。

分析

本题可以考虑如下贪心算法：

将所有的巧克力和盒子放入一个数组，按长度（$A_i$或$C_i$）的降序排序，长度相等的把盒子排在前面。
准备好一个空序列$S=()$，按如下规则遍历每个元素：
- 如果当前遍历的是一个盒子$(C_i,D_i)$：
  将$D_i$加入$S$。
- 如果当前遍历的是一块巧克力$(A_i,B_i)$：
  从$S$中删除不超过$B_i$的最小元素，如果没有元素可删除，输出No。
如果顺利地遍历了所有元素，输出Yes；否则，输出No。

本算法的时间复杂度是$\mathcal O(MN)$，但经过multiset优化后可降为$\mathcal O((M+N)\log(M+N)$，具体实现详见代码。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


#include <cstdio>
#include <set>
#include <algorithm>
using namespace std;

struct Item {
 int w, h;
 bool type;
 inline bool operator <(const Item& i2) const {
 return w == i2.w? type > i2.type: w > i2.w;
 // ^^^^^^^^^^^^^^
 // 注意sort必须有严格顺序，一开始我这里写成了type==1导致RE，详见：
 // https://atcoder.jp/contests/abc245/submissions/30526563
 }
} v[400005];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 // Chocolate
 for(int i=0; i<n; i++) scanf("%d", &v[i].w);
 for(int i=0; i<n; i++) scanf("%d", &v[i].h);
 // Box
 m += n;
 for(int i=n; i<m; i++) scanf("%d", &v[i].w);
 for(int i=n; i<m; i++) scanf("%d", &v[i].h);
 for(int i=n; i<m; i++) v[i].type = 1;
 // Algorithm
 sort(v, v + m);
 multiset<int> s;
 for(int i=0; i<m; i++)
 {
 const Item& it = v[i];
 if(it.type) s.insert(it.h); // Box
 else
 {
 auto itr = s.lower_bound(it.h);
 if(itr == s.end())
 {
 puts("No");
 return 0;
 }
 s.erase(itr);
 }
 }
 puts("Yes");
 return 0;
}

AtCoder Beginner Contest 244 D~F 题解

Sun, 20 Mar 2022 21:49:00 +0800

D - Swap Hats

题目大意

有$3$个Takahashi，他们帽子的颜色分别为$S_1,S_2,S_3$。
我们现在想通过正好$10^{18}$次操作，使得$S_i=T_i$。
每次操作如下：

选择$(i,j)$，交换$S_i$和$S_j$。

试问能否达成目标？

输入格式

$S_1~S_2~S_3$
$T_1~T_2~T_3$

输出格式

如果能达成目标，输出Yes；否则，输出No。

样例

样例输入

1
2


R G B
R G B

样例输出

1

Yes

分析

本题情况不多，可以手动枚举所有可能的情况，最终发现所有$S_i=T_i$或者所有$S_i\ne T_i$时输出Yes，否则输出No。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 char a, b, c, d, e, f;
 scanf("%c %c %c %c %c %c", &a, &b, &c, &d, &e, &f);
 puts(((a == d) + (b == e) + (c == f)) == 1? "No": "Yes");
 return 0;
}

E - King Bombee

题目大意

给定由$N$个点、$M$条边组成的简单无向图。第$i$条边连接顶点$U_i$和$V_i$。
求图中从$S$到$T$、长度为$K$且经过顶点$X$偶数次的路径的数量，==对$998244353$取模==。

$2\le N\le 2000$
$1\le M\le 2000$
$1\le K\le 2000$
$1\le S,T,X\le N$
$X\ne S,X\ne T$
$1\le U_i < V_i\le N$
$(U_i,V_i)\ne(U_j,V_j)$（$i\ne j$）

输入格式

$N~M~K~S~T~X$
$U_1~V_1$
$\vdots$
$U_N~V_N$

输出格式

输出图中从$S$到$T$、长度为$K$且经过顶点$X$偶数次的路径的数量，==对$998244353$取模==。

样例

样例输入1

1
2
3
4
5


4 4 4 1 3 2
1 2
2 3
3 4
1 4

样例输出1

1

4

有$4$条符合条件的路径：

$1\to2\to1\to2\to3$
$1\to2\to3\to2\to3$
$1\to4\to1\to4\to3$
$1\to4\to3\to4\to3$

注意$X=2$必须出现偶数次。

样例输入2

1
2
3
4
5
6


6 5 10 1 2 3
2 3
2 4
4 6
3 6
1 5

样例输出2

1

0

这张图没有连通。

样例输入3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


10 15 20 4 4 6
2 6
2 7
5 7
4 5
2 4
3 7
1 7
1 4
2 9
5 10
1 3
7 8
7 9
1 6
1 2

样例输出3

1

952504739

注意==对$998244353$取模==。

分析

我们先不考虑$X$的限制条件，则可以令$\mathrm{dp}(i,j)=~$第$i$步走到$j$的可能数，则因为点$j$可以从$G_j$中的任意一点走过来（$G$为邻接表存储），所以我们得到

$$\mathrm{dp}(i,j)=\sum_{k=1}^{|G_j|} \mathrm{dp}(i-1,{G_j}_k)$$

再考虑$X$必须是偶数的情况，令$\mathrm{dp}(i,j,k)=~$第$i$步走到$j$且$X$的出现次数除以$2$的余数为$k$的情况，则每次额外判断${G_j}_k$是否等于$X$即可。
$\mathrm{DP}$状态转移方程详见代码。

代码

注意：代码中运用了滚动表的优化，可以节省空间，当然也可以使用普通写法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


#include <cstdio>
#include <vector>
#define maxn 2005
#define MOD 998244353
using namespace std;

inline void mod(int& x)
{
 if(x >= MOD) x -= MOD;
}

vector<int> G[maxn];
int dp[2][maxn][2];

int main()
{
 int n, m, k, s, t, x;
 scanf("%d%d%d%d%d%d", &n, &m, &k, &s, &t, &x);
 x --;
 while(m--)
 {
 int u, v;
 scanf("%d%d", &u, &v);
 G[--u].push_back(--v);
 G[v].push_back(u);
 }
 dp[0][--s][0] = 1;
 for(int i=1; i<=k; i++)
 {
 bool c = i & 1, p = i & 1 ^ 1;
 for(int v=0; v<n; v++)
 {
 dp[c][v][0] = dp[c][v][1] = 0;
 for(int u: G[v])
 mod(dp[c][v][0] += dp[p][u][u == x]),
 mod(dp[c][v][1] += dp[p][u][u != x]);
 }
 }
 printf("%d\n", dp[k & 1][--t][0]);
 return 0;
}

F - Shortest Good Path

分析

令$\mathrm{dis}[S][j]=~$于点$j$结束的good path with respest to S的最短长度，跑一遍$\text{BFS}$即可。具体实现时可将$S$按位压缩为二进制，加快运算速度。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


#include <cstdio>
#include <queue>
#define INF 2147483647
#define maxn 17
using namespace std;

using ULL = unsigned long long;

int dis[1 << maxn][maxn];
vector<int> G[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int u, v;
 scanf("%d%d", &u, &v);
 G[--u].push_back(--v);
 G[v].push_back(u);
 }
 queue<ULL> q;
 for(int i=0; i<n; i++)
 dis[1 << i][i] = 1, q.push(1ULL<<i+32^i);
 while(!q.empty())
 {
 ULL pkg = q.front(); q.pop();
 int st = pkg >> 32ULL, v = pkg & 0x7fffffff;
 int nd = dis[st][v] + 1;
 for(int u: G[v])
 {
 int nst = st ^ (1 << u);
 if(dis[nst][u] == 0)
 {
 dis[nst][u] = nd;
 q.push(ULL(nst) << 32ULL ^ u);
 }
 }
 }
 long long ans = 0LL;
 for(int i=1, lim=1<<n; i<lim; i++)
 {
 int cur = INF;
 for(int j=0; j<n; j++)
 if(dis[i][j] > 0 && dis[i][j] < cur)
 cur = dis[i][j];
 ans += cur;
 }
 printf("%lld\n", ans);
 return 0;
}

【Python】72行实现代码行数统计，简单实用！

Tue, 15 Mar 2022 15:24:00 +0800

前言

最近突然想知道自己总共写了多少行代码，于是做了这样一个小工具……

准备工作

先考虑一下希望得到的效果：

Language（语言）	Lines（代码行数）	Size（代码文件总大小）	Files（代码文件总数）
A	12345	300 KB	193
B	2345	165 KB	98

如上，程序输出一个表格，将代码行数作为关键字排序。
代码框架：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


# -*- encoding: utf-8 -*-
import ...

# 代码行数计数类
class CodeLinesCounter(object):
 SIZES = [('B', 1), ('KB', 1024), ('MB', 1024**2), ('GB', 1024**3), ('TB', 1024**4)]
 
 def __init__(self, languages):
 self._languages = languages # 语言（dict,{文件后缀名：语言}）
 self._codelines = {suffix: (0, 0, 0) for suffix in languages} # 统计结果，{后缀名：(行数，大小，文件数)}
 self._successful = self._error = 0 # 记录成功、失败文件个数
 
 # @param directory: 要扫描的目录
 # @param log: 是否打印日志
 def scan(self, directory, log=False):
 if log: print('Scanning', directory)
 pass
 
 def report(self): # 输出结果
 pass

counter = CodeLinesCounter(languages={'py': 'Python', 'c': 'C', 'cpp': 'C++', 'java': 'Java', 'js': 'JavaScript', 'html': 'HTML', 'css': 'CSS', 'txt': 'Plain text'}) # 创建CodeLinesCounter实例
counter.scan('E:/') # 扫描E盘（注意不能用'E:'）
counter.report() # 输出结果

完成，下面正式进入==主要部分==

统计

文件扫描

首先，我们需要获取根目录下的文件列表。这可以用os.walk实现：
os.walk(rootdir)返回一个游走器（可迭代），包含根目录下每个子目录的文件及目录列表。我们来看一个例子：
有一文件夹Folder如下：

1
2
3
4
5
6
7
8


Folder
| file1
| Folder1
| file2
| file3
| Folder2
 | file4
 | Folder3

运行如下代码：

1
2
3
4


import os

for root, dirs, files in os.walk('Folder'):
 print(root, dirs, files)

则输出如下：

1
2
3
4


Folder					['Folder1', 'Folder2']	['file1']
Folder\Folder1			[]						['file2', 'file3']
Folder\Folder2			['Folder3']				['file4']
Folder\Folder2\Folder3	[]						[]

其中第一项是当前的根目录，第二项为目录下的目录列表，第三项则为当前的文件列表。
因此，我们可以编写如下代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


# -*- encoding: utf-8 -*-
from os.path import join, getsize, abspath
from os import walk

class CodeLinesCounter(object):
 SIZES = [('B', 1), ('KB', 1024), ('MB', 1024**2), ('GB', 1024**3), ('TB', 1024**4)]
 
 def __init__(self, languages):
 self._languages = languages
 self._results = {suffix: (0, 0, 0) for suffix in languages}
 self._successful = self._error = 0
 
 def scan(self, directory, log=False):
 if log: print('Scanning', directory)
 try:
 for root, _, files in walk(abspath(directory)):
 for filename in files:
 suffix = filename[filename.rfind('.') + 1:]
 filename = join(root, filename)
 if suffix in self._results:
 lines, size, numFiles = self._results[suffix]
 lines += 1 # 暂不统计，先按一行计算
 numFiles += 1
 size += getsize(filename) # getsize返回文件大小（字节）
 self._results[suffix] = (lines, size, numFiles)
 if log: print(filename)
 except KeyboardInterrupt:
 print('\nUser stopped operation')
 else:
 if log: print('Scan finished')
 
 def report(self):
 print('Language\tLines\tSize\tFiles')
 for suffix, (lines, size, files) in sorted(self._results.items(), key=lambda x: x[1], reverse=True):
 print(self._languages[suffix], lines, self.__format_size(size), files, sep='\t')

 # 单位转换
 def __format_size(self, bytes):
 for suffix, size in self.SIZES:
 if bytes < size * 1024:
 return '%.2f %s' % (bytes / size, suffix)
 return '%.2f %s' % (bytes / self.SIZES[-1][1], 2, self.SIZES[-1][0])

counter = CodeLinesCounter(languages={'py': 'Python', 'c': 'C', 'cpp': 'C++', 'java': 'Java', 'js': 'JavaScript', 'html': 'HTML', 'css': 'CSS', 'txt': 'Plain text'})
counter.scan('E:/')
counter.report()

运行结果应类似于下面这样（手动整理了一下）：

1
2
3
4
5
6
7
8
9


Language Lines Size 		Files
C++ 		667 671.51 KB 667
Python 		317 981.01 KB 317
HTML 		38 466.52 KB 38
Plain text 34 90.69 KB 34
JavaScript 19 1.43 MB			19
CSS 		9 341.04 KB 9
C 		2 20.45 KB 2
Java 		1 676.00 B 1

好，下面来到行数统计部分（表格输出后面会介绍）。

行数统计

众所周知，空行不应该算在代码行数中。因此，统计时需忽略空行。先写上如下代码（替换掉刚才的23行）：

1
2
3
4


with open(filename, 'r', encoding='utf-8') as f: # utf-8编码打开文件
 for line in f:
 if line and not line.isspace(): # 去掉空行
 lines += 1

但是，正当我们兴致勃勃地运行时——

1
2
3
4
5


Traceback (most recent call last):
 ...
 File "...\lib\codecs.py", line 322, in decode
 (result, consumed) = self._buffer_decode(data, self.errors, final)
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xb5 in position 355: invalid start byte

程序报错UnicodeDecodeError，分析后发现原因是部分文件使用了GBK编码，而utf-8编码无法正确打开，因此造成错误。
我们再次改进程序，使其尝试两种编码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


try:
 ln = 0
 with open(filename, 'r', encoding='utf-8') as f:
 for line in f:
 if line and not line.isspace():
 ln += 1
except UnicodeDecodeError: # 尝试使用GBK编码打开
 try:
 ln = 0
 with open(filename, 'r', encoding='gbk') as f:
 for line in f:
 if line and not line.isspace():
 ln += 1
 except:
 print(filename, '[Error: unknown encoding]')
 self._error += 1
 else:
 lines += ln
except Exception as e:
 print(filename, '[Unknown error: %s]' % e)
 self._error += 1
 continue
lines += ln
if log: print(f'{filename} [{ln}]')
self._successful += 1

这次，我们得到了正确的结果：

1
2
3
4
5
6
7
8
9


Language Lines Size 		Files
C++ 		35595 671.51 KB 667
JavaScript 24485 1.43 MB 		19
Python 		24130 982.16 KB 317
CSS 		8203 341.04 KB 9
HTML 		6138 466.52 KB 38
Plain text 741 90.69 KB 34
C 		557 20.45 KB 2
Java 		29 676.00 B 1

现在仅剩最后一步了——制表。

制表

python输出表格可以使用PrettyTable库。具体用法如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72


# -*- encoding: utf-8 -*-
from os.path import join, getsize, abspath
from os import walk
from prettytable import PrettyTable

class CodeLinesCounter(object):
 SIZES = [('B', 1), ('KB', 1024), ('MB', 1024**2), ('GB', 1024**3), ('TB', 1024**4)]
 
 def __init__(self, languages):
 self._languages = languages
 self._results = {suffix: (0, 0, 0) for suffix in languages}
 self._successful = self._error = 0
 
 def scan(self, directory, log=False):
 if log: print('Scanning', directory)
 try:
 for root, _, files in walk(abspath(directory)):
 for filename in files:
 suffix = filename[filename.rfind('.') + 1:]
 filename = join(root, filename)
 if suffix in self._results:
 lines, size, numFiles = self._results[suffix]
 numFiles += 1
 size += getsize(filename)
 try:
 ln = 0
 with open(filename, 'r', encoding='utf-8') as f:
 for line in f:
 if line and not line.isspace():
 ln += 1
 except UnicodeDecodeError: # Try 'gbk' encoding
 try:
 ln = 0
 with open(filename, 'r', encoding='gbk') as f:
 for line in f:
 if line and not line.isspace():
 ln += 1
 except:
 print(filename, '[Error: unknown encoding]')
 self._error += 1
 else:
 lines += ln
 except Exception as e:
 print(filename, '[Unknown error: %s]' % e)
 self._error += 1
 continue
 lines += ln
 if log: print(f'{filename} [{ln}]')
 self._successful += 1
 self._results[suffix] = (lines, size, numFiles)
 elif log:
 print(filename, '[None]')
 except KeyboardInterrupt:
 print('\nUser stopped operation')
 else:
 if log: print('Scan finished')
 
 def report(self):
 table = PrettyTable(['Language', 'Lines', 'Size', 'Files'], title=f'Scan result (OK {self._successful}, Error {self._error})') # 创建PrettyTable实例，添加标题
 for suffix, (lines, size, files) in sorted(self._results.items(), key=lambda x: x[1], reverse=True):
 table.add_row([self._languages[suffix], lines, self.__format_size(size), files]) # 添加行
 print(table) # 输出
 
 def __format_size(self, bytes):
 for suffix, size in self.SIZES:
 if bytes < size * 1024:
 return '%.2f %s' % (bytes / size, suffix)
 return '%.2f %s' % (bytes / self.SIZES[-1][1], 2, self.SIZES[-1][0])

counter = CodeLinesCounter(languages={'py': 'Python', 'c': 'C', 'cpp': 'C++', 'java': 'Java', 'js': 'JavaScript', 'html': 'HTML', 'css': 'CSS', 'txt': 'Plain text'})
counter.scan('E:/')
counter.report()

运行结果：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


+----------------------------------------+
| Scan result (OK 1087, Error 0) |
+------------+-------+-----------+-------+
| Language | Lines | Size | Files |
+------------+-------+-----------+-------+
| C++ | 35595 | 671.51 KB | 667 |
| JavaScript | 24485 | 1.43 MB | 19 |
| Python | 24130 | 982.16 KB | 317 |
| CSS | 8203 | 341.04 KB | 9 |
| HTML | 6138 | 466.52 KB | 38 |
| Plain text | 741 | 90.69 KB | 34 |
| C | 557 | 20.45 KB | 2 |
| Java | 29 | 676.00 B | 1 |
+------------+-------+-----------+-------+

总结

最终代码（无注释）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72


# -*- encoding: utf-8 -*-
from os.path import join, getsize, abspath
from os import walk
from prettytable import PrettyTable

class CodeLinesCounter(object):
 SIZES = [('B', 1), ('KB', 1024), ('MB', 1024**2), ('GB', 1024**3), ('TB', 1024**4)]
 
 def __init__(self, languages):
 self._languages = languages
 self._results = {suffix: (0, 0, 0) for suffix in languages}
 self._successful = self._error = 0
 
 def scan(self, directory, log=False):
 if log: print('Scanning', directory)
 try:
 for root, _, files in walk(abspath(directory)):
 for filename in files:
 suffix = filename[filename.rfind('.') + 1:]
 filename = join(root, filename)
 if suffix in self._results:
 lines, size, numFiles = self._results[suffix]
 numFiles += 1
 size += getsize(filename)
 try:
 ln = 0
 with open(filename, 'r', encoding='utf-8') as f:
 for line in f:
 if line and not line.isspace():
 ln += 1
 except UnicodeDecodeError: # Try 'gbk' encoding
 try:
 ln = 0
 with open(filename, 'r', encoding='gbk') as f:
 for line in f:
 if line and not line.isspace():
 ln += 1
 except:
 print(filename, '[Error: unknown encoding]')
 self._error += 1
 else:
 lines += ln
 except Exception as e:
 print(filename, '[Unknown error: %s]' % e)
 self._error += 1
 continue
 lines += ln
 if log: print(f'{filename} [{ln}]')
 self._successful += 1
 self._results[suffix] = (lines, size, numFiles)
 elif log:
 print(filename, '[None]')
 except KeyboardInterrupt:
 print('\nUser stopped operation')
 else:
 if log: print('Scan finished')
 
 def report(self):
 table = PrettyTable(['Language', 'Lines', 'Size', 'Files'], title=f'Scan result (OK {self._successful}, Error {self._error})')
 for suffix, (lines, size, files) in sorted(self._results.items(), key=lambda x: x[1], reverse=True):
 table.add_row([self._languages[suffix], lines, self.__format_size(size), files])
 print(table)
 
 def __format_size(self, bytes):
 for suffix, size in self.SIZES:
 if bytes < size * 1024:
 return '%.2f %s' % (bytes / size, suffix)
 return '%.2f %s' % (bytes / self.SIZES[-1][1], 2, self.SIZES[-1][0])

counter = CodeLinesCounter(languages={'py': 'Python', 'c': 'C', 'cpp': 'C++', 'java': 'Java', 'js': 'JavaScript', 'html': 'HTML', 'css': 'CSS', 'txt': 'Plain text'})
counter.scan('E:/')
counter.report()

后期改进：

增加正则表达式忽略文件
matplotlib绘图
PyQt5GUI
……（欢迎提出宝贵的意见！）

AtCoder Beginner Contest 242 C~E 题解

Tue, 08 Mar 2022 22:30:00 +0800

C - 1111gal password

题目大意

给定正整数$N$，求符合下列条件的整数$X$的个数，对$998244353$取模：

$X$是$N$位的正整数
$X$的每一位数都在$[1,9]$之间（==0不行==）；
$X$的相邻两位数之差的绝对值不超过$1$。

$2\le N\le 10^6$

输入格式

$N$

输出格式

输出答案。

样例

$N$	输出
$4$	$203$
$2$	$25$
$1000000$	$248860093$

分析

根据乘法原理可得，符合条件的$N$位数最多有$9^N$个，显然不能暴力求解。
但是，由于每一位会被上一位所限制，所以我们很容易想到使用$\text{DP}$求解。
令$f(i,j)=X$的第$i$位上出现$j$的可能数，易得：

$$ f(i,j)=\begin{cases} 1&(i=1)\\ f(i-1,1)+f(i-1,2)&(j=1)\\ f(i-1,8)+f(i-1,9)&(j=9)\\ f(i-1,j-1)+f(i-1,j)+f(i-1,j+1)&(i>1,2\le j\le8) \end{cases} $$

因此，直接输出$\sum\limits_{i=1}^9f(n,i)$即可。

代码

本代码运用了滚动表的优化，当然也可以直接开$N\times9$大小的数组，但这样会导致内存占用大，不建议使用。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#include <cstdio>
#define MOD 998244353
using namespace std;

inline void mod(int& x)
{
 if(x >= MOD) x -= MOD;
}

int dp[9], ldp[9];

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=0; i<9; i++)
 dp[i] = 1;
 while(--n)
 {
 for(int i=0; i<9; i++)
 ldp[i] = dp[i];
 mod(dp[0] += dp[1]), mod(dp[8] += dp[7]);
 for(int i=1; i<8; i++)
 mod(dp[i] += ldp[i - 1]),
 mod(dp[i] += ldp[i + 1]);
 }
 int ans = 0;
 for(int i=0; i<9; i++)
 mod(ans += dp[i]);
 printf("%d\n", ans);
 return 0;
}

D - ABC Transform

题目大意

给定由A、B、C组成的字符串$S$。令$S_0=S$，$S_i=S_{i-1}$将A、B、C分别替换为BC、CA、AB的新字符串。
回答$Q$个查询，第$i$个查询的问题如下：

求$S_{t_i}$的第$k_i$个字母。

$1\le |S|\le 10^5$
$1\le Q\le 10^5$
$1\le t_i\le 10^{18}$
$1\le k_i\le min(10^{18},S_{t_i}$的长度$)$

输入格式

$S$
$Q$
$t_1~k_1$
$\vdots$
$t_Q~k_Q$

样例

样例输入1

样例输出1

1
2
3
4


A
B
C
B

$S_0=~$ABC
$S_1=~$AABCB

样例输入2

1
2
3
4
5
6
7


CBBAACCCCC
5
57530144230160008 659279164847814847
29622990657296329 861239705300265164
509705228051901259 994708708957785197
176678501072691541 655134104344481648
827291290937314275 407121144297426665

样例输出2

1
2
3
4
5


A
A
C
A
A

注意小心整数溢出问题。

分析

令$f(t,k)=(S_0$为AAA..时$S_t$的第$k$个字母，其中A、B、C分别对应$0,1,2$且$k$从$0$开始$)$，则通过找规律可得：

$$ f(t,k)=\begin{cases} 0 & (t=0)\\ g(0,t) & (k=0)\\ g(f(t-1,\lfloor\frac k2\rfloor),(k\bmod2)+1) & (t>0,k>0) \end{cases} $$

其中$g(c,x)$为字符$c$在A,B,C,A,...这个环中$c$后面的第$x$个字符，即$g(c,x)=(c+x)\bmod3$。
因此，我们只要求出$x$在$S$的哪个字符分解后的结果中，再计算$f$即可。
答案为$\mathrm{ans}=g(f(t,(k-1)\bmod2^t),S_{\lfloor\frac {k-1}{2t}\rfloor})$。

代码

以下两种示范代码均使用非递归形式，当然也可使用递归形式。

代码1（标准）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


#include <cstdio>
using namespace std;

char s[100005];

int main()
{
 scanf("%s", s);
 int q;
 scanf("%d", &q);
 while(q--)
 {
 long long t, k;
 scanf("%lld%lld", &t, &k);
 k --;
 int x = s[t < 64? k >> t: 0] - 'A'; // 防止t太大导致RE
 while(t > 0 && k > 0)
 {
 x = (x + int(k & 1LL) + 1) % 3;
 k >>= 1LL, t --;
 }
 putchar((t + x) % 3 + 'A');
 putchar('\n');
 }
 return 0;
}

代码2（优化）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <cstdio>
using namespace std;

char s[100005];

int main()
{
 scanf("%s", s);
 int q;
 scanf("%d", &q);
 while(q--)
 {
 long long t, k;
 scanf("%lld%lld", &t, &k);
 k --;
 int c = 0;
 if(t < 64)
 {
 c = s[k >> t] - 'A';
 k &= (1LL << t) - 1LL;
 }
 else c = s[0] - 'A';
 for(c+=t%3; k>0; k&=k-1) c ++;
 putchar(c % 3 + 'A');
 putchar('\n');
 }
 return 0;
}

E - (∀x∀)

题目大意

对于$T$个测试点，分别解决下列问题：
给定整数$N$和字符串$S$，求合法字符串$X$的个数，使其符合下列条件：

$|X|=N$
$X$由大写英文字母组成，是一个回文串
按字典序，==$X\le S$==

$1\le T\le 250000$
$1\le N\le 10^6$
$1\le \sum N\le 10^6$
$|S|=N$且由大写英文字母组成。

分析

显然，通过$X$的前$\lceil\frac N2\rceil$个字符就可以确定唯一的$X$。下面，我们以ABCDE为例：

ABCDE的前$\lceil\frac N2\rceil$个字符分别为ABC
字典序小于ABC的字符串有$28$个（可看作一个$26$进制数来计算）
判断ABCBA是否可行，与ABCDE比较
可行，答案增加$1$得到$29$

因此，我们输出$29$。其他情况类似。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#include <cstdio>
#define maxn 1000005
#define MOD 998244353
using namespace std;

using LL = long long;
char s[maxn];

int main()
{
 int T;
 scanf("%d", &T);
 while(T--)
 {
 int n;
 scanf("%d%s", &n, s);
 long long x = 0LL;
 int j = n - 1 >> 1;
 for(int i=0; i<=j; i++)
 (x = x * 26LL + s[i] - 'A') %= MOD;
 bool ok = true;
 while(j >= 0)
 {
 if(s[j] < s[n - 1 - j]) break;
 if(s[j] > s[n - 1 - j]) { ok = false; break;}
 j --;
 }
 if(ok && ++x == MOD) x -= MOD;
 printf("%lld\n", x);
 }
 return 0;
}

AtCoder Beginner Contest 241 (Sponsored by Panasonic) D~F 题解

Sat, 05 Mar 2022 23:01:00 +0800

D - Sequence Query

题目大意

我们有一个空序列$A$。请依次处理$Q$个命令，每个命令有三种类型，每种类型的格式如下：

1 x：将$x$加入$A$（不去重）
2 x k：求在$A$的$\le x$的元素中，第$k$大的值。
3 x k：求在$A$的$\ge x$的元素中，第$k$小的值。

$1\le Q\le 2\times 10^5$
$1\le x\le 10^{18}$
==$1\le k\le 5$==

分析

注意题面中的$1\le k\le 5$，我们可以用multiset解决问题。
multiset顾名思义，就是不去重的set，支持二分查找操作。关于multiset的具体用法，请看这里
对于每个查询，我们作如下处理：

1 x：直接加入multiset
2 x k：先upper_bound，再将iterator向前移动$k$步
3 x k：先lower_bound，再将iterator向后移动$k$步

前面提到，因为$k$的值很小，所以移动iterator的时间复杂度可以忽略不计。
因此，总时间复杂度最优为$\mathcal O(Q)$，平均$\mathcal O(Q\log Q)$，最坏$\mathcal O(Q\log Q)$。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


#include <cstdio>
#include <set>
using namespace std;

int main()
{
 multiset<long long> s;
 int q;
 scanf("%d", &q);
 while(q--)
 {
 int op;
 long long x;
 scanf("%d%lld", &op, &x);
 if(op == 1) s.insert(x);
 else
 {
 int k;
 scanf("%d", &k);
 if(op == 2)
 {
 bool bad = false;
 auto it = s.upper_bound(x);
 for(; k--; --it)
 if(it == s.begin())
 {
 bad = true;
 break;
 }
 if(bad) puts("-1");
 else printf("%lld\n", *it);
 }
 else
 {
 auto it = s.lower_bound(x);
 for(; --k; ++it)
 if(it == s.end())
 break;
 if(it == s.end()) puts("-1");
 else printf("%lld\n", *it);
 }
 }
 }
 return 0;
}

E - Putting Candies

题目大意

给定长度为$N$的序列$A=(A_0,A_1,\dots,A_{N-1})$。
有一个空盘子。Takahashi每次会在其中加入$A_{(X\bmod N)}$颗糖果（$X$是当前盘子中糖果的数量）。
求$K$次操作后的糖果总数。

$2\le N\le 2\times 10^5$
$1\le K\le 10^{12}$
$1\le A_i\le 10^6$

分析

根据鸽笼原理（又称抽屉原理），$A_{(X\bmod N)}$的结果在最多$N$次操作后一定会重复。
因此，这道题可以看作数学上的一道周期问题。（~~又是数学题?!~~）
我们只需分别记录结果对应的时间和时间对应的结果即可。
最终总时间复杂度$\mathcal O(n)$，空间复杂度$\mathcal O(n)$。

代码

代码参考：AtCoder官方题解

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


#include <cstdio>
#define maxn 200005
using namespace std;

using LL = long long;
LL A[maxn], S[maxn];
int pre[maxn];

int main()
{
 int n;
 LL k;
 scanf("%d%lld", &n, &k);
 for(int i=0; i<n; i++)
 scanf("%lld", A + i);
 for(int i=1; i<n; i++)
 pre[i] = -1;
 int time, s;
 for(int i=0; i<n; i++)
 {
 S[i + 1] = S[i] + A[S[i] % n];
 if(pre[S[i + 1] % n] != -1)
 {
 s = pre[S[i + 1] % n];
 time = i + 1;
 break;
 }
 pre[S[i + 1] % n] = i + 1;
 }
 if(k <= s) printf("%lld\n", S[k]);
 else
 {
 int p = time - s;
 LL X = S[time] - S[s], t = k - s - 1;
 printf("%lld\n", S[s + t % p + 1] + t / p * X);
 }
 return 0;
}

F - Skate

题目大意

有一个$H\times W$的网格。网格上有$N$个障碍物，第$i$个的位置是$(X_i,Y_i)$。
我们从$(s_x,s_y)$开始，每一步向上、下、左、右中的一个方向行走，直到撞上障碍物，停在它前面的方格中。求到达$(g_x,g_y)$所用的最少步数。若无法到达终点，输出-1。

$1\le H,W\le 10^9$
==$1\le N\le 10^5$==
$1\le s_x,g_x,X_i\le H$
$1\le s_y,g_y,Y_i\le W$
$(s_x,g_x)\ne(g_x,g_y)\ne(X_i,Y_i)$
$(X_i,Y_i)\ne(X_j,Y_j)$（$i\ne j$）

分析

这道题看似数据范围很大，实则不然。因为$N$只有$10^5$，所以我们很容易想到使用$\text{BFS}$，用map存储每行每列，对于每个坐标，二分查找当前行/列中的位置即可。

代码

写代码时注意事项主要有两点：

行和列的坐标一定要排序，也可以用set
注意二分边界情况

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


#include <cstdio>
#include <queue>
#include <set>
#include <unordered_map>
using namespace std;

using LL = long long;
unordered_map<int, set<int>> row, col;
unordered_map<LL, int> dis;

inline LL pack(LL x, int y) { return x << 31LL | y; }
inline void unpack(const LL& b, int& x, int& y) { x = b >> 31LL, y = b & 0x7fffffff; }

int main()
{
 int h, w, n, sx, sy, gx, gy;
 scanf("%d%d%d%d%d%d%d", &h, &w, &n, &sx, &sy, &gx, &gy);
 for(int i=0; i<n; i++)
 {
 int x, y;
 scanf("%d%d", &x, &y);
 row[x].insert(y);
 col[y].insert(x);
 }
 LL target = pack(gx, gy);
 queue<pair<LL, int>> q;
 q.emplace(pack(sx, sy), 0);
 while(!q.empty())
 {
 auto [p, d] = q.front(); q.pop();
 if(!dis.emplace(p, d).second) continue;
 if(p == target) { printf("%d\n", d); return 0; }
 int x, y;
 unpack(p, x, y), ++d;
 if(row.count(x))
 {
 auto& s = row[x];
 auto it = s.lower_bound(y);
 if(it != s.end()) q.emplace(pack(x, *it - 1), d);
 if(it != s.begin()) q.emplace(pack(x, *--it + 1), d);
 }
 if(col.count(y))
 {
 auto& s = col[y];
 auto it = s.lower_bound(x);
 if(it != s.end()) q.emplace(pack(*it - 1, y), d);
 if(it != s.begin()) q.emplace(pack(*--it + 1, y), d);
 }
 }
 puts("-1");
 return 0;
}

Denso Create Programming Contest 2022 (AtCoder Beginner Contest 239) C~E 题解

Fri, 25 Feb 2022 23:08:00 +0800

C - Knight Fork

题目大意

在二维平面上是否有一个整数坐标点到$(x_1,y_1)$和$(x_2,y_2)$的欧几里得距离都是$\sqrt5$？

输入格式

$x_1~y_1~x_2~y_2$

输出格式

如果存在符合条件的点，输出Yes；否则，输出No。

样例

$x_1$	$y_1$	$x_2$	$y_2$	输出
$0$	$0$	$3$	$3$	`Yes`
$0$	$1$	$2$	$3$	`No`
$1000000000$	$1000000000$	$999999999$	$999999999$	`Yes`

分析

我们首先要知道，什么是“距离为$\sqrt5$”。设$\sqrt{(a-c)^2+(b-d)^2}=\sqrt5$（$a,b,c,d$均为整数），则有：

$$ (a-c)^2+(b-d)^2=5\\ \{a-c,b-d\}=\{1,2\} $$

所以，对于$(0,0)$这个点，有如下距离为$\sqrt5$的点（其他点都类似）：

所以，我们对找到$(x_1,y_1)$所有的距离为$\sqrt5$的点，并对计算与$(x_2,y_2)$的距离即可。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


#include <cstdio>
using namespace std;

using LL = long long;
const int d[8] = {-1, 1, 2, 2, 1, -1, -2, -2};

inline LL sqr2(const LL& x, const LL& y)
{
 return x * x + y * y;
}

int main()
{
 LL x1, y1, x2, y2;
 scanf("%lld%lld%lld%lld", &x1, &y1, &x2, &y2);
 x1 -= x2, y1 -= y2;
 for(int i=0; i<8; i++)
 if(sqr2(x1 + d[i], y1 + d[(i + 2) & 7]) == 5)
 {
 puts("Yes");
 return 0;
 }
 puts("No");
 return 0;
}

D - Prime Sum Game

~~==水题警告==~~

题目大意

Takahashi和Aoki在玩一个游戏。游戏过程如下：

Takahashi在中选择一个整数$A\le N\le B$。
Aoki中选择一个整数$C\le M\le D$。
如果$N+M$是质数，Aoki获胜。否则，Takahashi获胜。

当两人都按最优策略游戏时，谁会赢得比赛？

$1\le A\le B\le 100$
$1\le C\le D\le 100$

输入格式

$A~B~C~D$

输出格式

输出胜者的名字，即Takahashi或Aoki。

样例

$A$	$B$	$C$	$D$	输出
$2$	$3$	$3$	$4$	`Aoki`
$1$	$100$	$50$	$60$	`Takahashi`
$3$	$14$	$1$	$5$	`Aoki`

分析

要解决这道题，首先要知道什么是“最优策略”。
显然，当Takahashi选择的$N$加上任意的$M$都不是质数时，Takahashi胜利；
否则，当任意的$N$加上某一个$M$都得到质数时，Aoki胜利。
因为数据范围较小，我们可以暴力枚举所有$N$和$M$，质数判断耗时可以忽略不计。因此，总时间复杂度约为$\mathcal O(BD)$。

代码

P.S. 不可思议，运行时间居然是$4\mathrm{ms}$..（本来以为至少也有$30\mathrm{ms}$的..）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


#include <cstdio>
using namespace std;

inline bool isprime(int x)
{
 for(int t=__builtin_sqrt(x), i=2; i<=t; i++)
 if(x % i == 0)
 return false;
 return true;
}

int main()
{
 int a, b, c, d;
 scanf("%d%d%d%d", &a, &b, &c, &d);
 for(int i=a; i<=b; i++)
 {
 int j = c;
 for(; j<=d; j++)
 if(isprime(i + j))
 break;
 if(j > d) { puts("Takahashi"); return 0; }
 }
 puts("Aoki");
 return 0;
}

E - Subtree K-th Max

题目大意

有一个由$N$个节点（节点$1$，..，节点$N$）组成的树（根节点为节点$1$）。
第$i$条边连接节点$A_i$和$B_i$。节点$v$有一个数值$X_v$。
给定$Q$个询问，第$i$个询问由$(V_i,K_i)$组成：

在以节点$V_i$为根的子树当中，求所有节点的数值的第$K$大值（不去重）。

$2\le N,Q\le 10^5$
$0\le X_i\le 10^9$
$1\le A_i,B_i,V_i\le N$
==$1\le K_i\le 20$==

输入格式

$N~Q$
$X_1~\dots~X_N$
$A_1~B_1$
$\vdots$
$A_{N-1}~B_{N-1}$
$V_1~K_1$
$\vdots$
$V_Q~K_Q$

输出格式

输出$Q$行。第$i$行应包含对第$i$个询问的回答。

样例

略，请自行前往AtCoder查看

分析

我们首先发现题面中，$1\le K\le 20$。于是我们对每个节点分别存储以它为根的子树中前$20$的数值。
于是，我们按照拓扑序（或直接$\text{DFS}$），执行如下操作：

对于叶子节点，我们只存储一个当前的数值。
对于其他的节点，先排序当前节点数值和所有孩子的前$20$，排序后取前$20$即可。

排序建议用priority_queue，时间复杂度$\mathcal O(N+Q)$或$\mathcal O(N\log N+Q)$（直接排序）。

代码

示例代码实现方式为DFS + priority_queue，用时$190\mathrm{ms}$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


#include <cstdio>
#include <queue>
#define maxn 100005
using namespace std;

int x[maxn];
vector<int> G[maxn], dp[maxn];

void dfs(int v, int par)
{
 priority_queue<int, vector<int>, greater<int>> q;
 q.push(x[v]);
 for(int u: G[v])
 if(u != par)
 {
 dfs(u, v);
 for(int val: dp[u])
 {
 q.push(val);
 if(q.size() > 20) q.pop();
 }
 }
 while(!q.empty())
 {
 dp[v].push_back(q.top());
 q.pop();
 }
}

int main()
{
 int n, q;
 scanf("%d%d", &n, &q);
 for(int i=0; i<n; i++)
 scanf("%d", x + i);
 for(int i=1; i<n; i++)
 {
 int a, b;
 scanf("%d%d", &a, &b);
 G[--a].push_back(--b);
 G[b].push_back(a);
 }
 dfs(0, -1);
 while(q--)
 {
 int v, k;
 scanf("%d%d", &v, &k);
 const auto& d = dp[--v];
 printf("%d\n", d[d.size() - k]);
 }
 return 0;
}

AtCoder Beginner Contest 205 A~E 题解

Wed, 07 Jul 2021 16:40:00 +0800

A - kcal

题目大意

我们有一种每$100$毫升含有$A$千卡热量的饮料。$B$毫升的这种饮料含有多少千卡热量？

$0\le A, B\le 1000$

输入格式

$A~B$

输出格式

输出$B$毫升这种饮料包含的的千卡数。最大允许浮点数精度误差$10^{-6}$。

样例

$A$	$B$	输出
$45$	$200$	$90$
$37$	$450$	$166.5$
$0$	$1000$	$0$
$50$	$0$	$0$

分析

废话不多说，答案就是$\frac{AB}{100}$~

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


#include <cstdio>
using namespace std;

int main()
{
 int a, b;
 scanf("%d%d", &a, &b);
 a *= b;
 printf("%d.%d\n", a / 100, a % 100);
 return 0;
}

B - Permutation Check

题目大意

给定长度为$N$的序列$A=(A_1,A_2,\dots,A_N)$。
判断$A$是否为$(1,2,\dots,N)$的一种排列。

$1\le A_i\le N\le 10^3$

输入格式

$N$
$A_1~A_2~\dots~A_N$

输出格式

如果$A$是$(1,2,\dots,N)$的一种排列，输出Yes；否则，输出No。

样例

样例输入1

样例输出1

1

Yes

$(3,1,2,4,5)$是$(1,2,3,4,5)$的一种排列，所以我们输出Yes。

样例输入2

1
2


6
3 1 4 1 5 2

样例输出2

1

No

$(3,1,4,1,5,2)$不是$(1,2,3,4,5,6)$的一种排列，所以我们输出No。

样例输入3

样例输出3

1

Yes

样例输入4

样例输出4

1

Yes

分析

由于题目保证$1\le A_i\le N$，所以$(1,2,\dots,N)$的一种排列$A$定义如下：

$A$中$1$到$N$每个数字不重复出现。

因此，我们可以用数组记录每个数字是否出现，所以总时间复杂度为$\mathcal O(n)$。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <cstdio>
#define maxn 1005
using namespace std;

bool used[maxn];

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=0; i<n; i++)
 {
 int a;
 scanf("%d", &a);
 if(used[a])
 {
 puts("No");
 return 0;
 }
 used[a] = true;
 }
 puts("Yes");
 return 0;
}

C - POW

题目大意

给定三个整数$A,B,C$，判断$A^C$和$B^C$哪个更大。

$-10^9\le A,B\le 10^9$
$1\le C\le 10^9$

输入格式

$A~B~C$

输出格式

本题分如下三种情况输出：

如果$A^C < B^C$，输出<；
如果$A^C > B^C$，输出>；
如果$A^C = B^C$，输出=。

样例

$A$	$B$	$C$	输出
$3$	$2$	$4$	`>`
$-7$	$7$	$2$	`=`
$-8$	$6$	$3$	`<`

分析

首先，由于负负得正，$(-a)^2=a^2$。
这样，我们可以根据奇偶性得出，如果$n$为偶数，$(-a)^n=a^n$；但如果$n$为奇数，则$(-a)^n=-(a^n)$。
因此，我们只需判断如果$C$为偶数，将$A$替换为$|A|$，再将$B$替换为$|B|$。
最后，$A$和$B$的大小关系就是$A^C$和$B^C$的大小关系。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <cstdio>
using namespace std;

int main()
{
 int a, b, c;
 scanf("%d%d%d", &a, &b, &c);
 if(!(c & 1))
 {
 if(a < 0) a = -a;
 if(b < 0) b = -b;
 }
 puts(a < b? "<": a > b? ">": "=");
 return 0;
}

D - Kth Excluded

题目大意

给定长度为$N$的正整数序列$A=(A_1,A_2,\dots,A_N)$和$Q$次查询。
在第$i$次查询中，给定正整数$K_i$，求第$K_i$小的不在$A$中的正整数。

$1\le N,Q\le 10^5$
$1\le A_1 < A_2 < \dots < A_N\le10^{18}$
$1\le K_i\le 10^{18}$

输入格式

$N~Q$
$A_1~A_2~\dots~A_N$
$K_1$
$K_2$
$\hspace{5pt}\vdots$
$K_N$

输出格式

输出$Q$行。第$i$行应该包含第$K_i$小的不在$A$中的正整数。

样例

样例输入1

样例输出1

不在$A$中的正整数有$1,2,4,8,9,10,11,\dots$，其中有：

第$2$小的$2$；
第$5$小的$9$；
第$3$小的$4$。

因此，我们应该依次输出2，9，4。

样例输入2

样例输出2

分析

本题我们可以先预处理出$A$中每个元素比它小的元素的数量，再二分查找即可。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


#include <cstdio>
#include <algorithm>
#define maxn 100005
using namespace std;

using LL = long long;
LL a[maxn];

int main()
{
 int n, q;
 scanf("%d%d", &n, &q);
 for(int i=0; i<n; i++)
 {
 scanf("%lld", a + i);
 a[i] -= i;
 }
 while(q--)
 {
 LL k;
 scanf("%lld", &k);
 printf("%lld\n", k + (upper_bound(a, a + n, k) - a));
 }
 return 0;
}

E - White and Black Balls

题目大意

有多少种排列$N$个白球和$M$个黑球的方法使得下列条件成立？

对于每个$i$ ($1\le i\le N+M$)，设$w_i$和$b_i$分别是最左边$i$个球中白球和黑球的数量，$w_i\le b_i+K$成立。

答案对$(10^9+7)$取模。

$0\le N,M\le10^6$
$1\le N+M$
$0\le K\le N$

输入格式

$N~M~K$

输出格式

输出答案，对$(10^9+7)$取模。

样例

$N$	$M$	$K$	输出
$2$	$3$	$1$	$9$
$1$	$0$	$0$	$0$
$1000000$	$1000000$	$1000000$	$192151600$

分析

首先，本题中合法排列数就是如下符合任意$y\le x+K$的$(0,0)\to(M,N)$的最短路径的数量：

由此可见，如果$N > M+K$（即终点超出限制），答案一定为$0$。
我们还可以发现，如果没有$y\le x+K$这个限制，答案为$\binom{N + M}{N}$。
我们再考虑不合法的路径数，数量为$\binom{N + M}{M + K + 1}$。
因此，答案为$\binom{N + M}{N}-\binom{N + M}{M + K + 1}$。

代码

这里用AtCoder Library好像比较方便唉~

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <iostream>
#include <atcoder/modint>
using namespace std;

using modint = atcoder::modint1000000007;

modint f(int n, int m)
{
 if(n < 0 || m < 0)
 return 0;
 modint ret = 1;
 for(int i=1; i<=m; i++)
 ret = ret * (n + i) / i;
 return ret;
}

int main()
{
 int n, m, k;
 scanf("%d%d%d", &n, &m, &k);
 if(n > m + k) puts("0");
 else printf("%d\n", (f(n, m) - f(n - k - 1, m + k + 1)).val());
 return 0;
}

AtCoder Beginner Contest 199 (Sponsored by Panasonic) A~E 题解

Sun, 13 Jun 2021 11:31:00 +0800

A - Square Inequality

题目大意

给定三个整数$A,B,C$。判断$A^2+B^2 < C^2$是否成立。

$0\le A,B,C\le 1000$

输入格式

$A~B~C$

输出格式

如果$A^2+B^2 < C^2$，输出Yes；否则，输出No。

样例

$A$	$B$	$C$	输出
$2$	$2$	$4$	`Yes`
$10$	$10$	$10$	`No`
$3$	$4$	$5$	`No`

分析

直接按题意计算即可。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 int a, b, c;
 scanf("%d%d%d", &a, &b, &c);
 puts(a * a + b * b < c * c? "Yes": "No");
 return 0;
}

B - Intersection

题目大意

给定两个长度为$N$的序列：$A = (A_1, A_2, A_3, \dots, A_N)$和$B = (B_1, B_2, B_3, \dots, B_N)$。
找到符合如下条件的整数$x$的个数：

对于所有的$1\le i\le N$，$A_i\le x\le B_i$。

$1\le N\le 100$
$1\le A_i\le B_i\le 1000$

输入格式

$N$
$A_1~A_2~\dots~A_N$
$B_1~B_2~\dots~B_N$

输出格式

输出答案。

样例

样例输入1

样例输出1

1

3

$x$可以取$3,4,5$。

样例输入2

样例输出2

1

0

没有$x$符合条件。

样例输入3

样例输出3

1

2

分析

我们将$x$的限制条件拆解为：

对于所有的$1\le i\le N$，$A_i\le x$。
对于所有的$1\le i\le N$，$x\le B_i$。

这时，我们可以进一步简化条件：

$(\max A)\le x$。
$x\le (\min B)$。

从而得到$(\max A)\le x\le (\min B)$，所以合法的$x$的个数为$\max(0,\min B-\max A+1)$。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <cstdio>
using namespace std;

int main()
{
 int n, maxa = 1, minb = 1000;
 scanf("%d", &n);
 for(int i=0; i<n; i++)
 {
 int a;
 scanf("%d", &a);
 if(a > maxa) maxa = a;
 }
 while(n--)
 {
 int b;
 scanf("%d", &b);
 if(b < minb) minb = b;
 }
 if(maxa > minb) puts("0");
 else printf("%d\n", minb - maxa + 1);
 return 0;
}

C - IPFL

题目大意

给定长度为$2N$且只由大写英文字母组成的字符串$S$。
你要处理$Q$个请求。
第$i$个请求中由三个整数$T_i,A_i$和$B_i$组成：

如果$T_i=1$：交换$S$中第$A_i$和$B_i$个字符；
如果$T_i=2$，交换$S$中的前$N$个和后$N$个字符（如：FLIP$\to$IPFL）。

输出执行所有请求后的$S$。

$1\le N\le 2\times 10^5$
$|S|=2N$
$1\le Q\le 3\times 10^5$
$1\le T_i\le 2$，如果$T_i=1$，$1\le A_i < B_i\le 2N$；如果$T_i=2$，$A_i=B_i=0$。

输入格式

$N$
$S$
$Q$
$T_1~A_1~B_1$
$T_2~A_2~B_2$
$\hspace{18pt}\vdots$
$T_Q~A_Q~B_Q$

样例

样例输入1

样例输出1

1

LPFI

$\text{FLIP}\to\text{IPFL}\to\text{LPFI}$

样例输入2

样例输出2

1

ILPF

分析

首先，$\mathcal O(NQ)$的模拟法肯定行不通，会TLE。
我们考虑优化。
我们很容易发现，$T_i=1$的交换操作肯定是$\mathcal O(1)$的，但$T_i=2$的翻转操作是$\mathcal O(n)$的，所以需要优化。
我们可以用一个变量$\mathrm{flipped}$记录目前是否已经前后翻转（$1$表示已经翻转，$0$表示没有翻转），这时，操作变为如下：

当$T_i=2$，$\mathrm{flipped}:=1-\mathrm{flipped}$；
当$T_i=1$且$\mathrm{flipped}=0$时，我们直接交换$A_i$和$B_i$
当$T_i=\mathrm{flipped}=1$时，我们发现，一个位置$x$如果$< N$，则实际位置在$x+N$；否则，实际位置在$x-N$。

这种算法的时间复杂度为$\mathcal O(N+Q)$，可轻松通过此题。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


#include <cstdio>
#define maxn 400005
using namespace std;

char s[maxn];
int n;

inline void swap(char& x, char& y) { x ^= y ^= x ^= y; }
inline char& calc(int pos) { return s[pos < n? pos + n: pos - n]; }

int main()
{
 scanf("%d%s", &n, s);
 int q;
 scanf("%d", &q);
 bool flipped = false;
 while(q--)
 {
 int t, a, b;
 scanf("%d%d%d", &t, &a, &b);
 a --, b --;
 if(t == 2) flipped = !flipped;
 else if(flipped) swap(calc(a), calc(b));
 else swap(s[a], s[b]);
 }
 if(flipped)
 for(int i=0; i<n; i++)
 swap(s[i], s[n + i]);
 puts(s);
 return 0;
}

D - RGB Coloring 2

题目大意

我们有一个有$N$个点和$M$条边的简单无向图，第$i$条边连接着顶点$A_i$和$B_i$。
我们要给这个图用三种不同的颜色着色，使得相邻的顶点有不同的颜色。
有多少种合法的着色方法？不一定要使用所有颜色。

$1\le N\le 20$
$0\le M\le \frac{N(N-1)}2$
$1\le A_i,B_i\le N$

输入格式

$N~M$
$A_1~B_1$
$A_2~B_2$
$\hspace{12pt}\vdots$
$A_M~B_M$

输出格式

输出答案。

样例

样例输入1

样例输出1

1

6

我们用R、G、B分别代表三种不同的颜色，则有$6$中不同的着色方法，它们分别是RGB、RBG、GRB、GBR、BRG、BGR。

样例输入2

1

3 0

样例输出2

1

27

这个图没有边，所以任意着色都是可行的，一共有$3^N=27$种方法。

样例输入3

样例输出3

1

0

这里没有合法方案。

样例输入4

1

20 0

样例输出4

1

3486784401

分析

我们将图中的每个连通块依次暴力算出所有可能的着色方案数，再相乘即可。
其实，这里我们最大的总尝试数不是$3^N$，而是$3\times 2^{N-1}$，因为使用$\text{DFS}$时每个点的前一个点的颜色已经定好了，只需要尝试两种可能即可。

代码

~~似乎没人发现可以用unsigned int吧……~~

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


#include <cstdio>
#include <vector>
#define maxn 25
using namespace std;

vector<int> G[maxn];
int col[maxn], dep[maxn];

inline int next(int c) { return (c + 1) % 3; }

int paint(int v)
{
 for(int u: G[v])
 if(col[v] == col[u])
 return 0;
 int ans = 1;
 for(int u: G[v])
 {
 if(dep[u] == -1) dep[u] = dep[v] + 1;
 if(dep[u] == dep[v] + 1)
 {
 col[u] = next(col[v]);
 int res = paint(u);
 col[u] = next(col[u]);
 res += paint(u);
 col[u] = -1;
 if(res == 0) return 0;
 ans *= res;
 }
 }
 return ans;
}

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int x, y;
 scanf("%d%d", &x, &y);
 G[--x].push_back(--y);
 G[y].push_back(x);
 }
 for(int i=0; i<n; i++)
 col[i] = dep[i] = -1;
 unsigned int ans = 1;
 for(int i=0; i<n; i++)
 if(dep[i] == -1)
 {
 col[i] = dep[i] = 0;
 ans *= 3U * paint(i);
 }
 printf("%u\n", ans);
 return 0;
}

E - Permutation

题目大意

求符合如下条件的$(1,2,\dots,N)$的排列的个数：

对于每个$1\le i\le M$，这个排列的前$X_i$个数中不超过$Y_i$的最多有$Z_i$个。

$2\le N\le 18$
$0\le M\le 100$
$1\le X_i,Y_i < N$
$0\le Z_i < N$

输入格式

$N~M$
$X_1~Y_1~Z_1$
$X_2~Y_2~Z_2$
$\hspace{18pt}\vdots$
$X_M~Y_M~Z_M$

输出格式

输出一个整数，即符合条件的排列的个数。

样例

样例输入1

样例输出1

1

4

四个符合条件的排列分别为：$(1,2,3)$、$(2,3,1)$、$(3,1,2)$、$(3,2,1)$。

样例输入2

样例输出2

1

90

样例输入3

1

18 0

样例输出3

1

6402373705728000

由于没有限制条件，所有的$18!=6402373705728000$个排列都可行。这也是本题的最大输出。

分析

首先，还是先排除$\mathcal O(N!\sum X)$的暴力算法，这样做的时间复杂度太高了。
我们考虑状压$\text{DP}$。令$\mathrm{dp}_\mathrm{mask}$表示从$(1,2,\dots,N)$中选出子序列$\mathrm{mask}$（二进制第$i$位是$0$表示不选$i$，$1$表示选$i$）。
则，$\mathrm{dp}_0=1$，动态转移方程为$\mathrm{dp}_\mathrm{mask}=\mathrm{mask}$中所有为的$1$位上把$1$变成$0$的$\mathrm{dp}$中的和，详见代码。
写代码时注意判断合法性，最终答案应为$\mathrm{dp}_{2^N-1}$（全选）。

代码

我这里做了一个小优化，即忽略$Z_i\ge Y_i$的条件。当然，我们也可以不用优化，但不能不用long long！！！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


#include <cstdio>
#include <vector>
#define maxn 20
using namespace std;

using LL = long long;

vector<pair<int, int>> lim[maxn];
LL dp[1 << maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int x, y, z;
 scanf("%d%d%d", &x, &y, &z);
 if(z < y) lim[x].emplace_back(y, z);
 }
 int mx = 1 << n;
 dp[0] = 1LL;
 for(int st=0; st<mx; st++)
 {
 vector<int> s;
 for(int i=0; i<n; i++)
 if(st >> i & 1)
 s.push_back(i);
 int cnt = __builtin_popcount(st);
 bool ok = true;
 for(auto [y, z]: lim[cnt])
 {
 int tot = 0;
 for(auto x: s)
 if(x < y && ++tot > z)
 {
 ok = false;
 break;
 }
 if(!ok) break;
 }
 if(ok) for(int x: s) dp[st] += dp[st ^ (1 << x)];
 }
 printf("%lld\n", dp[mx - 1]);
 return 0;
}

KYOCERA Programming Contest 2021 (AtCoder Beginner Contest 200) A~E 题解

Thu, 10 Jun 2021 22:16:00 +0800

A - Century

题目大意

公元$N$年在第几个世纪中？

一个世纪是由$100$个年份组成的一个区间。如，$1$世纪为$[1,100]$年，$2$世纪为$[101,200]$年，……

$1\le N\le 3000$

输入格式

$N$

输出格式

将答案输出为一个整数。

样例

$N$	输出
$2021$	$21$
$200$	$2$

分析

根据本题条件我们可以推出：公元$N$年在世纪$\lceil \frac N {100}\rceil$。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 int n;
 scanf("%d", &n);
 printf("%d\n", n % 100 == 0? n / 100: n / 100 + 1);
 return 0;
}

B - 200th ABC-200

题目大意

对于整数$N$，执行$K$次如下操作：

如果$N$是$200$的倍数，将$N$除以$200$。
否则，在$N$后面添上$200$。（如，$123$变为$123200$）。

$1\le N\le 10^5$
$1\le K\le 20$

输入格式

$N~K$

输出格式

输出最终的$N$。

样例

$N$	$K$	输出
$2021$	$4$	$50531$
$40000$	$2$	$1$
$8691$	$20$	$84875488281$

分析

本题我们按照题意模拟即可，但我们需要证明答案不会超过$2^{63}-1$，这样才能使用long long：

任何数$N$添上$200$都是$200$的倍数。证明：一个数只要是$100$和$2$的公倍数，它就是$200$的倍数。$N$添上$200$后以00结尾，就证明了它是$200$的倍数。
这样，$N$每次添上$200$后都要除以$200$，相当于去掉两个零再将$N$除以$2$。
所以，$N$每次最多增加一位，还经常减少位数（除以$200$），肯定严格小于$2^{63}$。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <cstdio>
using namespace std;

int main()
{
 long long n;
 int k;
 scanf("%lld%d", &n, &k);
 while(k--)
 n = n % 200LL == 0LL? n / 200LL: n * 1000LL + 200LL;
 printf("%lld\n", n);
 return 0;
}

C - Ringo’s Favorite Numbers 2

题目大意

给定序列$A=(A_1,A_2,\dots,A_N)$，找到符合下列条件的所有$(i,j)$：

$1\le i < j\le N$；
$|A_i-A_j|$是$200$的倍数。

$2\le N\le 2\times 10^5$
$1\le A_i\le 10^9$

输出格式

$N$
$A_1~A_2~\dots~A_N$

样例

$A$	输出
$(123,223,123,523,200,2000)$	$4$
$(1,2,3,4,5)$	$0$
$(199,100,200,400,300,500,600,200)$	$9$

分析

首先，最容易想到的$\mathcal O(n^2)$的暴力算法肯定不行，因为$2\le N\le 2\times 10^5$。
我们考虑用桶优化：
我们有$200$个桶，分别如下：

桶的编号	元素$1$	元素$2$	元素$3$	元素$4$	……	元素除以$200$的余数
$0$	$0$	$200$	$400$	$600$	……	$0$
$1$	$1$	$201$	$401$	$601$	……	$1$
$2$	$2$	$202$	$402$	$602$	……	$2$
……	……	……	……	……	……	……
$198$	$198$	$398$	$598$	$798$	……	$198$
$199$	$199$	$399$	$599$	$799$	……	$199$
这时，我们发现，每个桶中的每个元素都能与这个同种的其他元素组成一对，所以我们只要在将元素加入桶中前将答案加上桶目前的大小即可。

总时间复杂度$\mathcal O(n)$。

代码

我们的桶中不需要真正的元素，只需要记录桶的大小即可。
注意：答案的数据类型一定要用long long！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <cstdio>
#define MOD 200
using namespace std;

int cnt[MOD];

int main()
{
 int n;
 scanf("%d", &n);
 long long ans = 0LL;
 while(n--)
 {
 int x;
 scanf("%d", &x);
 ans += cnt[x %= MOD] ++;
 }
 printf("%lld\n", ans);
 return 0;
}

D - Happy Birthday! 2

题目大意

给定序列$A=(A_1,A_2,\dots,A_N)$。你要从中选出两个子序列$B$和$C$（下标不同，不要求连续），使得$\sum B\equiv \sum C\pmod{200}$。

$2\le N\le 200$
$1\le A_i\le 10^9$

输入格式

$N$
$A_1~A_2~\dots~A_N$

输出

如果没有合法的$B$和$C$，输出No。
如果有合法的$B$和$C$，按下列格式输出，其中$x$为$B$的长度、$y$为$C$的长度，$B'$为$B$中元素对应的下标，$C'$为$C$中元素对应的下标：
$\text{Yes}$
$x~B'_1~B'_2~\dots~B'_x$
$y~C'_1~C'_2~\dots~C'_y$

样例

略，请自行前往AtCoder查看

分析

我们可以证明，只要$N\ge 8$，那么就一定有解。证明如下：

$8$个元素能组成的子序列有$2^8-1=255$种。（每个元素可以选或不选，去掉全不选的情况）
根据抽屉原理，我们将这$255$种子序列按照他们除以$200$的余数分别放入抽屉中，则至少有两个子序列在一个抽屉中，即必定有合法的$A$和$B$。

当$N < 8$时，我们暴力枚举所有可能；
当$N\ge 8$时，我们暴力枚举其中任意$8$个元素组成的所有可能即可找到解。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


#include <cstdio>
#include <vector>
#define maxn 10
#define MOD 200
using namespace std;

int a[maxn];
vector<int> bkt[MOD];

inline void print(const vector<int>& v)
{
 printf("%llu", v.size());
 for(int x: v)
 printf(" %d", x + 1);
 putchar('\n');
}

int main()
{
 int n;
 scanf("%d", &n);
 if(n > 8) n = 8;
 for(int i=0; i<n; i++)
 scanf("%d", a + i);
 int lim = 1 << n;
 for(int st=0; st<lim; st++)
 {
 int s = 0;
 vector<int> pos;
 for(int i=0; i<n; i++)
 if(st >> i & 1)
 s = (s + a[i]) % MOD, pos.push_back(i);
 if(!bkt[s].empty())
 {
 puts("Yes");
 print(bkt[s]);
 print(pos);
 return 0;
 }
 else bkt[s] = pos;
 }
 puts("No");
 return 0;
}

E - Patisserie ABC 2

题目大意

有$N^3$个三元组$(i,j,k)$（$1\le i,j,k\le N$），按如下排序：

$i+j+k$小的排在前面。
对于$i+j+k$相同的三元组，$i$小的排在前面，对于$i$相同的，$j$小的排在前面。

求第$K$个$(i,j,k)$。

$1\le N\le 10^6$
$1\le K\le N^3$

输入格式

$N~K$

输出格式

输出第$K$个$(i,j,k)$，用空格分隔。

样例

$N$	$K$	输出
$2$	$5$	$1~2~2$
$1000000$	$1000000000000000000$	$1000000~1000000~1000000$
$9$	$47$	$3~1~4$

分析

由于每个三元组的和都不会超过$3N$，所以我们考虑暴力枚举三元组的和，这样就能快速算出第$K$个三元组的和。那么，问题来了：符合$i+j+k=n$的三元组$(i,j,k)$（$i,j,k$均不超过$N$）有多少个？
这可以用容斥原理解决。首先，我们发现，上述问题实际上就是在求如下方程解的个数：

$$\begin{cases}i+j+k=n\\1\le i,j,k\le N\end{cases}$$

如果我们将问题改成求如下方程解的个数（注意$n$和$N$的区别）：

$$\begin{cases}i+j+k=n\\1\le i,j,k\le n\end{cases}$$

这个可以用挡板法解决，在$n-1$个位置上任选$2$个插入挡板，挡板分开的就是$i,j,k$，则公式为$C_{n-1}^2$。我们设$f(n)=~$上述方程解的个数（$C_{n-1}^2=(n-1)(n-2)$），则总方程解的个数为$f(n)$。
我们考虑一个、两个（不可能有三个）数大于$N$的情况，这样$\begin{cases}i+j+k=n\\1\le i,j,k\le N\end{cases}$这个方程解的个数就为$f(n)+3f(n-2N)-3f(n-N)$。

代码

计算$f(n)$时注意特判$n\le 2$的情况，否则可能会出现负数！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


#include <cstdio>
using namespace std;

using LL = long long;
int n;

inline int max(int x, int y) { return x > y? x: y; }
inline int min(int x, int y) { return x < y? x: y; }

inline LL f(LL n) { return n-- > 2? n * (n - 1LL) >> 1LL: 0LL; }
inline LL count(int s) { return f(s) - 3 * (f(s - n) - f(s - (n << 1))); }

int main()
{
 LL k;
 scanf("%d%lld", &n, &k);
 int lim = n * 3;
 for(int sum=3; sum<=lim; sum++)
 {
 LL cnt = count(sum);
 if(k > cnt) { k -= cnt; continue; }
 for(int a=1; a<=n; a++)
 {
 int minb = max(1, sum - a - n), maxb = min(n, sum - a - 1);
 if(minb > maxb) continue;
 int num = maxb - minb + 1;
 if(k <= num)
 {
 int b = minb + k - 1;
 int c = sum - a - b;
 printf("%d %d %d\n", a, b, c);
 return 0;
 }
 k -= num;
 }
 }
 return 0;
}

AtCoder Beginner Contest 204 A~E 题解

Mon, 07 Jun 2021 19:02:00 +0800

A - Rock-paper-scissors

三个人玩石头剪刀布平局，其中两个出的分别是$x,y$，求另一个人出的。

$0\le x,y\le 2$（$0,1,2$分别表示石头，剪刀，布）

输入格式

$x,y$

输出格式

用整数格式输出答案。

样例

$x$	$y$	输出
$0$	$1$	$2$
$0$	$0$	$0$

分析

石头剪刀布这个游戏三人平局只有两种情况（设$z$为第三个人出的）：

$x=y=z$
$x\ne y\ne z$

所以，我们得出如下递推式：
$z=\begin{cases}x & (x=y)\\3-x-y & (x\ne y)\end{cases}$

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 int x, y;
 scanf("%d%d", &x, &y);
 printf("%d\n", x == y? x: 3 - x - y);
 return 0;
}

B - Nuts

有$N$棵树，第$i$棵树上有$A_i$颗果实。
一个人会从第$i$棵树摘下$\max(0,A_i-10)$颗果实。他一共会得到多少果实？

$1\le N,A_i\le 1000$

输入格式

$N$
$A_1~\dots~A_N$

输出格式

输出答案。

样例

样例输入1

样例输出1

1

25

他会从三棵树上分别摘下$0,7,18$颗果实，总共$25$颗。

样例输入2

样例输出2

1

1

他只会从最后一棵树上得到一颗果实。

分析

我们直接按题意模拟即可。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <cstdio>
using namespace std;

int main()
{
 int n, ans = 0;
 scanf("%d", &n);
 while(n--)
 {
 int a;
 scanf("%d", &a);
 if(a > 10) ans += a - 10;
 }
 printf("%d\n", ans);
 return 0;
}

C - Tour

一个国家有编号为$1$至$N$的$N$座城市和编号为$1$至$M$的$M$条路。
第$i$条路从城市$A_i$到$B_i$，且不能用它从城市$B_i$到$A_i$。
一个人想从起点城市开始旅行并走过若干条路（可以不走，即只游玩一个城市）并到达终点城市。
有多少种合法的起点和终点城市？如果$X\ne Y$，则$X\to Y$和$Y\to X$算作两种不同的方案。

$2\le N\le 2000$
$0\le M\le \min(2000,N(N-1))$
$1\le A_i,B_i\le N$
$A_i\ne B_i$
$(A_i,B_i)$互不相同。

输入格式

$N~M$
$A_1~B_1$
$\vdots$
$A_M~B_M$

输出格式

输出答案。

样例

样例输入1

样例输出1

1

7

有七种可行的旅游方案：$1\to1$、$1\to2$、$1\to3$、$2\to2$、$2\to3$、$3\to2$、$3\to3$。

样例输入2

1

3 0

样例输出2

1

3

有三种可行的旅游方案：$1\to1$、$2\to2$、$3\to3$。

分析

我们可以把这个国家看成一个简单有向无权图，并把每个节点作为起点跑一遍$\text{DFS}$，计算总共能到达的结点数即可。
总时间复杂度为$\mathcal O(n^2)$。

代码

注意：每次$\text{DFS}$之前一定要将$\mathrm{vis}$数组清零！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


#include <cstdio>
#include <vector>
#define maxn 2005
using namespace std;

vector<int> G[maxn];
bool vis[maxn];

int ans;

void dfs(int v)
{
 if(vis[v]) return;
 vis[v] = true, ans ++;
 for(int u: G[v])
 dfs(u);
}

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int x, y;
 scanf("%d%d", &x, &y);
 G[--x].push_back(--y);
 }
 ans = 0;
 for(int i=0; i<n; i++)
 {
 for(int j=0; j<n; j++)
 vis[j] = false;
 dfs(i);
 }
 printf("%d\n", ans);
 return 0;
}

D - Cooking

两个人要洗$N$个碗，其中任意一个人洗第$i$个碗需要$T_i$分钟。一个人不能同时洗多个碗。
两个人一起洗碗，洗完所有碗至少需要多少分钟？

$1\le N\le 100$
$1\le T_i\le 10^3$

输入格式

$N$
$T_1~T_2~\dots~T_N$

输出格式

输出答案。

样例

样例输入1

样例输出1

1

13

我们可以让两个人分别洗如下的碗：

第一个人洗编号为$5,1$的碗。总时间为$T_5+T_1=13$分钟。
第二个人洗编号为$2,4,3$的碗。总时间为$T_2+T_4+T_3=10$分钟。

总耗时为$\max(13,10)=13$分钟。

样例输入2

样例输出2

1

1000

样例输入3

1
2


9
3 14 15 9 26 5 35 89 79

样例输出3

1

138

分析

这是一道经典01背包题。
题目可以直接描述为：给定序列$T$，将其分成两个子序列$A$和$B$（不要求连续），求最小的$\min(\sum A,\sum B)$。
这时，我们发现要使$\min(\sum A,\sum B)$最小，由于$\sum A+\sum B=\sum T$，所以$|\sum A-\sum B|$必须也达到最小。
我们可以将$\sum T$分成两半，其中一半为$\lfloor\frac{\sum T}2\rfloor$。这时，我们可以用dp背包解决此题：从$T$中选出一个子序列$A$，使得$\sum A\le\lfloor\frac{\sum T}2\rfloor$，这样答案就为$\sum T-\sum A$。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


#include <cstdio>
#define maxn 105
#define maxv 100005
using namespace std;

int dp[maxv], w[maxn];

inline void setmax(int& x, int y)
{
 if(y > x) x = y;
}

int main()
{
 int n, v = 0;
 scanf("%d", &n);
 for(int i=0; i<n; i++)
 {
 scanf("%d", w + i);
 v += w[i];
 }
 int t = v;
 v >>= 1;
 for(int i=0; i<n; i++)
 for(int j=v; j>=w[i]; j--)
 setmax(dp[j], dp[j - w[i]] + w[i]);
 printf("%d\n", t - dp[v]);
 return 0;
}

E - Rush Hour 2

一个国家有$N$座城市和$M$条路。城市的编号是$1$至$N$，路的编号则为$1$至$M$。第$i$条路双向连接着城市$A_i$和$B_i$。
在这个国家中，初始时间为$0$。如果你在时间点$t$通过公路$i$，所需时间为$C_i+\lfloor\frac {D_i} {t+1}\rfloor$。
一个人想从城市$1$到达城市$N$。他在每个城市可以停留任意自然数的时间。
求这个人最早到达城市$N$的时间。如果无法到达城市$N$，输出-1。

$2\le N\le 10^5$
$2\le M\le 10^5$
$1\le A_i,B_i\le N$
$0\le C_i,D_i\le 10^9$

输入格式

$N~M$
$A_1~B_1~C_1~D_1$
$\vdots$
$A_M~B_M~C_M~D_M$

输出格式

输出答案。

样例

样例输入1

样例输出1

1

4

我们可以先在城市$1$停留至时间$1$。然后，我们出发，最终到达时间$1+2+\lfloor\frac 3 {1+1}\rfloor=4$。

样例输入2

样例输出2

1

3

两个城市之间可能有多条路，一个城市也可能有到自己的路。

样例输入3

样例输出3

1

-1

城市$1$到城市$N$可能没有路径。

分析

我们可以把输入当成一幅无向图。其实，从一个城市到它自己的路根本没有用，所以我们直接忽略不计。
如果目前时间为$T$且我们要从城市$A_i$到$B_i$，我们可以证明，最好的整数出发时间应该是$\lfloor\sqrt D\rceil-1$（$\lfloor x\rceil$表示$x$四舍五入）。
如果$\lfloor\sqrt D\rceil\le T$，我们应该等到时间$\lfloor\sqrt D\rceil-1$再出发；否则，我们直接出发。
这时，我们可以使用Dijkstra最短路算法（使用优先队列优化），这样总时间复杂度就为$\mathcal O(M\log N)$。

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


#include <cstdio>
#include <cmath>
#include <vector>
#include <queue>
#include <tuple>
#define maxn 100005
#define INF 9223372036854775807LL
using namespace std;

using Road = tuple<int, int, int>;
using LL = long long;
using pli = pair<LL, int>;

vector<Road> G[maxn];
LL dist[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int a, b, c, d;
 scanf("%d%d%d%d", &a, &b, &c, &d);
 if(--a == --b) continue;
 G[a].emplace_back(b, c, d);
 G[b].emplace_back(a, c, d);
 }
 dist[0] = 0LL;
 for(int i=1; i<n; i++) dist[i] = INF;
 priority_queue<pli, vector<pli>, greater<pli>> q;
 q.emplace(0LL, 0);
 while(!q.empty())
 {
 auto [t, u] = q.top(); q.pop();
 if(dist[u] != t) continue;
 for(auto [v, c, d]: G[u])
 {
 LL t2 = sqrt((long double) d) - 0.5;
 if(t2 < t) t2 = t;
 t2 += LL(c) + LL(d) / (t2 + 1LL);
 if(t2 < dist[v])
 q.emplace(dist[v] = t2, v);
 }
 }
 if(dist[n - 1] == INF) puts("-1");
 else printf("%lld\n", dist[n - 1]);
 return 0;
}

Posts on GoodCoder's Blog

katac4: 基于 AlphaZero 的强化学习探索

前言

AlphaZero 速览

训练，退火

算法优化

梯度累加

动作空间剪枝

First Play Urgency (FPU)

模拟上限随机化

强制探索 & 策略剪枝

动态经验回放池

蒙特卡洛图搜索（MCGS）

工程优化

并行自对弈

CUDA Graphs

测试结果

后续改进方向

拓展阅读

Mathematica 入门

前言

界面

语法

帮助文档

注释

括号

圆括号 ()

方括号 []

大括号 {}

双方括号 [[]]

运算与表达式

布尔表达式

变量与常数

函数

调用

定义

内置函数

数值运算 N

三角函数

解方程和不等式 Solve/Reduce

解方程的其他方法 NSolve/FindInstance

极点值 Maximize/Minimize

偏导 D

积分 Integrate

展开 Expand/ExpandAll

因式分解 Factor

绘图 Plot/Plot3D

总结

UNIQUE VISION Programming Contest 2023 Christmas (AtCoder Beginner Contest 334) A~G 题解

题目大意

分析

代码

题目大意

分析

代码

题目大意

分析

代码

题目大意

分析

代码

题目大意

分析

代码

题目大意

分析

代码

实现 1：deque + multiset

实现 2：单调队列

题目大意

分析

代码

后记

洛谷 P9754 [CSP-S 2023] 结构体 题解

基本思路

分步详解

准备

数据类型的存储

操作 1：定义类型

操作 2：定义元素

圆括号 `()`

方括号 `[]`

大括号 `{}`

双方括号 `[[]]`

洛谷 P9754 [CSP-S 2023] 结构体题解