每日三题-Day5-C（HDU 1078 FatMouse and Cheese 记忆化搜索）

FatMouse and Cheese

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 9823 Accepted Submission(s): 4142

Problem Description

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
  
  

题目大意：

给你n和k

再给你一个n*n个数。这个数代表这个地方有多少个奶酪

一个老鼠在(0,0)处开始,可以向上下左右四个方向走不超过k格。

老鼠可以吃掉他走过的格子上的奶酪，但相对的，他会变胖。因此他下一次要走的格子上的奶酪数量要比这个格子的多。

问，这个老鼠最多能吃掉多少奶酪。

思路：

第一感觉应该是记忆化搜索，但是dp数组储存什么是个问题。

题目说了，下一个格子要比上一个格子的奶酪多，因此老鼠不能走回头路。而且也因为这个原因，走到该格子的话，后面能吃到的最多的奶酪（或者说后面的最优路径）已经唯一确定而不会改变。也就是说后面的路径和前面的路径无关。

因此，我选择用dp[i][j]储存在格子(i,j)处开始走的，能吃到的最多的奶酪数量。

如果走到了(i,j)，那么后面不用再往下搜了，直接+dp[i][j]。前提是已经搜过一遍了，dp[i][j]已经更新。

搜的同时，比较从上下左右四个方向的每个方案的dp值，取最大者。

状态转移方程：

dp[i][j]=num[i][j]+max(dp[a][b]);(a,b)为所有在(i,j)出可行的下一步。

AC代码：

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;

int dp[111][111];
int num[111][111];
int n,k;

int dfs(int a,int b)
{
    if(dp[a][b]!=-1) return dp[a][b];
    dp[a][b]=num[a][b];
    int re=0;
    for(int i=1;i<=k;i++)
    {
        if(a+i<n&&num[a+i][b]>num[a][b])
        {
            re=max(re,dfs(a+i,b));
        }
        if(a-i>=0&&num[a-i][b]>num[a][b])
        {
            re=max(re,dfs(a-i,b));
        }
        if(b-i>=0&&num[a][b-i]>num[a][b])
        {
            re=max(re,dfs(a,b-i));
        }
        if(b+i<n&&num[a][b+i]>num[a][b])
        {
            re=max(re,dfs(a,b+i));
        }
    }
    return dp[a][b]+=re;
}

int main()
{
    while(~scanf("%d%d",&n,&k))
    {
        if(n==-1&&k==-1) break;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                scanf("%d",&num[i][j]);
            }
        }
        memset(dp,-1,sizeof(dp));
        dfs(0,0);
        printf("%d\n",dp[0][0]);
    }
    return 0;
}