2023 5月 dp做题记录

目录

• 5月 dp做题记录
  • • P1064 [NOIP2006 提高组] 金明的预算方案
    • P1941 [NOIP2014 提高组] 飞扬的小鸟
    • P2679 [NOIP2015 提高组] 子串
    • P1850 [NOIP2016 提高组] 换教室
    • P2831 [NOIP2016 提高组] 愤怒的小鸟
    • P5020 [NOIP2018 提高组] 货币系统
    • P6064 [USACO05JAN]Naptime G
    • P9344 去年天气旧亭台
    • P4095 [HEOI2013]Eden 的新背包问题
    • P3174 [HAOI2009] 毛毛虫
    • P2340 [USACO03FALL]Cow Exhibition G
    • P4059 [Code+#1]找爸爸
    • P4342 [IOI1998]Polygon
    • CF149D Coloring Brackets
    • UVA12991 Game Rooms
    • Generate a String
    • Games with Rectangle
    • CF837D Round Subset
    • CF14D Two Paths
    • CF527D Clique Problem
    • P4310 绝世好题
    • P4158 [SCOI2009]粉刷匠
    • P1772 [ZJOI2006] 物流运输
    • P3861 拆分

5月 dp做题记录

P1064 [NOIP2006 提高组] 金明的预算方案 #

物体与物体之间有从属的限制关系，且从属关系只有一层，最多有两个个附件，所以我们很容易就可以想到列举出每一组的组合关系，毕竟每组最多四种组合，再跑一遍分组背包，从每组中至多选出一种组合，以满足限制条件。

P1941 [NOIP2014 提高组] 飞扬的小鸟 #

发现题目是一张 $n\times m$ 的地图，容易想到初始状态 $d{p}_{i,j}$ 为现在飞到第 $i$ 列，第 $j$ 行的最少跳跃次数，又发现是从左到右一列一列飞行，每一列只与上一列相关，所以可以用滚动数组滚掉一维。

再注意细节，如果跳跃过高是会顶格的，所以最高行是可以通过前一列所有小于跳跃高度的点转移的，这点要单独枚举。还有背包枚举顺序的问题，如果下落是不会再上升的，所以是先上升的 01 背包，再上升的完全背包，最后在下落的 01 背包，防止下落的状态被完全背包转移。

这题要注意的就是不能少转移，因为用的是滚动数组，前面的都要继承下来。

$\{\begin{array}{l}d{p}_{i,j}=min(d{p}_{i-1,j+y_i},d{p}_{i-1,j-x_i}+1)\\ d{p}_{i,m}=min(d{p}_{i,m},d{p}_{i-1,k}+1)(k+x_i\ge m)\\ d{p}_{i,j}=min(d{p}_{i,j},d{p}_{i,j-x_i}+1)\end{array}$

P2679 [NOIP2015 提高组] 子串 #

匹配问题，有状态 $d{p}_{i,j,k,0/1}$ 表示 $A$ 串中枚举到第 $i$ 位，匹配到了 $B$ 串的第 $j$ 位，选了 $k$ 段，并且第 $i$ 位选/不选的方案数，转移也很好写，写完发现第一维是可以滚动滚掉的，其余注意第二行 $d{p}_{i-1,j-1,k,0}$ 是不合法的，不能用这个转移就行。

初始状态 $d{p}_{0,0,0,0}=d{p}_{1,0,0,0}=1$。

$\{\begin{array}{l}d{p}_{i,j,k,0}=d{p}_{i-1,j,k,0}+d{p}_{i-1,j,k,1}\\ d{p}_{i,j,k,1}=d{p}_{i-1,j-1,k,1}+d{p}_{i-1,j-1,k-1,0}+d{p}_{i-1,j-1,k-1,1}(a_i=b_k)\end{array}$

答案为 $d{p}_{n,m,g,0}+d{p}_{n,m,g,1}$

#include <bits/stdc++.h>
using namespace std;
int read(){
    int x = 0, f = 1;
    char c = getchar();
    while(c < '0' || c > '9'){
        if(c == '-') f = -1;
        c = getchar();
    }
    while(c >= '0' && c <= '9'){
        x = (x << 1) + (x << 3) + (c - '0');
        c = getchar();
    }
    return x * f;
}
int n, m, g;
char a[1010], b[1010];
long long dp[2][210][210][2];
int main(){
    n = read(), m = read(), g = read();
    scanf("%s%s", a + 1, b + 1);
    dp[0][0][0][0] = dp[1][0][0][0] = 1;
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++){
            for(int k = 1; k <= g; k++){
                dp[i & 1][0][0][0] = 1, dp[i & 1 ^ 1][0][0][0] = 1, dp[i & 1][j][k][0] = 0, dp[i & 1][j][k][1] = 0;
                dp[i & 1][j][k][0] = (dp[i & 1 ^ 1][j][k][0] + dp[i & 1 ^ 1][j][k][1]) % 1000000007;
                if(a[i] == b[j]){
                    dp[i & 1][j][k][1] = (dp[i & 1 ^ 1][j - 1][k][1] + dp[i & 1 ^ 1][j - 1][k - 1][1] + dp[i & 1 ^ 1][j - 1][k - 1][0]) % 1000000007;
                }
            }
        }
    }
    cout << (dp[n & 1][m][g][0] + dp[n & 1][m][g][1]) % 1000000007 << endl;
    return 0;
} 

P1850 [NOIP2016 提高组] 换教室#

因为是选择性问题，所以状态就很套路，定义状态为 $d{p}_{i,j,0/1}$ 表示到了第 $i$ 堂课，用了 $j$ 次换课，第 $i$ 堂课换/不换的最大期望，转移长但好想，无非是成功的期望+失败的期望，四种情况，这次没换上次没换，这次没换上次换，这次换上次没换，这次换上次换，哪次成功就乘 $p_i$，失败就乘 $1-p_i$，注意上次换到 $d$，下次默认还是在 $c$，不会继承。

$\{\begin{array}{l}d{p}_{i,j,0}=min(d{p}_{i-1,j,0},d{p}_{i-1,j,1}+f_{c_{i-1,c_i}}\times p_i+f_{d_{i-1},c_i}\times (1-p_{i-1}))\\ d{p}_{i,j,1}=min(d{p}_{i-1,j-1,0}+f_{c_{i-1},d_i}\times p_i+f_{c_{i-1},c_i}\times (1-p_i),d{p}_{i-1,j-1,1}+f_{c_{i-1},c_i}\times (1-p_{i-1})\times (1-p_i)+f_{c_{i-1},d_i}\times (1-p_{i-1})\times p_i+f_{d_{i-1},c_i}\times p_{i-1}\times (1-p_i)+f_{d_{i-1},d_i}\times p_{i-1}\times p_i)\end{array}$

#include<bits/stdc++.h>
using namespace std;
int n, m, a, b;
int c[2010], d[2010];
double k[2010], ans, dp[2010][2010][2], f[310][310];
int main(){
	cin >> n >> m >> a >> b;
	for(int i = 1; i <= n; i++) cin >> c[i];
	for(int i = 1; i <= n; i++) cin >> d[i];
	for(int i = 1; i <= n; i++) cin >> k[i];
	for(int i = 1; i <= a; i++){
		for(int j = 1; j <= a; j++) f[i][j] = 2147483647;
	}
	for(int i = 1; i <= b; i++){
		int u, v;
		double w;
		cin >> u >> v >> w;
		f[u][v] = f[v][u] = min(f[u][v], w);
	}
	for(int k = 1; k <= a; k++){
		f[k][k] = 0;
		for(int i = 1; i <= a; i++){
			for(int j = 1; j <= a; j++){
				f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
			}
		}
	}
	for(int i = 1; i <= n; i++){
		for(int j = 0; j <= m; j++) dp[i][j][0] = dp[i][j][1] = 2147483647;
	}
	dp[1][0][0] = dp[1][1][1] = 0;
	for(int i = 2; i <= n; i++){
		for(int j = 0; j <= min(i, m); j++){
			dp[i][j][0] = min(dp[i - 1][j][0] + f[c[i - 1]][c[i]], dp[i - 1][j][1] + f[c[i - 1]][c[i]] * (1 - k[i - 1]) + f[d[i - 1]][c[i]] * k[i - 1]);
			if(j != 0) dp[i][j][1] = min(dp[i - 1][j - 1][0] + f[c[i - 1]][c[i]] * (1 - k[i]) + f[c[i - 1]][d[i]] * k[i], dp[i - 1][j - 1][1] + f[c[i - 1]][c[i]] * (1 - k[i - 1]) * (1 - k[i]) + f[c[i - 1]][d[i]] * (1 - k[i - 1]) * k[i] + f[d[i - 1]][c[i]] * k[i - 1] * (1 - k[i]) + f[d[i - 1]][d[i]] * k[i - 1] * k[i]);
		}
	}
	ans = 0x3f3f3f3f;
	for(int j = 0; j <= m; j++){
		ans = min(ans, dp[n][j][0]);
		if(j != 0) ans = min(ans, dp[n][j][1]);
	}
	cout << fixed << setprecision(2) << ans << endl;
	return 0;
}

P2831 [NOIP2016 提高组] 愤怒的小鸟#

这题需要一些数学知识，首先看数据范围，确定是状压 dp，简单的定义状态 $d{p}_S$ 为到 $S$ 状态的最少抛物线数，我们肯定不会去枚举子集，去判断差集能不能被一次穿过，而是想通过 $S$ 这个状态能给哪些状态转移。

横坐标不同的两点确定一条形式为 $y=a{x}^2+bx$ 的抛物线，$a$ 和 $b$ 都是可以解出来的

$\{\begin{array}{l}a{x}_1^2+b{x}_1=y_1\\ a{x}_2^2+b{x}_2=y_2\end{array}$

②式 $\Rightarrow a{x}_2^2{\displaystyle \frac{x_1}{x_2}}+b{x}_2{\displaystyle \frac{x_1}{x_2}}=y_2{\displaystyle \frac{x_1}{x_2}}$

$\Rightarrow a{x}_1{x}_2+b{x}_1={\displaystyle \frac{y_2{x}_1}{x_2}}$ ③式

①-③ $(x_1{x}_2-x_1^2)a={\displaystyle \frac{y_2{x}_1}{x_2}}-y_1={\displaystyle \frac{y_2{x}_1-y_1{x}_2}{x_2}}$

$a={\displaystyle \frac{y_2{x}_1-y_1{x}_2}{x_2}}\times {\displaystyle \frac{1}{x_1{x}_2-x_1^2}}={\displaystyle \frac{y_2{x}_1-y_1{x}_2}{x_1{x}_2^2-x_1^2{x}_2}}$

同理得，$b={\displaystyle \frac{y_1{x}_2^2-y_2{x}_1^2}{x_1{x}_2^2-x_1^2{x}_2}}$

$n^2$ 预处理一下每两个点连成的抛物线上能有多少点，二进制保存一下

$\{\begin{array}{l}d{p}_{S|(1<<(j-1))}=min(d{p}_{S|(1<<(j-1))},d{p}_S+1)\\ d{p}_{S|lin{e}_{j,k}}=min(d{p}_{S|lin{e}_{j,k}},d{p}_S+1)\end{array}$

这样的复杂度是 $O(T{n}^2{2}^n)$ 的，要过这题还要优化到 $O(Tn{2}^n)$ ，因为抛物线选择的顺序是不影响结果的，最后我们所有小猪都要全部得到，所以 $n^2$ 枚举所有抛物线的时候，实际上是枚举了原有的抛物线和很远之后的抛物线的，优化的大部分是很远之后的抛物线，这部分会一直重复不断的枚举，但有用的只有一次，所以我们强制选择一下，每次强制选经过最小的没被经过的点的抛物线，这样的抛物线只有 $n$ 条，这样从 $0$ 穷举到 $2^n-1$ 都是有顺序的选抛物线，不存在重复选和提早选，复杂度优化到 $O(Tn{2}^n)$ 。

#include<bits/stdc++.h>
using namespace std;
int t, n, m;
double eps = 1e-8, x[20], y[20];
int line[20][20], dp[1 << 20], lowbit[1 << 20];
void findline(double &a, double &b, double x1, double y1, double x2, double y2){
	a = -(y1 * x2 - y2 * x1) / (x2 * x2 * x1 - x1 * x1 * x2);
	b = (y1 * x2 * x2 - y2 * x1 * x1) / (x1 * x2 * x2 - x2 * x1 * x1);
}
int main(){
	cin >> t;
	for(int i = 0; i < (1 << 18); i++){
		for(int j = 1; j <= 18; j++){
			if((i & (1 << (j - 1))) == 0){
				lowbit[i] = j;
				break;
			}
		}
	}
	while(t--){
		memset(line, 0, sizeof(line));
		memset(dp, 1, sizeof(dp));
		cin >> n >> m;
		for(int i = 1; i <= n; i++){
			scanf("%lf%lf", &x[i], &y[i]);
		}
		for(int i = 1; i <= n; i++){
			for(int j = 1; j <= n; j++){
				if(fabs(x[i] - x[j]) < eps) continue;
				double a, b;
				findline(a, b, x[i], y[i], x[j], y[j]);
				if(a > -eps) continue;
				for(int k = 1; k <= n; k++){
					if(fabs(a * x[k] * x[k] + b * x[k] - y[k]) < eps) line[i][j] |= (1 << (k - 1));
				}
			}
		}
		dp[0] = 0;
		for(int i = 0; i < (1 << n) - 1; i++){
			int j = lowbit[i];
			dp[i | (1 << (j - 1))] = min(dp[i | (1 << (j - 1))], dp[i] + 1);
			for(int k = 1; k <= n; k++) dp[i | line[j][k]] = min(dp[i | line[j][k]], dp[i] + 1);
		}
		cout << dp[(1 << n) - 1] << endl;
	}
	return 0;
}

P5020 [NOIP2018 提高组] 货币系统#

要把 $n$ 个数能表示出的数尽可能用最少的数表示出来，我们首先可以探究一下 $(n,a)$ 与 $(m,b)$ 之间的关系。
$(n,a)$ 表示为集合 $A$，$(m,b)$ 表示为集合 $B$，要让 $(n,a)=(m,b)$，我们建的集合 $B$ 表示出的数不能有 $A$ 没有的，所以我们深入挖掘一下，如果 $B$ 中用的数不是 $A$ 中有的，我们担心这些数 $A$ 表示不出来，即可以用不在 $A$ 里的数来表示 $A$ 的数吗？

我们想验证的猜想其实就是证 $B\subseteq A$。我们发现每个集合中的数分为两类，第一类是不能被别人表示的数，第二类是能被别人表示的数，并且容易发现二类数一定能拆分成只用一类数的拼法（因为二类数可以一直拆，如果拆出二类数，那这个数还可以一直拆，直到不能再拆）。

要证 $B\subseteq A$，因为一类数比较特殊，在 $A$ 中不可少，所以首先可以证 $A$ 中的一类数是否一定属于 $B$。用反证法，假设一类数 $x\subseteq A$，且 $x⊈B$，那么根据 $(n,a)=(m,b)$，$B$ 中一定存在一些一类数能表示出 $x$，这些一类数中一定存在至少一个数不在 $A$ 中（如果都在 $A$ 中，那 $x$ 就不是一类数了），与 $(n,a)=(m,b)$ 矛盾，命题得证。

有了这个结论，就可以证 $B\subseteq A$ 了，反证法，假设 $x\subseteq B$，且 $x⊈A$，那么 $A$ 中一定存在一些一类数能表示出 $x$，根据上面的结论，这些一类数同时也在 $B$ 中，那么这些数本身就能表示出 $x$ 了，为什么 $B$ 里还要加一个 $x$ 呢，根据 $m$ 最小，得出 $x$ 是多余的，所以就不会存在 $x$ 这种数，也就是 $B\subseteq A$ 了。

知道了 $B\subseteq A$ 这题就简单了，题目就变成：求 $A$ 中最少能留几个数，把所有数表示出来。首先，$A$ 中的一类数一定都得在 $B$ 中，然后容易发现，剩下的都是二类数，直接就都能被一定得选的一类数表示出来，这样，不需要多的数，既然必选的数能表示出原来的 $A$，自然也就可以表示出 $(n,a)$，所以 $A$ 中的一类数数量就是答案了。中我们把所有数排序，做完全背包，如果当前枚举的数不能被之前小的数表示出来，它就是一类数，答案就是这些数的个数。

P6064 [USACO05JAN]Naptime G#

对于每一段，我们都有睡或不睡两种选择，并且是选段问题，并且当前的效用值有没有贡献取决于上一次有没有睡觉，所以我们的状态可以是 $d{p}_{i,j,0/1}$ 表示当前在第 $i$ 段，选了 $j$ 段睡觉，当前第 $i$ 段睡/ 不睡的最大总效用值。

$\{\begin{array}{l}d{p}_{1,0,0}=d{p}_{1,1,1}=0\\ d{p}_{i,j,0}=max(d{p}_{i-1,j,0},d{p}_{i-1,j,1})\\ d{p}_{i,j,1}=max(d{p}_{i-1,j-1,0},d{p}_{i-1,j-1,1}+a_i)\end{array}$

如果这题不可以睡到第二天早上，那么就这样就行了，但是我们发现这题是可以从第一天连着睡到第二天的前几段的。但是容易发现这其中的区别其实就是多了第一段的效用值，其他段并没有影响，因为每一段还是都只能睡一次，不会重复睡。这里有一个技巧，可以把睡觉分为两种情况，一种没有第一段，另一种强制选第一段。在初始化时，把 $d{p}_{1,0,0}=d{p}_{1,1,1}=a_1$ 就行了。

P9344 去年天气旧亭台 #

选若干段区间 $[i,j]$ （满足 $c_i=c_j$）覆盖整个区间，使得 $\sum a_i+a_j$ 最小。因为选区间的顺序是不影响答案的，所以我们可以从左到右考虑，设状态 $d{p}_i$ 表示覆盖 $[1,i]$ 用的最小费用，发现选的区间一定是一个紧贴着一个的，$d{p}_i$ 跟前面所有的 $d{p}_j$ 都相关，枚举断点 $j$，可以得出朴素的转移方程是

$$d{p}_i=\underset{j\le i}{min}(d{p}_{j-1}+a_j)+a_i(c_j=c_i)$$

每次都要枚举前面所有的 $d{p}_j$ 这样的方程复杂度是 $O(n^2)$ 的。但是我们很容易可以发现，之前处理的 $min$ 之后还可以用，只不过每次处理完多一个 $d{p}_i+a_{i+1}$ 而已，所以 $min$ 里面的值是可以继承的，也就是枚举 $i$ 的时候，就可以一边处理出当前最小的 $min$，考虑到 $c_j=c_i$ 的限制，我们把 $min$ 分成 $c_j=c_i=0$ 和 $c_j=c_i=1$ 两种情况，分别更新就行了。这样 $c_i=0/1$ 时，就可以直接取出前面实时更新的 $min$ 来 $O(1)$ 更新 $d{p}_i$ 了。

P4095 [HEOI2013]Eden 的新背包问题 #

对于每一次询问，给出不能选的一个物品 $d$，和最大价钱 $e$，做多重背包后的最大价值。如果每一次询问都做一次多重背包，肯定超时。我们回归背包的最原始状态 $d{p}_{i,j}$ 表示前 $i$ 个物品，最大价钱为 $j$ 能得到的最大价值。对于前 $i$ 个，如果不能选的是第 $i$ 个，那么容易知道答案是 $d{p}_{i-1,j}$。回到这题，我们还要考虑 $i$ 后面的最大价值，其实 $i$ 在整个序列中就充当一个分隔左右两部分的隔板，所以我们把 $i$ 分成前 $i$ 个和后 $n-i$ 个两种，分开考虑，每一种里，$i$ 都是最后一个，所以可以正着和反着分别做一遍多重背包，知道了 $i$ 前缀和后缀的 $dp$ 值，再枚举前面用的价钱 $v$，后面的就是 $e-v$ 了，左右两段 $dp$ 值相加就是答案。

答案即 $ans=max(ans,dp{1}_{l_d,i}+dp{2}_{r_d+1,e-i})$

其中 $l_i$ 和 $r_i$ 表示二进制拆分后，一个物体的左端点和右端点。

P3174 [HAOI2009] 毛毛虫 #

要找到一条链，使得链上的点加上点延伸出去的点最多，我们可以发现，对于一个点 $u$，如果在他的子树下连出了两条边，那么链就一定在子树里了。树中的每一条链我们都可以找到这样一个点，使得链在这个点的子树里。只要 $u$ 连出的边超过两条，在这个点下面的链肯定是连出两条的这种，并且我们希望这条链最大，肯定是连出的两条边的贡献都最大；除非是链，我们才会只连出一条边。所以我们设状态 $d{p}_{u,0/1/2}$ 表示在 $u$ 中连出了 $0/1/2$ 条边。转移中，对于他的子节点可以继续往下连，也可以到这就停止，$d{p}_{u,2}$ 其实就是统计的作用的，他们不会用来转移。

$\{\begin{array}{l}d{p}_{u,0}=s{z}_u\\ d{p}_{u,1}=max(d{p}_{u,1},max(d{p}_{v,1},d{p}_{v,0}))\\ d{p}_{u,2}=s{z}_u+maxn1+maxn2-1/s{z}_u+maxn1/s{z}_u\end{array}$

$s{z}_u$ 表示包括自己加上连出的点，两个 $maxn$ 分别为子树里的最长和次长，注意点 $u$ 的父亲也会被拓展，一定不要自以为是去掉然后漏了QWQ。

这题的状态还可以更简单一点，可以去掉 $0/1/2$ 这一维，因为不选其实囊括在 $d{p}_{u,1}$ 里了，不选一定是不优的（既然都走到 $v$ 了，不往下不就亏了）。

后面学完了树的直径，这题还可以更简单，其实就是我们现在每个点的最长链不是 $0$ 了，而是它所连出的边数加上自己，基于此，加上树的直径的 $dp$ 求法，设状态为 $d{p}_i$ 表示以 $i$ 为根的子树的最长链是多少，转移和直径一模一样。

$\{\begin{array}{l}ans=max(ans,d{p}_u+d{p}_v-1)\\ d{p}_u=max(d{p}_u,d{p}_v+s{z}_u-1)\end{array}$

$-1$ 是因为多算了一遍 $u$ 节点。

P2340 [USACO03FALL]Cow Exhibition G #

这题虽然是黄题，但是让我注意到了之前 $01$ 背包时没有注意到的细节。

要求在满足智商情商非负的情况下，智商情商和最大。我们平时写 $01$ 背包，一般都不会初始化，因为我们一般只需要直接用到 $d{p}_m$ 就可以了，它表示的是前 $n$ 个，最多花费 $m$ 的最大价值，$m$ 是虚值，并不是我们真正用的重量，这也是我们为什么可以不初始化 $d{p}_0=0$，其他的 $d{p}_i=-inf$。由于状态中描述是最多，说明前面用的重量是多少我们不在意，所以这样 $d{p}_{j-w_i}$ 就可以从随便一个地方开始（可以理解成假设前面用了一些价值是 $0$ 的物品，把背包塞到了 $j-w_i$），因为状态都是 $0$，前面有贡献的自然会转移，没有就直接用 $0$ 的价值转移，所以 $d{p}_m$ 是正确的，因为不需要里面重量到底用了多少，只想知道价值直接查询 $d{p}_m$ 就行了，不需要一个个枚举重量多少。

但我们想在这题里面同时知道智商和情商的花费情况，我们就需要初始化了，因为发现如果初始化了，状态描述就变成了 $d{p}_{i,j}$ 表示前 $i$ 个物品，装到 $j$ 重量的最大价值。因为此时我们只能从 $d{p}_{0,0}$ 转移，每一个 $j$ 都是真实能够达到的。

所以在这题里，我们随便用一个智商表示重量，求此时情商最大。防止数组越界，我们把重量加一个大的值。最后我们枚举正的智商 $i$，这时候如果智商 $i$ 能被组合出来，$d{p}_i$ 就不会是 $-inf$，$ans=i+d{p}_i-inf$。

P4059 [Code+#1]找爸爸 #

序列匹配问题，一般状态 $d{p}_{i,j}$ 表示 $A$ 序列前 $i$ 个，匹配了 $B$ 序列前 $j$ 个的最大价值。但是我们发现这样子对于这题还不够，因为每一位的匹配不能表示出来，不能计算贡献，所以考虑多加一维表示目前对齐完最后一位的情况

$\bullet$ 两个都是字母

$\bullet$ $A$ 序列是空格，$B$ 序列是字母

$\bullet$ $A$ 序列是字母，$B$ 序列是空格

$\bullet$ 两个都是空格

我们观察四个情况，很容易发现最后一个情况是对答案一定是负面影响，因为我们加空格，是为了接近匹配的目标，而第四种不仅接近不了目标，还减少相似度，所以可以直接去掉。

最后我们的状态 $d{p}_{i,j,0/1/2}$ 表示 $A$ 序列前 $i$ 个，通过空格，匹配了 $B$ 序列前 $j$ 个，且对齐后当前的情况为上面说的 $0/1/2$ 三种之一。如果是 $d{p}_{i,j,0}$，没有用空格，那么它上一个状态就是匹配数都少一个，为 $d{p}_{i-1,j-1,0}/d{p}_{i-1,j-1,1}/d{p}_{i-1,j-1,2}$；如果是 $d{p}_{i,j,1}$，$A$ 目前的最后一位用空格，那么上一个状态就是少了一行后， $i$ 不变（因为肯定这 $i$ 不是在当前行匹配的），$j$ 少一个为 $d{p}_{i,j-1,0}/d{p}_{i,j-1,1}/d{p}_{i,j-1,2}$；如果是 $d{p}_{i,j,2}$，$B$ 目前的最后一位用空格，那么和上一个同理。

$\{\begin{array}{l}d{p}_{i,j,0}=max(d{p}_{i-1,j-1,0},d{p}_{i-1,j-1,1},d{p}_{i-1,j-1,1})+d_{a_i,b_i}\\ d{p}_{i,j,1}=max(d{p}_{i,j-1,0}-a,d{p}_{i,j-1,1}-b,d{p}_{i,j-1,2}-a)\\ d{p}_{i,j,2}=max(d{p}_{i-1,j,0}-a,d{p}_{i-1,j,1}-a,d{p}_{i-1,j,2}-b)\end{array}$

注意这题的初始化比较多，大多是不可能达到或者不优的，比如 $d{p}_{i,0,1}=d{p}_{0,i,2}=d{p}_{i,0,0}=d{p}_{0,i,0}=-inf$，前面两个是一定不优（两个空格），后两个是不存在这样的方案。还有的是 $d{p}_{0,i,1}=d{p}_{i,0,2}=-A-B(i-1)$ 表示对 $A/B$ 序列补了 $i$ 个空格的费用。

这题细节还是多，要把细节好好回味一下

#include <bits/stdc++.h>
using namespace std;
int read(){
    int x = 0, f = 1;
    char c = getchar();
    while(c < '0' || c > '9'){
        if(c == '-') f = -1;
        c = getchar();
    }
    while(c >= '0' && c <= '9'){
        x = (x << 1) + (x << 3) + (c - '0');
        c = getchar();
    }
    return x * f;
}
string A, B;
int x, y;
int a[3010], b[3010], d[6][6], dp[3010][3010][3];
int find(char a){
    if(a == 'A') return 1;
    if(a == 'T') return 2;
    if(a == 'G') return 3;
    return 4;
}
int main(){
    cin >> A >> B;
    int n = A.length(), m = B.length();
    for(int i = 0; i < n; i++) a[i + 1] = find(A[i]);
    for(int i = 0; i < m; i++) b[i + 1] = find(B[i]);
    for(int i = 1; i <= 4; i++){
        for(int j = 1; j <= 4; j++) cin >> d[i][j];
    }
    cin >> x >> y;
    for(int i = 1; i <= max(n, m); i++){
        dp[i][0][0] = dp[0][i][0] = dp[i][0][1] = dp[0][i][2] = -0x3f3f3f3f;
        dp[i][0][2] = dp[0][i][1] = -x - y * (i - 1);
    }
    dp[0][0][1] = dp[0][0][2] = -0x3f3f3f3f;
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++){
            dp[i][j][0] = max(dp[i - 1][j - 1][0], max(dp[i - 1][j - 1][1], dp[i - 1][j - 1][2])) + d[a[i]][b[j]];
            dp[i][j][1] = max(dp[i][j - 1][0] - x, max(dp[i][j - 1][1] - y, dp[i][j - 1][2] - x));
            dp[i][j][2] = max(dp[i - 1][j][0] - x, max(dp[i - 1][j][1] - x, dp[i - 1][j][2] - y));
        }
    }
    cout << max(dp[n][m][0], max(dp[n][m][1], dp[n][m][2])) << endl;
    return 0;
}

P4342 [IOI1998]Polygon#

一眼环形 $dp$，并且是环形 $dp$ 中经典的合并性问题，对于这种问题，我们可以很套路的断环成链，即把原序列复制一份到它自身后面。其原理支撑就是环形问题中具有区间 dp 的性质（连续性）时，往往会发现在任意一种方案中都有至少一对相邻关系用不上，也就是一圈里有一条边会用不上。并且这个性质还和题目中去掉一条边完美吻合。

这道题就是普通的合并，所以设状态 $d{p}_{i,j}$ 表示区间 $[i,j]$ 合并的最大价值，转移也很好列

$\{\begin{array}{l}d{p}_{i,j}=max(d{p}_{i,j},d{p}_{i,k}+d{p}_{k+1,j})(c_{k+1}{=}^{\prime }{t}^{\prime })\\ d{p}_{i,j}=max(d{p}_{i,j},d{p}_{i,k}\times d{p}_{k+1,j})(c_{k+1}{=}^{\prime }{x}^{\prime })\end{array}$

但是我们发现，这样子每次区间都取最大最后合并出的不一定是最大的，原因就是数字中有负数，有可能我们的区间是负数乘负数得出的最大值。所以我们思考一下，发现大区间最大价值只跟小区间的最大值和最小值有关。所以我们可以维护两个状态 $f_{i,j}$ 和 $g_{i,j}$ 分别表示区间 $[i,j]$ 合并后的最大价值/最小价值。

分类讨论，断点是加法，最大值和最小值互不影响；断点是乘法，排列组合一下，最大乘最大，最大乘最小，最小乘最大，最大乘最小，最大值最小值乘法都一样。

$\{\begin{array}{l}{f}_{i,j}=max(f_{i,j},f_{i,k}+f_{k+1,j})(c_{k+1}{=}^{\prime }{t}^{\prime })\\ f_{i,j}=max(f_{i,j},f_{i,k}\times f_{k+1,j},g_{i,k}\times g_{k+1,j},g_{i,k}\times f_{k+1,j},f_{i,k}\times g_{k+1,j})(c_{k+1}{=}^{\prime }{x}^{\prime })\\ g_{i,j}=min(g_{i,j},g_{i,k}+g_{k+1,j})(c_{k+1}{=}^{\prime }{t}^{\prime })\\ g_{i,j}=min(g_{i,j},f_{i,k}\times f_{k+1,j},g_{i,k}\times g_{k+1,j},g_{i,k}\times f_{k+1,j},f_{i,k}\times g_{k+1,j})(c_{k+1}{=}^{\prime }{x}^{\prime })\end{array}$

答案便为 $max(f_{i,i+n-1})$，遍历一遍就行了。回到之前的性质，如果一个环形的合并状态表示为 $f_{i,i+n-1}$，那么它没用上的一条边就是 $i-1$，所以第二问也就解决了。

CF149D Coloring Brackets#

一道经典的区间染色题，特别的是由于括号的原因，任意的一段区间不一定是合法的，这些本身就不合法的区间是不好用来转移的。

我们要让状态转移，关心的地方就是题目给出的性质，两两相邻的括号颜色不同，而区间上特别的就是两个端点，这是从小区间转移到大区间我们最需要考虑的两点，所以我们设状态 $d{p}_{l,r,0/1/2,0/1/2}$ 表示 $[l,r]$ 区间合法的染色方案数，当前左端点为没染色/染红色/染蓝色，右端点为没染色/染红色/染蓝色，并且默认 $[l,r]$ 区间为合法配对的括号序列。

状态列出来，我们要考虑最开始的问题，怎样保证每次转移的状态都是配对的括号序列呢？递推是不好排除特殊情况的。很简单的想法就是我们自己考虑往哪转移，可以用记忆化搜索，从大的合法序列推向小的合法序列。

首先，每个左括号对应的右括号是可以预处理出来的，用栈模拟匹配括号，看到左括号就推进去；看到右括号，它对应的一定是栈顶的左括号。

我们考虑一个合法的括号序列 $[l,r]$：

$\bullet$ 如果左右端点是配对的，那么它的小的合法序列就是去掉外面的，为 $[l+1,r-1]$

$\bullet$ 如果左右端点不配对，那么序列就由两个合法序列拼起来构成，我们找到左端点配对的右括号位置（一定在 $[l,r]$ 内），那另一半也是合法的，为 $[l,c_l]$ 和 $[c_l+1,r]$

初始状态就是当 $l+1=r$ 时，括号一定是长这样 $()$，显然有 $d{p}_{l,r,0,1}=d{p}_{l,r,0,2}=d{p}_{l,r,1,0}=d{p}_{l,r,2,0}=1$

对于第一种情况，我们先递归 $[l+1,r-1]$，然后枚举端点的颜色：

$\{\begin{array}{l}d{p}_{l,r,0,1}=d{p}_{l,r,0,1}+d{p}_{l+1,r-1,i,j}(j\ne 1)\\ d{p}_{l,r,0,2}=d{p}_{l,r,0,2}+d{p}_{l+1,r-1,i,j}(j\ne 2)\\ d{p}_{l,r,1,0}=d{p}_{l,r,1,0}+d{p}_{l+1,r-1,i,j}(i\ne 1)\\ d{p}_{l,r,2,0}=d{p}_{l,r,2,0}+d{p}_{l+1,r-1,i,j}(i\ne 2)\end{array}$

对于第二种情况，先递归求出 $[l,c_l]$ 和 $[c_l+1,r]$，根据乘法原理，方案就是左边的方案乘右边的方案，注意的是两个序列拼起来的两点颜色要不一样，并且可以都不涂色（可能会被当做颜色相同）

$d{p}_{l,r,i,j}=d{p}_{l,r,i,j}+d{p}_{l,c_l,i,p}\times d{p}_{c_{l+1},r,q,j}(p\ne qorp=q=0)$

这题由于区间的是否合法性（毕竟只有先合法才能转移），可以用记忆化搜索，自己考虑往合法的区间递归。

/*
 * @Author: Fire_Raku 
 * @Date: 2023-05-21 12:06:46 
 * @Last Modified by: Fire_Raku
 * @Last Modified time: 2023-05-21 12:22:05
 */
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int read(){
    int x = 0, f = 1;
    char c = getchar();
    while(c < '0' || c > '9'){
        if(c == '-') f = -1;
        c = getchar();
    }
    while(c >= '0' && c <= '9'){
        x = (x << 1) + (x << 3) + (c - '0');
        c = getchar();
    }
    return x * f;
}
char s[710];
long long c[710], dp[710][710][3][3], ans;
stack<int> st; 
void dfs(int l, int r){
    if(l + 1 == r){
        dp[l][r][0][1] = dp[l][r][1][0] = dp[l][r][2][0] = dp[l][r][0][2] = 1;
        return;
    }
    if(c[l] == r){
        dfs(l + 1, r - 1);
        for(int i = 0; i <= 2; i++){
            for(int j = 0; j <= 2; j++){
                if(j != 1) dp[l][r][0][1] += dp[l + 1][r - 1][i][j], dp[l][r][0][1] %= mod;
                if(j != 2) dp[l][r][0][2] += dp[l + 1][r - 1][i][j], dp[l][r][0][2] %= mod;
                if(i != 1) dp[l][r][1][0] += dp[l + 1][r - 1][i][j], dp[l][r][1][0] %= mod;
                if(i != 2) dp[l][r][2][0] += dp[l + 1][r - 1][i][j], dp[l][r][2][0] %= mod;
            }
        }
        return;
    }
    else{
        dfs(l, c[l]), dfs(c[l] + 1, r);
        for(int i = 0; i <= 2; i++){
            for(int j = 0; j <= 2; j++){
                for(int k = 0; k <= 2; k++){
                    for(int p = 0; p <= 2; p++){ 
                        if((k != p) || (!k && !p)) dp[l][r][i][j] += (dp[l][c[l]][i][k] * dp[c[l] + 1][r][p][j]) % mod;
                    }
                }
            }
        }
        return;
    }
}
int main(){
    cin >> s + 1;
    int n = strlen(s + 1);
    for(int i = 1; i <= n; i++){
        if(s[i] == ')'){
            c[st.top()] = i;
            c[i] = st.top();
            st.pop();
        }
        else st.push(i);
    }
    dfs(1, n);
    for(int i = 0; i <= 2; i++){
        for(int j = 0; j <= 2; j++) ans += dp[1][n][i][j], ans %= mod;
    }
    cout << ans << endl;
    return 0;
}

UVA12991 Game Rooms#

求如何放乒乓球桌和游泳池，才能让楼层的人移动总和最小。状态里肯定有当前位置放的是什么来转移，并且因为放的数量没有限制，我们肯定的全放满最优。然后我们观察他们移动的距离，如果放的是乒乓球桌，那么喜欢游泳池的人们，就要走到离他们最近的游泳池，换句话说，就是走出他们所在的极大乒乓球区间，放游泳池同理。所以我们有一个结论，可以把楼层分为一个个连续的兵乓球桌区间和游泳池区间，并且一个区间固定，他里面的人们移动的总距离也就确定。

我们可以预处理出人们移动的距离，$O(1)$ 计算。因为距离跟走的楼层有关，所以不能用一阶前缀和表示，用二阶前缀和，即前缀和的前缀和。

$\{\begin{array}{l}pre{p}_i=pre{p}_{i-1}+pr{e}_i\\ pre{p}_i=i\times a_1+(i-1)\times a_2+\cdot \cdot \cdot a_i\end{array}$

它一阶一阶的，很像我们要的距离。设区间 $[l,r]$ 的人都要往右走到 $r+1$，总距离可以表示成 $di{s}_{l,r}=pre{p}_r-pre{p}_{l-1}-(r-l+1)\times pr{e}_{l-1}$。相当于减去了 $[1,l-1]$ 中算的 $a_1-a_{l-1}$ 和 $[l,r]$ 中算的 $a_1-a_{l-1}$。

显然，如果区间 $[l,r]$ 两边都可以走人，那么有 $mid=(l+r)>>1$，$[l,mid]$ 走左边， $[mid+1,r]$ 走右边。

有了这个，我们还需要状态。我们需要知道同色区间，但是现在两端都不知道在哪。这题里我们要转移，就必须要知道某一段全是同一种的区间。而如果我们用区间 dp，很难去表示它（因为 $d{p}_{l,r}$ 表示全是同一种颜色的话，最后 $d{p}_{1,n}$ 是啥呢；如果不是同一种，那么我们枚举这段区间有什么用呢），最简单的，区间 dp 复杂度 $O(n^3)$，通过不了本题。所以我们考虑固定右端点，去枚举它的左端点，它们之间是同色段。设状态 $d{p}_{i,0/1}$ 表示已经考虑完前 $i$ 个，第 $i$ 个放乒乓球桌/游泳池的最小总距离，转移跟上面说的一样。

$\{\begin{array}{l}d{p}_{i,0}=\underset{0\le j<i}{min}(d{p}_{j,1}+cost(j+1,i,0))\\ d{p}_{i,1}=\underset{0\le j<i}{min}(d{p}_{j,0}+cost(j+1,i,1))\end{array}$

$cost(l,r,co)$ 表示区间 $[l,r]$ 染 $co$ 色的代价。这样，我们既可以考虑到同色段，也考虑到了同色段之外的段的贡献，并且我们固定了右端点，就不需要考虑右端点右边的代价（因为不管右边怎么变，左边的代价还是只跟左边有关）。最后答案是 $min(d{p}_{n,0},d{p}_{n,1})$。

#include<bits/stdc++.h>
using namespace std;
int T, n, cas;
long long pre[4010][2], suf[4010][2], prep[4010][2], suff[4010][2], t[4010], p[4010], dp[4010][2];
void init(){
	memset(pre, 0, sizeof(pre));
	memset(suf, 0, sizeof(suf));
	memset(prep, 0, sizeof(prep));
	memset(suff, 0, sizeof(suff));
} 
long long cost(int l, int r, int co){
	if(l == 1 && r == n) return 0x3f3f3f3f3f3f3f; 
	if(l == 1) return prep[r][co];
	if(r == n) return suff[l][co];
	int mid = (l + r) >> 1;
	long long tot = 0;
	tot += suff[l][co] - suff[mid + 1][co] - (mid - l + 1) * suf[mid + 1][co];
	tot += prep[r][co] - prep[mid][co] - (r - mid) * pre[mid][co];
	return tot;
}
int main(){
	cin >> T;
	for(int k = 1; k <= T; k++){
		init();
		cas++;
		cin >> n;
		for(int i = 1; i <= n; i++){
			cin >> t[i] >> p[i];
			pre[i][0] = pre[i - 1][0] + t[i];
			pre[i][1] = pre[i - 1][1] + p[i];
			prep[i][0] = prep[i - 1][0] + pre[i][0];
			prep[i][1] = prep[i - 1][1] + pre[i][1];
		}
		for(int i = n; i >= 1; i--){
			suf[i][0] = suf[i + 1][0] + t[i];
			suf[i][1] = suf[i + 1][1] + p[i];
			suff[i][0] = suff[i + 1][0] + suf[i][0];
			suff[i][1] = suff[i + 1][1] + suf[i][1];
		}
		for(int i = 1; i <= n; i++) dp[i][0] = dp[i][1] = 0x3f3f3f3f3f3f3f;
		dp[0][0] = dp[0][1] = 0;
		for(int i = 1; i <= n; i++){
			for(int j = 0; j < i; j++){
				dp[i][0] = min(dp[i][0], dp[j][1] + cost(j + 1, i, 0));
				dp[i][1] = min(dp[i][1], dp[j][0] + cost(j + 1, i, 1));
			}
		}
		cout << "Case #" << cas << ": " << min(dp[n][0], dp[n][1]) << endl;
	}
	return 0;
}

P3959 [NOIP2017 提高组] 宝藏

简化题意，要在原图上找一颗生成树覆盖所有边，并且每个点连它的父亲的长度乘上到根的距离的和最短。

看到数据范围，猜测它是状压 dp。考虑当前连了多少点，并且由于转移跟点到根的距离有关，我们可能会设 $d{p}_{i,j}$ 表示以 $i$ 为根，状态为 $j$ 的最小代价。但是我们仔细想会发现这样还是不好转移（因为根不变，只有状态还是不能转移，并且我们还是不知道距离，并且，节点状态为本身时，它就是根节点，而且根节点不能转移，一看就是多余的）。

我们再观察树，因为是一颗树，所以点到根的距离其实就是它的深度，把树整理好它会是一层一层的，并且如果要到更远的点，前面一定会先走更近的点。树中有一个东西和距离很像，树高。它相当于表示目前最远的一些点离根的距离，或许可以用它来转移，因为当前的树高确定下来，只需要知道最后一层的节点，就可以知道代价，各个树高之间是可以转移的。

设状态 $d{p}_{i,j}$ 表示当前树高为 $i$，已选节点状态为 $j$ 时的最大价值。我们一层一层来转移状态，要算 $d{p}_{i,j}$，我们只需要再枚举树高 $i-1$ 时的状态 $k$，也就是 $j$ 的子集，转移就是

$$d{p}_{i,j}=\underset{k\in j}{min}(d{p}_{i-1,k}+cos{t}_{k,j}\times (i-1))$$

$cos{t}_{k,j}$ 表示从状态 $k$ 到状态 $j$ 的最小代价。这个是可以预处理出来的，因为我们从上一层到下一层，有且仅会经过一条边，所以这里的状态 $k$ 到状态 $j$，中间是不会经过其他点的，所以从 $k$ 变成 $j$ 需要的点一定只需要通过 $k$ 中其中一个点的一条边就能连接。所以总最小代价就是每个需要的点连接到状态 $k$ 里的最小代价之和。两个不能转移的状态直接赋值成极大值。

到这里，问题是，我们枚举的子集 $k$ 与原集合 $j$ 产生的差集一定会在第 $i$ 层吗？好像不能确定，如果是这样那么这么转移不会是错解吗？但是我们可以证明这是不会影响答案的，也就是差集不管在不在第 $i$ 层，最终答案都不会是由错误的计算更新的。

证：设 $p$ 为 $j$ 和 $k$ 的差集，假设 $p$ 中的有一些点不是由 $k$ 中的最大深度的点连接，那么一定存在一个集合 $q$，为集合 $k$ 再加上这些不是由 $k$ 的最大深度的点连接的点，从这个状态 $d{p}_{i-1,q}$ 转移一定会覆盖掉 $d{p}_{i-1,k}$ 这样的不优解（因为不在最深层的边你也按最深层的代价计算了，结果肯定会被 $q$ 这样把算错的点包含起来的状态（相当于 $p$ 改错好的状态）覆盖），证毕。

#include<bits/stdc++.h>
using namespace std;
int n, m;
long long ans = 0x3f3f3f3f3f3f3f3f;
long long dp[15][1 << 14], f[15][15], po[15], cost[1 << 13][1 << 13];
int main(){
	cin >> n >> m;
	memset(f, 0x3f, sizeof(f));
	for(int i = 1; i <= m; i++){
		int u, v;
		long long w;
		cin >> u >> v >> w;
		f[u][v] = f[v][u] = min(f[u][v], w);
	}
	po[0] = 1;
	for(int i = 1; i <= n; i++){
		po[i] = po[i - 1] * 2;
	}
	for(int i = 1; i < (1 << n); i++){
		for(int j = i; j; j = (j - 1) & i){
			bool flg = 0;
			int now = i ^ j;
			for(int p = n; p >= 1; p--){
				long long minn = 0x3f3f3f3f3f3f3f3f;
				if((po[p - 1] & now) == po[p - 1]){
					for(int q = 1; q <= n; q++){
						if((po[q - 1] & j) == po[q - 1]){
							minn = min(minn, f[p][q]);
						}
					}
					if(minn == 0x3f3f3f3f3f3f3f3f){
						flg = 1;
						break;
					}
					cost[j][i] += minn;
				}
			}
			if(flg){
				cost[j][i] = 0x3f3f3f3f3f3f3f3f;
			}
		}
	}
	memset(dp, 0x3f, sizeof(dp));
	for(int i = 1; i <= n; i++) dp[1][1 << (i - 1)] = 0;
	for(int k = 2; k <= n; k++){
		for(int i = 1; i < (1 << n); i++){
			for(int j = i; j; j = (j - 1) & i){
				if(cost[j][i] == 0x3f3f3f3f3f3f3f3f) continue;
				dp[k][i] = min(dp[k][i], dp[k - 1][j] + cost[j][i] * (k - 1));
			}
		}
	}
	for(int i = 1; i <= n; i++) ans = min(ans, dp[i][(1 << n) - 1]);
	cout << ans << endl;
	return 0;
}

Generate a String#

和入门动态规划时讲的题很像，但是它多了一种步骤，可以删除字符，并且我们分析发现，这种做法并不是无用的。

如果我们按照之前的状态 $d{p}_i$ 表示生成前 $i$ 字符的最小代价，转移就是

$\{\begin{array}{l}d{p}_i=min(d{p}_{i-1},d{p}_{i+1})\\ d{p}_i=min(d{p}_i,d{p}_{i/2})(imod2=0)\end{array}$

这样的 $dp$ 是没办法递推的，因为更新 $d{p}_i$ 时 $d{p}_{i+1}$ 还没更新。一种思路是把状态抽象成一个点，去跑最短路，但是通过不了。

我们考虑*为什么会有删除操作，因为前面翻倍之后超过了 $i$，要删去，所以删除操作还可以表示成 $d{p}_i=\underset{2\times k\ge i}{min}(d{p}_k+y+(2\times k-i)\times x)$，转化一下就变成 $d{p}_i=\underset{2\times k\ge i}{min}(d{p}_k+2\times k\times x)+y-i\times x$ 容易发现 $min$ 里面的值是可以用单调队列维护的，队列中的值对应在序列里也是单调的。

在思考，发现删除操作最多只会连续做一次，因为如果超过两次，为什么不在翻倍前就删呢，翻倍了删的数也翻倍，一定不优。所以直接把 $d{p}_{i+1}$ 的状态再往前推，是 $d{p}_{(i+1)/2}$，这样第三行转移就可以写成 $d{p}_i=min(d{p}_i,d{p}_{(i+1)/2})(imod2=1)$

Games with Rectangle#

在 $n\times m$ 的网格里选 $k$ 个矩形，要求矩形一个套一个，不能重叠，求不同的方案数。

首先数据范围是不允许超过 $O(n^2)$ 的，所以也就不能同时枚举三个值或者枚举端点。

根据乘法原理，总方案数等于横列合法方案数乘上纵列合法方案数，所以我们分别求出两个的方案数再相乘就是答案。每次转移跟层数和每次的长度有关，并且我们可以把 $n$ 和 $m$ 作为最后的长度，即题目给出的网格是第 $k+1$ 个矩形。所以设状态 $d{p}_{i,j}$ 表示已经从内到外考虑到第 $i$ 层，第 $i$ 层的长度为 $j$ 的合法方案数，转移是

$d{p}_{i,j}=\sum _{1\le k\le j-2}d{p}_{i-1,k}\times (j-k+1)$

但是即使这样复杂度还是 $O(n^{2}k)$，考虑优化。空间上容易发现 $i$ 这一维可以降维掉。后面的式子很有规律，随着 $k$ 的变化，乘的数不断变大，似乎 $d{p}_{i,j}$ 和 $d{p}_{i,j-1}$ 转移之后区别不大。

$d{p}_{i,j}=\sum _{1\le k\le j-2}d{p}_{i-1,k}\times (j-k+1)$

$d{p}_{i,j-1}=\sum _{1\le k\le j-3}d{p}_{i-1,k}\times (j-k)$

只是枚举的 $k$ 多了一，列出式子发现之间就少了 $\sum _{1\le k\le j-2}d{p}_{i-1,k}$，这部分明显可以用前缀和维护。转移可以写成

$d{p}_{i,j}=d{p}_{i,j-1}+\sum _{1\le k\le j-2}d{p}_{i-1,k}$。

复杂度降到 $O(n^2)$，初始化为 $d{p}_{1,i}=1$ 答案为 $d{p}_{k+1,n}\times d{p}_{k+1,m}$，$k+1$ 具体在代码中表现为循环 $k$ 次。

仔细思考后，发现这题既然用乘法原理简化到求横纵坐标各自的方案，其实就是在横纵坐标中各取 $2\times k$ 个点的方案数，为 $C_{n-1}^{2\times k}$ 和 $C_{m-1}^{2\times k}$ ,两个相乘就是答案。为什么不用考虑合不合法呢，因为对于每种组合，我们每次都取最大最小横坐标和最大最小纵坐标作为下一步，重复这个操作，最后一定是合法的。

CF837D Round Subset#

从 $n$ 个数中选 $k$ 个数，使得相乘后末尾的 $0$ 最多。容易发现，末尾的 $0$ 由 $2\times 5$ 得到。所以末尾 $0$ 的个数就是 $k$ 个数中 $2$ 的总个数和 $5$ 的总个数的最小值。每个数我们都可以预处理出 $2$ 和 $5$ 的个数。

这是一个选数问题，基本的状态 $d{p}_{i,j}$ 表示前 $i$ 个数选了 $j$ 个，因为同时要考虑到 $2$ 和 $5$ 的个数，我们可以借鉴 P2340 [USACO03FALL]Cow Exhibition G 一题中的思想，把 $2$ 抽象成重量，求 $5$ 最多为多少。所以状态可以再加一维，$d{p}_{i,j,k}$ 表示前 $i$ 个数选了 $j$ 个，$2$ 的个数为 $j$ 个时，$5$ 最多为多少个。由于 $j$ 并不是虚值，所以我们要初始化 $d{p}_{0,0,0}=0$。

$d{p}_{i,j,k}=max(d{p}_{i-1,j,k},d{p}_{i-1,j-1,k-b_i}+c_i)$

$b_i$ 表示 $2$ 的个数，$c_i$ 表示 $5$ 的个数。可以发现 $i$ 一维是可以用滚动数组的。注意的是，用滚动数组，不能少转移，比如 $k<b_i$ 时，也要写 $d{p}_{i,j,k}=d{p}_{i-1,j,k}$，不能直接去掉。统计答案时，我们枚举 $2$ 的个数，$ans=max(ans,min(i,d{p}_{n,k,i}))$，为 $2$ 的个数与 $5$ 的个数的最小值。

CF14D Two Paths#

求树中两条链，链不相交，使得两条链的长度相乘乘积最大。如果这题不是求乘积，其实就是求树的直径，设状态 $d{p}_u$ 表示以 $u$ 为根的最长链。

$\{\begin{array}{l}ans=max(ans,d{p}_u+d{p}_v+1)\\ d{p}_u=max(d{p}_u,d{p}_v+1)\end{array}$

而思考不相交的两条链，有的性质是，他们至少能用一条边使得它们相连，也就是说，它们之间隔着至少一条边。

那思路就有了，我们枚举他们之间隔着的边，这棵树就被分成了两棵树，分别在两棵树里面求树的直径，两个相乘就是至少隔着这条边时的最大值。依次更新 $ans$ 就可以了。

CF527D Clique Problem#

虽然这题的优解是贪心而不是 $dp$，但是 $dp$ 的角度也是很精彩的。这道题的突破口是 $abs(x_i-x_j)\ge w_i+w_j$。如果单纯的不加优化，这样是必须要枚举两个数的，但是我们假设只枚举一个数 $x_i$，并且 $x_i\ge x_j$，式子就可以变成 $-x_j-w_j\ge w_i-x_i$，这里是把下标相同放一边，也就是 $x_j+w_j\le x_i-w_i$。所以对答案有影响的就是每个点的 $x_i+w_i$ 和 $x_i-w_i$。我们枚举到一个 $i$，就可以用 $x_i-w_i$ 这个条件求出满足的点，具体操作就是把记录 $x_i+w_i$ 的数组排序，二分查找第一个大于 $x_i-w_i$ 的下标 $pos$，$pos-1$ 都是合法的。

解决完这个，我们考虑状态，如果是 $d{p}_i$ 表示前 $i$ 个点的话，可我们上面筛出来的点并不是在 $[1,i)$ 之内的，并且我们要上面筛的点的 $dp$ 值，如果是无序的不好找。所以状态需要顺序，设状态 $d{p}_i$ 为第 $i$ 大的 $x_i+w_i$ 构成的最大团点数。这时候更新是有顺序的，需要转移的状态是在一起的，并且二分查找可以去重了，我们要的是满足条件的状态，而不是点数，所以可以用到线段树优化维护 $d{p}_i$，二分查找找到第 $i$ 大对应的点，单点修改，查询区间最大值，$d{p}_i=max(maxn+1)$。$maxn$ 表示筛出的点中的最大 $dp$ 值。复杂度为 $O(nlogn)$

贪心的方法就是转换条件，可以发现 $x_i+w_i$ 和 $x_i-w_i$ 映射在数轴上就是一段区间，把 $l_i=x_i+w_i$，$r_i=x_i-w_i$。满足 $r_i\ge l_j$ 的两点是有边的，那么题目就转换成，在数轴上取最多线段，每条线段不相互覆盖。直接贪心，从 $r$ 最小的线段开始取，能取就取。复杂度为 $O(nlogn)$，常数比 $dp$ 小。

P4310 绝世好题#

选数问题，通常从左往右考虑，这题的限制不多，只需要状态 $d{p}_i$ 表示考虑前 $i$ 个，并且选了第 $i$ 个的最长长度。这题唯一给出的题目限制是序列 $b$ 中 $b_i\mathrm{\&}{b}_{i-1}\ne 0$。 朴素的，如果不加优化，转移是

$d{p}_i=\underset{1\le j<i}{max}(d{p}_i,d{p}_j+1)(a_i\mathrm{\&}{a}_j\ne 0)$

这是很容易想到的，瓶颈是复杂度是 $O(n^2)$ 的。我们考虑什么样的 $j$ 对 $i$ 是有贡献的。由于是 $\mathrm{\&}$，所以能不能转移，跟二进制中的 $1$ 有关，容易发现，在二进制中，如果 $a_j$ 与 $a_i$ 在同一位上都有 $1$，这样的 $j$ 是有贡献的。所以就有一个想法，二进制的每一位决定了你之后对什么样的数有贡献，我们可以对二进制的每一位都建立一个优先队列，每枚举到一个数都进行二进制拆分，拆到 $1$，说明它在这一位上对之后的 $a_i$ 是有贡献的，把它存到这一位的优先队列里，之后如果有一个 $a_i$ 的二进制某一位是 $1$，直接从这一位的优先队列中取出最大值更新就可以了。

在这个优化里，我们优化了枚举 $j$ 的时间，换成了常数小的二进制拆分，又因为我们只关心有贡献的每一位上的最大值，所以用到了优先队列，优化了在同一位上有贡献的数多余的更新。

复杂度约为 $O(nlogn)$。

P4158 [SCOI2009]粉刷匠#

给定 $n$ 条 $m$ 格的木板，每次可以给一个区间涂色，要求最多涂 $t$ 次正确涂色的最多格子数。观察题目，不同木板之间是不会相互影响的，

所以我们可以很快求出一块木板涂色几次的最多正确格子数，设状态 $f_{i,j,k}$ 表示第 $i$ 块木板涂到第 $j$ 格，期间涂了 $k$ 次的最多正确格子数，由于此题对区间长度没有要求，并且涂长了不会影响答案，我们可以直接默认涂的每个区间都是紧密贴合的，也就是不留不涂色的，这样状态也可以很快就列出来

$f_{i,j,k}=\underset{1\le p\le j}{max}(f_{i,j,k},f_{i,p-1,k-1}+max(sum{0}_{i,j}-sum{0}_{i,p-1},sum{1}_{i,j}-sum{1}_{i,p-1}))$

$su{m}_{i,j}$ 表示我们预处理的每块木板 $1$ 和 $0$ 的前缀和，枚举最近的区间左端点 $p$，在区间 $[p,j]$ 我们涂 $1$ 和 $0$ 中最多的数字，这样是最优的。

于是我们就知道了每块木板各种情况下的贡献，不用担心木板内部的情况，我们现在只需要考虑怎么分配涂色次数。按顺序涂色，把每块木板抽象成一个物品，我们投入的次数越多，贡献越大，所以我们从上到下考虑，设状态 $d{p}_{i,j}$ 表示前 $i$ 块木板最多涂了 $j$ 次的最多正确格子数，每次枚举这次要在第 $i$ 块木板上涂 $k$ 次，那么状态就是从 $d{p}_{i-1,j-k}$ 上转移而来。

$d{p}_{i,j,k}=\underset{0\le k\le min(m,t)}{max}(d{p}_{i-1,j},d{p}_{i-1,j-k}+f_{i,m,k})$

答案 $ans=\underset{0\le i\le t}{max}(d{p}_{n,i})$。题目中有些地方不用跑 $t$ 次，原因是每块木板最多 $50$ 格，所以只需要知道涂色次数与格数的最小值之内的状态就行了，

不然复杂度肯定过不了，还有要注意左端点是可以和右端点重合的，也就是只涂一格，一块木板也可以一次都不涂，也要转移。

P1772 [ZJOI2006] 物流运输#

有 $n$ 天，每天要从 $1$ 送到 $n$，这期间某些天某些点会损坏，更换路线要额外加钱，求 $n$ 天所花的最少花费。一看到这题，就直接想到 $d{p}_{i,j}$ 表示前 $i$ 天换了 $j$ 次，但是这样列不出方程，因为我们不能决定要走哪条路，事实上当前的最短路并不是最优的，有可能这次最短但是导致要给换路价钱。

思考之前的状态有什么缺点，这道题并没有限制我们的更换次数，我们记录它并没有用，我们记录的初衷可能是想表示这次换不换，但是知道这一次换和不换不能顾及到整个局面，况且你不换也不一定就是你上次走的最短路。

我们重点要解决决定路线的问题，观察条件，更换路线要加钱，并且每天都得送货，这使得这 $n$ 天被分为了若干个连续的区间，也可以观察到并不是每一段连续的天数都可以走同一条路的（有的时候必须换路），而且每个区间里走的是同一条路，并且一定是最短路。这是一个很特别的性质，这样就有了一个结论，只要当前区间确定下来，并且是合法的（即可以走同一条路），你就可以知道价钱。所以这题就变成了一个分段问题，我们可以固定右端点，枚举左端点来确定一个最近的区间，并且默认左端点前的路线不同，固定这个区间走同一条路，跑这些天里的最短路，就是价钱。

状态只需要一维，即 $d{p}_i$ 表示前 $i$ 天的最短价钱，我们不关心换了几次，每次换了就直接实时加换路钱就行了。

$d{p}_i=\underset{1\le j\le i}{min}(d{p}_i,d{p}_{j-1}+(i-j+1)\times cost+k)$

由于只需要单源最短路，所以直接跑 $spfa$ 或 $dijkstra$ 都可以。注意的是 $j$ 可以倒序枚举，因为后面不能走的点，前面还是不能走，如果当前 $[j,i]$ 已经不能用同一条路了，那前面也不行，直接不枚举了。初始化 $d{p}_0=-k$，因为第一次换路线不用钱，更新时遇到这个状态是会直接把 $k$ 抵消掉，相当于没花钱。

为什么可以默认前面的 $j-1$ 路线不同呢？ 我们想一下如果 $j-1$ 路线一样会怎么样，这时当我们往左就会枚举到真正意义上的断点时（也就是不能走之前的路，换了一条路时），之前的在 $j$ 时的左端点一定不优（因为相同路线换成相同路线还要花钱），并且一定会被真断点给覆盖掉。错解一定会被覆盖，不会影响答案。

#include <bits/stdc++.h>
using namespace std;
int read(){
    int x = 0, f = 1;
    char c = getchar();
    while(c < '0' || c > '9'){
        if(c == '-') f = -1;
        c = getchar();
    }
    while(c >= '0' && c <= '9'){
        x = (x << 1) + (x << 3) + (c - '0');
        c = getchar();
    }
    return x * f;
}
int n, m, k, e, cnt;
bool vis[300][1100], flg[300], inq[300];
int dp[1100], h[1100], dis[300];
struct node{
    int to, nxt, w;
}ed[4100];
void add(int u, int v, int w){
    ed[++cnt].to = v;
    ed[cnt].nxt = h[u];
    ed[cnt].w = w;
    h[u] = cnt;
}
int spfa(){
    queue<int> q;
    for(int i = 1; i <= m; i++) dis[i] = 0x3f3f3f3f, inq[i] = 0;
    inq[1] = 1;
    dis[1] = 0;
    q.push(1);
    while(!q.empty()){
        int u = q.front();
        q.pop();
        inq[u] = 0;
        for(int i = h[u]; i; i = ed[i].nxt){
            int v = ed[i].to;
            if(flg[v]) continue;
            if(dis[v] > dis[u] + ed[i].w){
                dis[v] = dis[u] + ed[i].w;
                if(!inq[v]){
                    inq[v] = 1;
                    q.push(v);
                }
            }
        }
    }
    return dis[m];
}
int main(){
    n = read(), m = read(), k = read(), e = read();
    for(int i = 1; i <= e; i++){
        int u = read(), v = read(), w = read();
        add(u, v, w), add(v, u, w);
    }
    int d = read();
    for(int i = 1; i <= d; i++){
        int num = read(), a = read(), b = read();
        for(int j = a; j <= b; j++){
            vis[num][j] = 1;
        }
    }
    memset(dp, 0x3f, sizeof(dp));
    dp[0] = -k;
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++) flg[j] = 0;
        for(int j = i; j >= 1; j--){
            for(int k = 1; k <= m; k++) if(vis[k][j]) flg[k] = 1;
            int res = spfa();
            if(res == 0x3f3f3f3f) break;
            dp[i] = min(dp[i], dp[j - 1] + (i - j + 1) * res + k);
        }
    }
    cout << dp[n] << endl;
    return 0;
}

P3861 拆分#

要求把 $n$ 拆成一些不小于 $2$ 的互不相同的数的乘积的方案数。看到数据范围 $n\le {10}^{12}$，肯定要先缩小范围。容易发现，$n$ 只可能由它的因数相乘得来，每个数都是如此。所以 $n$ 的转移只与 $n$ 的因数有关，我们可以用 $O(\sqrt{n})$ 的方法把因数筛出来，并且因数很少，$d({10}^{12})\le 6720$。

由于 $n$ 就是通过这些数得到，并且不需要合成，只需要把数选出来就行了，更不需要考虑选出的数有没有互不相同的问题了（每个数独一无二，只选一次）。

题目就转化成了，在这些因数中选一些数，组成 $n$ 的方案数有多少。这不就是背包问题吗，只是这里选出的物品变成了相乘。先把因数从小到大排序，因为大数由小数得到。

因为 $n$ 只可能由它的因数相乘得来，其他都是多余的。如果两个因数相乘不是因数，那就是没有用的，因为它一定拼不出 $n$，即我们要枚举的重量只可能是 $n$ 的因数。所以，我们最终只关心因数的拆分方案，可以设状态 $d{p}_{i,j}$ 表示前 $i$ 个数选出若干个数，表示出 $p_j$ 的方案数，省去了很多空间和时间。

$\{\begin{array}{l}d{p}_{i,j}=d{p}_{i-1,j}\\ d{p}_{i,j}=d{p}_{i,j}+d{p}_{i-1,k}(p_{j}mod{p}_i=0)\end{array}$

这里的 $k=pos{1}_{p_j/p_i}/pos{2}_{n/p_j/p_i}$，其中 $p_j/p_i$，必须是整除，如果是整除，那么这个数一定在原来的因数中（$a\mid b$，$b\mid c$，则 $a\mid c$）。$pos{1}_i$ 是我们预处理的每个数的位置，对于大于 $\sqrt{n}$ 的数，由于一定有一个小于 $\sqrt{n}$ 的数与之对应，所以记 $pos{2}_{p_i}=n-i+1$，空间复杂度降到 $O(\sqrt{n})$。这里的转移很基础，就是分为选/不选第 $i$ 个数，选了就是从 $k$ 上转移。

注意，这里求的是方案数，在不能降维的情况下，一定不能漏转移，也就是 $j$ 必须从 $1$ 到 $tot$ 不能遗漏转移 $d{p}_{i,j}=d{p}_{i-1,j}$，因为这对于所有情况都成立，其他情况在 $j<i$ 时可以跳过。

复杂度约为 $O(T(\sqrt{n}+d(n{)}^2))$。

#include<bits/stdc++.h>
using namespace std;
long long t, n, mod = 998244353, cnt;
long long dp[8010][8010], p[8010];
int pos1[1000010], pos2[1000010];
int main(){
	cin >> t;
	while(t--){
		cnt = 0;
		cin >> n;
		long long sqrn = sqrt(n);
		for(long long i = 1; i * i <= n; i++){
			if(n % i == 0){
				p[++cnt] = i;
				if(n / i != i) p[++cnt] = n / i;
			}
		}
		sort(p + 1, p + cnt + 1);
		for(int i = 1; i * 2 <= cnt + 1; i++){
			pos1[p[i]] = i;
			pos2[p[i]] = cnt - i + 1;
		}
		memset(dp, 0, sizeof(dp));
		dp[1][1] = 1;
		for(int i = 2; i <= cnt; i++){
			for(int j = cnt; j >= 1; j--){
				dp[i][j] = dp[i - 1][j];
				if(j < i) continue;
				if(p[j] % p[i] == 0){
					long long now = p[j] / p[i];
					int k = (now <= sqrn) ? pos1[now] : pos2[n / now];
					dp[i][j] = (dp[i][j] + dp[i - 1][k]) % mod;
				}
			}
		}
		cout << dp[cnt][cnt] - 1 << endl;
	}
	return 0;
}