给定一个无向图，求删掉一条边之后的最短路，但是删的是哪条边你不知道，问最坏情况下最短路是多长（）

题目来源：晴天的魔法乐园

分析：

综合上述讨论，本题的做法就是，先求一次最短路，用pre数组记录【其中一条】最短路径，然后遍历这条最短路径上的边，删除后各求一次路径，取他们中从起点到终点的最短距离的最大值即可

 

//// patest.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
////
#include "pch.h"

#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <iterator>
#include <algorithm>
#include <string>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <vector>
#include <stack>
#include <queue>
#include <deque>

using namespace std;
const int INF = 0x7fffffff;
const int maxn = 1010;
const int maxk = 10010;

//void printVector(vector<int>& vt) {
//    int size = vt.size();
//    for (int i = 0; i < size; i++) {
//        printf("%d", vt[i]);
//        if (i != size - 1) printf(" ");
//    }
//    printf("
");
//
//}


int n, m, st, ed;
bool vis[maxn];
int d[maxn];
int G[maxn][maxn];

vector<int> pre[maxn];

void Dijkstra(int s) {

    memset(vis, false, sizeof(vis));
    fill(d, d + maxn, INF);
    d[s] = 0;
    for (int i = 0; i < n; i++) {
        int u = -1, MIN = INF;
        for (int j = 1; j <= n; j++) {
            if (vis[j] == false && d[j] < MIN) {
                MIN = d[j];
                u = j;
            }
        }

        if (u == -1) return;
        vis[u] = true;
        for (int v = 1; v <= n; v++) {
            if (vis[v] == false && G[u][v] != INF) {
                if (d[u] + G[u][v] < d[v]) {
                    d[v] = d[u] + G[u][v];
                    pre[v].clear();
                    pre[v].push_back(u);
                }
                else if (d[u] + G[u][v] == d[v]) {
                    pre[v].push_back(u);
                }
            }
        }
        
    }
}

vector<pair<int, int>> ans;

void DFS(int index) {
    for (auto next : pre[index]) {
        ans.push_back(make_pair(index, next));
        DFS(next);
    }
}

int maxTime = -1;
int main() {

    fill(G[0], G[0] + maxn * maxn, INF);

    scanf("%d%d", &n, &m);
    st = 1, ed = n;
    for (int i = 0; i < m; i++) {
        int u, v, time;
        scanf("%d%d%d", &u, &v, &time);
        G[u][v] = G[v][u] = time;
    
    }

    Dijkstra(st);
    DFS(ed);

    int lastTime;
    for (int i = 0; i < ans.size(); i++) {
        int u = ans[i].first;
        int v = ans[i].second;
        if (i > 0) {
            int id1 = ans[i - 1].first;
            int id2 = ans[i - 1].second;
            G[id1][id2] = G[id2][id1] = lastTime;
        }

        lastTime = G[u][v];
        G[u][v] = G[v][u] = INF;

        Dijkstra(st);
        maxTime = max(maxTime, d[ed]);

    }

    if (maxTime == INF) printf("It's a bug!!!
");
    else printf("%d
", maxTime);
    
    
    

    return 0;
}