




from statistics import mean, stdev






def  snake_case(    __magic_name__			,		__magic_name__ = 3   )			->							Optional[int]:





     '''simple docstring'''


     lowercase :       str       =			min(lowerCamelCase__   )
     lowercase :       Optional[Any]       =			max(lowerCamelCase__   )
     # normalize data
     return [round((x - x_min) / (x_max - x_min)			,		lowerCamelCase__   ) for x in data]






def  snake_case(    __magic_name__			,		__magic_name__ = 3   )			->							Tuple:





     '''simple docstring'''


     lowercase :       int       =			mean(lowerCamelCase__   )
     lowercase :       Dict       =			stdev(lowerCamelCase__   )
     # standardize data
     return [round((x - mu) / (sigma)			,		lowerCamelCase__   ) for x in data]





from __future__ import annotations

import time

lowerCAmelCase_						=			list[tuple[int, int]]

lowerCAmelCase_						=			[
    [0, 0, 0, 0, 0, 0, 0],
    [0, 1, 0, 0, 0, 0, 0],  # 0 are free path whereas 1's are obstacles
    [0, 0, 0, 0, 0, 0, 0],
    [0, 0, 1, 0, 0, 0, 0],
    [1, 0, 1, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 1, 0, 0],
]

lowerCAmelCase_						=			[[-1, 0], [0, -1], [1, 0], [0, 1]]  # up, left, down, right
class 						_A :






  def __init__(  self		:     List[Any]				,						_A		:     int				,						_A		:     int				,						_A		:     int				,						_A		:     int				,						_A		:     Node | None				)		->   str:






       """simple docstring"""







       lowercase :       Any       =			pos_x
       lowercase :       Union[str, Any]       =			pos_y
       lowercase :       int       =			(pos_y, pos_x)
       lowercase :       List[str]       =			goal_x
       lowercase :       Optional[int]       =			goal_y
       lowercase :       Union[str, Any]       =			parent


class 						_A :






  def __init__(  self		:     Optional[Any]				,						_A		:     tuple[int, int]				,						_A		:     tuple[int, int]				)		->   List[Any]:






       """simple docstring"""







       lowercase :       int       =			Node(start[1]				,						start[0]				,						goal[1]				,						goal[0]				,						_A				)
       lowercase :       int       =			Node(goal[1]				,						goal[0]				,						goal[1]				,						goal[0]				,						_A				)

       lowercase :       List[str]       =			[self.start]
       lowercase :       Optional[int]       =			False






  def  __a      (  self		:     Dict				)		->   Path | None:






       """simple docstring"""







       while self.node_queue:
            lowercase :       Optional[Any]       =			self.node_queue.pop(0				)

            if current_node.pos == self.target.pos:
                 lowercase :       int       =			True
                 return self.retrace_path(_A				)

            lowercase :       Union[str, Any]       =			self.get_successors(_A				)

            for node in successors:
                 self.node_queue.append(_A				)

       if not self.reached:
            return [self.start.pos]
       return None






  def  __a      (  self		:     str				,						_A		:     Node				)		->   list[Node]:






       """simple docstring"""







       lowercase :       Union[str, Any]       =			[]
       for action in delta:
            lowercase :       List[str]       =			parent.pos_x + action[1]
            lowercase :       str       =			parent.pos_y + action[0]
            if not (0 <= pos_x <= len(grid[0]				) - 1 and 0 <= pos_y <= len(_A				) - 1):
                 continue

            if grid[pos_y][pos_x] != 0:
                 continue

            successors.append(
                Node(_A				,						_A				,						self.target.pos_y				,						self.target.pos_x				,						_A				)				)
       return successors






  def  __a      (  self		:     Any				,						_A		:     Node | None				)		->   Path:






       """simple docstring"""







       lowercase :       Optional[int]       =			node
       lowercase :       Dict       =			[]
       while current_node is not None:
            path.append((current_node.pos_y, current_node.pos_x)				)
            lowercase :       Tuple       =			current_node.parent
       path.reverse()
       return path


class 						_A :






  def __init__(  self		:     Optional[int]				,						_A		:     List[str]				,						_A		:     List[str]				)		->   int:






       """simple docstring"""







       lowercase :       str       =			BreadthFirstSearch(_A				,						_A				)
       lowercase :       Optional[Any]       =			BreadthFirstSearch(_A				,						_A				)
       lowercase :       List[str]       =			False






  def  __a      (  self		:     Tuple				)		->   Path | None:






       """simple docstring"""







       while self.fwd_bfs.node_queue or self.bwd_bfs.node_queue:
            lowercase :       str       =			self.fwd_bfs.node_queue.pop(0				)
            lowercase :       Tuple       =			self.bwd_bfs.node_queue.pop(0				)

            if current_bwd_node.pos == current_fwd_node.pos:
                 lowercase :       Optional[Any]       =			True
                 return self.retrace_bidirectional_path(
                     _A				,						_A				)

            lowercase :       Optional[int]       =			current_bwd_node
            lowercase :       Optional[int]       =			current_fwd_node

            lowercase :       Union[str, Any]       =			{
                self.fwd_bfs: self.fwd_bfs.get_successors(_A				),
                self.bwd_bfs: self.bwd_bfs.get_successors(_A				),
            }

            for bfs in [self.fwd_bfs, self.bwd_bfs]:
                 for node in successors[bfs]:
                      bfs.node_queue.append(_A				)

       if not self.reached:
            return [self.fwd_bfs.start.pos]
       return None






  def  __a      (  self		:     List[Any]				,						_A		:     Node				,						_A		:     Node				)		->   Path:






       """simple docstring"""







       lowercase :       Optional[Any]       =			self.fwd_bfs.retrace_path(_A				)
       lowercase :       Union[str, Any]       =			self.bwd_bfs.retrace_path(_A				)
       bwd_path.pop()
       bwd_path.reverse()
       lowercase :       Optional[int]       =			fwd_path + bwd_path
       return path


if __name__ == "__main__":
 # all coordinates are given in format [y,x]
 import doctest

 doctest.testmod()
 lowerCAmelCase_						=			(0, 0)
 lowerCAmelCase_						=			(len(grid) - 1, len(grid[0]) - 1)
 for elem in grid:
  print(elem)

 lowerCAmelCase_						=			time.time()
 lowerCAmelCase_						=			BreadthFirstSearch(init, goal)
 lowerCAmelCase_						=			bfs.search()
 lowerCAmelCase_						=			time.time() - start_bfs_time

 print('Unidirectional BFS computation time : ', bfs_time)

 lowerCAmelCase_						=			time.time()
 lowerCAmelCase_						=			BidirectionalBreadthFirstSearch(init, goal)
 lowerCAmelCase_						=			bd_bfs.search()
 lowerCAmelCase_						=			time.time() - start_bd_bfs_time

 print('Bidirectional BFS computation time : ', bd_bfs_time)