hdu 1595 find the longest of the shortest (dijkstra + spfa)

find the longest of the shortest

题目链接：Problem - 1595

题目大意：现有一个无向图，其中某一条边不存在（要删除），求所有情况中最短路里的最大值。

题目分析：

思路一：枚举m条边，一一删除进行spfa求出最短路，然后比较出最大值。（超时）

思路二：先利用dijkstra求出最短路，再在最短路里枚举个边，一一删除进行spfa求出最短路，然后比较最大值。（AC)

思路分析：之所以能在最短路里删边求最小值，避免了一一枚举m条边，是因为删边后最短路要保持其值小，如果删除最短路意外的边，所有最小值都等于最短路的值，就不存在最大值了，所以利用原来最短路的基础上删边是优化的正确选择。

步骤： 1）存图  vector

2）找最短路 dijkstra

3）路径还原 (前驱)

4）在最短路中一一删边，每次求出最短路，比较出最大值(spfa)

贴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;
int vis[1005];
int road[1005];   //记录路径
int a, b, t, couts, _a, _b, k;
unsigned int ans, maxs;
struct qq{
    int to, cost;
};
qq input;
vector <qq> v[1005];    //存图
struct node{
    int cost, pre;
};
node low[1005]; //dijkstra用
struct pp{
    int loc, cost;
    friend bool operator < (pp a, pp b)
    {
        return a.cost > b.cost;
    }
};      //spfa优先队列用
void dijkstra()   //求最短路径并还原路径  wa在此处3次
{
    for (int i = 1; i <= n; i++){
        low[i].cost = 10000005;
        low[i].pre = 0;
    }
    memset(vis, 0, sizeof(vis));
    low[1].cost = low[1].pre = 0;
    vis[1] = 1;
    for (int i = 0; i < v[1].size(); i++){
        low[v[1][i].to].cost = v[1][i].cost;
        low[v[1][i].to].pre = 1;
    }
    for (int j = 1; j < n; j++){
        unsigned int mins = -1;
        int loc = 1;
        for (int i = 1; i <= n; i++){
            if (low[i].cost && low[i].cost < mins && vis[i] == 0){
                mins = low[i].cost;
                loc = i;
            }
        }       //找到最小值位置
        vis[loc] = 1;
        for (int i = 0; i < v[loc].size(); i++){
            if (vis[v[loc][i].to] == 1) continue;
            // 如果满足更新后的距离小于原来的值，则可以更新，并更新前驱
            if (low[v[loc][i].to].cost > low[loc].cost + v[loc][i].cost){
                low[v[loc][i].to].cost = low[loc].cost + v[loc][i].cost;
                low[v[loc][i].to].pre = loc;
            }
        }
    }
    //路径还原
    k = n;
    couts = 0;
    road[couts++] = k;
    while(k != 0){
        road[couts++] = low[k].pre;
        k = low[k].pre;
    }
}
void spfa()     //求最短路的spfa  被题目绕进去了一开始求了最大值，wa了一次
{
    priority_queue <pp> q;
    while (!q.empty()) q.pop();
    memset(vis, 0, sizeof(vis));
    pp start;
    start.loc = 1;
    start.cost = 0;
    q.push(start);
    while (!q.empty()){
        pp news, tmp;
        tmp = q.top();
        q.pop();
        vis[tmp.loc] += 1;
        if (tmp.loc == n){
            if (ans > tmp.cost)
                ans = tmp.cost;
            break;
        }           //要求出每次删边的最短路！
        for (int i = 0; i < v[tmp.loc].size(); i++){
            news = tmp;
            if (vis[v[tmp.loc][i].to] == 1) continue;
            if (vis[tmp.loc] > 1) continue;
            //删边
            if (tmp.loc == _a && v[tmp.loc][i].to == _b) continue;
            if (v[tmp.loc][i].to == _a && tmp.loc == _b) continue;
            news.loc = v[tmp.loc][i].to;
            news.cost += v[tmp.loc][i].cost;
            //printf("%d -> %d , cost %d\n", tmp.loc, news.loc, news.cost);
            q.push(news);
        }
    }
}
int main()
{
    while (scanf("%d", &n) != EOF && n){
        scanf("%d", &m);
        for (int i = 0; i < 1005; i++)
            v[i].clear();
        for (int i = 0; i < m; i++){
            scanf("%d%d%d", &a, &b, &t);
            input.to = b;
            input.cost = t;
            v[a].push_back(input);
            input.to = a;
            v[b].push_back(input);
        }
        dijkstra();
        maxs = 0;
        for (int i = 0; i < couts - 1; i++){
            //printf(" -> %d ", road[i]);
            _a = road[i];
            _b = road[i+1];
            ans = -1;
            spfa();
            if (maxs < ans)
                maxs = ans;    //在每次求出的最短路中找出最大值
        }
        printf("%d\n", maxs);
    }
}