二维数组和最大的子矩阵

题目：给出一个 m*n 的二维矩阵(元素可为正可为负)，求该二维矩阵的一个子矩阵，且此子矩阵中所有元素的和最大，并输出该矩阵的和。

方法1：

i到j行的数组相加，得到一个一维数组。在整个一维数组上求和最大的连续子数组。

#include <iostream>
using namespace std;

int *sum_i_j(int **data,int cols,int i,int j){

int *sum=new int[cols];

memset(sum,0,sizeof(int)*cols);

for(int col=0;col<cols;col++){
for(int row=i;row<=j;row++){
sum[col]+=data[row][col];
}
}

return sum;
}

int maxSum(int *dataCols,int cols){
int max=dataCols[0];

int *sum=new int[cols];
memset(sum,0,sizeof(int)*cols);

sum[0]=dataCols[0];

for(int i=1;i<cols;i++){
sum[i]=dataCols[i];
if(sum[i]<(sum[i-1]+dataCols[i])){
sum[i]=sum[i-1]+dataCols[i];
}

if(sum[i]>max)
max=sum[i];
}

delete sum;

return max;
}

int maxSubSum(int **data,int rows,int cols){
int max=-0x3f3f3f3f;

int *sumTmp=new int[cols];

for(int i=0;i<rows;i++){
for(int j=i;j<rows;j++){
sumTmp=sum_i_j(data,cols,i,j);
int tmp=maxSum(sumTmp,cols);
if(tmp>max){
max=tmp;
}
}
}

delete sumTmp;

return max;
}

int main(){
/************************************************************************/
/*
4 4
0 -2 -7 0
9 2 -6 2
-4 1 -4 1
-1 8 0 -2                                                                     */
/************************************************************************/
int rows,cols;
cin>>rows>>cols;

int **data=new int*[rows];//二维数组传值很麻烦

for(int i=0;i<rows;i++){

data[i]=new int[cols];///

for(int j=0;j<cols;j++){
cin>>data[i][j];
;       }
}

cout<<maxSubSum(data,rows,cols)<<endl;

system("pause");
return 0;
}

方法1的时间复杂度为O（（m*n）^2），跟蛮力遍历好不到哪去。

分析可以得到，时间复杂度每次循环都要求出sumTmp=sum_i_j(data,cols,i,j);

如果耗费空间，先求好存起来，时间复杂度就小了。

方法2：

优化：给出一个二维子矩阵，为了更快地求出其对应的一维矩阵，我们可以使用二维数组sum[x][y]预先保存第y列，从第0行到第x行之间元素之和。

此时，我们要求第i行开始，到第j行结束的矩阵对应的一维矩阵时，可有sum[j][t] - sum[i - 1][t],t属于[0,n]得到.

此时，时间复杂度为O(m*m*n)

程序就不写了，粘一下别人的

#include <iostream>
#include <assert.h>
using namespace std;

/*最大子数组之和*/
int MaxSubSum(int nArr[],int nLen)
{
assert(nArr && nLen > 0);
int nMaxSum = nArr[0];
int nCurSum = nArr[0];
for (int i = 1;i < nLen;i++)
{
if (nCurSum < 0)
{
nCurSum = nArr[i];
}
else
{
nCurSum += nArr[i];
}
nMaxSum = max(nCurSum,nMaxSum);
}
return nMaxSum;
}

/*把原矩阵第i行和第j行之间元素进行压缩，形成一个一维数组*/
void InitSumArr(int** pnArr,int** pnArrColSum,int nXLen,int nYLen)
{
assert(pnArr && *pnArr && pnArrColSum && *pnArrColSum);
assert(nXLen > 0 && nYLen > 0);
for (int i = 0;i < nXLen;i++)//横坐标
{
for (int j = 0;j < nYLen;j++)//纵坐标
{
pnArrColSum[i][j] = 0;
for (int t = 0;t <= i;t++)
{
pnArrColSum[i][j] += pnArr[t][j];
}
}
}
}
/*枚举二维数组，压缩成一维数组，求解最大子数组和*/
int MaxSubMatrixSum(int** pnArr,int** pnArrColSum,int nXLen,int nYLen)
{
assert(pnArr && *pnArr && pnArrColSum && *pnArrColSum);
assert(nXLen > 0 && nYLen > 0);
int nMaxSum = -0x3f3f3f3f;
int nCurSum = -0x3f3f3f3f;
int* pTmpArr = new int[nYLen];
for (int i = 0;i < nXLen;i++)
{
for (int j = i;j < nXLen;j++)
{
if (i == 0)
{
for (int t = 0;t < nYLen;t++)
{
pTmpArr[t] = pnArrColSum[j][t];
}
nCurSum = MaxSubSum(pTmpArr,nYLen);
nMaxSum = max(nCurSum,nMaxSum);
}
else
{
//计算每列元素和,并求最大子数组之和
for (int t = 0;t < nYLen;t++)
{
pTmpArr[t] = pnArrColSum[j][t] - pnArrColSum[i - 1][t];
}
nCurSum = MaxSubSum(pTmpArr,nYLen);
nMaxSum = max(nCurSum,nMaxSum);
}
}
}
return nMaxSum;
}
int main()
{
int nXLen = 0;
int nYLen = 0;

cin>>nXLen>>nYLen;
int** pnArr = new int*[nXLen];
int** pnArrColSum = new int*[nXLen];
for (int i = 0;i < nXLen;i++)
{
pnArr[i] = new int[nYLen];
pnArrColSum[i] = new int[nYLen];
for (int j = 0;j < nYLen;j++)
{
cin>>pnArr[i][j];
}
}
InitSumArr(pnArr,pnArrColSum,nXLen,nYLen);
cout<<MaxSubMatrixSum(pnArr,pnArrColSum,nXLen,nYLen)<<endl;
system("pause");
return 1;
}