Kruskal求两点之间边权值最小的边+Uva10048

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 Cindicates the number of crossings (crossings are numbered using distinct integers ranging from 1 to C), Srepresents the number of streets and Q is the number of queries.

Each of the next S lines contains three integers: c₁, c₂ and d indicating that the average sound intensity level on the street connecting the crossings c₁ and c₂ ( ) is d decibels.

Each of the next Q lines contains two integers c₁ and c₂ ( ) asking for the minimum sound intensity level you must be able to tolerate in order to get from crossing c₁ to crossing c₂.

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
思路：最小生成树+kruskal(借鉴)
要求：所有满足能够到达终点的路径中一条边的最大值中的最小值，那么自然跟最小生成树联系起来
分析：利用kruskal的算法的思想，我们先把所有的要求的路径保存起来。那么利用kruskal开始生成树，每加入一个连通分量的我们就去判断所有要求的路径中是否已经在同一个连通分量里面并且没有求过，因为我们知道如果两个点在这一次合并后变成同一个连通分量，那么这两个点的最短路已经形成，并且由于kruskal的性质上一次加入的边长度肯定比下一次加入的小。所以可以知道这个路径要求的ans 就是当前的这个边的权值
下面是代码：
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;
const int MAX=1100;
struct node
{
    int u,v;
    int s;
} city[MAX];
struct inquir
{
    int a,b;
} in[11000];
int C,S,Q;
int pre[110],rank[110],ans[10100];
bool cmp(node a,node b)
{
    return a.s<b.s;
}
void init()
{
    for(int i=0; i<=C; i++)
    {
        pre[i]=i;
        rank[i]=i;
    }
}
int find(int x)
{
    if(pre[x]==x)
        return x;
    return pre[x]=find(pre[x]);
}
void unite(int x,int y)
{
    if(rank[x]<rank[y])
        pre[x]=y;
    else
    {
        pre[y]=x;
        if(rank[x]==rank[y])
            rank[x]++;
    }
}
void can(int x)
{
    for(int i=1; i<=Q; i++)
    {
        if(find(in[i].a)==find(in[i].b)&&!ans[i])
        {
            ans[i]=city[x].s;
        }
    }
}
void K()
{
    sort(city+1,city+S+1,cmp);
    for(int i=1; i<=S; i++)
    {
        int x=find(city[i].u);
        int y=find(city[i].v);
        if(x!=y)
        {
            unite(x,y);
            can(i);
        }
    }
    for(int i=1; i<=Q; i++)
    {
        if(ans[i])
            cout<<ans[i]<<endl;
        else
            cout<<"no path"<<endl;
    }
}
int main()
{
    //freopen("in.txt","r",stdin);
    int c1,c2,sound;
    int loop=1;
    bool first=true;
    while(cin>>C>>S>>Q,C+S+Q)
    {

        for(int i=1; i<=S; i++)
            cin>>city[i].u>>city[i].v>>city[i].s;
        init();
        for(int i=1; i<=Q; i++)
        {
            cin>>in[i].a>>in[i].b;
            ans[i]=0;
        }    
        if(!first)
        cout<<endl;
        else
            first=false;
        cout<<"Case #"<<loop++<<endl;
        K();

    }
    return 0;
}