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

题解:理想的正方形

题目传送门: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的情况,这样的复杂度是无法接受的。

三、解题思路 + 算法讲解

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

  1. 行处理:对每一行,使用单调队列分别计算该行中每个长度为n的滑动窗口的最大值和最小值,结果存储在rowmax和rowmin数组中。

  2. 列处理:对每一列,在rowmax和rowmin的基础上,再次使用单调队列计算每个长度为n的滑动窗口的最大值和最小值,这样就得到了每个n×n区域的最值。

  3. 结果计算:遍历所有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;
}

五、重点细节

  1. 单调队列维护:在行处理中,我们维护一个递减队列求最大值,维护一个递增队列求最小值。队列中存储的是下标,通过比较下标和当前元素位置来判断是否移出窗口。

  2. 二维处理顺序:先处理每一行的滑动窗口,再处理每一列的滑动窗口。这样两次一维处理就相当于二维处理。

  3. 边界条件:注意窗口大小n的限制,只有当i≥n时才记录结果。

六、复杂度分析

  • 时间复杂度:O(a*b)。对每行处理两次(最大和最小),每列处理两次,总共4次线性扫描。
  • 空间复杂度:O(a*b)。需要存储原始矩阵和中间结果的四个数组。

七、总结

本题通过两次单调队列处理(先行后列)高效地解决了二维滑动窗口的最值问题。这种方法避免了暴力解法的高时间复杂度,是处理此类问题的经典方法。关键在于理解单调队列如何维护窗口内的最值,以及如何将二维问题分解为两个一维问题处理。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

hongjianMa

感恩社区,回馈社区

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值