UVA 11228 （Kruskal 最小生成树）

题目大意：有一系列的点，这些点中假如欧氏距离小于r就认为是同一类，注意A和B同一类，B和C同一类，那么A和C就是同一类。

现在要在点集中铺路，在一类中我们需要铺路使得类中的点都连通，在不同类也需要通过路来把它们全部连起来，使得类和类之间能够互相连接。约束：注意我们总的铺路的距离要尽可能小。

最后输出铺路的距离。

思路：首先在类中最小生成树，然后不同类之间也要做一个最小生成树，注意在不同类别中做最小生成树的时候，那一个类别是作为一个节点（在这里WA了一发 555）。注意：在这里一个类就是题意中的一个state.

AC代码：

#include <bits/stdc++.h>
#define MAXN 1010
#define UNVISITED 0
#define VISITED 1
using namespace std;
double dist[MAXN][MAXN];
int N;
int R;
int flag[MAXN];
vector<int> ConPoi;
typedef vector<int > vi;
class Disjoint_Union_set {
private:
	vi p, rank, setSize;
	int numSets;
public:
	Disjoint_Union_set(int N) {
		p.assign(N, 0); rank.assign(N, 1); setSize.assign(N, 1);
		numSets = N; for (int i = 0; i<N; i++)p[i] = i;
	}
	int find_set(int i) { return p[i] == i ? i : p[i] = find_set(p[i]); }	//find the representative element(root of the tree)
	bool is_same_set(int i, int j) {
		//1 for same set
		return find_set(i) == find_set(j);
	}
	void union_set(int i, int j) {
		if (!is_same_set(i, j)) {
			int x = find_set(i); int y = find_set(j);
			numSets--;
			if (rank[x] < rank[y]) {
				p[x] = y;
				setSize[y] += setSize[x];
			}
			else {
				p[y] = x;
				setSize[x] += setSize[y];
				if (rank[x] == rank[y])rank[x] ++;
			}

		}

	}
	int numDisjointsets() {
		return numSets;
	}
	int sizeOfSet(int i) {
		return setSize[find_set(i)];
	}

};

void DFS(int u) {
	if (flag[u] != UNVISITED)return;
	ConPoi.push_back(u);
	flag[u] = VISITED;
	for (int nx = 0; nx<N; nx++) {
		if (nx == u)continue;
		if (dist[u][nx]>R)continue;
		DFS(nx);
	}
}
bool cmp(pair<double, pair<int, int>> &fir, pair<double, pair<int, int>> &las) {
	if (fir.first < las.first)return true;
	else return false;
}
int main() {
	int cases;
	cin >> cases;
	for (int ca = 0; ca<cases; ca++) {
		int n; int r;
		cin >> n >> r;
		N = n;
		R = r;

		vector<pair<int, int>> poi;
		for (int i = 0; i<n; i++) {
			int x, y;
			cin >> x >> y;
			poi.push_back(make_pair(x, y));
		}
		//cerr<<"read complete"<<endl;
		for (int i = 0; i<n - 1; i++) {
			int orix = poi[i].first;
			int oriy = poi[i].second;
			for (int j = i + 1; j<n; j++) {
				int nxx = poi[j].first;
				int nxy = poi[j].second;
				dist[i][j] = dist[j][i] = sqrt(pow((float)(orix - nxx), 2) + pow((float(oriy - nxy)), 2));
			}
		}
		memset(flag, UNVISITED, sizeof(flag));
		//cerr<<"dist matrix complete "<<endl;
		vector<vector<int>> vecCon;
		for (int i = 0; i<n; i++) {
			if (flag[i] != UNVISITED)continue;
			ConPoi.erase(ConPoi.begin(), ConPoi.end());
			DFS(i);
			vecCon.push_back(ConPoi);
		}
		//cerr<<'D'<<endl;
		double kruskalSum = 0;
		for (int i = 0; i<(int)vecCon.size(); i++) {
			vector<int> tmp = vecCon[i];
			vector<pair<double, pair<int, int> > > edges;

			for (int j = 0; j<(int)tmp.size() - 1; j++) {
				for (int z = j + 1; z<(int)tmp.size(); z++) {
					double wei = dist[tmp[j]][tmp[z]];
					pair<int, int> p;
					p = make_pair(tmp[j], tmp[z]);
					pair<double, pair<int, int>> p2;
					p2.first = wei;
					p2.second = p;
					edges.push_back(p2);
				}
			}
			Disjoint_Union_set DUSet(N + 1);
			sort(edges.begin(), edges.end(), cmp);
			for (int j = 0; j<(int)edges.size(); j++) {
				int nxx = edges[j].second.first;
				int nxy = edges[j].second.second;
				double wei = edges[j].first;
				if (!DUSet.is_same_set(nxx, nxy)) {
					DUSet.union_set(nxx, nxy);
					kruskalSum += wei;
				}
			}
		}
		//cerr<<"fir kruskal "<<endl;
		vector<pair<double, pair<int, int>>> edges;
		for (int i = 0; i<(int)vecCon.size() - 1; i++) {
			vector<int> outside = vecCon[i];
			for (int j = i + 1; j<(int)vecCon.size(); j++) {
				vector<int> inside = vecCon[j];
				double min_dist = 1e9;
				int rx = -1;
				int ry = -1;
				for (int ii = 0; ii<(int)outside.size(); ii++) {
					int outpoi = outside[ii];
					for (int jj = 0; jj<(int)inside.size(); jj++) {
						int inpoi = inside[jj];
						double tdis = dist[inpoi][outpoi];
						if (tdis < min_dist) {
							min_dist = tdis;
							rx = i;
							ry = j;
						}
					}
				}
				assert(rx != -1);
				pair<int, int> p;
				p = make_pair(rx, ry);
				pair<double, pair<int, int>> p2;
				p2.first = min_dist;
				p2.second = p;
				edges.push_back(p2);
			}
		}
		//cerr<<"connected component dist"<<endl;
		double kruskalSum2 = 0;
		Disjoint_Union_set dset(N + 1);
		sort(edges.begin(), edges.end(), cmp);
		for (int i = 0; i<(int)edges.size(); i++) {
			double wei = edges[i].first;
			int nxx = edges[i].second.first;
			int nxy = edges[i].second.second;
			
			if (!dset.is_same_set(nxx, nxy)) {
				dset.union_set(nxx, nxy);
				kruskalSum2 += wei;
			}
		}
		printf("Case #%d: %d %d %d\n", ca + 1, vecCon.size(), (int)round(kruskalSum), (int)round(kruskalSum2));
	}
	return 0;
}