UVA 10913 Walking on a Grid（记忆化搜索）

题意：

有一个大小有N（最多75）的方格，要你从（1，1）走到（n,n）。
有如下规则：你只有三个方向，左、右、下。不能走出方格。一个方格只能走一次。你要保证你的路径上的格子的和最大。你最多只能走k(最多为5)个负权值的格子，从起点到终点。如果可达输出最大的和，如果不可达输出”impossible”。

解析：

这题比较困难真的不好想。
这里用到了一个4维dp。dp[x][y][cur][dir]在当前(x,y)坐标上，经过cur次负权的格子，当前方向是dir时，最大的和。
然后又要用记忆化搜索，先从(1,1)推到(n,n)再逆推回来。
注意这题只能用vis数组进行标记，而不能用-INF进行标记。因为-INF是用来标记不可达的。还有就是，不要忘记(1,1)的时候有可能出现负数的话，搜索时cur要+1。

AC代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <cstdlib>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int N = 80;
int dx[] = { 1, 0, 0};
int dy[] = { 0,-1, 1};
int grid[N][N], dp[N][N][8][3];
bool vis[N][N][8][3];
int n, m;
int dfs(int x,int y,int cur,int dir) {
    int &ans = dp[x][y][cur][dir];
    bool &flag = vis[x][y][cur][dir];

    if(flag) return ans;
    if(cur > m) return ans = -INF;
    if(x == n && y == n) return ans = grid[n][n];

    ans = -INF;
    for(int i = 0; i < 3; i++) {
        int nx = x + dx[i];
        int ny = y + dy[i];
        if(i + dir == 3)
            continue;
        if(nx >= 1 && nx <= n && ny >= 1 && ny <= n) {
            int tmp = (grid[nx][ny] < 0);
            int sum = dfs(nx, ny, cur + tmp, i);
            if(sum != -INF)
                ans = max(ans, sum + grid[x][y]);
        }
    }

    flag = true;
    return ans;
}
int main() {
    int cas = 1;
    while(scanf("%d%d",&n,&m) != EOF && (n || m)) {
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= n; j++) {
                scanf("%d",&grid[i][j]);
            }
        }
        memset(vis,false,sizeof(vis));

        int tmp = (grid[1][1] < 0);
        int ans = dfs(1,1,tmp,0);
        printf("Case %d: ",cas++);
        if(dp[1][1][tmp][0] != -INF) {
            printf("%d\n",dp[1][1][tmp][0]);
        }else {
            printf("impossible\n");
        }
    }
    return 0;
}