BZOJ 2683: 简单题

2683: 简单题

Time Limit: 50 Sec  Memory Limit: 128 MB
Submit: 913  Solved: 379
[Submit][Status][Discuss]

Description

你有一个N*N的棋盘，每个格子内有一个整数，初始时的时候全部为0，现在需要维护两种操作：

 

命令	参数限制	内容
1 x y A	1<=x,y<=N，A是正整数	将格子x,y里的数字加上A
2 x1 y1 x2 y2	1<=x1<= x2<=N 1<=y1<= y2<=N	输出x1 y1 x2 y2这个矩形内的数字和
3	无	终止程序

Input

输入文件第一行一个正整数N。

接下来每行一个操作。

 

Output

对于每个2操作，输出一个对应的答案。

 

Sample Input

4
1 2 3 3
2 1 1 3 3
1 2 2 2
2 2 2 3 4
3

Sample Output

3
5

HINT

 

1<=N<=500000,操作数不超过200000个，内存限制20M。

对于100%的数据，操作1中的A不超过2000。

 

Source

 

[Submit][Status][Discuss]

 

分析

离线CDQ分治，对于预处理后的所有操作（查询）按照X坐标排序，然后用树状数组维护Y坐标上的前缀和。

 

代码

#include <bits/stdc++.h>

using namespace std;

const int N = 500005;
const int M = 200005;

template <class T>
__inline void read(T &x)
{
    x = 0; 
    bool f = false;
    char c = getchar();
    
    while (c < '0')
    {
        if (c == '-')
            f ^= true;
        c = getchar();
    }
    
    while (c >= '0')
    {
        x = x*10 + c - '0';
        c = getchar();
    }
    
    if (f)x = -x;
}

struct operation
{
    int id, op, to, x, y, d;
}q[M << 2], tmp[M << 2];

int cmp(const void *a, const void *b)
{
    operation *A = (operation *)a;
    operation *B = (operation *)b;
    
    if (A->x != B->x)
        return A->x - B->x;
    if (A->y != B->y)
        return A->y - B->y;
    return A->op - B->op;
}

int n, m, t;

void pushQuery(void)
{
    int x1; read(x1);
    int y1; read(y1);
    int x2; read(x2);
    int y2; read(y2);
    
    ++t;
    {
        ++m; 
        q[m].d = 1;
        q[m].op = 2;
        q[m].id = m; 
        q[m].to = t; 
        q[m].x = x1 - 1;
        q[m].y = y1 - 1;
    }
    {
        ++m;
        q[m].d = 1;
        q[m].op = 2;
        q[m].id = m;
        q[m].to = t;
        q[m].x = x2;
        q[m].y = y2;
    }
    {
        ++m;
        q[m].d = -1;
        q[m].op = 2;
        q[m].id = m;
        q[m].to = t;
        q[m].y = y2;
        q[m].x = x1 - 1;
    }
    {
        ++m;
        q[m].d = -1;
        q[m].op = 2;
        q[m].id = m;
        q[m].to = t;
        q[m].x = x2;
        q[m].y = y1 - 1;
    }
}

int answer[M];

void printAnswer(void)
{
    for (int i = 1; i <= t; ++i)
        printf("%d\n", answer[i]);
}

namespace binaryInsertTree
{
    int tree[N];
    
    void change(int p, int v)
    {
        for (int i = p; i <= n; i += i & -i)
            tree[i] += v;
    }
    
    int query(int p)
    {
        int ret = 0;
        
        for (int i = p; i >= 1; i -= i & -i)
            ret += tree[i];
        
        return ret;
    }
}

void divideAndConquer(int l, int r)
{
    if (l != r)
    {
        int mid = (l + r) >> 1;
        
        for (int i = l; i <= r; ++i)
        {
            if (q[i].op == 1 && q[i].id <= mid)
                binaryInsertTree::change(q[i].y, q[i].d);
            if (q[i].op == 2 && q[i].id > mid)
                answer[q[i].to] += binaryInsertTree::query(q[i].y) * q[i].d;
        }
        
        for (int i = l; i <= r; ++i)
            if (q[i].op == 1 && q[i].id <= mid)
                binaryInsertTree::change(q[i].y, -q[i].d);
        
        int t1 = l, t2 = mid + 1;
        
        for (int i = l; i <= r; ++i)
        {
            if (q[i].id <= mid)
                tmp[t1++] = q[i];
            else
                tmp[t2++] = q[i];
        }
        
        for (int i = l; i <= r; ++i)
            q[i] = tmp[i];
            
        divideAndConquer(l, mid);
        divideAndConquer(mid + 1, r);
    }
}

signed main(void)
{
    read(n);
    
    for (m = t = 0; ; )
    {
        int opt; read(opt);
        
        if (opt == 3)break;
        
        switch (opt)
        {
            case 1 :
                ++m;
                q[m].op = 1;
                q[m].id = m;
                read(q[m].x);
                read(q[m].y);
                read(q[m].d);
                break;
            case 2 :
                pushQuery();
        }
    }
    
    qsort(q + 1, m, sizeof(operation), cmp);
    
    divideAndConquer(1, m);
    
    printAnswer();
}

 

@Author: YouSiki