笔记:最短路

Dijkstra朴素：（链式前向星）

#include<bits/stdc++.h>
using namespace std;
const int inf=1e9;
int Begin[100010],Next[100010],To[100010],W[100010],e;
int n,m;
int dis[510];
bool vis[510];
void add(int a,int b,int c)
{
    To[++e] = b;
    W[e] = c;
    Next[e] = Begin[a];
    Begin[a] = e;
}
int dijkstra()
{
    for(int i=1;i<=n;i++)
    {
        int pos=-1,mi=INT_MAX;
        for(int j=1;j<=n;j++)
        {
            if(dis[j]<mi&&!vis[j])
            {
                pos = j;
                mi = dis[j];
            }
        }
        vis[pos] = 1;
        for(int j=Begin[pos];j;j=Next[j])
        {
            int v=To[j];
            if(dis[pos]+W[j]<dis[v])
            {
                dis[v] = dis[pos]+W[j];
            }
        }
    }
    if(dis[n] == inf)
    {
        return -1;
    }
    return dis[n];
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        dis[i] = inf;
    }
    dis[1] = 0;
    // vis[1] = 1;
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a, b, c);
    }
    cout<<dijkstra();
    return 0;
}

Dijkstra堆优化：(链式前向星)

#include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> PII;
const int inf=1e9;
int Begin[200010],Next[200010],To[200010],W[200010],e;
int n,m;
int dis[200010];
bool vis[200010];
priority_queue<PII,vector<PII>,greater<PII>> pq;
void add(int a,int b,int c)
{
    To[++e] = b;
    W[e] = c;
    Next[e] = Begin[a];
    Begin[a] = e;
}
int dijkstra()
{
    pq.push({0,1});
    for(int i=1;i<=n;i++)
    {
        auto a=pq.top();
        pq.pop();
        int pos=a.second;
        if(vis[pos])
        {
            continue;
        }
        vis[pos] = 1;
        for(int j=Begin[pos];j;j=Next[j])
        {
            int v=To[j];
            if(dis[pos]+W[j]<dis[v])
            {
                dis[v] = dis[pos]+W[j];
                pq.push({dis[v],v});
            }
        }
    }
    if(dis[n] == inf)
    {
        return -1;
    }
    return dis[n];
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        dis[i] = inf;
    }
    dis[1] = 0;
    // vis[1] = 1;
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a, b, c);
    }
    cout<<dijkstra();
    return 0;
}

SPFA:

#include<bits/stdc++.h>
using namespace std;
const int inf=0x3f3f3f3f;
int Begin[200010],Next[200010],To[200010],W[200010],e;
int n,m;
int dis[200010];
bool vis[200010];
void add(int a,int b,int c)
{
    To[++e] = b;
    W[e] = c;
    Next[e] = Begin[a];
    Begin[a] = e;
}
int spfa()
{
    queue<int>q;
    q.push(1);
    vis[1]=1;
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        for(int i=Begin[t];i;i=Next[i])
        {
            int v=To[i];
            if(dis[v]>dis[t]+W[i])
            {
                dis[v] = dis[t]+W[i];
                if(!vis[v])
                {
                    q.push(v);
                    vis[v]=1;
                }
            }
        }
    }
    if(dis[n] > 0x3f3f3f3f/2)
    {
        cout<<"impossible";
        exit(0);
    }
    return dis[n];
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        dis[i] = inf;
    }
    dis[1] = 0;
    // vis[1] = 1;
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a, b, c);
    }
    int t=spfa();
    cout<<t;
    return 0;
}

Bellman_ford

#include<bits/stdc++.h>
using namespace std;
struct edge{
    int a,b,w;
}ed[10010];
int n,m,k;
int dis[10010],backup[10010];
int bellman_ford()
{
    for(int i=1;i<=k;i++)
    {
        memcpy(backup,dis,sizeof(dis));
        for(int j=1;j<=m;j++)
        {
            int a=ed[j].a,b=ed[j].b,w=ed[j].w;
            dis[b] = min(dis[b],backup[a]+w);
        }
    }
    if(dis[n]>0x3f3f3f3f/2)
    {
        cout<<"impossible";
        exit(0);
    }
    return dis[n];
}
int main()
{
    cin>>n>>m>>k;
    for(int i=1;i<=m;i++)
    {
        cin>>ed[i].a>>ed[i].b>>ed[i].w;
    }
    memset(dis,0x3f,sizeof(dis));
    dis[1]=0;
    int t=bellman_ford();
    cout<<t;
    return 0;
}