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()
{
whil
4000
e(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;
}