洛谷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 = ;
 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 = ; i <= a; i++){
         for(int j = ; j <= b; j++){
             scanf("%lld", &grid[i][j]);
             row_big[i][j] = col_big[i][j] = -;
             row_small[i][j] = col_small[i][j] = LLONG_MAX;
         }
     }

     //cout<<endl;
     int tail_b = , tail_s = , head_b = , head_s = ;
     for(int i = ; i <= a; i++){
         tail_b = tail_s = ;
         head_b = head_s = ;
         for(int j = ; 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 = ; j <= b; j++){
         tail_b = tail_s = ;
         head_b = head_s = ;
         for(int i = ; 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\n", ans);
     return ;
 }