连续段 DP
连续段 DP：
在一些数排列的问题中，往往会遇到感觉是 DP 但是状态都列不来的情况，而连续段 DP 就是一个解决排列计数的利器。
具体思路是依次插入每个元素（通常是排序后从小到大/从大到小）。考虑当前元素插入到哪个位置，这样的话状态就需要记下当前插到了哪个数以及当前连续段个数。
转移时考虑：当前元素新开一个连通块，接在连通块的首/尾，连接两个连通块。
洛谷 P5999：
考虑把数字从小到大插入到序列中，从而得到一个排列。
定义 \(f_{i,j}\) 表示枚举到了第 \(i\) 个数，已经有了 \(j\) 个连续段的方案数。
那么每次加入数字有两种情况：
把两个段合并。有 \(j-1\) 个位置可以合并。\(f_{i,j}+=f_{i-1,j+1}\times j\)
重新创建一个段，但是注意 \(s\) 在最左边，\(t\) 在最右边。\(f_{i,j}+=f_{i-1,j-1}\times (j-[j>s]-[j>t])\)。
当 \(i\) 等于 \(s\) 或 \(t\) 时也要特判，考虑他们在边界单独开一个段，要么和边界的段合并，所以是 \(f_{i,j}=f_{i-1,j-1}+f_{i-1,j}\)。
Code：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2005, mod = 1e9 + 7;
int n, s, t, f[N][N];
int main() {
scanf("%d%d%d", &n, &s, &t);
f[1][1] = 1;
for (int i = 2; i <= n; ++i)
for (int j = 1; j <= i; ++j) {
if (i != s && i != t)
f[i][j] = 1ll * (j - (i > s) - (i > t)) * f[i - 1][j - 1] % mod + 1ll * j * f[i - 1][j + 1] % mod, f[i][j] %= mod;
else
f[i][j] = (f[i - 1][j] + f[i - 1][j - 1]) % mod;
}
printf("%d", f[n][1]);
return 0;
}
洛谷 P7967：
先把磁铁按照 \(r\) 从小到大排序。
\(f_{i,j,k}\) 表示插入了 \(i\) 个磁铁，\(j\) 个连通块，占用了 \(k\) 个空位的方案数。
这里的连通块是指：这些磁铁之间任意删除一个空都会导致他们吸引。
三种转移：
当前元素新开一个连通块：\(f_{i,j,k}+=f_{i-1,j-1,k-1}\times j\)。
接在连通块的首/尾：\(f_{i,j,k}+=f_{i-1,j,k-r_i}\times 2\times j\)。
连接两个连通块：\(f_{i,j,k}+=f_{i-1,j+1,k-2r_i+1}\times j\)。
最终统计答案就是插板。
Code：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 55, M = 10005, mod = 1e9 + 7;
int n, m;
int a[N];
int f[N][N][M];
int fac[M], inv[M];
int qpow(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = 1ll * res * x % mod;
x = 1ll * x * x % mod;
y >>= 1;
}
return res;
}
void init(int n) {
fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = 1ll * fac[i - 1] * i % mod;
inv[n] = qpow(fac[n], mod - 2);
for (int i = n - 1; ~i; --i) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
}
int C(int n, int m) {
if (n < 0 || m < 0 || n < m) return 0;
return 1ll * fac[n] * inv[n - m] % mod * inv[m] % mod;
}
void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int main() {
scanf("%d%d", &n, &m);
init(m);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
f[0][0][0] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= i; ++j)
for (int k = 1; k <= m; ++k) {
add(f[i][j][k], 1ll * f[i - 1][j - 1][k - 1] * j % mod);
if (k >= a[i]) add(f[i][j][k], 1ll * f[i - 1][j][k - a[i]] * j * 2 % mod);
if (k >= a[i] * 2 - 1) add(f[i][j][k], 1ll * f[i - 1][j + 1][k - (a[i] * 2 - 1)] * j % mod);
}
int ans = 0;
for (int i = 1; i <= m; ++i) add(ans, 1ll * f[n][1][i] * C(m - i + n, n) % mod);
printf("%d", ans);
return 0;
}
LOJ 2743：
这题涉及到另外一个很重要的套路。
首先是要将 \(a\) 从小到大排序。
引出一个处理绝对值的技巧：考虑每个绝对值能表示成 \(\sum_{i=l}^{r}a_{i+1}-a_{i}\)。
我们对于每个 \(a_{i+1}-a_{i}\) 统计其贡献次数即可。
他的贡献次数就是前 \(i\) 个数构成连续段的端点个数，因为端点旁边以后一定会插入比 \(i\) 大的数，就会产生贡献，有费用提前计算的感觉。
然后就可以用连续段 DP 来解决这个问题了，因为边界（端点是 \(1/n\)）并不会产生贡献所以要把它记录进状态。
设 \(f_{i,j,k,l}\) 表示插入了 \(i\) 个数，有 \(j\) 个连续段，贡献和是 \(k\)，\(l\) 个边界已经固定。每次增量法考虑一个新数的插入，新的贡献和为 \(k^{′}=k+(a_{i+1}-a_i)\times (2\times j-l)\)。
- 作为一个新的连续段插入到不为边界的空隙处：\(f_{i+1,j+1,k^{′},d}+=f_{i,j,k,l}\times (j+1-l)\)。
- 合并两个连续段：\(f_{i+1,j-1,k^{′},l}+=f_{i,j,k,l}\times (j-1)\)
- 添加到某个连续段的非边界端点处：\(f_{i+1,j,k^{′},l}+=f_{i,j,k,l}\times (2\times j-l)\)。
- 作为一个新的连续段插入到边界：\(f_{i+1,j+1,k^{′},l+1}+=f_{i,j,k,l}\times (2-l)\)。
- 添加到某个连续段作为边界：\(f_{i+1,j,k^{′},l+1}+=f_{i,j,k,l}\times (2-l)\)。
最后答案是 \(\sum f_{n,1,i,2}\)。
Code：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 105, M = 1005, mod = 1e9 + 7;
int n, m;
int a[N];
int ans;
int f[N][N][M][3];
void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
if (n == 1) return printf("%d", 1), 0;
sort(a + 1, a + n + 1);
f[0][0][0][0] = 1;
for (int i = 0; i < n; ++i)
for (int j = 0; j <= i; ++j)
for (int k = 0; k <= m; ++k)
for (int l = 0; l <= 2; ++l) {
int K = k + (2 * j - l) * (a[i + 1] - a[i]), t = f[i][j][k][l];
if (K > m || !t) continue;
add(f[i + 1][j + 1][K][l], 1ll * t * (j + 1 - l) % mod);
if (j) add(f[i + 1][j - 1][K][l], 1ll * t * (j - 1) % mod), add(f[i + 1][j][K][l], 1ll * t * (2 * j - l) % mod);
if (l < 2) add(f[i + 1][j + 1][K][l + 1], 1ll * t * (2 - l) % mod);
if (l < 2 && j) add(f[i + 1][j][K][l + 1], 1ll * t * (2 - l) % mod);
}
int ans = 0;
for (int i = 0; i <= m; ++i) add(ans, f[n][1][i][2]);
printf("%d", ans);
return 0;
}
CF1515E：
设 \(f_{i,j}\) 表示 \(i\) 个元素，形成了 \(j\) 个连续段的方案数。
- 作为一个新的连续段，\(f_{i+1,j+1}+=f_{i,j}\times (j+1)\)
- 插入到原有连续段的首/尾，\(f_{i+1,j}+=f_{i,j}\times 2\times j,f_{i+2,j}+=f_{i,j}\times 2\times j\)。
- 合并两个连续段，\(f_{i+2,j-1}+=f_{i,j}\times 2\times(j-1),f_{i+3,j-1}+=f_{i,j}\times (j-1)\)。
Code：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 405;
int n, mod;
int f[N][N];
void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int main() {
scanf("%d%d", &n, &mod);
f[1][1] = 1;
for (int i = 1; i < n; ++i)
for (int j = 1; j <= i; ++j) {
add(f[i + 1][j + 1], 1ll * f[i][j] * (j + 1) % mod);
add(f[i + 1][j], 1ll * f[i][j] * j * 2 % mod);
add(f[i + 2][j], 1ll * f[i][j] * j * 2 % mod);
if (j > 1) add(f[i + 2][j - 1], 1ll * f[i][j] * (j - 1) * 2 % mod), add(f[i + 3][j - 1], 1ll * f[i][j] * (j - 1) % mod);
}
printf("%d", f[n][1]);
return 0;
}
CF704B：
把 \(a_i\to a_i+x_i,b_i\to b_i-x_i,c_i\to c_i+x_i,d_i\to d_i-x_i\)。
\(w(i,j)=\left\{\begin{matrix}
d_i + a_j(i\lt j) \\
c_i + b_j(i\gt j)
\end{matrix}\right.\)
这样会发现 \(i,j\) 独立了。
剩下就没啥好说的了。
Code：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 5005;
int n, s, t;
int x[N], a[N], b[N], c[N], d[N];
ll f[2][N];
int cur;
void chkmin(ll &a, ll b) { if (a > b) a = b; }
int main() {
scanf("%d%d%d", &n, &s, &t);
for (int i = 1; i <= n; ++i) scanf("%d", &x[i]);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), a[i] += x[i];
for (int i = 1; i <= n; ++i) scanf("%d", &b[i]), b[i] -= x[i];
for (int i = 1; i <= n; ++i) scanf("%d", &c[i]), c[i] += x[i];
for (int i = 1; i <= n; ++i) scanf("%d", &d[i]), d[i] -= x[i];
memset(f[0], 0x3f, sizeof f), f[0][0] = 0;
for (int i = 0; i < n; ++i, cur ^= 1) {
memset(f[cur ^ 1], 0x3f, sizeof f[cur ^ 1]);
if (i + 1 == s) {
for (int j = (i + 1 > t); j <= i; ++j) {
if (j) chkmin(f[cur ^ 1][j], f[cur][j] + c[i + 1]);
chkmin(f[cur ^ 1][j + 1], f[cur][j] + d[i + 1]);
}
}
else if (i + 1 == t) {
for (int j = (i + 1 > s); j <= i; ++j) {
if (j) chkmin(f[cur ^ 1][j], f[cur][j] + a[i + 1]);
chkmin(f[cur ^ 1][j + 1], f[cur][j] + b[i + 1]);
}
}
else {
for (int j = (i + 1 > s) + (i + 1 > t); j <= i; ++j) {
if (j > (i + 1 > s)) chkmin(f[cur ^ 1][j], f[cur][j] + b[i + 1] + c[i + 1]);
if (j > (i + 1 > t)) chkmin(f[cur ^ 1][j], f[cur][j] + a[i + 1] + d[i + 1]);
if (j > 1) chkmin(f[cur ^ 1][j - 1], f[cur][j] + a[i + 1] + c[i + 1]);
chkmin(f[cur ^ 1][j + 1], f[cur][j] + b[i + 1] + d[i + 1]);
}
}
}
printf("%lld", f[cur][1]);
return 0;
}
