Python中Dijkstra算法在真实地图上的最短路径

Question

I'm trying to find the shortest path between two spots on the real map by Dijkstra's algorithm, but I cannot get a result in a limited time(120s). How do I optimize my code? I'm only permitted to use "pillow" as an external package.

There are two red spots(33, 193)(749, 457) on the map , and I want to draw the shortest path of them. But it cannot put a result even if taking a long time. I test my Dijkstra's algorithm well, and don't know if it still has many bugs. The Dijkstra's algorithm is created with same distance -- 1.

Here is the complete code.

def walkback(P, x, y):
    L = [y]
    while x != y:
        y = P[y]
        L = [y] + L
    return L

def path(A, x, y):
    M = []
    W = [x]
    P = {}
    while W != []:
       u = W.pop()
       if u == y:
            return walkback(P, x, y)
       M.append(u)
       for v in A[u]:
           if not v in M:
               P[v] = u
               W.append(v)
    return None

This is the Dijkstra's algorithm. And I tested it for this.

A = { 1.324: [2,5.24], 2: [1.324,6], 3: [2],
      4: [5],   5.24: [2,6], 6: [3] }
print(path(A, 1.324, 6))
print(path(A, 1.324, 4))

For any pixel, the white and the red(start, end) are movable points, and set to 0. Other colors are set to 1.

for x in range(0, w):
    for y in range(0, h):
        (r, g, b, a) = im.getpixel((x, y))
        if (r, g, b) == (255, 0, 0):
            Red.append((x, y))
            arr[y][x] = 0
        elif (r, g, b) == (255, 255, 255):
            arr[y][x] = 0
        else:
            arr[y][x] = 1

And this created a graph for any movable spot. For ['0.1': ['0.2', '0.3']], it means you can move to (0, 2) and (0, 3) from (0, 1).

def coord2num(x, y):
    z = str(x) + "." + str(y)
    return z

B = {}
for x in range(0, h):
    for y in range(0, w):
        if arr[x][y] != 0:
            continue
        key = coord2num(x, y)
        B[key] = []
        if x - 1 >= 0 and arr[x - 1][y] == 0:
            value = coord2num(x - 1, y)
            B[key].append(value)
        if x + 1 < h and arr[x + 1][y] == 0:
            value = coord2num(x + 1, y)
            B[key].append(value)
        if y + 1 < w and arr[x][y + 1] == 0:
            value = coord2num(x, y + 1)
            B[key].append(value)
        if y - 1 >= 0 and arr[x][y - 1] == 0:
            value = coord2num(x, y - 1)
            B[key].append(value)

I expect the output of the shortest path, but it still run out of time.

Answer 1

Is it compulsory that you use Dijkstra? It looks like using an A* approach would be better here, since you can easily design a good heuristic (manhattan distance for instance).

This would probably solve your time restrictions problem. Also, on a real map you should clarify how your graph is defined (do you only account for intersection? And if not, how do you cut space?).