bzoj1604

treap+并查集

我们能想到一个点和最近点对连接，用并查集维护，但是这个不仅不能求，而且还是不对的，于是就看了题解

把距离转为A(x-y,x+y),这样两点之间的距离就是max(x'-X',y'-Y'),那么就可以求了，我们按转换后的x排序，维护一个区间，最大的x和最小的x差不超过c，然后把y插进treap里，每次查找前驱后继，如果距离小于等于c就连接，最后扫一遍统计答案就行

曼哈顿和切比雪夫距离是可以互相转换的，x=x-y,y=x+y就行,切比雪夫距离转换为曼哈顿距离转换回去也可以

#include<bits/stdc++.h>
using namespace std;
const int N = , seed = , inf = ;
struct data {
    int x, y;
    data(int x = , int y = ) : x(x), y(y) {}
    bool friend operator < (data A, data B) { return A.x < B.x; }
} a[N];
int n, ans, root;
long long c;
pair<int, int> pre, nxt;
int sum[N], fa[N];
struct Treap {
    int cnt, P;
    pair<int, int> key[N];
    int size[N], child[N][], p[N], tot[N];
    inline int rand() { P = P * seed + ; return abs(P); }
    inline void update(int x) { size[x] = size[child[x][]] + size[child[x][]] + tot[x]; }
    inline void rotate(int &x, int t)
    {
        int y = child[x][t];
        child[x][t] = child[y][t ^ ];
        child[y][t ^ ] = x;
        update(x); update(y); x = y;
    }
    inline void insert(int &x, pair<int, int> o)
    {
        if(x == ) { p[x = ++cnt] = rand(); key[x] = o; tot[x] = ; }
        else
        {
            if(key[x] == o) ++tot[x];
            else { int t = o > key[x]; insert(child[x][t], o); if(p[child[x][t]] > p[x]) rotate(x, t); }
        }
        update(x);
    }
    inline void erase(int &x, pair<int, int> o)
    {
        if(key[x] == o)
        {
            if(child[x][] ==  && child[x][] == ) { --tot[x]; if(tot[x] == ) x = ; else update(x); }
            else { int t = p[child[x][]] > p[child[x][]]; rotate(x, t); erase(child[x][t ^ ], o); }
        }
        else erase(child[x][o > key[x]], o);
        update(x);
    }
    inline void query_pre(int x, pair<int, int> o)
    {
        if(x == ) return;
        if(key[x] > o) query_pre(child[x][], o);
        else { if(key[x] > pre) pre = key[x]; query_pre(child[x][], o); }
    }
    inline void query_nxt(int x, pair<int, int> o)
    {
        if(x == ) return;
        if(key[x] < o) query_nxt(child[x][], o);
        else { if(key[x] < nxt) nxt = key[x]; query_nxt(child[x][], o); }
    }
} treap;
inline int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
inline void connect(int x, int y)
{
    int u = find(x), v = find(y);
    if(u == v) return;
    --ans;
    fa[v] = u;
}
int main()
{
//    freopen("nabor.in", "r", stdin);
//    freopen("nabor.out", "w", stdout);
    scanf("%d%lld", &n, &c);
    ans = n;
    for(int i = ; i <= n; ++i)
    {
        int x, y;
        scanf("%d%d", &x, &y);
        a[i] = data(x - y, x + y);
    }
    a[].x = inf;
    sort(a + , a + n + );
    treap.insert(root, {-inf, -});
    treap.insert(root, {inf, -});
    for(int i = ; i <= n; ++i) fa[i] = i;
    int l = ;
    for(int i = ; i <= n; ++i)
    {
        pair<int, int> o;
        while(l <= i && a[i].x - a[l].x > c)
        {
            o = make_pair(a[l].y, l);
            treap.erase(root, o);
            ++l;
        }
        nxt = {inf + , -};
        pre = {-inf - , -};
        o = make_pair(a[i].y, i);
        treap.query_pre(root, o);
        treap.query_nxt(root, o);
        long long dis_pre, dis_nxt;
        treap.insert(root, o);
        dis_pre = (long long)a[i].y - (long long)pre.first;
        dis_nxt = (long long)nxt.first - (long long)a[i].y;
        if(dis_pre <= c && pre.second != -) connect(i, pre.second);
        if(dis_nxt <= c && nxt.second != -) connect(i, nxt.second);
    }
    printf("%d ", ans);
    ans = ;
    for(int i = ; i <= n; ++i) ++sum[find(i)];
    for(int i = ; i <= n; ++i) ans = max(ans, sum[i]);
    printf("%d\n", ans);
//    fclose(stdin);
//    fclose(stdout);
    return ;
}