最短路径问题

最短路径问题可以根据路径长度分为两种，一种是有负路径存在，一种是只有正路径。

对于只有正路径的情况，最经典的是dijkstra算法。

// dijkstra算法 伪代码

init_source_map(int d[], int nV);

push_all_V_into_queqe(pqueue<int>q, int nV);

for(int i=0; i<nV; i++){

    V = extract_min(q, d); //q.remove(V);

    relax_all(V);//(u, v, w(u, v))

}

复杂度分析：O(V*(V+V)) = O(V^2)。

实际代码：

#include<queue>
#include<stack>

using namespace std;

struct SE{
	int vIndex;
	int tag;
	int edge;
	SE* next;
};

struct SMap{
	SE* pE;
	int nnode;
};

void visit(SE *se){
	printf("%d\n", se->vIndex);
}

SMap* create_map(int matrix[][6], int n){
	SMap* pMap = new SMap();
	pMap->nnode = n;
	pMap->pE = new SE[n];
	memset(pMap->pE, 0, n*sizeof(SE));
	for (int i = 0; i<n; i++){
		pMap->pE[i].vIndex = i;
		pMap->pE[i].tag = 0;
		SE* p = &pMap->pE[i];
		for (int j = 0; j<n; j++){
			if (matrix[i][j] != 0){
				p->next = new SE();
				p->next->vIndex = j;
				p->next->edge = matrix[i][j];
				p->next->tag = 0;
				p->next->next = NULL;
				p = p->next;
			}
		}
	}
	return pMap;
}

int init_source_map(int d[], int nV){
	for (int i = 0; i<nV; i++){
		d[i] = INT_MAX;
	}
	d[0] = 0;
	return 0;
}

int push_all_V_into_queqe(pair<int, int> q[], int* d, int nV){
	for (int i = 0; i<nV; i++){
		q[i].first = 0;
		q[i].second = d[i];
	}
	return 0;
}

int extract_min(pair<int, int>q[], int* d, int nV){
	int mind = INT_MAX;
	int mini = 0;
	for (int i = 0; i<nV; i++){
		if (d[i]<mind && q[i].first == 0){
			mind = d[i];
			mini = i;
		}
	}
	q[mini].first = 1;
	return mini;
}

int relax_all(SE* pE, pair<int, int>q[], int d[], int V){

	SE* p = pE;
	int v = pE->vIndex;
	while (p->next){
		p = p->next;
		int u = p->vIndex;
		int w = p->edge;
		if (d[u] > d[v] + w){
			d[u] = d[v] + w;
			q[u].second = d[u];
		}
	}
	return 0;
}

int dijkstra(SMap* pmap){
	const int nV = 6;
	int d[nV] = { 0 };
	init_source_map(d, nV);
	pair<int, int>q[nV];
	push_all_V_into_queqe(q, d, nV);
	for (int i = 0; i<nV; i++){
		int V = extract_min(q, d, nV); // with q.remove(V);
		relax_all(&pmap->pE[V], q, d, V);
	}
	return 0;
}




int main(){
	int map[6][6] = {
		{ 0, 1, 0, 1, 0, 0 },
		{ 1, 0, 1, 1, 1, 0 },
		{ 0, 1, 0, 1, 0, 0 },
		{ 1, 1, 1, 0, 1, 0 },
		{ 0, 1, 0, 1, 0, 1 },
		{ 0, 0, 0, 0, 1, 0 }
	};

	SMap* smap = create_map(map, 6);
	dijkstra(smap);
	return 0;
}