Dijkstra算法python最佳路径

Question

i'm a begginer progammer and i really dont understand how to do a dijkstra algortihm.

I need a function that receive in arguments like

def(connection, startPoint, endPoint):

and return the best path

Example:

('a', 'b') is a connection
('a', 'c')  is a connection
('b', 'c')  is a connection

and return for example ('a', 'c') as the best path from 'a' to'c' (can be too 'a' 'b' 'c')

I tried several codes but never came up with a possible solution. Someone help?

Answer 1

There are a few things to consider when coming up with a solution. The first is how Dijkstra's algorithm itself works, and what data structures you're going to use in your solution. I would recommend reading up on it on Wikipedia before approaching the problem. To start, we can first go through the instructions of the algorithm itself.

Anyways, to be able to give a shortest path like the function signature in your post is effectively impossible, since the data of the graph itself needs to be given too. To start, we can code up dijkstra's algorithm like so:

import heapq
from collections import deque
from math import inf
    

def dijkstra(graph, source):

    prev, unvisited = {}, []

    for vertex in graph:
        heapq.heappush(unvisited, (0 if vertex == source else inf, vertex))

    dist = dict(map(reversed, unvisited))

    while unvisited:
        _, nearest = heapq.heappop(unvisited)

        for neighbour, cost in graph[nearest].items():
            alt = dist[nearest] + cost
            if alt < dist[neighbour]:
                dist[neighbour] = alt
                prev[neighbour] = nearest

    return prev, dist

Now, given this algorithm, we know the order of visited nodes. Whatever is returned from here can be used to reconstruct the path from our source to our target, so we can create a function like the signature you've provided, but with a graph and target also added as a parameter. That will look something like this:

def reconstruct_path(graph, dist, prev, source, target):

    path = deque()
    predecessor = target

    while predecessor is not None:
        path.appendleft(predecessor)
        predecessor = prev.get(predecessor)

    return path, cost

A graph in this case can simply be represented by a dictionary of strings (as nodes or vertices) mapped to another dictionary of strings (as nodes) to integers or floats (which in this case represent the cost of an edge).

An example graph would be something like:

test_graph = {
    "s": {"a": 1, "b": 5},
    "a": {"b": 2, "c": 2, "d": 1},
    "b": {"d": 2},
    "c": {"d": 3, "e": 1},
    "d": {"e": 2},
    "e": {},
}

So when we try to get the shortest path from a target vertex (in this example, we'll use "s"), with the following:

source = "s"
target = "b"

distances, predecessors = dijkstra(graph=test_graph, source=source, target=target)

print(reconstruct_path(graph=test_graph, dist=distances, prev=predecessors, target=target)

We get the following output:

path: ["s", "a", "b"]
cost: 3