算法6.10 迪杰斯特拉算法

算法6.10　迪杰斯特拉算法

代码实现

//算法6.10　迪杰斯特拉算法
#pragma once
#include <iostream>

using namespace std;

//图的邻接矩阵存储
//表示极大值
#define MaxInt 32767
//最大顶点数
#define MVNum 100
//顶点类型
typedef char VerTexType;
//边上的权值类型
typedef int ArcType;


//三个辅助数组
int* D = new int[MVNum];//用于记录最短路的长度 
bool* S = new bool[MVNum];//标记顶点是否进入S集合
int* Path = new int[MVNum];//用于记录最短路顶点的前驱


//------------图的邻接矩阵-----------------

typedef struct
{
	//顶点表
	VerTexType vexs[MVNum];
	//邻接矩阵
	ArcType arcs[MVNum][MVNum];
	//图中当前顶点数和边数
	int vexnum, arcnum;
}AMGraph;

int LocateVex(AMGraph G, VerTexType v) 
{
	//确定点v在G中的位置
	for (int i = 0; i < G.vexnum; ++i)
		if (G.vexs[i] == v)
			return i;
	return -1;
}




void CreateUDN(AMGraph& G)
{
	VerTexType v1, v2;
	ArcType w;
	int row;
	int col;
	//输入总顶点数，总边数
	cout << "请输总顶点数：";
	cin >> G.vexnum;
	cout << "请输总边数：";
	cin >> G.arcnum;
	//依次输入点的信息
	for (int i = 0; i < G.vexnum; i++)
	{
		cout << "输入顶点：";
		cin >> G.vexs[i];
	}
	//初始化邻接矩阵，边的权值置为最大值MaxInt
	for (int m = 0; m < G.vexnum; m++)
	{
		for (int n = 0; n < G.vexnum; n++)
		{
			G.arcs[m][n] = MaxInt;
		}
	}
	//构造邻接矩阵（非对称）
	for (int k = 0; k < G.arcnum; k++)
	{
		cout << "输入边依附的顶点以及权值：";
		cin >> v1 >> v2 >> w;
		row = LocateVex(G, v1);
		col = LocateVex(G, v2);
		G.arcs[row][col] = w;
	}
}

//输出有向网的邻接矩阵
void ShowGraph(AMGraph G)
{
	cout << "邻接矩阵为:" << endl;
	for (int i = 0; i < G.vexnum; i++)
	{
		for (int j = 0; j < G.vexnum; j++)
		{
			if (G.arcs[i][j]==MaxInt)
			{
				cout << "∞" << " ";
			}
			else
			{
				cout << G.arcs[i][j] << " ";
			}
			
		}
		cout << endl;
	}

}


//用Dijkstra算法求有向网G的v0顶点到其余顶点的最短路径 
void ShortestPath_DIJ(AMGraph G, int v0)
{	
	int v, i, w, min;
	//n为G中顶点的个数 
	int n = G.vexnum;                    	
	for (v = 0; v < n; ++v)
	{  //n个顶点依次初始化 
		S[v] = false; //S初始为空集 
		D[v] = G.arcs[v0][v]; //将v0到各个终点的最短路径长度初始化为弧上的权值 
		if (D[v] < MaxInt)
		{
			Path[v] = v0;//如果v0和v之间有弧，则将v的前驱置为v0 
		} 
		else 
		{
			Path[v] = -1;//如果v0和v之间无弧，则将v的前驱置为-1
		}  
	}

	S[v0] = true;  //将v0加入S 
	D[v0] = 0; //源点到源点的距离为0 

	/*―初始化结束，开始主循环，每次求得v0到某个顶点v的最短路径，将v加到S集―*/
	for (i = 1; i < n; ++i)
	{//对其余n-1个顶点，依次进行计算 
		min = MaxInt;
		for (w = 0; w < n; ++w)
		{
			if (!S[w] && D[w] < min)
			{
				//选择一条当前的最短路径，终点为v 
				v = w;
				min = D[w];
			}
		}

		S[v] = true; //将v加入S 
		for (w = 0; w < n; ++w) 
		{//更新从v0出发到集合V?S上所有顶点的最短路径长度 
			if (!S[w] && (D[v] + G.arcs[v][w] < D[w]))
			{
				D[w] = D[v] + G.arcs[v][w]; //更新D[w] 
				Path[w] = v; //更改w的前驱为v 
			}
		}
	}
}

 //显示最短路
void DisplayPath(AMGraph G, int begin, int temp) 
{
	if (Path[temp] != -1)
	{
		DisplayPath(G, begin, Path[temp]);
		cout << G.vexs[Path[temp]] << "-->";
	}
}

int main()
{
	//创建有向网的邻接矩阵
	AMGraph G;
	int i, j, num_start, num_destination;
	VerTexType start, destination;
	CreateUDN(G);
	cout << endl;
	cout << "*****无向网G创建完成！*****" << endl;
	//输出有向网的邻接矩阵
	ShowGraph(G);
	
	cout << "请依次输入起始点、终点名称：";
	cin >> start >> destination;
	num_start = LocateVex(G, start);
	num_destination = LocateVex(G, destination);
	ShortestPath_DIJ(G, num_start);
	cout << endl << "最短路径为：";
	DisplayPath(G, num_start, num_destination);
	cout << G.vexs[num_destination] << endl;


	system("pause");
	return 0;
}

运行结果