HDU4819 Mosaic

//It is made by ljh2000
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <ctime>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <string>
#include <complex>
using namespace std;
typedef long long LL;
const int MAXN = 811;
const int MAXM = 5000011;
int n,m,ju[MAXN][MAXN],X[2],Y[2],cnt,rt,ans,CC;
struct node{ int l,r,ls,rs,maxl,minl,tree; }a[MAXM];
inline int getint(){
    int w=0,q=0; char c=getchar(); while((c<‘0‘||c>‘9‘) && c!=‘-‘) c=getchar();
    if(c==‘-‘) q=1,c=getchar(); while (c>=‘0‘&&c<=‘9‘) w=w*10+c-‘0‘,c=getchar(); return q?-w:w;
}

namespace Seg_tree{
	inline void build(int &k,int l,int r,int bel){
		k=++cnt; a[k].l=l; a[k].r=r; if(l==r) { a[k].minl=a[k].maxl=ju[l][bel]; return ; }
		int mid=(l+r)>>1; build(a[k].ls,l,mid,bel); build(a[k].rs,mid+1,r,bel);
		a[k].minl=min(a[a[k].ls].minl,a[a[k].rs].minl); a[k].maxl=max(a[a[k].ls].maxl,a[a[k].rs].maxl);
	}

	inline int query_min(int k,int l,int r){
		if(Y[0]<=l && r<=Y[1]) return a[k].minl;
		int mid=(l+r)>>1;
		if(Y[0]>mid) return query_min(a[k].rs,mid+1,r); 
		else if(Y[1]<=mid) return query_min(a[k].ls,l,mid);
		else return min(query_min(a[k].ls,l,mid),query_min(a[k].rs,mid+1,r)); 
	}

	inline int query_max(int k,int l,int r){
		if(Y[0]<=l && r<=Y[1]) return a[k].maxl;
		int mid=(l+r)>>1;
		if(Y[0]>mid) return query_max(a[k].rs,mid+1,r); 
		else if(Y[1]<=mid) return query_max(a[k].ls,l,mid);
		else return max(query_max(a[k].ls,l,mid),query_max(a[k].rs,mid+1,r)); 
	}

	inline void modify(int k,int l,int r,int y){
		if(l==r) { a[k].minl=a[k].maxl=ans; return ; }
		int mid=(l+r)>>1; 
		if(y<=mid) modify(a[k].ls,l,mid,y); else modify(a[k].rs,mid+1,r,y);
		a[k].minl=min(a[a[k].ls].minl,a[a[k].rs].minl); a[k].maxl=max(a[a[k].ls].maxl,a[a[k].rs].maxl);
	}

	inline void update_min(int k,int l,int r,int y){
		if(l==r) { a[k].minl=CC; return ; }
		int mid=(l+r)>>1; 
		if(y<=mid) update_min(a[k].ls,l,mid,y); else update_min(a[k].rs,mid+1,r,y);
		a[k].minl=min(a[a[k].ls].minl,a[a[k].rs].minl);
	}

	inline void update_max(int k,int l,int r,int y){
		if(l==r) { a[k].maxl=CC; return ; }
		int mid=(l+r)>>1; 
		if(y<=mid) update_max(a[k].ls,l,mid,y); else update_max(a[k].rs,mid+1,r,y);
		a[k].maxl=max(a[a[k].ls].maxl,a[a[k].rs].maxl);
	}
}

inline void merge(int &k,node q,node qq){
	if(!k) k=++cnt; a[k].maxl=max(q.maxl,qq.maxl); a[k].minl=min(q.minl,qq.minl);
	a[k].l=q.l; a[k].r=q.r; if(q.l==q.r) return ;
	merge(a[k].ls,a[q.ls],a[qq.ls]);
	merge(a[k].rs,a[q.rs],a[qq.rs]);
}

inline void build(int &k,int l,int r){
	k=++cnt; a[k].l=l; a[k].r=r; 
	if(l==r) { 
		Seg_tree::build(a[k].tree,1,n,l); 
		return;
	}
	int mid=(l+r)>>1; build(a[k].ls,l,mid); build(a[k].rs,mid+1,r);
	merge(a[k].tree,a[ a[a[k].ls].tree ],a[ a[a[k].rs].tree ]);
}

inline int query_min(int k,int l,int r){ 
	if(X[0]<=l && r<=X[1]) return Seg_tree::query_min(a[k].tree,1,n);
	int mid=(l+r)>>1;
	if(X[0]>mid) return query_min(a[k].rs,mid+1,r);
	else if(X[1]<=mid) return query_min(a[k].ls,l,mid);
	else return min(query_min(a[k].ls,l,mid),query_min(a[k].rs,mid+1,r));
}

inline int query_max(int k,int l,int r){
	if(X[0]<=l && r<=X[1]) return Seg_tree::query_max(a[k].tree,1,n);
	int mid=(l+r)>>1;
	if(X[0]>mid) return query_max(a[k].rs,mid+1,r);
	else if(X[1]<=mid) return query_max(a[k].ls,l,mid);
	else return max(query_max(a[k].ls,l,mid),query_max(a[k].rs,mid+1,r));
}

inline void modify(int k,int l,int r,int x,int y){
	if(l==r) { Seg_tree::modify(a[k].tree,1,n,y); return ; }
	int mid=(l+r)>>1;
	if(x<=mid) modify(a[k].ls,l,mid,x,y);
	else modify(a[k].rs,mid+1,r,x,y);
	
	int lc=a[k].ls,rc=a[k].rs;
	int lmin=Seg_tree::query_min(a[lc].tree,a[a[lc].tree].l,a[a[lc].tree].r);
	int rmin=Seg_tree::query_min(a[rc].tree,a[a[rc].tree].l,a[a[rc].tree].r);
	CC=min(lmin,rmin); Seg_tree::update_min(a[k].tree,a[a[k].tree].l,a[a[k].tree].r,y);

	int lmax=Seg_tree::query_max(a[lc].tree,a[a[lc].tree].l,a[a[lc].tree].r);
	int rmax=Seg_tree::query_max(a[rc].tree,a[a[rc].tree].l,a[a[rc].tree].r);
	CC=max(lmax,rmax); Seg_tree::update_max(a[k].tree,a[a[k].tree].l,a[a[k].tree].r,y);
	//merge(a[k].tree,a[ a[a[k].ls].tree ],a[ a[a[k].rs].tree ]);
}

inline void work(){
	int T=getint();
	for(int Case=1;Case<=T;Case++) {
		printf("Case #%d:\n",Case);	n=getint(); for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) ju[i][j]=getint();
		for(int i=1;i<=cnt;i++) a[i].tree=a[i].ls=a[i].rs=0; cnt=0; rt=0; 
		build(rt,1,n); m=getint(); int x,y,z,da,xiao;
		while(m--) {
			y=getint(); x=getint(); z=getint();	z>>=1;
			X[0]=max(x-z,1); X[1]=min(x+z,n);
			Y[0]=max(y-z,1); Y[1]=min(y+z,n);
			da=query_max(rt,1,n); 
			xiao=query_min(rt,1,n);
			ans=(da+xiao)>>1; printf("%d\n",ans);
			Y[0]=Y[1]=y;
			modify(rt,1,n,x,y);
		}
	}

}

int main()
{
    work();
    return 0;
}