Narrar
Hoy finalmente escribí sobre el famoso algoritmo codicioso, el algoritmo Dijkstra , y estaba un poco emocionado.
-
La historia de Xiao Ming
El algoritmo de Dijstra parece difícil para muchas personas y no es muy comprensible, ¡pero no es nada!
Por ejemplo, Xiao Ming quiere conducir solo desde la Universidad de Ciencia y Tecnología hasta un museo. Teniendo en cuenta el aumento de los precios del petróleo y los bolsillos empobrecidos, Xiao Ming no puede ser tan testarudo y emprender un viaje a pie, por lo que Xiao Ming comenzó a planificar cuidadosamente como un idiota, buscando el camino más corto. Para acabar con esos gastos innecesarios. Sacas el mapa y comparas cuidadosamente las distintas rutas al museo, pero la complicada red de carreteras deslumbra a Xiao Ming. No encontrarás la ruta más económica por un tiempo, y tu corazón está muy irritable. En este momento, Xiao Ming saca su bolsillo. El general Bai allí, respiró hondo, de repente una luz salió de su mente y rápidamente encontró el camino más corto.
-
¿Cómo lo logró Xiao Ming?
Xiao Ming se preguntó si podría encontrar primero el punto de referencia más cercano a la Universidad de Ciencia y Tecnología y luego usar este punto de referencia como punto de partida para encontrar el siguiente punto de referencia más cercano, paso a paso, hasta encontrar el destino. Dado que la distancia encontrada cada vez es la más cercana, la distancia acumulada desde el origen hasta el destino también es la más cercana. Efectivamente, fue una buena idea. El emocionado Xiao Ming tiró la mitad inacabada del General Bai al suelo, se frotó un par de veces con los pies y comenzó a buscar el camino más corto, y pronto encontró la ruta ideal. -
Con la espléndida vida de
Xiao Ming, experiencia en informática, Xiao Ming descubrió rápidamente oportunidades comerciales después de regresar. Gracias a su ingenio, desarrolló un software de mapas, ganó mucho dinero y usó el dinero para invertir en la plataforma de citas individual más grande de China: CSDN. , Conviértase en el jefe de CSDN y lleve una vida feliz.
Implementación de código :
/*
Dijkstra的思路就是：
找到与源点权值最小的边，然后再此边找到到其他顶点的最小的边，依次类推，每次找到的都是最小的边
最后所得的最短路径长度就是各最小边的和
*/
#include<iostream>
#include<string>
#include<stack>
using namespace std;
#define OK 1
#define ERROR 0
#define MAXint 32767 //表示无穷大
#define MVNum 100 //最大顶点数
//邻接矩阵的结构
typedef struct
{
string vexs[MVNum];//顶点表
int arcs[MVNum][MVNum];//邻接矩阵，也就是表示边的权值
int vexnum, arcnum;//图的顶点数和边的个数
}AMGraph;
//邻接矩阵的结构
//Dijstra结构
bool S[MVNum] = {
false };//记录从源点到终点是否已被确定最短路径长度
int Path[MVNum] = {
-1 };//记录终点的直接前驱序号
int D[MVNum];//记录最短路径长度
//Dijstra结构
//查询结点位置
int Locate(AMGraph G, string v)
{
for (int i = 0; i < G.vexnum; i++)
{
if (G.vexs[i] == v)
{
return i;
}
}
return -1;
}
//查询结点位置
//创建邻接矩阵
int CreateUDN(AMGraph& G)//无向图的构造
{
cout << "请输入图的顶点数和边数：";
cin >> G.vexnum >> G.arcnum;
cout << "请输入各点的信息：";
for (int i = 0; i < G.vexnum; i++)
{
cin >> G.vexs[i];
}
for (int i = 0; i < G.vexnum; i++)//初始化边的权值为MAXINT
{
for (int j = 0; j < G.vexnum; j++)
{
G.arcs[i][j] = MAXint;
}
}
cout << "各边的顶点信息和权值：";
for (int k = 0; k < G.arcnum; k++)//构造邻接矩阵
{
string v1, v2;
int w;//边的两个顶点以及权值
cin >> v1 >> v2 >> w;
int i = Locate(G, v1);//找到点的位置
int j = Locate(G, v2);
G.arcs[i][j] = w;//赋予权值
//G.arcs[j][i] = G.arcs[i][j];
}
return OK;
}
//创建邻接矩阵
//Dijksta
void ShortestPath_DIJ(AMGraph G, int v)
{
int n = G.vexnum;//图的节点的数量
for (int i = 0; i < n; i++)
{
D[i] = G.arcs[v][i];
if (D[i] < MAXint)
{
Path[i] = v;
}
else
{
Path[i] = -1;
}
}
S[v] = true;//初始化v已有最短路径
D[v] = 0;//最短路径为0
for (int i = 1; i < n; i++)
{
int min = MAXint;
for (int j = 0; j < n; j++)//找到与v邻接的边的权值最小的
{
if (!S[j] && D[j] < min)
{
v = j;
min = D[j];
}
}
S[v] = true;//找到最短路径
for (int k = 0; k < n; k++)//更新从v出发到各顶点的最短路径长度
{
if (!S[k] && (D[v] + G.arcs[v][k]) < D[k])
{
D[k] = D[v] + G.arcs[v][k];//更新最短路径长度
Path[k] = v;//更改k的前驱为v
}
}
}
}
//Dijksta
//显示最短路径
void ShowShortTest(AMGraph G, string v)
{
int s = Locate(G,v);//定位
ShortestPath_DIJ(G, s);
for (int i = 0; i < G.vexnum; i++)
{
stack<string> sta;//引入栈
if (i != s && Path[i] != -1)
{
sta.push(G.vexs[i]);
int path = Path[i];
while (path != -1)
{
sta.push(G.vexs[path]);
path = Path[path];
}
}
if (!sta.empty())
{
cout << sta.top();
sta.pop();
}
while (!sta.empty())
{
cout << "->";
cout << sta.top();
sta.pop();
}
if (i != s && Path[i] != -1)
{
cout << " 最短路径长度为：" << D[i];
cout << endl;
}
}
}
//显示最短路径
int main()
{
AMGraph G;
CreateUDN(G);
string v;
cout << "请输入起点：";
cin >> v;
ShowShortTest(G, v);
return 0;
}
/*
v0 v1 v2 v3 v4 v5
各边的顶点信息和权值：v1 v2 5 v2 v3 50 v0 v2 10 v0 v4 30 v4 v3 20 v3 v5 10 v0 v5 100 v4 v5 60
*/