几种最短路径算法

Dijisktra

下面图片是从这个链接https://blog.csdn.net/qq_37796444/article/details/80663810找到，比较清楚

不能处理负边，时间复杂度O（n^2),堆优化O（nlogE）

基本思路：首先它是求单源点到其他边的最短路。方法就是创建一个集合来存放一些点，一开始放源点进去。然后每次取到集合外哪个点的距离最短，将其加入集合。（这个时候要更新，即通过该点再到其他点会不会比现在到其他点的距离短，会就更新）
在一开始输入图的信息后，肯定至少有一条边已经是最短边了，如果说能通过其他点再到目标点距离更短，那源点到这个其他点的距离不就更短了，不就是最短边了？

测试时，邻接矩阵太大了，爆掉了。

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
typedef long long ll;
const int unreach=2147483647;
ll node[10010][10010];//邻接矩阵存图
ll dist[10010];//单源点到其他点的距离
int exist[10010];//该点是否已列入集合中
int n,m,s,F,G,W;
/*
    给出一个有向图，请输出从某一点出发到所有点的最短路径长度
    N、M、S，分别表示点的个数、有向边的个数、出发点的编号
    Fi、Gi、Wi，分别表示第i条有向边的出发点、目标点和长度
*/
void dijkstra(int s)
{
    for(int i=1;i<=n;i++){
        dist[i]=node[s][i];
    }
    exist[s]=1;
    ll newnode,length;
    for(int k=1;k<=n-1;k++){
        for(int i=1;i<=n;i++){
            if(!exist[i]){
                newnode=i;
                length=dist[i];
                break;
            }
        }
        for(int i=1;i<=n;i++){
            if(!exist[i]&&dist[i]<length){
                newnode=i;
                length=dist[i];
            }
        }
        exist[newnode]=1;
        for(int i=1;i<=n;i++){
            dist[i]=min(dist[i],dist[newnode]+node[newnode][i]);
        }
    }
}
int main()
{
    cin>>n>>m>>s;
    //初始化
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            node[i][j]=unreach;
        }
        node[i][i]=0;
    }
    for(int i=1;i<=n;i++)
        exist[i]=0;
    //
    for(int i=0;i<m;i++){
        scanf("%d%d%d",&F,&G,&W);
        if(W<node[F][G])node[F][G]=W;
    }
    dijkstra(s);
    for(int i=1;i<=n;i++)
        printf("%lld ",dist[i]);
    return 0;
}

所以用邻接表，这里用vector模拟

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
typedef long long ll;
const int unreach=2147483647;
struct dot
{
    int pos;
    int length;
};
vector<dot> node[10010];
ll dist[10010];//单源点到其他点的最短距离
ll edge[10010];//点到其他点的距离
int exist[10010];//该点是否已列入集合中
int n,m,s,F,G,W;
/*
    给出一个有向图，请输出从某一点出发到所有点的最短路径长度
    N、M、S，分别表示点的个数、有向边的个数、出发点的编号
    Fi、Gi、Wi，分别表示第i条有向边的出发点、目标点和长度
*/
void dijkstra(int s)
{
    for(int i=1;i<=n;i++){
        dist[i]=unreach;
    }
    for(int j=0;j<node[s].size();j++){
        dot t=node[s][j];
        if(t.length<dist[t.pos]){//两个点之间可能不止一条边
            dist[t.pos]=t.length;
        }
    }
    dist[s]=0;

    exist[s]=1;
    ll newnode,length;
    for(int k=1;k<=n-1;k++){
        for(int i=1;i<=n;i++){
            if(!exist[i]){
                newnode=i;
                length=dist[i];
                break;
            }
        }
        for(int i=1;i<=n;i++){
            if(!exist[i]&&dist[i]<length){
                newnode=i;
                length=dist[i];
            }
        }
        exist[newnode]=1;
        for(int i=1;i<=n;i++)
            edge[i]=unreach;
        for(int i=0;i<node[newnode].size();i++){
            dot t=node[newnode][i];
            //两个点之间可能不止一条边
            if(t.length<edge[t.pos]){
                edge[t.pos]=t.length;
            }
        }
        for(int i=1;i<=n;i++){
            dist[i]=min(dist[i],dist[newnode]+edge[i]);
        }
    }
}
int main()
{
    cin>>n>>m>>s;
    //
    for(int i=0;i<m;i++){
        scanf("%d%d%d",&F,&G,&W);
        dot t;
        t.pos=G,t.length=W;
        node[F].push_back(t);
    }
    dijkstra(s);
    for(int i=1;i<=n;i++)
        printf("%lld ",dist[i]);
    return 0;
}

最后用堆优化

#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
using namespace std;
const int maxn = 100000 + 10;
struct Node {
    int pos;
    int dis;
    Node() {}
    Node(int p, int d) {
        pos = p;
        dis = d;
    }
};
// 由于优先队列默认为大顶堆，所以重载小于号要用 a.dis > b.dis，来起到小顶堆的作用
bool operator<(const Node &a, const Node &b) {
    return a.dis > b.dis;
}
int n,m,s,u,v,w;
int dis[maxn];
int vis[maxn];
vector<Node> G[maxn];
priority_queue<Node> que;

void dij(int s) {
    // 初始化距离
    for(int i=1;i<=n;i++){
        dis[i]=1e9+10;
    }
    dis[s] = 0;
    que.push(Node(s, 0));
    while(!que.empty()) {
        Node tmp = que.top();
        que.pop();
        if(vis[tmp.pos])continue;
        vis[tmp.pos]=1;
        // 更新节点 tmp 的邻接节点，若邻接节点被更新，则将节点和 dis 加入小顶堆
        int len = G[tmp.pos].size();
        for(int i = 0; i < len; ++i) {
            int pos = G[tmp.pos][i].pos;
            int d = G[tmp.pos][i].dis;
            if(dis[pos] > tmp.dis + d) {
                dis[pos] = tmp.dis + d;
                que.push(Node(pos, dis[pos]));
            }
        }
    }
}
int main()
{
    cin>>n>>m>>s;
    for(int i=0;i<m;i++){
        scanf("%d%d%d",&u,&v,&w);
        Node node;
        node.pos=v,node.dis=w;
        G[u].push_back(node);
    }
    dij(s);
    for(int i=1;i<=n;i++)
        printf("%d ",dis[i]);
    return 0;
}

Floyd

/*
    |Floyd算法|
    |任意点对最短路算法|
    |求图中任意两点的最短距离的算法|
*/

for (int i = 0; i < n; i++) {   //  初始化为0  
    for (int j = 0; j < n; j++)  
        scanf("%lf", &dis[i][j]);  
}  
for (int k = 0; k < n; k++) {  
    for (int i = 0; i < n; i++) {  
        for (int j = 0; j < n; j++) {  
            dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);  
        }  
    }
}