2017 第十场多校训练 HDU 6181 Two Paths 次短路+Dijkstra

/*
裸的次短路
不断更新v->u的次短路，直到v->u的次短路只比最短路小
*/
#include <vector>
#include <iostream>
#include <stdio.h>
#include <queue>
using namespace std;
#define ll long long
#define INF 1e18
#define MAXM 100100
struct edge{int to;ll w;};
typedef pair<ll,int>P;
int n,r;
ll d[MAXM];
ll d1[MAXM];
vector<edge>G[MAXM];
bool vis[MAXM];
void solve(){
    priority_queue<P, vector<P>,greater<P> >que;
    fill(d+1,d+n+1,INF);
    fill(d1+1,d1+n+1,INF);
    d[1]=0;
    que.push(P(0,1));
    while(!que.empty()){
        P p=que.top();
        que.pop();
        int v=p.second;
        if(d1[v]<p.first)continue;
        for(int i=0;i<G[v].size();i++){
            edge &e=G[v][i];
            ll d2=p.first+e.w;
            if(d[e.to]>d2){
                swap(d[e.to],d2);
                que.push(P(d[e.to],e.to));
            }
            if(d1[e.to]>d2&&d[e.to]<d2){
                d1[e.to]=d2;
                que.push(P(d1[e.to],e.to));
            }
        }
    }
    printf("%I64d\n",d1[n]);
}
int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%d %d",&n,&r);
        for(int i=1;i<=n;i++){
            G[i].clear();
        }
        int u,v;
        ll w;
        while(r--){
            scanf("%d %d %I64d",&u,&v,&w);
            G[u].push_back(edge{v,w});
            G[v].push_back(edge{u,w});
        }
        solve();
    }
    return 0;
}

一种复杂的做法

#include <bits/stdc++.h>
#define next _next
using namespace std;
typedef long long ll;
const ll inf=0x3f3f3f3f3f3f3f;
const int MAXN=200000+10;
struct Rec{
    int num;
    ll len;
    bool operator < (const Rec &a) const {
        return len>a.len;
    }
}; 
int u[MAXN*2],v[MAXN*2];
ll dis[MAXN/2],secondis[MAXN/2],w[MAXN*2];
int first[MAXN/2],next[MAXN*2];
int n,r;

void dijkstra()
{
    priority_queue<Rec>que;
    for (int i=1;i<n;i++){
         dis[i]=inf;
         secondis[i]=inf;
    }
    dis[0]=0;
    secondis[0]=inf;
    Rec temp;
    temp.len=0;
    temp.num=0;
    que.push(temp);
    while (!que.empty())
    {
        Rec head=que.top();
        que.pop();
        if (head.len>secondis[head.num]) continue;
        int k=first[head.num];
        while (k!=-1)
        {
            ll d=head.len+w[k];
            if (dis[v[k]]>d)
            {
                swap(dis[v[k]],d);
                temp.len=dis[v[k]];temp.num=v[k];
                que.push(temp);
            }
            if (dis[v[k]]<d && secondis[v[k]]>d)
            {
                secondis[v[k]]=d;
                temp.len=secondis[v[k]];temp.num=v[k];
                que.push(temp);
            }
            k=next[k];
        }
    }
}