牛客883F - Planting Trees 单调队列双指针

给一个矩阵，求一个范围最大的子矩阵，满足矩阵内元素最大差值不超过m。输出最大的面积。

本题卡$N^{3}logN$的做法卡得严，导致常数稍大也会超时，另外牛客网的测评机性能浮动大，让人很迷惑。

---

首先可以了解一下最大子矩阵的问题。子矩阵问题的模型（尤其是数据范围才几百的），常常要$n^2$枚举子矩阵的左右边界，对中间的部分做一些一维的操作。下面的问题是，如何枚举到，确定左右边界的子矩阵里的所有合题意的子矩阵。而且必须要$O(N)$做这一步。

对于一个子矩阵我们需要知道最大值和最小值的差，那么对于我们现在选的区间里，只需要知道每一行的最值就够了。

在选中的区间内，每行的最值其实可以在枚举边界的时候顺便求好，存在数组。这样无论多宽，每行都能用最大最小值代替，也就是$2N$个数。下面把需要枚举那些合法的矩阵的问题，转化成对那2n个数排成的数组，枚举最大差值小于m的所有区间。

现在就变成一维的问题了。可以用单调队列解决。

$O(N)$的做法是，单调队列维护最大和最小值，用双指针移动尺取。针对本题有个技巧，可以一个队列维护每一行的最大值，一个队列维护每一行的最小值。

若两队首差距大于m时，就是不合题意的选择，可移动合法左边界队首出队，到差距小于m；反之双指针的左右边界内的区间是合法的，这里的左右边界，其实就是我们枚举子矩阵的头行和尾行。

有了四个边界，就可以更新答案了。

以上就是这道题的做法流程虽然很长，但是理解了很快就敲好了，子矩阵是有点套路可循的。

#define _debug(x) cerr<<#x<<" = "<<x<<endl

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
const int INF = 0x3f3f3f3f;
const int MOD = 998244353;
const int MAXN = 500 + 59;

//手写Deque会快
struct Deque {
    int v[MAXN];
    int h, t;

    inline void clear() {
        h = 0;
        t = 1;
    }

    inline void pop_front() {
        h++;
    }

    inline void pop_back() {
        t--;
    }

    inline void push_back(int x) {
        v[t++] = x;
    }

    inline int front() {
        return v[h + 1];
    }

    inline int back() {
        return v[t - 1];
    }

    inline bool empty() {
        return h + 1 == t;
    }
};

int Kase, n, m;
int a[MAXN][MAXN];
int rMax[MAXN];			//第i行的最大值
int rMin[MAXN];			//第i行的最小值

int ans;

Deque qMax, qMin;


int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);


    cin >> Kase;
    while (Kase--) {
        ans = 0;
        cin >> n >> m;

        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= n; ++j) {
                cin >> a[i][j];
            }
        }

        for (int l = 1; l <= n; ++l) {
            for (int i = 1; i <= n; ++i)
                rMin[i] = rMax[i] = a[i][l];

            for (int r = l; r <= n; ++r) {
                for (int i = 1; i <= n; ++i) {
                    rMax[i] = max(rMax[i], a[i][r]);
                    rMin[i] = min(rMin[i], a[i][r]);
                }

                qMax.clear();
                qMin.clear();

                for (int j = 1, i = 1; i <= n && j <= n; i++) {
                    while (!qMax.empty() && rMax[qMax.back()] < rMax[i])
                        qMax.pop_back();

                    while (!qMin.empty() && rMin[qMin.back()] > rMin[i])
                        qMin.pop_back();

                    qMax.push_back(i);
                    qMin.push_back(i);

                    while (rMax[qMax.front()] - rMin[qMin.front()] > m) {
                        j++;
                        while (!qMax.empty() && qMax.front() < j)qMax.pop_front();
                        while (!qMin.empty() && qMin.front() < j)qMin.pop_front();
                        if (qMax.empty() || qMin.empty())break;
                    }
                    ans = max(ans, (i - j + 1) * (r - l + 1));
                }
            }
        }
        cout << ans << "\n";
    }


    return 0;
}

/*


 2
2 0
1 2
1 1

 3 2
 1 2 1
 5 3 1
 1 5 1


*/