dijkstra 与 spfa

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <queue>

using namespace std;

const int maxn = 105, maxm = maxn * maxn * 2, inf = 1e9;

int n, m, kase, T, tot;

int h[maxn], inqueue[maxn];

int dis[maxn];

struct edge
{
    int v, next;
    int w;
}a[maxm];

void add(int x, int y, int z)
{
    a[tot].v = y;
    a[tot].w = z;
    a[tot].next = h[x];
    h[x] = tot++;
}

void init()
{
    memset(h, -1, sizeof h); tot = 0;
    memset(inqueue, 0, sizeof inqueue);
    for (int i = 1; i <= n; i++)
    {
        dis[i] = inf;
    } 
    dis[1] = 0; inqueue[1] = 1;
}

int main()
{
    freopen("SPFA.in","r",stdin);
    while (scanf("%d%d", &n, &m) && n && m)
    {
        init();
        for (int i = 1; i <= m; i++)
        {
            int x, y, z;
            scanf("%d%d%d", &x, &y, &z);
            add(x, y, z); add(y, x, z);
        }
        queue<int> q;
        q.push(1);
        while (!q.empty())
        {
            int u = q.front(); q.pop(); inqueue[u] = 0;
            for (int i = h[u]; ~i; i = a[i].next)
            {
                int v = a[i].v;
                if (dis[u] + a[i].w < dis[v])
                {
                    dis[v] = dis[u] + a[i].w;
                    if (!inqueue[v])
                    {
                        q.push(v);
                        inqueue[v] = 1;
                    }
                }
            }
        }
        for (int i = 1; i <= n; i++)
        {
            printf("%d:%d
", i, dis[i]);
        }
        printf("
");
    }            
    return 0;
}

priority_queue<node> q;

void dijk(int s)
{
    for (int i = 1; i <= n; i++)
        dis[i] = inf;
    memset(done, 0, sizeof done);
    dis[s] = 0;
    q.push((node){s, 0});
    while (!q.empty())
    {
        node x = q.top(); q.pop();
        int u = x.u;
        if (done[u]) continue;
        done[u] = 1;
        for (int i = h[u]; ~i; i = a[i].next)
        {
            int v = a[i].v;
            if (dis[u] + a[i].w < dis[v])
            {
                dis[v] = dis[u] + a[i].w;
                p[s][v] = u;
                q.push((node){v, dis[v]});
            }
        }
    }

 区别在于，SPFA是先松弛再看看该点能否重复利用。

dijkstra是先看看该点能否重复利用，再松弛。