POJ1964-City Game

给你N×M大的矩阵，里面分别有字符‘F'和’R'，要找到一个最大的只有‘F'的矩阵，不能包含有’R‘。N，M<=1000。

一开始的思路是单调栈来求最大矩形面积，因为没看清题目不能包含’R'字符，所以算出每行的‘F'字符个数然后单调栈就WA了。。

然后想到要从左边开始，算出连续的‘F'字符个数，然后又WA了。

因为还有右边，所以右边开始的’F'字符也处理一下，也是WA。

接着想到这种情形：

R F F F R

R F F F R

这枚举F的开始结束的话都是不行的，那么因为就两种字符。然后我又上一步一样只是求出R连续的大小，然后统计

lf左边开始‘F'的连续个数然后单调栈

rf右边开始’F'的连续个数然后单调栈

lr左边开始‘R'的连续个数然后单调栈

rr右边开始’R'的连续个数然后单调栈。

那么答案我就觉得是max(lf,rf,n*m-max(lr,rr))

然后也WA，因为我想到一个反例：

R R R R R

R F  F F R

R F  F F R

R F  F F R

R R R R R

仔细观察这个样例，发现其实之前的做法很麻烦，我们最后得出的矩形一定是有左边的（废话），但是这个左边不确定，只要确定了直接用单调栈就出来了。

所以想到可以枚举K列，每次从第K列开始算。代码如下：

#include <iostream>
#include <fstream>
#include <stdio.h>
#include <string>
#include <string.h>
#include <algorithm>
using namespace std;

int n,m,arr[],stk[],w[];
char ma[][],ss[];
long long ans;
int main() {
    int k;
    scanf("%d",&k);
    while(k--) {
        long long lr,rr,lf,rf;
        lr=rr=lf=rf=;
        memset(stk,,sizeof stk);
        ans=;
        memset(w,,sizeof w);
        scanf("%d%d",&n,&m);
        for(int i=; i<=n; ++i) {
            for(int j=; j<=m; ++j)
                scanf("%s",ss),ma[i][j]=ss[];

        }
        for(int k=; k<=m; ++k) {
            for(int i=; i<=n; ++i) {
                int tmp=;
                int j=k;
                while(j<=m&&ma[i][j++]!='R')
                    ++tmp;
                /*
                for(int j=1;j<=m;++j)
                    if(ma[i][j]=='F')
                        ++tmp;
                */
                arr[i]=tmp;
            }
            memset(stk,,sizeof stk);
            memset(w,,sizeof w);
            lf=;
            arr[n+]=;
            int p=;
            for(int i=; i<=n+; ++i) {
                if(arr[i]>stk[p])
                    stk[++p]=arr[i],w[p]=;
                else {
                    int wid=;
                    while(stk[p]>arr[i]) {
                        wid+=w[p];
                        lf=max(lf,(long long)wid*stk[p]);
                        --p;
                    }
                    stk[++p]=arr[i];
                    w[p]=wid+;
                }
            }
            ans=max(ans,lf);
        }
        printf("%lld\n",ans*);
    }
    return ;
}