P1004 方格取数

题目描述

设有N \times NN×N的方格图(N \le 9)(N≤9)，我们将其中的某些方格中填入正整数，而其他的方格中则放入数字00。如下图所示（见样例）:

A
 0  0  0  0  0  0  0  0
 0  0 13  0  0  6  0  0
 0  0  0  0  7  0  0  0
 0  0  0 14  0  0  0  0
 0 21  0  0  0  4  0  0
 0  0 15  0  0  0  0  0
 0 14  0  0  0  0  0  0
 0  0  0  0  0  0  0  0
                         B

某人从图的左上角的AA点出发，可以向下行走，也可以向右走，直到到达右下角的BB点。在走过的路上，他可以取走方格中的数（取走后的方格中将变为数字00）。
此人从AA点到BB点共走两次，试找出22条这样的路径，使得取得的数之和为最大。

输入输出格式

输入格式：

 

输入的第一行为一个整数NN（表示N \times NN×N的方格图），接下来的每行有三个整数，前两个表示位置，第三个数为该位置上所放的数。一行单独的00表示输入结束。

 

输出格式：

 

只需输出一个整数，表示22条路径上取得的最大的和。

 

输入输出样例

输入样例#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

 

四维dp,本来一开始的想法是二维dp，然后赋值0，再来一次二维dp，后面发现有些样例这种写法会有问题，所以就采用四维dp

我们可以采用四重循环枚举每一种行走方式。我们可以采取这样的思维方式：题目中说“此人从A点到B点共走两次”，可以当成两个人相对而行，这样会方便一些。我们枚举第一个人的坐标（x1，y1）和第二个人的坐标（x2，y2）。因为题目已经说明只能向下或向右走，因此第一个人的方向为 [ x1-1 ] [ y1] 或 [ x1] [ y1-1]，第二个人的方向为 [ x1-1 ] [ y1] 或 [ x1] [ y1-1]。

我们设f[x1][y1][x2][y2]表示第一个人走到x1，y1点，第二个人走到x2，y2点的最优解。

动态转移方程为 f[x1][y1][x2][y2] =max(f[x1][y1][x2][y2],f[x1-1][y1][x2-1][y2],f[x1-1][y1][x2][y2-1],f[x1][y1-1][x2-1][y2],f[x1][y1-1][x2]

[y2-1]) + G[x1][y1] 若 x1 != x2 || y1 != y2，还应加上G[x2][y2]。即必须累加当前走过的路径上的数字，为防止两个人同时走到一个点而累加两次产生错误答案，我们判定一下。 最优解：f[n][n][n][n]

 

 

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int maxnum(int a, int b, int c, int d)
{
	return max(max(max(a, b), c), d);
}
int main()
{
	int N;
	cin >> N;
	int a[13][13];
	int dp[13][13][13][13] = { 0 };
	for (int i = 0; i < 13; i++)
	{
		for (int j = 0; j < 13; j++)
		{
			a[i][j] = 0;
		}
	}
	int x, y, z;
	cin >> x >> y >> z;
	while (!(x == 0 && y == 0 && z == 0))
	{
		a[x][y] = z;
		cin >> x >> y >> z;
	}
	for (int i = 1; i <= N; i++)
	{
		for (int j = 1; j <=N; j++)
		{
			for (int k = 1; k <=N; k++)
			{
				for (int s = 1; s <=N; s++)
				{
					dp[i][j][k][s] = maxnum(dp[i - 1][j][k - 1][s], dp[i - 1][j][k][s-1], dp[i][j-1][k - 1][s], dp[i][j-1][k][s-1]);
					dp[i][j][k][s] += a[i][j];
					dp[i][j][k][s] += a[k][s];
					if(i==k&&j==s)
						dp[i][j][k][s] -= a[k][s];
				}
			}
		}
	}
	cout << dp[N][N][N][N] << endl;
	return 0;
}