Mosaic
Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 102400/102400 K (Java/Others)
Total Submission(s): 904 Accepted Submission(s): 394
God of sheep decides to pixelate some pictures (i.e., change them into
pictures with mosaic). Here's how he is gonna make it: for each picture,
he divides the picture into n x n cells, where each cell is assigned a
color value. Then he chooses a cell, and checks the color values in the L
x L region whose center is at this specific cell. Assuming the maximum
and minimum color values in the region is A and B respectively, he will
replace the color value in the chosen cell with floor((A + B) / 2).
Can you help the God of sheep?
Each
test case begins with an integer n (5 < n < 800). Then the
following n rows describe the picture to pixelate, where each row has n
integers representing the original color values. The j-th integer in the
i-th row is the color value of cell (i, j) of the picture. Color values
are nonnegative integers and will not exceed 1,000,000,000 (10^9).
After the description of the picture, there is an integer Q (Q ≤ 100000 (10^5)), indicating the number of mosaics.
Then
Q actions follow: the i-th row gives the i-th replacement made by the
God of sheep: xi, yi, Li (1 ≤ xi, yi ≤ n, 1 ≤ Li < 10000, Li is odd).
This means the God of sheep will change the color value in (xi, yi)
(located at row xi and column yi) according to the Li x Li region as
described above. For example, an query (2, 3, 3) means changing the
color value of the cell at the second row and the third column according
to region (1, 2) (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 2), (3,
3), (3, 4). Notice that if the region is not entirely inside the
picture, only cells that are both in the region and the picture are
considered.
Note that the God of sheep will do the replacement one by one in the order given in the input.��
For each action, print the new color value of the updated cell.
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <list>
#include <iomanip>
#include <cstdlib>
#include <sstream>
using namespace std;
typedef long long LL;
const int INF=0x5fffffff;
const double EXP=1e-;
const int MS=;
int leafx[MS],leafy[MS];
int n;
struct nodey
{
int l,r,maxv,minv;
int mid()
{
return (l+r)>>;
}
}; struct nodex
{
int l,r;
nodey Y[MS<<];
int mid()
{
return (l+r)>>;
}
void build(int root,int l,int r)
{
Y[root].l=l;
Y[root].r=r;
Y[root].maxv=-INF;
Y[root].minv=INF;
if(l==r)
{
leafy[l]=root;
return ;
}
build(root<<,l,(l+r)/);
build(root<<|,(l+r)/+,r);
} int query_min(int root,int l,int r)
{
if(Y[root].l>=l&&Y[root].r<=r)
return Y[root].minv;
int mid=Y[root].mid();
if(r<=mid)
return query_min(root<<,l,r);
else if(l>mid)
return query_min(root<<|,l,r);
else
return min(query_min(root<<,l,mid),query_min(root<<|,mid+,r));
} int query_max(int root,int l,int r)
{
if(Y[root].l>=l&&Y[root].r<=r)
return Y[root].maxv;
int mid=Y[root].mid();
if(r<=mid)
return query_max(root<<,l,r);
else if(l>mid)
return query_max(root<<|,l,r);
else
return max(query_max(root<<,l,mid),query_max(root<<|,mid+,r));
}
}X[MS<<]; void build(int root,int l,int r)
{
X[root].l=l;
X[root].r=r;
X[root].build(,,n);
if(l==r)
{
leafx[l]=root;
return ;
}
build(root<<,l,(l+r)/);
build(root<<|,(l+r)/+,r);
} void updata(int x,int y,int value)
{
int tx=leafx[x];
int ty=leafy[y];
X[tx].Y[ty].minv=X[tx].Y[ty].maxv=value;
// push up
for(int i=tx;i;i>>=)
for(int j=ty;j;j>>=)
{
if(i==tx&&j==ty)
continue;
if(j==ty) // is leaf
{
X[i].Y[j].minv=min(X[i<<].Y[j].minv,X[i<<|].Y[j].minv);
X[i].Y[j].maxv=max(X[i<<].Y[j].maxv,X[i<<|].Y[j].maxv);
}
else
{
X[i].Y[j].minv=min(X[i].Y[j<<].minv,X[i].Y[j<<|].minv);
X[i].Y[j].maxv=max(X[i].Y[j<<].maxv,X[i].Y[j<<|].maxv);
}
}
} int query_min(int root,int x1,int x2,int y1,int y2)
{
if(X[root].l>=x1&&X[root].r<=x2)
return X[root].query_min(,y1,y2);
int mid=X[root].mid();
if(x2<=mid)
return query_min(root<<,x1,x2,y1,y2);
else if(x1>mid)
return query_min(root<<|,x1,x2,y1,y2);
return min(query_min(root<<,x1,mid,y1,y2),query_min(root<<|,mid+,x2,y1,y2));
} int query_max(int root,int x1,int x2,int y1,int y2)
{
if(X[root].l>=x1&&X[root].r<=x2)
return X[root].query_max(,y1,y2);
int mid=X[root].mid();
if(x2<=mid)
return query_max(root<<,x1,x2,y1,y2);
else if(x1>mid)
return query_max(root<<|,x1,x2,y1,y2);
return max(query_max(root<<,x1,mid,y1,y2),query_max(root<<|,mid+,x2,y1,y2));
} int main()
{
int T,x,y,z,Q;
scanf("%d",&T);
for(int k=;k<=T;k++)
{
scanf("%d",&n);
build(,,n);
for(int i=;i<=n;i++)
for(int j=;j<=n;j++)
{
scanf("%d",&x);
updata(i,j,x);
}
scanf("%d",&Q);
printf("Case #%d:\n",k);
while(Q--)
{
scanf("%d%d%d",&x,&y,&z);
int x1=max(x-z/,);
int x2=min(x+z/,n);
int y1=max(y-z/,);
int y2=min(y+z/,n);
int maxv=query_max(,x1,x2,y1,y2);
int minv=query_min(,x1,x2,y1,y2);
updata(x,y,(maxv+minv)>>);
printf("%d\n",(maxv+minv)>>);
}
}
return ;
}