决策规划算法--Dijkstra算法（C++）

---

深度优先（DFS）和广度优先（BFS）

---

Dijkstra基本概念

-Dijkstra算法的前提：

1，Dijkstra处理的是带正权值的有权图，需要一个二维数组（如果空间大用list数组）存储各个点到达(边)的权值大小(通常用邻接矩阵存储)；

2，需要一个final数组，判断哪些点已经确定最短长度，哪些点没有确定；初始时全为false；

3，需要一个D数组，存储到各点最短路径的权值之和；算法执行途中不断更新；初始时为邻接矩阵里直接读取的值；

4，需要一个P数组，存储最短路径下标，也就是每个顶点被访问后的前驱顶点的下标；初始时全为V0；

5，需要优先队列加入已经确定点的周围点。每次抛出确定最短路径的那个并且确定最短，直到所有点路径确定最短为止；

Dijkstra算法概述：

网和图的最短路径含义是不同的：

• 网：两顶点之间经过的边上权值之和最小的路径；

• 图：两顶点之间经过的边数最少的路径；

给定带权有向图G和源点v，求v到G中其他顶点的最短路径，可以使用Dijkstra算法；

基于已经求出的最短路径的基础上，求得更远顶点的最短路径，最终得到整个最短路径，是贪心算法的思想；

Dijkstra算法求出的路径中，中途每个顶点到源点的的路径也是每个顶点的最短路径；

• 贪心算法：在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解；

• 贪心算法不是对所有问题都能得到整体最优解，关键是贪心策略的选择，选择的贪心策略必须具备无后效性，即某个状态以前的过程不会影响以后的状态，只与当前状态有关

---

Dijkstra算法实现流程

---

Dijkstra算法.h

#pragma once
#include<iostream>
#include<stack>
using namespace std;

#define MAX_VERTEX_NUM 20  //顶点的最大个数
#define INFINITE 9999      //定义无穷大的数值
#define VRType int		   //顺序存储结构中，对于无权图，用 1 或 0 表示是否相邻；对于带权图，直接为权值
#define VertexType int	   //图中顶点的数据类型


class MGraph //图的顺序存储结构
{
public:
	VertexType vexs[MAX_VERTEX_NUM]; //一维数组，存储图中顶点数据
	VRType arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; //二维数组，记录顶点之间的关系 //对于无权图，用 1 或 0 表示是否相邻；对于带权图，直接为权值
	int vexnum;	//记录图的顶点数
	int arcnum; //记录图的弧（或边）数
};

class Dijkstra
{
public:
	Dijkstra();//构造函数，初始化邻接矩阵
	int LocateVex(MGraph& G, VertexType v); //根据顶点本身数据，判断出顶点在二维数组中的位置
	void CreateUDN(MGraph& G);//构造无向带权图
	void PrintGrapth(MGraph G); //打印整个图
	void ShortestPath_Dijkstra();

public:
	MGraph G;//创建图的对象
	int V0 = 0;//起点下标，初始化为0，也就是默认输入的第一个值就是起点
	int Patharc[MAX_VERTEX_NUM];//存储最短路径下标，也就是每个顶点被访问后的前驱顶点的下标；
	int Distance[MAX_VERTEX_NUM];//存储到各点最短路径的权值之和
	bool final[MAX_VERTEX_NUM];//标志位，final[w]=true表示已经求得V0到Vw的最短路径，w这个顶点已经被访问；
	int k;//临时下标
	int min;//min是临时最短路径的权值（最小权值之和）；
	stack<int> path;//用于打印
};

Dijkstra算法.cpp

#include"Dijkstra算法.h"

Dijkstra::Dijkstra()//构造函数，初始化邻接矩阵
{
	CreateUDN(G);//在初始化时就创建图	

	//遍历所有顶点，更新Distance、Patharc和final三个数组，更新起点信息；
	for (int i = 0; i < G.vexnum; i++)
	{
		final[i] = false;//全部顶点先初始化为未找到最短路径；
		Distance[i] = G.arcs[V0][i];//将与V0邻接的顶点所构成的边加上权值，其他保持为INFINITE；也就是读取邻接矩阵里的信息，赋值到Distance数组中；
		Patharc[i] = V0;//前驱顶点的下标先全部置为V0；//这里不能初始化为0或者-1，后续会出错，要初始化为源点；
	}
	Distance[V0] = 0;//起点就是V0，V0到V0距离为0；
	final[V0] = true;//起点V0已经找到最短路径；

	cout << endl;
	PrintGrapth(G);//打印整个图
}

int Dijkstra::LocateVex(MGraph& G, VertexType v) //根据顶点本身数据，判断出顶点在数组中的位置
{
	//遍历一维数组，找到变量v
	for (int i = 0; i < G.vexnum; i++)
	{
		if (G.vexs[i] == v)
		{
			return i;//找到了
		}
	}
	//如果找不到，输出提示语句，返回-1
	cout << "no such vertex." << endl;
	return -1;
}

void Dijkstra::CreateUDN(MGraph& G)//构造无向带权图
{
	int v;
	int a;

reInput1:
	cout << "请输入网的顶点数：" << endl;
	cin >> v;
	if (v > MAX_VERTEX_NUM || v <= 0)
	{
		cout << "顶点数超出范围，请重新输入" << endl;
		goto reInput1;
	}

reInput2:
	cout << "请输入网的边数：" << endl;
	cin >> a;
	if (a > (v * (v - 1) / 2) || a <= 0)
	{
		cout << "边数超出范围，请重新输入" << endl;
		goto reInput2;
	}

	G.vexnum = v;
	G.arcnum = a;

	int vex;
	for (int i = 0; i < G.vexnum; i++) //输入每个顶点的元素数据，给一维数组赋值
	{
		cout << "请输入该顶点的元素：" << endl;
		cin >> vex;
		G.vexs[i] = vex;
	}

	for (int i = 0; i < G.vexnum; i++) //初始化矩阵，给矩阵赋值
	{
		for (int j = 0; j < G.vexnum; j++)
		{
			G.arcs[i][j] = INFINITE;//先把矩阵的每个元初始化为无穷
		}
	}

	for (int i = 0; i < G.arcnum; i++) //创建顶点之间的连接关系，更新矩阵
	{
		VertexType v1, v2;
		VRType w;
		cout << "请输入要创建关系的两个顶点元素：" << endl;
		cin >> v1;
		cin >> v2;
		cout << "请输入这两个顶点之间边的权值：" << endl;
		cin >> w;

		int n = LocateVex(G, v1);
		int m = LocateVex(G, v2); //确定顶点位置
		if (m == -1 || n == -1)
		{
			cout << "no this vertex." << endl;//输入的两个顶点至少有一个不存在
			return;
		}

		G.arcs[n][m] = w;//权值赋值
		G.arcs[m][n] = w;//矩阵对称
	}

	for (int i = 0; i < G.vexnum; i++)
	{
		for (int j = 0; j < G.vexnum; j++)
		{
			if (i == j) //对角线上的元置0
			{
				G.arcs[i][j] = 0;
			}
		}
	}
}

void Dijkstra::PrintGrapth(MGraph G) //打印整个图
{
	cout << "图的邻接矩阵是：" << endl;
	for (int i = 0; i < G.vexnum; i++)
	{
		for (int j = 0; j < G.vexnum; j++)
		{
			cout << G.arcs[i][j] << ", ";
		}
		cout << endl;
	}
	cout << endl;
}

void Dijkstra::ShortestPath_Dijkstra()
{
	for (int i = 1; i < G.vexnum; i++)//v从1开始，因为V0已经确定了，不再考虑；//遍历邻接矩阵的每一行
	{
		min = INFINITE;//先让min=无穷，先和无穷比，比无穷小说明有连线，否则没有连线；
		for (int j = 0; j < G.vexnum; j++)//遍历邻接矩阵的每一列
		{
			if (!final[j] && Distance[j] < min)//如果w这个顶点还没有确认最短路径，并且现有的权值之和小于min
			{
				k = j;//更新下标
				min = Distance[j];//更新min
			}
			//到这里为止只是更新了两个临时变量，还没有更新三个数组的内容
		}
		final[k] = true;//将目前找到的顶点置为ture，也就是k这个顶点已经找到最短路径 //final数组被更新

		for (int j = 0; j < G.vexnum; j++)//还是遍历这一行的每一列（相当于找这个顶点的临近点），更新当前最短路径前驱顶点和路径值
		{
			if (!final[j])//如果w这个顶点还没有确认最短路径，
			{
				if (min + G.arcs[k][j] < Distance[j])//并且经过k顶点到达j顶点的路径总和，要小于不经过k顶点、直接到达j顶点的路径；
				{
					Distance[j] = min + G.arcs[k][j];//就把最短路径的值更新为经过k顶点的路径总和，也就是选更小的权值和；//Distance数组被更新
					Patharc[j] = k;//前驱顶点下标更新为k //Patharc数组被更新
				}
			}
		}
	}
	cout << endl;

	/*for (auto i : Patharc)
	{
		cout << i << " ";
	}
	cout << endl;*/ //调试用

	//打印
	cout << "Dijkstra算法求出的最短路径是：" << endl;
	for (int i = 0; i < G.vexnum; i++)
	{
		if (i != 0 && Distance[i] != INFINITY)
		{
			cout << "从顶点" << G.vexs[V0] << "到顶点" << G.vexs[i] << "，" << "最短路径权值是：" << Distance[i] << "，最短路径为：";

			int m = i;
			while (m != 0)
			{
				path.push(G.vexs[m]);//入栈
				m = Patharc[m];//m更新为m的前驱
			}
			path.push(G.vexs[V0]);

			while (!path.empty())
			{
				if (path.size() == 1)
				{
					cout << path.top();//打印最后一个栈元素
				}
				else
				{
					cout << path.top() << "->";//打印栈顶
				}
				path.pop();//出栈
			}
			cout << endl;
		}
	}
	cout << endl;
}



int main()
{
	Dijkstra D0; //创建Dijkstra类的对象
	D0.ShortestPath_Dijkstra();//求最短路径

	system("pause");
	return 0;
}

声明

本人所有文章仅作为自己的学习记录，若有侵权，联系立删。