HDU 2544(Floyd、Dijkstra、Bellman-Ford、SPFA)

中文题

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#define N 110
#define M 10010
#define INF 0x3f3f3f3f
using namespace std;
struct edgs{
    int u, v, dis;
}Edgs[M];

int dis[N][N], d[N], vis[N];
int u[M], v[M], head[M], Next[M], len[M];
int n, m, cnt;

void add_edgs(int s, int e, int l) {
    u[cnt] = s;
    v[cnt] = e;
    len[cnt] = l;
    Next[cnt] = head[s];
    head[s] = cnt++;
}

void init() {
    memset(dis, 0x3f, sizeof(dis));
    memset(head, -1, sizeof(head));
    cnt = 0;

    cnt = 0;
    int x, y, z;
    for (int i = 0; i < m; i++) {
        scanf("%d%d%d", &x, &y, &z);
        dis[x][y] = dis[y][x] = min(dis[x][y], z);
        Edgs[i].u = x;
        Edgs[i].v = y;
        Edgs[i].dis = min(dis[x][y], z);
        add_edgs(x, y, min(dis[x][y], z));
        add_edgs(y, x, min(dis[x][y], z));
    }
}

int Dijkstra() {

    memset(vis, 0, sizeof(vis));
    for (int i = 1; i <= n; i++)
        d[i] = INF;
    d[1] = 0;
    for (int i = 0; i < n; i++) {
        int x, t = INF;
        for (int j = 1; j <= m; j++)
            if (!vis[j] && d[j] < t) {
                x = j;
                t = d[j];
            }
        vis[x] = 1;

        for (int j = 1; j <= n; j++)
            d[j] = min(d[j], d[x] + dis[x][j]);
    }
    return d[n];
}

int Floyd() {
    for (int i = 1; i <= n; i++)
        dis[i][i] = 0;

    for (int k = 1; k <= n; k++)
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                if (dis[i][k] != INF && dis[k][j] != INF && dis[i][j] > dis[i][k] + dis[k][j])
                    dis[i][j] = dis[i][k] + dis[k][j];

    return dis[1][n];
}

int Bellman_Ford() {

    for (int i = 2; i <= n; i++)
        d[i] = INF;
    d[1] = 0;

    for (int i = 1; i <= n - 1; i++) 
        for (int j = 0; j < m; j++) {
            int u = Edgs[j].u;
            int v = Edgs[j].v;
            if (d[u] < INF)
                d[v] = min(d[v], d[u] + Edgs[j].dis);
            if (d[v] < INF)
                d[u] = min(d[u], d[v] + Edgs[j].dis);
        }  
    return d[n];
}

int SPFA() {
    memset(vis, 0, sizeof(vis));
    for (int i = 2; i <= n; i++)
        d[i] = INF;
    d[1] = 0;
    queue<int> q;
    q.push(1);

    while (!q.empty()) {    
        int t = q.front();
        q.pop();
        vis[t] = 0;
        for (int i = head[t]; i != -1; i = Next[i]) {
            if (d[v[i]] > d[u[i]] + len[i]) {
                d[v[i]] = d[u[i]] + len[i];
                if (!vis[v[i]]) {
                    q.push(v[i]);
                    vis[v[i]] = 1;
                }   
            }
        }
    }
    return d[n];    
}

int main() {
    while (scanf("%d%d", &n, &m) != EOF && n + m) {
        init();
//      printf("%d\n", Dijkstra());
//      printf("%d\n", Floyd());
//      printf("%d\n", Bellman_Ford());
        printf("%d\n", SPFA());
    }
    return 0;
}