最短路径之SPFA算法的C实现

        SPFA其实是队列优化的BellmanFord算法。

        此版的空间浪费很大，没用邻接表存储。

代码

#include <iostream>
#include <string>
using namespace std;

const int oo = 2500;        //最大的路径值
const int Max_Node = 2501;  //最大边的条数
int n, m;                   //n点 m边
int *D;
int *queue;
int begin;

struct bian {
    int a, b;  //边的出发点和结束点
    int w;     //权值
} * E;         //边集

struct node {
    int arc[Max_Node];  //每条以该定点为出发点的编号
    int num;            //以该点为出发点的边的数量
} * V;                  //点集

int input() {
    int i;
    cin >> n >> m >> begin;
    V = new node[n + 1];
    E = new bian[m + 1];
    int a, b, w;
    for (int i = 1; i <= m; i++) {
        cin >> a >> b >> w;
        E[i].a = a;
        E[i].b = b;
        E[i].w = w;
        V[a].arc[++V[a].num] = i;
    }
    D = new int[n + 1];
    memset(D, oo, sizeof(int) * (n + 1));
    D[begin] = 0;
    return 0;
}

int spfa() {
    int front = 0;
    int rear = 1;
    queue = new int[2 * n + 1];
    memset(queue, 0, sizeof(int) * (2 * n + 1));
    queue[front] = begin;
    while (front != rear) {
        for (int i = 1; i <= V[queue[front]].num; i++) {
            if (D[queue[front]] + E[V[queue[front]].arc[i]].w <= D[E[V[queue[front]].arc[i]].b]) {
                queue[rear++] = E[V[queue[front]].arc[i]].b;                                     //入队
                D[E[V[queue[front]].arc[i]].b] = D[queue[front]] + E[V[queue[front]].arc[i]].w;  //松弛
            }
        }
        front++;  //出队
    }
    return 0;
}
int main() {
    input();
    spfa();
    for (int i = 1; i <= n; i++) {
        cout << D[i];
    }
    system("pause");
    return 0;
}