洛谷——P1004 方格取数

原题链接

一道四维动态规划的模板题。不妨令两个人同时从起点走到终点，很容易知道，dp[i][j][m][k]表示第一个人走到（i，j）位置、第二个人走到（m，k）位置时取数的最大值。易得状态转移方程为dp[i][j][m][k] = max(max(dp[i][j - 1][m][k - 1], dp[i - 1][j][m - 1][k]), max(dp[i - 1][j][m][k - 1], dp[i][j - 1][m - 1][k])) + map[i][j] + map[m][k]。当然要考虑两个人位置重叠的情况，当i == m 且 j == k时，要减去一个map[i][j]。

要注意一点的是，由于两个人是同时行进，所以满足i+j==m+k。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;

const int N = 10;
int dp[N][N][N][N];
int map[N][N];
int n;

int main()
{
	ios_base::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	cin >> n;
	int x = 1, y = 1, num = 1;
	while (cin >> x && cin >> y && cin >> num && !(x == 0 && y == 0 && num == 0)) {
		map[x][y] = num;
	}

	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			for (int m = 1; m <= n; m++) {
				int k = i + j - m;
				if (k <= 0)
					break;
			
				dp[i][j][m][k] = max(max(dp[i][j - 1][m][k - 1], dp[i - 1][j][m - 1][k]), max(dp[i - 1][j][m][k - 1], dp[i][j - 1][m - 1][k])) + map[i][j] + map[m][k];
				if (i == m && j == k)
					dp[i][j][m][k] -= map[i][j];

			}
		}
	}
	cout << dp[n][n][n][n];
	return 0;
}

再考虑一下空间的优化。由于i+j==m+k，所以不妨用另一个变量表示横纵坐标之和。那么dp[i][j][k]表示横纵坐标之和为i、两个人的纵坐标为j、k时的取数最大值。这里i的取值范围是从2到2n。可以这样理解，因为起始点坐标为（1,1），所以i的最小值为2，终点是（n，n），所以最大值为2n。注意，j、k不能超过i。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;

const int N = 10;
int dp[2 * N][N][N];
int map[N][N];
int n;

int main()
{
	ios_base::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	cin >> n;
	int x = 1, y = 1, num = 1;
	while (cin >> x && cin >> y && cin >> num && !(x == 0 && y == 0 && num == 0)) {
		map[x][y] = num;
	}
	for (int i = 2; i <= 2 * n; i++) {
		for (int j = 1; j <= n && j < i; j++) {
			for (int k = 1; k <= n && k < i; k++) {

				dp[i][j][k] = max(max(dp[i - 1][j - 1][k - 1], dp[i - 1][j][k]), max(dp[i - 1][j][k - 1], dp[i - 1][j - 1][k])) + map[i - j][j] + map[i - k][k];
				if (j == k)
					dp[i][j][k] -= map[i - j][j];

			}
		}
	}
	cout << dp[2 * n][n][n];
	return 0;

}

又注意到，使用滚动数组时，每次横纵坐标和为i时使用的是横纵坐标和为i-1时的值。所以考虑进一步优化，转化为空间复杂度为n^2级别。具体方法是：i和i-1的奇偶性必然不同，所以可以对2取模，代码如下。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;

const int N = 10;
int dp[2][N][N];
int map[N][N];
int n;

int main()
{
	ios_base::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	cin >> n;
	int x = 1, y = 1, num = 1;
	while (cin >> x && cin >> y && cin >> num && !(x == 0 && y == 0 && num == 0)) {
		map[x][y] = num;
	}
	for (int i = 2; i <= 2 * n; i++) {
		for (int j = 1; j <= n && j < i; j++) {
			for (int k = 1; k <= n && k < i; k++) {
				dp[i % 2][j][k] = max(max(dp[(i - 1) % 2][j - 1][k - 1], dp[(i - 1) % 2][j][k]), max(dp[(i - 1) % 2][j][k - 1], dp[(i - 1) % 2][j - 1][k])) + map[i - j][j] + map[i - k][k];
				if (j == k)
					dp[i % 2][j][k] -= map[i - j][j];

			}
		}
	}
	cout << dp[0][n][n];
	return 0;

}

最后优化。因为每一次使用的是上一次的值，所以可以转化为背包问题。注意这里是从大到小。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;

const int N = 10;
int dp[N][N];
int map[N][N];
int n;

int main()
{
	ios_base::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	cin >> n;
	int x = 1, y = 1, num = 1;
	while (cin >> x && cin >> y && cin >> num && !(x == 0 && y == 0 && num == 0)) {
		map[x][y] = num;
	}
	for (int i = 2; i <= 2 * n; i++) {
		for (int j = i - 1; j >= 1; j--) {
			for (int k = i - 1; k >= 1; k--) {
				dp[j][k] = max(max(dp[j - 1][k - 1], dp[j][k]), max(dp[j][k - 1], dp[j - 1][k])) + map[i - j][j] + map[i - k][k];
				if (j == k)
					dp[j][k] -= map[i - j][j];

			}
		}
	}
	cout << dp[n][n];
	return 0;

}