NOI 2012 魔幻棋盘 | 二维差分 + 二维线段树

题目：luogu 2086

二维线段树，按套路差分原矩阵，gcd( x₁, x₂, ……, x_n ) = gcd( x_i , x₂ - x₁ , ……, x_n - x_n-1 )，必须要有一个原数 x_i，恰好每次询问都包含一个固定点 ( X , Y )，差分以它为中心就可以保证它是原值。以 e 为中心的二维差分如图。

对于一维序列，修改区间 [ l , r ] 只需修改差分后的 l 和 r + 1 两点。那么对于二维，差分后的修改如下所示：

中间的灰色格子为守卫者所在地（为方便表示多个区域把它拆成了 9 格），以它为差分中心，若修改矩阵在它的右下方，即黄色区域，设它的左上角坐标为 ( x1, y1)，右下角坐标 ( x2, y2 )，则需在 ( x1, y1 ) 处 + c，( x1, y2+1 ) 处 - c，( x2+1, y1 ) 处 - c，( x2 + 1, y2 + 1) 处 +c。

其他区域同理。再加上守卫者正上方、正下方、正左方、正右方的区域，一共 8 种情况。如果一个修改矩阵包含多个区域，就将其划分为若干个子矩阵处理。

这样就将巨慢的区间修改转换成了单点修改，每修改完一个点，pushup( ) 维护 gcd 即可。

另外读入的时候，500000 * 500000 的二维数组是开不了的，需要动态分配内存；或者开一个 500000 的一维数组读入，判断每一行的末端在哪里。

讨论的时候有些麻烦，下面列一下大致的情况：（黄色表示修改的区域，绿色加， 红色减）

仔细观察后，发现可分为三种情况：① 包含守卫者 ( X , Y )；② 包含 X 行或 Y 列；③ 只包含左上或左下、右上或右下区域。

细节诸多：

差分的时候不能用原数组减，因为前面的值会变，需要另开一个数组保存；

返回 gcd 的时候要取绝对值；二维线段树内层空间要开大。

 #include <cstdio>
 #include <string>

 const int N = ;
 typedef long long ll;

 int n, m; ll a[N], b[N];

 ll read() {
     ll x = , f = ;
     char c = getchar();
     while (!isdigit(c)) {
         if (c == '-') f = -;
         c = getchar();
     }
     while (isdigit(c)) {
         x = (x << ) + (x << ) + (c ^ );
         c = getchar();
     }
     return x * f;
 }

 ll abs(ll x) {
     if (x >= ) return x; return -x;
 }

 ll gcd(ll x, ll y) {
     if (y) return gcd(y, x % y); return abs(x);
 }

 struct inNode {
     ll val;
     inNode *ls, *rs;
     inNode() : val(), ls(NULL), rs(NULL) {}
 } inPool[N << ];

 inNode *newInNode () {
     static int cnt = ;
     return &inPool[++cnt];
 }

 void buildY(inNode *&cur, int l, int r, int x) {
     if (!cur) cur = newInNode();
     if (l == r) cur->val = a[(x - ) * m + l];
     else {
         int mid = l + ((r - l) >> );
         buildY(cur->ls, l, mid, x);
         buildY(cur->rs, mid + , r, x);
         cur->val = gcd(cur->ls->val, cur->rs->val);
     }
 }

 void updateY(inNode *&cur, int l, int r, int y, ll val) {
     if (l == r) cur->val += val;
     else {
         int mid = l + ((r - l) >> );
         if (y <= mid) updateY(cur->ls, l, mid, y, val);
         else updateY(cur->rs, mid + , r, y, val);
         cur->val = gcd(cur->ls ? cur->ls->val : , cur->rs ? cur->rs->val : );
     }
 }

 ll queryY(inNode *&cur, int l, int r, int y1, int y2) {
     if (y1 <= l && r <= y2) return cur->val;
     int mid = l + ((r - l) >> ); ll res = ;
     if (y1 <= mid) res = gcd(res, queryY(cur->ls, l, mid, y1, y2));
     if (mid < y2) res = gcd(res, queryY(cur->rs, mid + , r, y1, y2));
     return res;
 }

 struct outNode {
     inNode *root;
     outNode *ls, *rs;
     outNode() : root(NULL), ls(NULL), rs(NULL) {}
 } outPool[N << ], *root;

 outNode *newOutNode() {
     static int cnt = ;
     return &outPool[++cnt];
 }

 void maintain(inNode *&cur, inNode *&lc, inNode *&rc, int l, int r) {
     if (!cur) cur = newInNode();
     if (l == r) cur->val = gcd(lc->val, rc->val);
     else {
         int mid = l + ((r - l) >> );
         maintain(cur->ls, lc->ls, rc->ls, l, mid);
         maintain(cur->rs, lc->rs, rc->rs, mid + , r);
         cur->val = gcd(cur->ls->val ,cur->rs->val);
     }
 }

 void buildX(outNode *&cur, int l, int r) {
     if (!cur) cur = newOutNode();
     if (l == r) buildY(cur->root, , m, l);
     else {
         int mid = l + ((r - l) >> );
         buildX(cur->ls, l, mid);
         buildX(cur->rs, mid + , r);
         maintain(cur->root, cur->ls->root, cur->rs->root, , m);
     }
 }

 void change(inNode *&cur, int l, int r, int y, ll val) {
     if (l == r) cur->val = val;
     else {
         int mid = l + ((r - l) >> );
         if (y <= mid) change(cur->ls, l, mid, y, val);
         else change(cur->rs, mid + , r, y, val);
         cur->val = gcd(cur->ls ? cur->ls->val : , cur->rs ? cur->rs->val : );
     }
 }

 void updateX(outNode *&cur, int l, int r, int x, int y, ll val) {
     if (x <=  || y <=  || x > n || y > m) return;
     if (l == r) updateY(cur->root, , m, y, val);
     else {
         int mid = l + ((r - l) >> ); ll lv = , rv = ;
         if (x <= mid) updateX(cur->ls, l, mid, x, y, val);
         else updateX(cur->rs, mid + , r, x, y, val);
         if (cur->ls) lv = queryY(cur->ls->root, , m, y, y);
         if (cur->rs) rv = queryY(cur->rs->root, , m, y, y);
         change(cur->root, , m, y, gcd(lv, rv));
     }
 }

 ll queryX(outNode *&cur, int l, int r, int x1, int x2, int y1, int y2) {
     if (x1 <= l && r <= x2) return queryY(cur->root, , m, y1, y2);
     int mid = l + ((r - l) >> ); ll res = ;
     if (x1 <= mid) res = gcd(res, queryX(cur->ls, l, mid, x1, x2, y1, y2));
     if (mid < x2) res = gcd(res, queryX(cur->rs, mid + , r, x1, x2, y1, y2));
     return res;
 }

 int main() {
     n = read(), m = read();    int X = read(), Y = read(), T = read();
     for (int i = ; i <= n * m; ++ i) a[i] = read();
     for (int i = ; i <= n * m; ++ i) {
         if ((i - ) % m +  < Y) b[i] = a[i] - a[i + ];
         else if ((i - ) % m +  > Y) b[i] = a[i] - a[i - ];
         else b[i] = a[i];
     }
     for (int i = ; i <= n * m; ++ i) {
         if ((i - ) / m +  < X) a[i] = b[i] - b[i + m];
         else if ((i - ) / m +  > X) a[i] = b[i] - b[i - m];
         else a[i] = b[i];
     }
     buildX(root, , n);
     while (T--) {
         int opt = read(), x1 = read(), y1 = read(), x2 = read(), y2 = read();
         if (opt == ) {
             x1 = X - x1, x2 = X + x2, y1 = Y - y1, y2 = Y + y2;
             printf("%lld\n", queryX(root, , n, x1, x2, y1, y2));
         } else {
             ll val = read();
             if (x1 <= X && x2 >= X && y1 <= Y && y2 >= Y) {    //包含(X,Y)
                 updateX(root, , n, X, Y, val);
                 updateX(root, , n, x1 - , y1 - , val);
                 updateX(root, , n, x1 - , y2 + , val);
                 updateX(root, , n, x2 + , y1 - , val);
                 updateX(root, , n, x2 + , y2 + , val);
                 updateX(root, , n, x1 - , Y, -val);
                 updateX(root, , n, x2 + , Y, -val);
                 updateX(root, , n, X, y1 - , -val);
                 updateX(root, , n, X, y2 + , -val);
             } else if (y1 <= Y && y2 >= Y) {                //包含Y列
                 if (x1 < X) {                                //在(X,Y)上方
                     updateX(root, , n, x2, Y, val);
                     updateX(root, , n, x1 - , y1 - , val);
                     updateX(root, , n, x1 - , y2 + , val);
                     updateX(root, , n, x1 - , Y, -val);
                     updateX(root, , n, x2, y1 - , -val);
                     updateX(root, , n, x2, y2 + , -val);
                 } else {                                    //在(X,Y)下方
                     updateX(root, , n, x1, Y, val);
                     updateX(root, , n, x2 + , y1 - , val);
                     updateX(root, , n, x2 + , y2 + , val);
                     updateX(root, , n, x2 + , Y, -val);
                     updateX(root, , n, x1, y1 - , -val);
                     updateX(root, , n, x1, y2 + , -val);
                 }
             } else if (x1 <= X && x2 >= X) {                //包含X行
                 if (y1 < Y) {                                //在(X,Y)左边
                     updateX(root, , n, X, y2, val);
                     updateX(root, , n, x1 - , y1 - , val);
                     updateX(root, , n, x2 + , y1 - , val);
                     updateX(root, , n, X, y1 - , -val);
                     updateX(root, , n, x1 - , y2, -val);
                     updateX(root, , n, x2 + , y2, -val);
                 } else {                                    //在(X,Y)右边
                     updateX(root, , n, X, y1, val);
                     updateX(root, , n, x1 - , y2 + , val);
                     updateX(root, , n, x2 + , y2 + , val);
                     updateX(root, , n, X, y2 + , -val);
                     updateX(root, , n, x1 - , y1, -val);
                     updateX(root, , n, x2 + , y1, -val);
                 }
             } else if (x1 < X && y1 < Y) {                    //左上区域
                 updateX(root, , n, x2, y2, val);
                 updateX(root, , n, x1 - , y1 - , val);
                 updateX(root, , n, x1 - , y2, -val);
                 updateX(root, , n, x2, y1 - , -val);
             } else if (x1 < X && y1 > Y) {                    //右上区域
                 updateX(root, , n, x2, y1, val);
                 updateX(root, , n, x1 - , y2 + , val);
                 updateX(root, , n, x1 - , y1, -val);
                 updateX(root, , n, x2, y2 + , -val);
             } else if (x1 > X && y1 < Y) {                    //左下区域
                 updateX(root, , n, x1, y2, val);
                 updateX(root, , n, x2 + , y1 - , val);
                 updateX(root, , n, x1, y1 - , -val);
                 updateX(root, , n, x2 + , y2, -val);
             } else {                                        //右下区域
                 updateX(root, , n, x1, y1, val);
                 updateX(root, , n, x2 + , y2 + , val);
                 updateX(root, , n, x1, y2 + , -val);
                 updateX(root, , n, x2 + , y1, -val);
             }
         }
     }
     return ;
 }