Dijkstra算法分析及实现

Author： Nirvana Of Phoenixl
Proverbs for you：There is no doubt that good things will always come, and when it comes late, it can be a surprise.

1 单源最短路径

  Dijkstra算法是解决单源问题的一个贪心算法ID，给定一个带权有向图G=(V，E)，其中每条边的权是非负实数。另外还给定V中的一个顶点，称为源。现要计算从源到所有其他各顶点的最短路长度。这里路的长度是指路上各边权之和ID。这个问题通常称为单源最短路径问题。

2 Dijkstra算法基本思想

  设置顶点集合S并不断的做贪心选择来扩充这个集合。一个顶点属于集合S当且仅当从源到该顶点的最短路径长度已知。初始时，S中仅含有源。设u是G的某一个顶点，把从源u且中间只经过s中顶点的路径称为从源到u的特殊路径，并用数组dist记录当前每个顶点对应的最短特殊路径长。Dijkstra算法每次从V-S中取出具有最短特殊路长度的顶点u，将u添加到S中，同时对数组dist做必要的修改。一旦s包含的所有V中顶点，dist就记录了从源到其他各个顶点的最短路径长度。

3 实现要求

  （1）求路径长度；（2）输出最短路径

4 实现过程

4.1 基本流程：

  （1）初始时，S只包含起点s；U包含除s外的其他顶点，且U中顶点的距离为 “起点s到该顶点的距离”（例如，U中顶点v的距离为(s,v)的长度，然后s 和v不相邻，则v的距离为∞）。
  （2）从U中选出“距离最短的顶点k”，并将顶点k加入到S中；同时，从U中移除顶点k。
  （3）更新U中各个顶点到起点s的距离。之所以更新U中顶点的距离，是由于上一步中确定了k是求出最短路径的顶点，从而可以利用k来更新其它顶点的距离；例如，(s，v)的距离可能大于(s，k)+(k，v)的距离。
  （4）重复步骤(2)和(3)，直到遍历完所有顶点。
单纯的看上面的理论可能比较难以理解，下面通过实例来对该算法进行说明

4.2 代码实现过程：

  根据算法原理定义节点、权值、边等参数；通过初始化操作确定头节点也就是顶点；根据带权有向图描述其细节指定其定义参数的具体值，用以建图，并通过设计程序输入起始点、结束点和权值用以确定图，从而通过贪心原理依次遍历每个节点并统计其权重，计算保存从开始节点到每个顶点的最短路径，也就是利用Dijkstra算法进行计算，打印输出路径长度和最短路径。具体实现及结果部分见截屏，并在文章附录代码。

部分代码截图（完成代码在最后）

4.3 创建图、运行算法：

  创建5节点7边长的带权有向图：依次输入起始点、终止点、权值即可确定：

  组建图信息，包括从当前点开始连接的不同点及其权重：

   运行Dijkstra算法计算路径长度并统计最短路径：

代码附录(C++)：

```cpp
#include <iostream>
#include <limits>
using namespace std;


//-------单源问题带权有向图的算法描述和定义
struct Node {      //定义表结点
	int adjvex;    //该边所指向的顶点的位置
	int weight;    // 边的权值
	Node *next;    //下一条边的指针
};


//-------结构体头节点初始化
struct HeadNode {  // 定义头结点
	int nodeName;  // 顶点信息
	int inDegree;  // 入度
	int d;         //表示当前情况下起始顶点至该顶点的最短路径,初始化为无穷大
	bool isKnown;  //表示起始顶点至该顶点的最短路径是否已知,true表示已知，false表示未知
	int parent;    //表示最短路径的上一个顶点
	Node *link;    //指向第一条依附该顶点的边的指针
};


// -------描述细节带权有向图,其中G表示指向头结点数组的第一个结点的指针,
//-------nodeNum表示结点个数,arcNum表示边的个数
void createGraph(HeadNode *G, int nodeNum, int arcNum) {
	cout << "开始创建图(" << nodeNum << ", " << arcNum << ")" << endl;
     	//初始化头结点
	for (int i = 0; i < nodeNum; i++) {
		G[i].nodeName = i + 1; //位置0上面存储的是结点v1,依次类推
		G[i].inDegree = 0; //入度为0
		G[i].link = NULL;
	}
	for (int j = 0; j < arcNum; j++) {
		int begin, end, weight;
		cout << "依序输入 起始点-结束点-权值: ";
		cin >> begin >> end >> weight;
		// 创建新的结点插入链接表
		Node *node = new Node;
		node->adjvex = end - 1;
		node->weight = weight;
		++G[end - 1].inDegree; //入度加1
		//插入链接表的第一个位置
		node->next = G[begin - 1].link;
		G[begin - 1].link = node;
	}
}

//计算从建立的带权有向图，以各点为起点统计各边的权重（两点间路径长度）
void printGraph(HeadNode *G, int nodeNum) {
	for (int i = 0; i < nodeNum; i++) {
		cout << "结点V" << G[i].nodeName << "的入度为";
		cout << G[i].inDegree << ", 以其为起始顶点的边为: ";
		Node *node = G[i].link;
		while (node != NULL) {
			cout << "v" << G[node->adjvex].nodeName << "(权:" << node->weight << ")" << "  ";
			node = node->next;
		}
		cout << endl;
	}
}


//得到begin->end权重
int getWeight(HeadNode *G, int begin, int end) {
	Node *node = G[begin - 1].link;
	while (node) {
		if (node->adjvex == end - 1) {
			return node->weight;
		}
		node = node->next;
	}
}


//从start开始，计算其到每一个顶点的最短路径
void Dijkstra(HeadNode *G, int nodeNum, int start) {
	//初始化所有结点
	for (int i = 0; i < nodeNum; i++) {
		G[i].d = INT_MAX; //到每一个顶点的距离初始化为无穷大
		G[i].isKnown = false; // 到每一个顶点的距离为未知数
	}
	G[start - 1].d = 0; //到其本身的距离为0
	G[start - 1].parent = -1; //表示该结点是起始结点
	while (true) {
		//==== 如果所有的结点的最短距离都已知, 那么就跳出循环
		int k;
		bool ok = true; //表示是否全部ok
		for (k = 0; k < nodeNum; k++) {
			//只要有一个顶点的最短路径未知,ok就设置为false
			if (!G[k].isKnown) {
				ok = false;
				break;
			}
		}
		if (ok) return;
		//==========================================


		//==== 搜索未知结点中d最小的,将其变为known
		//==== 这里其实可以用最小堆来实现
		int i;
		int minIndex = -1;
		for (i = 0; i < nodeNum; i++) {
			if (!G[i].isKnown) {
				if (minIndex == -1)
					minIndex = i;
				else if (G[minIndex].d > G[i].d)
					minIndex = i;
			}
		}
		//===========================================


		cout << "当前选中的结点为: v" << (minIndex + 1) << endl;
		G[minIndex].isKnown = true; //将其加入最短路径已知的顶点集
		// 将以minIndex为起始顶点的所有的d更新
		Node *node = G[minIndex].link;
		while (node != NULL) {
			int begin = minIndex + 1;
			int end = node->adjvex + 1;
			int weight = getWeight(G, begin, end);
			if (G[minIndex].d + weight < G[end - 1].d) {
				G[end - 1].d = G[minIndex].d + weight;
				G[end - 1].parent = minIndex; //记录最短路径的上一个结点
			}
			node = node->next;
		}
	}
}


//打印到end-1的最短路径
void printPath(HeadNode *G, int end) {
	if (G[end - 1].parent == -1) {
		cout << "v" << end;
	}
	else if (end != 0) {
		printPath(G, G[end - 1].parent + 1); // 因为这里的parent表示的是下标，从0开始，所以要加1
		cout << " -> v" << end;
	}
}
int main() {
	HeadNode *G;
	int nodeNum, arcNum;
	cout << "请输入顶点个数和边个数: ";
	cin >> nodeNum >> arcNum;
	G = new HeadNode[nodeNum];
	createGraph(G, nodeNum, arcNum);


	cout << "***********************************" << endl;
	cout << "建图图信息..." << endl;
	printGraph(G, nodeNum);


	cout << "***********************************" << endl;
	cout << "Dijkstra算法..." << endl;
	Dijkstra(G, nodeNum, 1);


	cout << "***********************************" << endl;
	cout << "统计从V1开始所有的最短路径" << endl;
	for (int k = 2; k <= nodeNum; k++) {
		cout << "v1到v" << k << "的最短路径为" << G[k - 1].d << ": ";
		printPath(G, k);
		cout << endl;
	}
}