在有向图中使用字典和邻接列表查找最短路径

Question

I am trying to create a function that accepts a start and stop number then returns a list of nodes/numbers which represent the shorest path to get from Start to Stop in the graph. Right now my grpah is stored in a object Graph that has an object varaible Verticies which is the following dictionary where the key is the node and the values are its connected nodes

{1: [10, 12, 11],
 9: [1, 11, 12, 4],
 7: [12],
 10: [5, 4, 1, 11],
 12: [],
 4: [9, 11],
 11: [7, 9],
 5: [12]}

I am trying to get the shorest path from 1 to 7 and would expect the funciton to return a list of [11,7] ie the path to get from 1 to 7 and the amount of steps it would take ie 2.

I am using recursion to do a depth first search and updating a dictionary with the nodes and amount of steps it takes to get to the node from the start node.

I can get the function to print the shorest path if I use print but I am unsure on how to get a recursive function to return the shorests path as the function returns the shorest path when It finds the end node or finds a better route however it only returns to another inner recursive function which then modfifies path to remove the last node added.

I am not sure how I can return path, while also updating path each time I come out of a funciton to remove the node that I searched through? Would it be recomneded to store the path list into another list then try to return that list that way when the new list gets returned it is not changed by path being changed?

My funciton is below

def shortest_path(from_node,to_node,graph,visited={},Cost=0,path=[]):
    connections=graph.Verticies[from_node]
    if to_node in connections:
        if to_node in list(visited.keys()):
            if Cost+1<visited[to_node]:
                visited[to_node]=Cost+1
                try:
                    path.remove(to_node)
                except:
                    pass
                path.append(to_node)
                return((path,Cost+1))
            else:
                pass
        else:
            visited[to_node]=Cost+1
            path.append(to_node)
            return((path,Cost+1))
    else:
        for val in connections:
            if val in list(visited.keys()):
                if Cost+1<visited[val]:
                    visited[val]=Cost+1
                    Cost+=1
                    path.append(val)
                    optimal_path=shortest_path(val,to_node,graph,visited,Cost)
                    path.remove(val)
                    Cost-=1
                else:
                    continue
            else:
                visited[val]=Cost+1
                Cost+=1
                path.append(val)
                optimal_path=shortest_path(val,to_node,graph,visited,Cost)
                path.remove(val)
                Cost-=1
    return(path)
                
    

Answer 1

First, remember that the shortest distance between any two points is a straight line , or the hypotenuse . So the first thing you'll want to do in your function is check if it can go directly to the next input. Something like this:

if to_node in Graph[from_node]: #from_node is the variable and the key name
  return ([from_node, to_node])

if this doesn't work for the inputted values, which it will not the majority of the time, recursion will be necessary to find the shortest path.

else:
  epic_list_object = [from_node]
  for i in Graph[from_node]:
    if to_node in Graph[i]:
      epic_list_object.append(i)
      epic_list_object.append(to_node)
      return epic_list_object
      break
    else:
      pass
# add recursion using for or while statements to the above function to support inputs that are farther than 2 apart :)

finally, if you want just the length, just use len(epic_list_object)-1