POJ 3522 Slim Span【枚举+克鲁斯卡尔求最小生成树】

Slim Span


Time Limit: 5000MS


Memory Limit: 65536K


Total Submissions: 7365


Accepted: 3909

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 andbk (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 ofek. 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

题目大意:给你n个点,m条边,求一颗生成树,使得其最大权值边-最小权值边的权值最小。

分析题目:求生成树,使得最大权值边-最小权值边的权值尽可能小,我们不难想到使用克鲁斯卡尔贪心求最小生成树算法,因为贪心的求能够使得最大权值边-最小权值边尽可能的小,但是因为并不是最小生成树就一定是那棵目标生成树,所以我们这里采用枚举的方法来解决,点不多, 还给了5000ms。当然可以使用枚举的方法来解决这个问题啦~。

AC代码:

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
struct path
{
    int x,y,w;
} a[100000];
int f[10000];
int n,m;
int output;
int cmp(path a,path b)
{
    return a.w<b.w;
}
int find(int a)
{
    int r=a;
    while(f[r]!=r)
    r=f[r];
    int i=a;
    int j;
    while(i!=r)
    {
        j=f[i];
        f[i]=r;
        i=j;
    }
    return r;
}
void merge(int a,int b)
{
    int A,B;
    A=find(a);
    B=find(b);
    if(A!=B)
    f[B]=A;
}
void init()
{
    for(int i=1; i<=n; i++)
    {
        f[i]=i;
    }
}
void solve(int x)
{
    int cont=0;
    int minn=0x1f1f1f1f;
    int maxn=-0x1f1f1f1f;
    init();
    for(int i=x; i<m; i++)
    {
        if(find(a[i].x)!=find(a[i].y))
        {
            minn=min(a[i].w,minn);
            maxn=max(a[i].w,maxn);
            merge(a[i].x,a[i].y);
            cont++;
        }
    }
    if(cont==n-1)
    {
       // printf("%d\n",maxn-minn);
        output=min(output,maxn-minn);
    }
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        if(n+m==0)break;
        output=0x1f1f1f1f;
        for(int i=0; i<m; i++)
        {
            scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].w);
        }
        sort(a,a+m,cmp);
        for(int i=0; i<m; i++)
        {
            if(m-i<n-1)break;
            solve(i);
        }
       // printf("%d\n",output);
        if(output!=0x1f1f1f1f)
        printf("%d\n",output);
        else printf("-1\n");
    }
}
时间: 2024-11-04 15:14:03

POJ 3522 Slim Span【枚举+克鲁斯卡尔求最小生成树】的相关文章

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 3522 Slim Span (Kruskal +枚举 边权差最小的生成树)

Slim Span Time Limit: 5000MS Memory Limit: 65536K Total Submissions: 6685 Accepted: 3544 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 is a

POJ - 3522 Slim Span (kruskal+枚举)

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 is a set of vertices {v1, v2, -, vn} and E is a set of undirected edges {e1, e2, -, em}. Each

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 

UVa1395 &amp;&amp; POJ 3522 Slim Span

UVa POJ Description 求苗条度最小的生成树 苗条度指该生成树的最大边 - 最小边 Algorithm Kruskal变形 先sort 然后枚举最小边 构建最小生成树 Hint UVa JAVA的RE 不知道为何= = POJ的JAVA才1.5 λ表达式是JAVA 1.8才有的 然后本人才疏学浅 除了λ表达式以外不会写自定义sort比较 所以CE = = C++就过了 会了C++ 的INF写法 #include <climits> 这样就有 INT_MAX这个常量了 Code

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

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

POJ 3522 Slim Span (并查集 + 枚举 + kruskal)

链接:点击打开链接 题目好长, 而且还有图片,所以就不复制粘贴过来了,这道题的大意是: 一棵树T(连通无环子图)将用n-1条边连接原图的所有的n个顶点,生成的生成树的最大权值边与最小权值边的差(称"苗条值")尽量小,找出这个最小的苗条值: 思路: 用kruskal枚举: 首先对每条边的权值从小到大进行排序: 枚举每条边为最小边生成最小生成树,并计算这样的生成树的苗条值,枚举玩所有的情况就可以求出苗条值: 代码解析如下: #include <iostream> #includ

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

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

POJ 3522 Slim Span

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