最短路径和最小生成树常见算法整理

n点 m边
1.spfa算法最坏情况o(nm)一般情况下是线性的复杂度，当出现网格状的数据时容易出现最坏情况，一般不会被卡，边权可以是负数，但是不能有负环。最常用的算法因此写在第一个。
算法思想：该算法又叫做队列优化的bellman-ford算法，再bellman-ford算法将变小的保存在队列中（也就是会对距离产生变化的点）

#include<iostream>
#include<vector>
#include<queue>
#include<cstring>

using namespace std;

int n,m;
const int N=1e5+10;
vector<pair<int,int>>g[N];
int d[N];
bool in_que[N];

void spfa(){
    memset(d,0x3f,sizeof d);
    d[1]=0;
    queue<int>q;
    q.push(1);
    in_que[1]=true;
    while(q.size()){
        int ver=q.front();
        q.pop();
        in_que[ver]=false;
        for(pair<int,int>p:g[ver]){
            if(d[p.first]>d[ver]+p.second){
                d[p.first]=d[ver]+p.second;
                if(!in_que[p.first])q.push(p.first);
                in_que[p.first]=true;
            }
        }
    }
    if(d[n]>0x3f3f3f3f/2)cout<<"impossible";
    else cout<<d[n];
}

int main(){
    cin>>n>>m;
    while(m--){
        int a,b,c;
        cin>>a>>b>>c;
        g[a].push_back({b,c});
    }
    spfa();
    return 0;
}

2.dijkstra算法o(n*n)

#include<iostream>
#include<cstring>

using namespace std;

int n,m;
const int N=510;
int g[N][N];
int d[N];
bool v[N];
void dijkstra(){
    memset(d,0x3f,sizeof d);
    d[1]=0;
    for(int i=1;i<n;i++){
        int t=0;
        for(int j=1;j<=n;j++)
            if(!v[j]&&(t==0||d[j]<d[t]))t=j;
        v[t]=true;
        for(int j=1;j<=n;j++){
            if(!v[j]&&d[j]>d[t]+g[t][j])d[j]=d[t]+g[t][j];
        }
    }
    if(d[n]>=0x3f3f3f3f)cout<<-1;
    else cout<<d[n];
}

int main(){
    cin>>n>>m;
    memset(g,0x3f,sizeof g);
    while(m--){
        int a,b,c;
        cin>>a>>b>>c;
        g[a][b]=min(g[a][b],c);
    }
    dijkstra();
    return 0;
}

3.堆优化的dijkstra O(m*log(n))

#include<iostream>
#include<cstring>
#include<vector>
#include<queue>

using namespace std;

int n, m;
const int N = 1.5e5 + 10;
vector<pair<int, int>>g[N];
int d[N];
bool v[N];

void dijkstra() {
    memset(d, 0x3f, sizeof d);
    d[1] = 0;
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int,int>>>q;
    q.push({ 0,1 });
    while (q.size()) {
        pair<int, int>t = q.top();
        q.pop();
        if(v[t.second])continue;//防止重复判断堆中加入的元素
        v[t.second] = true;
        if(t.second==n)break;
        for (pair<int, int>p : g[t.second]) {
            int w = p.second;
            int ver = p.first;
            if (v[ver])continue;
            if (d[ver] > d[t.second] + w) {
                d[ver] = d[t.second] + w;
                q.push({ d[ver],ver });
            }
        }
    }
    if(d[n]>=0x3f3f3f3f)cout<<-1;
    else cout << d[n];
}

int main() {
    cin >> n >> m;
    while (m--) {
        int a, b, c;
        cin >> a >> b >> c;
        g[a].push_back({ b,c });
    }
    dijkstra();
    return 0;
}

最小生成树
1.prim （朴素版）O(n*n)
该算法跟dijkstra()算法特别像，不同点在于prim算法d数组（dist）维护的是到最小生成树的距离，prim算法可以进行堆优化，不过一般不常用，再稀疏图是kruskal算法更常用。

#include<iostream>
#include<cstring>

using namespace std;

int n,m;
const int N=510;
int d[N];
int g[N][N];
bool tg[N];

void prim(){
    memset(d,0x3f,sizeof d);
    d[1]=0;
    for(int i=1;i<n;i++){
        int t=0;
        for(int j=1;j<=n;j++)
            if(!tg[j]&&(t==0||d[j]<d[t]))t=j;
        tg[t]=true;
        for(int j=1;j<=n;j++){
            if(!tg[j]&&d[j]>g[t][j])d[j]=g[t][j];
        }
    }
    int res=0;
    for(int i=1;i<=n;i++)res+=d[i];
    if(res>0x3f3f3f3f/2)cout<<"impossible";
    else cout<<res;
}

int main(){
    cin>>n>>m;
    memset(g,0x3f,sizeof g);
    while(m--){
        int a,b,c;
        cin>>a>>b>>c;
        g[a][b]=min(g[a][b],c);
        g[b][a]=min(g[b][a],c);
    }
    prim();
    return 0;
}

2.kruskal算法 O(m*log(m))
算法的时间复杂度主要取决于排序的时间复杂度。算法的基本思想，将所有边小到大进行排序，遍历所有边，看看是否连通，如果不连通加入。

#include<iostream>
#include<algorithm>

using namespace std;

int n,m;
const int M=2e5+10;
const int N=1e5+10;
struct edge{int a,b,c;}edges[M];
int p[N];

int find(int a){
    if(p[a]!=a)p[a]=find(p[a]);
    return p[a];
}

void merge(int a,int b){
    p[find(a)]=find(b);
}

bool judge(int a,int b){
    return find(a)==find(b);
}

bool cmp(edge a,edge b){
    return a.c<b.c;
}

void kruskal(){
    int res=0;
    int cnt=0;
    sort(edges,edges+m,cmp);
    for(int i=0;i<m;i++){
        edge e=edges[i];
        if(!judge(e.a,e.b))merge(e.a,e.b),res+=e.c,cnt++;
    }
    if(cnt==n-1)cout<<res;
    else cout<<"impossible";
}

int main(){
    cin>>n>>m;
    for(int i=0;i<m;i++){
        int a,b,c;
        cin>>a>>b>>c;
        edges[i]={a,b,c};
    }
    for(int i=1;i<=n;i++)p[i]=i;
    kruskal();
    return 0;
}