牛客883F - Planting Trees 單調隊列雙指針

給一個矩陣，求一個範圍最大的子矩陣，滿足矩陣內元素最大差值不超過m。輸出最大的面積。

本題卡$N^3logN$的做法卡得嚴，導致常數稍大也會超時，另外牛客網的測評機性能浮動大，讓人很迷惑。

---

首先可以瞭解一下最大子矩陣的問題。子矩陣問題的模型（尤其是數據範圍才幾百的），常常要$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


*/