QUSTOJ1229：最大子矩阵

Description

有一个包含正数和负数的二维数组。一个子矩阵是指在该二维数组里，任意相邻的下标是 1 x 1 或更大的子数组。一个子矩阵的和是指该子矩阵中所有元素的和。本题中，把具有最大和的子矩阵称为最大子矩阵。

例如，如下数组的最大子矩阵位于左下角，

 0 -2 -7  0

 9  2 -6  2

-4  1 -4  1

-1  8  0 -2

最大子矩阵为

 9  2

-4  1

-1  8

其和为15。

Input

第一行是一个测试数据的个数T，表示将会有T组测试数据。下一行输入一个正整数N，表示二维方阵的大小。接下来是N2个整数（由空格和换行隔开）。该数组的N2个整数，是以行序给出的。也就是，先是第一行的数，由左到右；然后是第二行的数，由左到右，等等。N可能达到100，数组元素的范围是[-127,127]。

Output

与测试数据对应，刚好有T行，每行输出最大子矩阵的和。

Sample Input

2
4
0 -2 -7 0
9 2 -6 2
-4 1 -4 1
-1 8 0 -2
3
3 9 -5
-9 4 -2
3 6 -7

Sample Output

15
16

	So……这是开学以来做的第一个DP类问题了，以前学的东西现在忘得只能记得名字了，也是醉了……

	回归正题，我首先想到的方法是穷举所有情况，来算一下————确定第一个坐标要用O（n^2），确定第二个坐标也是O（n^2），计算并存储最大值是O（n^2），总复杂度是O（n^6）——这闹呢！貌似校内OJ的数据挺弱的，这样也能解出来，但是指望用穷举解这一类题是肯定不行的。

	要想有效的降低复杂度，解决办法就是用动态规划。So……How to use dynamic programming？
	让我们先来看另外的一个问题(最大子段和问题)：
 	给定一个长度为n的一维数组a，请找出此数组的一个子数组,使得此子数组的和sum＝a[i]+a[i+1]+……+a[j]最大，
	其中i>=0,i<n,j>=i,j<n，例如
  	 31 -41 59 26 -53  58 97 -93 -23 84
 	子矩阵59+26-53+58+97=187为所求的最大子数组。
	第一种方法－直接穷举法:
 maxsofar=0;
   for i = 0 to n
   {
       for  j = i to n 
       {
            sum=0;
            for k=i to j 
                sum+=a[k] 
            if (maxsofar>sum)
               maxsofar=sum;
       }
   }
	第二种方法－带记忆的递推法：
cumarr[0]=a[0]
   for i=1 to n      //首先生成一些部分和
   {
        cumarr[i]=cumarr[i-1]+a[i];       
   }

   maxsofar=0
   for i=0 to n
   {
       for  j=i to n     //下面通过已有的和递推
       {
           sum=cumarr[j]-cumarr[i-1]
           if(sum>maxsofar)
               maxsofar=sum
       }
   }

	显然第二种方法比第一种方法有所改进，时间复杂度为O(n*n)。
	下面我们来分析一下最大子段和的子结构，令b[j]表示从a[0]~a[j]的最大子段和，b[j]的当前值只有两种情况，(1) 最大子段一直连续到a[j]  (2) 以a[j]为起点的子段，不知有没有读者注意到还有一种情况，那就是最大字段没有包含a[j]，如果没有包含a[j]的话，那么在算b[j]之前的时候我们已经算出来了，注意我们只是算到位置为j的地方，所以最大子断在a[j]后面的情况我们可以暂时不考虑。
由此我们得出b[j]的状态转移方程为：b[j]=max{b[j-1]+a[j],a[j]},
所求的最大子断和为max{b[j],0<=j<n}。进一步我们可以将b[]数组用一个变量代替。
	得出的算法如下：
int maxSubArray(int n,int a[])
    {
        int b=0,sum=-10000000;
        for(int i=0;i<n;i++)
        {
             if(b>0) b+=a[i];
             else b=a[i];
             if(b>sum) sum=b;  
        }
        return sum;
    }

	这就是第三种方法－动态规划。
  现在回到我们的最初的最大子矩阵的问题,这个问题与上面所提到的最大子断有什么联系呢？
   假设最大子矩阵的结果为从第r行到k行、从第i列到j列的子矩阵，如下所示(ari表示a[r][i],假设数组下标从1开始)：
  | a11 …… a1i ……a1j ……a1n |
  | a21 …… a2i ……a2j ……a2n |
  |    .      .      .     .     .      .     .     |
  |    .      .      .     .     .      .     .     |
  | ar1 …… ari ……arj ……arn    |
  |    .      .      .     .     .      .     .     |
  |    .      .      .     .     .      .     .     |
  | ak1 …… aki ……akj ……akn  |
  |    .      .      .     .     .      .     .     |
  | an1 …… ani ……anj ……ann |
那么我们将从第r行到第k行的每一行中相同列的加起来，可以得到一个一维数组如下：
 (ar1+……+ak1, ar2+……+ak2, ……,arn+……+akn)
 由此我们可以看出最后所求的就是此一维数组的最大子断和问题，到此我们已经将问题转化为上面的已经解决了的问题了。 
最后，上代码！
#include <iostream>  
using namespace std;  
  
int ** a;  
int **sum;  
int max_array(int *a,int n)  
{  
        int *c = new int [n];  
        int i =0;  
        c[0] = a[0];  
        for(i=1;i<n;i++)  
        {  
                if(c[i-1]<0)  
                        c[i] = a[i];  
                else  
                        c[i] = c[i-1]+a[i];  
        }  
        int max_sum = -65536;  
        for(i=0;i<n;i++)  
                if(c[i]>max_sum)  
                        max_sum = c[i];  
        delete []c;  
        return max_sum;  
  
}  
int max_matrix(int n)  
{  
        int i =0;  
        int j = 0;  
        int max_sum = -65535;  
        int * b = new int [n];  
  
        for(i=0;i<n;i++)  
        {  
                for(j=0;j<n;j++)  
                        b[j]= 0;  
                for(j=i;j<n;j++)//把数组从第i行到第j行相加起来保存在b中，在加时，自底向上，首先计算行间隔(j-i)
					//等于1的情况，然后计算j-i等于2的情况，一次类推,在小间隔的基础上一次累加，避免重复计算  
                {  
                        for(int k =0;k<=n;k++)  
                                b[k] += a[j][k];  
                        int sum = max_array(b,n);  
                        if(sum > max_sum)  
                               max_sum = sum;  
                }  
        }  
        delete []b;  
        return max_sum;  
}  
int main()  
{  
        int n;  
        cin >> n;  
  
        a = new int *[n];  
        sum = new int *[n];  
        int i =0;  
        int j =0;  
        for(i=0;i<n;i++)  
        {  
                sum[i] = new int[n];  
                a[i] = new int[n];  
                for(j=0;j<n;j++)  
                {  
                        cin>>a[i][j];  
                        sum[i][j] =0 ;//sum[r][k]表示起始和结尾横坐标分别为r,k时的最大子矩阵  
                        //sum[r][k] = max{sum (a[i][j]):r<=i<=k}:0<=k<=n-1  
                }  
        }  
        /* 
        int b[10]={31,-41,59,26,-53,58,97,-93,-23,84}; 
        cout << max_array(b,10) << endl; 
        */  
        cout << max_matrix(n);  
} 
补充：另外一种算法，也可以A
#include<iostream>
#include<stdio.h>
#include<cstring>
using namespace std;
	int map[200][200];
	int f[200];
	int n,ans;
	int a[200];
void readdata()
{
	 memset(a,0,sizeof(f));
	 memset(a,0,sizeof(a));
	 n=ans=0;
     scanf("%d\n",&n);
     int i,j;
     for(i=1; i<=n; i++)
     for(j=1; j<=n; j++)
     scanf("%d",&map[i][j]);
}

void work()
{
     int i,j,q,tem,m,k;
     for(i=1; i<=n; i++)
     for(j=1; j<=n-i+1; j++)
     {
              for(q=1; q<=n; q++)
              {
                       tem=0;
                       for(k=i; k<=i+j-1; k++)
                       tem+=map[k][q];
                       a[q]=tem;
              }
              for(q=0; q<=n; q++)
              f[q]=0;
              f[1]=a[1];
              if(f[1]>ans) ans=f[1];
              for(m=2; m<=n; m++)
              {
                       f[m]=a[m]>f[m-1]+a[m] ? a[m]:f[m-1]+a[m];
                       if(f[m]>ans) ans=f[m];
              }
     }
}

void print()
{
     printf("%d\n",ans);
}

int main()
{
	int z;
	scanf("%d",&z);
	for(int i=1;i<=z;i++)
	{
    readdata();
    work();
    print();
	}
	return 0;
}