hdu4819 线段树套线段树

二维的线段树，每个横向节点都是一颗y方向的线段树，覆盖面积从线变为矩阵，维护即可，具体看代码。

附代码：

//二维线段树模板题
#include 
#include 
#include 
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define delf int m=(l+r)>>1

using namespace std;

int ma[810<<2][810<<2];        //最大值
int mi[810<<2][810<<2];        //最小值
int mm[810][810];
int n;
int a1,a2;
int x1,x2;
int y1;
int y2;

int min(int a,int b)
{
    return a>b?b:a;
}

int max(int a,int b)
{
    return a>b?a:b;
}

/*
纵向比较建立线段树，例如这是一颗包含两列的线段树，那么两列形成的新的叶子节点我已经求得，只需要将这一棵线段树
按照纵向更新上去即可
*/
void pushup(int xrt,int rt)
{
    ma[xrt][rt]=max(ma[xrt][rt<<1],ma[xrt][rt<<1|1]);
    mi[xrt][rt]=min(mi[xrt][rt<<1],mi[xrt][rt<<1|1]);
    return ;
}

void buildy(int xrt,int p,int l,int r,int rt)
{
    if (l==r)
    {
        //p表示的是建立的是什么类型的线段树，两种可能，一种直接赋值，此时x方向长度为1，一种比较获得，x方向长度大于1
        if (p!=-1)
            ma[xrt][rt]=mi[xrt][rt]=mm[p][l];
        /*
        把每一个节点的x轴方向覆盖范围内同一行的节点的值更新好，然后再维护这一棵线段树的时候就只需要更新y方向的
        值，相当于建立了这颗线段树的所有叶子节点，以后需要的就是依次更新，建立叶子节点的时候是横向比较，之后都是纵向
        此时的l==r相当于是xrt这颗线段树的叶子节点，其值由其左孩子和右孩子比较获得
        */
        else
        {
            ma[xrt][rt]=max(ma[xrt<<1][rt],ma[xrt<<1|1][rt]);
            mi[xrt][rt]=min(mi[xrt<<1][rt],mi[xrt<<1|1][rt]);
        }
        return ;
    }
    delf;
    buildy(xrt,p,lson);
    buildy(xrt,p,rson);
    pushup(xrt,rt);     //任意一个x节点都是一个y方向的线段树，因此更新的时候pushup的是y方向，维护的也是y方向
    return ;
}

void buildx(int l,int r,int rt)
{
    if (l==r)
    {
        buildy(rt,l,1,n,1);
        return ;
    }
    delf;
    buildx(lson);
    buildx(rson);
    /*
    这次更新时为了建立这个节点的线段树的所有叶子节点，此时rt节点的左孩子线段树已经建好，右孩子线段树也已经建好，直接
    建立rt这颗树的叶子节点，然后通过纵向的pushup建立这棵线段树，每一个横向的节点表示一个纵向的线段树，这棵线段树横向
    包含x节点的左孩子横向范围和右孩子横向范围，纵向是1到n的一颗新的线段树
    */
    /*
    为什么写成buildy，是因为它本质上也是建立一颗线段树的孩子节点，只不过赋值方式和x方向长度为1的线段树不同
    */
    buildy(rt,-1,1,n,1);
    return ;
}

void updatey(int xrt,int p,int y,int v,int l,int r,int rt)
{
    if (l==r)
    {
        if (p!=-1)
            ma[xrt][rt]=mi[xrt][rt]=v;
        else
        {
            ma[xrt][rt]=max(ma[xrt<<1][rt],ma[xrt<<1|1][rt]);
            mi[xrt][rt]=min(mi[xrt<<1][rt],mi[xrt<<1|1][rt]);
        }
        return ;
    }
    delf;
    if (m>=y)
        updatey(xrt,p,y,v,lson);
    else
        updatey(xrt,p,y,v,rson);
    pushup(xrt,rt);     //同buildy
    return ;
}

void updatex(int x,int y,int v,int l,int r,int rt)
{
    if (l==r)
    {
        updatey(rt,l,y,v,1,n,1);
        return ;
    }
    delf;
    if (m>=x)
        updatex(x,y,v,lson);
    else
        updatex(x,y,v,rson);
    /*
    所有包含这个节点的值都需要被更新，更新时这个节点的值肯定已经更新过了，只需要按照建立时的顺序，先通过横向比较更新每颗线段树
    的叶子节点，然后通过纵向比较建立线段树的所有非叶子节点
    */
    updatey(rt,-1,y,v,1,n,1);
}

//query函数就没什么了，同时需要满足x方向和y方向的结果才是可能解
void queryy(int xrt,int l,int r,int rt)
{
    if (y1<=l&&r<=y2)
    {
        a1=max(a1,ma[xrt][rt]);
        a2=min(a2,mi[xrt][rt]);
        return ;
    }
    delf;
    if (m>=y1)
        queryy(xrt,lson);
    if (y2>m)
        queryy(xrt,rson);
    return ;
}

void queryx(int l,int r,int rt)
{
    if (x1<=l&&r<=x2)
    {
        queryy(rt,1,n,1);
        return ;
    }
    delf;
    if (m>=x1)
        queryx(lson);
    if (x2>m)
        queryx(rson);
    return ;
}

int main()
{
    int T;
    scanf("%d",&T);
    for (int r=1;r<=T;r++)
    {
        scanf("%d",&n);
        for (int i=1;i<=n;i++)
            for (int t=1;t<=n;t++)
                scanf("%d",&mm[i][t]);
        buildx(1,n,1);
        int q;
        scanf("%d",&q);
        printf("Case #%d:\n",r);
        while (q--)
        {
            int x,y,l;
            scanf("%d%d%d",&x,&y,&l);
            a1=0;
            a2=0x3f3f3f3f;
            x1=max(1,x-(l/2));
            x2=min(n,x+(l/2));
            y1=max(1,y-(l/2));
            y2=min(n,y+(l/2));
            queryx(1,n,1);
            int v=(a1+a2)/2;
            printf("%d\n",v);
            updatex(x,y,v,1,n,1);
        }
    }
}