洛谷多维DP（2）：P1006 传纸条，P1004 方格取数——多路径不重复的棋盘DP

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;
}