最短路径Dijkstra的两种实现方法

1、Dijkstra单源最短路，邻接矩阵形式（权值是非负）

/*
	单源最短路径，Dijkstra算法，邻接矩阵形式，复杂度为O（n^2）
	求出源beg到所有点的最短路径，传入图的顶点数，和邻接矩阵cost[][]
	返回个点的最短路径dist[],路径pre[].pre[i]记录beg到i路径上的父结点，pre[beg]=-1
	可更改路径权类型，但是权值必须为非负
*/

const int maxn = 1010;
const int INF = 0x3f3f3f3f;
int cost[maxn][maxn];
int dist[maxn];
int pre[maxn];
bool vis[maxn];

void dijkstra(int n, int beg){
	memset(vis, false, sizeof(vis));
	for(int i=0; i<n; i++){
		dist[i] = INF;
		pre[i] = -1;
	}
	dist[beg] = 0;
	for(int j=0; j<n; j++){
		int k = -1;
		int mi = INF;
		for(int i=0; i<n; i++){
			if(!vis[i] && dist[i]<mi){
				mi = dist[i];
				k = i;
			}
		}
		if(k == -1) break;
		vis[k] = true;
		for(int i=0; i<n; i++){
			if(!vis[i] && dist[k]+cost[k][i]<dist[i]){
				dist[i] = dist[k]+cost[k][i];
				pre[i] = k;
			}
		}
	}
}

1、Dijkstra算法+堆优化

使用优先队列优化，复杂度O（E log E）

/*
	使用优先队列优化Dijkstra算法
	复杂度O(E log E)
	注意对vector<Edge>E[maxn]进行初始化后加边		
*/
const int INF = 0x3f3f3f3f;
const int maxn = 100000+100;

struct qnode{
	int v;
	int c;
	qnode(int _v = 0, int _c = 0):v(_v),c(_c){}
	bool operator < (const qnode &r) const{
		return c > r.c;
	}
};

struct Edge{
	int v, cost;
	Edge(int _v = 0, int _cost = 0):v(_v),cost(_cost){}
};

vector<Edge> E[maxn];
bool vis[maxn];
int dist[maxn];

void dijkstra(int n, int start){
	memset(vis, false, sizeof(vis));
	for(int i=0; i<=n; i++){
		dist[i] = INF;
	}
	priority_queue<qnode>que;
	while(!que.empty()) que.pop();
	dist[start] = 0;
	que.push(qnode(start, 0));
	qnode tmp;
	while(!que.empty()){
		tmp = que.top();
		que.pop();
		int u = tmp.v;
		if(vis[u]) continue;
		vis[u] = true;
		for(int i=0; i<E[u].size(); i++){
			int v = E[u][i].v;
			int cost = E[u][i].cost;
			if(!vis[v] && dist[v] > dist[u]+cost){
				dist[v] = dist[u]+cost;
				que.push(qnode(v, dist[v]));
			}
		}
	}
}

void addedge(int u, int v, int w){
	E[u].push_back(Edge(v, w));
}