双重有序，单调栈（贩卖土地，uva 12265）

最新推荐文章于 2021-02-10 15:49:33 发布

原创最新推荐文章于 2021-02-10 15:49:33 发布 · 743 阅读

1 ·

CC 4.0 BY-SA版权

紫书-第8章-高效算法设计同时被 3 个专栏收录

19 篇文章

订阅专栏

双重有序

2 篇文章

订阅专栏

单调栈

1 篇文章

订阅专栏

本文介绍了一种使用单调栈进行优化的算法实现方案，通过特殊的方法处理矩形的高度，确保栈顶始终保存当前最优解，实现了O(1)的时间复杂度查询。

这个单调栈的维护方法有些不一样。

若存在矩形比他高，那么就把所有比他高的矩形截到和他一样高，然后按照h-c维护单调栈（事实上也就是把除了第一个被截的矩形全部删掉，然后再考虑是否删掉第一个），新元素不用插入，因为就算插入了也会被删掉。

否则直接维护单调栈，事实上也就是考虑下要不要插入。

可以一直保证栈顶是最优解，O（1）查询。

因为发现最优解只和h-c有关，所以按h-c维护单调栈。

因为可能存在截短删除最优解的情况，所以不能只保留最优解。

截短是为了删除一些不可能的解。

截完后还要维护单调栈。

#include<bits/stdc++.h>
#define maxn 1010
using namespace std;
typedef pair<int,int> pii;

int n,m;
char MAP[maxn][maxn];
int MAX[maxn][maxn];
map<int,int>ans;
vector<pii>s;
void cl()
{
    s.clear();
}

void ps(pii x)
{
    if(s.size())
    {
        pii temp=s.back();
        if(temp.second<x.second)
        {
            if(temp.second-temp.first<x.second-x.first) s.push_back(x);
        }
        else
        {
            int i=s.size()-1;
            while(i-1>=0&&s[i-1].second>=x.second) i--;
            s.resize(i+1);
            s[i].second=x.second;
            if(i-1>=0&&s[i-1].second-s[i-1].first>=s[i].second-s[i].first) s.pop_back();
        }
    }
    else s.push_back(x);
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        ans.clear();
        cl();
        scanf("%d %d",&n,&m);
        for(int i=1;i<=n;i++)
            scanf("%s",MAP[i]+1);
        for(int i=1;i<=m;i++)
        {
            int u=1,d=1;
            while(u<=n)
            {
                while(u<=n&&MAP[u][i]=='#') u++;
                d=u;
                while(d<=n&&MAP[d][i]=='.')
                {
                    MAX[d][i]=u;
                    d++;
                }
                u=d;
            }
        }
        for(int i=1;i<=n;i++)
        {
            cl();
            for(int j=1;j<=m;j++)
            {
                if(MAP[i][j]=='#')
                {
                    cl();
                    continue;
                }
                ps(make_pair(j,i-MAX[i][j]+1));
                pii ANS=s.back();
                ans[2*(ANS.second+j-ANS.first+1)]++;
            }
        }
        for(map<int,int>::iterator it=ans.begin();it!=ans.end();++it)
            printf("%d x %d\n",it->second,it->first);
    }
    return 0;
}