最短路dijkstra,SPFA

Dijkstra算法

Dijkstra算法采用的是一种贪心的策略。

dijkstra不能有负权边

声明一个数组d来保存源点到各个顶点的最短距离和一个保存已经找到了最短路径的顶点的集合：T。

初始时，原点 s 的路径权重被赋为 0 （d[s] = 0）。若对于顶点 s 存在能直接到达的边（s,m），则把d[m]设为s到m的距离,同时把所有其他（s不能直接到达的）顶点的路径长度设为无穷大。初始时，集合T只有顶点s。 

然后，从dis数组选择最小值，则该值就是源点s到该值对应的顶点的最短路径，并且把该点加入到T中，OK，此时完成一个顶点， 
然后，我们需要看看新加入的顶点是否可以到达其他顶点并且看看通过该顶点到达其他点的路径长度是否比源点直接到达短，如果是，那么就替换这些顶点在dis中的值。 
然后，又从dis中找出最小值，重复上述动作，直到T中包含了图的所有顶点。

dijkstra模板：

#include<stdio.h>
#include<string.h>
#define INFINITY 1000
int d[100];
int final[100];
int g[100][100];
int n;
void dijkstra(int s)
{
    int min, w, v, i, j;
    memset(final, 0, sizeof(final));
    for(v = 1; v <= n; v++)
        d[v] = g[s][v];
    final[s] = 1;
    d[s] = 0;
    for(i = 2; i <= n; i++)//这个点对应的一行的每一个点的最短都找出来
    {
        min = INFINITY;
        v = -1;
        for(w = 1; w <= n; w++) //在所有末标识的点中，选D值最小的点
        {
            if(!final[w] && d[w] < min)
            {
                v = w;
                min = d[w];
            }
        }

        if(v != -1)//如果v=-1表示现在在找的这个点没有与其他任何点有路径
        {
            final[v] = 1;

            for(w = 1; w <= n; w++)//找到最段路径后对应的与之相连的新点
                if((!final[w]) && (g[v][w] < INFINITY))
                {
                    if(d[w] > min + g[v][w])
                        d[w] = min + g[v][w];
                }
        }
    }
}
int main()
{
    int i, j;
    scanf("%d", &n);
    for(i = 1; i <= n; i++)
        for(j = 1; j <= n; j++)
            scanf("%d", &g[i][j]);
    dijkstra(1);
    for(i = 1; i <= n; i++)
        printf("%d ", d[i]);
    return 0;
}

 spfa算法

spfa可以有负权边

主要应用queue队列

有关spfa算法，这个博客写的很详细：最快最好用的——spfa算法

模板（这个是hdoj通畅工程续的ac代码）：

#include<bits/stdc++.h>
using namespace std;
#define inf 99999999
#define maxn 210
int maps[maxn][maxn];
int visited[maxn], dis[maxn];
int n, m;
queue<int> q;
int spfa(int s, int t)
{
    for(int i = 0; i < n; i++)
    {
        dis[i] = inf;
        visited[i] = 0;
    }
    while(!q.empty())
        q.pop();
    dis[s] = 0;
    visited[s] = 1;
    q.push(s);//起点入队

    while(!q.empty())
    {
        int temp = q.front();
        q.pop();
        visited[temp] = 0;
        for(int i = 0; i < n; i++)
        {
            if(dis[i] > dis[temp] + maps[temp][i])
            {
                dis[i] = dis[temp] + maps[temp][i];
                if(visited[i] == 0)
                {
                    visited[i] = 1;
                    q.push(i);//当前最短距离的点入队
                }
            }

        }
    }
    if(dis[t] == inf)
        return -1;
    else
        return dis[t];
}
int main()
{
    int a, b, x, s, t, ans;
    while(scanf("%d %d", &n, &m) != EOF)
    {
        for(int i = 0; i < n; i++)
            for(int j = 0; j < n; j++)
                maps[i][j] = (i == j ? 0 : inf);
        while(m--)
        {
            scanf("%d %d %d", &a, &b, &x);
            if(x < maps[a][b])
                maps[a][b] = maps[b][a] = x;
        }
        scanf("%d %d", &s, &t);
        ans = spfa(s, t);
        printf("%d
", ans);
    }
    return 0;
}

参考博客：最短路径问题---Dijkstra算法详解  最快最好用的——spfa算法