




from __future__ import annotations

UpperCamelCase								=					[
    [-1, 0],  # left
    [0, -1],  # down
    [1, 0],  # right
    [0, 1],  # up
]



def 							_A       (						lowerCAmelCase_					: list[list[int]]       ,    lowerCAmelCase_					: list[int]       ,    lowerCAmelCase_					: list[int]       ,    lowerCAmelCase_					: int       ,    lowerCAmelCase_					: list[list[int]]       ,    ):
     """simple docstring"""

     lowerCAmelCase__          =			[
         [0 for col in range(len(grid[0]      )      )] for row in range(len(lowerCAmelCase_      )      )
     ]  # the reference grid
     lowerCAmelCase__          =			1
     lowerCAmelCase__          =			[
         [0 for col in range(len(grid[0]      )      )] for row in range(len(lowerCAmelCase_      )      )
     ]  # the action grid

     lowerCAmelCase__          =			init[0]
     lowerCAmelCase__          =			init[1]
     lowerCAmelCase__          =			0
     lowerCAmelCase__          =			g + heuristic[x][y]  # cost from starting cell to destination cell
     lowerCAmelCase__          =			[[f, g, x, y]]

     lowerCAmelCase__          =			False  # flag that is set when search is complete
     lowerCAmelCase__          =			False  # flag set if we can't find expand

     while not found and not resign:
          if len(lowerCAmelCase_      ) == 0:
               raise ValueError("Algorithm is unable to find solution"      )
          else:  # to choose the least costliest action so as to move closer to the goal
               cell.sort()
               cell.reverse()
               lowerCAmelCase__          =			cell.pop()
               lowerCAmelCase__          =			next_cell[2]
               lowerCAmelCase__          =			next_cell[3]
               lowerCAmelCase__          =			next_cell[1]

               if x == goal[0] and y == goal[1]:
                    lowerCAmelCase__          =			True
               else:
                    for i in range(len(lowerCAmelCase_      )      ):  # to try out different valid actions
                         lowerCAmelCase__          =			x + DIRECTIONS[i][0]
                         lowerCAmelCase__          =			y + DIRECTIONS[i][1]
                         if xa >= 0 and xa < len(lowerCAmelCase_      ) and ya >= 0 and ya < len(grid[0]      ):
                              if closed[xa][ya] == 0 and grid[xa][ya] == 0:
                                   lowerCAmelCase__          =			g + cost
                                   lowerCAmelCase__          =			ga + heuristic[xa][ya]
                                   cell.append([fa, ga, xa, ya]      )
                                   lowerCAmelCase__          =			1
                                   lowerCAmelCase__          =			i
     lowerCAmelCase__          =			[]
     lowerCAmelCase__          =			goal[0]
     lowerCAmelCase__          =			goal[1]
     invpath.append([x, y]      )  # we get the reverse path from here
     while x != init[0] or y != init[1]:
          lowerCAmelCase__          =			x - DIRECTIONS[action[x][y]][0]
          lowerCAmelCase__          =			y - DIRECTIONS[action[x][y]][1]
          lowerCAmelCase__          =			xa
          lowerCAmelCase__          =			ya
          invpath.append([x, y]      )

     lowerCAmelCase__          =			[]
     for i in range(len(lowerCAmelCase_      )      ):
          path.append(invpath[len(lowerCAmelCase_      ) - 1 - i]      )
     return path, action


if __name__ == "__main__":
     UpperCamelCase								=					[
         [0, 1, 0, 0, 0, 0],
         [0, 1, 0, 0, 0, 0],  # 0 are free path whereas 1's are obstacles
         [0, 1, 0, 0, 0, 0],
         [0, 1, 0, 0, 1, 0],
         [0, 0, 0, 0, 1, 0],
     ]

     UpperCamelCase								=					[0, 0]
     # all coordinates are given in format [y,x]
     UpperCamelCase								=					[len(grid) - 1, len(grid[0]) - 1]
     UpperCamelCase								=					1

     # the cost map which pushes the path closer to the goal
     UpperCamelCase								=					[[0 for row in range(len(grid[0]))] for col in range(len(grid))]
     for i in range(len(grid)):
          for j in range(len(grid[0])):
               UpperCamelCase								=					abs(i - goal[0]) + abs(j - goal[1])
               if grid[i][j] == 1:
                    # added extra penalty in the heuristic map
                    UpperCamelCase								=					99

     UpperCamelCase						,  UpperCamelCase								=					search(grid, init, goal, cost, heuristic)

     print('ACTION MAP')
     for i in range(len(action)):
          print(action[i])

     for i in range(len(path)):
          print(path[i])






from __future__ import annotations

UpperCamelCase								=					[
    [-1, 0],  # left
    [0, -1],  # down
    [1, 0],  # right
    [0, 1],  # up
]



def 							_A       (						lowerCAmelCase_					: list[list[int]]       ,    lowerCAmelCase_					: list[int]       ,    lowerCAmelCase_					: list[int]       ,    lowerCAmelCase_					: int       ,    lowerCAmelCase_					: list[list[int]]       ,    ):
     """simple docstring"""

     lowerCAmelCase__          =			[
         [0 for col in range(len(grid[0]      )      )] for row in range(len(lowerCAmelCase_      )      )
     ]  # the reference grid
     lowerCAmelCase__          =			1
     lowerCAmelCase__          =			[
         [0 for col in range(len(grid[0]      )      )] for row in range(len(lowerCAmelCase_      )      )
     ]  # the action grid

     lowerCAmelCase__          =			init[0]
     lowerCAmelCase__          =			init[1]
     lowerCAmelCase__          =			0
     lowerCAmelCase__          =			g + heuristic[x][y]  # cost from starting cell to destination cell
     lowerCAmelCase__          =			[[f, g, x, y]]

     lowerCAmelCase__          =			False  # flag that is set when search is complete
     lowerCAmelCase__          =			False  # flag set if we can't find expand

     while not found and not resign:
          if len(lowerCAmelCase_      ) == 0:
               raise ValueError("Algorithm is unable to find solution"      )
          else:  # to choose the least costliest action so as to move closer to the goal
               cell.sort()
               cell.reverse()
               lowerCAmelCase__          =			cell.pop()
               lowerCAmelCase__          =			next_cell[2]
               lowerCAmelCase__          =			next_cell[3]
               lowerCAmelCase__          =			next_cell[1]

               if x == goal[0] and y == goal[1]:
                    lowerCAmelCase__          =			True
               else:
                    for i in range(len(lowerCAmelCase_      )      ):  # to try out different valid actions
                         lowerCAmelCase__          =			x + DIRECTIONS[i][0]
                         lowerCAmelCase__          =			y + DIRECTIONS[i][1]
                         if xa >= 0 and xa < len(lowerCAmelCase_      ) and ya >= 0 and ya < len(grid[0]      ):
                              if closed[xa][ya] == 0 and grid[xa][ya] == 0:
                                   lowerCAmelCase__          =			g + cost
                                   lowerCAmelCase__          =			ga + heuristic[xa][ya]
                                   cell.append([fa, ga, xa, ya]      )
                                   lowerCAmelCase__          =			1
                                   lowerCAmelCase__          =			i
     lowerCAmelCase__          =			[]
     lowerCAmelCase__          =			goal[0]
     lowerCAmelCase__          =			goal[1]
     invpath.append([x, y]      )  # we get the reverse path from here
     while x != init[0] or y != init[1]:
          lowerCAmelCase__          =			x - DIRECTIONS[action[x][y]][0]
          lowerCAmelCase__          =			y - DIRECTIONS[action[x][y]][1]
          lowerCAmelCase__          =			xa
          lowerCAmelCase__          =			ya
          invpath.append([x, y]      )

     lowerCAmelCase__          =			[]
     for i in range(len(lowerCAmelCase_      )      ):
          path.append(invpath[len(lowerCAmelCase_      ) - 1 - i]      )
     return path, action


if __name__ == "__main__":
     UpperCamelCase								=					[
         [0, 1, 0, 0, 0, 0],
         [0, 1, 0, 0, 0, 0],  # 0 are free path whereas 1's are obstacles
         [0, 1, 0, 0, 0, 0],
         [0, 1, 0, 0, 1, 0],
         [0, 0, 0, 0, 1, 0],
     ]

     UpperCamelCase								=					[0, 0]
     # all coordinates are given in format [y,x]
     UpperCamelCase								=					[len(grid) - 1, len(grid[0]) - 1]
     UpperCamelCase								=					1

     # the cost map which pushes the path closer to the goal
     UpperCamelCase								=					[[0 for row in range(len(grid[0]))] for col in range(len(grid))]
     for i in range(len(grid)):
          for j in range(len(grid[0])):
               UpperCamelCase								=					abs(i - goal[0]) + abs(j - goal[1])
               if grid[i][j] == 1:
                    # added extra penalty in the heuristic map
                    UpperCamelCase								=					99

     UpperCamelCase						,  UpperCamelCase								=					search(grid, init, goal, cost, heuristic)

     print('ACTION MAP')
     for i in range(len(action)):
          print(action[i])

     for i in range(len(path)):
          print(path[i])
