UVA - 11992：Fast Matrix Operations

线段树，注意tag优先级

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#define MAXN 1000005
using namespace std;
struct Node{
    int sumv,maxv,minv,tag_add,tag_change;
    Node(int p1=,int p2=,int p3=,int p4=,int p5=){
        sumv=p1,maxv=p3,minv=p2,tag_add=p4,tag_change=p5;
    }
}dat[][MAXN<<];
int a[][MAXN];
Node Merge(Node t1,Node t2){
    if(t1.tag_add==-)return t2;
    if(t2.tag_add==-)return t1;
    Node ret;
    ret.sumv=t1.sumv+t2.sumv;
    ret.maxv=max(t1.maxv,t2.maxv);
    ret.minv=min(t1.minv,t2.minv);
    return ret;
}
void build(Node d[],int x,int k,int L,int R){
    if(L+==R){
        d[k].sumv=d[k].maxv=d[k].minv=a[x][L];
        return;
    }
    build(d,x,k<<,L,(L+R)>>);
    build(d,x,k<<|,(L+R)>>,R);
    d[k]=Merge(d[k<<],d[k<<|]);
}
void pushdown(Node d[],int k,int L,int R){
    int lc=(k<<),rc=(k<<|);
    if(d[k].tag_change){
        d[lc].tag_add=;
        d[lc].tag_change=d[k].tag_change;
        d[lc].sumv=d[k].tag_change*(((L+R)>>)-L);
        d[lc].maxv=d[k].tag_change;
        d[lc].minv=d[k].tag_change;
        d[rc].tag_add=;
        d[rc].tag_change=d[k].tag_change;
        d[rc].sumv=d[k].tag_change*(R-((L+R)>>));
        d[rc].maxv=d[k].tag_change;
        d[rc].minv=d[k].tag_change;
        d[k].tag_change=;
    }
    if(d[k].tag_add){
        d[lc].tag_add+=d[k].tag_add;
        d[lc].sumv+=d[k].tag_add*(((L+R)>>)-L);
        d[lc].maxv+=d[k].tag_add;
        d[lc].minv+=d[k].tag_add;
        d[rc].tag_add+=d[k].tag_add;
        d[rc].sumv+=d[k].tag_add*(R-((L+R)>>));
        d[rc].maxv+=d[k].tag_add;
        d[rc].minv+=d[k].tag_add;
        d[k].tag_add=;
    }
}
void add(Node d[],int a,int b,int k,int L,int R,int x){
    if(b<=L||R<=a){
        return;
    }
    else if(a<=L&&R<=b){
        d[k].tag_add+=x;
        d[k].sumv+=x*(R-L);
        d[k].maxv+=x;
        d[k].minv+=x;
    }
    else{
        if(d[k].tag_add||d[k].tag_change){
            pushdown(d,k,L,R);
        }
        add(d,a,b,k<<,L,(L+R)>>,x);
        add(d,a,b,k<<|,(L+R)>>,R,x);
        d[k]=Merge(d[k<<],d[k<<|]);
    }
}
void change(Node d[],int a,int b,int k,int L,int R,int x){
    if(b<=L||R<=a){
        return;
    }
    else if(a<=L&&R<=b){
        d[k].tag_add=;
        d[k].tag_change=x;
        d[k].sumv=x*(R-L);
        d[k].maxv=x;
        d[k].minv=x;
    }
    else{
        if(d[k].tag_add||d[k].tag_change){
            pushdown(d,k,L,R);
        }
        change(d,a,b,k<<,L,(L+R)>>,x);
        change(d,a,b,k<<|,(L+R)>>,R,x);
        d[k]=Merge(d[k<<],d[k<<|]);
    }
}
Node query(Node d[],int a,int b,int k,int L,int R){
    if(b<=L||R<=a){
        return Node(-,-,-,-,-);
    }
    else if(a<=L&&R<=b){
        return d[k];
    }
    else{
        if(d[k].tag_add||d[k].tag_change){
            pushdown(d,k,L,R);
        }
        Node lc=query(d,a,b,k<<,L,(L+R)>>);
        Node rc=query(d,a,b,k<<|,(L+R)>>,R);
        return Merge(lc,rc);
    }
}
void debug(Node d[],int k,int L,int R){
    if(d[k].tag_add||d[k].tag_change){
        pushdown(d,k,L,R);
    }
    if(L+==R){
        printf("%d ",d[k]);
        return;
    }
    debug(d,k<<,L,(L+R)>>);
    debug(d,k<<|,(L+R)>>,R);
}
int m,n,T;
void solve(){
    for(int i=;i<=m;i++){
        build(dat[i],i,,,n+);
    }
    while(T--){
        int p;scanf("%d",&p);
        int x1,y1,x2,y2;scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        if(==p){
            int v;scanf("%d",&v);
            for(int i=x1;i<=x2;i++){
                add(dat[i],y1,y2+,,,n+,v);
            }
        }
        else if(==p){
            int v;scanf("%d",&v);
            for(int i=x1;i<=x2;i++){
                change(dat[i],y1,y2+,,,n+,v);
            }
        }
        else{
            Node ans=query(dat[x1],y1,y2+,,,n+);
            for(int i=x1+;i<=x2;i++){
                Node t=query(dat[i],y1,y2+,,,n+);
                ans.sumv+=t.sumv;
                ans.maxv=max(ans.maxv,t.maxv);
                ans.minv=min(ans.minv,t.minv);
            }
            printf("%d %d %d\n",ans.sumv,ans.minv,ans.maxv);
        }
    }
}
int main()
{
//    freopen("data.in","r",stdin);
//    freopen("my.in","w",stdout);
    while(~scanf("%d%d%d",&m,&n,&T)){
        solve();
    }
}