CCF 201412-4 最优灌溉

试题编号： 201412-4

试题名称： 最优灌溉

时间限制： 1.0s 内存限制： 256.0MB

问题描述：

雷雷承包了很多片麦田，为了灌溉这些麦田，雷雷在第一个麦田挖了一口很深的水井，所有的麦田都从这口井来引水灌溉。为了灌溉，雷雷需要建立一些水渠，以连接水井和麦田，雷雷也可以利用部分麦田作为“中转站”，利用水渠连接不同的麦田，这样只要一片麦田能被灌溉，则与其连接的麦田也能被灌溉。现在雷雷知道哪些麦田之间可以建设水渠和建设每个水渠所需要的费用（注意不是所有麦田之间都可以建立水渠）。请问灌溉所有麦田最少需要多少费用来修建水渠。

输入格式

输入的第一行包含两个正整数n, m，分别表示麦田的片数和雷雷可以建立的水渠的数量。麦田使用1, 2, 3, ……依次标号。接下来m行，每行包含三个整数ai, bi, ci，表示第ai片麦田与第bi片麦田之间可以建立一条水渠，所需要的费用为ci。

输出格式

输出一行，包含一个整数，表示灌溉所有麦田所需要的最小费用。

样例输入

4 4
1 2 1
2 3 4
2 4 2
3 4 3

样例输出

6

样例说明

建立以下三条水渠：麦田1与麦田2、麦田2与麦田4、麦田4与麦田3。

评测用例规模与约定
前20%的评测用例满足：n≤5。前40%的评测用例满足：n≤20。前60%的评测用例满足：n≤100。所有评测用例都满足：1≤n≤1000，1≤m≤100,000，1≤ci≤10,000。

Code1:

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
// 并查集类
class UF {
	private:
		vector<int> v;
	public:
		UF(int n) {
			for(int i=0; i<=n; i++)
				v.push_back(i);
		}
		int Find(int x) {
			for(;;) {
				if(v[x] != x)
					x = v[x];
				else
					return x;
			}
		}
		bool Union(int x, int y) {
			x = Find(x);
			y = Find(y);
			if(x == y)
				return false;
			else {
				v[x] = y;
				return true;
			}
		}
};
struct edge {
	int src, dest, cost;
	bool operator < (const edge& n) const {
		return cost > n.cost;
	}
};
int main() {
	priority_queue<edge> q;     // 优先队列，用于存储边列表
	edge e;
	// 输入数据
	int n, m;
	cin >> n >> m;
	for(int i=1; i<=m; i++) {
		cin >> e.src >> e.dest >> e.cost;
		q.push(e);
	}
	// Kruskal算法
	UF uf(n);
	int ans=0, count=0;
	for(;;) {
		e = q.top();
		q.pop();
		if(uf.Find(e.src) != uf.Find(e.dest)) {
			uf.Union(e.src, e.dest);
			ans += e.cost;
			if(++count == n -1)
				break;
		}
	}
	// 输出结果
	cout << ans << endl;
	return 0;
}

Code2:

#include <iostream>
#include<queue>
#include<vector>
using namespace std;
struct edge {
	int end;
	int length;
	edge(int e,int l) {
		end=e;
		length=l;
	}
};
struct Edge {
	int start;
	int end;
	int length;
	Edge(int s,int e,int l) {
		start=s;
		end=e;
		length=l;
	}
};
bool operator <(Edge a,Edge b) {
	return a.length>b.length;
}
int n,m;
int main(int argc, char** argv) {
	cin>>n>>m;
	int s,e,l;
	vector<vector<edge> > G(n+1,vector<edge>());
	for(int i=0; i<m; ++i) {
		cin>>s>>e>>l;
		G[s].push_back(edge(e,l));
		G[e].push_back(edge(s,l));
	}
	priority_queue<Edge> pq;
	int cost=0;
	int count=1;
	vector<bool> visted(n+1,false);
	for(int i=0; i<G[1].size(); ++i) {
		pq.push(Edge(1,G[1][i].end,G[1][i].length));
	}
	visted[1]=true;
	while(count<n) {
		Edge e=pq.top();
		pq.pop();

		if(visted[e.start]&&visted[e.end])
			continue;
		cost+=e.length;
		count++;
		int node=visted[e.start]?e.end:e.start;
		visted[node]=true;
		for(int i=0; i<G[node].size(); ++i) {
			pq.push(Edge(node,G[node][i].end,G[node][i].length));
		}
	}
	cout<<cost;
	return 0;
}

若有疑问欢迎评论！