P - FatMouse and Cheese——记忆DP探索与发现过程

P - FatMouse and Cheese

Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u

Submit  Status

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

 

#include
#include
#include
int my_max(int x,int y)  {return x>y?x:y;}
int dp[105][105];
int e[104][105];
int main()
{
	int n,k,i,j,l,max;
	while(scanf("%d %d",&n,&k))
	{
		memset(dp,0,sizeof(dp));
		memset(e,0,sizeof(e));
		if(n==-1)	break;
		for(i=0;i=0)
					{
						if(e[i][j]>e[i][j-l])
						{
							max=my_max(max,dp[i][j-1]);
						}
					}
					if(j+le[i][j+l])
						{
							max=my_max(max,dp[i][j+1]);
						}
					}
					if(i+le[i+l][j])
						{
							max=my_max(max,dp[i+l][j]);
						}
					}
					if(i-l>=0)
					{
						if(e[i][j]>e[i-l][j])
						{
							max=my_max(max,dp[i-l][j]);
						}
					}
				}
				dp[i][j]=max+e[i][j];
			}
		}
		max=0;
		for(i=0;i

这是我刚开始的想法，一行一行的进行遍历，后来发现不行，因为后面和下面的DP值是不知道的，所有就没有办法进行下去

后来参考了其他资料，发现了记忆DP   利用递归的方式进行计算，

#include
#include
#define N 105

int e[N][N];
int dp[N][N];
int n,k;
int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

bool judge(int x, int y)
{
    if(x < 0 || y < 0)
        return false;
    if(x >= n || y >= n)
        return false;
    return true;
}


int memory(int x,int y)
{
    int i, j, max = 0, tmax;
    if(dp[x][y] > 0)//如果已经计算过了，就直接返回值，不必要重复计算了 
        return dp[x][y];
    
    for(i=0;i<4;i++)//向四个方向各找t个点 
    {
    	int xx=x,yy=y;
        for(j=0;je[x][y])//如果符合条件，则计算出对应点的值，并找出其中最大的值 
            {
                tmax=memory(xx,yy);
                if(tmax>max)
                    max=tmax;
            }
        }
    }
    dp[x][y]=max+e[x][y];//dp[][]加上对应的值 
    return dp[x][y];
}



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