如何在最短路径BFS中跟踪级别？

Question

I'm coding a problem where I'm asked to find the least amount of steps between 2 points on an 8 by 8 chess board only using knight movement (L shaped movement).

I am pretty sure my code is fine i just don't know where in the code I should track the number of steps.

Here is the code.

start = tuple(map(int, raw_input().split()))
goal = tuple(map(int, raw_input().split()))
steps = 0
visited, queue = set(), [start]
while queue:
vertex = queue.pop(0)
    if vertex not in visited:
        visited.add(vertex)
        if vertex == goal:
            print steps
            break
        else:
            if vertex[0] >= 3 and vertex[1] >= 2:
                queue.append(tuple([(vertex[0] -2), (vertex[1]-1)]))

            if vertex[0] >= 2 and vertex[1] >= 3:
                queue.append(tuple([(vertex[0] -1), (vertex[1]-2)]))

            if vertex[0] >= 3 and vertex[1] <=7:
                queue.append(tuple([(vertex[0] -2), (vertex[1]+1)]))

            if vertex[0] >=2 and vertex[1] <= 6:
                queue.append(tuple([(vertex[0] -1), (vertex[1]+2)]))

            if vertex[0] <= 6 and vertex[1] >= 2:
                queue.append(tuple([(vertex[0] +2), (vertex[1]-1)]))

            if vertex[0] <= 7 and vertex[1] >=3:
                queue.append(tuple([(vertex[0] +1), (vertex[1]-2)]))

            if vertex[0] <= 7 and vertex[1] <= 6:
                queue.append(tuple([(vertex[0] +1), (vertex[1]+2)]))

            if vertex[0] <= 6 and vertex[1] <= 7:
                queue.append(tuple([(vertex[0] +2), (vertex[1]+1)]))
            queue.append(0)

Answer 1

One possibility in BFS is to keep track of how you got to each vertex - so basically whenever we move to a new vertex we keep track of the "prior" vertex that led to the current one. When we've reached our goal vertex, we simply retrace our steps back using the list of "prior" vertices, and that gives us both the number of steps as well as the sequence.

Edit: looked closer at your code, and mbomb007 is right. Your code only calculates the next possible moves and adds them to the PQ. In order to calculate the number of moves, you need to find a way to track your knight's movements.

Answer 2

I'm pretty sure you need to keep track of the step-count along with the vertex in your queue. In other words, rather than queuing up just the vertex, include the number of steps taken to reach that vertex:

queue = [(start, 0)] #[ ((x, y), steps-so-far) ]

Then, in the main loop:

(vertex, steps) = queue.pop(0)
#...
    if vertex[0] >= 3 and vertex[1] >= 2:
        newVertex = (vertex[0] -2, vertex[1]-1) # No need to explicitly call tuple()
        queue.append( (newVertex, steps+1) )
    # And so on...

EDIT: The stuff below about reproducing the sequence of steps...it isn't quite so simple. The visited map could have a vertex in there multiple times, so there needs to be a way to know which is the right one. This could get messy. A better solution would probably be to keep track of the entire preceding sequence rather than just the previous vertex.

AdmiralWen has the right idea if you want the actual sequence of steps. Instead of keeping the step count you keep the previous vertex. Store the pair (vertex, prev-vertex) in your visited set so that you can retrace the sequence when you are done. Note that rather than a set, visited should be a map in this case, where the key is a vertex and the value is the previous vertex.