题目描述

---

题目思路

如果从A到B只走一次的话可以用动态规划轻松解决。问题在于会走两次，第二次显然要走获取数字最多的路径，但第一次走哪条路径需要抉择。

错误的思路是以为这道题适合贪心，两次都选择最优路线。可以举出反例。

A	2	1
1	2	1
1	2	B

如果两次都是贪心走最优路线的话，获得总点数为：(2+2+2)+(1+1)=8

但显然有总点数更大的走法：(2+1+1)+(1+2+2)=9

注意到数据的规模极小，考虑走第一趟使用暴力搜索，在9x9的格子内最多有12870种不同走法，第二趟使用动态规划，将一快一慢的两种算法结合起来，就能将运行时间限定在合理范围内。

为了将DFS每趟获得的所有数字发给动态规划函数，需要栈容器协助存放数据。

第二趟的动态规划，设为行列所能拿到最大数字和，则状态转移方程：

---

我的代码

#include <iostream>
#include <algorithm>
#include <stack>
using namespace std;
int dp[10][10];
int pre[10][10];
int ans = 0;
int n;
typedef pair<int, int> P;
stack<P> stk;
void dynamic_program(stack<P> stk2, int value) {
	//初始化
	int i;
	int j;
	for (i = 0; i <= n; i++)
	{
		for (j = 0; j <= n; j++)
		{
			dp[i][j] = pre[i][j];
		}
	}
	//取出第一趟带走的数字
	while (stk2.size()) {
		i = stk2.top().first;
		j = stk2.top().second;
		dp[i][j] = 0;
		stk2.pop();
	}
	
	//动态规划
	for (i = 1; i <= n; i++)
	{
		for (j = 1; j <= n; j++)
		{
			dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) + dp[i][j];
		}
	}
	value = value + dp[n][n];
	ans = max(value, ans);
}
void dfs(int x, int y,int value) {
	//init
	if (pre[x][y]) {
		value = value + pre[x][y];
		stk.push(P(x, y));
	}
	if (x == n && y == n) {
		dynamic_program(stk,value);
	}
	if (x + 1 <= n) {
		dfs(x + 1, y, value);
	}
	if (y + 1 <= n) {
		dfs(x, y + 1, value);
	}
	if (pre[x][y]) {
		stk.pop();
	}
}
int main() {
	cin >> n;
	//初始化
	for (int i = 0; i <= n; i++)
	{
		for (int j = 0; j <= n; j++)
		{
			dp[i][j] = 0;
		}
	}
	int flag = 0;
	while (flag == 0)
	{
		int x;
		int y;
		int v;
		cin >> x >> y >> v;
		if (x != 0 || y != 0 || v != 0) {
			pre[x][y] = v;
		}
		else {
			flag = 1;
		}
	}
	//深度优先搜索
	dfs(1, 1,0);
	cout << ans;
	return 0;
}

像这种情况复杂但数据很小的题型可以考虑多种算法结合使用。