<单调栈/悬线法>codevs 2491 玉蟾宫 1159 最大全0子矩阵

玉蟾宫
最大全0子矩阵
曾经做过玉蟾宫，现在拿来再做，却早就忘了。。。
一直在思考这个东西为什么要用单调栈来做。
既然是从左到右扫描，如果上一个矩形的高度大于当前高度，那么上一个矩形的高度对后面的答案就没有贡献了。如果上一个矩形的高度等于当前高度，那我们直接累加得到的答案肯定更优。对于这两种情况的矩形，既然留之无用，那为什么不扔掉！当把所有高度大于等于当前矩形的矩形扔掉后，会发现剩下的就是一个高度单调递增的矩形集合了。又因为我们只需要从后面拿，从后面放，所以就可以维护一个单调栈了。
不过，对于需要pop的矩形，虽然多出来的那些高度对后面没有贡献了，但是我们可以保留它的宽度对答案的贡献。即我们一定可以找出一个矩形，它的宽是当前矩形的宽加比当前矩形高的上一个矩形的宽，它的高是当前矩形的高。所以在pop较高矩形的同时，把当前的矩形的宽不断加上较高矩形的宽度，来对后面的答案做出贡献。一直到栈顶矩形的高度小于当前矩形的高度，保存当前矩形的宽度为累计宽度，然后丢进栈中。
那么对于较高矩形与前面矩形所形成的答案呢？为了防止遗漏，我们在pop较高矩形的时候，顺便统计一下栈顶矩形与前面矩形形成的答案。在宽度逐渐累加的时候，每次pop，都计算一下累计宽度乘以栈顶矩形高度，更新答案。
最后剩下的栈中的单调递增的矩形，还是按照宽度累加的方法，一直pop，更新答案，直到栈空。
之前对单调栈/单调队列一直很迷，其实仔细想想豁然开朗
PS：我是看的伟大的DQS学长的博客学的

要是不明白，就手动模拟！！

---

玉蟾宫：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<stack>
using namespace std;

const int maxn=1000+10;
int ans=0,n,m;
int wire[maxn][maxn],wide[maxn];
char ditu[maxn][maxn];
struct lxt
{
    int x,y;
};
stack<lxt>s;

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;++i)
      for(int j=1;j<=m;++j)
        cin>>ditu[i][j];
    for(int i=1;i<=n;++i)
      for(int j=1;j<=m;++j)
        if(ditu[i][j]=='F')
          wire[i][j]=wire[i-1][j]+1;
    for(int i=1;i<=n;++i)
    {
        memset(wide,0,sizeof(wide));
        for(int j=1;j<=m;++j)
        {
            lxt f;
            int d=0;
            while(!s.empty()&&wire[s.top().x][s.top().y]>=wire[i][j]) 
            {
                d+=wide[s.top().y];
                ans=max(ans,d*wire[s.top().x][s.top().y]);
                s.pop();
            }
            f.x=i;
            f.y=j;
            s.push(f);
            wide[j]=d+1;
        }
        int d=0;
        while(!s.empty())
        {
            d+=wide[s.top().y];
            ans=max(ans,d*wire[s.top().x][s.top().y]);
            s.pop();
        }
    }
    ans*=3;
    printf("%d",ans);
    return 0;
}

最大全0子矩阵：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stack>
using namespace std;

const int maxn=2000+10;
int n,ans;
int h[maxn][maxn],wide[maxn];
struct lxt
{
    int x,y;
};
stack<lxt>s;

int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;++i)
      for(int j=1;j<=n;++j)
      {
        int x;
        scanf("%d",&x);
        if(!x) h[i][j]=h[i-1][j]+1;
      }
    for(int i=1;i<=n;++i)
    {
        memset(wide,0,sizeof(wide));
        for(int j=1;j<=n;++j)
        {
            int d=0;
            while(!s.empty()&&h[s.top().x][s.top().y]>=h[i][j])
            {
                d+=wide[s.top().y];
                ans=max(ans,d*h[s.top().x][s.top().y]);
                s.pop();
            }
            s.push((lxt){i,j});
            wide[j]=++d;
        }
        int d=0;
        while(!s.empty())
        {
            d+=wide[s.top().y];
            ans=max(ans,d*h[s.top().x][s.top().y]);
            s.pop();
        }
    }
    printf("%d",ans);
    return 0;
}