poj-3522 最小生成树

Description

Given an undirected weighted graph G, you should find one of spanning trees specified as follows.

The graph G is an ordered pair (VE), where V is a set of vertices {v1v2, …, vn} and E is a set of undirected edges {e1e2, …, em}. Each edge e ∈ E has its weight w(e).

A spanning tree T is a tree (a connected subgraph without cycles) which connects all the n vertices with n ? 1 edges. The slimness of a spanning tree T is defined as the difference between the largest weight and the smallest weight among the n ? 1 edges of T.


Figure 5: A graph G and the weights of the edges

For example, a graph G in Figure 5(a) has four vertices {v1v2v3v4} and five undirected edges {e1e2e3e4e5}. The weights of the edges are w(e1) = 3, w(e2) = 5, w(e3) = 6, w(e4) = 6, w(e5) = 7 as shown in Figure 5(b).


Figure 6: Examples of the spanning trees of G

There are several spanning trees for G. Four of them are depicted in Figure 6(a)~(d). The spanning tree Ta in Figure 6(a) has three edges whose weights are 3, 6 and 7. The largest weight is 7 and the smallest weight is 3 so that the slimness of the tree Ta is 4. The slimnesses of spanning trees TbTc and Td shown in Figure 6(b), (c) and (d) are 3, 2 and 1, respectively. You can easily see the slimness of any other spanning tree is greater than or equal to 1, thus the spanning tree Td in Figure 6(d) is one of the slimmest spanning trees whose slimness is 1.

Your job is to write a program that computes the smallest slimness.

Input

The input consists of multiple datasets, followed by a line containing two zeros separated by a space. Each dataset has the following format.

n m  
a1 b1 w1
  ?  
am bm wm

Every input item in a dataset is a non-negative integer. Items in a line are separated by a space. n is the number of the vertices and m the number of the edges. You can assume 2 ≤ n ≤ 100 and 0 ≤ m ≤ n(n ? 1)/2. ak and bk (k = 1, …,m) are positive integers less than or equal to n, which represent the two vertices vak and vbk connected by the kth edge ekwk is a positive integer less than or equal to 10000, which indicates the weight of ek. You can assume that the graph G = (VE) is simple, that is, there are no self-loops (that connect the same vertex) nor parallel edges (that are two or more edges whose both ends are the same two vertices).

Output

For each dataset, if the graph has spanning trees, the smallest slimness among them should be printed. Otherwise, ?1 should be printed. An output should not contain extra characters.

Sample Input

4 5
1 2 3
1 3 5
1 4 6
2 4 6
3 4 7
4 6
1 2 10
1 3 100
1 4 90
2 3 20
2 4 80
3 4 40
2 1
1 2 1
3 0
3 1
1 2 1
3 3
1 2 2
2 3 5
1 3 6
5 10
1 2 110
1 3 120
1 4 130
1 5 120
2 3 110
2 4 120
2 5 130
3 4 120
3 5 110
4 5 120
5 10
1 2 9384
1 3 887
1 4 2778
1 5 6916
2 3 7794
2 4 8336
2 5 5387
3 4 493
3 5 6650
4 5 1422
5 8
1 2 1
2 3 100
3 4 100
4 5 100
1 5 50
2 5 50
3 5 50
4 1 150
0 0

Sample Output

1
20
0
-1
-1
1
0
1686
50

kruskal 求最小生成树  暴力枚举
 1 #include <cstdio>
 2 #include <cstring>
 3 #include <string>
 4 #include <algorithm>
 5 #include <queue>
 6 using namespace std;
 7
 8 const int maxn = 5e4 + 10;
 9 const int INF = 0x7fffffff;
10 int fa[510], vis[maxn];
11 int n, m;
12 struct node {
13     int u, v, w;
14 } qu[maxn];
15 int cmp(node a, node b) {
16     return a.w < b.w;
17 }
18 int Find(int x) {
19     return fa[x] == x ? x : fa[x] = Find(fa[x]);
20 }
21 int combine(int x, int y) {
22     int nx = Find(x);
23     int ny = Find(y);
24     if(nx != ny) {
25         fa[nx] = ny ;
26         return 1;
27     }
28     return 0;
29 }
30 int kruskal(int x) {
31     int big = -INF, small = INF, k = 0 ;
32     for (int i = x ; i < m ; i++) {
33         if (combine(qu[i].u, qu[i].v)) {
34             k++;
35             big = max(big, qu[i].w);
36             small = min(small, qu[i].w);
37         }
38     }
39     if (k!=n-1) return INF;
40     if (k==1) return 0;
41     return big - small;
42 }
43 int main() {
44     while(scanf("%d%d", &n, &m) != EOF) {
45         if (n == 0 && m == 0) break;
46         for (int i = 0 ; i < m ; i++)
47             scanf("%d%d%d", &qu[i].u, &qu[i].v, &qu[i].w);
48         sort(qu, qu + m, cmp);
49         int ans = INF;
50         for (int i = 0 ; i < m; i++) {
51             for (int j = 0 ; j <= n ; j++) fa[j] = j;
52             ans = min(ans, kruskal(i));
53         }
54         if (ans==INF) printf("-1\n");
55         else printf("%d\n", ans);
56     }
57     return 0;
58 }


原文地址:https://www.cnblogs.com/qldabiaoge/p/9074298.html

时间: 2024-10-04 06:55:14

poj-3522 最小生成树的相关文章

poj 3522 枚举+kruskal

过了样例就能AC 注意一点 0条边特意判断下.是否无法构成生成树也要判断 #include<iostream> #include<stdio.h> #include<string.h> using namespace std; #define maxn 110 int parent[maxn]; int N,M; struct edge { int u,v,w; }edges[maxn*maxn]; int cmp(void const *a,void const *b

poj——2031 最小生成树(MST) Kruskal算法

poj——2031 最小生成树(MST)  Kruskal算法 Building a Space Station Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 4985   Accepted: 2503 Description You are a member of the space station engineering team, and are assigned a task in the constructio

poj 3522 Slim Span 最大边减最小边最小的生成树

枚举最小边进行kruskal. #include <cstdio> #include <algorithm> using namespace std; #define maxn 120 #define maxm 10000 struct edge { int u,v,w; }e[maxm]; int p[maxn],n,m; int find(int x) { if(x==p[x]) return x; return p[x]=find(p[x]); } void link(int

poj 1251(最小生成树)

Description The Head Elder of the tropical island of Lagrishan has a problem. A burst of foreign aid money was spent on extra roads between villages some years ago. But the jungle overtakes roads relentlessly, so the large road network is too expensi

POJ 3522 ——Slim Span——————【最小生成树、最大边与最小边最小】

Slim Span Time Limit: 5000MS   Memory Limit: 65536K Total Submissions: 7102   Accepted: 3761 Description Given an undirected weighted graph G, you should find one of spanning trees specified as follows. The graph G is an ordered pair (V, E), where V 

POJ 3522 Slim Span 最小生成树,暴力 难度:0

kruskal思想,排序后暴力枚举从任意边开始能够组成的最小生成树 #include <cstdio> #include <algorithm> using namespace std; const int maxn = 101; const int maxe = maxn * maxn / 2; struct edge{ int f,t,c; bool operator <(edge e2)const { return c<e2.c; } }e[maxe]; int

POJ 3522 Slim Span(最小生成树)

题意:给定一个n个点m条边的无向图,找一颗苗条度(最大边减最小边)最小的生成树. 思路:假设苗条度最小的这棵树的最小边为a,若要使苗条度最小,答案一定是以a为最小边的一颗最小生成树,所以可以考虑枚举最小边,计算出苗条度并更新答案. #include<cstdio> #include<cstring> #include<cmath> #include<cstdlib> #include<iostream> #include<algorithm

uva 1395 - Slim Span poj 3522 Slim Span(最小生成树算法)

最近学习了一下 最小生成树 算法. 所谓最小生成树算法,就是给出一个连通图g[ maxn ][ maxn  ], 找出这个连通图的边权和最小的生成图(树). 可以实现这个目的的算法,我叫它最小生成树算法.kruskal算法就是我学到的一种实现这种功能的算法. 对于kruskal算法的描述以及简单的证明在刘汝佳第二版上已经说得够明白 本题就是求 最小生成树 里面的 最大边权和最小边权 相差最小的最小生成树. #include<cstdio> #include<cstring> #in

UVA 1359 POJ 3522 Slim Span(最小生成树kruskal)

Given an undirected weighted graph G, you should find one of spanning trees specified as follows. The graph G is an ordered pair (V, E), where V is a set of vertices {v1, v2, …, vn} and E is a set of undirected edges {e1, e2, …, em}. Each edge e ∈ E 

(极差最小生成树)POJ 3522 - Slim Span

题意: 给定一张无向图,求出一个最长边减最短边最小的生成树. 分析: 这题之前做过一模一样的(应该是...),跑kruskal算法,维护一个subset,一旦出现了环,就删除这条环上最轻的边,不断更新subset,subset中存当前生成树的边,一旦边的个数m=点数n-1,就更新ans. 这个复杂度是O(m*n).但是在这里样例都过不去,应该是写搓了...鲁棒性不够. 还有一个解法是用动态树link-cut-tree,可以再把复杂度降成O(m*logn).但是我还不会.. 这题因为点的数量只有1