求一个矩阵中最大的二维子矩阵(元素和最大)

转载：http://blog.csdn.net/zhanxinhang/article/details/6731134

题：求一个矩阵中最大的n==2的二维子矩阵(元素和最大).如:
          1 2 0 3 4
          2 3 4 5 1
          1 1 5 3 0
          中最大的是:  
          4 5
          5 3
          要求:(1)写出算法;(2)分析时间复杂度;(3)用C写出关键代码

分析：方法一、这是最容易想到也是最容易实现的方法。遍历矩阵(行迭代器为i,列迭代器为j)，以当前遍历到的元素为首a[i,j]，计算二维子矩阵的和(sum=a[i,j]+a[i+1,j]+a[i,j+1]+a[i+1,j+1])，并找出和最大的二维矩阵，注意矩阵的最后一行和最后一列不用遍历。时间复杂度为O(i*j)。

实现代码：

[cpp]  view plain copy

1. /** 
2. Author:花心龟 
3. Blog：http://blog.csdn.net/zhanxinhang 
4. **/  
5. void get_max_22Matrix(int *a,int row,int col,int *result)  
6. //a为原矩阵，row，col指a矩阵的行和列，result存储最终得到的子二维矩阵  
7. {  
8.   int maxsum=0,result_i,result_j,sum;  
9.     
10. #define a(i,j) *(a+(i)*col+(j))  //用二维的形式表示一维数组，访问需要一定的代价  
11. #define result(i,j) *(result+(i)*2+(j))  
12.     
13.   for(int i=0; i<row-1; i++)  
14.     for(int j=0; j<col-1; j++)  
15.       {  
16.         sum = a(i,j)+a(i+1,j)+a(i,j+1)+a(i+1,j+1); //访问四个元素并相加得到当前的和  
17.         if(maxsum<sum) //更新最大子二维矩阵数据  
18.           {  
19.             maxsum = sum;  
20.             result_i = i;  
21.             result_j = j;  
22.           }  
23.       }  
24.    
25.    /* 将结果存储到result二维数组中*/  
26.    result(0,0)=a(result_i,result_j);  
27.    result(1,0)=a(result_i+1,result_j);  
28.    result(0,1)=a(result_i,result_j+1);  
29.    result(1,1)=a(result_i+1,result_j+1);  
30. #undef a  
31. #undef result  
32. }  

方法二、这是对方法一的改进。分析方法一可知，方法一在每次遍历中，必须同时访问四个元素(a[i,j],a[i+1,j],a[i,j+1],a[i+1,j+1])，方法一的遍历效果如图所示（用方框框住的表示当前访问到或已访问的元素，元素被框住的次数就越多，表示被访问的次数也就越多，被染的颜色也就越深）。

可从图中看出，方法一中多个元素被重复访问多次，要知道访问一次元素的代价是不容小视的。实际上我们是可以对其进行改进，使每个元素的访问次数尽可能的降低的。改进方法如下：

一、增加一个变量，last_vsum（叫做“最新纵向和”，v是vertical） 且初始化为last_vsum = a[0,0]+a[1,0]，其作用将在下面说明。

二、改变遍历方式，原先每次访问四个元素，现在变为每次访问纵向的两个元素（a[i,j],a[i+1,j]），横向遍历，遍历的起始点改为第二个元素，终点到最后一个元素。

三、改变求和方式，求和方法是：首先将上一次保存的和last_vsum加进sum中，再将last_vsum更新为当前纵向的两个元素a[i,j],a[i+1,j]之和，然后再将last_vsum加入sum中，这样就得到本次二维矩阵的和可与maxsum进行比较。如此每次求和只需访问两个元素a[i,j],a[i+1,j]。

方法二执行步骤与效果图：

实现代码：

[cpp]  view plain copy

1. /** 
2. Author:花心龟 
3. Blog：http://blog.csdn.net/zhanxinhang 
4. **/  
5. void get_max_22Matrix(int *a,int row,int col,int *result)  
6. {  
7.   int maxsum=0,result_i,result_j,sum,last_vsum=0;  
8.     
9. #define a(i,j) *(a+(i)*col+(j))    
10. #define result(i,j) *(result+(i)*2+(j))  
11.     
12.   last_vsum = a(0,0)+a(1,0);  //初始last_vsum  
13.   for(int i=0; i<row-1; i++)  
14.     {  
15.      for(int j=1; j<col; j++)  
16.       {  
17.         sum = last_vsum ;  //将last_vsum加入sum  
18.         last_vsum = a(i,j)+a(i+1,j);//更新last_vsum  
19.         sum += last_vsum;//将更新后的last_vsum再与sum累加，得到当前子二维矩阵的和  
20.         if(maxsum<sum)  
21.           {  
22.             maxsum = sum;  
23.             result_i = i;  
24.             result_j = j-1;  
25.           }  
26.       }  
27.     }  
28.    
29.    /* 将结果存储到result二维数组中*/  
30.    result(0,0)=a(result_i,result_j);  
31.    result(1,0)=a(result_i+1,result_j);  
32.    result(0,1)=a(result_i,result_j+1);  
33.    result(1,1)=a(result_i+1,result_j+1);  
34. #undef a  
35. #undef result  
36. }  

方法二与方法一效果对照图：

其中，方法二有中间行需要被访问两次，总共访问次数为5+5+2*5=20次。

而方法一3,4,5元素被访问了4次，总共访问次数为4+2*8+3*4=32次。

方法二与方法一的时间复杂度相同，但是效率要高于方法一，尤其是在大矩阵情况下效果尤为明显

方法三、这可作为对方法二的补充。以上方法二中给的示例矩阵是3*5的矩阵，也就是列大于行的矩阵，但如果是行大于列依然用方法2去执行效果如何呢？效果如下图所示：

5*3矩阵，访问次数为6+2*9=24

可见当行大于列时，利用方法2效果已经下降，如果是大矩阵的话可不只只有4的相差啊。

针对这种情况，只需对方法二稍作改正，没错，就是原先方法二是横向遍历，现在改为纵向遍历，效果如下图所示：

同样是5*3矩阵，访问次数为5+5+2*5=20

又回到了方法2的访问次数。

这样如果是列大于行的矩阵使用方法二，也就是横向遍历

如果是行大于列的矩阵使用方法三，也就纵向遍历

实现代码略。

…………………………………………

赠一测试代码：

[cpp]  view plain copy

1. int main()  
2. {  
3.   int a[3*5]={1,2,0,3,4,  
4.           2,3,4,5,1,  
5.           1,1,5,3,0};  
6.   int result[2*2]={0};  
7.   
8.   get_max_22Matrix(a,3,5,result);  
9.   
10.  #define result(i,j) *(result+(i)*2+(j))  
11.    for(int i =0; i<2; i++)  
12.      {  
13.        for(int j=0; j<2; j++)  
14.      printf("%d ",result(i,j));  
15.        printf("\n");  
16.      }  
17.   return 0;  
18. }