计蒜客 逃生（DP）

逃生

#include <iostream>
#include <string>
#include <queue>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <algorithm>

#define maxn 1005
using namespace std;

int n, m, x, y, v, c, startx, starty;
int board[maxn][maxn];
long long dp[maxn][maxn];

int main()
{
    //freopen("data.in","r",stdin);
    ios::sync_with_stdio(false);

    cin >> n >> m >> x >> y >> v >> c;
    memset(dp, -1, sizeof(dp));
    for(int i = 1; i <= n; ++i)
    {
        for(int j = 1; j <= m; ++j)
        {
            cin >> board[i][j];
            if(board[i][j] == 0)
            {
                startx = i;
                starty = j;
            }
        }
    }

    long long res = -1;
    dp[startx][starty] = v;
    //预处理：左伸
    for(int j = starty - 1; j >= 1; --j)
    {
        if(dp[startx][j+1] > 0)
        {
            dp[startx][j] = dp[startx][j+1] + board[startx][j];
        }

        if(dp[startx][j] >= c )
        {
            dp[startx][j] = c;
        }
        if(dp[startx][j] <= 0)
        {
            dp[startx][j] = -1;
        }
    }
    //预处理：右伸
    for(int j = starty + 1; j <= m; ++j)
    {
        if(dp[startx][j-1] > 0)
        {
            dp[startx][j] = dp[startx][j-1] + board[startx][j];
        }

        if(dp[startx][j] >= c )
        {
            dp[startx][j] = c;
        }
        if(dp[startx][j] <= 0)
        {
            dp[startx][j] = -1;
        }
    }
    //预处理：上伸
    for(int i = startx - 1; i >= 1; --i)
    {
        if(dp[i+1][starty] > 0)
        {
            dp[i][starty] = dp[i+1][starty] + board[i][starty];
        }
        if(dp[i][starty] >= c )
        {
            dp[i][starty] = c;
        }
        if(dp[i][starty] <= 0)
        {
            dp[i][starty] = -1;
        }
    }
    //预处理：下伸
    for(int i = startx + 1; i <= n; ++i)
    {
        if(dp[i+1][starty] > 0)
        {
            dp[i][starty] = dp[i-1][starty] + board[i][starty];
        }
        if(dp[i][starty] >= c )
        {
            dp[i][starty] = c;
        }
        if(dp[i][starty] <= 0)
        {
            dp[i][starty] = -1;
        }
    }

    //左上
    for(int i = startx - 1; i >= 1; --i)
    {
        for(int j = starty - 1; j >= 1; --j)
        {
            if(dp[i+1][j] < 0 && dp[i][j+1] < 0)
            {
                dp[i][j] = -1;
            }
            else
            {
                dp[i][j] = board[i][j] + max(dp[i+1][j], dp[i][j+1]);
            }
            if(dp[i][j] >= c )
            {
                dp[i][j] = c;
            }
            if(dp[i][j] <= 0)
            {
                dp[i][j] = -1;
            }
        }
    }
    res = max(res, dp[1][1]);

    //右上
    for(int i = startx - 1; i >= 1; --i)
    {
        for(int j = starty + 1; j <= m; ++j)
        {
            if(dp[i+1][j] < 0 && dp[i][j-1] < 0)
            {
                dp[i][j] = -1;
            }
            else
            {
                dp[i][j] = board[i][j] + max(dp[i+1][j], dp[i][j-1]);
            }
            if(dp[i][j] >= c )
            {
                dp[i][j] = c;
            }
            if(dp[i][j] <= 0)
            {
                dp[i][j] = -1;
            }
        }
    }
    res = max(res, dp[1][m]);

    //左下
    for(int i = startx + 1; i <= n; ++i)
    {
        for(int j = starty - 1; j >= 1; --j)
        {
            if(dp[i-1][j] < 0 && dp[i][j+1] < 0)
            {
                dp[i][j] = -1;
            }
            else
            {
                dp[i][j] = board[i][j] + max(dp[i-1][j], dp[i][j+1]);
            }
            if(dp[i][j] >= c )
            {
                dp[i][j] = c;
            }
            if(dp[i][j] <= 0)
            {
                dp[i][j] = -1;
            }
        }
    }
    res = max(res, dp[n][1]);

    //右下
    for(int i = startx + 1; i <= n; ++i)
    {
        for(int j = starty + 1; j <= m; ++j)
        {
            if(dp[i-1][j] < 0 && dp[i][j-1] < 0)
            {
                dp[i][j] = -1;
            }
            else
            {
                dp[i][j] = board[i][j] + max(dp[i-1][j], dp[i][j-1]);
            }
            if(dp[i][j] >= c )
            {
                dp[i][j] = c;
            }
            if(dp[i][j] <= 0)
            {
                dp[i][j] = -1;
            }
        }
    }
    res = max(res, dp[n][m]);

    cout << res << endl;
    return 0;
}