BZOJ1227 [SDOI2009]虔诚的墓主人 【树状数组】

题目

小W 是一片新造公墓的管理人。公墓可以看成一块N×M 的矩形，矩形的每个格点，要么种着一棵常青树，要么是一块还没有归属的墓地。当地的居民都是非常虔诚的基督徒，他们愿意提前为自己找一块合适墓地。为了体现自己对主的真诚，他们希望自己的墓地拥有着较高的虔诚度。一块墓地的虔诚度是指以这块墓地为中心的十字架的数目。一个十字架可以看成中间是墓地，墓地的正上、正下、正左、正右都有恰好k 棵常青树。小W 希望知道他所管理的这片公墓中所有墓地的虔诚度总和是多少

输入格式

第一行包含两个用空格分隔的正整数N 和M，表示公墓的宽和长，因此这个矩形公墓共有(N+1) ×(M+1)个格点，左下角的坐标为(0, 0)，右上角的坐标为(N, M)。第二行包含一个正整数W，表示公墓中常青树的个数。第三行起共W 行，每行包含两个用空格分隔的非负整数xi和yi，表示一棵常青树的坐标。输入保证没有两棵常青树拥有相同的坐标。最后一行包含一个正整数k，意义如题目所示。

输出格式

包含一个非负整数，表示这片公墓中所有墓地的虔诚度总和。为了方便起见，答案对2,147,483,648 取模。

输入样例

5 6

13

0 2

0 3

1 2

1 3

2 0

2 1

2 4

2 5

2 6

3 2

3 3

4 3

5 2

2

输出样例

6

提示

图中，以墓地(2, 2)和(2, 3)为中心的十字架各有3个，即它们的虔诚度均为3。其他墓地的虔诚度为0。

所有数据满足1 ≤ N, M ≤ 1,000,000,000，0 ≤ xi ≤ N，0 ≤ yi ≤ M，1 ≤ W ≤ 100,000， 1 ≤ k ≤ 10。存在50%的数据，满足1 ≤ k ≤ 2。存在25%的数据，满足1 ≤ W ≤ 10000。

注意：”恰好有k颗树“，这里的恰好不是有且只有，而是从>=k的树中恰好选k棵

题解

题目中的模数等于\(2^31\)，所以int自然溢出就相当于取模

我们记一个点上下左右的树数量为u、d、l、r，则每个点的贡献是\(C_{u}^{k} * C_{d}^{k} * C_{l}^{k} * C_{r}^{k}\)

点的范围很大，我们将其离散化到100000以内

但总共\(W^2\)个点，不能直接算，但树只有\(W\)个，考虑从树出发

我们将所有树排序后，对于横坐标相同的两棵树之间的点，其式子中的\(C_{u}^{k} * C_{d}^{k}\)是一样的

我们用树状数组维护\(C_{l}^{k} * C_{r}^{k}\)，就可以加速运算了

#include<iostream>
#include<cstdio>
#include<algorithm>
#define lbt(x) (x & -x)
using namespace std;
const int maxn = 100005,maxm = 100005,INF = 1000000000;
inline int read(){
    int out = 0,flag = 1; char c = getchar();
    while (c < 48 || c > 57) {if (c == '-') flag = -1; c = getchar();}
    while (c >= 48 && c <= 57) {out = (out << 3) + (out << 1) + c - '0'; c = getchar();}
    return out * flag;
}
int s[maxn],C[maxn][11],b[maxn],tot,n,k;
int U[maxn],D[maxn],L[maxn],R[maxn],V[maxn];
struct point{int x,y;}p[maxn];
int getn(int x){return lower_bound(b + 1,b + 1 + tot,x) - b;}
inline bool operator <(const point& a,const point& b){
    return a.x == b.x ? a.y < b.y : a.x < b.x;
}
void add(int u,int v){while (u <= tot) s[u] += v,u += lbt(u);}
void mus(int u,int v){while (u <= tot) s[u] -= v,u += lbt(u);}
int query(int u){int ans = 0; while (u) ans += s[u],u -= lbt(u); return ans;}
int sum(int l,int r){return query(r) - query(l - 1);}
void cal(){
    for (int i = 0; i <= n; i++){
        C[i][0] = C[i][i] = 1;
        for (int j = 1; j <= i && j <= 10; j++)
            C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
    }
}
void init(){
    read(); read();
    n = read();
    cal();
    for (int i = 1; i <= n; i++)
        b[i] = p[i].x = read(),p[i].y = read();
    sort(b + 1,b + 1 + n); tot = 1;
    for (int i = 2; i <= n; i++) if (b[i] != b[tot]) b[++tot] = b[i];
    for (int i = 1; i <= n; i++) p[i].x = getn(p[i].x);
    for (int i = 1; i <= n; i++) b[i] = p[i].y;
    sort(b + 1,b + 1 + n); tot = 1;
    for (int i = 2; i <= n; i++) if (b[i] != b[tot]) b[++tot] = b[i];
    for (int i = 1; i <= n; i++) p[i].y = getn(p[i].y);
    k = read();
}
void solve(){
    sort(p + 1,p + 1 + n);
    int ans = 0;
    for (int i = 1; i <= n; i++) U[p[i].x]++,R[p[i].y]++;
    for (int i = 1; i <= n; i++){
        if (i > 1 && p[i - 1].x == p[i].x && p[i - 1].y + 1 < p[i].y)
            ans += C[U[p[i].x]][k] * C[D[p[i].x]][k] * sum(p[i - 1].y + 1,p[i].y - 1);
        U[p[i].x]--; D[p[i].x]++;
        R[p[i].y]--; L[p[i].y]++;
        add(p[i].y,-V[p[i].y]);
        add(p[i].y,V[p[i].y] = C[L[p[i].y]][k] * C[R[p[i].y]][k]);
    }
    cout << (ans >= 0 ? ans : ans + 2147483647 + 1) << endl;
}
int main(){
    init();
    solve();
    return 0;
}