51nod-1051 最大子矩阵和

1051 最大子矩阵和 

基准时间限制：2 秒 空间限制：131072 KB 分值: 40  难度：4级算法题

 收藏

 关注

一个M*N的矩阵，找到此矩阵的一个子矩阵，并且这个子矩阵的元素的和是最大的，输出这个最大的值。

例如：3*3的矩阵：

-1 3 -1

2 -1 3

-3 1 2

和最大的子矩阵是：

3 -1

-1 3

1 2

Input

第1行：M和N，中间用空格隔开（2 <= M,N <= 500)。
第2 - N + 1行：矩阵中的元素，每行M个数，中间用空格隔开。(-10^9 <= M[i] <= 10^9)

Output

输出和的最大值。如果所有数都是负数，就输出0。

Input示例

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

Output示例

7

思路：对于矩阵a[n][m]的最大子矩阵和，如果用暴力的话，要遍历子矩阵的上下左右边的位置，那么时间复杂度为 O(n^4) ,会 TLE, 因此要考虑优化，对于最大子矩阵和，肯定是要遍历所有的子矩阵，而对于子矩阵的四边位置，右下端的两边是一定要遍历的，那么就要考虑如何遍历另一边就可以找出 最大子矩阵，这样时间复杂度就为 O(n^3)。

dp[i][j][k]:  子矩阵右下端以 i,j为边， 高为h的最大子矩阵和    || S为 j-1->j 间绿色阴影面积

状态转移方程： 对于dp[i][j][k], 对dp[i][j-1][k]就行分析：

若 dp[i][j-1][k]>0:  则 dp[i][j][k]= dp[i][j-1][k]+ S

若dp[i][j-1][k]<=0: 则 dp[i][j][k]= S

综上：dp[i][j][k]= max(dp[i][j-1][k]+S,S);

由方程知 第一维[i]可以去掉，即 dp[j][k]= max(dp[j-1][k]+S,S);

而在观察可知 第二维 [j]也可以去掉，即  dp[k]=max(dp[k]+S,S);

而对于 面积S,可以先用前缀和求出 a[1][1]到 a[i][j]的和(就保存在 a[i][j]中。这样S=a[i][j]-a[i][j-1]-a[i-k][j]+a[i-k][j-1]

Code 1:

//二维dp 
#include<iostream>
using namespace std;
typedef long long LL;

const int MAX_N=505;
const int MAX_M=505;
int n,m;
LL a[MAX_N][MAX_M];
LL dp[MAX_M][MAX_N];	

int main()
{
	ios::sync_with_stdio(false);
	cin>>m>>n;
	for(int i=1;i<=n;++i)
		for(int j=1;j<=m;++j)
		{
			cin>>a[i][j];
			a[i][j]+=a[i-1][j]+a[i][j-1]-a[i-1][j-1];
		}
	LL ans=0;
	for(int i=1;i<=n;++i)
		for(int k=1;k<=i;++k)
			for(int j=1;j<=m;++j)
			{
				dp[j][k]+=a[i][j]-a[i][j-1]-a[i-k][j]+a[i-k][j-1];
				if(dp[j-1][k]>0)	dp[j][k]+=dp[j-1][k];
				ans=max(ans,dp[j][k]);
			}
	cout<<ans<<endl;
	return 0;
}

Code 2:

//一维DP 
#include<iostream>
using namespace std;
typedef long long LL;

const int MAX_N=505;
const int MAX_M=505;
int n,m;
LL a[MAX_N][MAX_M];
LL dp[MAX_N];	

int main()
{
	ios::sync_with_stdio(false);
	cin>>m>>n;
	for(int i=1;i<=n;++i)
		for(int j=1;j<=m;++j)
		{
			cin>>a[i][j];
			a[i][j]+=a[i-1][j]+a[i][j-1]-a[i-1][j-1];
		}
	LL ans=0;
	for(int i=1;i<=n;++i)
		for(int k=1;k<=i;++k)
		{
			dp[k]=0;
			for(int j=1;j<=m;++j)
			{
				if(dp[k]<0)	dp[k]=0;
				dp[k]+=a[i][j]-a[i][j-1]-a[i-k][j]+a[i-k][j-1];
				ans=max(ans,dp[k]);
			}
		}
	cout<<ans<<endl;
	return 0;
}