最短路徑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));
}