全是1的最大子矩阵问题

　　前一次寒假排位赛中遇到了这个问题，后来思考了一下。写个类似问题的总结。

　　这题的模型可以在51nod中找到：http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1158。但是其问题规模比较小，n^3暴力似乎都可以。

　　正解应当是单调栈，我记得上次在《挑战程序设计2》里面看到过这题，可以用单调栈在O(n*m)的复杂度下求解。虽然思路比较简单，但是我自己写起来还是花了比较久的时间= =。代码能力真的弱。。想说下的是，这题下如果规模是5000*5000，那么a数组和h数组应当只使用一个即可，或者a数组变成char或bool数组，否则是会超内存的。int一个5000*5000的就需要100M了。单调栈的代码如下：

#include <stdio.h>
#include <algorithm>
#include <string.h>
#include <stack>
using namespace std;
const int N = 500 + 5;

int n,m;
int a[N][N];
int h[N][N];
int left[N];

int main()
{
    while(scanf("%d%d",&n,&m) == 2)
    {
        memset(h,0,sizeof h);
        for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) scanf("%d",&a[i][j]);
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                if(a[i][j] == 1) h[i][j] = h[i-1][j] + 1;
                else h[i][j] = 0;
            }
        }
        int ans = 0;
        for(int i=1;i<=n;i++)
        {
            int pos = 0;
            stack<int> S;
            h[i][m+1] = 0;
            //memset(left,0,sizeof left);
            for(int j=1;j<=m+1;j++)
            {
                int now = h[i][j];
                if(S.empty() || h[i][S.top()] < now)
                {
                    if(now == 0) pos = j;
                    else
                    {
                        S.push(j);
                        left[j] = j;
                    }
                }
                else if(h[i][S.top()] == now)
                {
                    left[j] = left[S.top()];
                    S.push(j);
                }
                else
                {
                    while(!S.empty() && h[i][S.top()] > now)
                    {
                        int x = S.top(); S.pop();
                        ans = max(ans, (j-left[x])*h[i][x]);
                    }
                    if(now == 0) pos = j;
                    else if(S.empty()) left[j] = pos + 1;
                    else left[j] = S.top() + 1;
                    if(now) S.push(j);
                }
            }
        }
        printf("%d
",ans);
    }
    return 0;
}

　　值得一提的是这里还有一种简单的方法，直接用两个数组记录，到左边的第一个比当前h小的位置，右边同样也记录一下，然后一行内枚举位置，再依次更新答案（即h[i][j]*(right[j]-left[j]-1)）即可。两个数组的记录是可以在每一行先做预处理的，复杂度为线性。那么总的时间复杂度和上面单调栈是一样的。但是这个方法更容易理解，并且好写。代码如下：

#include <stdio.h>
#include <algorithm>
#include <string.h>
#include <stack>
using namespace std;
const int N = 500 + 5;

int n,m;
int a[N][N];
int h[N][N];
int left[N],right[N];

int main()
{
    while(scanf("%d%d",&n,&m) == 2)
    {
        memset(h,0,sizeof h);
        for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) scanf("%d",&a[i][j]);
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                if(a[i][j] == 1) h[i][j] = h[i-1][j] + 1;
                else h[i][j] = 0;
            }
        }
        int ans = 0;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                int now = j - 1;
                for(;now && h[i][j] <= h[i][now];now=left[now]);
                left[j] = now;
            }
            for(int j=m;j>=1;j--)
            {
                int now = j + 1;
                for(;now != m+1 && h[i][j] <= h[i][now];now=right[now]);
                right[j] = now;
            }
            for(int j=1;j<=m;j++) ans = max(ans, (right[j]-left[j]-1)*h[i][j]);
        }
        printf("%d
",ans);
    }
    return 0;
}

　　再提供一个类似的题目：SPOJ-MINSUB。题意是求一个面积大于等于k的子矩阵，这个矩阵内的最小的元素最大。做法是二分答案，然后原矩阵内值小于这个答案的置0，否则置1。再用同样的方法DP即可。代码如下：

#include <stdio.h>
#include <algorithm>
#include <string.h>
#include <stack>
using namespace std;
const int N = 1000 + 5;

int n,m;
int a[N][N];
int h[N][N];
int left[N];
int area,k;
bool solve(int mid)
{
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(a[i][j] >= mid) h[i][j] = h[i-1][j] + 1;
            else h[i][j] = 0;
        }
    }
    int ans = 0;
    for(int i=1;i<=n;i++)
    {
        int pos = 0;
        stack<int> S;
        h[i][m+1] = 0;
        for(int j=1;j<=m+1;j++)
        {
            int now = h[i][j];
            if(S.empty() || h[i][S.top()] < now)
            {
                if(now == 0) pos = j;
                else
                {
                    S.push(j);
                    left[j] = j;
                }
            }
            else if(h[i][S.top()] == now)
            {
                left[j] = left[S.top()];
                S.push(j);
            }
            else
            {
                while(!S.empty() && h[i][S.top()] > now)
                {
                    int x = S.top(); S.pop();
                    ans = max(ans, (j-left[x])*h[i][x]);
                }
                if(now == 0) pos = j;
                else if(S.empty()) left[j] = pos + 1;
                else left[j] = S.top() + 1;
                if(now) S.push(j);
            }
        }
    }
    return (area = ans) >= k;
}

int main()
{
    int T; scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d",&n,&m,&k);
        int L = 1, R = 0;
        for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) {scanf("%d",&a[i][j]); R = max(R, a[i][j]);}
        int ans = -1;
        area = 0;
        while(L <= R)
        {
            int mid = L + R >> 1;
            if(solve(mid))
            {
                ans = mid;
                L = mid + 1;
            }
            else R = mid - 1;
        }
        solve(ans);
        printf("%d %d
",ans,area);
    }
    return 0;
}