洛谷P2216 理想的正方形

题目描述

有一个a*b的整数组成的矩阵，现请你从中找出一个n*n的正方形区域，使得该区域所有数中的最大值和最小值的差最小。

输入输出格式

输入格式：

第一行为3个整数，分别表示a,b,n的值

第二行至第a+1行每行为b个非负整数，表示矩阵中相应位置上的数。每行相邻两数之间用一空格分隔。

输出格式：

仅一个整数，为a*b矩阵中所有“n*n正方形区域中的最大整数和最小整数的差值”的最小值。

输入输出样例

输入样例#1： 复制

5 4 2
1 2 5 6
0 17 16 0
16 17 2 1
2 10 2 1
1 2 2 2

输出样例#1： 复制

1

说明

问题规模

（1）矩阵中的所有数都不超过1,000,000,000

（2）20%的数据2<=a,b<=100,n<=a,n<=b,n<=10

（3）100%的数据2<=a,b<=1000,n<=a,n<=b,n<=100

题意：

给定一个a*b的矩阵，找一个n*n的正方形，使得正方形里最大值和最小值之差最小。

思路：

我们可以预处理出每一个n*n的正方形的最大最小值分别是多少，然后暴力跑一遍找到最小值就可以了。

先处理横着的，用单调队列来维护。刚开始一直写不对，因为队列中应该存的是位置的下标而不是直接存值，因为head++的时候比较的是下标的距离，而我刚开始直接比较了tail和head也就是队列里的元素个数。

然后按照同样的方法，在行处理好的基础上处理列。

发现写单调队列的套路就是。比如我们要建一个存最大值的，那我们应该比较队尾和当前值的关系。

如果队尾比当前值小就要一直tail--

然后删去不满足区间约束的队头的值。

然后每次取的应该是队头的元素。

#include <iostream>
#include <set>
#include <cmath>
#include <stdio.h>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#define inf 0x7f7f7f7f

const int maxn = 1005;
int a, b, n;
LL grid[maxn][maxn];
LL row_big[maxn][maxn], col_big[maxn][maxn], row_small[maxn][maxn], col_small[maxn][maxn];
LL que_big[maxn], que_small[maxn];

int main()
{
    scanf("%d%d%d", &a, &b, &n);
    for(int i = 1; i <= a; i++){
        for(int j = 1; j <= b; j++){
            scanf("%lld", &grid[i][j]);
            row_big[i][j] = col_big[i][j] = -1;
            row_small[i][j] = col_small[i][j] = LLONG_MAX;
        }
    }

    //cout<<endl;
    int tail_b = 0, tail_s = 0, head_b = 1, head_s = 1;
    for(int i = 1; i <= a; i++){
        tail_b = tail_s = 0;
        head_b = head_s = 1;
        for(int j = 1; j <= b; j++){
            //row_big[i][j] = max(que_big[tail_b], grid[i][j]);
            //cout<<row_big[i][j]<<" ";
            while(grid[i][que_big[tail_b]] <= grid[i][j] && head_b <= tail_b){
                tail_b--;
            }
            que_big[++tail_b] = j;
            while(j - que_big[head_b] >= n){
                head_b++;
            }
            row_big[i][j] = grid[i][que_big[head_b]];

            //row_small[i][j] = min(que_small[tail_s], grid[i][j]);
            while(grid[i][que_small[tail_s]] >= grid[i][j] && head_s <= tail_s){
                tail_s--;
            }
            que_small[++tail_s] = j;
            while(j - que_small[head_s] >= n){
                head_s++;
            }
            row_small[i][j] = grid[i][que_small[head_s]];
        }
        //cout<<endl;
    }

    /*cout<<endl;
    for(int i = 1; i <= a; i++){
        for(int j = n; j <= b; j++){
            cout<<row_big[i][j]<<" ";
        }
        cout<<endl;
    }*/

    for(int j = 1; j <= b; j++){
        tail_b = tail_s = 0;
        head_b = head_s = 1;
        for(int i = 1; i <= a; i++){
            //col_big[i][j] = max(que_big[tail_b], row_big[i][j]);
            while(row_big[que_big[tail_b]][j] <= row_big[i][j] && head_b <= tail_b){
                tail_b--;
            }
            que_big[++tail_b] = i;
            while(i - que_big[head_b] >= n){
                head_b++;
            }
            col_big[i][j] = row_big[que_big[head_b]][j];

            //col_small[i][j] = min(que_small[tail_s], row_small[i][j]);
            while(row_small[que_small[tail_s]][j] >= row_small[i][j] && head_s <= tail_s){
                tail_s--;
            }
            que_small[++tail_s] = i;
            while(i - que_small[head_s] >= n){
                head_s++;
            }
            col_small[i][j] = row_small[que_small[head_s]][j];
        }
    }

    /*cout<<endl;
    for(int i = n ;i <= a; i++){
        for(int j = n; j <= b; j++){
            cout<<col_big[i][j]<<" ";
        }
        cout<<endl;
    }*/

    LL ans = LLONG_MAX;
    for(int i = n; i <= a; i++){
        for(int j = n; j <= b; j++){
            ans = min(ans, col_big[i][j] - col_small[i][j]);
        }
    }
    printf("%lld
", ans);
    return 0;
}