UVa 10048 噪音恐惧症（Floyd）

传送门

题意

输入一个C个点S条边的无向带权图，边权表示该路径上的噪声值。输入一些询问，每次询问两个点，输出这两点间最大噪声值最小的路径。

思路

最简单的方法就是Floyd算法。本来是求长度的，现在求最大噪声值最小的路径，稍微改一下就好了。

d[i][j]=min(d[i][j],max(d[i][k],d[k][j]))

其次，也可以用Dijkstra算法来计算。

代码

#include<iostream> 
#include<cstring>
#include<string>
#include<algorithm>
#include<vector>
using namespace std;

#define INF 1000001

int n, m, t;
int s, e;

int map[105][105];


int main()
{
    //freopen("D:\txt.txt", "r", stdin);
    int kase = 1;
    int a, b, w;
    while (scanf("%d%d%d", &n, &m,&t))
    {
        if (m == 0 && n == 0 && t == 0)  break;
        if (kase > 1)   printf("
");
        printf("Case #%d
", kase++);

        for (int i = 1; i <= n; i++)
        {
            map[i][i] = INF;
            for (int j = i + 1; j <= n; j++)
                map[i][j] = map[j][i] = INF;
        }

        
        for (int i = 0; i < m; i++)
        {
            scanf("%d%d%d", &a, &b, &w);
            map[a][b] = map[b][a] = w;
        }

        for (int k = 1; k <= n;k++)
        for (int i = 1; i <= n;i++)
        for (int j = 1; j <= n; j++)
            map[i][j] = min(map[i][j], max(map[i][k], map[k][j]));

        for (int i = 0; i < t; i++)
        {
            scanf("%d%d", &s, &e);
            if (map[s][e] == INF)   printf("no path
");
            else  printf("%d
", map[s][e]);
        }
    }
    return 0;
}

#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#include<queue>
using namespace std;
const int inf = 0x3f3f3f3f;
typedef pair<int, int> pii;

int c, s, q;
vector<pii> g[105];
bool vis[105];
int d[105][105];

struct HeapNode{
    int d, u;
    bool operator < (const HeapNode& rhs) const{
        return d > rhs.d;
    }
};


void dijkstra(int s){
    memset(vis, 0, sizeof(vis));
    for(int i=1; i<=c; i++)  d[s][i] = inf;
    d[s][s] = 0;
    priority_queue<HeapNode> Q;
    Q.push((HeapNode){0, s});
    while(!Q.empty()){
        HeapNode x = Q.top(); Q.pop();
        int u = x.u;
        if(vis[u])  continue;
        vis[u] = true;
        for(int i=0; i<g[u].size(); i++){
            int v = g[u][i].first;
            if(d[s][v] > max(d[s][u], g[u][i].second)){
                d[s][v] = max(d[s][u], g[u][i].second);
                Q.push((HeapNode){d[s][v], v});
            }
        }
    }
}

int main(){
    //freopen("in.txt", "r", stdin);
    int cas = 1;
    while(~scanf("%d%d%d", &c, &s, &q) && c && s && q){
        for(int i=1; i<=c; i++)  g[i].clear();
        if(cas > 1)  puts("");
        printf("Case #%d
", cas++);
        for(int i=0; i<s; i++){
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            g[u].push_back(make_pair(v, w));
            g[v].push_back(make_pair(u, w));
        }
        for(int i=1; i<=c; i++){
            dijkstra(i);
        }

        while(q--){
            int st, ed;
            scanf("%d%d", &st, &ed);
            if(d[st][ed] == inf)  puts("no path");
            else printf("%d
", d[st][ed]);
        }
    }
    return 0;
}