HDU 1595 find the longest of the shortest

这道题的题意就是有一个稠密图，一个人要从1走到N点，中间可能某一条路会断掉，求最短路最坏的情况, 也就是断掉某条路时，最短路径最长。

这道题，不难想到枚举删边求最短路，这种方法下，用SPFA无疑是最好的选择。

首先，用SPFA求出初始状态下的最短路，然后记录下最短路的路径，再枚举路径中的每条路，对每条路删除后求一次最短路，取最大值就行了。那么为什么只用枚举最短路上的这些路呢，很显而易见的是，如果我们删除的是除了最短路径以外的某条路，那么求出来的最短路还是这个最短路，并且是最短的最短路。所以只用枚举最短路径上的每一条路。

这里面有一个记录路径的方法需要注意一下，开一个pre数组，如果说松弛时d[v] > d[u] + w成立了，那么便更新pre数组为pre[v] = u;那么最后把路径输出来就是

for(i = n; i != 1; i = pre[i]) pre[i]和i的连线即为一条路。      

然后我在删边时，并没有真的删除这个节点，只是把节点上的值该为正无穷了。

/*
ID: sdj22251
PROG: subset
LANG: C++
*/
#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#define MAXN 1005
#define INF 100000000
#define eps 1e-9
#define L(x) x<<1
#define R(x) x<<1|1
using namespace std;
struct node
{
    int v, w;
    node *next;
} edge[MAXN], temp[MAXN * MAXN]; // 
struct wwj
{
    int x, y;
}road[MAXN * MAXN];
int d[MAXN], n, m, pos = 0;
int q[MAXN * MAXN];
bool visited[MAXN]; // 
int pre[MAXN];
int tt[MAXN][MAXN];
void spfa(int src, int *ecost) //src是起点， ecost是边权
{
    int h, t, u, i;
    node *ptr;
    h = 0, t = 1;
    memset(visited, 0, sizeof(visited));
    memset(pre, -1, sizeof(pre));
    q[0] = src;
    ecost[src] = 0;
    visited[src] = true;
    while(h < t)
    {
        u = q[h++];
        visited[u] = false;
        ptr = edge[u].next;
        while(ptr)
        {
            if(ecost[ptr -> v] > ecost[u] + ptr -> w)
            {
                pre[ptr -> v] = u;
                ecost[ptr -> v] = ecost[u] + ptr -> w;
                if(!visited[ptr -> v])
                {
                    q[t++] = ptr -> v;
                    visited[ptr -> v] = true;
                }
            }
            ptr = ptr -> next;
        }
    }
}
void insert(const int &x, const int &y, const int &w)
{
    node *ptr = &temp[pos++]; //注意 这里也可以用,node *ptr = new node, 但是极其消耗时间
    ptr -> v = y;
    ptr -> w = w;
    ptr -> next = edge[x].next;
    edge[x].next = ptr;
}
void changeit(const int &x, const int &y, int va)
{
    node *ptr = edge[x].next;
    while(ptr)
    {
        if(ptr -> v == y)
        {
            ptr -> w = va;
        }
        ptr = ptr -> next;
    }
}
void init()
{
    for(int i = 0; i <= n; i++)
    {
        edge[i].next = NULL;
        d[i] = INF;
    }
}
int main()
{
    int i, j;
    while(scanf("%d%d", &n, &m) != EOF)
    {
        int x, y, z;
        init();
        for(i = 0; i < m; i++)
        {
            scanf("%d%d%d", &x, &y, &z);
            insert(x, y, z);
            insert(y, x, z);
            tt[x][y] = tt[y][x] = z;
        }
        spfa(1, d);
        int ct = 0;
        for(i = n; i != 1; i = pre[i])
        {
            road[ct].x = i;
            road[ct].y = pre[i];
            ct++;
        }
        int ans = 0;
        for(i = 0; i < ct; i++)
        {
            changeit(road[i].x, road[i].y, INF);
            changeit(road[i].y, road[i].x, INF);
            for(j = 0; j <= n; j++)
            d[j] = INF;
            spfa(1, d);
            if(d[n] > ans) ans = d[n];
            changeit(road[i].x, road[i].y, tt[road[i].x][road[i].y]);
            changeit(road[i].y, road[i].x, tt[road[i].x][road[i].y]);
        }
        printf("%d\n", ans);
    }
    return 0;
}