迷阵突围的一种解法

题目描述：

蒜头君陷入了坐标系上的一个迷阵，迷阵上有 n 个点，编号从 1 到 n。蒜头君在编号为 1 的位置，他想到编号为 n 的位置上。蒜头君当然想尽快到达目的地，但是他觉得最短的路径可能有风险，所以他会选择第二短的路径。现在蒜头君知道了 n 个点的坐标，以及哪些点之间是相连的，他想知道第二短的路径长度是多少。

输入输出：

输入格式

第一行输入两个整数 n和 m，表示一共有 n 个点和 m 条边。

接下来输入 n 行，每行输入两个整数 xi​,yi​(−500≤xi​,yi​≤500)，代表第 i 个点的坐标。

接下来输入 m 行，每行输入两个整数 pj​,qj​ (1≤pj​,qj​≤n)，表示点 pj​ 和点 qj​ 之间相连。

输出格式

输出一行，输出包含一个数，表示第二短的路径长度（小数点后面保留两位），如果第一短路径有多条，则答案就是第一最短路径的长度；如果第二最短路径不存在，则输出 −1。

核心思想：dijkstra算法，先找一条最短路径，再通过依次删除这个最短路径上的每一条边来找子图的最短路径（也就是整个图的次短路径）

解题过程：自己在书上学dijkstra算法时用的是邻接矩阵，因此自己的题解也是用的邻接矩阵，遇到问题是删边出了问题，看了大佬的代码是通过建立边的结构体来解题，但是又不想改已经写好的邻接矩阵的思路，就在此基础上把删边操作修改正确得到题解

代码如下：

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define INF 30000
int pre[210];//记录这个点的前驱结点
int minpath[210];
double d[210];
int vset[210]; //判断是否在集合V中
typedef struct position {
    int x;
    int y;
}P;//记录位置
P posi[210];
double a[210][210];//构建有权值的邻接矩阵
int n, m;
int num;//记录最短路径的结点数
double ans = INF;

double dist(P i, P j)
{
    return sqrt((i.x - j.x) * (i.x - j.x) + (i.y - j.y) * (i.y - j.y));
}
//得到一条逆路径
void getpath(int n)
{
    num++;
    minpath[num] = n;
    if (n == 1) return;
    getpath(pre[n]);
}
int main()
{
    scanf("%d %d", &n, &m);
    //初始化的一些操作
    for (int i = 1; i <= n; i++) {
        scanf("%d %d", &posi[i].x, &posi[i].y);
    }
    for (int i = 1; i <= m; i++) {
        int p, q;
        scanf("%d %d", &p, &q);
        a[p][q] = a[q][p] = dist(posi[p], posi[q]);
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (i == j) a[i][j] = 0;
            else if (a[i][j] == 0) a[i][j] = INF;
        }
    }
    for (int i = 2; i <= n; i++) {
        d[i] = a[1][i];
        pre[i] = 1;
    }
    vset[1] = 1;
    pre[1] = -1;
    int k = 1;
    //开始找第一最短路径，并且记录前驱结点
    while (1) {
        double mind = INF;
        int now;
        for (int i = 2; i <= n; i++) {
            if (mind > d[i] && vset[i] == 0) {
                now = i;
                mind = d[i];
            }
        }
        if (now == n) break;
        vset[now] = 1;
        //根据now来更新
        for (int i = 2; i <= n; i++) {
            if (i != now) {
                if (d[now] + a[now][i] < d[i]) {
                    d[i] = d[now] + a[now][i];
                    pre[i] = now;//改变前驱
                }
            }
        }
    }
    double minlen = d[n];
    //得到一条最短路径
    getpath(n);

    //寻找第二最短路径
    //枚举“删除”第一最短路径的任意一条边,枚举次数为num-1
    double min = INF;
    for (int i = 1; i < num; i++) {
        //minpath是一条逆路径
        double tmp = a[minpath[i + 1]][minpath[i]];
        a[minpath[i + 1]][minpath[i]]= a[minpath[i]][minpath[i+1]] = INF;
        //初始化操作
        for (int i = 2; i <= n; i++) {
            d[i] = a[1][i];
            //不用pre数组了
            vset[i] = 0;
        }
        while (1) {
            double mind = INF;
            int now;
            for (int i = 2; i <= n; i++) {
                if (d[i] < mind && vset[i] == 0) {
                    mind = d[i];
                    now = i;
                }
            }
            vset[now] = 1;
            if (now == n) break;
            //依据p做更改
            for (int i = 2; i <= n; i++) {
                if (i != now && d[now] + a[now][i] < d[i]) {
                    d[i] = d[now] + a[now][i];
                }
            }
        }
        if (d[n] < ans) ans = d[n];
        //说明不止一条最短路径
        if (fabs(ans - minlen)<1e-6) break;
        a[minpath[i + 1]][minpath[i]] = a[minpath[i]][minpath[i + 1]] = tmp;//恢复
    }
    if(ans==INF) printf("-1");
    else printf("%.2lf", ans);
    return 0;
}