Dijkstra单元最短路径，最小堆优化，SPFA算法求单源最短（c++）

介绍原理的有很多，所以直接附上代码：

输入

输入的第一行包含2个正整数n和s，表示图中共有n个顶点，且源点为s。其中n不超过50，s小于n。

以后的n行中每行有n个用空格隔开的整数。对于第i行的第j个整数，如果大于0，则表示第i个顶点有指向第j个顶点的有向边，且权值为对应的整数值；如果这个整数为0，则表示没有i指向j的有向边。当i和j相等的时候，保证对应的整数为0。

输出

只有一行，共有n-1个整数，表示源点至其它每一个顶点的最短路径长度。如果不存在从源点至相应顶点的路径，输出-1。

请注意行尾输出换行。

样例输入

4 1
0 3 0 1
0 0 4 0
2 0 0 0
0 0 1 0

样例输出

6 4 7 

#include <iostream>
#include <algorithm>
using namespace std;
#define INF (1 << 21)
static const int MAX = 500;
int cost[MAX][MAX];  //cost[i][j]数组表示点i 与点j 的距离
int d[MAX];            //d[i]表示源点s 距离i 点的距离
bool used[MAX];        //used[i] 表示点i 是否加入已确定的顶点
int V;
void dijkstra(int s){
    for(int i = 0; i < V; i++){        // 初始化d[i],和used[i]数组
        d[i] = INF;
        used[i] = false;
    }
    d[s] = 0;        //起点s 距离 s点的距离为0
    while(true){
        int v = -1;
        for(int u = 0; u < V; u++){        //从尚未使用过的顶点中选取距离最小的顶点
            if(!used[u] && (v == -1 || d[u] < d[v] )) v = u;
        }
        if(v == -1) break;
        used[v] = true;
        for(int u = 0 ; u < V; u++){        //更新d[i]，取之前的的d[i]值与 v点到u 点距离的最小值
            d[u] = min(d[u], d[v] + cost[v][u]);
        }
    }
}
int main()
{
    int s;
    cin >> V >> s;
    int x;
    for(int i = 0; i < V; i++){
        for(int j = 0; j < V; j++){        //输入cost[][],如果输入的是0，则设置为无穷大，即两点间无边
            cin >> x;
            if(x == 0)
                cost[i][j] = INF;
            else{
                cost[i][j] = x;
            }
        }
    }
    dijkstra(s);
    for(int i = 0; i < V; i++){
        if(i == s) continue;
        cout << (d[i] == INF ? -1 : d[i]) << " ";
    }
    return 0;
}

优先队列（最小堆）进行优化

#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
#define INF (1<<21)
const int N=1e3+9;
vector< pair<int,int> > E[N];
int n;
int dist[N];
int inq[N];
void dijkstra(int s){
    for(int i=0;i<n;i++){
        dist[i]=INF;
    }
    dist[s]=0;
    priority_queue< pair<int,int> > Q;
    Q.push(make_pair(-dist[s],s));
    while(!Q.empty()){
        int u = Q.top().second;
        Q.pop();
        if(inq[u])continue;
        inq[u]=1;
        for(int i=0;i<E[u].size();i++){
            int v = E[u][i].first;
            int d = E[u][i].second;
            if(d+dist[u]<dist[v]){
                dist[v] = d+dist[u];
                Q.push(make_pair(-dist[v],v));
            }
        }
    }
}
int main(){
    int s;
    cin>>n>>s;
    int x;
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            cin>>x;
            if(x)
                E[i].push_back(make_pair(j,x));
        }
    }
    dijkstra(s);
    for(int i=0;i<n;i++){
        if(i==s)continue;
        else{
            cout<<(dist[i]==INF ? -1 : dist[i])<<" ";
        }
    }
    return 0;
}

SPFA算法（最短路径的最快算法，可以检测负环，但无法处理）

#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<cmath>
using namespace std;
#define INF (1<<21)
const int N = 500;
vector<pair<int,int> > E[N];
int dist[N];
bool vis[N];
int num[N];
int n;
void spfa(int s){
 for(int i=0;i<n;i++){
    dist[i]=INF;
 }
  dist[s]=0;
  queue<int> q;
  q.push(s);
  vis[s]=true;
  num[s]++;
  while(!q.empty()){
    int now = q.front();
    q.pop();
    vis[now]=false;
    for(int i=0;i<E[now].size();i++){
        int v = E[now][i].first;
        int d = E[now][i].second;
        if(d+dist[now]<dist[v]){
            dist[v] = d+dist[now];
            if(vis[v]==true)continue;
            q.push(v);
            vis[v]=true;
            if(++num[v]>n-1) return;
        }
    }

  }

}
int main(){
    int s,x;
    cin>>n>>s;
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
                cin>>x;
            if(x!=0){
                E[i].push_back(make_pair(j,x));
            }
        }
    }
    spfa(s);
    for(int i=0;i<n;i++){
        if(i==s)continue;
        cout<<(dist[i]==INF? -1:dist[i])<<" ";
    }
    return 0;
}