UVa 10048 - Audiophobia(Floyd, Kruskal)

链接:

http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=24&page=show_problem&problem=989

题目：

Problem B: Audiophobia

Consider yourself lucky! Consider yourself lucky to be still breathing and having fun participating in this contest. But we apprehend that many of your descendants may not have this luxury. For, as you
know, we are the dwellers of one of the most polluted cities on earth. Pollution is everywhere, both in the environment and in society and our lack of consciousness is simply aggravating the situation.

However, for the time being, we will consider only one type of pollution ­- the sound pollution. The loudness or intensity level of sound is usually measured in decibels and sound having intensity
level 130 decibels or higher is considered painful. The intensity level of normal conversation is 60­65 decibels and that of heavy traffic is 70­80 decibels.
Consider the following city map where the edges refer to streets and the nodes refer to crossings. The integer on each edge is the average intensity level of sound (in decibels) in the corresponding street.



To get from crossing A to crossing G you may follow the following path: A­C­F­G. In that case you must be capable of tolerating sound intensity as high
as 140 decibels. For the paths A­B­E­G, A­B­D­G and A­C­F­D­G you must tolerate respectively 90, 120 and 80 decibels of sound intensity. There are other paths, too. However, it is clear that A­C­F­D­G is
the most comfortable path since it does not demand you to tolerate more than 80 decibels.
In this problem, given a city map you are required to determine the minimum sound intensity level you must be able to tolerate in order to get from a given crossing to another.

Input

The input may contain multiple test cases.
The first line of each test case contains three integers

,

and

where C indicates
the number of crossings (crossings are numbered using distinct integers ranging from 1 to C), S represents the number of streets and Q is the number of queries.
Each of the next S lines contains three integers: c1, c2 and d indicating that the average sound intensity level on the street connecting the crossings c1 and c2 (

)
is d decibels.
Each of the next Q lines contains two integers c1 and c2 (

)
asking for the minimum sound intensity level you must be able to tolerate in order to get from crossing c1 to crossing c2.
The input will terminate with three zeros form C, S and Q.

Output

For each test case in the input first output the test case number (starting from 1) as shown in the sample output. Then for each query in the input print a line giving the minimum sound intensity level
(in decibels) you must be able to tolerate in order to get from the first to the second crossing in the query. If there exists no path between them just print the line ``no path".
Print a blank line between two consecutive test cases.

Sample Input

7 9 3
1 2 50
1 3 60
2 4 120
2 5 90
3 6 50
4 6 80
4 7 70
5 7 40
6 7 140
1 7
2 6
6 2
7 6 3
1 2 50
1 3 60
2 4 120
3 6 50
4 6 80
5 7 40
7 5
1 7
2 4
0 0 0

Sample Output

Case #1
80
60
60
 
Case #2
40
no path
80

题目大意：

从a点到b点， 找到一条路径，使得这条路径上的所有噪音中最大的值是所有路径中最小的， 这个噪音值便是要求的。

分析与总结：

用floyd是找出所有路径中长度最小的，只需要稍微变形一下，便可求得答案。

除了用这个方法，还可以用Kruskal算法，按照Kruskal算法的步骤，一条边一条边的加入树中，每加入一次，就判断所有要问的起点和终点是否已经连通， 一旦有连通的，那么那条路径中的最大值便是当前加入的这条边的权值，因为加入的边是按照从小到大顺序加入的。



代码：

1.Kruskal

#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 1005
using namespace std;
int n,m,Q, f
,rank
,ans[N*10];
bool vis[N*10];

struct Edge{
    int u,v,val;
    friend bool operator<(const Edge&a,const Edge&b){
        return a.val < b.val;
    }
}arr
;
struct Query{
    int id, u, v;
}q[N*10];

inline void init(){
    for(int i=0; i<N; ++i)
        f[i]=i,rank[i]=0;
}
int find(int x){
    int i,j=x;
    while(j!=f[j]) j=f[j];
    while(x!=j){
        i=f[x]; f[x]=j; x=i;
    }
    return j;
}
bool Union(int x, int y){
    int a=find(x), b=find(y);
    if(a==b)return false;
    if(rank[a]>rank)
        f[b]=a;
    else{
        if(rank[a]==rank[b])
            ++rank[b];
        f[a]=b;
    }
    return true;
}
    

int main(){
    int a,b,c,cas=1;
    while(~scanf("%d%d%d",&n,&m,&Q)){
        if(!n&&!m&&!Q) break;
        for(int i=0; i<m; ++i){
            scanf("%d%d%d",&a,&b,&c);
            arr[i].u=a, arr[i].v=b, arr[i].val=c;
        }
        for(int i=0; i<Q; ++i){
            scanf("%d%d",&a,&b);
            q[i].id=i, q[i].u=a, q[i].v=b;
        }
        init();
        memset(vis, 0, sizeof(vis));
        memset(ans, -1, sizeof(ans));
        sort(arr,arr+m);
        for(int i=0; i<m; ++i){
            if(Union(arr[i].u,arr[i].v)){
		        for(int j=0; j<Q; ++j)if(!vis[j]){
		            int a=find(q[j].u), b=find(q[j].v);
		            if(a==b){
                        vis[j] = true;
                        ans[j] = arr[i].val;
		            }
            	}
            }
        }
        if(cas!=1) printf("\n");
        printf("Case #%d\n", cas++);
        for(int i=0; i<Q; ++i){
            if(ans[i]==-1) printf("no path\n");
            else printf("%d\n", ans[i]);
        }
    }
    return 0;
}

[b]2.Floyd

#include<cstdio>  
#include<cstring>  
#include<algorithm>  
const int N = 105;
const int INF = 1000000000;
using namespace std;
int d

, n, m, Q;

inline void read_graph(){
    for(int i=1; i<N; ++i){
        d[i][i] = INF; 
        for(int j=i+1; j<N; ++j)
            d[i][j]=d[j][i]=INF;
    }
    int a,b,c;
    for(int i=0; i<m; ++i){
        scanf("%d%d%d",&a,&b,&c);
        d[a]=d[b][a]=c;
    }
}
inline void Floyd(){
    for(int k=1; k<=n; ++k){
        for(int i=1; i<=n; ++i){
            for(int j=1; j<=n; ++j){
                int tmp = max(d[i][k], d[k][j]);
                d[i][j] = min(d[i][j], tmp);
            }
        }
    }
}
inline void output(){
    int u,v;
    for(int i=0; i<Q; ++i){
        scanf("%d%d",&u,&v);
        if(d[u][v]!=INF) printf("%d\n",d[u][v]);
        else printf("no path\n");
    }
}

int main(){
    int a,b,c,cas=1;
    while(~scanf("%d%d%d",&n,&m,&Q)){
        if(!n&&!m&&!Q) break;
        read_graph();
        Floyd();
        if(cas!=1) puts("");
        printf("Case #%d\n",cas++);
        output();
    }
    return 0;
}

[b]——  生命的意义，在于赋予它意义。               原创 http://blog.csdn.net/shuangde800 ， By   D_Double  (转载请标明)