【BZOJ-2177】曼哈顿最小生成树 Kruskal + 树状数组

2177: 曼哈顿最小生成树

Time Limit: 10 Sec Memory Limit: 259 MB
Submit: 190 Solved: 77
[Submit][Status][Discuss]

Description

平面坐标系xOy内，给定n个顶点V = (x , y)。对于顶点u、v，u与v之间的距离d定义为|xu – xv| + |yu – yv| 你的任务就是求出这n个顶点的最小生成树。

Input

第一行一个正整数n，表示定点个数。
接下来n行每行两个正整数x、y，描述一个顶点。

Output

只有一行，为最小生成树的边的距离和。

Sample Input

4

1 0

0 1

0 -1

-1 0

Sample Output

6

HINT

对于100%的数据n <= 50000；
0 <= x, y <= 100000。

Source

Solution

曼哈顿距离最小生成树裸题

那么来说一下曼哈顿距离最小生成树

首先给出$N$个点，求普通的最小生成树，Kruskal的时间复杂度是$O(MlogN)$，显然$M$的级别是$N^{2}$的，但曼哈顿距离最小生成树能做到$O(NlogN)$

先考虑最小生成树的一个性质：如果图中存在一个环，那么把环上最大边删掉，得到的与不删环的MST权和是一样的

利用这个性质，我们构建边的时候，就能大大减少边的数量

考虑现在在一个点$S$,可以从这个点为中心，把平面分成8份



然后我们发现，在一个象限中，点$S$至多和一个点相连的边是有用的。

先说一个自己的理解但不是很详尽的证明；



我们考虑，如果全都连边，大概是这样的情况，但是我们发现，$|AC|<|AB| && |CB|<|AB|$

那么考虑环切定理，这样，边AB是可以删去的，所以很容易理解每个点只需要连象限中离他最近的点即可

Code

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
int read()
{
int x=0,f=1; char ch=getchar();
while (ch<'0' || ch>'9') {if (ch=='-') f=-1; ch=getchar();}
while (ch>='0' && ch<='9') {x=x*10+ch-'0'; ch=getchar();}
return x*f;
}
#define MAXN 100010
int N;
struct PointNode{int x,y,id;}P[MAXN];
bool cmpP(PointNode A,PointNode B) {return A.x!=B.x? A.x<B.x : A.y<B.y;}
struct UnionFind
{
int Fa[MAXN];
void Init() {for (int i=1; i<=N; i++) Fa[i]=i;}
int Find(int x) {if (Fa[x]==x) return x; else return Fa[x]=Find(Fa[x]);}
bool Merge(int x,int y) {int f1=Find(x),f2=Find(y); if (f1==f2) return 0; Fa[f1]=f2; return 1;}
}uf;
int Dis(PointNode A,PointNode B) {return abs(A.x-B.x)+abs(A.y-B.y);}
struct EdgeNode{int to,val,from;}edge[MAXN<<2];
int cnt;
void AddEdge(int u,int v,int w) {cnt++; edge[cnt].from=u; edge[cnt].to=v; edge[cnt].val=w;}
bool cmpE(EdgeNode A,EdgeNode B) {return A.val<B.val;}
int lowbit(int x) {return x&-x;}
struct BITNode{int minn,pos; void init() {minn=0x7fffffff; pos=-1;}}bit[MAXN];
void Update(int x,int val,int pos)
{
for (int i=x; i; i-=lowbit(i))
if (val<bit[i].minn) bit[i].minn=val,bit[i].pos=pos;
}
int Query(int x,int M)
{
int minn=0x7fffffff,pos=-1;
for (int i=x; i<=M; i+=lowbit(i))
if (bit[i].minn<minn) minn=bit[i].minn,pos=bit[i].pos;
return pos;
}
int num,Ans;
void MST()
{
int a[MAXN],b[MAXN];
for (int k=0; k<=3; k++)
{
if (k==1 || k==3) for (int i=1; i<=N; i++) swap(P[i].x,P[i].y);
else if (k==2) for (int i=1; i<=N; i++) P[i].x=-P[i].x;
stable_sort(P+1,P+N+1,cmpP);
for (int i=1; i<=N; i++)
a[i]=b[i]=P[i].y-P[i].x;
stable_sort(b+1,b+N+1);
int M=unique(b+1,b+N+1)-b-1;
for (int i=1; i<=M; i++) bit[i].init();
for (int i=N; i>=1; i--)
{
int pos=lower_bound(b+1,b+M+1,a[i])-b;
int ans=Query(pos,M);
if (ans!=-1) AddEdge(P[i].id,P[ans].id,Dis(P[i],P[ans]));
Update(pos,P[i].x+P[i].y,i);
}
}
stable_sort(edge+1,edge+cnt+1,cmpE);
uf.Init();
for (int i=1; i<=cnt; i++)
{
int u=edge[i].from,v=edge[i].to;
if (uf.Merge(u,v)) Ans+=edge[i].val,num++;
if (num==N-1) break;
}
}
int main()
{
N=read();
for (int i=1; i<=N; i++) P[i].x=read(),P[i].y=read(),P[i].id=i;
MST();
printf("%d\n",Ans);
return 0;
}

感觉很愚蠢的代码