P1006 传纸条
输入输出样例
输入 #1复制
3 3
0 3 9
2 8 5
5 7 0
输出 #1复制
34
要点目录
1.状态方程的获得
2.计算顺序与重复路径的思考(有效方案)
1 状态方程的获得
这个需要2条路线,因此考虑使用4维dp应该是比较自然的,考虑两者同时走,因此可以看成都从左上出发,一起到达右下角。
定义dp[i][j][k][l]为小渊在[i,j],小轩在[k,l]时候的最大的好感度,很容易得到以下的状态转移方程。
dp[i][j][k][l] = max({ dp[i - 1][j][k - 1][l],dp[i - 1][j][k][l - 1],dp[i][j - 1][k - 1][l],dp[i][j - 1][k][l - 1] }) + mat[i][j] + mat[k][l];
但是问题是,题目中提到的,不允许经过重复的路径,应该如何体现?因为动态规划是不考虑前者的路径过程的,我们不进行记录,因此这个问题确实有些棘手。
2 计算顺序与重复路径的思考(有效方案)
在说明之前先说一些本题的基本事实:
1、[i,j]和[k,l]是一起走的,也就是说要达到[i,j,k,l]必须是左右都走一步,不能左边走右边不走,因此状态方程里是有4个变量进行求最大值。
2、对于i == k , j == l的情况,此时左边和右边是在同一个位置的,此时状态为[i,j,i,j],即dp[i][j][i][j],这种状态是没有意义的,由于我们求最大值,因此这里置0,其实我觉得置为int_min然后特判更好,但是写起来就啰嗦了。
因此,在这里我对这种重复点进行的判断,跳过他们。在其他点进行比较的时候,这些点为0,因此不会影响结果。简单点来说就是,我们最终得到的dp[i][j][k][l]绝对不会是由i == k, j == l的这种状态发展得到的因此永远是合理的,也就不必担心了。(这句话可以参照下面的方格取数这题来理解)
而其他答主使用的令l=j+1,应该也是让j!=l的一种方法,至于为什么不把左边也算上,可能是为了剪枝吧,因为单纯求2条路径,左右路径是可以交换的,因此总有一条在右边,因此把这些遍历了就可以了;即相当于这两条路径是一个组合,而不是排列。
代码
#include<iostream>
#include<algorithm>
#include<climits>
using namespace std;
int mat[55][55] = {};
int dp[55][55][55][55] = {};
int main() {
int m, n;
cin >> m >> n;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
cin >> mat[i][j];
}
}
//for (int i = 1; i <= m; i++) {
// for (int j = 1; j <= n; j++) {
// for (int k = 1; k <= m; k++) {
// for (int l = j + 1; l <= n; l++) {
// dp[i][j][k][l] = max({ dp[i - 1][j][k - 1][l],dp[i - 1][j][k][l - 1],dp[i][j - 1][k - 1][l],dp[i][j - 1][k][l - 1] }) + mat[i][j] + mat[k][l];
// }
// }
// }
//}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= m; k++) {
for (int l =1; l <= n; l++) {
if (i == k&&j == l)continue;
else
dp[i][j][k][l] = max({ dp[i - 1][j][k - 1][l],dp[i - 1][j][k][l - 1],dp[i][j - 1][k - 1][l],dp[i][j - 1][k][l - 1] }) + mat[i][j] + mat[k][l];
}
}
}
}
cout << dp[m][n-1][m-1][n];
return 0;
}
优化后的三维代码
优化后len其实就是最大步长,为m+n-1,其余的横纵坐标的有效范围是>=1。对于无效的用continue跳过,另外最后的结果是dp[m+n-1][m][m-1]
#include<iostream>
#include<algorithm>
#include<climits>
using namespace std;
int mat[55][55] = {};
int dp[110][55][55] = {};//dp[len][i][k];
int main() {
int m, n;
cin >> m >> n;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
cin >> mat[i][j];
}
}
for (int len = 1; len <= m + n - 1; len++) {
for (int i = 1; i <= m; i++) {
for (int k = 1; k <= m; k++) {
if (i == k)continue;
if (len - i< 1 || len - k < 1)continue;
dp[len][i][k] = max({ dp[len - 1][i][k],dp[len - 1][i - 1][k],dp[len - 1][i][k - 1],dp[len - 1][i - 1][k-1] }) + mat[i][len - i] + mat[k][len - k];
}
}
}
cout << dp[m + n - 1][m][m-1];
return 0;
}
P1004 方格取数
输入输出样例
输入 #1复制
8
2 3 13
2 6 6
3 5 7
4 4 14
5 2 21
5 6 4
6 3 15
7 2 14
0 0 0
输出 #1复制
67
总结目录
1 说明为什么计算的时候置算1次就可以避免重复,不需要额外置0
1 为什么计算的时候只需要计算1次就可以避免重复,不需要额外置0
一开始做这题的时候我也是十分困惑的,状态方程是好写的,关键是重复部分被拿掉的是如何体现呢?为什么只算1次就可以保证重复的已经被拿掉了呢?
考虑一个简单的例子如下,n==2,mat是个2X2的矩阵,容易得到相应的状态如下。那么我们担心的其实是:由于遍历是由先后顺序的,那么在遍历过程中,我们似乎先遍历了k,l;再遍历i,j;那么在这个过程中他们可能会经过同一点,但是这个点我们没有置0,那么会不会导致重复计算出错?
我们将我们的问题进行更加细化,我们考虑一下, 在什么情况下我们会重复算一个,或者说可能重复计算的是什么样子的?其实就是i == k,j == l的情况嘛。那这个时候我们重复计算了吗?没有,因为我们用特判把这种情况的重复给去掉了,只加了一次mat[i][j]。 那么我们的问题是:用了这个特判之后,不置0就能解决我们的问题了吗?回答是,是的,问题已经解决。
下面用一张图来进行说明。由于我们dp[i,j,k,l]表示的是一个状态,即路径1到[i,j]且路径2到[k,l]时的两者和的最大值。那么这个状态是如何得到的?没错,是通过相邻的4个状态得到的!即[i-1,j],[i,j-1];[k-1,l],[k,l-1]的组合有4种得到的。那么这4个状态如果在计算的时候没有重复,那么dp[i,j,k,l]就是没有重复的。为什么?如下图所示,因为假设dp[n,n,n,n]计算得到的最大值的两个路径如下图所示,两个路径有2个交点,那么这两个交点的状态在计算的时候没有重复计算(用了我们的特判),那么后续的状态是根据前面的状态得到的,也不会有重复计算!因此dp[n,n,n,n]就能够满足我们的要求。
代码
#include<iostream>
#include<algorithm>
using namespace std;
int mat[15][15] = {};
int dp[15][15][15][15] = {};
int main() {
int n;
cin >> n;
while (1) {
int i, j, val;
cin >> i >> j >> val;
if (i == 0 && j == 0 && val == 0)break;
mat[i][j] = val;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
for (int l = 1; l <= n; l++) {
if (i == k&&j == l) {
dp[i][j][k][l] = max({ dp[i - 1][j][k - 1][l],dp[i - 1][j][k][l - 1],dp[i][j - 1][k][l - 1],dp[i][j - 1][k - 1][l] }) + mat[i][j];
}
else {
dp[i][j][k][l] = max({ dp[i - 1][j][k - 1][l],dp[i - 1][j][k][l - 1],dp[i][j - 1][k][l - 1],dp[i][j - 1][k - 1][l] }) + mat[i][j] + mat[k][l];
}
}
}
}
}
cout << dp[n][n][n][n];
return 0;
}