2017 Multi-University Training Contest 1 solutions BY 北京航空航天大学

转自 http://bestcoder.hdu.edu.cn/blog/

1001. Add More Zero

答案就是 ⌊log10(2m−1)⌋\left \lfloor \log_{10}(2^m - 1) \right \rfloor，注意到不存在 10k=2m10^k = 2^m ，所以⌊log10(2m−1)⌋=⌊log102m⌋=⌊mlog102⌋\left \lfloor \log_{10}(2^m - 1) \right \rfloor = \left \lfloor \log_{10}{2^m} \right \rfloor = \left \lfloor m \log_{10}{2} \right \rfloor，这样做的时间复杂度是 O(1) 。

1002. Balala Power!

每个字符对答案的贡献都可以看作一个 26 进制的数字，问题相当于要给这些贡献加一个 0 到 25 的权重使得答案最大。最大的数匹配 25，次大的数匹配 24，依次类推。排序后这样依次贪心即可，唯一注意的是不能出现前导 0。

1003. Colorful Tree

单独考虑每一种颜色，答案就是对于每种颜色至少经过一次这种的路径条数之和。反过来思考只需要求有多少条路径没有经过这种颜色即可。直接做可以采用虚树的思想（不用真正建出来），对每种颜色的点按照 dfs 序列排个序，就能求出这些点把原来的树划分成的块的大小。这个过程实际上可以直接一次 dfs 求出。

1004. Division Game

显然每个石子堆最多做 ∑mi=1ei\sum_{i = 1}^{m}{e_i} （记为 ww ）次操作。此外，如果定义一个堆做 xx 次操作恰好变为 11 的方案数为 f(x)f(x) ，显然每个数字做少于 xx 次操作不变为 11 的方案数也是 f(x)f(x) 。

为了统计结束于石子堆 ii 的情况数，我们可以枚举这是它第几次操作时结束的，不妨设为 xx ，则对应的方案数恰好是 f(x+1)i−1f(x)k−i+1f(x + 1)^{i - 1} f(x)^{k - i + 1} ，因为编号小于等于 ii 的石子堆做了 xx 次操作不变为，其他石子堆做 x−1x - 1 次操作恰好变为 11 ，且只有石子堆 ii 变成了一个石子。因此我们在 O(w k) 时间复杂度下将问题规约到 f(x)f(x) 的计算。

我们可以基于一个数的不同质因子几乎互不影响的观察得到第一个结论。每次操作保证任何一个 eie_i (ei>;0)(e_i \gt; 0) 可以减少且至少一个 eie_i 会减少。自然而然我们可以发现一个容斥关系。

考虑 f(x)f(x) 的组成，不妨设在某种方案中第 jj 次操作使 eie_i 减少了 d(i,j)d(i, j) （非负值）。我们知道对于每个 eie_i 有 ∑xj=1d(i,j)=ei\sum_{j = 1}^{x}{d(i, j)} = e_i ，且对于每个 jj 有 ∑mi=1d(i,j)>;0\sum_{i = 1}^{m}{d(i, j)} \gt; 0 。进一步我们能发现 f(x)f(x) 也就是分配 d(i,j)d(i, j) (1≤i≤m,1≤j≤x)(1 \leq i \leq m, 1 \leq j \leq x) 使其满足上述两个条件的方案数。

假设只满足第一个条件的相应方案数为 g(x)g(x) ，我们可以发现每个 ii 分别对应一个组合问题，从而是有 g(x)=∏i=1m(ei+x−1x−1)\displaystyle g(x) = \prod_{i = 1}^{m}{e_i + x - 1 \choose x - 1} 。

我们也可以观察到如果某些 jj 与第二个条件产生了矛盾，与之相关的 d(i,j)d(i, j) 都会是零。利用容斥原理可以得到 f(x)=∑y=0x(−1)x−y(xy)g(y)\displaystyle f(x) = \sum_{y = 0}^{x}{(-1)^{x - y} {x \choose y} g(y)} 。这个式子可以化为一个卷积式子 f(x)x!=∑y=0x(−1)x−y(x−y)!⋅g(y)y!\displaystyle \frac{f(x)}{x!} = \sum_{y = 0}^{x}{\frac{(-1)^{x - y}}{(x - y)!} \cdot \frac{g(y)}{y!}} 。因此你可以用一些方法来加速卷积，不过 985661441=235×222+1985661441 = 235 \times 2^{22} + 1 是一个特殊的质数，所以我们推荐使用 NTT 。

总时间复杂度为 O(w m + wlognw \log n + w k)，然而实现上谨慎一些也是很有必要的。

1005. Expectation Division

解决这道题需要观察到一些比较经典的结论。在分析前我们先两组与题目相关的定义：对于任意正整数的质因子分解 n=∏ki=1peiin = \prod_{i = 1}^{k}{p_i^{e_i}} ，定义 ω(n)=k\omega(n) = k 表示 nn 的不同质因子个数， σ(n)=∑d|n1=∑ki=1(ei+1)\sigma(n) = \sum_{d | n}{1} = \sum_{i = 1}^{k}{(e_i + 1)} 表示 nn 的约数个数，显然有 2ω(n)≤σ(n)2^{\omega(n)} \leq \sigma(n) 。

这题本来是为 OI 赛制的比赛准备的，然而没有被使用。接下来会根据几个部分分给出做法，希望能对大家有所启发。

对于 n≤106n \leq 10^6 的数据：

题目中所表述的过程是一个标准马尔可夫过程，所以我们可以用 f(n)f(n) 表示使用这种操作把 nn 变成 11 的期望试验次数，并且我们可以得到 f(1)=0,f(1) = 0, f(n)=∑d|nf(d)∑d|n1+1\displaystyle f(n) = \frac{\sum_{d | n}{f(d)}}{\sum_{d | n}{1}} + 1 ，化简后为 f(n)=σ(n)+∑d|n,d<;nf(d)σ(n)−1\displaystyle f(n) = \frac {\sigma (n) + \sum_{d | n, d \lt; n}{f(d)}}{\sigma (n) - 1} 。

很容易计算出满足 n∈N+,n \in N^{+}, n≤Nn \leq N 的所有 f(n)f(n) ，复杂度为 O(∑n≤Nσ(n))=O(NlogN)\sum_{n \leq N}{\sigma(n)}) = O(N\log N) ，这里不再赘述。

对于 n≤1012n \leq 10^{12} 的数据：

直接在线为每个询问计算答案是有些不现实的，这里给出一个考虑不同数字之间的关系并记忆化存储信息的做法。

首先观察到，对于 n=∏ki=1peii,n = \prod_{i = 1}^{k}{p_i^{e_i}}, m=∏k′i=1p′ie′im = \prod_{i=1}^{k'}{{p'_i}^{e'_i}} ，如果 k=k′k = k' 并且对于 i=1,2,⋯,ki = 1, 2, \cdots, k 都有 ei=e′ie_i = e'_i （适当地安排质因子的顺序之后），那么我们可以得到 f(n)=f(m)f(n) = f(m) ，这与具体的 pi,p′ip_i, p'_i 是多少无关。

不妨将每个数字对应的 e1,e2,⋯,eke_1, e_2, \cdots, e_k 按非升序排序，可以观察到将这些幂指数的集合拿出来并去重后剩下集合的数量不会很多。对于一个集合 e1,e2,⋯,eke_1, e_2, \cdots, e_k （满足非升序），我们可以构造出可能的最小值 n=2e13e25e37e4⋯n = 2^{e_1} 3^{e_2} 5^{e_3} 7^{e_4} \cdots ，而且可以大致估计出不超过 NN 的本质不同的幂指数的集合个数不会超过 logN\log N 的分拆数数量，再利用搜索就可以确定实际的数量了，例如 N=1012N = 10^{12} 时本质不同的集合个数为 43574357 。

事实上当 n≤1012n \leq 10^{12} 时，我们可以观察到 σ(n)≤6720\sigma(n) \leq 6720 ，于是每次询问时将 nn 映射到其幂指数的集合上，利用记忆化搜索的技巧枚举约数即可以单次 O(σ(n))\sigma(n)) 的复杂度通过测试数据。

对于 n≤1018n \leq 10^{18} 的数据：

之前的方法难以奏效，因为现在有 σ(n)≤103680\sigma(n) \leq 103680 并且本质不同的集合个数达到 3274932749 个。

为了观察更细致一些，我们定义 g(n)=∑d|nf(d)g(n) = \sum_{d | n}{f(d)} ，记忆化搜索时先计算出满足 d|n,d<;nd | n, d \lt; n 的所有 f(d),g(d)f(d), g(d) ，然后依次计算出 g′(n)=∑d|n,d<;nf(d),g'(n) = \sum_{d | n, d \lt; n}{f(d)}, f(n)=σ(n)+g′(n)σ(n)−1,f(n) = \frac{\sigma(n) + g'(n)}{\sigma(n) - 1}, g(n)=g′(n)+f(n)g(n) = g'(n) + f(n) 。

尝试优化计算 g′(n)g'(n) 的过程，也即计算中的瓶颈部分。如果改用容斥的技巧，我们有 g′(n)=∑T⊆S(−1)|T|+1g(n∏pi∈Tpi)\displaystyle g'(n) = \sum_{T \subseteq S}{(-1)^{|T| + 1} g\left(\frac{n}{\prod_{p_i \in T}{p_i}}\right)} ，其中 S={pi|i=1,2,⋯,k}S = \{p_i | i = 1, 2, \cdots, k\} ，这样可以使单次运算的复杂度从 O(σ(n))O(\sigma(n)) 降到了 O(2ω(n))O(2^{\omega(n)}) 。

类似地，当 n≤1018n \leq 10^{18} 时，我们可以观察到 ω(n)≤15\omega(n) \leq 15 ，所以这个优化在实际运算中已经足以通过 n≤1018n \leq 10^{18} 的数据。

[b]对于 n≤1024n \leq 10^{24} 的数据：[/b]

上述做法再次不适用了，因为现在本质不同的集合个数达到 172513172513 个，并且有 2ω(n)≤218≤2621442^{\omega(n)} \leq 2^{18} \leq 262144 ，因此我们需要再次进行优化。

考虑 g(n)g(n) 的组成，所有满足 d=∏ki=1pitid = \prod_{i = 1}^{k}{{p_i}^{t_i}} 且对于 i=1,2,⋯,ki = 1, 2, \cdots, k 有 0≤ti≤ei0 ≤ t_i ≤ e_i 的 dd 都会对 g(n)g(n) 贡献一个 f(d)f(d) ，这本质上是 kk 维前缀和。

参考大小为 kk 的二进制子集求和（经典问题），我们可以定义 gx(n)g_x(n) 表示对于 i=1,2,⋯,xi = 1, 2, \cdots, x 有 0≤ti≤ei0 \leq t_i \leq e_i 且对于 i=x+1,x+2,⋯,ki = x + 1, x + 2, \cdots, k 有 ti=eit_i = e_i 的 f(d)f(d) 之和，而考虑 i=xi = x 时 0≤ti<;ei0 \leq t_i \lt; e_i 和 ti=eit_i = e_i 这两种情况，不难得到 gx(n)g_x(n) 可以用 gx−1(n)g_{x - 1}(n) 和 gy(npx)g_y(\frac{n}{p_x}) 表示，其中 yy 取决于 npx\frac{n}{p_x} 是否依旧能整除 pxp_x 。这个方法可以将时间复杂度降低至每次 O(ω(n))O(\omega(n)) 。

注意这个做法具体结合到非升序的幂指数序列时可能要修改一下 gx(n)g_x(n) 的定义。

复杂度分析：

这道题的大数运算很容易在常数时间内实现。记忆化搜索时可以用 bitset 配合基数排序线性地对幂指数序列的排序，但是它是可以避免的（甚至是递归时的拷贝）。标程的时间复杂度与空间复杂度都是 O((S(N)+T)ω(N))O((S(N) + T) \omega(N)) ，其中 S(N)S(N) 表示在不超过 NN 的正整数里出现的本质不同的集合个数 (S(N)≤172513)(S(N) \leq 172513) ， TT 表示数据组数，并且 ω(N)≤18\omega(N) \leq 18 。

1006. Function

考虑置换 aa 的一个循环节，长度为 ll ，那么有 f(i)=bf(ai)=bbf(aai)=b⋯bf(i)⏟l times bf(i) = b_{f(a_i)} = b_{b_{f(a_{a_i})}} = \underbrace{b_{\cdots b_{f(i)}}}_{l\text{ times }b} 。

那么 f(i)f(i) 的值在置换 bb 中所在的循环节的长度必须为 ll 的因数。

而如果 f(i)f(i) 的值确定下来了，这个循环节的另外 l−1l - 1 个数的函数值也都确定下来了。

答案就是 ∑ki=1∑j|lij⋅calj\sum_{i = 1}^{k} \sum_{j | l_i} {j \cdot cal_j} 改为 ∏ki=1∑j|lij⋅calj\prod_{i = 1}^{k} \sum_{j | l_i} {j \cdot cal_j} ，其中 kk 是置换 aa 中循环节的个数， lil_i 表示置换 aa 中第 ii 个循环节的长度， caljcal_j 表示置换 bb 中长度为 jj 的循环节的个数。

时间复杂度是 (n+m)\mathcal{O}(n + m) 。

1007. Gear Up

整个图的结构是一个森林，首先可以将共轴的齿轮看成一个块（它们角速度相同），再考虑共边的情况。

如果 xx 和 yy 共边， xx 的半径为 rxr_x 、角速度为 ωx\omega_x， yy 的半径为 ryr_y 、角速度为 ωy\omega_y ，则可以知道 logωy=logωx+logrx−logry\log\omega_y = \log\omega_x + \log r_x - \log r_y 。

由此可以得出每个连通分量中每个齿轮角速度与某个特定齿轮的关系，从而利用线段树维护齿轮（或块）的 dfs 序列对应的区间角速度最大值。具体来说，每个连通分量任选一个齿轮作为参照点，维护其他齿轮与其角速度的差值。每个连通分量可以看成是一棵有根树，当一个齿轮的半径发生变化时，根据其是 rxr_x 还是 ryr_y 分两种情况更新一段 dfs 序区间。查询时只需要得出对应连通分量中相对角速度的最大值，再与当前点的相对角速度进行对比即可算出实际的最大值。

具体实现中可以维护 log2ω\log_2 \omega ，在输出时再转化为 logω\log\omega 。

1008. Hints of sd0061

最慢的情况是 bb 的取值为 0,0, 1,1, 2,2, 3,3, 5,5, 8,8, ⋯\cdots 的情况，但事实上也只有 (log1.618n)\mathcal{O}(\log_{1.618}{n}) 个取值。

从最大的取值到最小的取值依次使用近似线性复杂度的求第 kk 小的方法即可，该方法的思想与快排相似，可以保证前 k−1k - 1 小的元素都放置在第 kk 小元素的前面，这样枚举的时候就可以依次减少每次的枚举量，时间复杂度 ⎛⎝⎜⎜∑i≥0n1.618i⎞⎠⎟⎟=(n)\displaystyle\mathcal{O}\left(\sum_{i \geq 0}{\frac{n}{1.618^i}}\right) = \mathcal{O}(n) 。

1009. I Curse Myself

由于图是一个仙人掌，所以显然对于图上的每一个环都需要从环上取出一条边删掉。所以问题就变为有 MM 个集合，每个集合里面都有一堆数字，要从每个集合中选择一个恰好一个数加起来。求所有的这样的和中，前 KK 大的是哪些。这就是一个经典问题了。

对所有集合两个两个进行合并，设当前合并的集合是 AA 和 BB，合并的过程中用堆来求出当前 Ai+BjA_{i} + B_{j} 的前 KK 大值是哪些。这样的复杂度看起来为 (MKlogK)\mathcal{O}(MK \log K)，但如果合并的时候保证堆内的元素个数是新集合里的元素个数，设每个集合的大小分别为 m0,m1,⋯,mM−1m_{0}, m_{1}, \cdots, m_{M-1}，则复杂度为 (∑Klogmi)=(Klog∏mi)\mathcal{O}(\sum{K \log{m_{i}}}) = \mathcal{O}(K \log{\prod{m_i}})。当 mim_{i} 都相等时取得最大值 (MKlog∑miM)\mathcal{O}\left(MK \log{\frac{\sum{m_i}}{M}}\right)，所以实际复杂度为 (MK)\mathcal{O}(MK)。

事实上存在一个时间复杂度 (MK)\mathcal{O}(MK) 直接暴力求解的算法，但需要空间复杂度较好，例如空间复杂度 (K)\mathcal{O}(K) 。

1010. Journey with Knapsack

标程的做法是生成函数。定义装满 kk 体积空间的食物有 f(k)f(k) 种方案，对应的生成函数为 F(z)=∑k≥0f(k)zkF(z) = \sum_{k \geq 0}{f(k) z^k} 。如果我们可以确定多项式 F(z)modz2n+1F(z) \bmod z^{2 n + 1} 的系数，那么枚举 mm 个装备的体积即可轻松算出答案。

根据乘法原理，第 ii 种食物对 F(z)F(z) 贡献的因子是 1+zi+z2i+⋯+zaii=1−z(ai+1)i1−zi\displaystyle 1 + z^i + z^{2 i} + \cdots + z^{a_i i} = \frac{1 - z^{(a_i + 1) i}}{1 - z^i} ，因此 F(z)=∏i=1n1−z(ai+1)i1−zi=∏i=1n(1−z(ai+1)i)∏i=1n11−zi\displaystyle F(z) = \prod_{i = 1}^{n}{\frac{1 - z^{(a_i + 1) i}}{1 - z^i}} = \prod_{i = 1}^{n}{\left(1 - z^{(a_i + 1) i}\right)} \prod_{i = 1}^{n}{\frac{1}{1 - z^i}} 。

由于 0≤a1<;a2<;⋯<;an0 \leq a_1 \lt; a_2 \lt; \cdots \lt; a_n 的限制，我们知道对于 i=1,2,⋯,ni = 1, 2, \cdots, n 有 ai≥i−1a_i \geq i - 1 ，也即 (ai+1)i≥i2(a_i + 1) i \geq i^2 。所以只有 (n‾√)\mathcal{O}(\sqrt{n}) 项 (1−z(ai+1)i)\left(1 - z^{(a_i + 1) i}\right) 在模 z2n+1z^{2 n + 1} 意义下不为 11 。你可以利用类似背包的动态规划 (nn‾√)\mathcal{O}(n \sqrt{n}) 进行计数。

剩下的部分是 (∏i=1n11−zi)modz2n+1\displaystyle \left(\prod_{i = 1}^{n}{\frac{1}{1 - z^i}}\right) \bmod z^{2 n + 1} ，这很像分拆数的生成函数。分拆数的生成函数被定义为 P(z)=∑k≥0p(k)zkP(z) = \sum_{k \geq 0}{p(k) z^k} ，其中 p(k)p(k) 表示 kk 的本质不同的拆分数量。五边形数定理表明 P(z)=1+∑k≥1(−1)k(zk(3k+1)2+zk(3k−1)2)\displaystyle P(z) = 1 + \sum_{k \geq 1}{(-1)^k \left(z^{\frac{k (3 k + 1)}{2}} + z^{\frac{k (3 k - 1)}{2}}\right)} ，从而我们可以在需要的时候 (mm‾‾√)\mathcal{O}(m \sqrt{m}) 计算出多项式 P(z)modzmP(z) \bmod z^m 。

回到原来的部分，我们做如下化简：

∏i=1n11−zi≡∏i=n+12n(1−zi)∏i=12n11−zi≡P(z)∏i=n+12n(1−zi)≡P(z)(1−∑i=n+12nzi)(modz2n+1)

\displaystyle{\prod_{i = 1}^{n}{\frac{1}{1 - z^i}} \equiv \prod_{i = n + 1}^{2 n}{(1 - z^i)} \prod_{i = 1}^{2 n}{\frac{1}{1 - z^i}} \equiv P(z) \prod_{i = n + 1}^{2 n}{(1 - z^i)} \equiv P(z) \left(1 - \sum_{i = n + 1}^{2 n}{z^i}\right) \pmod{z^{2 n + 1}}}

上面的式子表明我们可以利用前缀和将其规约到 P(z)modz2n+1P(z) \bmod z^{2 n + 1} 。总的时间复杂度为 (nn‾√)\mathcal{O}(n \sqrt{n}) 。

1011. KazaQ’s Socks

找规律即可。规律是 1,2,⋯,nn numbers,\underbrace{1, 2, \cdots, n}_{n\text{ numbers}}, 1,2,⋯,n−1n−1 numbers,\underbrace{1, 2, \cdots, n - 1}_{n - 1\text{ numbers}}, 1,2,⋯,n−2,nn−1 numbers,\underbrace{1, 2, \cdots, n - 2, n}_{n - 1\text{ numbers}}, 1,2,⋯,n−1n−1 numbers,\underbrace{1, 2, \cdots, n - 1}_{n - 1\text{ numbers}}, 1,2,⋯,n−2,nn−1 numbers,\underbrace{1, 2, \cdots, n - 2, n}_{n - 1\text{ numbers}}, ⋯\cdots 。

1012. Limited Permutation

根据 [li,ri][l_i, r_i] (1≤i≤n)(1 \leq i \leq n) ，我们可以尝试线性地排序并建立一棵笛卡尔树，如果产生矛盾则答案为 00 。

具体来说，我们可以依次找到能够覆盖整个区间 [L,R][L, R] 的点 uu 。如果找不到则无解。如果找到多个，随便选一个，反正会在之后的决策中被中断。在这棵笛卡尔树上， uu 的左孩子（如果存在）应该能覆盖 [L,u−1][L, u - 1] ，同理它的右孩子（如果存在）应该能覆盖 [u+1,R][u + 1, R] ，这意味着我们可以固定区间的一个端点，排序另外一个端点得到孩子节点。最终我们可以建立一棵笛卡尔树。

若存在一棵笛卡尔树，则这棵笛卡尔树是唯一的。每棵子树都基于相似的子问题，所以我们只需要在合并子树时计算子树的组合即可。例如 uu 有两个儿子 v1v_1 和 v2v_2 ，它们的子树对应的方案数分别为 f(v1)f(v_1) 和 f(v2)f(v_2) ，子树大小分别为 s(v1)s(v_1) 和 s(v2)s(v_2) ，则 uu 的子树对应的方案数为 f(u)=(s(v1)+s(v2)s(v1))⋅f(v1)⋅f(v2)\displaystyle f(u) = {s(v_1) + s(v_2) \choose s(v_1)} \cdot f(v_1) \cdot f(v_2) 。

由于使用基数排序，故处理的时间复杂度为 (n)\mathcal{O}(n) ，主要时间还是花在了读入上面。我们可以加一些读入优化使得复杂度变成 (nlog10n)\mathcal{O}(n \log_{10}{n}) ，其中 log10n≤6\log_{10}{n} \leq 6 。