基于邻接矩阵的Dijkstra算法


title: LeetCode 基于邻接矩阵的Dijkstra算法

categories:

  • 算法

tags:

  • Programing
  • 算法
  • 最短路径
  • Dijkstra

基于邻接矩阵的Dijkstra算法

如果你的图不是邻接矩阵,转换成矩阵的形式就可以了。这里节点我就是用index表示的。

# fixme: Dijkstra算法寻找最短路径,从给定初始点到每个节点的最短路径
    def Dijkstra(self, start, adjacent_matrix):
        """
        :param start: Int 给点初始节点在邻接矩阵中的下标
        :param adjacent_matrix: 邻接矩阵
        :return: distance, path 返回到每个节点的最短距离,返回路径
        """
        # 初始化操作
        n = len(adjacent_matrix) # 节点个数
        inf = float('inf')
        distance = [inf] * n # 用于存放从某个点到其他点的最短路径长度
        path = [None] * n # 用于存放从初始点到其他点的路径
        final = [None] * n # 用于存放从初始点到其他点的最短路径
        for i in range(n):
            final[i] = False
            distance[i] = adjacent_matrix[start][i]
            path[i] = ""  # 路径置空
            if distance[i] < inf:
                path[i] = str(i)
        distance[start] = 0
        final[start] = True
        # 算法
        for i in range(1,n):
            min = inf
            for k in range(n):
                if not final[k] and distance[k] < min:
                    v = k
                    min = distance[k]
            final[v] = True
            for k in range(n):
                if not final[k] and min + adjacent_matrix[v][k] < distance[k]:
                    distance[k] = min + adjacent_matrix[v][k]
                    path[k] = path[v] + ',' + str(k)
        return distance, path
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Dijkstra算法是一种用于求解单源最短路径的经典算法,可以使用邻接矩阵来实现。具体步骤如下: 1. 初始化距离数组dist和标记数组visited,将源点s的距离设为0,其他点的距离设为无穷大,所有点的visited值均为false。 2. 从距离数组dist中选择一个未标记的距离最小的点u,标记该点,并对其所有邻接点v进行松弛操作:如果从源点s到u再到v的距离比从源点s直接到v的距离更短,则更新v的距离dist[v]为新的距离,并将v标记为未访问。 3. 重复步骤2,直到所有节点均被标记为已访问,或者不存在未标记节点的距离小于无穷大的点。 4. 最终距离数组dist中存储了从源点s到所有其他点的最短距离。 下面给出使用邻接矩阵实现Dijkstra算法的代码示例: ```python import sys # 用邻接矩阵表示 class Graph: def __init__(self, vertices): self.V = vertices self.graph = [[0 for column in range(vertices)] for row in range(vertices)] # 找到距离最小的未访问节点 def min_distance(self, dist, visited): min_dist = sys.maxsize min_index = -1 for v in range(self.V): if dist[v] < min_dist and not visited[v]: min_dist = dist[v] min_index = v return min_index # 打印最短路径 def print_path(self, parent, j): if parent[j] == -1: print(j, end=' ') return self.print_path(parent, parent[j]) print(j, end=' ') # Dijkstra算法 def dijkstra(self, src): dist = [sys.maxsize] * self.V parent = [-1] * self.V dist[src] = 0 visited = [False] * self.V for cout in range(self.V): u = self.min_distance(dist, visited) visited[u] = True for v in range(self.V): if self.graph[u][v] > 0 and not visited[v] and \ dist[u] + self.graph[u][v] < dist[v]: dist[v] = dist[u] + self.graph[u][v] parent[v] = u print("最短路径:") for i in range(self.V): print(src, "->", i, "距离:", dist[i], "路径:", end=' ') self.print_path(parent, i) print() # 测试 g = Graph(9) g.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]] g.dijkstra(0) ``` 上述代码中,我们使用邻接矩阵来表示,dist数组存储源点到各个节点的距离,parent数组存储最短路径上每个节点的前驱节点,visited数组表示该节点是否被访问过。在Dijkstra算法中,我们通过找到距离最小的未访问节点,以及对其邻接点进行松弛操作,来逐步求解源点到各个节点的最短距离。最后打印出最短路径和距离即可。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

StriveZs

用爱发电

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值