方格取数 NOI Openjudge 8786 / 洛谷P1004

8786.方格取数

描述

设有N*N的方格图(N<=10),我们将其中的某些方格中填入正整数,而其他的方格中则放入数字0。如下图所示（见样例）：

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

输入

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

输出

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

样例输入

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

样例输出

67

分析

很明显，这道题需要用到动态规划来解决（因为分类就是这么分的）
但是，如果真的要用正宗的动态规划就会用一个四维的数组（而且我不会，等会看懂了思路之后再补充）
而如果不用动态规划，用搜索 _{深度优先搜索}的方法就会发现搜索两次复杂度太高，需要的时间太长。
那么， 如果我能够把两者放在一起

• 先用灵活的搜索
• 再用快捷的动态规划

这个问题就解决了，毕竟只有一次搜索，数据规模也不大。

如果我非要走不寻常的路，整一个两次搜索怎么办

后来，一位网友给出了方案，具体分析可以看原文
我只是觉得他的代码不是很清晰，所以我在后面附上更为清晰的版本，当然，注释是不能少的*^_^*

代码

搜索+DP

#include <iostream>
#include <cstring>

using namespace std;

int mp[12][12];

int maxn = 0;

// 第一层用搜索，第二次用dp

int second() {
	int dp[12][12];
	memset(dp, 0, sizeof(dp));

	for (int i = 1; i < 12; i++) {
		for (int j = 1; j < 12; j++) {
			dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]) + mp[i][j];
		}
	}

	return dp[11][11];
}


void first(int x, int y, int n) {
	if (x == 11 && y == 11) {
		n += second();
		maxn = max(n, maxn);
		return;
	}

	// 超出边界
	if (x > 11 || y > 11) return;

	// if (n != 0) { printf("x, y, n : %d %d %d\n", x, y, n); }

	// 标记
	int on = mp[x][y];
	n += on;
	mp[x][y] = 0;
	// 向右或向下
	
	if (x < 11) first(x + 1, y, n);
	if (y < 11) first(x, y + 1, n);

	// 回溯
	mp[x][y] = on;
}

int main() {
	int t; cin >> t;

	memset(mp, 0, sizeof(mp));

	int nx, ny, n;
	while (true) {
		cin >> nx >> ny >> n;
		if (nx + ny + n == 0) break;
		mp[nx][ny] = n;
	}

	first(0, 0, 0);

	cout << maxn << endl;
	return 0;
}

深度搜索

#include <iostream>
#include <cstring>
#include <tuple>
#include <utility>
#include <vector>

using namespace std;

int mp[11][11];
int cache[11][11][11][11];

int N;

int pprint() {
	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= N; j++) {
			printf("%-3d ", mp[i][j]);
		}
		printf("\n");
	}
	return 0;
}

int dfs(int a, int b, int x, int y) {
	if (a == N && b == N && x == N && y == N) {
		return mp[N][N];
	}

	if (a > N || b > N || x > N || y > N) return 0;
	
	if (cache[a][b][x][y] != -1) return cache[a][b][x][y];
	
	int cur = mp[a][b];
	// 标记清0
	int on = mp[a][b];
	mp[a][b] = 0;
	// 然后在加xy, 防止重复
	cur += mp[x][y];

	int best = 0;
	// ab向右，xy向下
	if (b < N && x < N)
		best = max(best, dfs(a, b+1, x+1, y) + cur);
	
	// ab，xy都向下
	if (a < N && x < N)
		best = max(best, dfs(a+1, b, x+1, y) + cur);

	// ab,xy都右
	if (b < N && y < N)
		best = max(best, dfs(a, b+1, x, y+1) + cur);

	// ab下，xy右
	if (a < N && y < N)
		best = max(best, dfs(a+1, b, x, y+1) + cur);
	// 回溯
	mp[a][b] = on;

	cache[a][b][x][y] = best;
	return best;
}

int main() {
	cin >> N;

	// clear, pre-process
	memset(mp, 0, sizeof(mp));
	// 如果cache设为0的话，当第一次搜索没有搜到任何数的时候，best为0……
	// 后果只是陷入死循环而已
	for (int a = 0; a <= N; a++)
		for (int b = 0; b <= N; b++)
			for (int c = 0; c <= N; c++)
				for (int d = 0; d <= N; d++)
					cache[a][b][c][d] = -1;

	int nx, ny, n;
	while (true) {
		cin >> nx >> ny >> n;
		if (nx + ny + n == 0) break;
		mp[nx][ny] = n;
	}

	// pprint();

	cout << dfs(1, 1, 1, 1) << endl;
	return 0;
}