最短路

朴素Dijkstra

//Dijkstra算法，用于单源最短路边都为正数的情况
int n, m;
int dis[N], g[N][N]； //dis -> 最短距离 g -> 图
bool st[N];

int Dijkstra(){
    memset(dis, 0x3f, sizeof(dis));
    dis[1] = 0;
    
    for(int i = 0; i < n; i++){
        int t = - 1; 
        for(int j = 1; j <= n; j++)
          if(!st[j] && (t == -1 || dis[t] > dis[j]))
            t = j;
        st[t] = true;
        
        for(int j = 1; j <= n; j++)
          dis[j]= min(dis[j], dis[t] + g[t][j]);
    }
    if(dis[n] == 0x3f3f3f3f) return -1;
    return dis[n];
}

Dijkstra的堆优化

typedef pair<int, int> PII;
int n;      // 点的数量
int h[N], w[N], e[N], ne[N], idx;// 邻接表存储所有边
int dist[N];        // 存储所有点到1号点的距离
bool st[N];     // 存储每个点的最短距离是否已确定

// 求1号点到n号点的最短距离，如果不存在，则返回-1
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1});      // first存储距离，second存储节点编号

    while (heap.size()){
        auto t = heap.top();
        heap.pop();

        int ver = t.second, distance = t.first;

        if (st[ver]) continue;
        st[ver] = true;

        for (int i = h[ver]; i != -1; i = ne[i]){
            int j = e[i];
            if (dist[j] > distance + w[i]){
                dist[j] = distance + w[i];
                heap.push({dist[j], j});
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

Bellman-Ford

//Bellman-Ford算法，用于单源最短路存在负权边的情况

struct Node{
    int a, b, w;
}edge[M];

int bellman_ford(){
    memset(dis, 0x3f, sizeof(dis));
    dis[1] = 0;
    
    for(int i = 0; i < k; i++){
        memcpy(backup, dis, sizeof(dis));
        
        for(int j = 0; j < m; j++){
            int a = edge[j].a, b = edge[j].b, w = edge[j].w;
            dis[b] = min(dis[b], backup[a] + w); //备份，防止原来的数据被覆盖
        }
    }
    if(dis[n] > 0x3f3f3f3f / 2) return -1;    //要将无穷除以2（可能存在负边，但不是最短路）
    return dis[n];
}

spfa 算法（队列优化的Bellman-Ford算法)

时间复杂度 平均情况下 O(m)，最坏情况下 O(nm), n 表示点数，m 表示边数

int n;      // 总点数
int h[N], w[N], e[N], ne[N], idx;  // 邻接表存储所有边
int dist[N];        // 存储每个点到1号点的最短距离
bool st[N];     // 存储每个点是否在队列中

// 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
int spfa(){
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    queue<int> q;
    q.push(1);
    st[1] = true;

    while (q.size()){
        
        auto t = q.front();
        q.pop(); st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i]){
            int j = e[i];
            if (dist[j] > dist[t] + w[i]){
                dist[j] = dist[t] + w[i];
                if (!st[j]){     // 如果队列中已存在j，则不需要将j重复插入
                    q.push(j);st[j] = true;
                }
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

floyd

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= n; j ++ )
            if (i != j)  d[i][j] = INF;

// 算法结束后，d[a][b]表示a到b的最短距离
void floyd(){
    for (int k = 1; k <= n; k ++ )
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= n; j ++ )
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}