Dijkstra算法——基本原理 + 各部分本质及其衍生操作

本文深入解析Dijkstra算法,一种用于寻找单源最短路径的经典算法。文章详细介绍了算法的背景、原理及实现步骤,包括如何更新路径表、访问表,并探讨了贪心策略的应用。此外,还提供了双源最短路径及路径数量的求解方法,通过实例讲解加深理解。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

Dijkstra背景

Dijkstra是研究

  1. 单源
  2. 最短
  3. 路径长度

的算法
且 边长度/权值 不能有负数

注:且大部分题目都以无向边形式呈现

Dijkstra原理解析

Dijkstra的思路是更新2个表,其中有

  1.  mark:标记点是否被访问过
  2.  path:走到每个点的权值/路径
  3.  其他追加记录:可访问表(略)

写法上

Dijkstra有3个模块;

模块0:设定初始状态
1、visit设定全false 2、path设定全为INT_MAX,起始点为0 3、定义 每次访问的点;最小路经

开始循环:设定最小路经为 INT_MAX

  1. 模块1——循环1:遍历visit表;找到path表中最小的 点;
  2. 模块2:更新visit表及其他操作(例如 记录访问的点 等)
  3. 模块3——循环2:遍历min的邻接点;更新path表

原因:当走到min点后,可不可能存在:“通过先到min,再到目标点 比 原来直接达到目标点 更短”
若有则更新path表

模块1的追加操作:强化贪心判断(存在先后优先级的多个判断)

操作1的本质:Dijkstra的核心思想——贪心(每次都抓取局部最优解)

操作1:追加点权——要求在同时最短路下,同时判别点权最小/大

for (auto i = visit.begin(); i != visit.end(); ++i) {
	if (i->second == false && length[i->first] < min_path) {
		min_path = length[i->first];
		next = i->first;
	}
	else if (i->second == false && length[i->first] == min_path) {
		if (happy_sum[i->first] > happy_sum[next]) {
			next = i->first;
		}

在操作1的基础上可以进行拓展,追加多个判断

 

模块2的追加操作:

模块2的本质:在Dijkstra的已找到最优解下,进行记录
即:全局操作

 

模块3的追加操作:拓展处理双源问题(明确起点和终点)

模块3的本质:当有点可访问时/存在更短的路经时;更新对这个点的一系列状态(所需路经等)
即:局部操作

注:以上操作仍然要全部点访问一遍再跳出Dijkstra,即做一次完整的Dijkstra
而不是访问到终点就跳出

操作1:确定1条双源最短路经

原理:用1个容器,来记录前后关系

具体操作:

初始化:对每个点,与他自身进行线索

例:输入时作如下操作

tree[x] = x;

实际过程类似构建1个以起点为根的n叉树

在模块3的循环下添加:(此处以邻接表为例)

for (auto i = graph[u].begin(); i != graph[u].end(); ++i) {
	if (visit[(*i).v] == false && (*i).key + length[u] < length[(*i).v]) {
		length[(*i).v] = (*i).key + length[u];
		tree[(*i).v] = next;//每次有更小路经时,则挂上前驱
	}
}

最终脱出Dijkstra时,从想要的终点进行逆向线索到起点即可

操作2:确定双源最短路经的条数

原理:用1个容器,来记录访问到该结点的路经数

具体操作:

初始化:对起点start,设置cout[start]=1

在模块3的循环判断 下添加:

在<时追加

path_number[(*i).v] = path_number[u];

在==时追加

path_number[(*i).v] += path_number[u];

课后练习

PAT 1087 All Roads Lead to Rome

此题网上大部分解都是基于柳神的DFS+Dijkstra

但是可以只用Dijkstra进行破解,考察了贪心法的思路和对点的维护
即 模块1和模块3的追加操作

注:用柳神的办法确实好理解,但是如果能用纯Dijkstra进行破解,定能加深你对Dijkstra本质的理解

注:以上全文都是基于该题,产生的新理解,新总结

讲解 Dijkstra 算法的基本思想,另外还有算法实现. 当然了,这个算法当路径点上万的时候效率上会降低。 我有另外的改进实现, 上万个点也是在200毫秒内完成。但是不知道怎么添加, 我只能在这里贴关键代码了 : static std::list<Node*> vecNodes; static std::list<Edge*> vecEdges; bool CDijkstras::DijkstrasFindPath(Node* psrcNode, Node* pdstNode, std::list<Node*>& vec, double& fromSrcDist) { if (psrcNode == 0 || pdstNode == 0) return false; if (psrcNode == pdstNode) { vec.push_back(pdstNode); return false; } std::list<Node*>::const_iterator it; for (it=vecNodes.begin(); it!=vecNodes.end(); it++) { (*it)->bAdded = false; (*it)->previous = 0; (*it)->distanceFromStart = MAXDOUBLE; (*it)->smallest = 0; } bool bFindDst = DijkstrasRouteInitialize(psrcNode, pdstNode); fromSrcDist = pdstNode->distanceFromStart; Node* previous = pdstNode; while (previous) { vec.push_back(previous); previous = previous->previous; } m_pDstNode = pdstNode; return bFindDst; } bool CDijkstras::DijkstrasRouteInitialize(Node* psrcNode, Node* pdstNode) { bool bFindDst = false; psrcNode->distanceFromStart = 0; Node* smallest = psrcNode; smallest->bAdded = true; std::list<Node*>::const_iterator it, ait; std::list<Node*> AdjAdjNodes ; for (it=psrcNode->connectNodes.begin(); it!=psrcNode->connectNodes.end(); it++) { if ((*it)->bAdded) continue; (*it)->smallest = psrcNode; (*it)->bAdded = true; AdjAdjNodes.push_back(*it); } while (1) { std::list<Node*> tempAdjAdjNodes; for (it=AdjAdjNodes.begin(); it!=AdjAdjNodes.end(); it++) { Node* curNode = *it; for (ait=curNode->connectNodes.begin(); ait!=curNode->connectNodes.end(); ait++) { Node* pns = *ait; double distance = Distance(pns, curNode) + pns->distanceFromStart; if (distance < curNode->distanceFromStart) { curNode->distanceFromStart = distance; curNode->previous = pns; } if (pns->bAdded == false) { tempAdjAdjNodes.push_back(pns); pns->bAdded = true; } } if (curNode == pdstNode) { bFindDst = true; } } if (bFindDst) break; if (tempAdjAdjNodes.size() == 0) break; AdjAdjNodes.clear(); AdjAdjNodes = tempAdjAdjNodes; } return bFindDst; } // Return distance between two connected nodes float CDijkstras::Distance(Node* node1, Node* node2) { std::list<Edge*>::const_iterator it; for (it=node1->connectEdges.begin(); it!=node1->connectEdges.end(); it++) { if ( (*it)->node1 == node2 || (*it)->node2 == node2 ) return (*it)->distance; } #ifdef _DEBUG __asm {int 3}; #endif return (float)ULONG_MAX; } /****************************************************************************/ /****************************************************************************/ /****************************************************************************/ //得到区域的Key// __int64 CDijkstras::GetRegionKey( float x, float z ) { long xRegion = (long)(x / m_regionWidth); long zRegion = (long)(z / m_regionHeight); __int64 key = xRegion; key <<= 32; key |= ( zRegion & 0x00000000FFFFFFFF ); return key; } //得到区域的Key// __int64 CDijkstras::GetRegionKey( long tx, long tz ) { long xRegion = tx ; long zRegion = tz ; __int64 key = xRegion; key <<= 32; key |= ( zRegion & 0x00000000FFFFFFFF ); return key; } //取得一个区域内的所有的路径点, 返回添加的路径点的个数// unsigned long CDijkstras::GetRegionWaypoint (__int64 rkey, std::vector<Node*>& vec) { unsigned long i = 0; SAME_RANGE_NODE rangeNode = mmapWaypoint.equal_range(rkey); for (CRWPIT it=rangeNode.first; it!=rangeNode.second; it++) { i++; Node* pn = it->second; vec.push_back(pn); } return i; } inline bool cmdDistanceNode (Node* pNode1, Node* pNode2) { return pNode1->cmpFromStart < pNode2->cmpFromStart; }; //添加一个路径点// Node* CDijkstras::AddNode (unsigned long id, float x, float y, float z) { Node* pNode = new Node(id, x, y, z); __int64 rkey = GetRegionKey(x, z); mmapWaypoint.insert(make_pair(rkey, pNode)); mapID2Node[id] = pNode; return pNode; } //添加一条边// Edge* CDijkstras::AddEdge (Node* node1, Node* node2, float fCost) { Edge* e = new Edge (node1, node2, fCost); return e; } //通过路径点ID得到路径点的指针// Node* CDijkstras::GetNodeByID (unsigned long nid) { std::map<unsigned long, Node*>::const_iterator it; it = mapID2Node.find(nid); if (it!=mapID2Node.end()) return it->second; return NULL; }
Dijkstra算法是一种用于在加权图中找到最短路径的算法,它可以处理没有负权边的图。算法的基本思想是,从源点开始,逐步增加到其他顶点的距离,直到找到最短路径为止。Dijkstra算法采用贪心策略,每次找到距离源点最近的一个未被访问的顶点,并更新其他顶点到源点的距离。 在Java中实现Dijkstra算法通常需要使用优先队列来优化查找当前距离源点最近顶点的过程。以下是Dijkstra算法的Java实现的一个简单例子: ```java import java.util.*; class Dijkstra { // 图的顶点数量 private static final int N = 9; // Dijkstra算法的实现 public static void dijkstra(int[][] graph, int startVertex) { // 记录源点到每个顶点的最短路径 int[] dist = new int[N]; // 初始化距离数组,所有顶点距离设置为无穷大 Arrays.fill(dist, Integer.MAX_VALUE); // 用于标记顶点是否被访问过 boolean[] visited = new boolean[N]; // 起始点到自身的距离是0 dist[startVertex] = 0; // 用优先队列优化查找最小距离的顶点 PriorityQueue<Integer> pq = new PriorityQueue<>(Comparator.comparingInt(i -> dist[i])); // 将起始点加入优先队列 pq.add(startVertex); while (!pq.isEmpty()) { // 从优先队列中选出距离最小的顶点 int u = pq.poll(); // 如果这个顶点已经被访问过,跳过 if (visited[u]) continue; // 标记顶点为已访问 visited[u] = true; // 遍历所有邻接的顶点 for (int v = 0; v < N; v++) { // 如果顶点u到顶点v存在边,并且顶点v未被访问 if (graph[u][v] != 0 && !visited[v]) { // 计算源点通过顶点u到顶点v的路径长度 int newDist = dist[u] + graph[u][v]; // 如果新的路径长度小于当前记录的路径长度,则更新之 if (newDist < dist[v]) { dist[v] = newDist; // 将顶点v加入优先队列 pq.add(v); } } } } // 输出从源点到每个顶点的最短路径长度 for (int i = 0; i < N; i++) { System.out.println("Distance from vertex " + startVertex + " to vertex " + i + " is " + dist[i]); } } public static void main(String[] args) { // 示例图的邻接矩阵表示 int[][] graph = { {0, 4, 0, 0, 0, 0, 0, 8, 0}, {4, 0, 8, 0, 0, 0, 0, 11, 0}, {0, 8, 0, 7, 0, 4, 0, 0, 2}, {0, 0, 7, 0, 9, 14, 0, 0, 0}, {0, 0, 0, 9, 0, 10, 0, 0, 0}, {0, 0, 4, 14, 10, 0, 2, 0, 0}, {0, 0, 0, 0, 0, 2, 0, 1, 6}, {8, 11, 0, 0, 0, 0, 1, 0, 7}, {0, 0, 2, 0, 0, 0, 6, 7, 0} }; // 从顶点0开始计算最短路径 dijkstra(graph, 0); } } ``` 在这个例子中,`graph`是一个图的邻接矩阵表示,`dijkstra`方法实现了Dijkstra算法,`main`方法用于测试算法。请注意,这个例子假设图是用邻接矩阵表示的,并且顶点编号从0开始。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值