51nod 1213 二维曼哈顿距离最小生成树 树状数组+最小生成树

Description

---

二维平面上有N个坐标为整数的点，点x1 y1同点x2 y2之间的距离为：横纵坐标的差的绝对值之和，即：Abs(x1 - x2) + Abs(y1 - y2)（也称曼哈顿距离）。求这N个点所组成的完全图的最小生成树的边权之和。

2 <= N <= 50000
坐标 0 <= x, y <= 1000000

输出N个点所组成的完全图的最小生成树的边权之和。

Solution

---

名字好长(＃°Д°)
这似乎就是莫队复杂度的证明，但是莫队的做法不能得到最优解

图片来自这里

然后就可以用数据结构优化建图跑kruskal

对于建图的部分，我们只需要考虑由直线y=x和y轴的正半轴形成的区域内与当前点的关系。若点j是此区域内与点i最近的点则有
1. yj-xj>yi-xi
2. xj>xi
这是一个二维偏序问题，排序+树状数组搞搞就行
可以通过翻转xy、翻转x坐标、再翻转xy来把其他位置翻过来。注意到连边实际上是对称的，因此可以只做四次

之所以我们不选择直线y=x与x轴正半轴形成的区域，是因为这样做出来的直线需要考虑斜率为负数的情况，非常的麻烦。我一开始想当然地写了这个然后就wa了

Code

---

#include <stdio.h>
#include <string.h>
#include <algorithm>
#define rep(i,st,ed) for (int i=st;i<=ed;++i)
#define drp(i,st,ed) for (int i=st;i>=ed;--i)
#define fill(x,t) memset(x,t,sizeof(x))
#define lowbit(x) ((x)&(-(x)))

const int INF=0x3f3f3f3f;
const int N=100005;

struct edge {int x,y,w;} e[N*4];
struct pos {int x,y,id;} p[N];

int b[N],c[N],d[N],fa[N],n,size,edCnt;

int read() {
    int x=0,v=1; char ch=getchar();
    for (;ch<'0'||ch>'9';v=(ch=='-')?(-1):(v),ch=getchar());
    for (;ch<='9'&&ch>='0';x=x*10+ch-'0',ch=getchar());
    return x*v;
}

void add_edge(int x,int y,int w) {
    e[++edCnt]=(edge) {x,y,w};
    // printf("%d %d %d\n", x,y,w);
}

int get_dis(pos x,pos y) {
    return abs(x.x-y.x)+abs(x.y-y.y);
}

int find(int x) {
    if (!fa[x]) return x;
    return fa[x]=find(fa[x]);
}

bool cmpE(edge a,edge b) {
    return a.w<b.w;
}

void MST() {
    int ans=0,cnt=0;
    std:: sort(e+1,e+edCnt+1,cmpE);
    rep(i,1,edCnt) {
        int fx=find(e[i].x),fy=find(e[i].y);
        if (fx!=fy) {
            fa[fx]=fy; cnt++;
            ans+=e[i].w;
            // printf("%d %d %d\n", e[i].x,e[i].y,e[i].w);
        }
        if (cnt==n-1) break;
    }
    printf("%d\n", ans);
}

bool cmp(pos a,pos b) {
    return a.x<b.x||a.x==b.x&&a.y<b.y;
}

int query(int x) {
    int ret=0,min=INF;
    for (;x<=size;x+=lowbit(x)) {
        if (c[x]<min) {
            min=c[x]; ret=d[x];
        }
    }
    return ret;
}

void modify(int x,int v,int pos) {
    for (;x;x-=lowbit(x)) {
        if (v<c[x]) {
            c[x]=v; d[x]=pos;
        }
    }
}

void build() {
    b[0]=0; rep(i,1,n) b[++b[0]]=p[i].y-p[i].x;
    std:: sort(p+1,p+n+1,cmp);
    std:: sort(b+1,b+b[0]+1);
    size=std:: unique(b+1,b+b[0]+1)-b-1;
    rep(i,0,size) {c[i]=INF; d[i]=0;};
    drp(i,n,1) {
        int pos=std:: lower_bound(b+1,b+size+1,p[i].y-p[i].x)-b;
        int ret=query(pos);
        if (ret) add_edge(p[ret].id,p[i].id,get_dis(p[i],p[ret]));
        modify(pos,p[i].x+p[i].y,i);
    }
}

int main(void) {
    n=read();
    rep(i,1,n) p[i]=(pos) {read(),read(),i};
    build();
    rep(i,1,n) std:: swap(p[i].x,p[i].y);
    build();
    rep(i,1,n) p[i].x=-p[i].x;
    build();
    rep(i,1,n) std:: swap(p[i].x,p[i].y);
    build();
    MST();
    return 0;
}