最短路径：迪杰斯特拉算法保姆级别详解

一，大致的遍历过程图解及过程讲解

先从开始点寻找与其他边连接最小的边

• 如下图（a）中，找A点与其它五点中C的距离最短弧；
•        所以连接AC（因为由图可知B点无入度，所以可忽略不计）；

---

• 图（b）将与A点连接的顶点和与C点连接的所有顶点的弧相比较，看谁距离最短，
• （因为此时D点不直接与A相连，而是通过中间点C，所以此时AD的距离可以看作AC+CD）
• 所以连接AE。

---

• 图（c）与A点连接的顶点和与C点连接的顶点和E点连接的所有顶点的弧相比较，看谁距离最短，
• 此时A点到F点有两条路：1，AF，2，通过E点再连接A->E->F.
•      此时A点到D点也有两条路：1，A->C->D;2,A->E->D;
•      此时通过比较A->E->D最短。所以连接ED；

---

• 图（d）与A点连接的顶点和与C点连接的顶点和E点连接的顶点和D点连接的所有顶点的弧相比较，看谁距离最短，
•      此时A到F有三条路：1，A->F;
•                                        2,A->E->F; 
•                                        3,A->E->D->F
•      根据比较长短可知第三种距离最短。所以连接DE。
• （因为B点没有入度，所以AB之间无连接）

二，实现方法

这种方法除了构造邻接矩阵所需的结构体和函数之外，加入了三个新数组：

int S[pointMax];         //到所求顶点的最短路径是否被确定，等于-1代表未被确认

     即表示某一点是否被连接（如上图a中，C点连接，则S[2]赋值为1，代表该点已确认）

int D[pointMax];         //最短路径

     即表示某点到所求点的距离（如上图a中，C点确认连接，则D[2]赋值为10，代表AC距离为10）

int Path[pointMax];      //连通弧的前驱

     为了防止出现回路，即某一连通边都赋值为一样，

    （如上图c中，ED连接，此时A->E->D连接，所以A点E点D点的Path[]值一样

 

1. 先构造邻接矩阵，并赋值，该过程类似于图的邻接矩阵储存法类似。
2. 先将上面新加入的三个数组进行赋值。
3. 从所有能连通的弧中，找到一个最小弧，并连通，然后给相对应的三个数组进行赋值改变。
4. 然后第三步继续循环循环，总共循环（顶点数-1）次。

大致思路都已经在上面的图中写出来了，只要将上面的图理解，大致就会了，三个数组只是辅助遍历。

实现截图

这个截图显示的信息并不是特别多（如果想知道详细每一次遍历后信息，可自行在对应地方添加显示信息）

四，代码

#include<iostream>
#include<stdlib.h>

using namespace std;

#define pointMax 100
#define MaxInt 32767

struct AMgroup
{
	char VTchart[pointMax];                  //顶点表
	int AMchart[pointMax][pointMax];         //邻接矩阵
	int point, vert;                         //点，边
};

int AMlocate(AMgroup A, char x)
{
	for (int i = 0; i < A.point; i++)        //依次输入点的信息
	{
		if (A.VTchart[i] == x)
		{
			return i;
			break;
		}
	}
}

void CreatAM(AMgroup &A)
{
	cout << "输入邻接矩阵顶点数：";          //第一步
	cin >> A.point;
	cout << "输入邻接矩阵边数：";
	cin >> A.vert;
	getchar();

	char a[100];
	cout << "输入点的信息：";                //第二步
	gets_s(a);
	for (int i = 0; i < A.point; i++)        //依次输入点的信息
	{
		A.VTchart[i] = a[i];
	}
	for (int i = 0; i < A.point; i++)        //初始换邻接矩阵，边的权值均设为最大
	{
		for (int j = 0; j < A.point; j++)
		{
			A.AMchart[i][j] = MaxInt;
		}
	}

	cout << endl;
	char v1, v2; int len;
	for (int i = 1; i <= A.vert; i++)        //构造邻接矩阵
	{
		cout << "输入第" << i << "条边的两个顶点以及权值：";
		cin >> v1 >> v2 >> len;
		int m, n;
		m = AMlocate(A, v1);
		n = AMlocate(A, v2);
		A.AMchart[m][n] = len;
	}
}

int S[pointMax];         //到所求顶点的最短路径是否被确定，等于-1代表未被确认
int D[pointMax];         //最短路径
int Path[pointMax];      //连通弧的前驱
void SP_DIJ(AMgroup &A, int v0)
{
	//初始化过程
	int number = A.point;                     //有向图中的顶点数
	for (int i = 0; i < number; i++)
	{
		S[i] = -1;                         //初始为空-1
		D[i] = A.AMchart[v0][i];           //各个顶点到v0的权值
		if (D[i] < MaxInt)
		{
			Path[i] = v0;                  //如果有边，则将i的前驱初始化为v0
		}
		else
		{
			Path[i] = -1;                  //无边则初始化为空-1
		}
	}
	S[v0] = 1;             //将v0加入S中
	D[v0] = 0;             //源点到源点的距离为0
	//求最短路径
	int n;
	for (int i = 1; i < number; i++)//对其余number-1个顶点依次进行计算
	{
		int min = MaxInt;
		for (int j = 0; j < number; j++)
		{
			if (S[j] == -1 && D[j] < min)
			{
				n = j;
				min = D[j];
			}
		}
		cout << n << ":" << min << endl;
		S[n] = 1;
		for (int j = 0; j < number; j++)
		{
			if (S[j] == -1 && D[n] + A.AMchart[n][j] < D[j])
			{
				D[j] = D[n] + A.AMchart[n][j];
				Path[j] = n;
			}
		}
	}
	cout << endl;
	for (int i = 0; i < A.point; i++)
	{
		if (i != v0)
		{
			if (D[i] == MaxInt)
			{
				cout << A.VTchart[v0] << "-->" << A.VTchart[i] << "不连通" << endl;
			}
			else
			{
				cout << A.VTchart[v0] << "-->" << A.VTchart[i] << "的最短路径为：" << D[i] << endl;
			}
		}
	}
}

int main()
{
	AMgroup *A = new AMgroup;
	CreatAM(*A);
	int m;
	cout << "\n从第几个点开始遍历：";
	cin >> m;
	SP_DIJ(*A, m);
	system("pause");
}