1002

1002 - Country Roads

I am going to my home. There are many cities and many bi-directional roads between them. The cities are numbered from 0 to n-1 and each road has a cost. There are m roads. You are given the number of my city t where I belong. Now from each city you have to find the minimum cost to go to my city. The cost is defined by the cost of the maximum road you have used to go to my city.

 

For example, in the above picture, if we want to go from 0 to 4, then we can choose

1)      0 - 1 - 4 which costs 8, as 8 (1 - 4) is the maximum road we used

2)      0 - 2 - 4 which costs 9, as 9 (0 - 2) is the maximum road we used

3)      0 - 3 - 4 which costs 7, as 7 (3 - 4) is the maximum road we used

So, our result is 7, as we can use 0 - 3 - 4.

Input

Input starts with an integer T (≤ 20), denoting the number of test cases.

Each case starts with a blank line and two integers n (1 ≤ n ≤ 500) and m (0 ≤ m ≤ 16000). The next m lines, each will contain three integers u, v, w (0 ≤ u, v < n, u ≠ v, 1 ≤ w ≤ 20000) indicating that there is a road between u and v with cost w. Then there will be a single integer t (0 ≤ t < n). There can be multiple roads between two cities.

Output

For each case, print the case number first. Then for all the cities (from 0 to n-1) you have to print the cost. If there is no such path, print 'Impossible'.

Sample Input	Output for Sample Input
2 5 6 0 1 5 0 1 4 2 1 3 3 0 7 3 4 6 3 1 8 1 5 4 0 1 5 0 1 4 2 1 3 3 4 7 1	Case 1: 4 0 3 7 7 Case 2: 4 0 3 Impossible Impossible

Note

Dataset is huge, user faster I/O methods.

---

PROBLEM SETTER: JANE ALAM JAN

思路：最小生成树变形。

由于要找一条路径从出发点到另一点的路径中最大边的值最小。

根据最小生成树的算法，我们在算最小生成树的时候优先选择到集合路径最小的点加入集合，并把边加上，因为我们要选的从出发点到另一点的路径中最大边的值最小。

所以由最小生成树的优先可以知道我们所选的边是当前最小的，，所以满足要保证路径上的边都是最优的，并且更新的时候为  d[vec[l][i].to]=max(vec[l][i].cost,d[l]);

这就保证了，到当前的点的路的最大值，这样每次选最大值最小的。

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include<vector>
#include<string.h>
void prim(int n,int cnt);
int ma[600][600];
using namespace std;
typedef long long LL;
typedef struct pp {
    int from;
    int to;
    int cost;
} ss ;
int d[600];
vector<ss>vec[600];
int main(void) {
    int i,j,k,p,q;
    int x,y,z;
    int s;
    scanf("%d",&k);
    for(s=1; s<=k; s++) {
        for(i=0; i<600; i++) {
            vec[i].clear();
            for(j=0; j<600; j++) {
                ma[i][j]=1e9;

            }
        }
        scanf("%d %d",&p,&q);
        while(q--) {
            scanf("%d %d %d",&x,&y,&z);
            if(ma[x][y]>z) {
                ma[y][x]=z;ma[x][y]=z;
            }
        }
        for(i=0; i<600; i++) {
            for(j=0; j<600; j++) {
                if(ma[i][j]!=1e9) {
                    ss dd;
                    dd.cost=ma[i][j];
                    dd.from=i;
                    dd.to=j;
                    vec[dd.from].push_back(dd);
                }
            }
        }
        int u;
        cin>>u;
        prim(u,p-1);
        printf("Case %d:
",s);
        for(i=0; i<p; i++)
            if(d[i]!=1e9)printf("%d
",d[i]);
            else printf("Impossible
");
    }
    return 0;

}
void prim(int n,int cnt) {
    fill(d,d+600,1e9);
    d[n]=0;
    queue<int>que;bool flag[600];
    memset(flag,0,sizeof(flag));
    while(true)
    {
        int l=-1;int i;
        for(i=0;i<=cnt;i++)
        {
            if((l==-1||d[i]<d[l])&&!flag[i])
            {
                l=i;
            }
        }
        if(l==-1||d[l]==1e9)
        {
            break;
        }
        flag[l]=true;
        for(i=0;i<vec[l].size();i++)
        {
            if(d[vec[l][i].to]>vec[l][i].cost)
            {
                d[vec[l][i].to]=max(vec[l][i].cost,d[l]);
            }
        }
    }
}