【HDU 4819】Mosaic

【题目链接】

点击打开链接

【算法】

二维线段树（树套树）

【代码】

#include<bits/stdc++.h>
using namespace std;
#define MAXN 800

int i,q,n,xa,xb,ya,yb,l,tmp,T,Max,Min,x,y;

struct info { int Max,Min; } Tree[MAXN*][MAXN*];

template <typename T> inline void read(T &x) {
    int f = ; x = ;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) { if (c == '-') f = -f; }
    for (; isdigit(c); c = getchar()) x = (x << ) + (x << ) + c - '';
        x *= f;
}
template <typename T> inline void write(T x) {
    if (x < ) { putchar('-'); x = -x; }
    if (x > ) write(x/);
    putchar(x%+'');
}
template <typename T> inline void writeln(T x) {
    write(x);
    puts("");
}

inline void push_up(int D,int index) {
    Tree[D][index].Max = max(Tree[D][index<<].Max,Tree[D][index<<|].Max);
    Tree[D][index].Min = min(Tree[D][index<<].Min,Tree[D][index<<|].Min);
}

inline void build_y(int D,int index,int l,int r,int opt) {
    int mid,val;
    if (l == r) {
        if (opt == ) {
            read(val);
            Tree[D][index].Max = Tree[D][index].Min = val;
        } else {
            Tree[D][index].Max = max(Tree[D<<][index].Max,Tree[D<<|][index].Max);
            Tree[D][index].Min = min(Tree[D<<][index].Min,Tree[D<<|][index].Min);
        }
        return;
    }
    mid = (l + r) >> ;
    build_y(D,index<<,l,mid,opt);
    build_y(D,index<<|,mid+,r,opt);
    push_up(D,index);
}

inline void build_x(int index,int l,int r) {
    int mid;
    if (l == r) {
        build_y(index,,,n,);
        return;
    }
    mid = (l + r) >> ;
    build_x(index<<,l,mid);
    build_x(index<<|,mid+,r);
    build_y(index,,,n,);
}

inline void modify_y(int D,int index,int l,int r,int val,int opt) {
    int mid;
    if (l == r) {
        if (opt == ) Tree[D][index].Max = Tree[D][index].Min = val;
        else {
            Tree[D][index].Max = max(Tree[D<<][index].Max,Tree[D<<|][index].Max);
            Tree[D][index].Min = min(Tree[D<<][index].Min,Tree[D<<|][index].Min);
        }
        return;
    }
    mid = (l + r) >> ;
    if (mid >= y) modify_y(D,index<<,l,mid,val,opt);
    else modify_y(D,index<<|,mid+,r,val,opt);
    push_up(D,index);
}

inline void modify_x(int index,int l,int r,int val) {
    int mid;
    if (l == r) {
        modify_y(index,,,n,val,);
        return;
    }
    mid = (l + r) >> ;
    if (mid >= x) modify_x(index<<,l,mid,val);
    else modify_x(index<<|,mid+,r,val);
    modify_y(index,,,n,val,);
}

inline int query_min_y(int D,int index,int l,int r,int x,int y) {
    int mid;
    if (l == x && r == y) return Tree[D][index].Min;
    mid = (l + r) >> ;
    if (mid >= y) return query_min_y(D,index<<,l,mid,x,y);
    else if (mid +  <= x) return query_min_y(D,index<<|,mid+,r,x,y);
    else return min(query_min_y(D,index<<,l,mid,x,mid),query_min_y(D,index<<|,mid+,r,mid+,y));
}

inline int query_min_x(int index,int l,int r,int x,int y) {
    int mid;
    if (l == x && r == y) return query_min_y(index,,,n,ya,yb);
    mid = (l + r) >> ;
    if (mid >= y) return query_min_x(index<<,l,mid,x,y);
    else if (mid +  <= x) return query_min_x(index<<|,mid+,r,x,y);
    else return min(query_min_x(index<<,l,mid,x,mid),query_min_x(index<<|,mid+,r,mid+,y));
}

inline int query_max_y(int D,int index,int l,int r,int x,int y) {
    int mid;
    if (l == x && r == y) return Tree[D][index].Max;
    mid = (l + r) >> ;
    if (mid >= y) return query_max_y(D,index<<,l,mid,x,y);
    else if (mid +  <= x) return query_max_y(D,index<<|,mid+,r,x,y);
    else return max(query_max_y(D,index<<,l,mid,x,mid),query_max_y(D,index<<|,mid+,r,mid+,y));
}

inline int query_max_x(int index,int l,int r,int x,int y) {
    int mid;
    if (l == x && r == y) return query_max_y(index,,,n,ya,yb);
    mid = (l + r) >> ;
    if (mid >= y) return query_max_x(index<<,l,mid,x,y);
    else if (mid +  <= x) return query_max_x(index<<|,mid+,r,x,y);
    else return max(query_max_x(index<<,l,mid,x,mid),query_max_x(index<<|,mid+,r,mid+,y));
}

int main() {

    read(T);
    for (i = ; i <= T; i++) {
        read(n);
        build_x(,,n);
        read(q);
        cout<<"Case #"<< i << ':' << endl;
        while (q--) {
            read(x); read(y); read(l);
            xa = max(,x-l/);
            xb = min(n,x+l/);
            ya = max(,y-l/);
            yb = min(n,y+l/);
            Max = query_max_x(,,n,xa,xb);
            Min = query_min_x(,,n,xa,xb);
            tmp = (Max + Min) / ;
            writeln(tmp);
            modify_x(,,n,tmp);
        }
    }
    return ;
}