【图论】单源最短路径Dijkstra算法

封装完后的优化版，复杂度O(mlogn)，n表示点数，m表示边数：
链式前向星写法：

#include<bits/stdc++.h>
#define ll long long
#define white 0
#define black 1
#define grey  2
#define endl '\n'
#define INF 0x3f3f3f3f3f
#define IO ios::sync_with_stdio(false);cin.tie(0);
using namespace std;
const int maxn=1e5+5;
int tot,head[maxn];
struct E{
	int to,next,w;
}edge[maxn<<1];
void add(int u,int v,int w){
	edge[tot].to=v;
	edge[tot].w=w;
	edge[tot].next=head[u];
	head[u]=tot++;
}
ll d[maxn];ll color[maxn];
priority_queue<pair<ll,ll> >q; 
ll n,m,s;int pre[maxn],id[maxn];
void Dijkstra(ll s){
	for(ll i=0;i<=n;i++) pre[i]=s,d[i]=INF,color[i]=white;
	d[s]=0;
	q.push(make_pair(0,s));
	color[s]=grey;
	while(!q.empty()){
		pair<ll,ll> f=q.top();
		q.pop();
		ll u=f.second;
		color[u]=black;
		if(d[u]<f.first*(-1)) continue;
		for(ll i=head[u];i!=-1;i=edge[i].next){
			int v=edge[i].to;
			if(color[v]==black) continue;
			if(d[v]>d[u]+edge[i].w){
				d[v]=d[u]+edge[i].w;
				q.push(make_pair(d[v]*(-1),v));
				color[v]=grey;
				pre[v]=u;//表示最终最短路中v的前缀是u
				id[v]=i;//表示最终最短路中指向v这个点的边号是i
			}		
		}
	}
}
int main(){
	cin>>n>>m>>s;
	memset(head,-1,sizeof(head));
	for(ll i=1;i<=m;i++){
		ll u,v,w;cin>>u>>v>>w;
		add(u,v,w);add(v,u,w);
	}
	Dijkstra(s);
	for(ll i=1;i<=n;i++){
		cout<<d[i]<<" ";
	}
	cout<<endl;
	int temp=n;//输出以temp点终点构成最短路的前缀
	while(temp!=s){
		cout<<temp<<" ";
		temp=pre[temp];
	}
}

封装后的朴素Dijk算法，时间复杂度O(n^2+m),n表示点数，m表示边数：

#include<bits/stdc++.h>
#define ll long long
#define endl '\n'
#define white 0
#define black 1
#define grey 2
using namespace std;
const int INF=0x3f3f3f3f;
const int mod=142857;
const int maxn=5050;
ll dis[maxn][maxn],d[maxn],color[maxn];
ll n,m,s;
void dijkstra(ll s){
	for(ll i=0;i<=n;i++){
		d[i]=INF;color[i]=white;
	}
	d[s]=0;color[s]=grey;
	while(1){
		ll mind=INF,u=-1;
		for(ll i=1;i<=n;i++){
			if(color[i]!=black&&d[i]<mind){
				mind=d[i];
				u=i;
			}
		}
		if(u==-1) break;
		color[u]=black;
		for(ll v=1;v<=n;v++){
			if(color[v]!=black&&dis[u][v]!=INF){
				if(d[v]>d[u]+dis[u][v]){
					d[v]=d[u]+dis[u][v];
					color[v]=grey;
				}
			}
		}
	}
}
int main(){
	cin>>n>>m>>s;
	for(ll i=0;i<maxn;i++){
		for(ll j=0;j<maxn;j++){
			dis[i][j]=INF;
			if(i==j) dis[i][j]=0;
		}
	}
	for(ll i=1;i<=m;i++){
		ll u,v,w;cin>>u>>v>>w;
		if(w<=dis[u][v]) dis[u][v]=dis[v][u]=w;
	}
	dijkstra(s);
	for(ll i=1;i<=n;i++) cout<<d[i]<<" ";
}

/*
4 6 1
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
1 4 4
*/
//output 0 2 4 3

vector写法：

#include<bits/stdc++.h>
#define ll long long
#define white 0
#define black 1
#define grey  2
#define endl '\n'
#define INF 0x3f3f3f3f3f
#define IO ios::sync_with_stdio(false);cin.tie(0);
using namespace std;
const int maxn=1e5+5;
ll d[maxn];ll color[maxn];
vector<pair<ll,ll> >vec[maxn];
priority_queue<pair<ll,ll> >q; 
ll n,m,s;
void Dijkstra(ll s){
	for(ll i=0;i<=n;i++) d[i]=INF,color[i]=white;
	d[s]=0;
	q.push(make_pair(0,s));
	color[s]=grey;
	while(!q.empty()){
		pair<ll,ll> f=q.top();
		q.pop();
		ll u=f.second;
		color[u]=black;
		if(d[u]<f.first*(-1)) continue;
		for(ll i=0;i<vec[u].size();i++){
			ll v=vec[u][i].first;
			if(color[v]==black) continue;
			if(d[v]>d[u]+vec[u][i].second){
				d[v]=d[u]+vec[u][i].second;
				q.push(make_pair(d[v]*(-1),v));
				color[v]=grey;
			}
		}
	}
}
int main(){
	cin>>n>>m>>s;
	for(ll i=1;i<=m;i++){
		ll u,v,w;cin>>u>>v>>w;
		vec[u].push_back(make_pair(v,w));
		vec[v].push_back(make_pair(u,w));
	}
	Dijkstra(s);
	for(ll i=1;i<=n;i++){
		cout<<d[i]<<" ";
	}
	cout<<endl;
}

---

优化版的最先队列代码板子写法：

#include<iostream>
#include<algorithm>
#include<queue>
#define MAX 100005
#define INF 0x3f3f3f3f
#define WHITE 0
#define BLACK 1
#define GRAY 2
using namespace std;

int n,e;//n为顶点个数，e为边数
vector<pair<int,int> > adj[MAX];//有向加权图的邻接矩阵表示
int d[MAX];

void dijkstra(int s){//使用优先队列优化的dijkstra
  priority_queue<pair<int,int> > pq;//优先队列pq
  int color[MAX];//color数组

  for(int i=0;i<=n;i++){//初始化
    d[i]=INF;
    color[i]=WHITE;
  }
  d[s]=0;//s到自身的距离为0
  pq.push(make_pair(0,s));//入队列
  color[s]=GRAY;
  while(!pq.empty()){//队列非空
    pair<int,int> f=pq.top();//取出队首元素，一定是d最小的
    pq.pop();
    int u=f.second;//u等于取出d最小元素的编号

    color[u]=BLACK;//访问u

    if(d[u]<f.first*(-1)){//取出最小值，如果不是最短路径则忽略
        continue;
    }

    for(int j=0;j<adj[u].size();j++){//访问u的邻接列表
        int v=adj[u][j].first;//v等于u邻接列表中元素的编号
        if(color[v]==BLACK){//若已经访问，则跳过
            continue;
        }
        if(d[v]>d[u]+adj[u][j].second){//松弛操作
            d[v]=d[u]+adj[u][j].second;
            pq.push(make_pair(d[v]*(-1),v));//入队列
            color[v]=GRAY;
        }
    }
  }
}

int main(){
  int s;
  cin>>n>>e>>s;
  int a,b,len;
  for(int i=0;i<e;i++){//读入邻接列表
    cin>>a>>b>>len;
    adj[a].push_back(make_pair(b,len));
    adj[b].push_back(make_pair(a,len)); //如果是单向连接就去掉   
  }

  dijkstra(s);
  for(int i=1;i<=n;i++){
    if(d[i]==INF) cout<<"2147483647 ";
    else cout<<d[i]<<' ';
  }
  return 0;
}

非优化版，小心MLE

#include<iostream>
#define MAX 10005
#define WHITE 0
#define BLACK 1
#define GRAY 2
#define INF 0x3f3f3f3f
using namespace std;

int n,e;//n为顶点个数，e为边数
int m[MAX][MAX];//m为图的邻接矩阵
int d[MAX];//d[]数组
int color[MAX];//访问数组

void dijkstra(int s){
  int minv;
  for(int i=0;i<=n;i++){//初始化
    color[i]=WHITE;
    d[i]=INF;
  }

  d[s]=0;//起始点的d为0
  color[s]=GRAY;//访问起始点

  while(1){
    minv=INF;
    int u=-1;
    for(int i=1;i<=n;i++){//找到图中d[i]最小的点
        if(minv>d[i]&&color[i]!=BLACK){
            u=i;
            minv=d[i];
        }
    }

    if(u==-1){//若所有点都已经访问，则跳出循环
        break;
    }
    color[u]=BLACK;//访问u结点
    for(int v=1;v<=n;v++){//松弛操作
        if(color[v]!=BLACK&&m[u][v]!=INF){
            if(d[v]>d[u]+m[u][v]){
                d[v]=d[u]+m[u][v];
                color[v]=GRAY;
            }
        }
    }
  }
}

int main(){
  int s;//起点
  cin>>n>>e>>s;
  int a,b,len;
  for(int i=0;i<MAX;i++){//m[][]初始化
    for(int j=0;j<MAX;j++){
        m[i][j]=INF;
    }
  }
  for(int i=0;i<e;i++){//读入数据
    cin>>a>>b>>len;
    if(m[a][b]>len){
       m[a][b]=len;
  	   m[b][a]=len;//如果是双向图就加上这一行，否则去掉
  	}
  }
  dijkstra(s);//求s到其他点的最短路径
  for(int i=1;i<=n;i++){
    if(d[i]==INF) cout<<"2147483647 ";
    else cout<<d[i]<<' ';
  }
  return 0;
}