Uva11992 Fast Matrix Operations(线段树区间修改+更新)

题意：给定一个n * m矩阵，三种操作，一种是给一个子矩阵每个元素加v，第二种是将子矩阵的所有元素修改为v，第三种是查询子矩阵的所有元素和，最大值，最小值

思路：二维转换为一维，用线段树进行区间更新，修改和查询

#include<cstdio>
#include<cstring>
#include<cmath>
#include<map>
#include<string>
#include<stack>
#include<vector>
#include<queue>
#include<set>
#include<algorithm>
#include<iostream>
const int maxn = 4 * 1e6 + 10;
typedef long long ll;
const ll INF = 1e15;
using namespace std;

struct P {
    ll sum, maxv, minv;
    P() {}
    P(ll a, ll b, ll c) : sum(a), maxv(b), minv(c) {}
} C[maxn];
ll del[maxn], res[maxn];
int n, m, k, op;
int ql, qr;
ll change;

void init() {
    for(int i = 0; i < maxn; i++) {
        C[i].sum = C[i].maxv = C[i].minv = 0;
    }
    memset(del, 0, sizeof(del));
    memset(res, 0, sizeof(res));
}

void pushdown(int node, int l, int r) {
    if(l == r) {
        del[node] = res[node] = 0;
        C[node].maxv = C[node].minv = C[node].sum;
        return ;
    }
    int ls = 2 * node, rs = 2 * node + 1;
    int mid = (l + r) >> 1;
    if(res[node]) {
        C[ls].sum = (mid - l + 1) * res[node];
        C[rs].sum = (r - mid) * res[node];
        C[rs].maxv = C[rs].minv = res[node];
        C[ls].maxv = C[ls].minv = res[node];
        res[ls] = res[node];
        res[rs] = res[node];
        res[node] = 0;
        del[ls] = del[rs] = 0;
    }
    if(del[node]) {
        C[ls].sum += (mid - l + 1) * del[node];
        C[ls].maxv += del[node];
        C[ls].minv += del[node];
        C[rs].sum += (r - mid) * del[node];
        C[rs].maxv += del[node];
        C[rs].minv += del[node];
        del[ls] += del[node];
        del[rs] += del[node];
        del[node] = 0;
    }
    return ;
}

void update(int node, int l, int r, int o) {
    if(l >= ql && r <= qr) {
        if(o == 1) {
            if(res[node]) pushdown(node, l, r);
            del[node] += change;
            C[node].sum += (r - l + 1) * change;
            C[node].maxv += change;
            C[node].minv += change;
        } else {
            if(del[node]) pushdown(node, l, r);
            res[node] = change;
            C[node].sum = (r - l + 1) * change;
            C[node].maxv = C[node].minv = change;
        }
        return ;
    }
    int ls = 2 * node, rs = 2 * node + 1;
    int mid = (l + r) >> 1;
    pushdown(node, l, r);
    if(ql <= mid) update(ls, l, mid, o);
    if(qr > mid) update(rs, mid + 1, r, o);
    C[node].sum = C[ls].sum + C[rs].sum;
    C[node].maxv = max(C[ls].maxv, C[rs].maxv);
    C[node].minv = min(C[ls].minv, C[rs].minv);
}

P query(int node, int l, int r) {
    if(l >= ql && r <= qr) return C[node];
    if(r < ql || l > qr) return P(0, -INF, INF);
    pushdown(node, l, r);
    int ls = 2 * node, rs = 2 * node + 1;
    int mid = (l + r) >> 1;
    P p1 = query(ls, l, mid);
    P p2 = query(rs, mid + 1, r);
    return P(p1.sum + p2.sum, max(p1.maxv, p2.maxv), min(p1.minv, p2.minv));
}

int main()
{
    while(scanf("%d %d %d", &n, &m, &k) != EOF) {
        init();
        int N = n * m - 1;
        while(k--) {
            int x, y, X, Y;
            scanf("%d %d %d %d %d", &op, &x, &y, &X, &Y);
            x--; y--; X--; Y--;
            if(op <= 2) {
                scanf("%lld", &change);
                for(int i = x; i <= X; i++) {
                    ql = i * m + y;
                    qr = i * m + Y;
                    update(1, 0, N, op);
                }
            } else {
                P st(0, -INF, INF);
                for(int i = x; i <= X; i++) {
                    ql = i * m + y;
                    qr = i * m + Y;
                    P p = query(1, 0, N);
                    st.sum += p.sum;
                    st.maxv = max(st.maxv, p.maxv);
                    st.minv = min(st.minv, p.minv);
                }
                printf("%lld %lld %lld\n", st.sum, st.minv, st.maxv);
            }
        }
    }
    return 0;
}