动态规划：2020 CSP-J2赛题之方格取数

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

【输入格式】
第一行有两个整数 n，m。
接下来 n 行，每行 m 个整数，依次代表每个方格中的整数。

【输出格式】
一个整数，表示小熊能取到的整数之和的最大值。

【数据规模与约定】
对于20%的数据，n，m≤5。
对于40%的数据，n , m ≤ 50 。
对于70%的数据，n , m ≤ 300。 
对于100%的数据，1≤n，m≤10^3。方格中整数的绝对值不超过10^4。

【算法分析一】
将数据矩阵顺时针旋转90度，则每一步由只能向上、向下或向右走一格转变为只能向左、向右或向下走一格，加上题目给出的“不能重复经过已经走过的方格”的约束，则走法便退化为了只能向下、向右走一格，显然此时已经是经典的DP问题了，满足DP“无后效性”的特点，便可按经典DP的自底向上方法或最后一步法（动态规划适用的问题类型及分析思路 ＜--- 最后一步法_hnjzsyjyj的专栏-CSDN博客_动态规划适合解决什么类型的问题）进行分析。
在代码实现上，为了达到旋转数据矩阵的要求，在按题意读入数据后，按照先列后行的顺序处理便可。即以原矩阵的转置矩阵进行分析。

设f[i][j][0]表示由左方来到(i,j)的路径上的整数之和的最大值，f[i][j][1]表示由右方来到(i,j)的路径上的整数之和的最大值：
● 由左方来到(i,j)的路径上的整数之和的最大值：f[i][j][0]=max(f[i][j][0],f[i][j−1][0]+a[i][j])
● 由右方来到(i,j)的路径上的整数之和的最大值：f[i][j][1]=max(f[i][j][1],f[i][j+1][1]+a[i][j])
● 由上方来到(i,j)的路径上的整数之和的最大值：f[i][j][0]=max(f[i][j][0],max(f[i−1][j][0],f[i−1][j][1]))+a[i][j]、f[i][j][1]=max(f[i][j][1],max(f[i−1][j][0],f[i−1][j][1]))+a[i][j]

答案为：max(f[n][m][0],f[n][m][1])

【算法代码一：旋转法】

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;
LL n,m;
const int maxn=1005;
LL f[maxn][maxn][2];
LL a[maxn][maxn];

const int inf=0x3f3f3f3f;

int main() {
	cin>>n>>m;
	for(int i=1; i<=n; i++)
		for(int j=1; j<=m; j++)
			cin>>a[j][i];
	
	swap(n,m);
	
	for(int i=0; i<=n+1; i++)
		for(int j=0; j<=m+1; j++)
			f[i][j][0]=f[i][j][1]=-inf;	
	f[1][1][0]=f[1][1][1]=a[1][1];
	
	for(int i=1; i<=n; i++) {
		for(int j=1; j<=m; j++) {
			if(i>1) { //from up
				f[i][j][0]=max(f[i][j][0],max(f[i-1][j][0],f[i-1][j][1])+a[i][j]);
				f[i][j][1]=max(f[i][j][1],max(f[i-1][j][0],f[i-1][j][1])+a[i][j]);
			}
			if(j>1) f[i][j][0]=max(f[i][j][0],f[i][j-1][0]+a[i][j]); //from left
		}
		for(int j=m; j>0; j--) //from right
			if(j<m) f[i][j][1]=max(f[i][j][1],f[i][j+1][1]+a[i][j]);
	}
	
	cout<<max(f[n][m][0],f[n][m][1]);

	return 0;
}

/*
in 1:
3 4
1 -1 3 2
2 -1 4 -1
-2 2 -3 -1

out 1:
9
----------------------
in 2:
2 5
-1 -1 -3 -2 -7
-2 -1 -4 -1 -2

out 2:
-10
*/

【算法分析二】
将数据矩阵按列分析，也满足DP“无后效性”的特点。

【算法代码二：按列法】

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;
const int maxn=1005;
LL f[maxn][maxn];
LL a[maxn][maxn];

const int inf=0x3f3f3f3f;

int main() {
	//read data
	int n,m;
	cin>>n>>m;
	for(int i=1; i<=n; i++) {
		for(int j=1; j<=m; j++) {
			cin>>a[i][j];
		}
	}

	//initialization
	f[1][1]=a[1][1];
	for(int i=2; i<=n; i++) {
		f[i][1]=-inf;
	}

	//state transition
	LL s;
	for(int j=2; j<=m; j++) {
		//from up to down
		s=-inf;
		for(int i=1; i<=n; i++) {
			s=max(f[i][j-1],s+a[i][j-1]);
			f[i][j]=s+a[i][j];
		}

		//from down to up
		s=-inf;
		for(int i=n; i>=1; i--) {
			s=max(f[i][j-1],s+a[i][j-1]);
			f[i][j]=max(f[i][j],s+a[i][j]);
		}
	}

	//searching for answers
	LL ans=-inf;
	s=0;
	for(int i=n; i>=1; i--) {
		ans=max(ans,f[i][m]+s);
		s+=a[i][m];
	}

	cout<<ans<<endl;

	return 0;
}

/*
in 1:
3 4
1 -1 3 2
2 -1 4 -1
-2 2 -3 -1

out 1:
9
----------------------
in 2:
2 5
-1 -1 -3 -2 -7
-2 -1 -4 -1 -2

out 2:
-10
*/

【参考文献】
https://blog.csdn.net/dgssl_xhy/article/details/110257858
https://blog.csdn.net/qq_39940018/article/details/110240821
https://www.acwing.com/solution/content/24644/
https://blog.csdn.net/qiaoxinwei/article/details/109636436
https://blog.csdn.net/justidle/article/details/109560228