CSP-S 方格取数

首先第一想法暴力搜索 但所需的时间复杂度太高，放弃了（但还是偷偷写了一下，大概能得二十分）

于是根据题目要求不能向左走，决定一列一列的处理，在每一列中求出当前位置最大值。 但是这种写法只有四十分
思路过程
1.数据按列处理，利用数dp存储到当前位置的最大值，为下一列存储做准备
2.每一个最大值dp[i][j] 可以看作是(上，下，左)三个方向中的所有可能路线取得的最大值，尤其是上下的所有路线比较复杂，具体可以看代码的设计。

40分代码：

#include<bits/stdc++.h>
using namespace std;
//a用于存储原地图

int a[1001][1001];
//dp用于存储到当前格的最大值
int dp[1001][1001];
int m,n;


int main()
{
	
	cin>>m>>n;
	for(int i=0;i<m;i++)
	{   
		for(int j=0;j<n;j++)
		{
			cin>>a[i][j];
		}
	}
	
	//dp初始化
	for(int i=0;i<m;i++)
	{   
		for(int j=0;j<n;j++)
		{
			dp[i][j]=-999999;
		}
	}
	
	//第一个数单独处理
	dp[0][0]=a[0][0];
	// 第一列单独处理
	for(int i=1;i<m;i++)
	{
		dp[i][0]=dp[i-1][0]+a[i][0];		
	}
	
	//按列一个一个处理
	for(int j=1;j<n;j++)
	{
		//处理(2--n)列
		for(int i=0;i<m;i++)
		{
		
			//找dp[i][j]的最大值
			//从上至下
			for(int z=0;z<=i;z++)
			{
				int sum=0;
				//从y行累加到n行
				int y;
				for(y=z;y<i;y++)
				{
					sum+=a[y][j];		
				}
				dp[i][j]=max(dp[i][j],sum+dp[z][j-1]+a[i][j]);
			
			}
			
			
			//从下至上
			for(int z=m-1;z>i;z--)
			{
				int sum=0;
				//从y行累加到i行
				int y;
				for(y=z;y>i;y--)
				{
					sum+=a[y][j];		
				}
				dp[i][j]=max(dp[i][j],sum+dp[z][j-1]+a[i][j]);
			}

		}
	}
	

	cout<<dp[m-1][n-1];
	return 0;
}

后来想着利用前缀和优化了一下代码，对方案提出一些更改。
1.对于任意一个点所求出的最大值，可以看作三个方向（下，上，左）取最大值，即max(down[i-1][j],up[i+1][j],dp[i-1][j])+a[i][j]。
2.也就是说只要将 down[i-1][j],up[i+1][j]求出来那就完事大吉了
注意：down[i-1][j] 代表 从上至下和从左至右到i-1的最大值
up[i-1][j] 代表 从下至上和从左至右到i-1的最大值

AC代码：

#include<bits/stdc++.h>
using namespace std;
//a用于存储原地图
long long a[1001][1001];
//dp用于存储到当前格的最大值
long long  dp[1001][1001];
long long down[1001][1001],up[1001][1001];

int m,n;
int main()
{
	
	cin>>m>>n;
	for(int i=1;i<=m;i++)
	{   
		for(int j=1;j<=n;j++)
		{
			cin>>a[i][j];
		}
	}
	
	memset(dp,128,sizeof(dp));
	memset(down,128,sizeof(down));	
	memset(up,128,sizeof(up));
		
	//第一个数单独处理
	dp[1][1]=a[1][1];
	// 第一列单独处理
	for(int i=2;i<=m;i++)
	{
		dp[i][1]=dp[i-1][1]+a[i][1];		
	}
	
	//m行n列 
	//按列一个一个处理 ,处理(2--n)列
	for(int j=2;j<=n;j++)
	{
		//遍历向下可以匹配到的最大值 
		down[1][j]=a[1][j]+dp[1][j-1];
		for(int i=2;i<=m;i++)
		{
			down[i][j]=max(down[i-1][j],dp[i][j-1])+a[i][j];
		}
		//遍历向上可以匹配到的最大值 
		up[m][j]=a[m][j]+dp[m][j-1];
		for(int i=m-1;i>=1;i--)
		{
			up[i][j]=max(up[i+1][j],dp[i][j-1])+a[i][j];
		}
		
		for(int i=1;i<=m;i++)
		{
			dp[i][j]=max(max(down[i-1][j],up[i+1][j]),dp[i][j-1])+a[i][j];
		}
		

	}
	cout<<dp[m][n];
	return 0;
}