最短路问题的几种算法

一、单源最短路
（1）Dijkstra算法（时间复杂度为o（n^2））
双重循环

#include
#include 
#include
using namespace std;//DJK求最短路径，o(n^2)//不常用 
                    //单源最短路（下面可以求出st到每个点的最短路 ） *到上一个顶点为最短路不一定到下一个点就是最短路 
const int maxn = (int)1000 + 10;
const int INF = 0x3f3f3f3f;

int mp[maxn][maxn];//图 
int n,m;//n表示点，m表示边
int vis[maxn];
int dis[maxn];//记录st到每个点的最短路 
//全为0 —n-1； 
void init(int n){
    for(int i = 0;ifor(int j =0;jif(i == j) mp[i][j] = 0;//初始化环
            else mp[i][j] = INF; 
        }
    }
}

void getmap(int m){//建图 
    int u,v,val;
    for(int i = 0;i"%d%d%d",&u,&v,&val);
        u--,v--;//从0开始的 
        mp[u][v] = val,mp[v][u] = val;//无向图
        //mp[u][v] = val;//有向图 
    } 
}
void djk(int st,int en){
    memset(vis,0,sizeof(vis));
    vis[st] = 1;
    for(int i = 0;ifor(int i = 1;i//每一次都有一次更新 
        int mn = INF,id = -1;
        for(int j = 0;j//找到离st最近的点 
            if(dis[j] < mn && !vis[j]){
                mn = dis[j],id = j;
            }
        }
            if(id == -1) break;     
            vis[id] = 1;
            for(int j = 0;jif(!vis[j] && mp[id][j] != INF){
                    if(dis[j] > dis[id] + mp[id][j])
                        dis[j] = dis[id] + mp[id][j];
                }
            }
    }
    printf("%d\n",dis[en]);
}

//int main(){
//  scanf("%d%d",&n,&m);    
//  init(n);
//  getmap(m);
//  djk(n-1,0);
//}

（2）Dijkstra（链式前向星、优先队列求法）

#include 
#include 
#include 
using namespace std;

// <3> 优先队列优化的djk求单源最短路,链式前向星存图 时间复杂度o(E * log(V)) 

typedef pair<int, int>pii;
const int N = (int) 1e5 + 11; // 最大点数
const int M = (int) 1e6 + 11;
const int INF = (int) 0x3f3f3f3f;

struct  Edge{
    int to;
    int next;
    int val;
}edge[M<<1];


int n, m; // n 是图中的点数，m是图中的边数
int head[N], top;
void init(int n){ // 初始化
    memset(head, -1, sizeof(int) * (n + 1));
    top = 0;
} 

void Add(int u,int w,int v){
    edge[top].to = w;
    edge[top].val = v;
    edge[top].next = head[u];
    head[u] = top++;
}
void getmap(int m){ // 建图
    int u, v, val;
    while(m--){
        scanf("%d%d%d",&u , &v, &val); // u->v有边
        Add(u, v, val);  
        Add(v, u, val); // 如果是双向图，加上这个代码
    }
}
int dis[N];
void djk(int st, int ed){ // 核心代码，点的序号可以从0-(n-1)或者1-n
    memset(dis, 0x3f, sizeof(int) * (n + 1));
    priority_queuevector, greater > que; // make_pair(dis, v) 表示v到起点的距离为dis
    dis[st] = 0; que.push(make_pair(0, st));
    while(!que.empty()){
        pii p = que.top(); que.pop(); // 每次取离起点最近的
        int v = p.second;
        if(dis[v] < p.first) continue; // 如果 没有更优，跳过
        for(int i = head[v]; ~i; i = edge[i].next){
            Edge e = edge[i];
            if(dis[e.to] > dis[v] + e.val) { // 是否可以进行松弛
                dis[e.to] = dis[v] + e.val;
                que.push(make_pair(dis[e.to], e.to));
            }
        }
    }
    printf("%d\n", dis[ed] == INF ? -1 : dis[ed]);
}
//int main(){
//  int t; scanf("%d%d", &t, &n);
//  init(n);
//  getmap(t);
//  djk(n, 1);
//  return 0;
//}

(3)spfa算法（链式前向星、队列）

#include 
#include 
#include 
using namespace std;

// <1> spfa求单源最短路,链式前向星存图 时间复杂度o(kE) k是常数，大多数情况下为2

const int N = (int) 1e5 + 11; // 最大点数
const int M = (int) 1e6 + 11; // 最大边数
const int INF = (int) 0x3f3f3f3f;

struct Edge{ // 边的定义
    int to, val, next;
    Edge(){}
    Edge(int _to, int _val, int _next){
        to = _to; val = _val; next = _next;
    }
}edge[M << 1]; // !!如果是双向图的话，边的数量是题目中描述的二倍

int n, m; // n 是图中的点数，m是图中的边数
int head[N], top;
void init(int n){ // 初始化
    memset(head, -1, sizeof(int) * (n + 1));
    top = 0;
}
void Add(int u, int v, int val){ // 加单向边
    edge[top] = Edge(v, val, head[u]);
    head[u] = top++;
}
void getmap(int m){ // 建图
    int u, v, val;
    while(m--){
        scanf("%d%d%d",&u , &v, &val); // u->v有边
        Add(u, v, val);  
        Add(v, u, val); // 如果是双向图，加上这个代码
    }
}

bool vis[N]; int dis[N]; 
void spfa(int st, int ed){ // 核心代码,点序号从0-(n-1)或者1-n都可以
    memset(dis, 0x3f, sizeof(int) * (n + 1));
    memset(vis, false, sizeof(bool) * (n + 1)); // 清空和初始化
    queue<int>que; que.push(st); 
    vis[st] = true; dis[st] = 0;
    while(!que.empty()){
        int u = que.front(); que.pop(); vis[u] = false;
        for(int i = head[u]; ~i; i = edge[i].next){
            Edge e = edge[i];
            if(dis[e.to] > dis[u] + e.val) {//是否可以进行松弛
                dis[e.to] = dis[u] + e.val;
                if(!vis[e.to]){ // 是否在队列中，如果在可以跳过
                    que.push(e.to);
                    vis[e.to] = true;
                }
            }

        }
    } 
    printf("%d\n", dis[ed] == INF ? -1 : dis[ed]); // st到不了ed输出-1
}

int main(){
    int t; scanf("%d%d", &t, &n);
    init(n);
    getmap(t);
    spfa(n, 1);
    return 0;
}

*链式前向星（一种存图方式，很省时）

#include
using namespace std;
#define MAXN 10050
struct EDGE
{
    int w;//权值 
    int next;//与该边同起点的上一条边的位置 
    int e;//边的终点 
}edge[MAXN];
int cnt; 
int head[MAXN];//以i为起点的最后一条边
void add(int u,int v,int w)
{
    edge[cnt].w=w;
    edge[cnt].e=v;
    edge[cnt].next=head[u];//记录位置 
    head[u]=cnt++;//位置更新 
} 

int main()
{
    memset(head,0,sizeof(head));
    cnt=1;
    int n,a,b,c;
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>a>>b>>c;
        add(a,b,c);
    }
    int start;
    cin>>start;
    for(int i=head[start];i!=0;i=edge[i].next)
    {
        cout<"->"<" "<return 0;
}

二、多源最短路
（1）Floyd算法

#include 
#include 
#include 
using namespace std;

// <4> floyd求多源最短路,邻接矩阵存图 时间复杂度o(n^3)，可求得任意两个点之间的最短距离

const int N = (int) 1000 + 11;
const int INF = (int) 0x3f3f3f3f;

int n, m;
int mp[N][N];
void init(int n){ // 初始化
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            if(i == j) mp[i][j] = 0;
            else mp[i][j] = mp[j][i] = INF;
        }
    }
}
void getmap(int m){ // 建图
    int u, v, val;
    while(m--){
        scanf("%d%d%d", &u, &v, &val); u--; v--;
        mp[u][v] = mp[v][u] = min(mp[u][v], val); // 双向图写这行
        //mp[u][v] = min(mp[u][v], val); // 单向图写着行
    }
}
void floyd(int n){ // 核心代码，点的序号为0-n-1
    for(int k = 0; k < n; k++){ 
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                mp[i][j] = min(mp[i][j], mp[i][k] + mp[k][j]); // dp
            }
        }
    }
}

int main(){
    int t; scanf("%d%d", &t, &n);
    init(n);
    getmap(t);
    floyd(n);
    printf("%d\n", mp[n - 1][0] == INF ? -1 : mp[n - 1][0]);
    return 0;
}