子矩阵（蓝桥杯，acwing，单调队列）

最新推荐文章于 2024-07-14 19:56:17 发布

麦田里的小白羊

最新推荐文章于 2024-07-14 19:56:17 发布

阅读量1.1k

点赞数 19

分类专栏：单调队列文章标签：算法 c++ 数据结构蓝桥杯线性代数矩阵

本文链接：https://blog.csdn.net/2302_76987120/article/details/136994437

版权

单调队列专栏收录该内容

3 篇文章 0 订阅

订阅专栏

题目描述：

给定一个 n×m（n 行 m 列）的矩阵。

设一个矩阵的价值为其所有数中的最大值和最小值的乘积。

求给定矩阵的所有大小为 a×b （a 行 b 列）的子矩阵的价值的和。

答案可能很大，你只需要输出答案对 998244353取模后的结果。

输入格式：

输入的第一行包含四个整数分别表示 n,m,a,b相邻整数之间使用一个空格分隔。

接下来 n 行每行包含 m 个整数，相邻整数之间使用一个空格分隔，表示矩阵中的每个数 Ai,j

输出格式：

输出一行包含一个整数表示答案。

数据范围：

对于 40%的评测用例，1≤n,m≤100
对于 70%的评测用例，1≤n,m≤500；
对于所有评测用例，1≤a≤n≤1000，1≤b≤m≤1000，1≤Ai,j≤1e9

输入样例：

2 3 1 2
1 2 3
4 5 6

输出样例：

样例解释：

1×2+2×3+4×5+5×6=58。

分析步骤：

第一：拿到这道题目，我们可以知道要找到一个区间中最小的值和最大的值，想到这里我们就知道可以用一个队列来维护我们这个区间，并且在这个区间之中我们是要找到一个极值的，所以只要把没有用的值剔除出去，由此我们这个队列之中就自然而然呈现出了一种单调的特点，所以在这个单调的队列之中在对头或者对尾就是我们所需要找的极值。所以想到这里我们有理有据的要运用单调对列来解答我们的题目。

所以用单调队列的思考顺序是这样的：

1.用队列维护集合；

2.把没有用的值给他剔除出去；

3.该队列会呈现单调的特点；

4.在O(1)时间找最值

但是这道题目我们是要维护的是一个二维的空间矩阵，那我们应该怎么做呢？很简单！我们只需要横着来一遍，纵着来一遍。也就是说我们先将这个矩阵先分为一维的只有一行但是列是符合条件的，这样我们先来一遍找出最小值和最大值分别用两个数组存下来，这样我们就将很多数，合并为一个数。再将这些数看成只有一列但有多行再从之前找的每一行的最小值再次筛选一遍找出区间的最小值。最大值也是这样。我们就完成了这道题目。

第二：书写主函数，构建整体框架。

输入相应的值和地图值，在找出横向一维中最小的值和最大的值，分别用amin和amax数组储存，将地图的边界和题目要求的矩阵的宽度传入函数之中。那么这样我们就可以找到最小值和最大值，将多个数合并为一个数。

定义res储存答案，定义a数组来储存之前找的的极值，b，c数组来储存这个要求的矩阵之中真正最小值和最大值，将他们相乘就是我们要的是答案。注意这里相乘可能会超出int的值，所以应该改为long long。

int main() {
    cin >> n >> m >> A >> B;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            scanf("%d", &arr[i][j]);
        }
    }

    for (int i = 0; i < n; i++) {
        get_max(arr[i], amax[i], m, B);
        get_min(arr[i], amin[i], m, B);
    }
    
    int res = 0;
    int a[N], b[N], c[N];
    for (int i = B - 1; i < m; i++) {
        for (int j = 0; j < n; j++) a[j] = amax[j][i];
        get_max(a, b, n, A);
        for (int j = 0; j < n; j++) a[j] = amin[j][i];
        get_min(a, c, n, A);
        for (int j = A - 1; j < n; j++)
            res = (res + (LL)b[j] * c[j]) % MOD;
    }
    
    cout << res << endl;
    
    return 0;
}

第四：书写得到一维中最值的函数：

我们已经分析出了要用单调队列所以很简单把模板一套就基本出来了；

定义我们的头节点和尾节点

用for循环去遍历我们的矩阵，题目中给出的B也就是函数中的k相当于我们队列所需要维护的空间。判断一下如果队列的头节点小于等于了我们 i - k 值了的话那么就意味着对头已经出去了我们所维护的空间之中，所以队列不为空的话就应该头节点++。

当队列不为空的话如果找的是最小值则队列尾部的值大于等于我们要进队列的值的话我们就应该尾指针往后退回直到这个队列之中没有比刚进入的这个值更小的值了的话就成功了，之后只要将此点入队就可以。因为我们这个队列找最小值所以队列头一定是最小的数。找极大值就只有while循环时有不同，因为是找最大值所以只要对尾的值小于等于我们要进入队列的值则将尾部节点回退。

各位注意哈！我们单调队列之中存的是位置而不是真正的值的大小。


void get_max(int w[], int mm[], int tot, int k) {
    int hh = 0, tt = -1;
    for (int i = 0; i < tot; i++) {
        if (q[hh] <= i - k and hh <= tt) hh++;
        while (hh <= tt and w[q[tt]] <= w[i]) tt--;
        q[++tt] = i;
        mm[i] = w[q[hh]];
    }
}

void get_min(int w[], int mm[], int tot, int k) {
    int hh = 0, tt = -1;
    for (int i = 0; i < tot; i++) {
        if (q[hh] <= i - k and hh <= tt) hh++;
        while (hh <= tt and w[q[tt]] >= w[i]) tt--;
        q[++tt] = i;
        mm[i] = w[q[hh]];
    }

代码：

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;
typedef long long LL;

const int N = 1010, MOD = 998244353;

int n, m, A, B;
int arr[N][N];
int amax[N][N], amin[N][N];
int q[N];

void get_max(int w[], int mm[], int tot, int k) {
    int hh = 0, tt = -1;
    for (int i = 0; i < tot; i++) {
        if (q[hh] <= i - k and hh <= tt) hh++;
        while (hh <= tt and w[q[tt]] <= w[i]) tt--;
        q[++tt] = i;
        mm[i] = w[q[hh]];
    }
}

void get_min(int w[], int mm[], int tot, int k) {
    int hh = 0, tt = -1;
    for (int i = 0; i < tot; i++) {
        if (q[hh] <= i - k and hh <= tt) hh++;
        while (hh <= tt and w[q[tt]] >= w[i]) tt--;
        q[++tt] = i;
        mm[i] = w[q[hh]];
    }
}

int main() {
    cin >> n >> m >> A >> B;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            scanf("%d", &arr[i][j]);
        }
    }

    for (int i = 0; i < n; i++) {
        get_max(arr[i], amax[i], m, B);
        get_min(arr[i], amin[i], m, B);
    }
    
    int res = 0;
    int a[N], b[N], c[N];
    for (int i = B - 1; i < m; i++) {
        for (int j = 0; j < n; j++) a[j] = amax[j][i];
        get_max(a, b, n, A);
        for (int j = 0; j < n; j++) a[j] = amin[j][i];
        get_min(a, c, n, A);
        for (int j = A - 1; j < n; j++)
            res = (res + (LL)b[j] * c[j]) % MOD;
    }
    
    cout << res << endl;
    
    return 0;
}