[TYVJ P1716/BZOJ 3132 上帝造题的七分钟] 二维树状数组区间修改、区间查询

[TYVJ P1716/BZOJ 3132 上帝造题的七分钟] 二维树状数组区间修改、区间查询

知识点：data structure binary index tree

1. 题目链接

[TYVJ P1716 上帝造题的七分钟]
类似题目还有[POJ 2155 Matrix]。只不过这个题目就是一个二维的区间翻转，单点查询。一个树状数组就可以做了，但是可以套上这题的模板做，如果你不闲麻烦的话。。

2. 题意描述

有一个 n∗m 的矩阵，有 2 种操作（操作次数不超过 200000 次）。
操作一：二维区间修改，选一个子矩阵【以 (a,b),(c,d) 为顶点】，进行区间加上 delta ；
操作二：二维区间求和，选一个子矩阵【以 (a,b),(c,d) 为顶点】，求这个子矩阵的所有元素之和。

3. 解题思路

BZOJ 3132这个题目好像找不到了？就在TYVJ上找到这个题目了。
二维树状数组区间修改、区间查询的裸题。但是这个题目有点剧毒，可能是卡常特别严重？TLE了很多次，加上超级输入挂，依旧TLE，非得再加一个输出挂。
二维树状数组区间修改，区间更新原理：
跟一维树状数组区间修改，区间更新的原理类似。也是用差分增量数据来表示一个前缀和。然后用前缀和描述区间。
对于原矩阵 A ，用矩阵 dij 表示 (1,1)−(n,m) 的增量，那么子矩阵 (1,1)−(x,y) 的和为：

sum=∑i=1x∑j=1y[di,j∗(x−i+1)∗(y−i+1)]=∑i=1x∑j=1y{di,j∗[(x+1)∗(y+1)−(x+1)∗j−(y+1)∗i+i∗j]}=∑i=1x∑j=1y[(x+1)∗(y+1)∗dij−(x+1)∗j∗dij−(y+1)∗i∗dij+i∗j∗dij]

因此，用四个树状数组分别维护： dij,(i∗dij),(j∗dij),(i∗j∗dij)
最后，贴一个二维树状数组的模板。

4. 实现代码

#include 
using namespace std;

typedef long long LL;
const int MAXN = 2048 + 1;

int n, m;
// 输入挂
namespace IO {
    const int MT = 10 * 1024 * 1024;  /// 10MB 请注意输入数据的大小！！！
    char IO_BUF[MT];
    int IO_PTR, IO_SZ;
    /// 要记得把这一行添加到main函数第一行！！！
    void begin() {
        IO_PTR = 0;
        IO_SZ = fread (IO_BUF, 1, MT, stdin);
    }
    template<typename T>
    inline bool scan_d (T & t) {
        while (IO_PTR < IO_SZ && IO_BUF[IO_PTR] != '-' && (IO_BUF[IO_PTR] < '0' || IO_BUF[IO_PTR] > '9'))
            IO_PTR ++;
        if (IO_PTR >= IO_SZ) return false;
        bool sgn = false;
        if (IO_BUF[IO_PTR] == '-') sgn = true, IO_PTR ++;
        for (t = 0; IO_PTR < IO_SZ && '0' <= IO_BUF[IO_PTR] && IO_BUF[IO_PTR] <= '9'; IO_PTR ++)
            t = t * 10 + IO_BUF[IO_PTR] - '0';
        if (sgn) t = -t;
        return true;
    }
    inline bool scan_s (char s[]) {
        while (IO_PTR < IO_SZ && (IO_BUF[IO_PTR] == ' ' || IO_BUF[IO_PTR] == '\n') ) IO_PTR ++;
        if (IO_PTR >= IO_SZ) return false;
        int len = 0;
        while (IO_PTR < IO_SZ && IO_BUF[IO_PTR] != ' ' && IO_BUF[IO_PTR] != '\n')
            s[len ++] = IO_BUF[IO_PTR], IO_PTR ++;
        s[len] = '\0';
        return true;
    }
    template<typename T>
    void print(T x) {
        static char s[33], *s1; s1 = s;
        if (!x) *s1++ = '0';
        if (x < 0) putchar('-'), x = -x;
        while(x) *s1++ = (x % 10 + '0'), x /= 10;
        while(s1-- != s) putchar(*s1);
    }
    template<typename T>
    void println(T x) {
        print(x); putchar('\n');
    }
};

template<class T>
struct BIT_2D {
    struct Core {
        T C[4][MAXN][MAXN];
        void I() { memset(C, 0, sizeof(C)); }
        inline T lowbit(const T& x) { return x & (-x); }
        void update(const int& x0, const int& y0, const T& val) {
            for(int x = x0; x <= n; x += x & (-x)) {
                for(int y = y0; y <= m; y += y & (-y)) {
                    C[0][x][y] += val;
                    C[1][x][y] += val * x0;
                    C[2][x][y] += val * y0;
                    C[3][x][y] += val * x0 * y0;
                }
            }
        }
        T query(const int& x0, const int& y0) {
            T ret = 0;
            for(int x = x0; x > 0; x -= x & (-x)) {
                for(int y = y0; y > 0; y -= y & (-y)) {
                    ret += C[0][x][y] * (x0 + 1) * (y0 + 1);
                    ret -= C[1][x][y] * (y0 + 1);
                    ret -= C[2][x][y] * (x0 + 1);
                    ret += C[3][x][y];
                }
            }
            return ret;
        }
    };
    Core core;
    void update(const int& x0, const int& y0, const int& x1, const int& y1, const int& val) {
        int dx[4] = {x0, x1 + 1, x0, x1 + 1};
        int dy[4] = {y0, y1 + 1, y1 + 1, y0};
        int v[4] = {val, val, -val, -val};
        for(int i = 0; i < 4; ++i) {
            core.update(dx[i], dy[i], v[i]);
        }
    }
    int query(const int& x0, const int& y0, const int& x1, const int& y1) {
        int ret = 0;
        int dx[4] = {x0 - 1, x1, x0 - 1, x1};
        int dy[4] = {y0 - 1, y1, y1, y0 - 1};
        int v[4] = {1, 1, -1, -1};
        for(int i = 0; i < 4; ++i) {
            ret += v[i] * core.query(dx[i], dy[i]);
        }
        return ret;
    }
};
BIT_2D<int> bit;

char op[5];
int x[2], y[2], delta;

int main() {
#ifdef ___LOCAL_WONZY___
    freopen("input.txt", "r", stdin);
#endif // ___LOCAL_WONZY___
    IO::begin();
    while(IO::scan_s(op)) {
        if(op[0] == 'X') {
            IO::scan_d(n);
            IO::scan_d(m);
//            a.I(), b.I(), c.I(), d.I();
            continue;
        }
        IO::scan_d(x[0]);
        IO::scan_d(y[0]);
        IO::scan_d(x[1]);
        IO::scan_d(y[1]);
        if(op[0] == 'k') {
            IO::println(bit.query(x[0], y[0], x[1], y[1]));
        } else {
            IO::scan_d(delta);
            bit.update(x[0], y[0], x[1], y[1], delta);
        }
    }
    return 0;
}