FatMouse and Cheese HDU - 1078

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

首先这道题是记忆化搜索和dp的结合考察，什么是记忆化搜索？顾名思义，就是带有记忆化的搜索，利用数组的方式将已经计算过的东西记录下来在下一次使用的时候直接用已经计算出的值，避免重复运算，去掉重复的搜索树。递推法的时间复杂度：状态总数*每个状态的决策个数*决策时间。如果不同状态的决策个数不同，需要具体问题具体分析。记忆化搜索不像递推法那样显式的指明了计算顺序，但仍然可以保证每个节点之访问一次，使用记忆化搜索时，不必要事先确定各状态的计算顺序，但需要计算每个状态是否已经计算过。

题目大意就是老鼠在n*n的地图上走，每次只能移动k步，而且他每次移动到下一个点奶酪数必须比上一次大。求他最多能吃到多少奶酪？

样例解释：1-->2-->5-->6-->11-->12            加起来就是37也就是所求值。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=101;
int dp[maxn][maxn];
int map[maxn][maxn];
int nex[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
int n,k;
int dfs(int x,int y)
{
  int ans=0;
  if(!dp[x][y])
  {
    for(int i=1;i<=k;i++)
    {
      for(int j=0;j<4;j++)
      {
        int xx=x+nex[j][0]*i;
        int yy=y+nex[j][1]*i;
        if(xx<1||xx>n||yy<1||yy>n)
           continue;
        if(map[x][y]<map[xx][yy])
        {
          ans=max(ans,dfs(xx,yy));
        }
      }
    }
    dp[x][y]=map[x][y]+ans;
  }
  return dp[x][y];
}
int main()
{
  while(cin>>n>>k)
  {
    if(n==-1||k==-1)
       break;
    memset(map,0,sizeof(map));
    memset(dp,0,sizeof(dp));
    for(int i=1;i<=n;i++)
    {
      for(int j=1;j<=n;j++)
      {
        cin>>map[i][j];
      }
    }
    cout<<dfs(1,1)<<endl;
  }
  return 0;
}

这道题用了记忆化搜索能降低时间复杂度，提升效率。