UVA - 10913 Walking on a Grid

题意：求在经过的负数不超过K的情况下，从左上角到右下角的最大权值和，方向有左，右，下。

思路：跟数塔类似的思想，如果我们能够知道在满足条件的多个倒数第二的话，我们就可以得到最后一步的最大值，所以用四维空间记录状态，重要的一点是不能重复以前的路，就是不能从左来，有走回左边去，DP到最后一行的时候显然只能一直往右走，才能到达目标，INF表示无法走到的坐标

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 80;
const int INF = 1<<30;

bool vis[N][N][10][3];
long long dp[N][N][10][3];
int n,k,cas=1;
int map[N][N];
int dx[3]={0,0,1};
int dy[3]={-1,1,0};

int DP(int i,int j,int k,int d)
{
    long long &m = dp[i][j][k][d];
    if(vis[i][j][k][d])
        return m;
    vis[i][j][k][d]=true;

    if(k == 0 && map[i][j] < 0)
        return -INF;

    if(i == n-1 && j== n-1)
        return m = map[i][j];


    int x,y;
    if(map[i][j] < 0)
        k--;
    if(d != 1)
    {
        x = i + dx[1],y = j + dy[1];
        if (x >= 0 && x < n && y >= 0 && y < n)
        {
            DP(x,y,k,0);
            if(dp[x][y][k][0] != -INF)
                m = max(m,dp[x][y][k][0]+map[i][j]);
        }
    }
    if(d != 0 && i != n-1)
    {
        x = i + dx[0],y = j + dy[0];
        if (x >= 0 && x < n && y >= 0 && y < n)
        {
            DP(x,y,k,1);
            if(dp[x][y][k][1] != -INF)
                m=max(m,dp[x][y][k][1]+map[i][j]);
        }
    }
    if(i != n-1)
    {
        x = i + 1,y = j;
        DP(x,y,k,2);
        if(dp[x][y][k][2] != -INF)
            m=max(m,dp[x][y][k][2]+map[i][j]);
    }
    return m;
}

int main()
{
    while(scanf("%d%d",&n,&k),n+k)
    {
        for(int i = 0; i < n; i++)
            for(int j = 0; j < n; j++)
            {
                scanf("%d",&map[i][j]);
                for(int t = 0; t <= k; t++)
                    dp[i][j][t][0] = dp[i][j][t][1] = dp[i][j][t][2] = -INF;
            }
        memset(vis,false,sizeof(vis));
        DP(0,0,k,0);
        printf("Case %d: ",cas++);
        if(dp[0][0][k][0] != -INF)
            printf("%lld\n",dp[0][0][k][0]);
        else
            puts("impossible");
    }
    return 0;
}