Dijkstra

模板一（map数组模拟邻接表）

处理小图速度相对较快。
内存占用较小，对重边优化较差。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>

using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1000;

int map[maxn][maxn];
int pre[maxn],dis[maxn];
bool vis[maxn];
int n,m;

void Dijkstra(int s)
{
    memset(dis,0x3f,sizeof(dis));
    memset(pre,-1,sizeof(pre));
    memset(vis,false,sizeof(vis));
    for(int i=1;i<=n;++i)
    {
        dis[i]=map[s][i];
        pre[i]=s;
    }
    dis[s]=0;
    vis[s]=true;
    for(int i=2;i<=n;++i)
    {
        int mindist=INF;
        int u=s;
        for(int j=1;j<=n;++j)
            if((!vis[j])&&dis[j]<mindist)
            {
                u=j;
                mindist=dis[j];
            }
        vis[u]=true;
        for(int j=1;j<=n;++j)
            if((!vis[j])&&map[u][j]<INF)
            {
                if(map[u][j]+dis[u]<dis[j])
                {
                    dis[j]=map[u][j]+dis[u];
                    pre[j]=u;
                }
            }
    }
}
int main(){
    cin >> m >> n;
    for (int i=1; i <=n;i++)
        for (int j=1;j <=n;j++){
            if (i == j) map[i][j] = 0;
            else map[i][j] = map[j][i] = INF;
        }
    while (m--) {
        int start, end, len;
        cin >> start >> end >> len;
        map[start][end] = len;
        map[end][start] = len;
    }
    cout << map[2][5] << endl;
    Dijkstra(1);
    cout << dis[n] << endl;
    return 0;
}

模板二（链式前向星+优先队列优化）

主要优化在重边。因为使用了STL所以占用内存和速度相对较慢。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<queue>

using namespace std;
const int INF=0x3f3f3f3f;

struct node
{
    int d,u;
    friend bool operator<(node a,node b)
    {
        return a.d>b.d;
    }
    node(int dist,int point):d(dist),u(point){}
};

struct Edge
{
    int to,next;
    int dist;
}edge[maxm];
int head[maxn],tot;
int pre[maxn],dis[maxn];

void init()
{
    memset(head,-1,sizeof(head));
    tot=0;
}

void addedge(int u,int v,int d)
{
    edge[tot].to=v;
    edge[tot].dist=d;
    edge[tot].next=head[u];
    head[u]=tot++;
}

void Dijkstra(int s)
{
    priority_queue<node> q;
    memset(dis,0x3f,sizeof(dis));
    memset(pre,-1,sizeof(pre));
    dis[s]=0;
    while(!q.empty())
        q.pop();
    node a(0,s);
    q.push(a);       //起点入队列
    while(!q.empty())
    {
        node x=q.top();
        q.pop();
        if(dis[x.u]<x.d)   //最短路已找到
            continue;
        for(int i=head[x.u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].to;
            if(dis[v]>dis[x.u]+edge[i].dist)
            {
                dis[v]=dis[x.u]+edge[i].dist;
                pre[v]=x.u;
                q.push(node(dis[v],v));
            }
        }
    }
}

模板三（结构体内置方法）

因为使用了链式前向星所以不担心重边。
其中还使用了快读方法，所以很快。

#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
#include <utility>
using namespace std;

const int N = 1005;
const int M = 1005;
const int INF = 0x3f3f3f3f

struct Graph{
    struct Edge{
        int v, w, next;
    }edge[M];
    int ehead[N];
    void init(){
        memset(ehead, -1, sizeof(ehead))
    }
    inline void addedge(int u, int v, int w){
        edge[ecnt] = {v, w, ehead[u]};
        ehead[u] = ecnt++;
    }
    int dist[N];
    bool vis[N];
    void Dijkstra(int s){
        memset(dist, INF, sizeof(dist));
        memset(vis, 0, sizeof(vis));
        priority_queue<pair<int, int> > q;
        q.push(make_pair(-(dist[s] = 0), s));
        while(q.size()){
            int u = q.top().second; q.pop();
            if (vis[u]) continue;
            vis[u] = true;
            for (int i = ehead[u]; ~i; i = edge[i].next){
                int v = edge[i].v;
                if (vis[v]) continue;
                int ndist = dist[u] + edge[i].w;
                if (ndist < dist[v]) q.push(make_pair(-(dist[v] = ndist), v));
            }
        }
    }
}g1, g2;

int Input(){
    char c;
    for (c = getchar(); c<'0' || c>'9'; c = getchar());
    int a = c - '0';
    for (c = getchar(); c >= '0' && c <= '9'; c = getchar())
        a = a*10 + c - '0';
    return a;
}

Floyd

代码很短，时间复杂度很高（O(n^3)）。

void floyd(){
    for(int k=1; k<=n; ++k)
        for(int i=1; i<=n; ++i)
            for(int j=1; j<=n; ++j)
                if (map[i][j] > map[i][k] + map[k][j]) //松弛
                    map[i][j] = map[i][k] + map[k][j];
}

Bellman-Ford

模板一（链式前向星）

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
using namespace std;
struct Edge{
    int u, v;
    double r, c;
}edge[maxn*2];

double mostMoney[maxn];
int n, m, s;
double v;
int tot;

void addedge(int u, int v, double r, double c){
    edge[tot].u = u;
    edge[tot].v = v;
    edge[tot].r = r;
    edge[tot++].c = c;
}

bool relax(int n){
    double temp = (mostMoney[edge[n].u] - edge[n].c)*edge[n].r;
    if (temp > mostMoney[edge[n].v]){
        mostMoney[edge[n].v] = temp;
        return true;
    }
    return false;
}

bool bellman_ford(){
    bool flag;
    for (int i=0; i<n; i++) mostMoney[i] = 0.0;
    mostMoney[s] = v;
    for (int i=0; i<n-1; ++i){
        flag = false;
        for (int j=0; j<tot; ++j)
            if (relax(j)) flag = true;
        if (mostMoney[s] > v) return true;
        if (!flag) return false;
    }
    for (int i=0; i<tot; ++i){
        if (relax(i)) return true;
    }
    return false;
}

模板二

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
using namespace std;

const int INF=0x3f3f3f3f;
struct Edge{
    int u,v; //起点、终点
    int dist; //长度
}edge[maxn];

int dis[maxn]; //最短距离数组
int n, m; //结点数、边数

bool Bellman_ford(int s){
    memset(dis, INF, sizeof(dis));
    dis[s]=0;
    for(int k=1; k<n; ++k){ //迭代n-1次
        for(int i=0; i<m; ++i){  //检查每条边
            int x = edge[i].u, y = edge[i].v;
            if(dis[x] < INF)
                dis[y] = min(dis[y], dis[x] + edge[i].dist);
        }
    }
    bool flag=1;
  for(int i=0; i<m; ++i){   //判断是否有负环
        int x = edge[i].u, y = edge[i].v;
        if(d[y] > d[x] + edge[i].dist){
            flag = 0; break;
        }
    }
    return flag;
}

SPFA

#include <cstdio>
#include <iostream>
#include <cstring>
#include <queue>
#define maxn 1000005
using namespace std;
const long long INF = 0xffffffff;

int Input(){
    char c;
    for (c = getchar(); c<'0' || c>'9'; c = getchar());
    int a = c - '0';
    for (c = getchar(); c>='0' && c<='9'; c = getchar()) a = a * 10 + c - '0';
    return a;
}

int n, m;
struct edge{
    int e, next, w;
}edge[2][maxn];

long long dis[maxn], ans;
int head[2][maxn], vis[maxn];

inline void spfa(int x){
    for (int i=1; i<=n; i++){
        dis[i] = 0xffffffff;
        //cout << dis[i] << endl;
    }
    memset(vis, 0, sizeof(vis));
    
    queue<int> q;
    int a, b;
    
    q.push(1);
    vis[1] = 1;
    dis[1] = 0;
    
    while(!q.empty()){
        a = q.front(); q.pop();
        vis[a] = 1;
        
        for (int i=head[x][a]; i != -1; i=edge[x][i].next){
            b = edge[x][i].e;
            if (dis[b] > dis[a] + edge[x][i].w){
                dis[b] = dis[a] + edge[x][i].w;
                if (!vis[b]) { q.push(b); vis[b] = 1; }
            }
        }
    }
}