2020牛客暑期多校训练营（第六场）题解
文章目录
-
-
- A. African Sort
- B. Binary Vector
- C. Combination of Physics and Maths
- D.Data structure
- E. Easy Construction
- G. Grid Coloring
- H. Harmony Pairs
- J. Josephus Transform
- K. K-Bag
-
A. African Sort
给出一个 1 1 1 ~ n n n 的排列，每次你可以选定一个子序列进行操作，代价为子序列的大小，操作内容为随机打乱这个子序列，问你在最优策略下使这个序列有序的最小代价。
如果让 i i i 向 p i p_i pi 连边，那么可以将这个排列看成若干个环，显然最优策略下肯定是对每个环单独求解，最后的结束状态是每个环的大小都为 1 1 1。
操作的花费之和可以转化为每一个点在操作过程中被几个环包含过，令 f n f_n fn 表示一个一开始在大小为n的环内的点期望会被多少个环包含，要求这个东西，首先需要一个引理：
引理：随机打乱一个大小为 n n n 的环，环内每个点将等概率出现在大小为 1 1 1 ~ n n n 的环内。
证明： 设环内一个点在打乱后出现在一个大小为 i i i 的环内的概率为 c c c，那么 c = C n − 1 i − 1 × ( i − 1 ) ! × ( n − i ) ! c=C_{n-1}^{i-1}\times(i-1)!\times(n-i)! c=Cn−1i−1×(i−1)!×(n−i)!， C n − 1 i − 1 C_{n-1}^{i-1} Cn−1i−1 表示选出环内另外 i − 1 i-1 i−1 个点， ( i − 1 ) ! (i-1)! (i−1)! 表示这 i i i 个点圆排列方案数， ( n − i ) ! (n-i)! (n−i)! 表示剩下的点随便排列，将这个东西化简就得到 ( n − 1 ) ! (n-1)! (n−1)!，是与 i i i 无关的，所以是等概率出现在大小为 1 1 1 ~ n n n 的环内。
然后还有一个性质：每次操作整个环是最优的。相对的，另外一种想法是先操作环的一部分，再操作剩下的部分，这两种打乱方式代价同样为 n n n，但是前者一定更优，官方题解里是这么说的：
说实话，并不知道官方题解在说什么，也没有什么严谨的证明，自己手玩了很久也找不到证明，只能找到一些奇怪的结论，就不写了，如果有大佬会证的话还请救救蒟蒻qwq。
根据这两个性质，就可以推出 f f f 了：
f n = 1 + 1 n f n + ∑ i = 1 n − 1 f i = n n − 1 ( 1 + ∑ i = 1 n − 1 f i ) = n n − 1 + n n − 1 ∑ i = 1 n − 1 f i \begin{aligned} f_n&=1+\frac 1 n f_n+\sum_{i=1}^{n-1}f_i\\ &=\frac n {n-1}(1+\sum_{i=1}^{n-1}f_i)\\ &=\frac n {n-1}+\frac n {n-1}\sum_{i=1}^{n-1}f_i \end{aligned} fn=1+n1fn+i=1∑n−1fi=n−1n(1+i=1∑n−1fi)=n−1n+n−1ni=1∑n−1fi
类似的，可以知道：
f n − 1 = n − 1 n − 2 + n − 1 n − 2 ∑ i = 1 n − 2 f i f_{n-1}=\frac {n-1} {n-2}+\frac {n-1} {n-2}\sum_{i=1}^{n-2}f_i fn−1=n−2n−1+n−2n−1i=1∑n−2fi
那么就有：
f n = f n − 1 × n − 2 n − 1 + 1 n − 1 + 1 n − 1 f n − 1 = f n − 1 + 1 n − 1 = f 2 + ∑ i = 3 n 1 i − 1 = 1 + ∑ i = 1 n − 1 1 i \begin{aligned} f_n&=f_{n-1}\times \frac {n-2} {n-1}+\frac 1 {n-1}+\frac 1 {n-1} f_{n-1}\\ &=f_{n-1}+\frac 1 {n-1}\\ &=f_2+\sum_{i=3}^n \frac 1 {i-1}\\ &=1+\sum_{i=1}^{n-1}\frac 1 i \end{aligned} fn=fn−1×n−1n−2+n−11+n−11fn−1=fn−1+n−11=f2+i=3∑ni−11=1+i=1∑n−1i1
此时就可以递推求 f f f 了，边界为 f 1 = 0 , f 2 = 2 f_1=0,f_2=2 f1=0,f2=2
那么对于一个大小为 k k k 的环，代价就是 k × f k k\times f_k k×fk，这样就可以求解了，代码如下：
#include B. Binary Vector
问你随机选出 n n n 个 n n n 维向量，他们线性无关的概率是多少，要求选出的向量每一维只能是 0 0 0 或 1 1 1。
假设现在已经选出 i i i 个线性无关的向量了，那么这 i i i 个向量一定张成了一个 i i i 维的空间，在这个 i i i 维空间内任意向量都可以被这 i i i 个向量表示出来。
也就是说，第 i + 1 i+1 i+1 个向量一定要扩张出新的一维，这样才能保证这个新向量与前面的向量线性无关。由于前面已经形成了一个 i i i 维的空间，这个空间内包含了 2 i 2^i 2i 个 01 01 01 向量，所以新向量只能选择剩下的 2 n − 2 i 2^n-2^i 2n−2i 个向量，选到的概率就是 2 n − 2 i 2 n \dfrac {2^n-2^i} {2^n} 2n2n−2i。
那么就有：
f ( n ) = ∏ i = 0 n − 1 2 n − 2 i 2 n = ∏ i = 0 n − 1 2 n − i − 1 2 n − i = ∏ i = 1 n 2 i − 1 2 i = f ( n − 1 ) × 2 n − 1 2 n \begin{aligned} f(n)&=\prod_{i=0}^{n-1} \frac {2^n-2^i} {2^n}\\ &=\prod_{i=0}^{n-1} \frac {2^{n-i}-1} {2^{n-i}}\\ &=\prod_{i=1}^n \frac {2^i-1} {2^i}\\ &=f(n-1)\times \frac {2^n-1} {2^n} \end{aligned} f(n)=i=0∏n−12n2n−2i=i=0∏n−12n−i2n−i−1=i=1∏n2i2i−1=f(n−1)×2n2n−1
于是代码如下：
#include C. Combination of Physics and Maths
给出一个矩阵 a a a，找到一个 { 1 , 2 , . . . , n } \{1,2,...,n\} { 1,2,...,n} 的子序列 A A A 和 { 1 , 2 , . . . , m } \{1,2,...,m\} { 1,2,...,m} 的子序列 B B B，满足 ( ∑ i = 1 ∣ A ∣ ∑ j = 1 ∣ B ∣ a A i , B j ) / ( ∑ j = 1 ∣ B ∣ a A ∣ A ∣ B j ) (\sum_{i=1}^{|A|}\sum_{j=1}^{|B|}a_{A_i,B_j})/(\sum_{j=1}^{|B|}a_{A_{|A|}B_j}) (∑i=1∣A∣∑j=1∣B∣aAi,Bj)/(∑j=1∣B∣aA∣A∣Bj) 最大。
容易发现一个性质，当子矩阵的底为第 i i i 行时， A A A 一定为 { 1 , 2 , . . . , i } \{1,2,...,i\} { 1,2,...,i}，因为上面那些不拿白不拿，拿了肯定能更大。
那么可以考虑枚举子矩阵的底，设为第 i i i 行，然后对于每一列，令 b j = ∑ x = 1 i a i , j b_j=\sum_{x=1}^i a_{i,j} bj=∑x=1iai,j，那么就是要选出若干个 j j j 使 ∑ x = 1 ∣ B ∣ b B x ∑ x = 1 ∣ B ∣ a i , B x \dfrac{\sum_{x=1}^{|B|} b_{B_x}} {\sum_{x=1}^{|B|}a_{i,B_x}} ∑x=1∣B∣ai,Bx∑x=1∣B∣bBx 最大。
当时想到这里，发现这不是个裸的 01 01 01 分数规划吗！冲冲冲
写到一半发现，这压根不用规划，直接贪心拿 b x a i , x \dfrac {b_x} {a_{i,x}} ai,xbx 最大的 x x x 就好了，再拿其他的显然不能使比值更大……
于是代码如下：
#include D.Data structure
给出一棵树，有 m m m 个询问，每次询问区间 [ l , r ] [l,r] [l,r] 内有多少对点的 l c a lca lca 是 x x x。
询问转化一下，就是 x x x 子树中 [ l , r ] [l,r] [l,r] 内的点两两配对减 x x x 的儿子的子树中 [ l , r ] [l,r] [l,r] 内点两两配对。
前者可以用主席树瞎搞，比较简单，重点是后者。
考虑轻重链剖分，对于一个对 x x x 点的询问，直接减去 x x x 重儿子子树内的配对数，这个也可以用主席树求，这部分复杂度为 O ( m log n ) O(m\log n) O(mlogn)。
对于轻儿子，考虑对询问跑莫队，每次新增或删除一个点时，将这个点沿着重链跳，由于此时只需要求轻儿子的答案，所以只会影响 log n \log n logn 个点，这部分复杂度是 O ( n n log n ) O(n\sqrt n\log n) O(nnlogn) 的。
但是事实上第二个部分会 T T T 飞。
为了听懂下面的优化，你得先理解上面这个做法，这份代码是上面做法的正确实现，不太理解的话建议看一遍：
#include 考虑优化，实测发现代码中 90 % 90\% 90% 的时间复杂度都来自第二个部分，考虑降低一下他的复杂度。
不妨稍微让轻重链剖分假一点，考虑根号分治，设置一个上线 S Z SZ SZ，令 x x x 的子树大小超过SZ的儿子都成为 x x x 的重儿子，那么第二个部分跳重链时跳次数的就会少很多。
如果让 S Z SZ SZ 与根号相关，比如 s i z e [ x ] \sqrt{size[x]} size[x]， s i z e [ x ] size[x] size[x] 是 x x x 的子树大小，那么 x x x 的重儿子个数不会超过 S Z SZ SZ 个，那么第一个部分的时间复杂度就变成了 O ( n c log n ) O(nc\log n) O(nclogn)，其中 c c c 是每个点重儿子个数，比 n \sqrt n n 要小不少但是仍然大于 log n \log n logn。
然后再考虑降低一下第一个部分的时间复杂度，发现主席树其实是可以用树状数组代替的，只需要将所有询问排个序即可。
时间用了 775 m s 775ms 775ms，算挺快的，具体细节看代码吧：
#include E. Easy Construction
构造一个 1 1 1 ~ n n n 的排列，满足对于任意 i i i，都存在一个长为 i i i 的区间，这个区间的和在模 n n n 意义下等于 k k k。
比较简单就直接上代码了：
#include G. Grid Coloring
给出一张 n × n n\times n n×n 的网格图，有 k k k 种颜色，你要给每条边染色，满足：1、每种颜色出现次数相同；2、没有一个格子的四条边相同颜色；3、没有一行或一列的边都是相同颜色的。
有解的话一定满足 n > 1 , k > 1 , k ∣ 2 n ( n + 1 ) n>1,k>1,k|2n(n+1) n>1,k>1,k∣2n(n+1)。
分类讨论，当 k k k 是偶数且 k ≠ 2 k\neq 2 k=2 时，可以将 k k k 种颜色均分两份分别给行和列，然后找到 n + 1 n+1 n+1 和 n n n 的一组因子 x , y x,y x,y 满足 x y = k 2 xy=\dfrac k 2 xy=2k，然后将行或列的 ( n + 1 ) × n (n+1)\times n (n+1)×n 条边分成 x × y x\times y x×y 份，然后每份内放相同的颜色，为了满足限制 2 2 2，将每行的颜色交错着放，再要满足限制 3 3 3，将奇数行右移一位即可，这是官方题解的图：
说句闲话，官方题解给的std A不了这题QAQ……
代码如下：
#include 这是重写的更简短的代码：
#include H. Harmony Pairs
设 S ( x ) S(x) S(x) 表示 x x x 每一位上的数字之和，求满足 0 ≤ A ≤ B ≤ n , S ( A ) > S ( B ) 0\leq A\leq B\leq n,S(A)>S(B) 0≤A≤B≤n,S(A)>S(B) 的 A , B A,B A,B 有多少对。
比较容易想到数位 dp \text{dp} dp，我一开始想的状态是前 i i i 位和为 j j j 的数字个数，然后写的时候越写越难写，很难判断和 n n n 位数一样的数是否大于 n n n，然后就自闭了。
膜了一发题解，题解的状态很妙，设 f [ i ] [ j ] [ t 1 ] [ t 2 ] f[i][j][t1][t2] f[i][j][t1][t2] 表示最高的 i i i 位已经确定，两数的 S S S 差为 j j j， t 1 , t 2 t1,t2 t1,t2 表示 A A A 与 B B B ， B B B 与 n n n 目前的大小关系， 1 1 1 表示小于， 0 0 0 表示等于，大于的状态是没有用的所以不记录。
然后每次枚举 A , B A,B A,B 下一位是什么就可以了，很容易写，代码如下：
#include J. Josephus Transform
给出一个序列，有 m m m 次操作，每次给出 k , x k,x k,x，表示对这个序列进行 x x x 次距离为 k k k 的约瑟夫游戏，进行一次游戏后生成的序列是每个数按死亡时间排序后的序列，求最后的序列。
注意到数据范围 n × m ≤ 1 0 6 n\times m\leq 10^6 n×m≤106，就是在暗示我们每次操作是 O ( n ) O(n) O(n) 或 O ( n log n ) O(n\log n) O(nlogn) 的qwq。
所以每次可以用权值线段树求出 1 1 1 ~ n n n 的排列进行一次距离为 k k k 的约瑟夫游戏后的序列，这个序列可以看成一个置换，将其中的每个循环旋转 x − 1 x-1 x−1 次，就得到了 1 1 1 ~ n n n 进行 x x x 次 k k k 距离的约瑟夫游戏后的序列，再将原序列映射一下就好了。
代码如下：
#include K. K-Bag
定义一个序列是 k-Bag \text{k-Bag} k-Bag 的，当且仅当这个序列由若干个 1 1 1 ~ k k k 的排列拼接而成，现在问一个序列是不是一个 k-Bag \text{k-Bag} k-Bag 序列的片段。
如果是，那么一定形如： ∗ ∗ ∗ + 1 ***+1 ∗∗∗+1 ~ k + 1 k+1 k+1 ~ k + . . . + 1 k+...+1 k+...+1 ~ k + ∗ ∗ ∗ k+*** k+∗∗∗， 1 1 1 ~ k k k 表示 1 1 1 到 k k k 的一个排列， ∗ ∗ ∗ *** ∗∗∗ 表示一段没有重复数字的序列，并且长度小于 k k k。
然后就随便判一下就做完了，代码如下：
#include