[poj 3241]二维曼哈顿距离最小生成树

模板。

注意一定要倒着扫

注意边一定不要开小了

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#define maxn 100005
using namespace std;

int n, k;

struct Point{
	int x, y, id;
	bool operator<(const Point& k)const{
		if(x != k.x)return x < k.x;
		return y < k.y;
	}
}b[maxn];


namespace BIT{
	int t[maxn], pos[maxn];
 	int n;
	void init(int p){
		n = p;
		memset(t, 0x7f, sizeof t);
		memset(pos, -1, sizeof pos);
	}
	int lowbit(int x){
		//return x&((~x)+1);
		return x & -x;
	}
	void update(int x, int val, int id){
		for(int i = x; i; i -= lowbit(i)){
			if(t[i] > val){
				t[i] = val;
				pos[i] = id;
			}
		}
	}
	int ask(int x){
		int ans = t[0], k = -1;
		for(int i = x; i <= n; i += lowbit(i)){
			if(t[i] < ans){
				k = pos[i];
				ans = t[i];
			}
		}
		return k;
	}
}

int Abs(int x){
	return x > 0 ? x : -x;
}

int dist(int u, int v){
	return Abs(b[u].x - b[v].x) + Abs(b[u].y - b[v].y);
}

int h[maxn], a[maxn];



struct Edge{
	int u, v, w;
	bool operator<(const Edge& k)const{
		return w < k.w;
	}
}edge[maxn * 8];

int cnt;

void add(int u, int v, int w){
	cnt ++;
	edge[cnt].u = u;
	edge[cnt].v = v;
	edge[cnt].w = w;
}

namespace Kruscal{
	int fa[maxn], ans[maxn];
	int getfa(int x){
		return x == fa[x] ? x : fa[x] = getfa(fa[x]);
	}
	void work(){
		for(int i = 1; i <= n; i ++)
		    fa[i] = i;
		sort(edge + 1, edge + 1 + cnt);
		int C = n - 1;
		for(int i = 1; i <= cnt; i ++){
			int u = getfa(edge[i].u), v = getfa(edge[i].v);
			if(u != v){
				ans[C] = edge[i].w;
				C --;
				fa[u] = v;
				if(C == 0)break;
			}
		}
		printf("%d\n", ans[k]);
	}
}

int main(){
	scanf("%d%d", &n, &k);
	for(int i = 1; i <= n;i ++)
	    scanf("%d%d", &b[i].x, &b[i].y);
    for(int i = 1; i <= n;i ++)
        b[i].id = i;
	for(int dir = 1; dir <= 4; dir ++){
		if(dir == 2 || dir == 4)
			for(int i = 1; i <= n; i ++)
			    swap(b[i].x, b[i].y);
		else if(dir == 3)
		    for(int i = 1; i <= n; i ++)
				b[i].x = -b[i].x;
		sort(b + 1, b + 1 + n);
		for(int i = 1; i <= n; i ++)
		    a[i] = h[i] = b[i].y - b[i].x;
		sort(h + 1, h + 1 + n);
		int m = unique(h + 1, h + 1 + n) - h - 1;
		BIT::init(m);
		for(int i = n; i >= 1; i --){
			int t = lower_bound(h + 1, h + 1 + m, a[i]) - h;
			int k = BIT::ask(t);
			if(k != -1)
				add(b[i].id, b[k].id, dist(i, k));
			BIT::update(t, b[i].x + b[i].y, i);
		}
	}
	Kruscal::work();
	return 0;
}