洛谷4147 玉蟾宫

题目背景

有一天，小猫rainbow和freda来到了湘西张家界的天门山玉蟾宫，玉蟾宫宫主蓝兔盛情地款待了它们，并赐予它们一片土地。

题目描述

这片土地被分成N*M个格子，每个格子里写着'R'或者'F'，R代表这块土地被赐予了rainbow，F代表这块土地被赐予了freda。

现在freda要在这里卖萌。。。它要找一块矩形土地，要求这片土地都标着'F'并且面积最大。

但是rainbow和freda的OI水平都弱爆了，找不出这块土地，而蓝兔也想看freda卖萌（她显然是不会编程的……），所以它们决定，如果你找到的土地面积为S，它们每人给你S两银子。

输入输出格式

输入格式：

第一行两个整数N,M，表示矩形土地有N行M列。

接下来N行，每行M个用空格隔开的字符'F'或'R'，描述了矩形土地。

输出格式：

输出一个整数，表示你能得到多少银子，即(3*最大'F'矩形土地面积)的值。

输入输出样例

输入样例#1：

5 6
R F F F F F
F F F F F F
R R R F F F
F F F F F F
F F F F F F

输出样例#1：

45

说明

对于50%的数据，1<=N,M<=200

对于100%的数据，1<=N,M<=1000

题解

超时n³算法

n^3算法很好想，首先要进行一个预处理，以样例为例:
首先,读入之后将字符'F'设为1，'R' 设为0，那么样例处理之后效果如下：

0 1 1 1 1 1
1 2 2 2 2 2
1 2 2 3 3 3
2 3 3 4 4 4
3 4 4 5 5 5

然后进行n^3模拟即可，在这里不多介绍。

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#include<bits/stdc++.h>

using namespace std;

int n,m;
int ans=-1;
int a[1050][1050];
 
void init() {
    char c;
    scanf("%d%d",&n,&m);
    for(int i=1; i<=n; i++)
        for(int j=1; j<=m; j++) {
            cin>>c;
            if(c=='F')a[i][j]=1;
        }
    for(int i=1; i<=n; i++)
        for(int j=1; j<=m; j++)
            a[i][j]+=a[i-1][j];
    return ;
}

void out() {
    for(int i=1; i<=n; i++) {
        for(int j=1; j<=m; j++)
            printf ("%d ",a[i][j]);
        cout<<endl;
    }
    return;
}

void work() {
    //out(); 
    for(int i=1; i<=n; ++i)
        for(int j=1; j<=i; j++) {
            int sum=0;
            for(int k=1; k<=m; ++k) {
                if(a[i][k]-a[j-1][k]==i-j+1)
                    sum+=a[i][k]-a[j-1][k],ans=max(ans,sum);
                else sum=0;
            }
        }
    cout<<ans*3<<endl;
    return;
}

int main() {
    init();
    work();
    return 0;
}

 代码中可以看到，我同时开了O1,O2,O3优化，但是仍然没有逃脱超时的命运。

满分算法

我们考虑使用单调栈。关于单调栈，我推荐一篇博客：

https://www.cnblogs.com/COLIN-LIGHTNING/p/8474668.html

这篇博客很良心，博主是我在博客园中唯一关注的。

那下面还是从头讲本题正解：

1.我们按行去划分，O(n)枚举行，对该行即以上的部分做最大矩阵处理；

2.那么我们用pos数组记录每行向上可延伸的最大距离，预处理的方式即为：

    (1)读到一个‘F’，该处a=上一行该列a的值+1；

    (2)读到一个‘R’，该处a=0（因为该处不可向上伸展）；

（以上都是n^3超时算法也要处理的）

3.那么对于每次枚举:对该行及以上的部分从左往右或从右往左进行一次单增栈，每次弹栈时更新最大面积;

    (1)首先，该栈是单调递增的

    (2)如果入栈元素小于栈顶元素，栈顶元素就要出栈

    (3)如果入栈元素不小于栈顶元素，那么先入栈，然后计算当前的最大面积，更新本组答案。

4.对每次枚举的最大面积取max即为最终答案；

#include <stack>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <bits/stdc++.h>
using namespace std;

const int N=1005;

int n,m,ans=0;
int a[N][N];
stack <int> s,L;

void init()
{
    int i,j;
    char ch[2];
    scanf("%d %d",&n,&m);
    for (i=1; i<=n; i++)
        for(j=1; j<=m; j++)
        {
            scanf("%s",ch);
            if (ch[0]=='F')
                a[i][j]=a[i-1][j]+1;//a[i][j]表示第j列从第i行往上'F'的个数(高度)
        }
}

void work(int h[])//处理到第i行
{
    int j,len;
    s.push(0);//栈内保存高度
    L.push(0);//栈内保存宽度
    for(j=1; j<=m; j++)
        if (h[j]>=s.top())
        {
            s.push(h[j]);
            L.push(1);
        }
        else
        {
            len=0;
            while(!s.empty() && s.top()>h[j])//高度栈保证单调递增
            {
                len+=L.top();
                ans=max(ans,len*s.top());
                s.pop();
                L.pop();
            }
            s.push(h[j]);
            L.push(len+1);
        }
    len=0;
    while(!s.empty())//最后计算答案
    {
        len+=L.top();
        ans=max(ans,len*s.top());
        s.pop();
        L.pop();
    }
}

int main()
{
    init();
    for(int i=1; i<=n; i++)
        work(a[i]);
    printf("%d
",3*ans);
    return 0;
}

出处：https://www.cnblogs.com/yujustin/

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

温馨提示：尽量使用版本较高的浏览器，并打开极速模式。