[Usaco2006 Nov]Roadblocks第二短路 堆优化的dijkstra

贝茜把家搬到了一个小农场，但她常常回到FJ的农场去拜访她的朋友。贝茜很喜欢路边的风景，不想那么快地结束她的旅途，于是她每次回农场，都会选择第二短的路径，而不象我们所习惯的那样，选择最短路。 贝茜所在的乡村有R(1<=R<=100,000)条双向道路，每条路都联结了所有的N(1<=N<=5000)个农场中的某两个。贝茜居住在农场1，她的朋友们居住在农场N（即贝茜每次旅行的目的地）。 贝茜选择的第二短的路径中，可以包含任何一条在最短路中出现的道路，并且，一条路可以重复走多次。当然咯，第二短路的长度必须严格大于最短路（可能有多条）的长度，但它的长度必须不大于所有除最短路外的路径的长度。

如题，就是次短路而已，用SPFA或者Dij都行。

不过这次我使用了Dij，由于要求次短路，那么外层的循环要有2*n-1次了，可以说成里边有n-1次求最短路的，n次求次短路的

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#define MAXM 222222
#define MAXN 5555
#define INF 1000000007
using namespace std;
struct node
{
    int v, next, w;
}edge[MAXM];
int d[MAXN][2], e, n, m;
int cnt[MAXN][2];
int head[MAXN];
bool vis[MAXN][2];
void init()
{
    e = 0;
    memset(head, -1, sizeof(head));
}
void insert(int x, int y, int w)
{
    edge[e].v = y;
    edge[e].w = w;
    edge[e].next = head[x];
    head[x] = e++;
}
int dijkstra(int s, int t)
{
    int flag, u;
    memset(vis, 0, sizeof(vis));
    for(int i = 1; i <= n; i++)
        d[i][0] = d[i][1] = INF;
    d[s][0] = 0;
    for(int i = 1; i < 2 * n; i++)
    {
        int mini = INF;
        for(int j = 1; j <= n; j++)
        {
            if(!vis[j][0] && d[j][0] < mini)
            {
                u = j;
                flag = 0;
                mini = d[j][0];
            }
            else if(!vis[j][1] && d[j][1] < mini)
            {
                u = j;
                flag = 1;
                mini = d[j][1];
            }
        }
        if(mini == INF) break;
        vis[u][flag] = 1;
        for(int j = head[u] ; j != -1; j = edge[j].next)
        {
            int w = edge[j].w;
            int v = edge[j].v;
            if(d[v][0] > mini + w)
            {
                d[v][1] = d[v][0];
                d[v][0] = mini + w;
            }
            else if(d[v][1] > mini + w)
                d[v][1] = mini + w;
        }
    }
    return d[t][1];
}
int main()
{
    int s, t, T, x, y, w;
    init();
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= m; i++)
    {
        scanf("%d%d%d", &x, &y, &w);
        insert(x, y, w);
        insert(y, x, w);
    }
    printf("%d\n", dijkstra(1, n));
    return 0;
}

然后还有个堆优化的

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#define MAXN 5555
#define MAXM 222222
#define INF 1000000000
using namespace std;
struct Edge
{
    int to, cost;
};
typedef pair<int, int> P; //first是最短距离，second是点的标号
int n, r;
vector<Edge>g[MAXN];
int dis[MAXN];
int dis2[MAXN];
priority_queue<P, vector<P>, greater<P> >que;
void solve(int s, int t)
{
    for(int i = 1; i <= n; i++)
        dis[i] = dis2[i] = INF;
    dis[s] = 0;
    que.push(P(0, s));
    while(!que.empty())
    {
        P p = que.top();
        que.pop();
        int v = p.second, d = p.first;
        if(dis2[v] < d) continue;
        for(int i = 0; i < g[v].size(); i++)
        {
            Edge e = g[v][i];
            int d2 = d + e.cost;
            if(dis[e.to] > d2)
            {
                dis2[e.to] = dis[e.to];
                dis[e.to] = d2;
                que.push(P(dis[e.to], e.to));
            }
            else if(dis2[e.to] > d2)
            {
                dis2[e.to] = d2;
                que.push(P(dis2[e.to], e.to));
            }
        }
    }
    printf("%d\n", dis2[t]);
}
int main()
{
    int s, t, T, x, y, w;
    scanf("%d%d", &n, &r);
    for(int i = 1; i <= r; i++)
    {
        scanf("%d%d%d", &x, &y, &w);
        g[x].push_back({y, w});
        g[y].push_back({x, w});
    }
    solve(1, n);
    return 0;
}