POJ 3241 Object Clustering 二维平面曼哈顿距离最小生成树

题目链接:点击打开链接

题意:

给定二维平面上的n个点坐标,常数k

下面n行给出坐标

求一个最小生成树,问第k大的边是多少。

任意两个点间建一条边的花费是其曼哈顿距离。

思路:转自:点击打开链接

一、曼哈顿距离最小生成树

曼哈顿距离最小生成树问题可以简述如下:

给定二维平面上的N个点,在两点之间连边的代价为其曼哈顿距离,求使所有点连通的最小代价。

朴素的算法可以用O(N2)的Prim,或者处理出所有边做Kruskal,但在这里总边数有O(N2)条,所以Kruskal的复杂度变成了O(N2logN)。

但是事实上,真正有用的边远没有O(N2)条。我们考虑每个点会和其他一些什么样的点连边。可以得出这样一个结论,以一个点为原点建立直角坐标系,在每45度内只会向距离该点最近的一个点连边。

这个结论可以证明如下:假设我们以点A为原点建系,考虑在y轴向右45度区域内的任意两点B(x1,y1)和C(x2,y2),不妨设|AB|≤|AC|(这里的距离为曼哈顿距离),如下图:


|AB|=x1+y1,|AC|=x2+y2,|BC|=|x1-x2|+|y1-y2|。而由于B和C都在y轴向右45度的区域内,有y-x>0且x>0。下面我们分情况讨论:

1.      x1>x2且y1>y2。这与|AB|≤|AC|矛盾;

2.      x1≤x2且y1>y2。此时|BC|=x2-x1+y1-y2,|AC|-|BC|=x2+y2-x2+x1-y1+y2=x1-y1+2*y2。由前面各种关系可得y1>y2>x2>x1。假设|AC|<|BC|即y1>2*y2+x1,那么|AB|=x1+y1>2*x1+2*y2,|AC|=x2+y2<2*y2<|AB|与前提矛盾,故|AC|≥|BC|;

3.      x1>x2且y1≤y2。与2同理;

4.      x1≤x2且y1≤y2。此时显然有|AB|+|BC|=|AC|,即有|AC|>|BC|。

综上有|AC|≥|BC|,也即在这个区域内只需选择距离A最近的点向A连边。

这种连边方式可以保证边数是O(N)的,那么如果能高效处理出这些边,就可以用Kruskal在O(NlogN)的时间内解决问题。下面我们就考虑怎样高效处理边。

我们只需考虑在一块区域内的点,其他区域内的点可以通过坐标变换“移动”到这个区域内。为了方便处理,我们考虑在y轴向右45度的区域。在某个点A(x0,y0)的这个区域内的点B(x1,y1)满足x1≥x0且y1-x1>y0-x0。这里对于边界我们只取一边,但是操作中两边都取也无所谓。那么|AB|=y1-y0+x1-x0=(x1+y1)-(x0+y0)。在A的区域内距离A最近的点也即满足条件的点中x+y最小的点。因此我们可以将所有点按x坐标排序,再按y-x离散,用线段树或者树状数组维护大于当前点的y-x的最小的x+y对应的点。时间复杂度O(NlogN)。

至于坐标变换,一个比较好处理的方法是第一次直接做;第二次沿直线y=x翻转,即交换x和y坐标;第三次沿直线x=0翻转,即将x坐标取相反数;第四次再沿直线y=x翻转。注意只需要做4次,因为边是双向的。

至此,整个问题就可以在O(NlogN)的复杂度内解决了。


#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
const int inf = 1e8;
const double eps = 1e-8;
const double pi = acos(-1.0);
template 
inline bool rd(T &ret) {
	char c; int sgn;
	if (c = getchar(), c == EOF) return 0;
	while (c != '-' && (c<'0' || c>'9')) c = getchar();
	sgn = (c == '-') ? -1 : 1;
	ret = (c == '-') ? 0 : (c - '0');
	while (c = getchar(), c >= '0'&&c <= '9') ret = ret * 10 + (c - '0');
	ret *= sgn;
	return 1;
}
template 
inline void pt(T x) {
	if (x <0) { putchar('-'); x = -x; }
	if (x>9) pt(x / 10);
	putchar(x % 10 + '0');
}
using namespace std;
const int N = 1e5 + 10;

class MST{
	struct Edge{
		int from, to, dis;
		Edge(int _from = 0, int _to = 0, int _dis = 0) :from(_from), to(_to), dis(_dis){}
		bool operator < (const Edge &x) const{
			return dis < x.dis;
		}
	}edge[N << 3];
	int f[N], tot;
	int find(int x){ return x == f[x] ? x : f[x] = find(f[x]); }
	bool Union(int x, int y){
		x = find(x); y = find(y);
		if (x == y)return false;
		if (x > y)swap(x, y);
		f[x] = y;
		return true;
	}
public:
	void init(int n){
		for (int i = 0; i <= n; i++)f[i] = i;
		tot = 0;
	}
	void add(int u, int v, int dis){
		edge[tot++] = Edge(u, v, dis);
	}
	int work(){
		sort(edge, edge + tot);
		int cost = 0;
		for (int i = 0; i < tot; i++){
			if (Union(edge[i].from, edge[i].to))
				cost += edge[i].dis;
		}
		return cost;
	}
	int work_kth(int k){
		sort(edge, edge + tot);
		int cost = 0;
		for (int i = 0; i < tot && k; i++){
			if (Union(edge[i].from, edge[i].to))
				cost = edge[i].dis, k--;
		}
		return cost;
	}
}mst;
struct Point{
	int x, y, id;
	friend bool operator<(const Point&a, const Point&b){
		if (a.x == b.x)return a.y < b.y;
		return a.x < b.x;
	}
}p[N];
class BIT{
	int c[N], id[N], maxn;
	int lowbit(int x){ return x&-x; }
public:
	void init(int n){
		maxn = n + 10;
		fill(c, c + maxn + 1, inf);
		fill(id, id + maxn + 1, -1);
	}
	void updata(int pos, int val, int _id){
		while (pos){
			if (c[pos] > val){ c[pos] = val; id[pos] = _id; }
			pos -= lowbit(pos);
		}
	}
	int query(int pos){
		int val = inf, _id = -1;
		while (pos <= maxn){
			if (val > c[pos]){ val = c[pos]; _id = id[pos]; }
			pos += lowbit(pos);
		}
		return _id;
	}
}tree;
inline bool cmp(int *x, int *y){ return *x < *y; }
class Manhattan_MST{
	int *po[N], a[N]; 
public:
	int work(int l, int r, int k){
		mst.init(r);
		for (int dir = 1; dir <= 4; dir++){
			if (dir%2==0)for (int i = l; i <= r; i++)swap(p[i].x, p[i].y);
			else if (dir == 3)for (int i = l; i <= r; i++)p[i].x = -p[i].x;
			sort(p + l, p + r + 1);
			for (int i = l; i <= r; ++i) a[i] = p[i].y - p[i].x, po[i] = &a[i];
			sort(po + l, po + r + 1, cmp);
			for (int i = l; i <= r; i++)*po[i] = i;
			tree.init(r);
			for (int i = r; i >= l; i--)
			{
				int id = tree.query(a[i]);
				if (id != -1)
					mst.add(p[i].id, p[id].id, abs(p[i].x - p[id].x) + abs(p[i].y - p[id].y));
				tree.updata(a[i], p[i].x + p[i].y, i);
			}
		}
		return mst.work_kth(k);
	}
}m_mst;

int n, k;
int main(){
	rd(n); rd(k);
	for (int i = 1; i <= n; i++)rd(p[i].x), rd(p[i].y), p[i].id = i;
	pt(m_mst.work(1, n, n-k)); puts("");
	return 0;
}



你可能感兴趣的:(生成树,莫队算法)