Fast Matrix Operations

A Simple Problem with Integers

每次将区间向下更新，或是用之前的方法，统计当前节点到父节点处的覆盖数目。

#include <cstdio>
#include <iostream>
using namespace std;

const int MAXN = ;

typedef long long int64;

int d[MAXN];

class SegNode {
public:
    int L, R;
    int64 c, sum;
    int64 get_c() { return c * (R - L + ); }
    void log(const char *info) {
        printf("%s: [%d %d]: %lld, %lld.\n", info, L, R, c, sum);
    }
} node[MAXN * ];

class SegTree {
public:
    void log(const char *info) {
        printf("%s:\n", info);
        printf("{%d %d}, %lld, %lld.\n", node[].L, node[].R, node[].c, node[].sum);
    }
    void build(int r, int L, int R) {
        node[r].L = L;
        node[r].R = R;
        node[r].c = ;
        if (L == R) {
            node[r].sum = d[L];
        } else {
            int M = (L + R) / ;
            build( * r, L, M);
            build( * r + , M + , R);
            node[r].sum = node[ * r].sum + node[ * r + ].sum;
        }
    }
    int64 query(int r, int L, int R) {
        if (L <= node[r].L && node[r].R <= R) {
            return node[r].sum + node[r].get_c();
        } else {
            node[ * r].c += node[r].c;
            node[ * r + ].c += node[r].c;
            int64 res = ;
            if (L <= node[ * r].R) {
                res += query( * r, L, R);
            }
            if (R >= node[ * r + ].L) {
                res += query( * r + , L, R);
            }
            node[r].c = ;
            node[r].sum = node[ * r].sum + node[ * r + ].sum + node[ * r].get_c() + node[ * r + ].get_c();
            //node[r].log("query");
            return res;
        }
    }
    void insert(int r, int L, int R, int c) {
        if (L <= node[r].L && node[r].R <= R) {
            node[r].c += c;
        } else {
            node[ * r].c += node[r].c;
            node[ * r + ].c += node[r].c;
            if (L <= node[ * r].R) {
                insert( * r, L, R, c);
            }
            if (R >= node[ * r + ].L) {
                insert( * r + , L, R, c);
            }
            node[r].c = ;
            node[r].sum = node[ * r].sum + node[ * r + ].sum + node[ * r].get_c() + node[ * r + ].get_c();
        }
        //log("tree");
        //node[r].log("insert");
    }
    /*{{{ insert2*/
    void insert2(int r, int L, int R, int c) {
        if (L <= node[r].L && node[r].R <= R) {
            node[r].c += c;
        } else {
            if (L <= node[ * r].R) {
                insert( * r, L, R, c);
            }
            if (R >= node[ * r + ].L) {
                insert( * r + , L, R, c);
            }
            node[r].sum = node[ * r].sum + node[ * r + ].sum + node[ * r].get_c() + node[ * r + ].get_c();
        }
    }
    /*}}}*/
    /*{{{ query2*/
    int64 query2(int r, int L, int R, int dd) {
        dd += node[r].c;
        if (L <= node[r].L && node[r].R <= R) {
            return node[r].sum + (node[r].R - node[r].L + ) * dd;
        } else {
            int res = ;
            if (L <= node[ * r].R) {
                res += query( * r, L, R);
            }
            if (R >= node[ * r + ].L) {
                res += query( * r + , L, R);
            }
            return res;
        }
    }
    /*}}}*/
};

int main() {
    int n, q;
    while (scanf("%d%d", &n, &q) != EOF) {
    SegTree tree;
    for (int i = ; i <= n; i++) scanf("%d", &d[i]);
    tree.build(, , n);
    while (q--) {
        char ch[];
        int a, b;
        scanf("%s%d%d", ch, &a, &b);
        if (ch[] == 'C') {
            int c;
            scanf("%d", &c);
            tree.insert(, a, b, c);
            //tree.insert2(1, a, b, c);
        } else if (ch[] == 'Q') {
            printf("%lld\n", tree.query(, a, b));
            /*
            int dd = 0;
            printf("%lld\n", tree.query2(1, a, b, dd));
            */
        }
    }
    }
}

Fast Matrix Operations

需要注意的是：

1. 插入及查询在树上向下遍历时，不然是否有遍历，都应该将节点上的覆盖数目向下传递；

2. 树构建的时候，一些节点会构建不出来，这种类型的节点，在插入向孩子节点遍历的时候，之前判断失败的条件，可能会判断成功，从而导致错误；

3. 节点中的sum表示的是当前节点构成的树除了当前节点上的覆盖数以外的所有数的和。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

typedef long long int64;

class SegNode {
public:
    int L, R, B, T;
    int64 v, m_min, m_max, m_sum;
    bool is_clear;
    SegNode* sons[];
    SegNode() {
        v = m_min = m_max = m_sum = ;
        is_clear = false;
        memset(sons, NULL, sizeof(sons));
    }
    int area() {
        return (R - L + ) * (T - B + );
    }
};

class SegTree {
public:
    void free(SegNode *node) {
        for (int i = ; i < ; i++) {
            if (node->sons[i] != NULL) {
                free(node->sons[i]);
            }
        }
        if (node != NULL) {
            delete node;
            node = NULL;
        }
    }
    void build(SegNode* &node, int L, int R, int B, int T) {
        node = new SegNode();
        node->L = L; node->R = R; node->B = B; node->T = T;
        if (L == R && B == T) {
            // leaf
        } else {
            // non leaf
            int M1 = (L + R) / ;
            int M2 = (B + T) / ;
            if (L <= M1 && M2 +  <= T) build(node->sons[], L, M1, M2 + , T);
            if (M1 +  <= R && M2 +  <= T) build(node->sons[], M1 + , R, M2 + , T);
            if (L <= M1 && B <= M2) build(node->sons[], L, M1, B, M2);
            if (M1 +  <= R && B <= M2) build(node->sons[], M1 + , R, B, M2);
        }
    }
    void insert(SegNode *node, int L, int R, int B, int T, int v, int k) {
        //node->log();
        if (L <= node->L && node->R <= R && B <= node->B && node->T <= T) {
            if (k == ) node->v += v;
            else if (k == ) {
                node->v = v;
                node->m_min = node->m_max = node->m_sum = ;
                node->is_clear = true;
            }
        } else {
            int M1 = (node->L + node->R) / ;
            int M2 = (node->B + node->T) / ;
            for (int i = ; i < ; i++) {
                if (node->sons[i] != NULL) {
                    down(node, node->sons[i]);
                }
            }
            if (L <= M1 && T >= M2 + ) {
                if (node->sons[] != NULL)
                insert(node->sons[], L, R, B, T, v, k);
            }
            if (R >= M1 +  && T >= M2 + ) {
                if (node->sons[] != NULL)
                insert(node->sons[], L, R, B, T, v, k);
            }
            if (L <= M1 && B <= M2) {
                if (node->sons[] != NULL)
                insert(node->sons[], L, R, B, T, v, k);
            }
            if (R >= M1 +  && B <= M2) {
                if (node->sons[] != NULL)
                insert(node->sons[], L, R, B, T, v, k);
            }
            // clear node[r]
            node->is_clear = false;
            node->v = ;
            update(node);
        }
    }
    void down(SegNode *r, SegNode *t) {
        r->is_clear;
        if (r->is_clear) {
            t->is_clear = true;
            t->v = r->v;
            //
            t->m_min = t->m_max = t->m_sum = ;
        } else {
            t->v += r->v;
        }
    }
    void update(SegNode *r) {
        bool need = true;
        for (int i = ; i < ; i++) {
            if (r->sons[i] != NULL) {
                if (need) {
                    need = false;
                    r->m_min = r->sons[i]->m_min + r->sons[i]->v;
                    r->m_max = r->sons[i]->m_max + r->sons[i]->v;
                    r->m_sum = r->sons[i]->m_sum + r->sons[i]->v * r->sons[i]->area();
                } else {
                    r->m_min = min(r->m_min, r->sons[i]->m_min + r->sons[i]->v);
                    r->m_max = max(r->m_max, r->sons[i]->m_max + r->sons[i]->v);
                    r->m_sum += r->sons[i]->m_sum + r->sons[i]->v * r->sons[i]->area();
                }
            }
        }
    }
    void query(SegNode *node, int L, int R, int B, int T, int64& mmin, int64& mmax, int64& msum) {
        //node->log();
        if (L <= node->L && node->R <= R && B <= node->B && node->T <= T) {
            mmin = min(mmin, node->m_min + node->v);
            mmax = max(mmax, node->m_max + node->v);
            msum += node->m_sum + node->v * node->area();
        } else {
            int M1 = (node->L + node->R) / ;
            int M2 = (node->B + node->T) / ;
            for (int i = ; i < ; i++) {
                if (node->sons[i] != NULL) {
                    down(node, node->sons[i]);
                }
            }
            if (L <= M1 && T >= M2 + ) {
                if (node->sons[] != NULL)
                query(node->sons[], L, R, B, T, mmin, mmax, msum);
            }
            if (R >= M1 +  && T >= M2 + ) {
                if (node->sons[] != NULL)
                query(node->sons[], L, R, B, T, mmin, mmax, msum);
            }
            if (L <= M1 && B <= M2) {
                if (node->sons[] != NULL)
                query(node->sons[], L, R, B, T, mmin, mmax, msum);
            }
            if (R >= M1 +  && B <= M2) {
                if (node->sons[] != NULL)
                query(node->sons[], L, R, B, T, mmin, mmax, msum);
            }
            // clear node[r]
            node->is_clear = false;
            node->v = ;
            update(node);
        }
    }
};

int main() {
    //freopen("fast.in", "r", stdin);

    int r, c, m;
    while (scanf("%d%d%d", &r, &c, &m) != EOF) {
        SegTree tree;
        SegNode *root = NULL;
        tree.build(root, , r, , c);
        for (int i = ; i < m; i++) {
            int k, x1, y1, x2, y2, v;
            scanf("%d%d%d%d%d", &k, &x1, &y1, &x2, &y2);
            if (k == ) {
                int64 mmin = 1e9, mmax = -1e9, msum = ;
                tree.query(root, x1, x2, y1, y2, mmin, mmax, msum);
                printf("%lld %lld %lld\n", msum, mmin, mmax);
            } else {
                scanf("%d", &v);
                tree.insert(root, x1, x2, y1, y2, v, k);
            }
        }
        tree.free(root);
    }
}