HDU 1598 find the most comfortable road

最新推荐文章于 2020-09-07 07:18:51 发布

Sherlock_n

最新推荐文章于 2020-09-07 07:18:51 发布

阅读量339

点赞数

分类专栏： ACM-最小生成树文章标签： HDU 1598 最小生成树

本文链接：https://blog.csdn.net/Courage_kn/article/details/51883249

版权

ACM-最小生成树专栏收录该内容

5 篇文章 0 订阅

订阅专栏

巴卡斯（杭州），亚信科技，壹晨仟阳(杭州)
Hot~~欢迎“信息学（OI）选手”——报考杭州电子科技大学！

find the most comfortable road

Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 6133 Accepted Submission(s): 2639

Problem Description

XX星有许多城市，城市之间通过一种奇怪的高速公路SARS(Super Air Roam Structure---超级空中漫游结构）进行交流，每条SARS都对行驶在上面的Flycar限制了固定的Speed，同时XX星人对 Flycar的“舒适度”有特殊要求，即乘坐过程中最高速度与最低速度的差越小乘坐越舒服 ,(理解为SARS的限速要求，flycar必须瞬间提速/降速，痛苦呀 ),
但XX星人对时间却没那么多要求。要你找出一条城市间的最舒适的路径。(SARS是双向的）。

Input

输入包括多个测试实例，每个实例包括：
第一行有2个正整数n (1<n<=200)和m (m<=1000),表示有N个城市和M条SARS。
接下来的行是三个正整数StartCity,EndCity,speed,表示从表面上看StartCity到EndCity,限速为speedSARS。speed<=1000000
然后是一个正整数Q（Q<11),表示寻路的个数。
接下来Q行每行有2个正整数Start,End, 表示寻路的起终点。

Output

每个寻路要求打印一行，仅输出一个非负整数表示最佳路线的舒适度最高速与最低速的差。如果起点和终点不能到达，那么输出-1。

Sample Input

Sample Output

1
0

Author

ailyanlu

Source

HDU 2007-Spring Programming Contest - Warm Up （1）

Recommend

8600

题意：给定一个图，求两点间路径上，两条边的最大权值差。

思路：利用kruskal算法的方法。对边排序，从最小的边开始枚举，依次添加比它大的边，知道所给的两个点连通，用最后一条边的权值减去开始枚举的那条边的权值。维护的最大值就是答案。和这一题一样的题还有POJ 3522 Slim Span。这篇博客写的详细一点。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cstring>
#include <cmath>
using namespace std;
const int MAX_V = 205;
const int MAX_E = 1004;
const int INF = INT_MAX;

int V, E;
int par[MAX_V];
int ran[MAX_V];
int start, en;

void init(int n)
{
    for(int i = 0; i < n; ++i) {
        par[i] = i;
        ran[i] = 0;
    }
}

int fin(int x)
{
    if(par[x] == x) {
        return x;
    } else {
        return par[x] = fin(par[x]);
    }
}

bool same(int x, int y)
{
    return fin(x) == fin(y);
}

void unite(int x, int y)
{
    x = fin(x);
    y = fin(y);
    if(x == y) {
        return ;
    }
    if(ran[x] < ran[y]) {
        par[x] = y;
    } else {
        par[y] = x;
        if(ran[x] == ran[y]) {
            ran[x]++;
        }
    }
}

struct edge {
    int u, v, cost;
};

bool comp(const edge & e1, const edge & e2)
{
    return e1.cost < e2.cost;
}

edge es[MAX_E];

int kruskal(int t)
{
    init(V);
    for(int k = t; k < E; ++k) {  //枚举每一条边
        edge e = es[k];
        if(!same(e.u, e.v)) {
            unite(e.u, e.v);
        }
        if(same(start, en)) {  //判断这两个点是否连通
            return e.cost - es[t].cost;
        }
    }
    return INF;
}

int main()
{
    while(scanf("%d%d", &V, &E) != EOF) {
        for(int i = 0; i < E; ++i) {
            scanf("%d%d%d", &es[i].v, &es[i].u, &es[i].cost);
            es[i].v--;
            es[i].u--;
        }
        int q;
        scanf("%d", &q);
        sort(es, es + E, comp);
        for(int i = 0; i < q; ++i) {
            scanf("%d%d", &start, &en);
            start--;
            en--;
            int ans = INF;
            for(int j = 0; j < E; ++j) {
                ans = min(ans, kruskal(j));
            }
            if(ans == INF) {
                cout << -1 << endl;
            } else {
                printf("%d\n", ans);
            }
        }
    }
    return 0;
}