最大子段和||最大子矩阵和||最大全1子矩阵||最大全1子正方形||

最大子段和
给定n个整数组成的序列A[0,1,…,n-1]，求该序列子段的最大和。

算法一

枚举所有可能的左右边界l,r，计算sum[l,...r]，算法复杂度为O(n^3)

算法二

sum[l,...r]的值可以由sum[0,...r]-sum[0,...l]得到。在O(n)内我们可以得到sum[0,..,n]，这样只有r,l可以变化，算法复杂度为O(n^2)，这是典型的空间换时间。

算法三（DP）

我们定义一个最大值dp[i]表示以i结尾的最大子段和，那么初始dp[0]=A[0].关键是求解dp[i]与dp[i-1]的关系
dp[i]=max(dp[i-1]+A[i],A[i])

即A[i]<0时dp[i] = dp[i-1];否则dp[i]=dp[i-1]+A[i]

最大子矩阵和

假设A[M，N]有M行，N列。
我们可以只移动行或只移动列，这里以行为例
行范围的全部遍历是O(n^2)的，i从0~M-1，j从i~N-1。这样行范围就被全部遍历了，A[i,….j;0,….N-1]。对于每一列k(0…N-1)我们相当于将i~j范围的子矩阵压扁，将同一列的元素驾到b[k]中去，在数组b中求最大子段和，这个字段和就是A[i,….j;0,….N-1]这个横条状的数组的最大子矩阵和，当j每移动一次时就更新下MaxSum

int maxSubArray(int a[],int n)  
{  
     int b=0,sum=a[0];  
     for(int i=0;i<n;i++)  
     {  
       if(b>0)   
          b+=a[i];  
       else   
          b=a[i];  
       if(b>sum)  
          sum=b;  
     }  
    return sum;    
}  
int maxSubMatrix(int array[][],int M,int N)  
{  
            int i,j,k,max=0,sum=-100000000;  
            int b[N];  
            for(i=0;i<M;i++)  
            {  
                  for(k=0;k<N;k++)//初始化b[]  
                  {  
                        b[k]=0;  
                  }  
                  for(j=i;j<M;j++)//把第i行到第j行相加,对每一次相加求出最大值  
                  {  
                        for(k=0;k<N;k++)  
                        {  
                              b[k]+=array[j][k];  
                        }  
                        max=maxSubArray(b,k); //此时K即为N-1   
                        if(max>sum)  
                        {  
                                sum=max;  
                        }  
                  }  
            }  
            return sum;  
} 

这里的算法复杂度为O(N^3)

最大全1子矩阵

这里与最大子矩阵和的区别是子矩阵内的元素全是1.
输入：
4 4
0 0 0 0
0 1 1 0
0 1 1 0
0 0 0 0
输出：
4

这里假设输入矩阵A为M行，N列，则

1、先将0、1矩阵读入A，对于每一个非零元素A[i][j],将其更新为：在本行，它前面的连续1的个数加一（+1表示算入自身）

for(i = 0; i<M; i++)
    for(j = 0; j <N; j++)
        A[i][j]=(A[i][j]==0?0:(j==0?0:A[i][j-1]+1));

2、对于每一个非零元素A[i][j]，从第j列向上（j-1到0)和向下（j+1到N-1)扫描，直到遇到比A[i][j]小的元素，扫描了y行，则得到一个大小为（y+1)*A[i][j]的全1子矩阵（+1表示自身）

for(up = i;up>=0&&A[i][up]>=A[i][j]; up--);
for(down = i;down<N&&A[i][down]>=A[i][j];down++);
area = (down-up+1)*A[i][j];
Max_area=(Max_area>area)?Max_area:area;

3、i,j遍历0~N-1，从中挑一个最大值。

思想大概如下图所示（空白处的0没有标出）

对照步骤2中给出的例子，蓝色的箭头表示向上向下扫描，黑色的框表示最终得到的全1子矩阵

这样做为什么是对的？

想一想，对那个最大的全1子矩阵，用这种方法能不能找到它呢？——肯定可以。

一个最大全1子矩阵，肯定是四个边界中的每一个都不能再扩展了，如下图

int maximalRectangle(vector<vector<char>>& matrix) {
        int H = matrix.size(); if(H <= 0) return 0;
        int W = matrix[0].size(); if(W <= 0) return 0;
        int left[H][W]; int i, j, k, MaxArea = 0, area = 0;
        for(i = 0; i < H; ++i)
            for(j = 0; j < W; ++j)
                left[i][j] = (matrix[i][j] == '0' ? 0 : (j == 0 ? 0 : left[i][j-1]) + 1);
        for(i = 0; i < H; ++i){
            for(j = 0; j < W; ++j){
                if(left[i][j] == 0) continue;
                for(k = i-1, area = left[i][j]; k >= 0 && left[k][j] >= left[i][j]; --k, area += left[i][j]);
                for(k = i+1; k < H && left[k][j] >= left[i][j]; ++k, area += left[i][j]);
                MaxArea = max(MaxArea, area);
            }
        }
        return MaxArea;
    }

最大全1子正方形

DP的思路，我们假设f(i,j)表示的是以i,j为右下角顶点的最大子正方形的边长。
这样初始条件f(0,j) f(i,0)即第一行和第一列分别都是自己的值

递推关系如果f(i,j)本身为0，则不用更新（说明以ij为右下角顶点的最大子正方形的边长为0），如果f(i,j)==1,则f(i,j)更新为min(f(i-1,j),f(i,j-1),f(i-1,j-1))+1

for(int i=1; i<n; i++) {  
            for(int j=1; j<m; j++) {  
                if(matrix[i][j]=='0') d[i][j]=0;  
                else {  
                    d[i][j] = Math.min( Math.min( d[i-1][j], d[i][j-1]), d[i-1][j-1] ) + 1;  
                    max = Math.max(max, d[i][j]);  
                }  
            }  
        }  
        return max*max;