input: from typing import List
  
  class Maze:
      def __init__(self, n, m):
          self._n, self._m = n, m
          self._grid = [[None] * m for _ in range(n)]
  
      def solve_maze(self) -> List[int]:
          """ This method solves the maze by finding the shortest path from the start (top-left corner) to the end (bottom-right corner).
          The grid is filled with 1s where there are possible paths and 0s where there are barriers.
          If there is a valid path, it returns a list of values representing steps starting from 0 to the end.
          If no path exists, it returns an empty list.
          
          >>> maze = Maze(3, 3)
          >>> maze._grid = [[1, 0, 1], [1, 1, 1], [0, 1, 1]]
          >>> maze.solve_maze()
          [4]
          
          >>> maze = Maze(3, 3)
          >>> maze._grid = [[1, 0, 1], [1, 0, 1], [0, 1, 1]]
          >>> maze.solve_maze()
          []
          """
          result, found = [], False
          start, end = (0, 0), (self._n-1, self._m-1)
  
          for i in range(self._n):
              for j in range(self._m):
                  if self._grid[i][j] == 1:
                      value = 0
                      self._find_omega(i, j, value, result, start, end, found)
                      return result
  
      def _find_omega(self, i, j, value, result, start, end, found):
          rowNbr, colNbr = [-1, 0, 0, 1], [0, -1, 1, 0]
  
          if (i, j) == end:
              found = True
              result.append(value)
              return
  
          if found == True:
              return
  
          self._grid[i][j] = 0
          for k in range(4):
              if self._on_board(i + rowNbr[k], j + colNbr[k]):
                  self._find_omega(i + rowNbr[k], j + colNbr[k], value + 1, result, start, end, found)
  
      def _on_board(self, i, j):
          return 0 <= i < self._n and 0 <= j < self._m and self._grid[i][j] == 1
output:     result, found = [], False
      start, end = (0, 0), (self._n-1, self._m-1)
  
      if self._grid[start[0]][start[1]] == 0 or self._grid[end[0]][end[1]] == 0:
          return []
  
      queue = [(start[0], start[1], 0)]
      visited = set()
      visited.add(start)
  
      while queue:
          x, y, dist = queue.pop(0)
  
          if (x, y) == end:
              return [dist]
  
          for k in range(4):
              new_x, new_y = x + rowNbr[k], y + colNbr[k]
              if self._on_board(new_x, new_y) and (new_x, new_y) not in visited:
                  visited.add((new_x, new_y))
                  queue.append((new_x, new_y, dist + 1))
  
      return []