对于每一个点进行一遍 Dijkstra 是不可接受的，考虑点分治处理。
我们按照点分治的方式递归处理一个询问，假设当前递归到的分治中心是 $c$，询问的两点是 $u,v$，那么我们就要为最短路径分类。所有的最短路径可以分为三类：
$$d(u,v)=\min_{i=1}^{s}\left(d(p_i,u)+d(p_i,v)\right)$$
但是时间瓶颈是由子树个数 $s$ 决定的，因为我们对每一个分治重心都要跑 $s+1$ 遍 Dijkstra。根据题目条件，容易想到对整棵树进行三度化。此时对每一个分治重心只需最多跑 $4$ 遍 Dijkstra，而三度化最多只会新增 $n$ 个节点，所以总结点数仍是 $O(n)$ 的。
实际上分治时可以将所有询问离散化，在每次分治时一并处理，可以省很多空间。在递归时如果某个子树没有询问了，就不要向下递归，这样剪枝可以节省很多时间。
时间复杂度 $O(n\log^2n)$。
1 | const int inf = 0x3f3f3f3f3f3f3f3fll; |
考虑构造约束图。当前进行到第 $i$ 轮，当前还未被淘汰掉的点有 $u_1,u_2,\dots,u_k$，这里考虑进行到偶数轮，奇数轮是这种情况的对称。如果点 $u_i$ 在当前论中没被淘汰，那么一定有 $u_i>u_{i-1}$ 且 $u_i>u_{i+1}$，所以连接 $u_i\to u_{i-1}$ 和 $u_i\to u_{i+1}$。如果点 $u_i$ 在当前论中被淘汰了，若其左右没被淘汰，那么大小关系一定是确定的，不用考虑。如果有一个连通块 $u_l,u_{l+1}，\dots,u_r$，所有的点在这一轮中都是要淘汰的，那么就需要手动确定一组大小关系来满足条件，连通块内的点只能全部用 $<$ 或 $>$ 连接。若 $u_l=u_1$，那么只能有 $u_l<u_{l+1}<\dots<u_r$，否则若 $u_1>u_2$ 时 $u_1$ 就不会被淘汰了。同理，若 $u_r=u_k$，那么只能有 $u_l>u_{l+1}>\dots>u_r$。一般情况下 $u_l<u_{l+1}<\dots<u_r$ 和 $u_l>u_{l+1}>\dots>u_r$ 都是可行的，随便选择一组连接即可。
时间复杂度 $O(n)$。
]]>首先我们考虑有一个确定的序列 $X$，其是否能与序列 $A$ 通过一样的按法按出来的 DP 怎么做？定义两个序列能通过一样的按法为两个序列是否匹配，那么我们用 $f_i$ 表示 $A$ 与 $X$ 的前 $i$ 项是否匹配，转移很简单，我们判断最后 $1/2/4$ 位是否能匹配，与之前的答案相拼即可。
下面考虑设计状态。一个数的匹配状态显然最多只和前面三个数是什么有关，所以我们定义 $F_{i,a,b,c,p_1,p_2,p_3,p_4}$ 表示倒数的三个数分别是 $a,b,c$ 且倒数的四个位置的 $f$ 值分别是 $p_1,p_2,p_3,p_4$ 的方案数。对于 $F_i$ 来说，我们枚举第 $i+1$ 个数是什么，并判断 $[i-2,i+1]$ 或 $[i,i+1]$ 或 $i+1$ 这几个区间能否匹配且前面的那一部分是否匹配来决定新的 $p_4$ 的值。这样转移我们考虑的是每一个新数的值是什么，显然这样计数是不重不漏的。
具体地，转移显然是由 $F_{i,a,b,c,p_1,p_2,p_3,p_4}$ 向 $F_{i+1,b,c,d,p_2,p_3,p_4,p^{\prime}}$ 的。显然有下式：$$F_{i,a,b,c,p_1,p_2,p_3,p_4}\rightarrow F_{i+1,b,c,d,p_2,p_3,p_4,p^{\prime}}$$$p^{\prime}=1$ 成立条件如下：$$p^{\prime} = 1 \iff\begin{aligned}& [i-2,i+1]\text{ is valid } \land p_1=1 & \text{(1)} \\\lor\ & [i,i+1]\text{ is valid } \land p_3=1 & \text{(2)} \\\lor\ & d=a_{i+1} \land p_4=1 & \text{(3)}\end{aligned}$$$[L,R]\text{ is valid}$ 表示区间 $[L,R]$ 是否能与 $A$ 序列相应区间匹配。
这样 DP 的状态时间复杂度为 $O(n)$，但是对于每一个 $i$ 来说，枚举状态有 $9^3\times2^4$ 种，转移时要枚举 $9$ 个数。这样常数太大（比 $n$ 都大了），考虑减少状态数。
其实在 $9^3\times2^4$ 种状态中，有很多状态向后转移的效果是一样的，所以我们可以合并且少枚举一些状态，这样会大大减少转移常数。考虑决定 $p^{\prime}$ 的三个条件：$$\begin{aligned}& [i-2,i+1]\text{ is valid } \land p_1=1 & \text{(1)} \\& [i,i+1]\text{ is valid } \land p_3=1 & \text{(2)} \\& d=a_{i+1} \land p_4=1 & \text{(3)}\end{aligned}$$先从 $p$ 的角度考虑。如果 $p_1=0$，此时条件 $(1)$ 肯定不能满足了，那么无论 $a$ 是多少，向后转移的结果都是一样的，所以不用记录 $a$ 了。如果 $p_1=p_2=0$，那么最早为 $1$ 的位置是 $p_3$，这是只有条件 $(2)$ 和 $(3)$ 能被满足，同理 $b$ 也没有记录的必要了。如果 $p_1=p_2=p_3=0$，那么只有条件 $(3)$ 有满足的可能，$c$ 也没有记录的必要了。然后从区间匹配的角度去考虑。如果 $(a,b,c)$ 与任意的 $d$ 都不能匹配，$p_1$ 和 $a$ 就没有记录的必要了。同理，如果 $(b,c)$ 与任意的 $(d,e)$ 都不能匹配，同理 $p_2$ 和 $b$ 也就没有记录的必要了。这样状态最多只有 $150$ 种左右，足够通过此题。
在实现代码时，我们可以用unordered_map存储每一个状态，对于每一个 $i$，枚举 $i+1$ 那一位的值并判断新的 $p_4$ 是否合法来写出新的状态，再对其进行剪枝处理合并状态。注意到 $F_i$ 只会转移到 $F_{i+1}$，所以我们使用滚动数组存储 $F_i$，这样大大减少了使用的空间。
相对于普通的 LIS 计数，我们不仅需要考虑 LIS 的长度，还需要让护卫的编号（以下定义为“关键数字”）在原序列中单调递增地出现。如何根据这两个限制来定义状态呢？
有一种求 LIS 的方式：定义一个集合 $S$，初始时 $S=\varnothing$，对于每一个 $a_i$，如果 $S$ 中存在最小的 $x$ 使得 $x>a_i$，那么删去 $x$ 加入 $a_i$，否则直接加入 $a_i$，最终 $|S|$ 即为 LIS。
我们可以根据这种方式设计 dp 状态。定义 $dp_{S,T}$ 表示当前已经考虑了 $S$ 中的数，在集合中的数有 $T$，的方案数。这样定义状态数时我们可以用 $|T|$ 限制 LIS 的长度。在转移的时候，我们统计一下 $S$ 中出现了几个关键数字，在加入新的数字的时候判断一下是否是关键数字，如果是的话只能加入第一个没出现的，这样就能考虑到关键数字顺序的限制。
下面分析时间复杂度。由于 $T\subseteq S$，所以枚举状态时间复杂度是 $O(3^n)$ 的，转移的时候枚举新加入的数时间复杂度是 $O(n)$ 的，所以总时间复杂度为 $O(n3^n)$。在实现的时候用unordered_map存储子集状态就可以了，在实现时需稍微注意一下常数。
代码实现可以参考。
1 | int a[20], sp[20]; |
由于题目让我们求在树的子图中最长的蜈蚣图的长度，所以容易想到要用树形 dp 解决。我们定义一个蜈蚣图的身体为其中间的链，腿为和中间链连接的两个点。对于一个身体上的点来说，腿与其有两种连接方式，一种是选取两个子节点作为腿，一种是选取一个子节点和父节点作为腿。设当前考虑的节点为 $u$，如果选择了 $fa_u$，那么蜈蚣的身体就不能再向 $fa_u$ 及其祖先转移。所以我们定义 $f_{u,0}$ 表示以 $u$ 为蜈蚣的身体上端点而且不选 $fa_u$ 最为腿的最大长度，而 $f_{u,1}$ 则是选 $fa_u$ 最为腿的最大长度。然而我们发现身体端点不一定所有身体节点的祖先，所以我们定义 $g_u$ 表示以 $u$ 为身体中点的最大长度。
下面我们考虑如何转移。
若 $v$ 是 $u$ 的儿子，我们定义最大的 $f_{v,0}$ 叫 $w_0$，次大的 $f_{v,0}$ 叫 $w_1$，其儿子个数为 $n_u$。那么有以下几种转移。$$f_{u,0}=\max(f_{u,0},w_0+1),n_u\geq3$$
$$f_{u,1}=\max(f_{u,1},w_0+1),n_u\geq2\land u\neq root$$
当然，如果 $u$ 作为蜈蚣的身体下端点的话，则有如下转移：$$f_{u,0}=\max(f_{u,0},1),n_u\geq2$$
$$f_{u,1}=\max(f_{u,1},1),n_u\geq1\land u\neq root$$
那么拼接两个蜈蚣的情况如下：$$g_u=\max(g_u,w_0+w_1+1),n_u\geq4 \lor (n_u\geq3\land u\neq root)$$最后的答案如下：$$ans=\max_{u=1}^n\left(\max(f_{u,0},f_{u,1},g_u)\right)$$
时间复杂度 $O(n)$。
1 | int n; |
我们容易注意到，每进行完一次连发之后，两个炮都要重新进入一轮冷却，相当于我们面对的是一个血量更少的敌人，这构成了一个新的子问题。我们只需要考虑在打掉怪物多少血量的时候连发，可以让总时间最小。这显然是一个 dp 问题，定义 $f_i$ 表示只能连发一次并且打掉 $i$ 的血量所需要的最小时间，$g_i$ 表示连发多次并且打掉 $i$ 的血量所需要的最小时间。容易得到 dp 方程如下：
$$g_i = \min_{j < i}\lbrace g_j + f _{i - j}\rbrace$$
对于 $f_i$ 我们二分枚举所需时间，这样更方便一些。
但是有一种情况，一个炮冷却时间特别长，所以连发不如单个打划算。我们在二分的时候把这种情况考虑一下就行。
1 |
|
因此，我们考虑：假设第 $i$ 个位置的匹配数是 $suc_i$，那么我们能不能把区间 $[l, r]$ 的匹配数转化成 $suc_r - suc_l$ 这样的形式？大体可行，但是有一些情况我们需要处理。
我们询问的区间是 $[l, r]$，有一个匹配成功的字符串 $[x, y]$，如果 $1 \leq x < l \leq y \leq r $ 那么 $[x, y]$ 显然是被多算的。我们要排除这种影响。
定义 $sl_i$ 表示在第 $i$ 位结尾的所有匹配中的起始点（这个值可以用 fail 树随便维护一下），如果 $sl_i < l$，那么存在多算的匹配。如果我们找到 $[l, r]$ 中最大的使得 $sl_i < l$ 的 $i$，记作 $m$，那么在第 $[m + 1, r]$ 位之间结尾的匹配一定不会多算，所以直接加上 $suc_r - suc_m$。$m$ 我们可以离线二分或者在线的线段树二分维护。
接下来处理 $[l, m]$ 之间的匹配。根据刚才的条件，我们一定存在一个模式串，使得 $[l, m]$ 一定是这个模式串的后缀，所以相当于我们要求出来每一个模式串后缀的匹配数。我们把所有模式串的反串扔到一个 AC 自动机上，对于每一个模式串倒着匹配一遍，就可以以 $\sum |s_i|$ 的复杂度求出每一个模式串的后缀匹配数。把这部分的答案加上就好。
代码如下：
1 | // By 0x0F |
ps：写得有点烂，请多多包涵。
]]>首先我们考虑按位或的性质。
假设有一个 0/1 数组。由性质得，如果一个区间只要存在 1，那么这个区间的贡献就是 1。定义 $f_i$ 表示以 $i$ 结尾的所有区间的贡献和，所以 $f_i$ 显然就是间 $[1,i]$ 中最后一个 1 出现的位置，答案就是 $\sum f_i$。回到原题，我们会很容易想到把每一个数拆位来计算贡献，对于每一位，从头到尾跑一遍。注意其实 $a_i$ 和 $f_i$ 其实没必要存下来，就可以省下来空间。时间复杂度 $O(n \log V)$，会拿到 30pts 的好成绩。
代码如下：
1 | using namespace READ; |
我们考虑优化。首先定义 $l_i$ 表示当前位置第 $i$ 个数位最后一个 1 出现的位置，那么对于当前这个位置的答案就是 $\sum 2^i \times lst_i$。我们发现拆数位比拆位置的位数多很多，那我们为什么不拆位置呢？所以我们定义 $c_i$ 表示位置二进制拆分后第 $i$ 位为 1 的每一个数位是否存在最后一个 1 的情况。我们发现按照状压的方法存，$c_i$ 天然地帮我们乘好了每一个数位的系数。最终这个位置的答案就是 $\sum 2^i \times c_i$（注意这里的 $i$ 表示拆分的位置，而不是数位）。
我们考虑怎么维护 $c_i$？过程可以分成两步，一步是删去新加数的数位上原来的贡献，一步是加上现在的贡献。假设当前位置上的值是 $x$，第一步给每一个 $c_i$ 执行 $c_i \leftarrow c_i \land \overline{x}$，第二步对于拆分位置后是 1 的 $c_i$ 执行 $c_i \leftarrow c_i \lor x$，最后把答案合并算一下就行了。满分代码如下：
1 | using namespace READ; |
时间复杂度 $O(n \log n)$，这个数据范围虽然看着十分恐怖，但是实际上只需要 1s 左右，跑得飞快。
]]>一种 vector<int>, vector<int> 的 map 做法，代码稍长一些但是特别好想。
先考虑 $k = 1$ 时的做法，后面 $k$ 增大时在原基础上改动一点就可以了。
看到左右括号，我们容易想到遇到左括号加 $1$，右括号减 $1$，记第到 $i$ 个位置的前缀和为 $sum_i$。显然，区间 $[l,r]$ 若是合法的，必须满足以下条件：
用数学的形式表达，就是：
移项，得：
我们分开考虑每个条件。
若假设 $l$ 为当前计算区间的左端点，那么若存在一点 $i$ 满足 $sum_i < sum_{l - 1}$ 且 $i \geq l$，那么 $i$ 以及后面的所有点和 $l$ 所构成的区间都是不合法的。那么我们找到 $l$ 右边第一个比 $sum_{l - 1}$ 小的位置 $R$（可以用单调栈预处理），那么 $R$ 以前的位置都可能合法。条件二的限制就解决了。结合条件一，我们预处理每个 $sum$ 值都出现过的坐标，用 vector 存起来排序，在 $sum_{l - 1}$ 查找 $[i, R - 1]$ 之间有几个坐标，加到答案即可。
对于增加的 $k$，$R$ 取 $k$ 个数里的最小值，由于 $k \leq 10$，我们直接把 $k$ 个 $sum$ 放到一个 vector 里并做成 map，每次用 vector 查就好了，自己想想就清楚了。
时间复杂度 $O(nk \log n)$。
1 | // By 0x0F |
首先我们根据贪心的策略，很容易想出来一定要把最上边的那一行和最左边的那一列全部连起来，剩下的点连向左边或者上边就可以了。$O(n ^ 2)$ 的暴力做法就是枚举每个点是连向左边还是上边，直接加上每个点的贡献就可以了。
对于 $O(n \log n)$ 的做法，我们就不能挨个考虑每个点连接的方向了。我们进而分析每个点连接的方向和数组 $a, b, c, d$ 的关系。显然，我们选择连上面而不是左边时，满足：
$$a_{i - 1} + b_j < c_i + d_{j - 1}$$
移项，得
$$a_{i - 1} - c_i < d_{j - 1} - b_j$$
即
$$d_{j - 1} - b_j > a_{i - 1} - c_i$$
而对于每一行来说，$a_{i - 1} - c_i$ 是固定不变的。所以我们可以预处理好 $d_{j - 1} - b_j$ 的值，记作 $diff$，每次在 $diff$ 上二分 $a_{i - 1} - c_i$ 的值，这个值右边的所有数就是连向上面的，左边的所有数就是连向左边的，进而我们可以求出连向上面和左边的点的个数，分别记作 $n_U$ 和 $n_L$。
对于计算贡献，我们可以把 $a, c$ 和 $b, d$ 分开考虑。$a, c$ 的计算比较简单，我们只需要加上 $n_U$ 个 $a_{i - 1}$ 和 $n_L$ 个 $c_i$。$b, d$ 的处理比较麻烦一些，我们可以把 $b_j, d_{j - 1}, d_{j - 1} - b_j$，放在一个结构体里，按照 $diff$ 值排序之后，对 $b$ 和 $d$ 做前缀和，二分位置前的加上 $d$，位置后的加上 $b$ 就可以了，当然也有其他的方法，这里就不多说了。
代码实现时需要注意一点小细节，自己想想就明白了。
]]>本题需要模拟一个链表，考虑需要加入时需要知道一个点的后继，删除时需要知道一个点的前驱和后继，所以我们采用双向链表维护。用数组维护每个点的前驱和后继。由于值域是 $10^9$ 的，所以我们采用map维护。
首先考虑构建链表。我们把序列中的点顺次放入链表中，具体地说，对于每个点 $a_i$，它的前驱是 $a_{i-1}$，后继是 $a_{i+1}$。特别地，我们建立两个虚拟节点，分别作为 $a_1$ 的前驱和 $a_n$ 的后继。
考虑添加点。我们很容易得知要添加点的左右两个点 $L$ 和 $R$，设添加的点为 $X$，对于后继，把 $L$ 的后继连向 $X$，$X$ 的后继连向 $R$，前驱同理，如图所示：
考虑删除。我们很容易得知要删除点的左右两个点 $L$ 和 $R$，把 $L$ 的后继连向 $R$，$R$ 的前驱连向 $L$ 如图所示：
最后从最左边的虚拟点开始，向右寻找后继输出，直至寻找到最右边的点，输出结束。
时间复杂度 $O(n \log n)$。
1 | // By 0x0F |
首先转换一下题意。
对于 $a_i$ 和 $a_j$，满足 $a_i + a_j$ 可被 $x$ 整除，也就是满足 $a_i + a_j \equiv 0 \pmod{x}$，两边同时减 $a_j$，得 $a_i \equiv -a_j \pmod{x}$，即 $a_j \equiv -a_i \pmod{x}$；满足 $a_i - a_j$ 可被 $y$ 整除，也就是满足 $a_i - a_j \equiv 0 \pmod{y}$，两边同时加 $a_j$，得 $a_i \equiv a_j \pmod{y}$。
有一个问题，就是处理 $-a_i \mod x$ 的方法。显然 $a_i \equiv x-a_i \mod x \pmod{x}$，所以使用 $(x-a_i \mod x) \mod x$ 来处理。
开个map数组，以每个数模 $x$ 和模 $i$ 的值作为下标，对于每个数 $a_i$，其对应的答案就是 $mp_{-a_i \mod x,a_i \mod y}$。
1 | // By 0x0F |
设设个序列为 $S$，如果有一个位置 $i$ 满足 $S_i=S_{i-1}$，那么把 $i$ 的位置记录下来（也就是说记录两个数相同的位置），由于数据范围是 $5 \times 10^5$ 的，所以把位置可以用bool数组存下来，查询时如果 $[l+1,r]$ 内没有被标记的位置，就是合法的，否则是不合法的，我们可以用线段树维护这个数组。
对于修改，显然修改后区间内数的相对关系是不会改变的，修改区间外数的相对关系当然也不会改变，可能改变的只有 $[l-1,l]$ 和 $[r,r+1]$，所以我们只需要从新判断这两个位置的数的关系是相同的还是不同的，并作出修改就好了。
如何得知修改后每个数是 $0$ 还是 $1$？我们可以维护一下每个数字被取反了几次，修改时区间加上 $1$，设这个数被取反了 $k$ 次，原始的值是 $0/1$，那么查询就是 $(k\mod 2 + 0/1) \mod 2$。区间加、单点查询用差分就可以维护。
时间复杂度 $O(Q \log N)$。
1 | // By 0x0F |
关于本题单调性的证明：因为显示器的宽度越大，一行能显示的宽度越多，所以显示需要的行数越少（单词总量不变）。所以显示器的宽度和显示需要的行数具有单调递减的关系，所以可以使用二分。
二分枚举显示器的宽度 $w$，然后计算以 $w$ 为宽度显示单词需要的最少行数，如果需要的行数小于等于 $m$，则符合要求，否则不符合要求。
怎么计算呢？
如果显示器的宽度 $w$ 小于单词的最大宽度 $mw$，说明一个单词都无法放进显示器中，显然是不符合要求的。
令 $sum$ 表示当前行已经用了多少宽度，$cnt$ 表示当前用了多少行，一次枚举单词的长度 $l_i$，如果当前宽度加上一个空格和 $l_i$ 的长度大于 $w$，说明当前行已经放不下这个单词了，需要新开一行，让 $cnt$ 加 $1$，并且让 $sum$ 等于 $l_i$，否则 $sum$ 加上 $l_i$ 和一个空格的长度。
时间复杂度：二分的复杂度是 $O(\log n)$，计算一遍的复杂度是 $O(n)$，整体时间复杂度 $O(n \log n)$。
1 |
|
枚举左上角坐标 $(x_1,y_1)$ 和右上角坐标 $(x_2,y_2)$ ，然后用二维前缀和判断一下有没有沼泽地，最后算一下面积，取最大值 就是答案。
时间复杂度 $O(n^4)$ ，很明显会超时。
暴力代码：
1 |
|
我们可以枚举一个矩形的两列竖边 $l_1$ 和 $l_2$ ，然后枚举所有在 $[l_1,l_2]$ 间没有沼泽的横边，处理出来放到一个数组 $q$ 里，如图
我们已经保证横边没有沼泽了，我们还需要找出两条横边，且两条横边夹着的两条竖边间没有沼泽，这样就能求出矩形的面积，然后取最大值。
问题是我们要找出两条横边并且是复杂度是 $O(n)$ 的，怎么找？
定义两个指针 $p_1$ 和 $p_2$ ，遍历一下数组 $q$ ，令当前下标为 $i$ ，让 $p_2$ 等于 $i$ ，如果 $p_1$ 到 $p_2$ 间有沼泽，令 $p_1$ 等于 $p_2$ ，否则不变，计算此时的面积，取最大值。
关于这样做正确性证明：如果能走到 $[p_1,p_2-1]$ 这里，那么 $[p_1,p_2-1]$ 之间肯定是没有沼泽的，如果在 $[p_1,p_2]$ 间发现了沼泽，那么沼泽肯定是在 $[p_{2}-1,p_2]$ 之间的，也就是说区间想以 $p_2$ 结尾，开头肯定只能从 $p_2$ 开始。
时间复杂度 $O(n^3)$ 。
1 |
|
首先我们思考朴素的 dp 方程。
首先定义 $dp_i$，表示当前最后一个分区是以 $i$ 结尾时均势区和更赛牛较多区的和的最小值。
然后我们定义 $cnt_i$ 表示 $[1,i]$ 范围内更赛牛减荷斯坦牛的数量，所以 $[l,r]$ 范围内更赛牛减荷斯坦牛的数量就是 $cnt_r - cnt_{l-1}$，在读入时只需要碰到字符 G 加 $1$，碰到字符 H 减 $1$ 就可以了。
我们假设倒数第二个区间是以 $j$ 结尾的，则最后一个区间的范围是 $[j+1,i]$。由于一个区间的长度大于 $1$ 小于 $k$，所以 $j$ 的范围是从 $i-k$ 到 $i-1$。枚举每一个 $j$，如果 $sum_i-sum_j\geqslant0$，也就是说 $[j+1,i]$ 这个区间是一个均势区或更赛牛较多区，$dp_i=dp_j+1$，否则这不是均势区或更赛牛较多区，$dp_i=dp_j$，最后对所有的 $j$ 转移来的情况区最小值，方程如下：
$$dp_i=\min\limits_{j=i-k}^{i-1} \begin{cases}dp_j+1&sum_i-sum_j\geqslant0\dp_j&sum_i-sum_j <0\end{cases}$$
时间复杂度 $\mathcal{O}(nk)$。
很显然，这样一定会 TLE。
我们从状态转移处下手。由于每次转移的范围 $k$ 是固定的，所以没必要一个一个枚举 $j$，而可以用单调队列维护这段转移区间。队列内部存放决策的下标 $j$。
设 $f$ 为当前队首的值， $b$ 为当前队尾的值，则转移分三步：
如果 $i - f > k$ 且队列不为空，说明它超过了长度限制，不能从这里转移来，从队首弹出。循环弹出所有过期的。
转移 $dp_i$ 时，从 $dp_f$ 转移来，这时是最优的。
循环从队尾弹出过期时间早且不够优秀的。
什么叫“不够优秀”？
第一种情况，如果 $dp_b > dp_i$，那么从 $dp_b$ 转移不如 $dp_i$，弹出；第二种情况，如果 $dp_b = dp_i$，但是 $sum_i - sum_j \geqslant 0$，转移时需要加上 $1$，这样最多和 $dp_i$ 转移答案相同，或不及 $dp_i$，且比 $dp_i$ 过期得早，弹出。
核心代码如下：
1 | while(!q.empty()&&i-q.front()>k)q.pop_front(); |
时间复杂度 $\mathcal{O}(n)$ 。
1 |
|
你需要求出有多少整数可能成为 $b$ 的众数。
想表达的意思应该是
你需要求出有多少种数可能成为 $b$ 的众数。
吧。
所以你输出的是能成为众数的种类数，而不是个数。
这里我提供一种贪心的做法。
首先只需维护出每一种数出现的次数（因为题目只关心可能成为众数的数的数量）。
接下来我们思考怎样一种数才可能成为众数。
经过 $k$ 次修改以后，一种数只有在被修改后出现次数大于等于被修改后出现次数最大的那种数的出现次数时才可以成为众数。
那么每一次修改是什么呢？
想要让第 $i$ 种数成为众数，对于每一次修改，我们将除了第 $i$ 种数外的一个数修改为第 $i$ 种数。这样就让第 $i$ 种数出现的次数 $+1$ ，让除了第 $i$ 种数外的一种数出现的次数 $-1$ 。不难想到，这样可以让第 $i$ 种数出现的次数最大。
具体来说，设第 $i$ 种数出现的次数为 $v_i$ ，那么它在被操作 $k$ 次后出现的次数为 $v_i+k$ ，设经过操作后的最大出现次数为 $x$ ，那么第 $i$ 种数能成为众数的条件是：
$$v_i+k \geq x$$
因为 $v_i+k$ 已经确定了，所以想让成为众数的数尽可能多，就要让 $x$ 最小。
怎么让 $x$ 最小呢？
我们让当前一个最大的出现次数 $-1$ ，然后把它放回原数列，再找到当前一个最大的出现次数，如此操作 $k$ 次就可以了。
比如一个数组 $v=[1,2,3,5,4,3]$ ，经过 $5$ 次操作后的状态如下：
第一次操作：
$$[1,2,3,4,4,3]$$
第二次操作：
$$[1,2,3,3,4,3]$$
第三次操作：
$$[1,2,3,3,3,3]$$
第四次操作：
$$[1,2,2,3,3,3]$$
第五次操作：
$$[1,2,2,2,3,3]$$
由于每次都要取出其中的最大值，所以这个问题刚好可以用大根堆（优先队列）来解决。每次操作取出堆顶，将其 $-1$ ，然后丢回堆里面。
核心代码如下：
1 | priority_queue<int>q; |
由于堆每次操作的复杂度为 $O(\log n)$ ，$k$ 次操作的复杂度就是 $O(k \log n)$ ，也就是 $O(n \log n)$ ，在 $10^6$ 的数据下可以通过。
最后一个问题，怎么处理无限多种数可以成为众数的情况？
如果经过操作后的最大出现次数 $x \leq k$ 时，也就是说任意一个数操作 $k$ 次都能修改成众数，自然答案就是无限了。
1 |
|
我们定义两个变量 $cnt1$ $cnt2$，分别用于记录上一个连续 $0/1$ 区间的长度和这一个连续 $0/1$ 区间的长度。只要这个连续区间的长度不等于上个区间的长度，那么直接输出NO，然后return 0就可以了(因为这里不一样后面就无需判断，这是一个小优化)。如果相等，那么 $cnt2$ 清零，重新计算新的连续区间的长度，以此类推计算就可以了。
那么这个过程怎么实现呢？
对于代码实现来说，对于当前的 $a_i$ 来说，分两种情况：
如果 $a_i$ 等于 $a_{i-1}$ ，那么说明还在当前的区间中，那么 $cnt2+1$ ，长度加 $1$ 。
如果 $a_i$ 不等于 $a_{i-1}$ ，那么按照上面的思路判断就可以了。
这里需要注意一些细节：加一个特判，判断 $cnt1$ 是不是 $0$ ，并在cnt2=1前面把 $cnt1$ 修改为 $cnt2$ ，就可以了。然后把 $a_{n+1}$ 赋值为 $2$ ，循环到 $n+1$ 就可以处理最后一次的问题。
ps：一定要从 $2$ 开始循环，要不然会出问题，为什么呢？
因为从 $1$ 开始循环，那么 $a_0$ 的值始终是 $0$ ，我们无法确定 $a_1$ 是零是一，这样就会造成 $cnt$ 错误。
如果大家还是看的不清楚，可以看代码里的注释。
1 | a[n+1]=2; |
这个写法应该是目前特判比较少的解法了吧。
]]>这道题不难，主要考察的是数学知识。
首先我们都知道，两点之间线段最短，如下图所示：
这个距离很好求，我们把 $A$ 点和 $B$ 所在的轴画出来，如下图所示：
很容易看出来这三条线构成了一个直角三角形。根据勾股定理，我们就求出了距离公式，如下：
$$\large{dis(i,j)=\sqrt{(x_i-x_j)^2 + (y_i-y_j)^2}}$$
这个距离公式也是现在最常用的距离公式。
切比雪夫距离用于解决格点上的距离问题。这类问题只能向自己点的上、下、左、右、左上、左下、右上、右下方向走。
在这个问题中，每走一个斜线和走一个直线的距离相同。那我们想要距离最短，那就按照欧几里得距离的思想，尽量先走斜线到对方的横坐标上，在走直线到达对方的点，如下图所示：
这就是当前问题下的最短距离。
那么怎么算出距离呢？
因为棋盘的性质，走一个斜线等于走一个直线的距离，所以只需要求出两边距离的最大值就可以了。公式如下：
$$\large{dis(i,j)=\max(|x_i-x_j|,|y_i-y_j|)}$$
按照本题的题意，此题为切比雪夫距离。
]]>这里介绍两个函数，reverse()和to_string()。
to_string()是在 C++11 中新加入的函数，定义于<string>头文件中。用法为to_string(val)，其中val可以是int,long,long long,unsigned int,unsigned long long,fload,double,long double类型。其作用是将数字转换成字符串。
reverse()函数是一个可以翻转数组，string，vector等数据结构的函数，定义于<algorithm>头文件中。用法为reverse(p1,p2)，p1为前指针，p2为后指针。
1 | reverse(array,array+a_length) //数组 |
明白之后代码就简单多了。
1 |
|