【LG2154】[SDOI2009]虔诚的墓主人

题面

洛谷

题解

可以发现，对于某一个点，它的答案就是上下左右几个组合数乘起来。
这样直接做复杂度显然爆炸，考虑怎么优化这个东西。

我们可以固定左右，在某两个左右之间维护上下有多少个，这样子的话左右的贡献就是不变的，而且你最多只会变化\(O(n)\)次左右边界，复杂度有保证。

这样的话，每次查询一个左右边界内上下的贡献，用线段树维护即可。(描述可能有些模糊，具体详见代码)

代码

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;
inline int gi() {
    register int data = 0, w = 1;
    register char ch = 0;
    while (!isdigit(ch) && ch != '-') ch = getchar();
    if (ch == '-') w = -1, ch = getchar();
    while (isdigit(ch)) data = 10 * data + ch - '0', ch = getchar();
    return w * data;
}
const int MAX_N = 1e5 + 5;
#define lson (o << 1)
#define rson (o << 1 | 1)
int sum[MAX_N << 2];
void modify(int o, int l, int r, int pos, int v) {
    if (l == r) return (void)(sum[o] = v);
    int mid = (l + r) >> 1;
    if (pos <= mid) modify(lson, l, mid, pos, v);
    else modify(rson, mid + 1, r, pos, v);
    sum[o] = sum[lson] + sum[rson];
}
int query(int o, int l, int r, int ql, int qr) {
    if (ql <= l && r <= qr) return sum[o];
    int mid = (l + r) >> 1, res = 0;
    if (ql <= mid) res += query(lson, l, mid, ql, qr);
    if (qr > mid) res += query(rson, mid + 1, r, ql, qr);
    return res;
}
int W, H, N, K;
int x[MAX_N], y[MAX_N], ox[MAX_N], oy[MAX_N], tx, ty;
vector<int> vec[MAX_N];
int C[MAX_N][15], c1[MAX_N], c2[MAX_N];
bool cmp(const int &l, const int &r) { return y[l] < y[r]; }
int main () {
#ifndef ONLINE_JUDGE
    freopen("cpp.in", "r", stdin);
#endif
    W = gi(), H = gi(), N = gi();
    for (int i = 1; i <= N; i++) x[i] = ox[i] = gi(), y[i] = oy[i] = gi();
    K = gi();
    sort(&ox[1], &ox[N + 1]), sort(&oy[1], &oy[N + 1]);
    tx = unique(&ox[1], &ox[N + 1]) - ox - 1;
    ty = unique(&oy[1], &oy[N + 1]) - oy - 1;
    for (int i = 1; i <= N; i++) {
        x[i] = lower_bound(&ox[1], &ox[tx + 1], x[i]) - ox;
        y[i] = lower_bound(&oy[1], &oy[ty + 1], y[i]) - oy;
    }
    for (int i = 1; i <= N; i++) vec[x[i]].push_back(i), c1[y[i]]++;
    for (int i = 1; i <= tx; i++) vec[i].push_back(N + 1);
    y[N + 1] = ty + 1;
    for (int i = 1; i <= tx; i++) sort(vec[i].begin(), vec[i].end(), cmp);
    for (int i = 0; i <= N; i++) C[i][0] = 1;
    for (int i = 1; i <= N; i++)
        for (int j = 1; j <= min(i, K); j++)
            C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
    int ans = 0;
    for (int i = 1; i <= tx; i++) {
        int res = 0, sz = vec[i].size();
        for (int j = 0; j < sz; j++) {
            int l = j ? y[vec[i][j - 1]] : 0, r = y[vec[i][j]];
            if (l + 1 <= r - 1) ans += res * query(1, 1, ty, l + 1, r - 1);
            if (j == sz - 1) break;
            res = C[j + 1][K] * C[sz - j - 2][K];
            ++c2[r];
            modify(1, 1, ty, r, C[c2[r]][K] * C[c1[r] - c2[r]][K]);
        }
    }
    if (ans < 0) ans += 2147483648ll;
    printf("%d\n", ans);
    return 0;
}