hdu 1598 find the most comfortable road (并查集+枚举下界)

find the most comfortable road

题目链接：Problem - 1598

题目大意：求一条差值最小的路。

题目分析：

思路一：深搜，一一枚举各条合法的路，如果此路连接了起始点和结束点，计算此时的差，然后比较得出差得最小值。

（路的个数有1000条，此方法肯定会超时）

思路二：dijkstra，找出一条最短路，一路上记录最大值，最小值，比如1->2->5,记录Low[5][2].maxs,和low[5][2].mins(5是pos,2是pre)最后对low[e][]扫一遍，得出最小值。（此方法只能保留一个前驱的mins,maxs，比如2 -> 5有[mins,maxs]=[2,5]和[1,4],2个范围不冲突，应全部保留，此方法值能保留一个，wa）

思路三：并查集+枚举下界。对路的长度进行排序，枚举下界mins，进行并查集操作，因为每次枚举都是先选小边再选大边，所以一旦满足finds(end)=finds(start)，所得到的差值一定是此下界最小的情况。

思路分析：

1）存路并排序（road[1005])

2）枚举下界，mins值，每次都进行并查集操作，当start和end点根相同时记录cha，比较出所有情况下cha的最小值。

笔者心得：做图论题一是考虑方法，而是考虑复杂度，否则一直会死在错误算法里，笔者就再思路二上挣扎了1天。

贴AC代码：

#include <stdio.h> //定义输入／输出函数
#include <limits.h> //定义各种数据类型最值常量
#include <math.h> //定义数学函数
#include <stdlib.h> //定义杂项函数及内存分配函数
#include <string.h> //字符串处理
#include <algorithm>//算法
#include <queue>//队列
#include <stack>//栈
#include <vector>
using namespace std;
int n, m, q, mins, maxs, ans, s, e;
int re[205];
struct node{
    int from, to, cost;
};
node road[1005];
int finds(int x){
    if (re[x] == x) return x;
    else return re[x] = finds(re[x]);
}
int cmp(node a, node b){
    return a.cost < b.cost;
}
int main()
{
    while (scanf("%d", &n) != EOF && n){
        scanf("%d", &m);
        for (int i = 0; i < m; i++){
            scanf("%d%d%d", &road[i].from, &road[i].to, &road[i].cost);
        }
        sort(road, road + m, cmp);
        scanf("%d", &q);
        while (q--){
            scanf("%d%d", &s, &e);
            ans = 1000005;
            int flag = 0;
            for (int i = 0; i < m; i++){
                //枚举min；
                mins = 1000005;
                maxs = 0;
                for (int j = 1; j <= n; j++)
                    re[j] = j;
                for (int j = i; j < m; j++){
                    //kruskal
                    if (finds(road[j].from) == finds(road[j].to)) continue;
                    re[finds(road[j].from)] = finds(road[j].to);
                    mins = min(road[j].cost, mins);
                    maxs = max(road[j].cost, maxs);
                    //printf("%d <-> %d == [%d, %d]\n", road[j].from, road[j].to, mins, maxs);
                    if (finds(s) == finds(e)){
                        flag = 1;
                        if (ans > maxs - mins)
                            ans = maxs - mins;
                        break;
                    }
                }
            }
            if (flag == 1) printf("%d\n", ans);
            else printf("-1\n");
        }
    }
}

贴思路二代码：

#include <stdio.h> //定义输入／输出函数
#include <limits.h> //定义各种数据类型最值常量
#include <math.h> //定义数学函数
#include <stdlib.h> //定义杂项函数及内存分配函数
#include <string.h> //字符串处理
#include <algorithm>//算法
#include <queue>//队列
#include <stack>//栈
#include <vector>
using namespace std;
int n, m, Q, s, e, tmp;
int map[205][205];
struct node{
    int mins, maxs, cha;
};
node low[205];
bool vis[205];
void input()
{
    int a, b, c;
    scanf("%d%d%d", &a, &b, &c);
    map[a][b] = c;
    map[b][a] = c;
}
void dijkstra()
{
    memset(low, 0, sizeof(low));
    for (int i = 0; i < 205; i++)
        low[i].cha = 1000005;
    memset(vis, 0, sizeof(vis));
    //int flag = 1;
    for (int i = 1; i <= n; i ++){
        if (map[s][i] == 0) continue;
        low[i].mins = low[i].maxs = map[s][i];
        low[i].cha = 0;
        // flag = 0;
    }
    //从s出发，初始化
    //if (flag == 1) return;
    // 是否连通
    vis[s] = 1;
    for (int i = 0; i < n-1;i ++){
        unsigned int cmp = 1000005;
        tmp = 0;
        for (int j = 1; j <= n; j++){
            if (low[j].cha < cmp && vis[j] == 0){
                cmp = low[j].cha;
                tmp = j;
            }
        }
        if (tmp == 0) continue;
        vis[tmp] = 1;
        for (int j = 1; j <= n; j++){
            if (vis[j] == 1) continue;
            if (map[tmp][j] == 0) continue;
            int k = max(low[tmp].maxs, map[tmp][j]);
            int kk = min(low[tmp].mins, map[tmp][j]);
            if (low[j].cha > k - kk){
                low[j].cha = k - kk;
                low[j].maxs = k;
                low[j].mins = kk;
            }
            //printf("%d(%d,%d)  --> %d == %d\n", tmp,low[j].maxs, low[j].mins, j, low[j].cha);
        }
    }
}
int main()
{
    while (scanf("%d", &n) != EOF && n){
        scanf("%d", &m);
        memset(map, 0, sizeof(map));
        for (int i = 0; i < m; i ++)
            input();
        scanf("%d", &Q);
        while (Q--){
            scanf("%d%d", &s, &e);
            dijkstra();
            if (low[e].cha != 1000005)printf("%d\n", low[e].cha);
            else printf("-1\n");
        }
    }
}

贴思路一代码：

#include <stdio.h> //定义输入／输出函数
#include <limits.h> //定义各种数据类型最值常量
#include <math.h> //定义数学函数
#include <stdlib.h> //定义杂项函数及内存分配函数
#include <string.h> //字符串处理
#include <algorithm>//算法
#include <queue>//队列
#include <stack>//栈
#include <vector>
using namespace std;
int n, m, q, mins, maxs, s, e, couts, ans;
bool vis[205];
int map[205][205];
int road[205];
void dfs(int loc)
{
    if (loc == e){
        maxs = 0;
        mins = 1000005;
        for (int j = 0; j < couts; j++){
            if (road[j] > maxs) maxs = road[j];
            if (road[j] < mins) mins = road[j];
        }
        if (ans > maxs - mins)
            ans = maxs - mins;
        return;
    }
    for (int i = 1; i <= n; i++){
        if (vis[i] == 1) continue;
        if (map[loc][i] == 0) continue;
        road[couts++] = map[loc][i];
        vis[i] = 1;
        dfs(i);
        vis[i] = 0;
        couts--;
    }
}
int main()
{
    while(scanf("%d", &n) != EOF && n){
        scanf("%d", &m);
        memset(map, 0, sizeof(map));
        while(m--){
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            map[a][b] = map[b][a] = c;
        }
        scanf("%d", &q);
        while (q--){
            scanf("%d%d", &s, &e);
            memset(vis, 0, sizeof(vis));
            memset(road, 0, sizeof(road));
            couts = 0;
            vis[s] = 1;
            ans = 1000005;
            if (s == e){
            	printf("0\n");
            	continue;
            }
            dfs(s);
            if (ans != 1000005) printf("%d\n", ans);
            else printf("-1\n");
        }
    }
}