input: Write a function to find the most efficient path for a robot to take from its current location to a given destination using a breadth-first search algorithm. The function should return the path as a list of coordinates if a valid path is found, otherwise it should return None. If the start and end locations are the same, the function should return a path containing only the start location.
  
  assert find_path((4, 2), (9, 9)) == [
      [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], 
      [9, 3], [9, 4], [9, 5], [9, 6], [9, 7], [9, 8]
  ]
  assert find_path((4, 2), (4, 2)) == [[4, 2]]
  assert find_path((1, 1), (9, 9)) == None
  assert find_path((0, 0), (2, 2)) == [[0, 0], [1, 0], [2, 0], [2, 1], [2, 2]]
output: def find_path(start, end):
      if start == end:
          return [list(start)]
      
      queue = [(start, [list(start)])]
      visited = set()
      visited.add(start)
      
      while queue:
          (current, path) = queue.pop(0)
          x, y = current
          
          for dx, dy in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
              nx, ny = x + dx, y + dy
              next_pos = (nx, ny)
              
              if next_pos == end:
                  return path + [list(next_pos)]
              
              if next_pos not in visited:
                  visited.add(next_pos)
                  queue.append((next_pos, path + [list(next_pos)]))
      
      return None