hdu1078（dfs-记忆化搜索）

FatMouse has stored some cheese in a city. The city can be considered as a square grid of dimension n: each grid location is labelled (p,q) where 0 <= p < n and 0 <= q < n. At each grid location Fatmouse has hid between 0 and 100 blocks of cheese in a hole. Now he’s going to enjoy his favorite food.

FatMouse begins by standing at location (0,0). He eats up the cheese where he stands and then runs either horizontally or vertically to another location. The problem is that there is a super Cat named Top Killer sitting near his hole, so each time he can run at most k locations to get into the hole before being caught by Top Killer. What is worse – after eating up the cheese at one location, FatMouse gets fatter. So in order to gain enough energy for his next run, he has to run to a location which have more blocks of cheese than those that were at the current hole.

Given n, k, and the number of blocks of cheese at each grid location, compute the maximum amount of cheese FatMouse can eat before being unable to move.
Input
There are several test cases. Each test case consists of

a line containing two integers between 1 and 100: n and k
n lines, each with n numbers: the first line contains the number of blocks of cheese at locations (0,0) (0,1) … (0,n-1); the next line contains the number of blocks of cheese at locations (1,0), (1,1), … (1,n-1), and so on.
The input ends with a pair of -1’s.
Output
For each test case output in a line the single integer giving the number of blocks of cheese collected.
Sample Input
3 1
1 2 5
10 11 6
12 12 7
-1 -1
Sample Output
37

一开始用bfs超内存，后来用dfs超时间，以为因为数是越来越大的，所以不用标记同一条路线就不会走重复点了，就没有标记了，但这道题是要你选一条路线走各点数相加起来是最大的（数相加时是从小到大的）那么你这里就可以用一个二维数组存储从改点走可以得到最大的和（不包括改点之前走的数），那么如果你该点的最大和已经知道了，其他路线走到这点时就直接用即可，就不用在找改点及以后的最大值了，省的时间是非常惊人的。

ac代码

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <math.h>
#include <cstdlib>
#include <queue>
#include<iomanip>
using namespace std;
int p[105][105], n,k;
int s1[4] = { 1,-1,0,0 };
int s2[4] = { 0,0,1,-1 };
int ji[105][105];//记从该点走起的最大和（包括该点数）
int dfs(int x, int y)
{
	int h = 0,max = 0;
	int p1, p2;
	if (!ji[x][y])//该点走起的最大和如果已经知道了，就不用再找了，记忆化搜索记忆化搜索，一直忽略导致超时，没有记忆化，走完都要费了
	{
		for (int j = 1; j <= k; j++)
		{
			for (int i = 0; i < 4; i++)
			{
				p1 = x + s1[i] * j;
				p2 = y + s2[i] * j;
				if (p1 >= 0 && p2 >= 0 && p1 < n&&p2<n&&p[p1][p2]>p[x][y])
				{
					int h = dfs(p1, p2);//找某点后不同方向走能的到的最大和
					max = h > max ? h : max;//找出上边最大的
				}
			}
		}
	ji[x][y] = max + p[x][y];//那该点的数加上该点以后的最大和就是该点走起的最大和（包括该点数）。
	}
	return ji[x][y];
}
int main()
{
	
	while (cin >> n >> k)
	{
		memset(ji, 0, sizeof(ji));
		if (n == -1 && k == -1)break;
		for (int i = 0; i < n; i++)
			for (int j = 0; j < n; j++)
			scanf("%d", &p[i][j]);
		cout <<dfs(0,0) << endl;

	}
}