hdu 4533

题意：

         给n个矩阵，输入询问q个t(按递增），求在矩阵（0,0） （t，t）覆盖的面积，重叠的也算

算法：

        将每个矩阵分割，可以分割成（x，x）（y，y）矩阵的要特殊处理，其他分割的矩阵放进一个树状数组中，用数组c1和c2处理成段更新的

例如矩阵（3,10）（8，12） 变成一段10到12，每次加5 = （8-3）的大小，而对角上的矩阵（x，x） （y，y）可以变成（0,0）（x,x)  /  (0,x)  (x,y)  / (x,y) (0,x)   

三个矩阵，每次在节点x和y节点处理，节点x是减去x*x和更新树状数组x，y， -2*x，节点y是直接加上 y * y；将（x+1，y） 全部加1

用树状数组维护，具体处理用c3数组

      我用这样的做法就没用到题目条件询问时递增的，我的可以求任意一个时刻的覆盖的面积

代码如下

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>

using namespace std;

#define N 200100
#define M 20010
#define LL long long

LL c[N], c1[N];
inline int lowbit(int x) {
    return x & (-x);
}
void add(int x, LL d) {
    for (; x; x -= lowbit(x))
        c[x] += d;
}
LL sum(int x) {
    LL ret = 0;
    for (; x < N; x += lowbit(x))
        ret += c[x];
    return ret;
}
void add1(int x, LL d) {
    for (; x < N; x += lowbit(x))
        c1[x] += d;
}
LL sum1(int x) {
    LL ret = 0;
    for (; x; x -= lowbit(x))
        ret += c1[x];
    return ret;
}
LL query(int x) {
    return sum1(x) + sum(x) * x;
}

void ad(int a,int b,int d){
    a+=4; b+=3;
    if(a > b || d == 0) return ;
    add(a-2,-d);
    add(b-1,d);
    add1(a-1,1ll*d*(1-a));
    add1(b,1ll*d*b);
}
LL summ[N];
int c3[N];
void add3(int x, int d){
    for(int i = x; i < N; i += lowbit(i))
        c3[i] += d;
}
int sum3(int x){
   int ret = 0;
   for(int i = x; i > 0; i -= lowbit(i))
       ret += c3[i];
   return ret;
}
vector<int> in[N],out[N];
int main() {
//    freopen("in","r",stdin);    
    int T;
    scanf("%d",&T);
    while(T--){
        memset(c,0,sizeof(c));
        memset(c1,0,sizeof(c1));
        memset(c3,0,sizeof(c3));
        memset(summ,0,sizeof(summ));
        for(int i = 0; i < N;  i++){
            in[i].clear();
            out[i].clear();
        }
        int n;
        scanf("%d",&n);
        while(n--){
            int x1, x2, y1, y2;
            scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
            if(x2 <= y1){
                 ad(y1,y2,x2-x1);
            }
            else if(x1 >= y2){
                 ad(x1,x2,y2-y1);
            }
            else {
                if(y1 <= x1) {
                    swap(x1,y1),swap(x2,y2);
                }
                if(y2 <= x2){//y1,y2
                    ad(y1,y2,y1-x1);
                    ad(y2,x2,y2-y1);
                    in[y1].push_back(y2);
                    out[y2].push_back(y1);
                    add3(y1+1,1);
                    add3(y2+1,-1);
                }
                else {//y1,x2
                    ad(y1,x2,y1-x1);
                    ad(x2,y2,x2-x1);
                    in[y1].push_back(x2);
                    out[x2].push_back(y1);
                    add3(y1+1,1);
                    add3(x2+1,-1);

                }
            }
        }
        
        LL tmp = 0;
        for(LL i = 1; i < N; i++){
            LL cn = (LL)sum3(i);
            cn *= i * i;
            summ[i] += query(i+3) + cn + tmp;
            for(int j = 0; j < in[i].size(); j++){
                tmp -= i * i;
                ad(i,in[i][j],-2 * i);
            }
            for(int j = 0; j < out[i].size(); j++){
                tmp = tmp + i * i;
            }
        }
        int q;
        scanf("%d",&q);
        while(q--){
            int t;
            scanf("%d",&t);
            printf("%I64d\n",summ[t]);
        }
    }
    return 0;
}