【DP】方格取数

方格取数 [ Problem 4882 ] [ Discussion ]

Description
设有 $n\times m$的方格图，每个方格中都有一个整数。现有一只小熊，想从图的左上角走到右下角，每一步只能向上、向下或向右走一格，并且不能重复经过已经走过的方格，也不能走出边界。小熊会取走所有经过的方格中的整数，求它能取到的整数之和的最大值。

Input
第一行有两个整数 $n,m$。
接下来 $n$ 行每行 $m$ 个整数，依次代表每个方格中的整数。

Output
一个整数，表示小熊能取到的整数之和的最大值。

Samples
Input Copy

3 4
1 -1 3 2
2 -1 4 -1
-2 2 -3 -1

Output

9

Input Copy

2 5
-1 -1 -3 -2 -7
-2 -1 -4 -1 -2

Output

-10

样例1解释：

按上述走法，取到的数之和为$1+2+(-1)+4+3+2+(-1)+(-1)=9$，可以证明为最大值。

注意，上述走法是错误的，因为第 $2$ 行第 $2$ 列的方格走过了两次，而根据题意，不能经过已经走过的方格。

另外，上述走法也是错误的，因为没有走到右下角的终点。

样例2解释：

按上述走法，取到的数之和为$(-1)+(-1)+(-3)+(-2)+(-1)+(-2)=-10$，可以证明为最大值。因此，请注意，取到的数之和的最大值也可能为负数。

数据范围：

对于 $20$% 的数据，$n,m\le 5$。
对于 $40$% 的数据，$n,m\le 50$。
对于 $70$%的数据，$n,m\le 300$。
对于 $100$%的数据，$1\le n,m\le 10^3$。方格中整数的绝对值不超过 $10^4$。

Source
2020 CSP J2

大佬题解：直呼抽风大佬$Orz$ %%%

我自己一开始写的是 $DFS$ 三个方向搜索，自我感觉挺对的，但是只得了 $5$ 分就很尴尬。
错误得代码写上，记录一下。

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
int n, m;
ll a[2010][2010];
bool vis[2010][2010];
ll ans;
int dx[] = { 1,0,-1};
int dy[] = { 0,1,0};
void dfs(int x, int y,ll sum)
{
	if (x == n && y == m)
	{
		ans = max(ans, sum);
		return;
	}
	for (int i = 0;i < 3;i++)
	{
		int xx = x + dx[i];
		int yy = y + dy[i];
		if (!vis[xx][yy]&&xx>=1&&xx<=n&&yy>=1&&yy<=m)
		{
			vis[xx][yy] = true;
			dfs(xx, yy, sum + a[xx][yy]);
			vis[xx][yy] = false;
		}
	}
}
int main()
{
	cin >> n >> m;
	for (int i = 1;i <= n;i++)
	{
		for (int j = 1;j <= m;j++)
		{
			scanf("%lld", &a[i][j]);
		}
	}
    vis[1][1] = true;
    ans = -1000000000000000;
    dfs(1, 1, a[1][1]);
    cout << ans << endl;
	return 0;
}

上面这份代码只能得 $5$ 分或者不得分，较大的可能应该是超时的缘故吧（自己瞎猜的）。

正解：经过学习抽风大佬博客里的讲解，大概了解了。思路就是 $DP$，就和数字三角形
那道题差不多，这道题是它的强化版，数字三角形就只是从上到下的递推，这道题可以从上到下，从左到右，也可以从下到上的进行转化，利用符号语言来表示就是，如下：
$$dp[i-1][j]->dp[i][j]$$
$$dp[i+1][j]->dp[i][j]$$
$$dp[i][j-1]->dp[i][j]$$
这样一来可分析出，$dp[i][j]$这个状态可以有以上三种状态转移过来。
对于每一列来说，只能是从左侧转移到右侧一个方向，从此处下手就很容易推到出递推公式，初次踏入第j列时一定是由左侧向右走得到。对于$dp(i,j-1)$这个状态的得出是根据上方三个来源得到的，取三者最优即可。
对于是从上方来的，还是下方来的，需要同时处理，方便起见再加一维来表示方向，$dp[i][j][0]$表示从上方或左方转移而来的状态，$dp[i][j][1]$表示从下方或左方转移过来的状态。
递推公式：

dp[i][j][0] = max(dp[i - 1][j][0],max(dp[i][j - 1][0],dp[i][j - 1][1])) + a[i][j];
dp[i][j][1] = max(dp[i + 1][j][1],max(dp[i][j - 1][0],dp[i][j - 1][1])) + a[i][j];

上代码（100分）

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
int n, m;
ll dp[1010][1010][2];
///dp[i][j][0]表示从上方走到（i,j）位置的最大值
///dp[i][j][1]表示从下方走到（i,j）位置的最大值
ll a[1010][1010];
int main()
{
	scanf("%d%d",&n,&m);
	for(int i = 1;i <= n;i++)
    {
        for(int j = 1;j <= m;j++)
        {
            scanf("%lld",&a[i][j]);
        }
    }
    memset(dp,0xcf,sizeof dp);
	dp[1][0][0] = dp[1][0][1] = 0;
    for(int j = 1;j <= m;j++)///循环列
    {
        for(int i = 1;i <= n;i++)///从上到下更新dp[i][j][0]
        {
            dp[i][j][0] = max(dp[i - 1][j][0],max(dp[i][j - 1][0],dp[i][j - 1][1])) + a[i][j];
        }
        for(int i = n;i >= 1;i--)///从下到上更新dp[i][j][1]
        {
            dp[i][j][1] = max(dp[i + 1][j][1],max(dp[i][j - 1][0],dp[i][j - 1][1])) + a[i][j];
        }
    }
    cout<<dp[n][m][0]<<endl;
	return 0;
}