某次模拟赛 请客

题目描述 Description

在 hzwer 的帮助下高老师终于搞定（搬运完）了这套题，所以高老师打算请 hzwer 吃饭，高老师家可以看成是一个 n*m 的矩阵，每块区域都有独一无二的海拔高度 h（h>0）！其最大值为 n*m。现在他要选择一个子矩阵摆放一张桌子，在他眼里，这样摆放桌子的美观度为这个子矩阵的最小值，他想知道，如果他要求摆放桌子的美观度为 i，那么可以选择多少种子矩阵呢？对于所有可能的 i 值（1<=i<=n*m），你都应该得出其方案数，这样你也有机会被请去吃饭啦！

输入描述 Input Description

第一行两个整数 n，m
接下来有 n 行 m 列描述对应的矩阵

输出描述 Output Description

n*m 行，每行一个整数，第 i 行的整数表示美观度为 i 时的方案数

样例输入 Sample Input

2 3
2 5 1
6 3 4

样例输出 Sample Output

6
4
5
1
1
1

数据范围及提示 Data Size & Hint

30%的数据 1<=n,m<=50
100%的数据 1<=n,m<=300

之前的一些废话：边看论语边画画，太爽了！

题解：首先枚举左右边界[L,R]来确定矩阵的宽,顺便维护了每一行中[L,R]的最小值，（一个矩形能不能扩张决定于该矩阵的最小值）。然后我们对于每一行需要计算出它能扩展的最大范围（即在它上下两端找到离它最近并且比他还小的），这个可以通过O（n^2）来进行计算，但再加上枚举左右边界就变成O(n^4)了，不行，所以我们需要在计算出它能扩展的最大范围的过程中进行优化。

维护一个单调栈（单调递增），若中途元素i比栈顶小，那我就发现了栈顶元素的下端离它最近并且比他还小的，而栈顶元素上端离它最近并且比它小的一定是单调栈中的栈顶之前的那个元素。这样，我们就把栈顶的信息更新完了。更新之后，往下弹栈，直至栈顶元素比i小，并将i压入栈，这样的操作做完之后我们得到一个严格单调的栈。栈中元素的上端比它小的很显然是离它最近的，下端没有比它小的了所以只能是n了。综上所述，我们巧妙的运用了单调栈优化掉了一个n，最后复杂度是O（n^3）

代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<cmath>
#include<cstring>
using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
#define mem(a,b) memset(a,b,sizeof(a))
inline int read()
{
    int x=0,f=1;char c=getchar();
    while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}
    while(isdigit(c)){x=x*10+c-'0';c=getchar();}
    return x*f;
}
const int maxn=310,oo=2147483647;
int n,m,mat[maxn][maxn],minn[maxn],sta[maxn],top,len[maxn];
LL ans[maxn*maxn];
int front(){return sta[top];}
void pop(){top--;}
void push(int a){sta[++top]=a;}
bool size(){return top>0;}
int main()
{
    n=read();m=read();
    for(int i=1;i<=n;i++)for(int j=1;j<=m;j++)mat[i][j]=read();
    for(int i=1;i<=m;i++)
    {
        for(int j=1;j<=n;j++)minn[j]=mat[j][i];
        for(int j=i;j<=m;j++)
        {
            for(int k=1;k<=n;k++)minn[k]=min(minn[k],mat[k][j]);
            while(size())pop();
            for(int k=1;k<=n;k++)
            {
                len[k]=1;
                while(size() && minn[front()]>minn[k])
                {
                    int now=front();
                    len[k]+=len[now];
                    ans[minn[now]]+=len[now]*(k-now);
                    pop();
                }
                push(k);
            }
            while(size())
            {
                int now=front();pop();
                ans[minn[now]]+=len[now]*(n+1-now);
            }
        }
    }
    for(int i=1;i<=n*m;i++)printf("%lld
",ans[i]);
    return 0;
}

总结：发现一个惊人的套路：这种矩阵的题基本都是把二维问题转化为一维问题！还有一道类似的题是给一个01矩阵，问全0子矩阵个数，那道题也是先通过枚举左右边界确定矩阵的一个维度，剩下的那个维度就拿滑动窗口来搞。这肯定是一个套路。