In an n*n
grid, there is a snake that spans 2 cells and starts moving from the top left corner at (0, 0)
and (0, 1)
. The grid has empty cells represented by zeros and blocked cells represented by ones. The snake wants to reach the lower right corner at (n-1, n-2)
and (n-1, n-1)
.
In one move the snake can:
- Move one cell to the right if there are no blocked cells there. This move keeps the horizontal/vertical position of the snake as it is.
- Move down one cell if there are no blocked cells there. This move keeps the horizontal/vertical position of the snake as it is.
- Rotate clockwise if it's in a horizontal position and the two cells under it are both empty. In that case the snake moves from
(r, c)
and(r, c+1)
to(r, c)
and(r+1, c)
. - Rotate counterclockwise if it's in a vertical position and the two cells to its right are both empty. In that case the snake moves from
(r, c)
and(r+1, c)
to(r, c)
and(r, c+1)
.
Return the minimum number of moves to reach the target.
If there is no way to reach the target, return -1
.
Example 1:
Input: grid = [[0,0,0,0,0,1], [1,1,0,0,1,0], [0,0,0,0,1,1], [0,0,1,0,1,0], [0,1,1,0,0,0], [0,1,1,0,0,0]] Output: 11 Explanation: One possible solution is [right, right, rotate clockwise, right, down, down, down, down, rotate counterclockwise, right, down].
Example 2:
Input: grid = [[0,0,1,1,1,1], [0,0,0,0,1,1], [1,1,0,0,0,1], [1,1,1,0,0,1], [1,1,1,0,0,1], [1,1,1,0,0,0]] Output: 9
Constraints:
2 <= n <= 100
0 <= grid[i][j] <= 1
- It is guaranteed that the snake starts at empty cells.
思路:DP不太好弄,直接BFS
class Solution(object):
def minimumMoves(self, grid):
"""
:type grid: List[List[int]]
:rtype: int
"""
n=len(grid)
q,qq=[(0,0,0)],[]
vis=set([(0,0,0)])
step=0
while q:
while q:
i,j,s=q.pop()
if i==n-1 and j==n-2 and s==0: return step
if s==0:
if i+1<n and grid[i+1][j]==0 and grid[i+1][j+1]==0 and (i,j,1) not in vis:
qq.append((i,j,1))
vis.add((i,j,1))
if j+2<n and grid[i][j+2]==0 and (i,j+1,s) not in vis:
qq.append((i,j+1,s))
vis.add((i,j+1,s))
if i+1<n and grid[i+1][j]==0 and grid[i+1][j+1]==0 and (i+1,j,s) not in vis:
qq.append((i+1,j,s))
vis.add((i+1,j,s))
else:
if j+1<n and grid[i][j+1]==0 and grid[i+1][j+1]==0 and (i,j,0) not in vis:
qq.append((i,j,0))
vis.add((i,j,0))
if j+1<n and grid[i][j+1]==0 and grid[i+1][j+1]==0 and (i,j+1,s) not in vis:
qq.append((i,j+1,s))
vis.add((i,j+1,s))
if i+2<n and grid[i+2][j]==0 and (i+1,j,s) not in vis:
qq.append((i+1,j,s))
vis.add((i+1,j,s))
q,qq=qq,q
step+=1
return -1
s=Solution()
print(s.minimumMoves([[0,0,0,0,0,1],
[1,1,0,0,1,0],
[0,0,0,0,1,1],
[0,0,1,0,1,0],
[0,1,1,0,0,0],
[0,1,1,0,0,0]]))