CF1140F

题意：对于点集S，定义函数F(S)为对S不断扩展到不能扩展时S的点数。一次扩展定义为如果有一个平行于坐标轴的矩形的三个点在S中，则第四个点加入S。

动态在S中加点删点，每次操作完后求F(S)的值。

解：首先有个结论就是，把这些点用平行于坐标轴的线段连接起来，则E值为每个连通块的横坐标种数 * 纵坐标种数之和。

线段树分治 + 可回退化并查集，O(nlog²n)。

#include <bits/stdc++.h>

typedef long long LL;
const int N = 300010;

struct Node {
    int x, y;
    Node(int X, int Y) {
        x = X;
        y = Y;
    }
};

std::map<int, int> mp[N];
int n, m;
LL ans[N];
std::vector<Node> v[N << 2];

namespace ufs {
    
    struct opt {
        int x, y;
        opt(){}
        opt(int X, int Y) {
            x = X, y = Y;
        }
    }stk[N * 4]; int top;
    
    int fa[N * 2], siz[N * 2], s1[N * 2], s2[N * 2], clock;
    LL tot, stk2[N];
    inline void init() {
        for(int i = 1; i < N; i++) {
            fa[i] = i;
            fa[i + N] = i + N;
            siz[i] = siz[i + N] = 1;
            s1[i] = s2[i + N] = 1;
            s2[i] = s1[i + N] = 0;
        }
        top = clock = 0;
        return;
    }
    int find(int x) {
        if(x == fa[x]) return x;
        return find(fa[x]);
    }
    inline LL cal(int x) {
        return 1ll * s1[x] * s2[x];
    }
    inline void merge(int x, int y) {
        x = find(x);
        y = find(y);
        if(x == y) return;
        if(siz[x] < siz[y]) {
            std::swap(x, y);
        }
        stk2[++clock] = tot;
        tot -= cal(x) + cal(y);
        stk[++top] = opt(y, fa[y]);
        fa[y] = x;
        stk[++top] = opt(x, siz[x]);
        siz[x] += siz[y];
        stk[++top] = opt(x, s1[x]);
        s1[x] += s1[y];
        stk[++top] = opt(x, s2[x]);
        s2[x] += s2[y];
        tot += cal(x);
        return;
    }
    inline void erase(int t) {
        while(clock > t) {
            tot = stk2[clock--];
            s2[stk[top].x] = stk[top].y;
            top--;
            s1[stk[top].x] = stk[top].y;
            top--;
            siz[stk[top].x] = stk[top].y;
            top--;
            fa[stk[top].x] = stk[top].y;
            top--;
        }
        return;
    }
}

void add(int L, int R, Node x, int l, int r, int o) {
    if(L <= l && r <= R) {
        v[o].push_back(x);
        return;
    }
    int mid = (l + r) >> 1;
    if(L <= mid) {
        add(L, R, x, l, mid, o << 1);
    }
    if(mid < R) {
        add(L, R, x, mid + 1, r, o << 1 | 1);
    }
    return;
}

void solve(int l, int r, int o) {
    int now = ufs::clock;
    for(int i = 0; i < (int)v[o].size(); i++) {
        ufs::merge(v[o][i].x, v[o][i].y + N);
        //printf("[%d %d] merge %d %d 
", l, r, v[o][i].x, v[o][i].y);
    }
    if(l == r) {
        ans[r] = ufs::tot;
        ufs::erase(now);
        return;
    }
    int mid = (l + r) >> 1;
    solve(l, mid, o << 1);
    solve(mid + 1, r, o << 1 | 1);
    ufs::erase(now);
    return;
}

int main() {
    ufs::init();
    scanf("%d", &n);
    for(int i = 1, x, y; i <= n; i++) {
        scanf("%d%d", &x, &y);
        if(mp[x][y]) {
            add(mp[x][y], i - 1, Node(x, y), 1, n, 1);
            //printf("add : (%d %d) [%d %d] 
", x, y, mp[x][y], i - 1);
            mp[x][y] = 0;
        }
        else {
            mp[x][y] = i;
        }
    }
    std::map<int, int>::iterator it;
    for(int i = 1; i < N; i++) {
        for(it = mp[i].begin(); it != mp[i].end(); it++) {
            if(it->second) {
                add(it->second, n, Node(i, it->first), 1, n, 1);
                //printf("add : (%d %d) [%d %d] 
", i, it->first, it->second, n);
            }
        }
    }
    
    solve(1, n, 1);
    for(int i = 1; i <= n; i++) {
        printf("%lld ", ans[i]);
    }
    return 0;
}