2019牛客暑期多校训练营（第三场）F

题目描述

来源

    这个学期终于结束了，暑假就要来了。然而，作为大学毕业要求的一部分，你必须在假期期间参加一些社会服务。最后，你决定加入一个志愿者团体，在山上植树。
    为了简化这个问题，让我们用一个n乘以N $\times$N网格。让我们给行编号1到N从上到下，给列编号1到N从左到右。用a${}_{ij}$表示第i行第j列的格子的高度。
    你的领导决定在山中的长方形区域种植树木，并且该矩形中的任意两个单元格之间的最大高度差不应超过M
    请帮助你的领导计算尽可能多的细胞在这样一个矩形，以便他知道将种植多少棵树。

输入描述

输入包含多个案例。输入的第一行包含单个整数T(1≤T≤1000)，即情况数。对于每一种情况，输入的第一行包含两个整数N(1≤N≤500)和M(0≤M≤10⁵)。以下N行包含N个整数a${}_{ij}$​(1≤ i，j​≤10 5)。保证所有情况下N³之和不超过25$\cdot$ 10⁷。

输出描述

对于每种情况，都要打印一个整数，即有效矩形中单元格的最大数量。

输入样例

2
2 0
1 2
2 1
3 1
1 3 2
2 3 1
3 2 1

输出样例

1
4

解题思路

参考自官方题解

• 枚举子矩形的上下边界O(n^2)，同时维护当前上下边界范围内的每列最大最小值。
• 确定了上下边界后，枚举矩形的右边界，如何知道可行的最小左边界?可以使用数据结构或二分求，则复杂度为O(N³ log N),可能会超时
• 更快的做法:枚举右边界同时维护两个单调队列，分别维护最大值和最小值
  • 最小值的单调队列应为下标递增、大小递增
  • 最大值为下标递增、大小递减
  • 以最小值为例，每次入队时弹出队尾大于等于当前入队元素的元素，此外，当l值变动时，同时更新队列首部，如果不在 当前左右区间[l,r] 内，则弹出队首元素。这样单调队列的队首始终是当前区间内的最小值。
  • 显然随着右边界右移，每个元素都只入队出队一次, 时间复杂度: O(N³)

AC代码

来源

#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 505;
int m, n, t, a[maxn][maxn], i, j, w, k, ans;
int mn[maxn], mx[maxn];//第i到j列 最小 最大 的元素
int q1[maxn], q2[maxn], l1, r1, l2, r2; //最小 最大单调栈
int main(){
    cin >> t;
    while (t--) {
        ans = 0;
        scanf("%d%d", &n, &m);
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= n; j++) {
                scanf("%d", &a[i][j]);
            }
        }
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= n; j++) { //mn和mx数组初始化
                mn[j] = a[i][j];
                mx[j] = a[i][j];
            }
  
            for (j = i; j <= n; j++) { //求第i行到第j行，每列的最大和最小值
                for (k = 1; k <= n; k++) {
                    mn[k] = min(mn[k], a[j][k]);
                    mx[k] = max(mx[k], a[j][k]);
                }
  
                if ((j - i + 1)*n < ans) continue;
                l1 = l2 = 1, r1 = r2 = 0;
                for (k = w = 1; k <= n; k++) { //左边w列 右边k列
                    while (l1 <= r1&&mn[q1[r1]] >= mn[k]) r1--; //最小值单调栈
                    q1[++r1] = k;
                    while (l2 <= r2&&mx[q2[r2]] <= mx[k]) r2--; //最大值单调栈
                    q2[++r2] = k;
  
                    while (w <= k && mx[q2[l2]] - mn[q1[l1]]>m) { //w到k列不满足条件，w+1，如果单调栈最低端序号<w，序号加上去
                        w++;
                        while (l1 <= r1&&q1[l1] < w) l1++;
                        while (l2 <= r2&&q2[l2] < w) l2++;
                    }
                    if ((j - i + 1)*(n - w + 1)<ans) break;
                    if (w <= k) ans = max(ans, (j - i + 1)*(k - w + 1));
                }
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}

用list模拟单调队列

逻辑结构一样，但是会超时，目前还没有找到原因

#include<iostream>
#include<list>
using namespace std;
const int N = (int) (5e2+5);
//const int INF = 0x3f3f3f;
int t,n,m;
int a[N][N];
int amin[N];//amin[k]表示当前上下界内第k列的最小值
int amax[N];
int ans;
list<int> hmin,hmax;//最小值、最大值栈 
void solve(){
    ans = 0;
    for(int i=0;i<n;i++){//矩形上边界
        /*fill(amin,amin+n,INF);
        fill(amax,amax+n,0);*/ 
		for(int k=0;k<n;k++){
			amin[k]=a[i][k];
			amax[k]=a[i][k];
		}       
        for(int j=i;j<n;j++){//矩形下边界
            for(int k=0;k<n;k++){//初始化每列最值
                amin[k] = min(amin[k],a[j][k]);
                amax[k] = max(amax[k],a[j][k]);
            }
            //该情况最大都比已得结果小，不用往下计算了
            if((j - i + 1) * n < ans) continue;//这行和上面一个for交换会出错，想象为什么 
            int l=0,r=0;//矩形左右边界
            hmin.clear();
            hmax.clear();
            for(r=0;r<n;r++){//每个元素只入栈出栈一次，时间O(n)
                while(!hmin.empty()&&amin[r]<=amin[hmin.back()]){
                    hmin.pop_back();
                }//保证新加入的元素比栈顶元素大
                hmin.push_back(r);
                while(!hmax.empty()&&amax[r]>=amax[hmax.back()]){
                    hmax.pop_back();
                }//保证新加入的元素比栈顶元素小
                hmax.push_back(r);
                while (l <= r && amax[hmax.front()] - amin[hmin.front()] > m) {
					l++;
					//最小值栈的栈顶元素(最小值)的小标必须大于等于l,如果小于的话就弹出，
					//即保证最大值和最小值都是当前区间[l,r]内的 
                    while (!hmin.empty()&& hmin.front() < l) hmin.pop_front();
                    while (!hmax.empty()&& hmax.front() < l) hmax.pop_front();
                }
                if ((j - i + 1)*(n - l + 1)<ans) break;//r加到最大其得到的面积也小于当前结果，退出本轮 
                if (l <= r) ans = max(ans, (j - i + 1)*(r - l + 1));
            }
        }
    }
    //cout<<ans<<endl;   
    printf("%d\n",ans);
}
int main(){
    //ios::sync_with_stdio(false);
    //cin>>t;
    scanf("%d",&t);
while(t--){
    //cin>>n>>m;
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++){
            //cin>>a[i][j];
            scanf("%d",&a[i][j]);
        }
     solve();           
}    
    return 0;
}

总结

本题又考验了单调栈、单调队列的运用，如果用的好，时间将降为O(n)
这个问题怎样才能想到用单调队列，是一个难点
思考过程：

• 首先，如果暴力求解，先枚举矩形的四个边界O(n⁴)，然后再判断每个矩形是否合法O(n²)，总时间复杂度O(n⁶)。
• 有没有办法可以优化呢，在判断每个矩形是否合法时，每个格子都被重复访问，如果提前做个预处理会不会减少时间。可以先求出每列的最值，时间O(n²),这样在判断每个矩形是否合法时，只需要以O(n)的时间进行判断。
• 这样时间还是太大，有没有必要枚举矩形的四个边界呢，如果其中三个确定了，我是否可以用二分来确定第四个边界。比如先确定上、下、右边界，二分左边界，如果满足条件，左边界左移，如果不满足，左边界右移。完全可行，这样枚举所有可能的矩形的时间降为O(n³logn)，再算上判断合法的时间，总时间为O(n⁴logn)
• 时间还是会超，在看一遍题目，保证了n³$\le$ 25$\cdot$ 10⁷,这其中肯定有猫腻，n³,也就是说，如果把时间降为n³，这题就能过。同样的，尝试再对最值的预处理进行优化一下，枚举了矩形的上下边界后，接下来就是枚举右边界，在这之前…实在想不出来了
• 强行加上一条规律，如果要把时间降为O(n)尝试用单调队列 or 单调栈
• 在O(n)的遍历中，用它们同步更新最大值最小值，其时间仍为O(n), 这样确定三个边界后，判断矩形合法只需O(1)的时间
• 强行扯了这么多总结其实然并卵，多做题才是王道，解题的灵感来自于相似类型的题目