Poj 352 UVA oj 1395 Slim Span 最小生成树应用

Slim Span
Time Limit: 5000MS Memory Limit: 65536K
Total Submissions: 7147 Accepted: 3783
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 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 {v1, v2, v3, v4} and five undirected edges {e1, e2, e3, e4, e5}. 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 Tb, Tc 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 ek. wk is a positive integer less than or equal to 10000, which indicates the weight of ek. You can assume that the graph G = (V, E) 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条边，找到一个生成树，使这个生成树中最大边权值减去最小边权值的最小值。

首先，找生成树，肯定是prim和kruskal，只有100个点，感觉都可以用，但是，kruskal感觉好写一些，我用的kruskal。

然后具体做法是，暴力枚举每条边形成的生成树，然后找出每个生成树的最大边和最小边的差值，再找出最小值就是了。过程就是对边进行排序（小到大，大到小也可以，我采用小到大），从最小边进行枚举，每个边边找到一棵树，直到找到n-1条边，因为排过序，然后用最后的这条边权值减去最开始进来的第一条边的权值，得到一个答案，然后暴力找出了所有答案筛选出最小的一个就行了。注意，因为最少都要n-1条边，所以枚举边的时候只能枚举到第m-(n-1)+1 == m-n+2条边（我的一条边序号为1），还有，当这个图不连通时，输出-1。

CODE

#include"stdio.h"
#include"iostream"
#include"algorithm"
#include"string.h"
#include"math.h"
#include"stdlib.h"
#include"queue"
#define inf 777777777
#define maxn 105
using namespace std;

struct node
{
    int st;
    int en;
    int len;
}edge[maxn*maxn];  ///边
int n,m;   ///n个点m条边
int fa[maxn];   ///记录父亲节点

bool cmp(node a,node b)   ///由小到大排序
{
    if(a.len < b.len)
        return true;
    return false;
}

int Find(int x)   ///找根节点
{
    if(fa[x] == x)
        return x;
    else
        return fa[x] = Find(fa[x]);
}
int kruskal(int loc)   ///kruskal加点改动
{
    for(int i = 0;i <= n;i++)   ///把每个点的父亲节点设置本身
        fa[i] = i;
    int cnt = 0;   ///统计加边的数量
    for(int i = loc;i <= m;i++)
    {
        int fx = Find(edge[i].st);
        int fy = Find(edge[i].en);
        if(fx != fy)
        {
            fa[fx] = fy;
            cnt++;
            if(cnt == n-1)   ///如果已经统计了n-1条边了，返回最大和最小权值之差
                return edge[i].len-edge[loc].len;
        }
    }
    return -1;   ///不能统计到n-1条边，图不连通，返回-1
}
int main(void)
{
    while(scanf("%d%d",&n,&m) && (n||m))
    {
        for(int i = 1;i <= m;i++)
        {
            scanf("%d%d%d",&edge[i].st,&edge[i].en,&edge[i].len);
        }
        sort(edge+1,edge+m+1,cmp);   ///排序
        int ans = inf;   ///找最小赋最大初值
        for(int i = 1;i <= m-n+2;i++)   ///枚举每条边
        {
            int t = kruskal(i);
            if(t != -1)
                ans = min(ans,t);
        }
        if(ans == inf)   ///ans值没有变化就输出-1
            printf("-1\n");
        else
            printf("%d\n",ans);
    }
    return 0;
}