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;
}

這道題用了記憶化搜索能降低時間複雜度，提升效率。