算法：二维单调队列-P2216 [HAOI2007] 理想的正方形题解

原创于 2025-03-31 17:13:17 发布 · 440 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #c++ #数据结构

题解：理想的正方形

题目传送门：P2216 [HAOI2007] 理想的正方形

一、题目描述 + 样例解释

给定一个a×b的整数矩阵，要求从中找出一个n×n的正方形区域，使得该区域内最大值和最小值的差最小。输出这个最小的差值。

样例解释：
输入一个5×4的矩阵，n=2。我们需要找到所有2×2正方形区域中最大最小值差最小的那个。在样例中，最小的差值为1（比如右下角的2×2区域，值为2和1）。

二、题目分析

这是一个典型的二维滑动窗口问题。我们需要高效地计算每个n×n正方形区域的最大值和最小值，然后找出差值最小的那个。

直接暴力计算每个n×n区域的最值时间复杂度为O(abn²)，对于a,b=1000，n=100的情况，这样的复杂度是无法接受的。

三、解题思路 + 算法讲解

采用单调队列优化的二维滑动窗口算法：

行处理：对每一行，使用单调队列分别计算该行中每个长度为n的滑动窗口的最大值和最小值，结果存储在rowmax和rowmin数组中。
列处理：对每一列，在rowmax和rowmin的基础上，再次使用单调队列计算每个长度为n的滑动窗口的最大值和最小值，这样就得到了每个n×n区域的最值。
结果计算：遍历所有n×n区域，计算最大值与最小值的差，找出最小的那个。

这种方法通过两次单调队列处理（先行后列），将时间复杂度从O(abn²)降低到O(a*b)。

四、代码实现

#include <iostream>
using namespace std;

const int N = 1010;
int m[N][N], q[N];              // m存储原始矩阵，q为单调队列的数组
int rowmin[N][N], rowmax[N][N]; // 存储每行滑动窗口的最小值和最大值
int colmin[N][N], colmax[N][N]; // 存储每列滑动窗口的最小值和最大值
int a, b, n, ans = 1e9;         // ans初始化为极大值

int main()
{
    cin >> a >> b >> n;
    // 读取输入矩阵
    for (int i = 1; i <= a; i++)
        for (int j = 1; j <= b; j++)
            cin >> m[i][j];

    // 处理每一行的滑动窗口最值
    for (int row = 1; row <= a; row++)
    {
        // 计算当前行的最大值
        int hh = 0, tt = 0; // 单调队列头尾指针
        for (int i = 1; i <= b; i++)
        {
            // 维护队列，移除超出窗口的元素
            while (hh < tt && q[hh] + n <= i)
                hh++;
            // 保持队列递减，移除尾部较小的元素
            while (hh < tt && m[row][q[tt - 1]] < m[row][i])
                tt--;
            q[tt++] = i;
            // 当i足够大时，保存当前窗口的最大值
            if (i >= n)
                rowmax[row][i - n + 1] = m[row][q[hh]];
        }

        // 计算当前行的最小值，逻辑类似最大值
        hh = 0, tt = 0;
        for (int i = 1; i <= b; i++)
        {
            while (hh < tt && q[hh] + n <= i)
                hh++;
            // 保持队列递增，移除尾部较大的元素
            while (hh < tt && m[row][q[tt - 1]] > m[row][i])
                tt--;
            q[tt++] = i;
            if (i >= n)
                rowmin[row][i - n + 1] = m[row][q[hh]];
        }
    }

    // 处理每一列的滑动窗口最值，基于rowmax和rowmin的结果
    for (int col = 1; col <= b - n + 1; col++)
    {
        // 处理当前列的最大值
        int hh = 0, tt = 0;
        for (int i = 1; i <= a; i++)
        {
            while (hh < tt && q[hh] + n <= i)
                hh++;
            // 比较的是rowmax中的值
            while (hh < tt && rowmax[q[tt - 1]][col] < rowmax[i][col])
                tt--;
            q[tt++] = i;
            if (i >= n)
                colmax[i - n + 1][col] = rowmax[q[hh]][col];
        }

        // 处理当前列的最小值
        hh = 0, tt = 0;
        for (int i = 1; i <= a; i++)
        {
            while (hh < tt && q[hh] + n <= i)
                hh++;
            // 比较的是rowmin中的值
            while (hh < tt && rowmin[q[tt - 1]][col] > rowmin[i][col])
                tt--;
            q[tt++] = i;
            if (i >= n)
                colmin[i - n + 1][col] = rowmin[q[hh]][col];
        }
    }

    // 遍历所有n×n区域，寻找最小差值
    for (int i = 1; i <= a - n + 1; i++)
        for (int j = 1; j <= b - n + 1; j++)
            ans = min(ans, colmax[i][j] - colmin[i][j]);

    cout << ans;
    return 0;
}