【二维单调队列】BZOJ1047-[HAOI2007]理想的正方形

【题目大意】

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

【思路】

裸的二维单调队列。二维单调队列的思路其实很简单:

(1)对于每一行维护两个宽度为n的滑动窗口记录单行中的min和max，和POJ2823一个道理。此时相当于把n个格子浓缩到了一个格子当中。

(2)维护n*n大小的二维滑动窗口中的min和max。由于有了第一步操作，只要考虑每一个n*n的矩形右上角到右下角的最值即可。相当于对于每一列，维护两个宽度为n的滑动窗口。此时循环要行和列里外颠倒，而列只要从第n列开始维护即可（我一开始就错在了这两个地方）

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define INF 0x7fffffff
 struct node
 {
     int data,pos;
 };
 using namespace std;
 const int MAXN=+;
 int a,b,n;
 int num[MAXN][MAXN];
 int rmin[MAXN][MAXN],rmax[MAXN][MAXN],smin[MAXN][MAXN],smax[MAXN][MAXN];

 void init()
 {
     scanf("%d%d%d",&a,&b,&n);
     for (int i=;i<a;i++)
         for (int j=;j<b;j++) scanf("%d",&num[i][j]);
 }

 void humdrum_queue()
 {
     /*对于每一行，用单调队列维护[x-n+1,x]的最小值和最大值*/
     for (int i=;i<a;i++)
     {
         int minhead=,mintail=,maxhead=,maxtail=;
         node qmin[MAXN],qmax[MAXN];
         for (int j=;j<b;j++)
         {
             int nown=num[i][j];
             /*维护最小值*/
             while (minhead<mintail && qmin[mintail-].data>nown) mintail--;
             qmin[mintail++]=(node){nown,j};
             while (minhead<mintail && qmin[minhead].pos<=j-n) minhead++;
             rmin[i][j]=qmin[minhead].data;

             /*维护最大值*/
             while (maxhead<maxtail && qmax[maxtail-].data<nown) maxtail--;
             qmax[maxtail++]=(node){nown,j};
             while (maxhead<maxtail && qmax[maxhead].pos<=j-n) maxhead++;
             rmax[i][j]=qmax[maxhead].data;
         }
     }

     /*对于以[i,j]为右下角的n*n矩形，用单调队列维护它的最小值和最大值
       这步操作可以用单调队列维护每一列，相当于维护该矩形右上角到右下角对应点的rmin与rmax值*/
     /*|ATTENTION|要注意的是这里i和j要颠倒过来，所以内外循环以及队列中的pos均要颠倒！*/
     for (int j=n-;j<b;j++)
     {
         int minhead=,mintail=,maxhead=,maxtail=;
         node qmin[MAXN],qmax[MAXN];
           for (int i=;i<a;i++)
         {
             int nowmin=rmin[i][j],nowmax=rmax[i][j];
             /*维护最小值*/
             while (minhead<mintail && qmin[mintail-].data>nowmin) mintail--;
             qmin[mintail++]=(node){nowmin,i};
             while (minhead<mintail && qmin[minhead].pos<=i-n) minhead++;
             smin[i][j]=qmin[minhead].data;

             /*维护最大值*/
             while (maxhead<maxtail && qmax[maxtail-].data<nowmax) maxtail--;
             qmax[maxtail++]=(node){nowmax,i};
             while (maxhead<maxtail && qmax[maxhead].pos<=i-n) maxhead++;
             smax[i][j]=qmax[maxhead].data;
         }
     }
 }

 void getans()
 {
     int ans=INF;
     for (int i=n-;i<a;i++)
         for (int j=n-;j<b;j++)
             if (smax[i][j]-smin[i][j]<ans) ans=smax[i][j]-smin[i][j];
     cout<<ans<<endl;
 }

 int main()
 {
      init();
      humdrum_queue();
      getans();
      return ;
 }