4.16 AT好题选做

前言

学长给我们挑了几道AT的思维题，码量都很小，但是思维难度较高。
马拉松的时候过了前三道，后三道的确是人类智慧。记录一下做法。

[ARC103D] Distance Sums(确定树的形态,trick)

题意：
给你一个长度为 $N$ 的正整数数组 $D_i$，保证 $D_i$ 互不相同。你需要构造一棵 $N$ 个点的树，树的边权都为 $1$， 满足 $i$ 号点到其它所有点的距离和恰好为 $D_i$。如果不存在输出 $-1$，否则输出所有的边 $(u_i,v_i)$。

$2\le N\le 10^5,1\le D_i\le 10^{12}$， 保证 $D_i$ 互不相同。

分析：
关键点在于怎样运用 $D_i$ 互不相同。
首先容易看出，如果能构造满足条件的树，那么这棵树一定只有一个 重心，并且重心的编号就是 $D_i$ 最小的 $i$。
考虑以这个重心为根确定树的形态：
从根往下确定是比较难做的，我们考虑对于每个点确定它的父亲，这在许多交互题里是常见的套路。设任意一个点 $x$ 的父亲为 $y$，一定满足 $D_y<D_x$，这是因为在以重心为根的情况下向子树里递归距离的增量总是大于减量的。那么我们将 $D_i$ 从小到大排序后倒着确定每个点 $i$ 的父亲，此时一定确定 $i$ 子树里所有的点。
那么同时知道 $i$ 的子树大小 和 $D_i$，是很容易确定 $i$ 父亲 $j$ 的 $D_j$ 的。考虑从 $j$ 递归到 $i$ 时，增量为 $n-s{z}_i$，减量为 $s{z}_i$，因此有 $D_j+n-2\times s{z}_i=D_i$， $D_j=D_i+2\times s{z}_i-n$，那么开一个 $map$ 就能知道 $D_j$ 对应的编号了。
坑点在于还原出树的形态也未必能对应上 $D_i$ 数组，我们还需要验证一下重心 $x$ 到其它点的距离和是否等于 $D_x$。
复杂度 $O(n)$。
CODE：

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
typedef long long LL;
unordered_map< LL, int > idx;
int n, odr[N], fat[N], sz[N];
LL d[N];
inline bool cmp(int x, int y) {return d[x] < d[y];}
int main() {scanf("%d", &n);for(int i = 1; i <= n; i ++ ) {scanf("%lld", &d[i]);odr[i] = i;idx[d[i]] = i;}sort(odr + 1, odr + n + 1, cmp);for(int i = 1; i <= n; i ++ ) sz[i] = 1;LL res = 0;for(int i = n; i > 1; i -- ) { // 倒着考虑 int o = odr[i];LL v = d[o] - (n - 2 * sz[o]);if(!idx[v] || v >= d[o]) {puts("-1"); return 0;}sz[idx[v]] += sz[o], fat[o] = idx[v]; res += 1LL * sz[o];}if(res != d[odr[1]]) {puts("-1"); return 0;}for(int i = 1; i <= n; i ++ ) {if(fat[i]) printf("%d %d\n", fat[i], i);}return 0;
}

[AGC062B] Split and Insert(区间 $dp$)

题意：
给你一个长度为 $N$ 的排列 $A$，初始时 $A_i=i$。你可以进行 $K$ 轮操作，每一轮你可以选择排列末尾的 $k_i$ 个数字，需要满足 $k_i\in [0,n-1]$。 然后将排列变成 $A^{\prime }$， 需要满足 $A_{1\dots n-k_i}$ 在 $A^{\prime }$ 是 $A^{\prime }$ 的一个 子序列， $A_{n-k_i+1\dots n}$ 是 $A^{\prime }$ 的一个子序列。
你的目标是 $K$ 轮操作后将排列变成 $P$，你的花费为 $\sum _{i=1}^K{C}_i\times k_i$。其中 $P$ 为给定排列， $C$ 为给定的数组。问你能否完成目标，如果不能输出 $-1$，否则输出最小花费。

$2\le N\le 100,1\le K\le 100,1\le C_i\le 10^9$。

分析：
首先令 $po{s}_{P_i}=i$，然后将 $A_i\leftarrow po{s}_i$，那么目标变成了将 $A$ 排序。
来考虑操作和排序有什么关系：发现如果有两个极长有序段，那么操作后面的连续段可以把它与前面的合并为一个极长有序段。

这启发我们先将原排列划分成若干个 极长有序段 考虑：
首先有一个容易想到的事情是，每次操作一定是末尾的若干完整段，不会在某一个段内断开。
感性证明：如果第 $i$ 次在某一段内断开，那么下次操作剩下这一部分时的代价系数 $C_j$ 如果小于 $C_i$，显然可以将原来那一部分放到这次操作，否则可以将剩下这一部分在上次操作，答案会变得更优。
那么目标就变成了最优化合并过程，使得最后合并成一段。

每次操作的末尾几段应该怎么与前面合并？
首先合并后这几段不可能存在两段同时出现在一个有序段里，因为相对顺序不能改变。所以它们只有分别找前面的一段合并才有用。
但是你会发现将这几段合并到最靠前的段里好像未必最优，因为可能存在后面某轮 $C_i$ 比较小，我想把此时最后一段合并到第一段，那么此时最后一段应该越多越优。
但是能够发现 这些段的第一段一定是合并到开头段 的。证明感性理解吧。
那么由于 $C_i$ 的系数是 数量，会发现此时选中段与前面段可以 独立考虑 了！！可以认为 两部分在后面的轮次中都需要将所有段合并到这一部分的开头段。并且容易证明不存在更优秀的策略了。

因此直接区间 $dp$ 即可：设 $d{p}_{l,r,k}$ 表示从第 $k$ 轮开始往后的轮次中，将 $l\sim r$ 的极长连续段合并成一段的最小花费。转移枚举第 $k$ 次选中的后缀段即可。复杂度 $O(n^{3}K)$。

CODE：

#include<bits/stdc++.h>
using namespace std;
const int N = 110;
typedef long long LL;
int n, K, p[N], pos[N], a[N], tot;
LL c[N], dp[N][N][N], sum[N];
int main() {scanf("%d%d", &n, &K);for(int i = 1; i <= K; i ++ ) scanf("%lld", &c[i]);for(int i = 1; i <= n; i ++ ) {scanf("%d", &p[i]); pos[p[i]] = i;}for(int i = 1; i <= n; i ++ ) p[i] = pos[i]; // 现在要把 p[i] 排序for(int i = 1; i <= n; ) {int j = i + 1;while(j <= n && p[j] > p[j - 1]) j ++;a[++ tot] = j - i;i = j;}for(int i = 1; i <= tot; i ++ ) sum[i] = sum[i - 1] + a[i];memset(dp, 0x3f, sizeof dp);for(int i = 0; i <= K + 1; i ++ ) {for(int j = 1; j <= tot; j ++ ) {dp[j][j][i] = 0;}}for(int len = 2; len <= tot; len ++ ) {for(int L = 1; L + len - 1 <= tot; L ++ ) {int R = L + len - 1;for(int k = K; k >= 1; k -- ) {			dp[L][R][k] = min(dp[L][R][k], dp[L][R][k + 1]); // 不动for(int mid = L + 1; mid <= R; mid ++ ) { // [mid, R] 移动  dp[L][R][k] = min(dp[L][R][k], dp[L][mid - 1][k + 1] + dp[mid][R][k + 1] + (sum[R] - sum[mid - 1]) * c[k]);}}}}if(dp[1][tot][1] > 1e12) puts("-1");else printf("%lld\n", dp[1][tot][1]);return 0;
}

[AGC012E] Camel and Oases(状压，可行性dp转最优性dp)

题意：
给你数轴上的 $N$ 个点 $x_1\dots x_N$，保证 $-10^9\le x_1<x_2<\cdots <x_N\le 10^9$。你需要对某个点 $i$ 判断以 $x_i$ 为起点能否按照以下方式遍历所有点：

• 初始时有一个油量上限 $V$， $V$ 开始时给定。开始时有 $V$ 升油。
• 你可以从当前点 $a$ 走路到一个点 $b$，满足 $|x_a-x_b|\le V^{\prime }$。$V^{\prime }$ 为此时剩下的油量，走路会消耗你 $|x_a-x_b|$升油。
• 当你位于 $N$ 个点的任意一个点时，可以将油量加至上限。
• 当 $V^{\prime }>0$ 时，你可以 跳跃 到这 $N$ 个点的任意一个，并将油量上限改为 $\lfloor \frac{V^{\prime }}{2}\rfloor$。

$2\le N,V\le 2\times 10^5$，$-10^9\le x_1<x_2<\cdots <x_N\le 10^9$，保证 $V$ 和 $x_i$ 都是整数。

分析：
首先不难发现，每次只会在油量满的情况下 跳跃，因此油量上限只会取到 T = { ⌊ V 2 i ⌋ } T = \{\left \lfloor \frac{V}{2^i} \right \rfloor\} T={⌊2iV​⌋} 中的数。并且能观察出 $|T|={\log }_{2}V$，将集合中的数从大到小排序，设第 $i$ 个数为 $T_i$。
考虑 走路 和 跳跃 交替使用的过程：假设当前上限为 $v\in T$，将相邻且距离不超过 $v$ 的点连一条边，那么会形成若干条链。如果当前在 $x$ 号点，一定是把 $x$ 所在链上的点用 走路 遍历完后，跳跃到别的点上，然后令 $v\leftarrow \lfloor \frac{v}{2}\rfloor$。并且不难发现，随着 $v$ 的减小，一定是在原先的基础上删掉一些边得到新的图。
可以认为，遍历所有点的过程等价于 将所有点都分到一条链里，并且满足所有链是按照 $S$ 中一个数为限制形成的，并且没有用到重复的数。进一步的，如果我们规定一个点为起点，那么就表明这个点一定在以 $V$ 为限制形成的链里。
由此我们枚举起点 $s$，可以得到一个可行性 $dp$ 的 $check$：
先将 $s$ 所在的以 $V$ 为限制形成的链上的所有点删去，然后对剩下的点 $dp$。
设 $d{p}_{i,S,j}$ 表示考虑了前 $i$ 个点并且把它们都划分到了一条链中，已经用掉的数的集合为 $S$，第 $i$ 个点所在链用的第 $j$ 个数为限制是否可行。
$i$ 往 $i+1$ 转移：首先看一下 $x_{i+1}^{\prime }-x_i$ 是否小于等于 $T_j$，如果小于等于可以转移给 $d{p}_{i+1,S,j}$。否则可以枚举 $S$ 中没用到的一个数将 $i+1$ 划分到一条新链中。
复杂度显然是不对的，考虑优化：首先能发现， $j$ 时没有用的，因为我们每次新开一段一定直接延伸到最右边不能延伸的位置是最优的。接着你能发现，对于 $S$ 相同的合法状态 $d{p}_{i,S}$，一定只有 $i$ 最大的那个有用，因此直接改成最优化 $dp$。
设 $d{p}_S$ 表示用掉了 $S$ 集合中的数，当前最靠右能划分到哪。转移枚举一个还没用的数 $k$ ，假设当前位置在相邻距离不超过 $T_k$ 的情况下最远能走到 $p$，这个可以 $O(n\log V)$ 预处理。那么可以用 $p+1$ 更新 $d{p}_{S\cup k}$。$+1$ 是因为新开段前可以跳跃，但是需要注意使用 $S$ 中 最后一个 还未被使用 的数时不能 $+1$。
这样单次 $check$ 的复杂度就是 $O(V\log V)$ 的。发现以 $V$ 为限制形成的每条链中的点是等价的，并且如果此时链的数量大于 $|T|$ 那么一定每个点都不能遍历其余点，而 $|T|=\log V$，因此暴力枚举每一条链 $check$ 即可。
总复杂度 $O((n+V){\log }^{2}V)$。

CODE：

// 相当于把 n 个位置划分到 logV 段里，每段步长不同 
// 首先想出一个可行性dp，然后变成最优化问题即可。 
#include<bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, V, s[20], tot; // s[i] 表示 v / 2^i    取值为 [0, tot] 
int dp[1 << 19], x[N], y[N], len, lst[1 << 19], o[1 << 19]; // dp[S] 表示使用了 S 里的步长， 最靠后能延伸到哪 
int l[N], r[N], ct, R[N][19];
inline int jump(int s, int S, int l) { // 从 s 开始使用 l 步长最靠后能跳到哪 if(s > len) return s;else return R[s][l] - ((S ^ (1 << l)) == (1 << tot + 1) - 1);
}
inline void pre() { // 预处理 for(int i = 1; i <= tot; i ++ ) {for(int j = 1; j <= len; ) {int k = j + 1;while(k <= len && y[k] - y[k - 1] <= s[i]) k ++;for(int l = j; l < k; l ++ ) R[l][i] = k;j = k;}}
}
inline void DP(int l) {memset(dp, -1, sizeof dp);dp[1 << 0] = 1; // 能跳到 1 for(int s = 0; s < (1 << tot + 1); s ++ ) {if(dp[s] < 0) continue;else {for(int l = 0; l <= tot; l ++ ) {if(!(s >> l & 1)) { // 考虑使用 l 步长 dp[s ^ (1 << l)] = max(dp[s ^ (1 << l)], jump(dp[s], s, l));}}}}
}
int main() {scanf("%d%d", &n, &V);int nv = V;for(int i = 0; i <= 20; i ++ ) {s[i] = nv; if(nv == 0) {tot = i; break;}nv /= 2;}for(int i = 1; i <= n; i ++ ) scanf("%d", &x[i]);for(int i = 1; i <= n; ) {int j = i + 1;while(j <= n && x[j] - x[j - 1] <= V) j ++;l[++ ct] = i, r[ct] = j - 1;i = j;}if(ct > tot + 1) {for(int i = 1; i <= n; i ++ ) puts("Impossible"); return 0;}else {for(int i = 1; i <= ct; i ++ ) {len = 0;for(int j = 1; j <= ct; j ++ ) {if(j == i) continue;for(int k = l[j]; k <= r[j]; k ++ ) y[++ len] = x[k];}pre();DP(len);if(dp[(1 << tot + 1) - 1] >= len) {for(int k = l[i]; k <= r[i]; k ++ ) puts("Possible");}else {for(int k = l[i]; k <= r[i]; k ++ ) puts("Impossible");}}}return 0;
}

[ARC094D] Normalization(trick，转化)

题意：
给你一个仅包含 $a,b,c$ 的字符串 $S$，你可以进行以下操作任意次：

• 选择两个相邻的不相同字符，把它们替换成两个没有出现的那种字符。

例如你可以操作$ab\to cc$。
你需要求出一共能得到多少种 本质不同 的字符串。答案对 $998244353$ 取模。

$2\le |S|\le 2\times 10^5$。

分析：
很有 $atc$ 风格的一道题？反正我是没想到。
考虑将 $a,b,c$ 分别别替换为 $0,1,2$。那么会发现 操作前后两个数的和在模 $3$ 下相同。
也就是说一个字符串 $S$ 每个字符替换成数字后的和在任意操作后是不变的。定义 $f(S)$ 为 $S$ 中的字符用数字替换后模 $3$ 下的数字和。
那么很容易猜到 $S$ 能变换得到的字符串与 $f(T)=f(S)$ 的所有字符串 $T$ 有很大关系。
经过打表，发现重要结论：

• 当 $n>3$ 时， $S$ 可以变换得到 所有 $f(T)=f(S)$，且 $T$ 中存在相邻相同字符的字符串 $T$。

存在相邻相同字符也是好理解的，因为每次操作后必定存在相邻的相同字符。
那么就很容易做了，我们考虑拿 $f(T)=f(S)$ 的 $T$ 的数量减去 $f(T)=f(S)$ 且 $T$ 中不存在相邻相同字符的 $T$ 的数量。
对于前者，显然答案是 $3^{n-1}$。
对于后者，考虑一个 $dp$： $d{p}_{i,j,k}$ 表示考虑前 $i$ 个字符，当前和模 $3$ 为 $j$，第 $i$ 个填了 $k$ 的方案数，转移是平凡的。

需要特判 $n\le 3$ 以及 $S$ 中所有字符都相等的情况。
时间复杂度 $O(n)$。

CODE：

// 无敌妙妙题 
#include<bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
typedef long long LL;
const LL mod = 998244353;
int n;
char s[N];
LL f[N][3][3], mi[N]; // f[i][j][k] 表示考虑到前 i 个， 和为 j， 第i个填了 k 
int main() {scanf("%s", s + 1); n = strlen(s + 1); if(n <= 3) {if(n == 1) puts("1");else if(n == 2) {if(s[1] == s[2]) puts("1");else puts("2");}else {int cnt = (s[1] != s[2]) + (s[2] != s[3]);if(cnt == 0) puts("1");else if(cnt == 1) puts("6");else {if(s[1] != s[3]) puts("3");else puts("7");}}}else {mi[0] = 1; for(int i = 1; i <= n; i ++ ) mi[i] = mi[i - 1] * 3 % mod;bool flag = 0; int sum = 0;for(int i = 2; i <= n; i ++ ) flag |= (s[i] != s[i - 1]);for(int i = 1; i <= n; i ++ ) sum += (s[i] - 'a'); sum %= 3;if(!flag) puts("1");else { // 能得到所有和相同， 存在相邻相同字符的字符串 int c = 1;for(int i = 2; i <= n; i ++ ) if(s[i] == s[i - 1]) c = 0;for(int i = 0; i <= 2; i ++ ) f[1][i][i] = 1;for(int i = 2; i <= n; i ++ ) for(int j = 0; j <= 2; j ++ ) for(int k = 0; k <= 2; k ++ ) for(int l = 0; l <= 2; l ++ )if(k != l) f[i][(j + l) % 3][l] = (f[i][(j + l) % 3][l] + f[i - 1][j][k]) % mod; LL res = 0;for(int i = 0; i <= 2; i ++ ) res = (res + f[n][sum][i]) % mod;printf("%lld\n", (mi[n - 1] - res + mod + c) % mod); }}return 0;
}

[ARC125F] Tree Degree Subset Sum(结论，adhoc)

题意：
给你一棵 $N$ 个点的树，你需要求出所有满足以下条件的二元组 $(x,y)$ 的数量：

• $0\le x\le N$
• 存在一种恰好选出 $x$ 个点的方案，使得这 $x$ 个点的度数和为 $y$。

$2\le N\le 2\times 10^5$。

分析：
首先树的形态没有任何作用，我们只需要求出度数数组就可以把树扔掉。
然后是非常超模的一步：
将所有 $de{g}_i-1$，不难发现此时求得的所有二元组 $(x,y^{\prime })$ 与原来的 $(x,y)$ 一一对应。更具体的，现在的 $(x,y)$ 对应了原来的 $(x,y+x)$。
那么有重要结论：

• 所有 $de{g}_i-1$ 后，此时求得的所有二元组 $(x,y)$，满足将 $y$ 固定后合法的 $x$ 是一段区间。

这个也可能是打表所有 $(x,y-x)$ 时看出的结论。

证明：
假设 $de{g}_i-1$ 后有 $k$ 个 $0$。对于一个 $y$，合法的最小 $x$ 为 $mn$，最大 $x$ 为 $mx$。那么 $mn$ 个里面一定不包含 $0$， $mx$ 里面一定包含了所有的 $k$ 个 $0$。因此可以将 $mn$ 向上调整至 $mn+k$，$mx$ 向下调整至 $mx-k$，只需要证明 $mn+k\ge mx-k$，即 $2k\ge mx-mn$。

由于 $\sum de{g}_i-1=n-2$，所以对于合法对 $(x,y)$，有：

• $x-k\le y\le n-2\Rightarrow x\le y+k$

那么一定存在 $(n-x,n-2-y)$，因此有：

• $n-x-k\le n-2-y\le n-2\Rightarrow x\ge y+2-k$

因此解出来 $x$ 的一个范围：
$y-k+2\le x\le y+k$

那么 $mx-mn\le 2k-2\le 2k$，证毕。

因此将 度数 看作 体积，点的数量 看作 价值，跑 最优化背包 即可。
但是这样暴力是 $O(n^2)$ 的。注意到不同的 $de{g}_i$ 只有 $O(\sqrt{n})$ 种，这是因为 $de{g}_i$ 的和为 $2n-2$。
因此可以跑 单调队列优化多重背包。复杂度 $O(n\sqrt{n})$。

CODE：

// 将每个点度数减 1 后， 对于一个固定的 y， 合法的 x 是一段区间 
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 2e5 + 10;
int n, deg[N], c[N];
int f[N], g[N], tf[N], tg[N]; // f[i] 表示现在度数和为 i 选中的最少点， g[i] 表示最多点 
int main() {scanf("%d", &n);for(int i = 1; i < n; i ++ ) {int u, v; scanf("%d%d", &u, &v);deg[u] ++; deg[v] ++;}for(int i = 1; i <= n; i ++ ) c[-- deg[i]] ++; // 每个点度数减 1 memset(f, 0x3f, sizeof f);memset(g, 0xcf, sizeof g);g[0] = f[0] = 0; for(int i = 0; i < n; i ++ ) {if(!c[i]) continue;if(i == 0) {for(int j = 0; j <= n; j ++ ) g[j] += c[i];}else {for(int r = 0; r < i; r ++ ) { // 枚举余数 deque< int > q1, q2; // 最小和最大 for(int j = 0; j <= (n - r) / i; j ++ ) { // 数量 while(!q1.empty() && f[q1.back() * i + r] - q1.back() >= f[j * i + r] - j) q1.pop_back();while(!q1.empty() && j - q1.front() > c[i]) q1.pop_front();q1.push_back(j);tf[j * i + r] = f[q1.front() * i + r] + (j - q1.front());while(!q2.empty() && g[q2.back() * i + r] - q2.back() <= g[j * i + r] - j) q2.pop_back();while(!q2.empty() && j - q2.front() > c[i]) q2.pop_front();q2.push_back(j);tg[j * i + r] = g[q2.front() * i + r] + (j - q2.front());}}for(int j = 0; j <= n; j ++ ) f[j] = tf[j], g[j] = tg[j];}}LL res = 0;for(int i = 0; i <= n; i ++ ) {if(g[i] >= f[i]) res += g[i] - f[i] + 1;}cout << res << endl;return 0;
}

[AGC049E] Increment Decrement(slope trick， 计数技巧，神仙题)

题意：
我们可以对一个非负整数序列 { A i } \{A_i\} {Ai​} 进行以下两种操作任意多次：

• 选定一项使其 $+1$ 或 $-1$，花费为 $1$。
• 选定一个区间使其中的每一项 $+1$ 或 $-1$，花费为 $C$。

定义一个非负整数序列 { A i } \{A_i\} {Ai​} 的花费为将一个初始全为 $0$ 的序列变成序列 $A$ 的最小花费。

给定 $N$ 个长为 $K$ 的序列 $B_i$，可以将 $A_i$ 赋值为 $B_{i,1\dots K}$ 中任意一项。你需要求出 $K^N$ 种可能的 $A$ 序列的花费之和。

$1\le N\le 50,1\le C\le 50,1\le K\le 50$， $1\le B_{i,j}\le 10^9$。

分析：
神题！！！

这种题的一般思路是想怎样对于固定的 $A$ 序列求最优答案，然后转计数就可以 $dp$ 套 $dp$ 或者一些别的思路。

那么首先考虑怎么对一个固定的 $A$ 求答案：

显然一操作和二操作顺序任意，先执行完所有二操作，假设得到了序列 $P$，那么一操作的花费就是 ${\sum }_{i=1}^n|P_i-A_i|$。二操作的花费即为 ${\sum }_{i=1}^{n}C\times \max (P_i-P_{i-1},0)$。可以认为 $P_0=0$。

可以得到一个 $dp$：
$f_{i,j}$ 表示填过了前 $i$ 个位置的 $P$，第 $i$ 个位置填了 $j$ 的最小花费。那么有转移：

$f_{i,j}=\underset{k}{\min }(f_{i-1,k}+C\times \max (j-k,0))+|j-A_i|$

看到了加绝对值函数，猜测 $f_i$ 关于 $j$ 下凸。下面来 归纳证明 一下：
套路的，将转移拆成两步：

$f_{i,j}\leftarrow \underset{k}{\min }(f_{i-1,k}+C\times \max (j-k,0))$

$f_i$ 加绝对值函数 $|j-A_i|$。

第二步显然不影响下凸性，只需要证明第一步转移后下凸即可。

设 $f_{i-1}$ 关于 $j$ 下凸，最小值取到 $f_{i-1,k}$，设 $w$ 为满足 $f_{i-1,w+1}-f_{i-1,w}>C$ 的最小的数。
那么当 $j\le k$，显然 $f_{i,j}\leftarrow f_{i-1,k}$。
当 $j\ge w$ 时，显然 $f_{i,j}\leftarrow f_{i-1,w}+C\times (j-w)$。
其余的 $j$ 都有 $f_{i,j}\leftarrow f_{i-1,j}$。
概括的说就是将最小值左边部分推平，斜率大于 $C$ 的部分改成一条斜率为 $C$ 的直线。
那么图形的斜率仍然单调递增，还是下凸。
加上第二步转移来看，会发现实际上函数的斜率只存在 $[-1,C+1]$。第一步转移就是将斜率为 $-1$ 的部分推平并将斜率为 $C+1$ 的部分删去。

那么可以 $slopetirck$ 维护。为了方便，我们令 $f_{0,j}=C\times j$，这样正常转移也是对的。也就是首先往函数斜率变化点的可重集里插入 $C$ 个 $0$。考虑两步操作变成了什么：

• 当 $i>1$ 时，将可重集里的最小值和最大值删去。
• 插入两个 $A_i$ 表示在 $A_i$ 部分斜率变化了 $2$。
• 记此时可重集的最小值为 $p$，将答案加上 $A_i-p$，表示最小值的增量。

那么我们可以在 $O(n\log V)$ 的复杂度解决这个问题。

考虑第二部分，改成计数：
我们要对所有可能的 $A$ 求一次答案加起来。观察求解答案的过程，可以分作两部分：

• $+A_i$
• 减去当前可重集的最小值

第一部分的贡献是简单的，只需要将 ${\sum }_{i=1}^n{K}^{n-1}{\sum }_{j=1}^K{B}_{i,j}$ 加到答案中即可。
对于第二部分：
考虑枚举一种数 $x$ 计算它作为最小值被减了多少次。
维护可重集是困难的，但是如果数字只有 $0/1$ 是好做的。
因此我们将 $x$ 被减的次数拆成 $\le x$的数被减的次数减去 $<x$ 的数被减的次数。
对于前者，可以将所有 $\le x$ 的数看作 $0$，其余看作 $1$。对于后者只需要将 $<x$ 的数看作 $0$，其余看作 $1$ 即可。
那么现在问题就变成了数字只有 $0,1$ 两种，你需要求出 $K^n$ 中情况中 $0$ 作为最小值被减了几次。
这个显然是简单的，每步操作后都有 $C+2$ 个数，只需要记录其中有多少个 $0$ 就能转移。
更简单的，注意到只有可重集中所有 $C+2$ 个数都是 $1$ 时 $0$ 才不是最小值。
那么考虑一个容斥，总的拿出最小值次数减去最小值取 $1$ 的次数。
总的次数显然是 $n\times K^n$。
对第二部分，设一个$dp$： $f_{i,j}$ 表示考虑了前 $i$ 个$A_i$ 的取值，当前可重集中有 $j$ 个 $1$ 的方案数。转移只需要考虑当前位置选 $0$ 还是 $1$ 并乘上系数即可。那么第二部分的答案就是 ${\sum }_{i=1}^n{f}_{i,C+2}\times K^{n-i}$。

最小值种类数 $nk$，每次 $dp$ 复杂度 $O(nk)$ ，总复杂度 $O(n^2{k}^2)$。

CODE：

// 绝世好题， 考察 slope trick 和 计数技巧 
#include<bits/stdc++.h>
using namespace std;
const int N = 55;
typedef long long LL;
const int mod = 1e9 + 7;
int mi[N], res;
int n, C, K, a[N][N], c[N], b[N * N], tot;
int dp[N][N]; // dp[i][j] 表示考虑到 i， 当前有 j 个 1 的方案数 
inline int del(int x, int y) {return x - y < 0 ? x - y + mod : x - y;} 
inline int add(int x, int y) {return x + y >= mod ? x + y - mod : x + y;}
inline int mul(int x, int y) {return 1LL * x * y % mod;}
inline int f(int x) { // 将 <= x 的看作 0, > x 的看作 1， 求 K^n 种有多少次最小值为 0 int ret = mul(n, mi[n]);for(int i = 1; i <= n; i ++ ) {c[i] = 0;for(int j = 1; j <= K; j ++ ) c[i] += (a[i][j] > x);}memset(dp, 0, sizeof dp);dp[0][0] = 1;for(int i = 1; i <= n; i ++ ) {if(i == 1) {dp[i][0] = mul(dp[i - 1][0], K - c[i]);dp[i][2] = mul(dp[i - 1][0], c[i]);}else {for(int j = 0; j <= C + 2; j ++ ) { // 枚举上一个有多少个 1 int &v = dp[i][j - (j == C + 2) - (j > 0)];v = add(v, mul(dp[i - 1][j], K - c[i])); // 放 0int &z = dp[i][j - (j == C + 2) - (j > 0) + 2];z = add(z, mul(dp[i - 1][j], c[i]));}}ret = del(ret, mul(dp[i][C + 2], mi[n - i]));}return ret;
}
int main() {scanf("%d%d%d", &n, &C, &K);for(int i = 1; i <= n; i ++ ) for(int j = 1; j <= K; j ++ ) {scanf("%d", &a[i][j]);b[++ tot] = a[i][j];}mi[0] = 1; for(int i = 1; i <= n; i ++ ) mi[i] = mul(mi[i - 1], K);for(int i = 1; i <= n; i ++ ) // 所有 a[i][j] 的贡献 for(int j = 1; j <= K; j ++ ) res = add(res, mul(mi[n - 1], a[i][j]));sort(b + 1, b + tot + 1);tot = unique(b + 1, b + tot + 1) - (b + 1);for(int i = 1; i <= tot; i ++ ) { // 枚举最小值， 计算它们的系数 res = del(res, mul(del(f(b[i]), f(b[i] - 1)), b[i]));}cout << res << endl;return 0;
}