FatMouse and Cheese【暑期集训D题】【DFS+记忆化搜索】

       之所以先写这道题其实是有理由的，因为这道题要讲课，所以提前在博客上写些（说实话这道题是今早才A的，但是前面有好几道题还没来得及写下来......）

题面：

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. 

InputThere 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. 
OutputFor 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

        说一下这道题吧，就是一直老鼠从（0，0）点出发，每次只能（either......or.......）水平走或者垂直走1～k步，那么问题就能够简化了，我们从一个点，就定义为（x，y），出发，老鼠想吃到的奶酪，无非就是比这个点上奶酪数多的水平或者垂直方向上1～k步上的这些个点，那么我们就确定了下一步的几个点，接下来就是要确认我们要选的是接下来的哪一个点，不妨把这个点的值当作已经知道结果了的值点，那么就是我运用DFS思维的由来，其中对每个元素的DFS返还的是它之后所能吃到的奶酪的最大值，附上主要代码说明一下：

int dfs(int now_x, int now_y)
{
    if(!dp[now_x][now_y])
    {
        int maxx=0;
        for(int i=1; i<=k; i++)
        {
            for(int j=0; j<4; j++)
            {
                int next_x=now_x+dir[j][0]*i;
                int next_y=now_y+dir[j][1]*i;
                if(!within(next_x, next_y))continue;
                if(mp[next_x][next_y]>mp[now_x][now_y])
                {
                    maxx=max(maxx, dfs(next_x, next_y));
                }
            }
        }
        dp[now_x][now_y]=mp[now_x][now_y]+maxx;
    }
    return dp[now_x][now_y];
}

        在这里，我们用逆向思维，把目前顶点当作所求点，把之后的所有目的地点当作比较点，而对于每个目的地点，假如他已经求出值，那么这个值注定是该点在该区域上的最大值。

完整代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int n,k;
int mp[105][105];
int dp[105][105];
int dir[4][2]=
{
    -1,0,
    0,-1,
    0,1,
    1,0
};
bool within(int now_x, int now_y)       //是否在图上
{
    return (now_x>=0&&now_x<n&&now_y>=0&&now_y<n)?true:false;
}
int dfs(int now_x, int now_y)
{
    if(!dp[now_x][now_y])
    {
        int maxx=0;
        for(int i=1; i<=k; i++)
        {
            for(int j=0; j<4; j++)
            {
                int next_x=now_x+dir[j][0]*i;
                int next_y=now_y+dir[j][1]*i;
                if(!within(next_x, next_y))continue;
                if(mp[next_x][next_y]>mp[now_x][now_y])
                {
                    maxx=max(maxx, dfs(next_x, next_y));
                }
            }
        }
        dp[now_x][now_y]=mp[now_x][now_y]+maxx;
    }
    return dp[now_x][now_y];
}
int main()
{
    while(scanf("%d%d",&n,&k))
    {
        memset(dp, 0, sizeof(dp));
        memset(mp, 0, sizeof(mp));
        if(n==-1&&k==-1)break;
        for(int i=0; i<n; i++)
        {
            for(int j=0; j<n; j++)
            {
                scanf("%d",&mp[i][j]);
            }
        }
        printf("%d\n",dfs(0, 0));
    }
    return 0;
}