整体二分的经典例题。
对于整体二分，我个人的理解是二分答案套分治。
具体来说就是对答案进行二分，然后对于询问进行类似于权值线段树求区间第 (k) 大的分治做法。
首先，我们暴力做法就是对每个询问都跑一边二分答案，这样的复杂度是 O((nm log n))
这显然我们是不能够接受的。
我们发现我们二分答案处理每个询问时，会重复计算好多遍加权的操作。
我们就考虑把询问放在一起处理，每个加权操作只重复计算一次。
这样就能省去不少时间。具体怎么实现呢？
假设，我们二分出来的答案为 (mid) 那么此时询问的答案分成了两种情况
一种是答案小于 (mid) 的，我们可以继续递归下去，
就像这样：
紫色的为这个询问的答案。
另一种是大于 (mid) 的询问，我们就要减去左边的贡献，在 (mid - R) 这个范围递归下去（可以参考权值线段树求解区间第 (k) 大的方法）。
就像这样
我们把答案在 (mid) 左边的询问放在前面，答案在 (mid) 右边的询问放在后面。
这样我们前一部分就可以递归 (L-mid) 这一段区间，后一部分就可以递归 (mid - R) 这个区间。（也就是对询问分治）
对于这个题，我们怎么判断这个询问的答案是大于或小于 (mid) 的呢？
我们可以利用二维树状数组，对于 (L-mid) 的这一部分的加权操作加上，然后对于每个询问就相当于二维数点。
这块区间的点的数量大于 (q[i].c) 我们就说明此时答案小于 (mid)，反之大于 (mid).
一个需要注意的点是，在把询问分成前后两部分的时候，一定要先减去 (L-mid) 的贡献，在赋给中间的那个过渡数组（我在这里卡了近一个小时）
还有就是要将记录前后两部分询问数量的变量例如 (cntl), (cntr) 要设为局部变量，不然他就会一直加下去导致你答案出错
具体代码长这样 (带有注释的良心代码)
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;
const int N = 300000;
int n,m,tot;
int a[510][510],tr[510][510],ans[N],b[N];
struct node{ int x,y;};
struct kkk
{
int x1,x2,id;
int y1,y2,c;
}q[N],tong[N],stal[N],star[N];
vector< node > sta[N];
inline int read()
{
int s = 0,w = 1; char ch = getchar();
while(ch < '0' || ch > '9'){if(ch == '-') w = -1; ch = getchar();}
while(ch >= '0' && ch <= '9'){s = s * 10 + ch - '0'; ch = getchar();}
return s * w;
}
int lowbit(int x){return x & -x;}
void chenge(int x,int y,int val)//二维树状数组
{
for(int i = x; i <= n; i += lowbit(i))
{
for(int j = y; j <= n; j += lowbit(j))
{
tr[i][j] += val;
}
}
}
int ask(int x,int y)
{
int res = 0;
for(int i = x; i; i -= lowbit(i))
{
for(int j = y; j; j -= lowbit(j))
{
res += tr[i][j];
}
}
return res;
}
int get_ans(int x1,int y1,int x2,int y2)//二维数点
{
return (ask(x2,y2) + ask(x1-1,y1-1) - ask(x1-1,y2) - ask(x2,y1-1));
}
void work(int l,int r,int L,int R)//l-r 是我们的答案的区间， L-R 是我们的询问区间
{
int cntl = 0, cntr = 0;//这两个变量一定要设为局部变量
if(l == r)//l==r 说明此时我们 L-R 这一部分询问的答案就是 l
{
for(int i = L; i <= R; i++)
{
ans[q[i].id] = l;
}
return;
}
int mid = (l+r)>>1;//二分答案
for(int i = l; i <= mid; i++)
{
for(int j = 0; j < (int)sta[i].size(); j++)
{
int x = sta[i][j].x;
int y = sta[i][j].y;
chenge(x,y,1);//加权操作
}
}
for(int i = L; i <= R; i++)
{
int tmp = get_ans(q[i].x1,q[i].y1,q[i].x2,q[i].y2);//二维数点
if(tmp >= q[i].c)//如果这个区域的点的数量大于 q[i].c 说明我们这个询问的答案小于 mid 要把他放在前一部分
{
stal[++cntl] = q[i];
}
else
{
q[i].c -= tmp;//后一部分先减去 l-mid 这个答案的贡献，在去 mid - r 这个区间二分答案
star[++cntr] = q[i];//把他分到后面的那一部分
}
}
for(int i = l; i <= mid; i++)//把加权操作还原
{
for(int j = 0; j < sta[i].size(); j++)
{
int x = sta[i][j].x;
int y = sta[i][j].y;
chenge(x,y,-1);
}
}
for(int i = L; i <= L + cntl - 1 ; i++) q[i] = stal[i - L + 1];//重新给询问排一下序把答案小于 mid 的放前面，反之放后面
for(int i = L + cntl; i <= R; i++) q[i] = star[i - L - cntl + 1];
work(l,mid,L,L + cntl - 1); work(mid + 1,r,L + cntl,R);//继续递归下去
}
int main()
{
n = read(); m = read();
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= n; j++)
{
a[i][j] = read();
b[++tot] = a[i][j];
}
}
sort(b + 1,b + tot + 1);//离散化
int t = unique(b + 1,b + tot + 1) - b - 1;
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= n; j++)
{
a[i][j] = lower_bound(b+1,b+t+1,a[i][j]) - b;
sta[a[i][j]].push_back((node){i,j});//记录每个权值出现的位置
}
}
for(int i = 1; i <= m; i++)
{
q[i].x1 = read(); q[i].y1 = read();
q[i].x2 = read(); q[i].y2 = read();
q[i].c = read(); q[i].id = i;
}
work(1,t,1,m);//整体二分
for(int i = 1; i <= m; i++)
{
printf("%d
",b[ans[i]]);
}
return 0;
}