[最小生成树小结]hdu1875/hdu1879/poj2395/poj2421/poj2485/poj1258/poj2349

最新推荐文章于 2016-08-04 21:39:57 发布
最新推荐文章于 2016-08-04 21:39:57 发布
阅读量750 收藏
点赞数
分类专栏： 图论 文章标签： 最小生成树 prim算法 Kruskal算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bit_Line/article/details/41827769
版权

找到了

hdu1875

hdu1879

poj2395

poj2421

poj2485

poj1258

poj2349(toj1411)几个题，都是简单的最小生成树，可以用于练习达到熟练程度。一起干掉。

代码：

hdu1875

#include <cstdio>
#include <cstring>
#include <cfloat>
#include <cmath>
#include <queue>
#include <algorithm>
using namespace std;

const double eps = 1e-8;
const double INF = DBL_MAX * 0.5;
const int MAX = 107;
double G[MAX][MAX];
bool vis[MAX];
double mincost[MAX];
struct Node {
	int x, y;
	double dis(const Node& B)const {
		return sqrt((double)(x - B.x) * (x - B.x) + (double)(y - B.y) * (y - B.y));
	}
} Point[MAX];

bool BFS(int u, int n) {
	memset(vis, false, sizeof(vis));
	vis[u] = true;
	queue<int> Q;
	int p = u;
	Q.push(p);
	while (!Q.empty()) {
		p = Q.front();
		Q.pop();
		
		for (int i = 0; i < n; ++i) {
			if (G[p][i] + eps < INF && !vis[i]) {
				vis[i] = true;
				Q.push(i);
			}
		}
	}
	
	for (int i = 0; i < n; ++i) {
		if (!vis[i]) return false;
	}
	return true;
}

double prim(int u, int n) {
	fill(mincost, mincost + MAX, INF);
	memset(vis, false, sizeof(vis));
	mincost[u] = 0.0;
	double sum = 0.0;
	while (true) {
		int v = -1;
		for (int u = 0; u < n; ++u) {
			if (!vis[u] && (v == -1 || mincost[u] < mincost[v])) {
				v = u;
			}
		}
		if (v == -1) break;
		vis[v] = true;
		sum += mincost[v];
		for (int i = 0; i < n; ++i) {
			if (mincost[i] > G[v][i]) mincost[i] = G[v][i];
		}
	}
	return sum * 100.0;
}

inline int read() {
	char ch;
	while ((ch = getchar()) < '0' || ch > '9');
	int x = ch - '0';
	while ((ch = getchar()) >= '0' && ch <= '9') {
		x = (x << 3) + (x << 1) + ch - '0';
	}
	return x;
}

int main() {
	int T, n;
	T = read();
	while (T--) {
		n = read();
		//scanf(" %d", &C);
		for (int i = 0; i < n; ++i) {
			for (int j = 0; j < n; ++j) {
				G[i][j] = INF;
			}
		}
		for (int i = 0; i < n; ++i) {
			Point[i].x = read();
			Point[i].y = read();
			//scanf(" %d %d", &Point[i].x, &Point[i].y);
		}
		for (int i = 0; i < n; ++i) {
			for (int j = 0; j < n; ++j) {
				if (j <= i) G[i][j] = G[j][i];
				else {
					G[i][j] = Point[i].dis(Point[j]);
					if (G[i][j] + eps < 10.0 || G[i][j] > 1000.0 + eps) {
						G[i][j] = INF;
					}
				}
			}
		}
		if (!BFS(0, n)) puts("oh!");
		else printf("%.1f\n", prim(0, n));
	}
	return 0;
}

hdu1879: 

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

const int MAX = 1024;
struct edge {
	int from, to;
	int cost;
	edge(){}
	edge(int _from, int _to, int _cost):from(_from), to(_to), cost(_cost){}
	bool operator<(const edge& B)const {
		return cost < B.cost;
	}
};
vector<edge> G;
int father[MAX];

int find(int x) {
	return x == father[x] ? x : father[x] = find(father[x]);
}

void Union(int x, int y) {
	int fx = find(x);
	int fy = find(y);
	if (fx != fy) {
		father[fx] = fy;
	}
}

int kruskal(int n) {
	for (int i = 0; i < MAX; ++i) {
		father[i] = i;
	}
	sort(G.begin(), G.end());
	
	int sum = 0;
	for (int i = 0; i < G.size(); ++i) {
		edge &e = G[i];
		if (find(e.from) == find(e.to)) {
			continue;
		}
		sum += e.cost;
		Union(e.from, e.to);
	}
	return sum;
}

inline int read() {
	char ch;
	while ((ch = getchar()) < '0' || ch > '9');
	int x = ch - '0';
	while ((ch = getchar()) >= '0' && ch <= '9') {
		x = (x << 3) + (x << 1) + ch - '0';
	}
	return x;
}
int main() {
	int n;
	while (~scanf(" %d", &n) && n) {
		int u, v, c, d;
		G.clear();
		int es = n * (n - 1) >> 1;
		for (int i = 0; i < es; ++i) {
			u = read();
			v = read();
			c = read();
			d = read();
			//scanf(" %d %d %d %d", &u, &v, &c, &d);
			G.push_back(edge(u, v, (d ? 0 : c)));
		}
		printf("%d\n", kruskal(n));
	}
	
	return 0;
}

poj1258: 

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

const int MAX = 105;
int G[MAX][MAX];
int mincost[MAX];
bool vis[MAX];

int prim(int node) {
	memset(vis, false, sizeof(vis));
	fill(mincost, mincost + node + 1, 0xffffff);
	int sum = 0;
	mincost[1] = 0;
	for (int i = 1; i <= node; ++i) {
		int v = 0;
		for (int u = 1; u <= node; ++u) {
			if (!vis[u] && (v == 0 || mincost[v] > mincost[u])) {
				v = u;
			}
		}
		if (!v) break;
		sum += mincost[v];
		vis[v] = true;
		for (int i = 1; i <= node; ++i) {
			if (mincost[i] > G[v][i]) mincost[i] = G[v][i];
		}
	}
	return sum;
}
int read() {
	char ch;
	while ((ch = getchar()) < '0' || ch > '9');
	int x = ch - '0';
	while ((ch = getchar()) >= '0' && ch <= '9') {
		x = (x << 3) + (x << 1) + ch - '0';
	}
	return x;
}

int main() {
	int n;
	while (~scanf(" %d", &n)) {
		for (int i = 1; i <= n; ++i) {
			for (int j = 1; j <= n; ++j) {
				G[i][j] = read(); //scanf(" %d", &G[i][j]);
			}
		}
		printf("%d\n", prim(n));
	}
	return 0;
}

poj2349: 

/*
	初始化每个点一个连通分量 
	每次只需要选最小边即可，然后在剩下s个连通分量时答案就更新完毕鸟
*/ 
#include <cstdio>
#include <cmath>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;

const double INF = 1e10;
const int MAX = 512;
struct Point {
	double x, y;
	double dis(const Point& B) {
		return sqrt((x - B.x) * (x - B.x) + (y - B.y ) * (y - B.y));
	}
} a[MAX];
struct edge {
	int from, to;
	double cost;
};
struct cmp {
	bool operator()(edge& e1, edge& e2) {
		return e1.cost > e2.cost;
	}
};

int father[MAX];

int find(int x) {
	return x == father[x] ? x : father[x] = find(father[x]);
}
void Union(int x, int y) {
	int fx = find(x), fy = find(y);
	if (fx != fy) {
		father[fx] = fy;
	}
}

double gao(int s, int p) {
	priority_queue<edge, vector<edge>, cmp> Q;
	for (int i = 0; i < p; ++i) {
		for (int j = i + 1; j < p; ++j) {
			Q.push((struct edge){i, j, a[i].dis(a[j])});
		}
		father[i] = i;
	}
	double ans = 0.0;
	for (int i = s; i < p; ++i) {
		edge e;
		e.from = e.to = e.cost = 0.0;
		while (!Q.empty()) {
			e = Q.top();
			Q.pop();
			if (find(e.from) != find(e.to)) break;
		}
		
		Union(e.from, e.to);
		if (ans < e.cost) ans = e.cost;
	}
	return ans;
}

int main() {
	int T;
	scanf(" %d", &T);
	while (T--) {
		int s, p;
		scanf(" %d %d", &s, &p);
		for (int i = 0; i < p; ++i) {
			scanf(" %lf %lf", &a[i].x, &a[i].y);
		}
		printf("%.2f\n", gao(s, p));
	}
	return 0;
}

poj2395: 

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

const int MAX = 2048;
struct edge {
	int from, to;
	int cost;
	bool operator<(const edge& e)const {
		return cost < e.cost;
	}
};
vector<edge> G;
int father[MAX];

int find(int x) {
	return x == father[x] ? x : father[x] = find(father[x]);
}
bool Union(int x, int y) {
	int fx = find(x), fy = find(y);
	if (fx != fy) {
		father[fx] = fy;
		return true;
	}
	return false;
}

int kruskal(int n) {
	for (int i = 1; i <= n; ++i) father[i] = i;
	sort(G.begin(), G.end());
	int ans = 0;
	for (vector<edge>::iterator e = G.begin(); e != G.end(); ++e) {
		if (Union(e->from, e->to) && ans < e->cost) {
			ans = e->cost;
		}
	}
	return ans;
}

inline int read() {
	char ch;
	while ((ch = getchar()) < '0' || ch > '9');
	int x = ch - '0';
	while ((ch = getchar()) >= '0' && ch <= '9') {
		x = (x << 3) + (x << 1) + ch - '0';
	}
	return x;
}

int main() {
	int n, m;
	while (~scanf(" %d %d", &n, &m)) {
		G.clear();
		int u, v, c;
		while (m--) {
			u = read();
			v = read();
			c = read();
			G.push_back((struct edge){u, v, c});
		}
		printf("%d\n", kruskal(n));
	}
	return 0;
}

poj2421: 

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

const int MAX = 128;
struct edge {
	int from, to;
	int cost;
	bool operator<(const edge& e)const {
		return cost < e.cost;
	}
};
vector<edge> G;
int father[MAX];

int find(int x) {
	return x == father[x] ? x : father[x] = find(father[x]);
}
bool Union(int x, int y) {
	int fx = find(x), fy = find(y);
	if (fx != fy) {
		father[fx] = fy;
		return true;
	}
	return false;
}

int kruskal(int n) {
	for (int i = 1; i <= n; ++i) father[i] = i;
	sort(G.begin(), G.end());
	int sum = 0;
	for (vector<edge>::iterator e = G.begin(); e != G.end(); ++e) {
		if (Union(e->from, e->to)) {
			sum += e->cost;
		}
	}
	return sum;
}

inline int read() {
	char ch;
	while ((ch = getchar()) < '0' || ch > '9');
	int x = ch - '0';
	while ((ch = getchar()) >= '0' && ch <= '9') {
		x = (x << 3) + (x << 1) + ch - '0';
	}
	return x;
}

int main() {
	int n, c;
	while (~scanf(" %d", &n)) {
		G.clear();
		for (int i = 1; i <= n; ++i) {
			for (int j = 1; j <= n; ++j) {
				c = read();
				if (j > i) {
					G.push_back((struct edge){i, j, c});
				}
			}
		}
		int u, v, m = read();
		while (m--) {
			u = read();
			v = read();
			G.push_back((struct edge){u, v, 0});
		}
		printf("%d\n", kruskal(n));
	}
	return 0;
}

poj2485: 

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

const int MAX = 512;
struct edge {
	int from, to;
	int cost;
	bool operator<(const edge& e)const {
		return cost < e.cost;
	}
};
vector<edge> G;
int father[MAX];

int find(int x) {
	return x == father[x] ? x : father[x] = find(father[x]);
}
bool Union(int x, int y) {
	int fx = find(x), fy = find(y);
	if (fx != fy) {
		father[fx] = fy;
		return true;
	}
	return false;
}

int kruskal(int n) {
	for (int i = 1; i <= n; ++i) father[i] = i;
	sort(G.begin(), G.end());
	int ans = 0;
	for (vector<edge>::iterator e = G.begin(); e != G.end(); ++e) {
		if (Union(e->from, e->to) && ans < e->cost) {
			ans = e->cost;
		}
	}
	return ans;
}

inline int read() {
	char ch;
	while ((ch = getchar()) < '0' || ch > '9');
	int x = ch - '0';
	while ((ch = getchar()) >= '0' && ch <= '9') {
		x = (x << 3) + (x << 1) + ch - '0';
	}
	return x;
}

int main() {
	int T, n, c;
	T = read();
	while (T--) {
		n = read();
		G.clear();
		for (int i = 1; i <= n; ++i) {
			for (int j = 1; j <= n; ++j) {
				c = read(); //scanf(" %d", &c);
				if (j > i) {
					G.push_back((struct edge){i, j, c});
				}
			}
		}
		printf("%d\n", kruskal(n));
	}
	return 0;
}

小结：这类问题还是可以有一些变形和应用的，上述中，有些题可能需要有诸如增加权为0的边，将边删除等等小技巧。prim的复杂度略高一些，但是应对一般的小规模数据还是没有问题的，而且图论部分的问题规模都不会特别大。具体来说，prim和kruskal的实现部分还是智者见智，让自己习惯一些就好︿(￣︶￣)︿

虽然暑假集训时学习过，但是那时对这块的东西好像还只是很模糊的，因为理解得并不是很深刻，所以代码实现起来也不见得行云流水。还望自己多多努力吧……之后再做一些诸如次小生成树之类的问题，加深理解︿(￣︶￣)︿

bit_line
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
初识最短路算法-Bellman-Ford, Djistera & Floyd
When you go away
07-25 855
学习最短路中＞．． 好吧，真相是：发现图论学的一团糟，所以下决心从最基础的开始一步一步走结实一些～～～ 在此总结一下三种单源最短路的算法： 1.Bellman-Ford算法 适用范围：DAG，即无环有向图，当然，只要不是负权环就可以，正权环还是可以用的．复杂度O(|V|*|E|). 主要代码： const int MAX = 1024; struct edge { int fro
【小结】最小费用流&最大权闭合图
When you go away
08-05 797
最小费用流就是在保证流量FF的前提下，求解最少花费是多少的问题O_O{O\_O} 建图: 每条边在最大流基础上(to指向点,cap容量,rev反向边)\left(to指向点,cap容量,rev反向边\right)，增加一个费用(cost)\left(cost\right) 求解方法: 在最大流中，是按照任意可行路径，也就是残余网络中的可增广路径，向网络中注入流量，从而在汇点获得相应流量的策略进行，直
hdu2122 poj2485 最小生成树
一段旅途
07-26 511
最小生成树的题俩算法，prim和krustal，分别以以下
HDU 1301 &POJ 1215 Jungle Roads【最小生成树，Prime算法+Kruskal算法】
AC_Dreameng
08-04 3132
Jungle Roads Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 6737    Accepted Submission(s): 4893 Problem Description The Head
最小生成树，POJ和HDU几道题目的解题报告（基于自己的模板）
Tham 在思索中前行！
05-27 828
首先POJ题目： 链接：1251 Jungle Roads 题目大意：纯求最小生成树，结果为最小权值边的和。采用邻接表 #include #include #include #include using namespace std; #define maxn 30 //最大顶点个数 int n; //顶点数，边数 struct arcnode //边结
HDU 1301 / POJ 1251 Jungle Roads（最小生成树）
Shyazhut
08-04 430
Jungle Roads（POJ链接） Jungle Roads（HDU链接） Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 23971   Accepted: 11240 Description The Head Elder of
hdu oj poj 题目代码与详解
09-08
很多经典的杭电oj与poj习题的ac代码与详解!全部ac,决对没有错误的代码!
最佳跨平台在线评委在线评委内核虚拟评委适配器竞赛收集命令行界面Telnet服务器/clinetFTP服务器/客户端
最新发布
04-15
Online Judge Kernel支持Virtual Judge：http://acm.hdu.edu.cn，http://leetcode-cn.com 。Online Judge Kernel支持命令行管理，命令行特性支持命令联想、自动补全等功能，极大方便了系统的管理。（这是我们的特色...
1.dijkstra.gz_C/C++_
08-11
这是hdu1874的解法，我用了5种方法解决，这是第一种
jihe.rar_2289_POJ 3714_poj3714_poj3714 Ra_visual c
09-22
三道几何题：hdu 1007、hdu 2289、poj 3714
HDU&&POJ图论题集
04-24
图论〔Graph Theory〕是数学的一个分支。它以图为研究对象。图论中的图是由若干给定的点及连接两点的线所构成的图形，这种图形通常用来描述某些事物之间的某种特定关系，用点代表事物，用连接两点的线表示相应两个...
poj1273Drainage Ditches最大流[dinic算法]
When you go away
07-30 1130
这题太经典,可以作为所有最大流算法的入门题...所以昨天搞了好久dinic,愣是没明白建图那一步.后来干脆抛开那些代码,自己根据对dinic的理解写.没想到还能做出来! 好惊喜... 唉,也说说自己的感受吧,网上关于这方面的文章什么的太多了,而且各有各的理解,昨晚好痛苦,看了无数篇博客文章,总算理解到算法最关键的部分了.也给自己留个教训:别总想着模板,好习惯什么的,甚至还担心如果建图甚么的没做好
【小结】强联通分量分解
When you go away
07-17 877
强联通分量 在一个有向图的顶点子集SS中，对∀(u,v)\forall (u,v)，如果都能找到一条从uu到vv的路径，那么就称SS是强联通的。如果向SS中加入任何一个其他顶点后SS都不再是强联通的，就称SS时原图的一个强联通分量。 显然，如果把所有的强联通分量都缩点，原图将变成一个DAGDAG SCCSCC的求解可通过两次dfsdfs实现，第一次在原图中后续遍历，标号；第二遍将所有边反向后，从编号
网络流-最大流：两枚[poj1459&poj3436]
When you go away
05-02 840
说说建图吧…poj1459:增加超级源点，超级汇点，跑一遍即可。#include <cstdio> #include <cstring> #include <vector> #include <cstdlib> #include <cmath> #include <queue> #include <algorithm> using namespace std;const int MAX = 107;
【康托展开+状压BFS】poj1077 Eight(八数码问题)
When you go away
01-29 840
The Cantor Expassion is something that help us to solve some problem about the numbers arrange. Besides, it can help to compress state(encode&decode), so that we can use BFS/DFS to solve those proble
[toj3517]【求树的直径】
When you go away
01-02 821
题意是给一棵树，求树中任意两点间的距离的最大值。其本质就是：求树的直径。 最短路径部分，可以用迪杰斯特拉实现。可以加优先队列优化一下，但是这里数据不大可以随便搞，快速读入并没有时间优化效果。   1493228 2015-01-02 13:37:59 Accepted 3517 C++ 1.7K 0'00.11" 980K   0'00.
[网络流入门,简单题]poj1273Drainage Ditches最大流
When you go away
07-29 801
最大流第一题.哦也~~~~~~~~~凭自己的理解写的代码,多做点题,ying
[BFS]HDU1044 Collect More Jewels
When you go away
04-24 796
HDU1044 Collect More Jewels 代码数学公式 UML 图 离线写博客 浏览器兼容HDU1044 Collect More Jewels 两遍BFS，首先需要记录一下每个点到DEST的距离，然后就可以搜了。当然也可以直接A*搞一下，估值函数设为f(x)={dis<代码:#include <cstdio> #include <cstring> #include <cctype>
hdu1969 java
10-17
针对你的问题，我猜测你是在问如何使用Java解决hdu1969这道题目。如果我的猜测正确，那么我可以给你一些思路和代码实现。 首先，我们需要明确题目的意思。题目要求我们求出一个多边形的面积，这个多边形由若干个点...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值